LIEF: Library to Instrument Executable Formats Version 0.17.0
Loading...
Searching...
No Matches
ELF/Binary.hpp
Go to the documentation of this file.
1/* Copyright 2017 - 2025 R. Thomas
2 * Copyright 2017 - 2025 Quarkslab
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16#ifndef LIEF_ELF_BINARY_H
17#define LIEF_ELF_BINARY_H
18
19#include <vector>
20#include <memory>
21
22#include "LIEF/visibility.h"
23#include "LIEF/errors.hpp"
24#include "LIEF/iterators.hpp"
25
27
28#include "LIEF/ELF/Note.hpp"
30#include "LIEF/ELF/Header.hpp"
31#include "LIEF/ELF/Section.hpp"
32#include "LIEF/ELF/Segment.hpp"
33#include "LIEF/ELF/Builder.hpp"
34
35namespace LIEF {
37namespace ELF {
38namespace DataHandler {
39class Handler;
40}
41
42class ExeLayout;
43class GnuHash;
44class Layout;
45class ObjectFileLayout;
46class Parser;
47class Relocation;
48class Section;
49class Segment;
50class Symbol;
51class SymbolVersion;
55class SysvHash;
56struct sizing_info_t;
57
60 friend class Parser;
61 friend class Builder;
62 friend class ExeLayout;
63 friend class Layout;
64 friend class ObjectFileLayout;
65
66 public:
67 using string_list_t = std::vector<std::string>;
68
70 using notes_t = std::vector<std::unique_ptr<Note>>;
71
74
77
79 using symbols_version_requirement_t = std::vector<std::unique_ptr<SymbolVersionRequirement>>;
80
83
86
88 using symbols_version_definition_t = std::vector<std::unique_ptr<SymbolVersionDefinition>>;
89
92
95
97 using segments_t = std::vector<std::unique_ptr<Segment>>;
98
101
104
106 using dynamic_entries_t = std::vector<std::unique_ptr<DynamicEntry>>;
107
110
113
115 using symbols_version_t = std::vector<std::unique_ptr<SymbolVersion>>;
116
119
122
124 using relocations_t = std::vector<std::unique_ptr<Relocation>>;
125
128
131
134
137
140
143
146
149
151 using symbols_t = std::vector<std::unique_ptr<Symbol>>;
152
155
158
161
164
167
170
173
176
179
182
184 using sections_t = std::vector<std::unique_ptr<Section>>;
185
188
191
192 public:
225
228 enum class SEC_INSERT_POS {
230 AUTO = 0,
231
238
243 };
244
245 public:
246 Binary& operator=(const Binary& ) = delete;
247 Binary(const Binary& copy) = delete;
248
251 return type_;
252 }
253
256 return header_;
257 }
258
259 const Header& header() const {
260 return header_;
261 }
262
265 uint64_t last_offset_section() const;
266
269 uint64_t last_offset_segment() const;
270
272 uint64_t next_virtual_address() const;
273
276 return sections_;
277 }
278
280 return sections_;
281 }
282
284 uint64_t entrypoint() const override {
285 return header_.entrypoint();
286 }
287
290 return segments_;
291 }
292
294 return segments_;
295 }
296
299 return dynamic_entries_;
300 }
301
303 return dynamic_entries_;
304 }
305
308
310 Note& add(const Note& note);
311
313 void remove(const DynamicEntry& entry);
314
317
323 void remove(const Section& section, bool clear = false);
324
326 void remove(const Note& note);
327
330
333 void remove(const Segment& seg, bool clear = false);
334
339 void remove(Segment::TYPE type, bool clear = false);
340
344 return dynamic_symbols_;
345 }
346
348 return dynamic_symbols_;
349 }
350
354
358
361 return symtab_symbols_;
362 }
363
365 return symtab_symbols_;
366 }
367
370 return symbol_version_table_;
371 }
373 return symbol_version_table_;
374 }
375
378 return symbol_version_definition_;
379 }
380
382 return symbol_version_definition_;
383 }
384
387 return symbol_version_requirements_;
388 }
389
391 return symbol_version_requirements_;
392 }
393
397
404
410
418 Relocation* add_object_relocation(const Relocation& relocation, const Section& section);
419
423
427
430 return relocations_;
431 }
432
434 return relocations_;
435 }
436
439 const Relocation* get_relocation(uint64_t address) const;
440 Relocation* get_relocation(uint64_t address) {
441 return const_cast<Relocation*>(static_cast<const Binary*>(this)->get_relocation(address));
442 }
443
446 const Relocation* get_relocation(const Symbol& symbol) const;
448 return const_cast<Relocation*>(static_cast<const Binary*>(this)->get_relocation(symbol));
449 }
450
453 const Relocation* get_relocation(const std::string& symbol_name) const;
454 Relocation* get_relocation(const std::string& symbol_name) {
455 return const_cast<Relocation*>(static_cast<const Binary*>(this)->get_relocation(symbol_name));
456 }
457
461 bool use_gnu_hash() const {
462 return gnu_hash_ != nullptr && has(DynamicEntry::TAG::GNU_HASH);
463 }
464
467 const GnuHash* gnu_hash() const {
468 return use_gnu_hash() ? gnu_hash_.get() : nullptr;
469 }
470
474 bool use_sysv_hash() const {
475 return sysv_hash_ != nullptr && has(DynamicEntry::TAG::HASH);
476 }
477
480 const SysvHash* sysv_hash() const {
481 return use_sysv_hash() ? sysv_hash_.get() : nullptr;
482 }
483
485 bool has_section(const std::string& name) const {
486 return get_section(name) != nullptr;
487 }
488
490 bool has_section_with_offset(uint64_t offset) const;
491
493 bool has_section_with_va(uint64_t va) const;
494
497 Section* get_section(const std::string& name) {
498 return const_cast<Section*>(static_cast<const Binary*>(this)->get_section(name));
499 }
500 const Section* get_section(const std::string& name) const;
501
505 return get_section(".text");
506 }
507
511
515
519
524 uint64_t imagebase() const override;
525
527 uint64_t virtual_size() const;
528
531 bool has_interpreter() const;
532
537 const std::string& interpreter() const {
538 return interpreter_;
539 }
540
542 void interpreter(const std::string& interpreter) {
543 interpreter_ = interpreter;
544 }
545
548 return symtab_dyn_symbols();
549 }
550
552 return symtab_dyn_symbols();
553 }
554
556 Symbol& export_symbol(const Symbol& symbol);
557
559 Symbol& export_symbol(const std::string& symbol_name, uint64_t value = 0);
560
562 bool has_dynamic_symbol(const std::string& name) const {
563 return get_dynamic_symbol(name) != nullptr;
564 }
565
568 const Symbol* get_dynamic_symbol(const std::string& name) const;
569
570 Symbol* get_dynamic_symbol(const std::string& name) {
571 return const_cast<Symbol*>(static_cast<const Binary*>(this)->get_dynamic_symbol(name));
572 }
573
575 bool has_symtab_symbol(const std::string& name) const {
576 return get_symtab_symbol(name) != nullptr;
577 }
578
581 const Symbol* get_symtab_symbol(const std::string& name) const;
582
583 Symbol* get_symtab_symbol(const std::string& name) {
584 return const_cast<Symbol*>(static_cast<const Binary*>(this)->get_symtab_symbol(name));
585 }
586
590 string_list_t strings(size_t min_size = 5) const;
591
597 void remove_symbol(const std::string& name);
598
600 void remove_symtab_symbol(const std::string& name);
602
604 void remove_dynamic_symbol(const std::string& name);
605
612
614 result<uint64_t> get_function_address(const std::string& func_name) const override;
615
617 //
620 result<uint64_t> get_function_address(const std::string& func_name, bool demangled) const;
621
632 Section* add(const Section& section, bool loaded = true,
634
635 Section* extend(const Section& section, uint64_t size);
636
639
641 Symbol& add_dynamic_symbol(const Symbol& symbol, const SymbolVersion* version = nullptr);
642
644 Symbol& add_exported_function(uint64_t address, const std::string& name = "");
645
647 DynamicEntryLibrary& add_library(const std::string& library_name);
648
650 void remove_library(const std::string& library_name);
651
654 DynamicEntryLibrary* get_library(const std::string& library_name) {
655 return const_cast<DynamicEntryLibrary*>(static_cast<const Binary*>(this)->get_library(library_name));
656 }
657
660 const DynamicEntryLibrary* get_library(const std::string& library_name) const;
661
663 bool has_library(const std::string& name) const {
664 return get_library(name) != nullptr;
665 }
666
674 Segment* add(const Segment& segment, uint64_t base = 0);
675
679 Segment* replace(const Segment& new_segment, const Segment& original_segment, uint64_t base = 0);
680
681 Segment* extend(const Segment& segment, uint64_t size);
682
683
689 void patch_address(uint64_t address, const std::vector<uint8_t>& patch_value,
691
692
699 void patch_address(uint64_t address, uint64_t patch_value,
700 size_t size = sizeof(uint64_t),
702
707 void patch_pltgot(const Symbol& symbol, uint64_t address);
708
709
714 void patch_pltgot(const std::string& symbol_name, uint64_t address);
715
717 void strip();
718
723 void remove_section(const std::string& name, bool clear = false) override;
724
731 void write(const std::string& filename) {
732 return write(filename, Builder::config_t{});
733 }
734
742 void write(const std::string& filename, Builder::config_t config);
743
750 void write(std::ostream& os) {
751 return write(os, Builder::config_t{});
752 }
753
758 void write(std::ostream& os, Builder::config_t config);
759
761 std::vector<uint8_t> raw();
762
764 result<uint64_t> virtual_address_to_offset(uint64_t virtual_address) const;
765
770 result<uint64_t> offset_to_virtual_address(uint64_t offset, uint64_t slide = 0) const override;
771
776 bool is_pie() const override;
777
779 bool has_nx() const override;
780
783 int64_t dynsym_idx(const std::string& name) const;
784
785 int64_t dynsym_idx(const Symbol& sym) const;
786
788 int64_t symtab_idx(const std::string& name) const;
789
790 int64_t symtab_idx(const Symbol& sym) const;
791
797 const Section* section_from_offset(uint64_t offset, bool skip_nobits = true) const;
798 Section* section_from_offset(uint64_t offset, bool skip_nobits = true) {
799 return const_cast<Section*>(static_cast<const Binary*>(this)->section_from_offset(offset, skip_nobits));
800 }
801
807 const Section* section_from_virtual_address(uint64_t address, bool skip_nobits = true) const;
808 Section* section_from_virtual_address(uint64_t address, bool skip_nobits = true) {
809 return const_cast<Section*>(static_cast<const Binary*>(this)->section_from_virtual_address(address, skip_nobits));
810 }
811
814 const Segment* segment_from_virtual_address(uint64_t address) const;
816 return const_cast<Segment*>(static_cast<const Binary*>(this)->segment_from_virtual_address(address));
817 }
818
819
822 return const_cast<Segment*>(static_cast<const Binary*>(this)->segment_from_virtual_address(type, address));
823 }
824
827 const Segment* segment_from_offset(uint64_t offset) const;
828 Segment* segment_from_offset(uint64_t offset) {
829 return const_cast<Segment*>(static_cast<const Binary*>(this)->segment_from_offset(offset));
830 }
831
836 return const_cast<DynamicEntry*>(static_cast<const Binary*>(this)->get(tag));
837 }
838
843 return const_cast<Segment*>(static_cast<const Binary*>(this)->get(type));
844 }
845
848 const Note* get(Note::TYPE type) const;
850 return const_cast<Note*>(static_cast<const Binary*>(this)->get(type));
851 }
852
857 return const_cast<Section*>(static_cast<const Binary*>(this)->get(type));
858 }
859
861 bool has(DynamicEntry::TAG tag) const {
862 return get(tag) != nullptr;
863 }
864
866 bool has(Segment::TYPE type) const {
867 return get(type) != nullptr;
868 }
869
871 bool has(Note::TYPE type) const {
872 return get(type) != nullptr;
873 }
874
876 bool has(Section::TYPE type) const {
877 return get(type) != nullptr;
878 }
879
881 span<const uint8_t> get_content_from_virtual_address(uint64_t virtual_address, uint64_t size,
882 Binary::VA_TYPES addr_type = Binary::VA_TYPES::AUTO) const override;
883
885 void accept(LIEF::Visitor& visitor) const override;
886
888 void permute_dynamic_symbols(const std::vector<size_t>& permutation);
889
892
895
898
900 bool has_notes() const;
901
906 return notes_;
907 }
908
910 return notes_;
911 }
912
915 uint64_t eof_offset() const;
916
918 bool has_overlay() const {
919 return !overlay_.empty();
920 }
921
924 return overlay_;
925 }
926
928 void overlay(std::vector<uint8_t> overlay) {
929 overlay_ = std::move(overlay);
930 }
931
941
944 std::vector<uint64_t> get_relocated_dynamic_array(DynamicEntry::TAG tag) const;
945
948
950 result<size_t> get_section_idx(const Section& section) const {
951 auto it = std::find_if(sections_.begin(), sections_.end(),
952 [&section] (const std::unique_ptr<Section>& S) {
953 return S.get() == &section;
954 }
955 );
956 if (it == sections_.end()) {
958 }
959 return std::distance(sections_.begin(), it);
960 }
961
963 result<size_t> get_section_idx(const std::string& name) const {
964 auto it = std::find_if(sections_.begin(), sections_.end(),
965 [name] (const std::unique_ptr<Section>& S) {
966 return S->name() == name;
967 }
968 );
969 if (it == sections_.end()) {
971 }
972 return std::distance(sections_.begin(), it);
973 }
974
978 find_version_requirement(const std::string& libname) const;
979
981 return const_cast<SymbolVersionRequirement*>(static_cast<const Binary*>(this)->find_version_requirement(name));
982 }
983
990 bool remove_version_requirement(const std::string& libname);
991
992 uint8_t ptr_size() const {
993 switch (type()) {
995 return sizeof(uint32_t);
997 return sizeof(uint64_t);
998 default:
999 return 0;
1000 }
1001 return 0;
1002 }
1003
1004 uint64_t page_size() const override;
1005
1006 static bool classof(const LIEF::Binary* bin) {
1007 return bin->format() == Binary::FORMATS::ELF ||
1008 bin->format() == Binary::FORMATS::OAT;
1009 }
1010
1011 size_t hash(const std::string& name);
1012
1013 ~Binary() override;
1014
1015 std::ostream& print(std::ostream& os) const override;
1016
1018 add(entry);
1019 return *this;
1020 }
1021 Binary& operator+=(const Section& section) {
1022 add(section);
1023 return *this;
1024 }
1025
1026 Binary& operator+=(const Segment& segment) {
1027 add(segment);
1028 return *this;
1029 }
1030
1031 Binary& operator+=(const Note& note) {
1032 add(note);
1033 return *this;
1034 }
1035
1037 remove(entry);
1038 return *this;
1039 }
1040
1042 remove(tag);
1043 return *this;
1044 }
1045
1046 Binary& operator-=(const Note& note) {
1047 remove(note);
1048 return *this;
1049 }
1050
1052 remove(type);
1053 return *this;
1054 }
1055
1057 return get(type);
1058 }
1059
1061 return get(type);
1062 }
1063
1065 return get(tag);
1066 }
1067
1069 return get(tag);
1070 }
1071
1073 return get(type);
1074 }
1075
1077 return get(type);
1078 }
1079
1081 return get(type);
1082 }
1083
1085 return get(type);
1086 }
1087
1088 bool should_swap() const {
1089 return should_swap_;
1090 }
1091
1092 protected:
1093 struct phdr_relocation_info_t {
1094 uint64_t new_offset = 0;
1095 size_t nb_segments = 0;
1096 void clear() {
1097 new_offset = 0;
1098 nb_segments = 0;
1099 }
1100 };
1101 LIEF_LOCAL Binary();
1102
1104 LIEF_LOCAL LIEF::Binary::sections_t get_abstract_sections() override;
1105
1106 LIEF_LOCAL LIEF::Header get_abstract_header() const override {
1107 return LIEF::Header::from(*this);
1108 }
1109
1110 LIEF_LOCAL LIEF::Binary::functions_t get_abstract_exported_functions() const override;
1111 LIEF_LOCAL LIEF::Binary::functions_t get_abstract_imported_functions() const override;
1112 LIEF_LOCAL std::vector<std::string> get_abstract_imported_libraries() const override;
1113 LIEF_LOCAL LIEF::Binary::symbols_t get_abstract_symbols() override;
1114 LIEF_LOCAL LIEF::Binary::relocations_t get_abstract_relocations() override;
1115
1116 template<ELF::ARCH ARCH>
1117 LIEF_LOCAL void patch_relocations(uint64_t from, uint64_t shift);
1118
1119 template<class T>
1120 LIEF_LOCAL void patch_addend(Relocation& relocatio, uint64_t from, uint64_t shift);
1121
1122 LIEF_LOCAL void shift_sections(uint64_t from, uint64_t shift);
1123 LIEF_LOCAL void shift_segments(uint64_t from, uint64_t shift);
1124 LIEF_LOCAL void shift_dynamic_entries(uint64_t from, uint64_t shift);
1125 LIEF_LOCAL void shift_symbols(uint64_t from, uint64_t shift);
1126 LIEF_LOCAL void shift_relocations(uint64_t from, uint64_t shift);
1127
1128 template<class ELF_T>
1129 LIEF_LOCAL void fix_got_entries(uint64_t from, uint64_t shift);
1130
1131 LIEF_LOCAL LIEF::Binary::functions_t eh_frame_functions() const;
1132 LIEF_LOCAL LIEF::Binary::functions_t armexid_functions() const;
1133
1134 template<Header::FILE_TYPE OBJECT_TYPE, bool note = false>
1135 LIEF_LOCAL Segment* add_segment(const Segment& segment, uint64_t base);
1136
1137 LIEF_LOCAL uint64_t relocate_phdr_table_auto();
1138 LIEF_LOCAL uint64_t relocate_phdr_table_pie();
1139 LIEF_LOCAL uint64_t relocate_phdr_table_v1();
1140 LIEF_LOCAL uint64_t relocate_phdr_table_v2();
1141 LIEF_LOCAL uint64_t relocate_phdr_table_v3();
1142
1143 template<Segment::TYPE PT>
1144 LIEF_LOCAL Segment* extend_segment(const Segment& segment, uint64_t size);
1145
1146 template<bool LOADED>
1147 LIEF_LOCAL Section* add_section(const Section& section, SEC_INSERT_POS pos);
1148
1149 std::vector<Symbol*> symtab_dyn_symbols() const;
1150
1151 LIEF_LOCAL std::string shstrtab_name() const;
1152 LIEF_LOCAL Section* add_frame_section(const Section& sec);
1153 LIEF_LOCAL Section* add_section(std::unique_ptr<Section> sec);
1154
1155 LIEF_LOCAL LIEF::Binary::functions_t tor_functions(DynamicEntry::TAG tag) const;
1156
1157 Header::CLASS type_ = Header::CLASS::NONE;
1158 Header header_;
1159 sections_t sections_;
1160 segments_t segments_;
1161 dynamic_entries_t dynamic_entries_;
1162 symbols_t dynamic_symbols_;
1163 symbols_t symtab_symbols_;
1164 relocations_t relocations_;
1165 symbols_version_t symbol_version_table_;
1166 symbols_version_requirement_t symbol_version_requirements_;
1167 symbols_version_definition_t symbol_version_definition_;
1168 notes_t notes_;
1169 std::unique_ptr<GnuHash> gnu_hash_;
1170 std::unique_ptr<SysvHash> sysv_hash_;
1171 std::unique_ptr<DataHandler::Handler> datahandler_;
1172 phdr_relocation_info_t phdr_reloc_info_;
1173
1174 std::string interpreter_;
1175 std::vector<uint8_t> overlay_;
1176 std::unique_ptr<sizing_info_t> sizing_info_;
1177 uint64_t pagesize_ = 0;
1178 bool should_swap_ = false;
1179};
1180
1181}
1182}
1183#endif
Abstract binary that exposes an uniform API for the different executable file formats.
Definition Abstract/Binary.hpp:53
std::vector< Function > functions_t
Definition Abstract/Binary.hpp:71
@ ELF
Definition Abstract/Binary.hpp:65
@ OAT
Definition Abstract/Binary.hpp:68
FORMATS format() const
Executable format (ELF, PE, Mach-O) of the underlying binary.
Definition Abstract/Binary.hpp:113
std::vector< Symbol * > symbols_t
Internal container.
Definition Abstract/Binary.hpp:83
VA_TYPES
Type of a virtual address.
Definition Abstract/Binary.hpp:57
@ AUTO
Try to guess if it's relative or not.
Definition Abstract/Binary.hpp:58
std::vector< Section * > sections_t
Internal container.
Definition Abstract/Binary.hpp:74
std::vector< Relocation * > relocations_t
Internal container.
Definition Abstract/Binary.hpp:92
friend class ObjectFileLayout
Definition ELF/Binary.hpp:64
const_ref_iterator< std::vector< Symbol * > > it_const_symbols
Iterator which outputs static and dynamic const Symbol& object.
Definition ELF/Binary.hpp:169
~Binary() override
Segment * add(const Segment &segment, uint64_t base=0)
Add a new segment in the binary.
bool use_gnu_hash() const
true if GNU hash is used
Definition ELF/Binary.hpp:461
const DynamicEntry * get(DynamicEntry::TAG tag) const
Return the first ELF::DynamicEntry associated with the given tag If the tag can't be found,...
void remove(const Segment &seg, bool clear=false)
Remove the given segment. If clear is set, the original content of the segment will be filled with ze...
Header::CLASS type() const
Return binary's class (ELF32 or ELF64).
Definition ELF/Binary.hpp:250
std::vector< std::unique_ptr< Symbol > > symbols_t
Internal container for storing ELF's Symbol.
Definition ELF/Binary.hpp:151
const_ref_iterator< const sections_t &, const Section * > it_const_sections
Iterator which outputs const Section& object.
Definition ELF/Binary.hpp:190
bool should_swap() const
Definition ELF/Binary.hpp:1088
const_filter_iterator< const relocations_t &, const Relocation * > it_const_dynamic_relocations
Iterator which outputs dynamic const Relocation& object (not related to the PLT/GOT mechanism).
Definition ELF/Binary.hpp:136
result< uint64_t > virtual_address_to_offset(uint64_t virtual_address) const
Convert a virtual address to a file offset.
it_const_symbols symbols() const
Definition ELF/Binary.hpp:551
uint64_t last_offset_section() const
Return the last offset used in binary according to sections table.
SEC_INSERT_POS
This enum defines where the content of a newly added section should be inserted.
Definition ELF/Binary.hpp:228
@ POST_SEGMENT
Insert the section after the last valid offset in the segments table.
Definition ELF/Binary.hpp:237
@ POST_SECTION
Insert the section after the last valid offset in the section table.
Definition ELF/Binary.hpp:242
@ AUTO
Defer the choice to LIEF.
Definition ELF/Binary.hpp:230
span< const uint8_t > get_content_from_virtual_address(uint64_t virtual_address, uint64_t size, Binary::VA_TYPES addr_type=Binary::VA_TYPES::AUTO) const override
Return the content located at virtual address.
PHDR_RELOC
Definition ELF/Binary.hpp:196
@ PIE_SHIFT
Definition ELF/Binary.hpp:207
@ AUTO
Definition ELF/Binary.hpp:200
@ BSS_END
Definition ELF/Binary.hpp:213
@ BINARY_END
Definition ELF/Binary.hpp:217
@ SEGMENT_GAP
Definition ELF/Binary.hpp:223
Header & header()
Return Elf header .
Definition ELF/Binary.hpp:255
friend class ExeLayout
Definition ELF/Binary.hpp:62
const Section * section_from_offset(uint64_t offset, bool skip_nobits=true) const
Return the ELF::Section from the given offset. Return a nullptr if a section can't be found.
it_dynamic_entries dynamic_entries()
Return binary's dynamic entries.
Definition ELF/Binary.hpp:298
it_symbols_version_requirement symbols_version_requirement()
Return Symbol version requirement.
Definition ELF/Binary.hpp:386
void remove(Segment::TYPE type, bool clear=false)
Remove all segments associated with the given type.
size_t hash(const std::string &name)
it_const_dynamic_relocations dynamic_relocations() const
it_pltgot_relocations pltgot_relocations()
Return plt.got relocations.
ref_iterator< notes_t &, Note * > it_notes
Iterator which outputs Note& object.
Definition ELF/Binary.hpp:73
filter_iterator< relocations_t &, Relocation * > it_object_relocations
Iterator which outputs Relocation& object found in object files (.o).
Definition ELF/Binary.hpp:139
ref_iterator< symbols_version_definition_t &, SymbolVersionDefinition * > it_symbols_version_definition
Iterator which outputs SymbolVersionDefinition& object.
Definition ELF/Binary.hpp:91
void strip()
Strip the binary by removing symtab symbols.
Note & add(const Note &note)
Add the given note and return the created entry.
Symbol & export_symbol(const std::string &symbol_name, uint64_t value=0)
Export the symbol with the given name and create it if it doesn't exist.
void remove_symtab_symbol(Symbol *symbol)
Binary & operator+=(const DynamicEntry &entry)
Definition ELF/Binary.hpp:1017
void remove(const Note &note)
Remove the given note.
const Note * operator[](Note::TYPE type) const
Definition ELF/Binary.hpp:1076
std::vector< std::unique_ptr< Relocation > > relocations_t
Internal container for storing ELF's Relocation.
Definition ELF/Binary.hpp:124
bool has_notes() const
true if the binary embeds notes
int64_t dynsym_idx(const std::string &name) const
Symbol index in the dynamic symbol table or -1 if the symbol does not exist.
Segment * segment_from_virtual_address(uint64_t address)
Definition ELF/Binary.hpp:815
const Relocation * get_relocation(const Symbol &symbol) const
Return relocation associated with the given Symbol It returns a nullptr if it is not found.
void remove_dynamic_symbol(const std::string &name)
Remove dynamic symbols with the given name.
Binary & operator-=(const Note &note)
Definition ELF/Binary.hpp:1046
const Section * section_from_virtual_address(uint64_t address, bool skip_nobits=true) const
Return the ELF::Section from the given address. Return a nullptr if a section can't be found.
const Relocation * get_relocation(const std::string &symbol_name) const
Return relocation associated with the given Symbol name It returns a nullptr if it is not found.
it_symtab_symbols symtab_symbols()
Return the debug symbols from the .symtab section.
Definition ELF/Binary.hpp:360
LIEF::Binary::functions_t ctor_functions() const override
List of binary constructors (typically, the functions located in the .init_array).
uint64_t imagebase() const override
Return program image base. For instance 0x40000.
LIEF::Binary::functions_t functions() const
List of the functions found the in the binary.
bool has_library(const std::string &name) const
Check if the given library name exists in the current binary.
Definition ELF/Binary.hpp:663
const_ref_iterator< const symbols_t &, const Symbol * > it_const_dynamic_symbols
Iterator which outputs the Dynamic const Symbol& object.
Definition ELF/Binary.hpp:157
int64_t dynsym_idx(const Symbol &sym) const
const_ref_iterator< const symbols_version_definition_t &, const SymbolVersionDefinition * > it_const_symbols_version_definition
Iterator which outputs const SymbolVersionDefinition& object.
Definition ELF/Binary.hpp:94
LIEF::Binary::functions_t dtor_functions() const
List of the binary destructors (typically, the functions located in the .fini_array).
const_ref_iterator< const dynamic_entries_t &, const DynamicEntry * > it_const_dynamic_entries
Iterator which outputs const DynamicEntry& object.
Definition ELF/Binary.hpp:112
std::vector< std::unique_ptr< SymbolVersion > > symbols_version_t
Internal container for storing ELF's SymbolVersion.
Definition ELF/Binary.hpp:115
Segment * operator[](Segment::TYPE type)
Definition ELF/Binary.hpp:1056
const Symbol * get_dynamic_symbol(const std::string &name) const
Get the dynamic symbol from the given name. Return a nullptr if it can't be found.
Relocation * get_relocation(uint64_t address)
Definition ELF/Binary.hpp:440
const Segment * segment_from_virtual_address(Segment::TYPE type, uint64_t address) const
DynamicEntryLibrary * get_library(const std::string &library_name)
Get the library object (DynamicEntryLibrary) from the given name If the library can't be found,...
Definition ELF/Binary.hpp:654
bool is_pie() const override
Check if the binary has been compiled with -fpie -pie flags.
Symbol * get_symtab_symbol(const std::string &name)
Definition ELF/Binary.hpp:583
it_symbols_version symbols_version()
Return the symbol versions.
Definition ELF/Binary.hpp:369
DynamicEntryLibrary & add_library(const std::string &library_name)
Add a library as dependency.
Section * text_section()
Return the .text section. If the section can't be found, it returns a nullptr.
Definition ELF/Binary.hpp:504
filter_iterator< std::vector< Symbol * > > it_exported_symbols
Iterator which outputs exported Symbol& object.
Definition ELF/Binary.hpp:172
it_object_relocations object_relocations()
Return relocations used in an object file (*.o).
Section * get_section(const std::string &name)
Return Section with the given name. If the section can't be found, it returns a nullptr.
Definition ELF/Binary.hpp:497
it_imported_symbols imported_symbols()
Return symbols which are imported by the binary.
std::vector< std::unique_ptr< Segment > > segments_t
Internal container for storing ELF's Segment.
Definition ELF/Binary.hpp:97
it_sections sections()
Return an iterator over the binary's sections.
Definition ELF/Binary.hpp:275
it_const_notes notes() const
Return an iterator over the ELF's LIEF::ELF::Note.
Definition ELF/Binary.hpp:905
void patch_address(uint64_t address, uint64_t patch_value, size_t size=sizeof(uint64_t), LIEF::Binary::VA_TYPES addr_type=LIEF::Binary::VA_TYPES::AUTO) override
Patch the address with the given value.
it_symbols_version_definition symbols_version_definition()
Return symbols version definition.
Definition ELF/Binary.hpp:377
it_const_object_relocations object_relocations() const
const Symbol * get_symtab_symbol(const std::string &name) const
Get the symtab symbol from the given name Return a nullptr if it can't be found.
it_dynamic_relocations dynamic_relocations()
Return dynamic relocations.
void overlay(std::vector< uint8_t > overlay)
Function to set the overlay.
Definition ELF/Binary.hpp:928
ref_iterator< symbols_version_requirement_t &, SymbolVersionRequirement * > it_symbols_version_requirement
Iterator which outputs SymbolVersionRequirement& object.
Definition ELF/Binary.hpp:82
Note * get(Note::TYPE type)
Definition ELF/Binary.hpp:849
void remove_dynamic_symbol(Symbol *symbol)
Remove the given symbol from the dynamic symbols table.
span< const uint8_t > overlay() const
Overlay data (if any).
Definition ELF/Binary.hpp:923
bool has_overlay() const
True if data are present at the end of the binary.
Definition ELF/Binary.hpp:918
bool has(Section::TYPE type) const
Check if a ELF::Section associated with the given type exists.
Definition ELF/Binary.hpp:876
std::ostream & print(std::ostream &os) const override
Relocation * get_relocation(const std::string &symbol_name)
Definition ELF/Binary.hpp:454
Symbol & add_dynamic_symbol(const Symbol &symbol, const SymbolVersion *version=nullptr)
Add a dynamic symbol with the associated SymbolVersion.
ref_iterator< segments_t &, Segment * > it_segments
Iterator which outputs Segment& object.
Definition ELF/Binary.hpp:100
const_filter_iterator< const relocations_t &, const Relocation * > it_const_pltgot_relocations
Iterator which outputs plt/got const Relocation& object.
Definition ELF/Binary.hpp:130
std::vector< std::unique_ptr< DynamicEntry > > dynamic_entries_t
Internal container for storing ELF's DynamicEntry.
Definition ELF/Binary.hpp:106
Symbol & add_symtab_symbol(const Symbol &symbol)
Add a symtab symbol.
Binary & operator+=(const Section &section)
Definition ELF/Binary.hpp:1021
const Section * get_section(const std::string &name) const
const_filter_iterator< const relocations_t &, const Relocation * > it_const_object_relocations
Iterator which outputs const Relocation& object found in object files (.o).
Definition ELF/Binary.hpp:142
void interpreter(const std::string &interpreter)
Change the interpreter.
Definition ELF/Binary.hpp:542
const_filter_iterator< std::vector< Symbol * > > it_const_imported_symbols
Iterator which outputs imported const Symbol& object.
Definition ELF/Binary.hpp:181
Binary(const Binary &copy)=delete
int64_t symtab_idx(const Symbol &sym) const
const Segment * operator[](Segment::TYPE type) const
Definition ELF/Binary.hpp:1060
it_const_sections sections() const
Definition ELF/Binary.hpp:279
result< size_t > get_section_idx(const std::string &name) const
Find the index of the section with the name given in the first parameter.
Definition ELF/Binary.hpp:963
Relocation * add_object_relocation(const Relocation &relocation, const Section &section)
Add relocation for object file (.o).
uint64_t virtual_size() const
Return the size of the mapped binary.
it_exported_symbols exported_symbols()
Return symbols which are exported by the binary.
const Header & header() const
Definition ELF/Binary.hpp:259
std::vector< std::string > string_list_t
Definition ELF/Binary.hpp:67
it_const_symtab_symbols symtab_symbols() const
Definition ELF/Binary.hpp:364
const_ref_iterator< const relocations_t &, const Relocation * > it_const_relocations
Iterator which outputs const Relocation& object.
Definition ELF/Binary.hpp:148
result< size_t > get_section_idx(const Section &section) const
Find the index of the section given in the first parameter.
Definition ELF/Binary.hpp:950
Section * extend(const Section &section, uint64_t size)
std::vector< std::unique_ptr< Note > > notes_t
Internal container for storing notes.
Definition ELF/Binary.hpp:70
const Segment * get(Segment::TYPE type) const
Return the first ELF::Segment associated with the given type. If a segment can't be found,...
uint64_t entrypoint() const override
Return the binary's entrypoint.
Definition ELF/Binary.hpp:284
void write(const std::string &filename)
Reconstruct the binary object and write it in filename.
Definition ELF/Binary.hpp:731
friend class Builder
Definition ELF/Binary.hpp:61
bool has(Note::TYPE type) const
Check if a ELF::Note associated with the given type exists.
Definition ELF/Binary.hpp:871
Segment * segment_from_offset(uint64_t offset)
Definition ELF/Binary.hpp:828
bool has_symtab_symbol(const std::string &name) const
Check if the symbol with the given name exists in the symtab symbol table.
Definition ELF/Binary.hpp:575
bool has_dynamic_symbol(const std::string &name) const
Check if the symbol with the given name exists in the dynamic symbols table.
Definition ELF/Binary.hpp:562
DynamicEntry * operator[](DynamicEntry::TAG tag)
Definition ELF/Binary.hpp:1064
result< uint64_t > offset_to_virtual_address(uint64_t offset, uint64_t slide=0) const override
Convert the given offset into a virtual address.
ref_iterator< symbols_t &, Symbol * > it_symtab_symbols
Iterator which outputs the static/debug Symbol& object.
Definition ELF/Binary.hpp:160
const SymbolVersionRequirement * find_version_requirement(const std::string &libname) const
Try to find the SymbolVersionRequirement associated with the given library name (e....
it_const_symbols_version_definition symbols_version_definition() const
Definition ELF/Binary.hpp:381
const Section * get(Section::TYPE type) const
Return the first ELF::Section associated with the given type If a section can't be found,...
Section * hash_section()
Return the hash section. If the section can't be found, it returns a nullptr.
uint64_t next_virtual_address() const
Return the next virtual address available.
it_const_exported_symbols exported_symbols() const
const Segment * segment_from_virtual_address(uint64_t address) const
Return the ELF::Segment from the given address. Return a nullptr if a segment can't be found.
Binary & operator-=(const DynamicEntry &entry)
Definition ELF/Binary.hpp:1036
uint64_t eof_offset() const
Return the last offset used by the ELF binary according to both: the sections table and the segments ...
void remove(DynamicEntry::TAG tag)
Remove all dynamic entries with the given tag.
uint64_t page_size() const override
Get the default memory page size according to the architecture and the format of the current binary.
it_segments segments()
Return binary's segments.
Definition ELF/Binary.hpp:289
void remove_library(const std::string &library_name)
Remove the given library from the dependencies.
const_ref_iterator< const symbols_version_t &, const SymbolVersion * > it_const_symbols_version
Iterator which outputs const SymbolVersion& object.
Definition ELF/Binary.hpp:121
result< uint64_t > get_function_address(const std::string &func_name, bool demangled) const
Return the address of the given function name.
it_dynamic_symbols dynamic_symbols()
Return an iterator over the binary's dynamic symbols The dynamic symbols are those located in the ....
Definition ELF/Binary.hpp:343
filter_iterator< std::vector< Symbol * > > it_imported_symbols
Iterator which outputs imported Symbol& object.
Definition ELF/Binary.hpp:178
it_const_dynamic_entries dynamic_entries() const
Definition ELF/Binary.hpp:302
void remove_symtab_symbol(const std::string &name)
Remove symtabl symbols with the given name.
Binary & operator-=(DynamicEntry::TAG tag)
Definition ELF/Binary.hpp:1041
it_relocations relocations()
Return all relocations present in the binary.
Definition ELF/Binary.hpp:429
Section * dynamic_section()
Return the .dynamic section. If the section can't be found, it returns a nullptr.
Segment * get(Segment::TYPE type)
Definition ELF/Binary.hpp:842
const DynamicEntryLibrary * get_library(const std::string &library_name) const
Get the library object (DynamicEntryLibrary) from the given name If the library can't be found,...
const_ref_iterator< const symbols_t &, const Symbol * > it_const_symtab_symbols
Iterator which outputs the static/debug const Symbol& object.
Definition ELF/Binary.hpp:163
uint8_t ptr_size() const
Definition ELF/Binary.hpp:992
const DynamicEntry * operator[](DynamicEntry::TAG tag) const
Definition ELF/Binary.hpp:1068
it_symbols symbols()
Return an iterator on both static and dynamic symbols.
Definition ELF/Binary.hpp:547
uint64_t relocate_phdr_table(PHDR_RELOC type)
Force relocating the segments table in a specific way.
std::vector< std::unique_ptr< Section > > sections_t
Internal container for storing ELF's Section.
Definition ELF/Binary.hpp:184
const_ref_iterator< const segments_t &, const Segment * > it_const_segments
Iterator which outputs const Segment& object.
Definition ELF/Binary.hpp:103
Segment * replace(const Segment &new_segment, const Segment &original_segment, uint64_t base=0)
Replace the segment given in 2nd parameter with the segment given in the first one and return the upd...
void remove(const Section &section, bool clear=false)
Remove the given section. The clear parameter can be used to zeroize the original content beforehand.
Symbol * get_dynamic_symbol(const std::string &name)
Definition ELF/Binary.hpp:570
Section * operator[](Section::TYPE type)
Definition ELF/Binary.hpp:1080
it_const_dynamic_symbols dynamic_symbols() const
Definition ELF/Binary.hpp:347
bool has_section_with_offset(uint64_t offset) const
Check if a section that handles the given offset exists.
string_list_t strings(size_t min_size=5) const
Return list of the strings used by the ELF binary.
void remove_section(const std::string &name, bool clear=false) override
Remove a binary's section.
friend class Parser
Definition ELF/Binary.hpp:60
std::vector< uint8_t > raw()
Reconstruct the binary object and return its content as a byte vector.
const SysvHash * sysv_hash() const
Return the SysvHash object as a read-only object If the ELF binary does not use the legacy sysv hash ...
Definition ELF/Binary.hpp:480
SymbolVersionRequirement * find_version_requirement(const std::string &name)
Definition ELF/Binary.hpp:980
std::vector< std::unique_ptr< SymbolVersionDefinition > > symbols_version_definition_t
Internal container for storing SymbolVersionDefinition.
Definition ELF/Binary.hpp:88
bool has_section(const std::string &name) const
Check if a section with the given name exists in the binary.
Definition ELF/Binary.hpp:485
Relocation * get_relocation(const Symbol &symbol)
Definition ELF/Binary.hpp:447
Section * section_from_offset(uint64_t offset, bool skip_nobits=true)
Definition ELF/Binary.hpp:798
Section * get(Section::TYPE type)
Definition ELF/Binary.hpp:856
static bool classof(const LIEF::Binary *bin)
Definition ELF/Binary.hpp:1006
it_const_relocations relocations() const
Definition ELF/Binary.hpp:433
Binary & operator-=(Note::TYPE type)
Definition ELF/Binary.hpp:1051
Symbol & add_exported_function(uint64_t address, const std::string &name="")
Create a symbol for the function at the given address and export it.
bool is_targeting_android() const
True if the current ELF is targeting Android.
it_const_segments segments() const
Definition ELF/Binary.hpp:293
DynamicEntry * get(DynamicEntry::TAG tag)
Definition ELF/Binary.hpp:835
Section * symtab_symbols_section()
Return section which holds the symtab symbols. If the section can't be found, it returns a nullptr.
uint64_t last_offset_segment() const
Return the last offset used in binary according to segments table.
bool use_sysv_hash() const
true if SYSV hash is used
Definition ELF/Binary.hpp:474
friend class Layout
Definition ELF/Binary.hpp:63
ref_iterator< sections_t &, Section * > it_sections
Iterator which outputs Section& object.
Definition ELF/Binary.hpp:187
void patch_pltgot(const Symbol &symbol, uint64_t address)
Patch the imported symbol with the address.
void write(std::ostream &os, Builder::config_t config)
Reconstruct the binary object with the given config and write it in os stream.
filter_iterator< relocations_t &, Relocation * > it_dynamic_relocations
Iterator which outputs dynamic Relocation& object (not related to the PLT/GOT mechanism).
Definition ELF/Binary.hpp:133
ref_iterator< relocations_t &, Relocation * > it_relocations
Iterator which outputs Relocation& object.
Definition ELF/Binary.hpp:145
bool has_interpreter() const
Check if the binary uses a loader (also named linker or interpreter).
const Relocation * get_relocation(uint64_t address) const
Return relocation associated with the given address. It returns a nullptr if it is not found.
void remove_symbol(const std::string &name)
Remove symbols with the given name in both:
const Section * operator[](Section::TYPE type) const
Definition ELF/Binary.hpp:1084
const Segment * segment_from_offset(uint64_t offset) const
Return the ELF::Segment from the offset. Return a nullptr if a segment can't be found.
Section * section_from_virtual_address(uint64_t address, bool skip_nobits=true)
Definition ELF/Binary.hpp:808
void remove(Note::TYPE type)
Remove all notes with the given type.
Relocation & add_dynamic_relocation(const Relocation &relocation)
Add a new dynamic relocation.
ref_iterator< symbols_t &, Symbol * > it_dynamic_symbols
Iterator which outputs the Dynamic Symbol& object.
Definition ELF/Binary.hpp:154
const std::string & interpreter() const
Return the ELF interpreter if any. (e.g. /lib64/ld-linux-x86-64.so.2) If the binary does not have an ...
Definition ELF/Binary.hpp:537
int64_t symtab_idx(const std::string &name) const
Symbol index from the .symtab section or -1 if the symbol is not present.
Segment * extend(const Segment &segment, uint64_t size)
bool remove_version_requirement(const std::string &libname)
Deletes all required symbol versions linked to the specified library name. The function returns true ...
std::vector< uint64_t > get_relocated_dynamic_array(DynamicEntry::TAG tag) const
Return the array defined by the given tag (e.g. DynamicEntry::TAG::INIT_ARRAY) with relocations appli...
it_const_pltgot_relocations pltgot_relocations() const
it_const_symbols_version_requirement symbols_version_requirement() const
Definition ELF/Binary.hpp:390
ref_iterator< std::vector< Symbol * > > it_symbols
Iterator which outputs static and dynamic Symbol& object.
Definition ELF/Binary.hpp:166
it_notes notes()
Definition ELF/Binary.hpp:909
it_const_imported_symbols imported_symbols() const
ref_iterator< symbols_version_t &, SymbolVersion * > it_symbols_version
Iterator which outputs SymbolVersion& object.
Definition ELF/Binary.hpp:118
void patch_address(uint64_t address, const std::vector< uint8_t > &patch_value, LIEF::Binary::VA_TYPES addr_type=LIEF::Binary::VA_TYPES::AUTO) override
Patch the content at virtual address address with patch_value.
Note * operator[](Note::TYPE type)
Definition ELF/Binary.hpp:1072
const_filter_iterator< std::vector< Symbol * > > it_const_exported_symbols
Iterator which outputs exported const Symbol& object.
Definition ELF/Binary.hpp:175
Binary & operator+=(const Segment &segment)
Definition ELF/Binary.hpp:1026
void write(const std::string &filename, Builder::config_t config)
Reconstruct the binary object with the given config and write it in filename.
Binary & operator=(const Binary &)=delete
filter_iterator< relocations_t &, Relocation * > it_pltgot_relocations
Iterator which outputs plt/got Relocation& object.
Definition ELF/Binary.hpp:127
Section * add(const Section &section, bool loaded=true, SEC_INSERT_POS pos=SEC_INSERT_POS::AUTO)
Add a new section in the binary.
Segment * segment_from_virtual_address(Segment::TYPE type, uint64_t address)
Definition ELF/Binary.hpp:821
void permute_dynamic_symbols(const std::vector< size_t > &permutation)
Apply the given permutation on the dynamic symbols table.
bool has_section_with_va(uint64_t va) const
Check if a section that handles the given virtual address exists.
const_ref_iterator< const notes_t &, const Note * > it_const_notes
Iterator which outputs const Note& object.
Definition ELF/Binary.hpp:76
void patch_pltgot(const std::string &symbol_name, uint64_t address)
Patch the imported symbol's name with the address.
void accept(LIEF::Visitor &visitor) const override
Method associated with the visitor pattern.
const Note * get(Note::TYPE type) const
Return the first ELF::Note associated with the given type If a note can't be found,...
ref_iterator< dynamic_entries_t &, DynamicEntry * > it_dynamic_entries
Iterator which outputs DynamicEntry& object.
Definition ELF/Binary.hpp:109
Symbol & export_symbol(const Symbol &symbol)
Export the given symbol and create it if it doesn't exist.
it_const_symbols_version symbols_version() const
Definition ELF/Binary.hpp:372
Relocation & add_pltgot_relocation(const Relocation &relocation)
Add a .plt.got relocation. This kind of relocation is usually associated with a PLT stub that aims at...
Binary & operator+=(const Note &note)
Definition ELF/Binary.hpp:1031
std::vector< std::unique_ptr< SymbolVersionRequirement > > symbols_version_requirement_t
Internal container for storing SymbolVersionRequirement.
Definition ELF/Binary.hpp:79
result< uint64_t > get_function_address(const std::string &func_name) const override
Return the address of the given function name.
const GnuHash * gnu_hash() const
Return the GnuHash object in readonly If the ELF binary does not use the GNU hash table,...
Definition ELF/Binary.hpp:467
void write(std::ostream &os)
Reconstruct the binary object and write it in os stream.
Definition ELF/Binary.hpp:750
bool has_nx() const override
Check if the binary uses the NX protection (Non executable stack).
void remove(const DynamicEntry &entry)
Remove the given dynamic entry.
const_ref_iterator< const symbols_version_requirement_t &, const SymbolVersionRequirement * > it_const_symbols_version_requirement
Iterator which outputs const SymbolVersionRequirement& object.
Definition ELF/Binary.hpp:85
DynamicEntry & add(const DynamicEntry &entry)
Add the given dynamic entry and return the new entry.
bool has(Segment::TYPE type) const
Check if ELF::Segment associated with the given type exists.
Definition ELF/Binary.hpp:866
bool has(DynamicEntry::TAG tag) const
Check if an ELF::DynamicEntry associated with the given tag exists.
Definition ELF/Binary.hpp:861
Class which represents a DT_NEEDED entry in the dynamic table.
Definition DynamicEntryLibrary.hpp:29
Class which represents an entry in the dynamic table These entries are located in the ....
Definition DynamicEntry.hpp:36
TAG
Definition DynamicEntry.hpp:47
@ HASH
Definition DynamicEntry.hpp:53
@ GNU_HASH
Definition DynamicEntry.hpp:88
Class which provides a view over the GNU Hash implementation. Most of the fields are read-only since ...
Definition GnuHash.hpp:36
Class which represents the ELF's header. This class mirrors the raw ELF Elfxx_Ehdr structure.
Definition ELF/Header.hpp:35
CLASS
Match the result of Elfxx_Ehdr.e_ident[EI_CLASS].
Definition ELF/Header.hpp:73
@ ELF64
32-bit objects
Definition ELF/Header.hpp:76
@ ELF32
Invalid class.
Definition ELF/Header.hpp:75
Class which represents an ELF note. This class can be instantiated using the static Note::create func...
Definition Note.hpp:39
TYPE
LIEF representation of the ELF NT_ values.
Definition Note.hpp:49
Class which parses and transforms an ELF file into a ELF::Binary object.
Definition ELF/Parser.hpp:45
Class that represents an ELF relocation.
Definition ELF/Relocation.hpp:40
Class which represents an ELF Section.
Definition ELF/Section.hpp:48
TYPE
Definition ELF/Section.hpp:62
Class which represents the ELF segments.
Definition Segment.hpp:48
TYPE
Definition Segment.hpp:72
Class which represents an entry defined in DT_VERDEF or .gnu.version_d.
Definition SymbolVersionDefinition.hpp:38
Class which represents an entry in the DT_VERNEED or .gnu.version_r table.
Definition SymbolVersionRequirement.hpp:40
Class which represents an entry defined in the DT_VERSYM dynamic entry.
Definition SymbolVersion.hpp:33
Class which represents an ELF symbol.
Definition ELF/Symbol.hpp:35
Class which represents the SYSV hash for the symbols resolution.
Definition SysvHash.hpp:39
Definition Abstract/Header.hpp:40
static Header from(const LIEF::ELF::Binary &elf)
Definition Visitor.hpp:210
Iterator which return a ref on container's values given predicates.
Definition iterators.hpp:263
Iterator which returns reference on container's values.
Definition iterators.hpp:46
@ not_found
Definition errors.hpp:25
tl::unexpected< lief_errors > make_error_code(lief_errors e)
Create an standard error code from lief_errors.
Definition errors.hpp:52
Definition ELF/Binary.hpp:38
Namespace related to the LIEF's ELF module.
Definition Abstract/Header.hpp:28
LIEF namespace.
Definition Abstract/Binary.hpp:40
filter_iterator< CT, U, typename decay_t< CT >::const_iterator > const_filter_iterator
Iterator which return a const ref on container's values given predicates.
Definition iterators.hpp:479
tcb::span< ElementType, Extent > span
Definition span.hpp:22
lief_version_t version()
Return the current version.
ref_iterator< CT, U, typename decay_t< CT >::const_iterator > const_ref_iterator
Iterator which return const ref on container's values.
Definition iterators.hpp:257
tl::expected< T, lief_errors > result
Wrapper that contains an Object (T) or an error.
Definition errors.hpp:75
Configuration options to tweak the building process.
Definition ELF/Builder.hpp:55
#define LIEF_API
Definition visibility.h:41
#define LIEF_LOCAL
Definition visibility.h:42