10 #include <sys/types.h>
15 #include <elfutils/libdwfl.h>
40 return elf_symbol::NOTYPE_TYPE;
42 return elf_symbol::OBJECT_TYPE;
44 return elf_symbol::FUNC_TYPE;
46 return elf_symbol::SECTION_TYPE;
48 return elf_symbol::FILE_TYPE;
50 return elf_symbol::COMMON_TYPE;
52 return elf_symbol::TLS_TYPE;
54 return elf_symbol::GNU_IFUNC_TYPE;
76 return elf_symbol::LOCAL_BINDING;
78 return elf_symbol::GLOBAL_BINDING;
80 return elf_symbol::WEAK_BINDING;
82 return elf_symbol::GNU_UNIQUE_BINDING;
102 return elf_symbol::DEFAULT_VISIBILITY;
104 return elf_symbol::INTERNAL_VISIBILITY;
106 return elf_symbol::HIDDEN_VISIBILITY;
108 return elf_symbol::PROTECTED_VISIBILITY;
127 return "elf-no-arch";
129 return "elf-att-we-32100";
131 return "elf-sun-sparc";
133 return "elf-intel-80386";
135 return "elf-motorola-68k";
137 return "elf-motorola-88k";
139 return "elf-intel-80860";
141 return "elf-mips-r3000-be";
143 return "elf-ibm-s370";
145 return "elf-mips-r3000-le";
147 return "elf-hp-parisc";
149 return "elf-fujitsu-vpp500";
151 return "elf-sun-sparc-v8plus";
153 return "elf-intel-80960";
155 return "elf-powerpc";
157 return "elf-powerpc-64";
159 return "elf-ibm-s390";
161 return "elf-nec-v800";
163 return "elf-fujitsu-fr20";
165 return "elf-trw-rh32";
167 return "elf-motorola-rce";
171 return "elf-digital-alpha";
173 return "elf-hitachi-sh";
175 return "elf-sun-sparc-v9-64";
177 return "elf-siemens-tricore";
179 return "elf-argonaut-risc-core";
181 return "elf-hitachi-h8-300";
183 return "elf-hitachi-h8-300h";
185 return "elf-hitachi-h8s";
187 return "elf-hitachi-h8-500";
189 return "elf-intel-ia-64";
191 return "elf-stanford-mips-x";
193 return "elf-motorola-coldfire";
195 return "elf-motorola-68hc12";
197 return "elf-fujitsu-mma";
199 return "elf-siemens-pcp";
201 return "elf-sony-ncpu";
203 return "elf-denso-ndr1";
205 return "elf-motorola-starcore";
207 return "elf-toyota-me16";
209 return "elf-stm-st100";
211 return "elf-alc-tinyj";
213 return "elf-amd-x86_64";
215 return "elf-sony-pdsp";
217 return "elf-siemens-fx66";
219 return "elf-stm-st9+";
221 return "elf-stm-st7";
223 return "elf-motorola-68hc16";
225 return "elf-motorola-68hc11";
227 return "elf-motorola-68hc08";
229 return "elf-motorola-68hc05";
233 return "elf-stm-st19";
235 return "elf-digital-vax";
237 return "elf-axis-cris";
239 return "elf-infineon-javelin";
241 return "elf-firepath";
243 return "elf-lsi-zsp";
245 return "elf-don-knuth-mmix";
247 return "elf-harvard-huany";
249 return "elf-sitera-prism";
251 return "elf-atmel-avr";
253 return "elf-fujistu-fr30";
255 return "elf-mitsubishi-d10v";
257 return "elf-mitsubishi-d30v";
259 return "elf-nec-v850";
261 return "elf-mitsubishi-m32r";
263 return "elf-matsushita-mn10300";
265 return "elf-matsushita-mn10200";
267 return "elf-picojava";
269 return "elf-openrisc-32";
273 return "elf-tensilica-xtensa";
275 #ifdef HAVE_EM_AARCH64_MACRO
277 return "elf-arm-aarch64";
280 #ifdef HAVE_EM_TILEPRO_MACRO
282 return "elf-tilera-tilepro";
285 #ifdef HAVE_EM_TILEGX_MACRO
287 return "elf-tilera-tilegx";
291 return "elf-last-arch-number";
293 return "elf-non-official-alpha";
296 std::ostringstream o;
297 o <<
"elf-unknown-arch-value-" << e_machine;
313 size_t section_header_string_index = 0;
314 if (elf_getshdrstrndx (elf_handle, §ion_header_string_index) < 0)
317 Elf_Scn* section = 0;
318 GElf_Shdr header_mem, *header;
319 while ((section = elf_nextscn(elf_handle, section)) != 0)
321 header = gelf_getshdr(section, &header_mem);
325 const char* section_name =
326 elf_strptr(elf_handle, section_header_string_index, header->sh_name);
327 if (section_name && name == section_name)
346 find_section(Elf* elf_handle,
const std::string& name, Elf64_Word section_type)
348 size_t section_header_string_index = 0;
349 if (elf_getshdrstrndx (elf_handle, §ion_header_string_index) < 0)
352 Elf_Scn* section = 0;
353 GElf_Shdr header_mem, *header;
354 while ((section = elf_nextscn(elf_handle, section)) != 0)
356 header = gelf_getshdr(section, &header_mem);
357 if (header == NULL || header->sh_type != section_type)
360 const char* section_name =
361 elf_strptr(elf_handle, section_header_string_index, header->sh_name);
362 if (section_name && name == section_name)
381 Elf_Scn* section =
nullptr;
382 while ((section = elf_nextscn(elf_handle, section)) != 0)
384 GElf_Shdr header_mem, *header;
385 header = gelf_getshdr(section, &header_mem);
386 if (header->sh_type == section_type)
432 if (dynsym || sym_tab)
435 GElf_Ehdr* elf_header = gelf_getehdr(elf_handle, &eh_mem);
436 if (elf_header->e_type == ET_REL
437 || elf_header->e_type == ET_EXEC)
438 return sym_tab ? sym_tab : dynsym;
440 return dynsym ? dynsym : sym_tab;
466 symtab_index = elf_ndxscn(section);
481 size_t& ht_section_index,
482 size_t& symtab_section_index)
485 return NO_HASH_TABLE_KIND;
487 GElf_Shdr header_mem, *section_header;
488 bool found_sysv_ht =
false, found_gnu_ht =
false;
489 for (Elf_Scn* section = elf_nextscn(elf_handle, 0);
491 section = elf_nextscn(elf_handle, section))
493 section_header= gelf_getshdr(section, &header_mem);
494 if (section_header->sh_type != SHT_HASH
495 && section_header->sh_type != SHT_GNU_HASH)
498 ht_section_index = elf_ndxscn(section);
499 symtab_section_index = section_header->sh_link;
501 if (section_header->sh_type == SHT_HASH)
502 found_sysv_ht =
true;
503 else if (section_header->sh_type == SHT_GNU_HASH)
508 return GNU_HASH_TABLE_KIND;
509 else if (found_sysv_ht)
510 return SYSV_HASH_TABLE_KIND;
512 return NO_HASH_TABLE_KIND;
522 {
return find_section(elf_handle,
".text", SHT_PROGBITS);}
540 {
return find_section(elf_handle,
".rodata", SHT_PROGBITS);}
549 {
return find_section(elf_handle,
".data", SHT_PROGBITS);}
558 {
return find_section(elf_handle,
".data1", SHT_PROGBITS);}
569 {
return find_section(elf_handle,
".opd", SHT_PROGBITS);}
588 Elf_Scn*& versym_section,
589 Elf_Scn*& verdef_section,
590 Elf_Scn*& verneed_section)
592 Elf_Scn* section = NULL;
594 Elf_Scn* versym = NULL, *verdef = NULL, *verneed = NULL;
596 while ((section = elf_nextscn(elf_handle, section)) != NULL)
598 GElf_Shdr* h = gelf_getshdr(section, &mem);
599 if (h->sh_type == SHT_GNU_versym)
601 else if (h->sh_type == SHT_GNU_verdef)
603 else if (h->sh_type == SHT_GNU_verneed)
607 if (versym || verdef || verneed)
610 versym_section = versym;
611 verdef_section = verdef;
612 verneed_section = verneed;
627 {
return find_section(elf_handle,
"__ksymtab", SHT_PROGBITS);}
637 {
return find_section(elf_handle,
"__ksymtab_gpl", SHT_PROGBITS);}
650 return find_section(elf_handle,
"__ksymtab_strings", SHT_PROGBITS);
667 size_t target_index = elf_ndxscn(target_section);
671 Elf_Scn* section = 0;
672 GElf_Shdr header_mem, *header;
673 while ((section = elf_nextscn(elf_handle, section)) != 0)
675 header = gelf_getshdr(section, &header_mem);
677 || (header->sh_type != SHT_RELA && header->sh_type != SHT_REL))
680 if (header->sh_info == target_index)
697 Elf_Scn *strtab_section = NULL;
701 GElf_Shdr symtab_shdr_mem, *symtab_shdr;
703 symtab_shdr = gelf_getshdr(symtab_section, &symtab_shdr_mem);
704 strtab_section = elf_getscn(elf_handle, symtab_shdr->sh_link);
707 return strtab_section;
726 Elf_Scn* verdef_section,
729 Elf_Data* verdef_data = elf_getdata(verdef_section, NULL);
730 GElf_Verdef verdef_mem;
731 GElf_Verdef* verdef = gelf_getverdef(verdef_data, 0, &verdef_mem);
732 size_t vd_offset = 0;
734 for (;; vd_offset += verdef->vd_next)
738 if (verdef->vd_ndx == (*versym & 0x7fff))
741 vd_offset += verdef->vd_next;
742 verdef = (verdef->vd_next == 0
744 : gelf_getverdef(verdef_data, vd_offset, &verdef_mem));
749 GElf_Verdaux verdaux_mem;
750 GElf_Verdaux *verdaux = gelf_getverdaux(verdef_data,
751 vd_offset + verdef->vd_aux,
753 GElf_Shdr header_mem;
754 GElf_Shdr* verdef_section_header = gelf_getshdr(verdef_section,
756 size_t verdef_stridx = verdef_section_header->sh_link;
757 version.
str(elf_strptr(elf_handle, verdef_stridx, verdaux->vda_name));
758 if (*versym & 0x8000)
764 if (!verdef || verdef->vd_next == 0)
787 Elf_Scn* verneed_section,
790 if (versym == 0 || elf_handle == 0 || verneed_section == 0)
793 size_t vn_offset = 0;
794 Elf_Data* verneed_data = elf_getdata(verneed_section, NULL);
795 GElf_Verneed verneed_mem;
796 GElf_Verneed* verneed = gelf_getverneed(verneed_data, 0, &verneed_mem);
798 for (;verneed; vn_offset += verneed->vn_next)
800 size_t vna_offset = vn_offset;
801 GElf_Vernaux vernaux_mem;
802 GElf_Vernaux *vernaux = gelf_getvernaux(verneed_data,
803 vn_offset + verneed->vn_aux,
805 for (;vernaux != 0 && verneed;)
807 if (vernaux->vna_other == *versym)
810 vna_offset += verneed->vn_next;
811 verneed = (verneed->vn_next == 0
813 : gelf_getverneed(verneed_data, vna_offset, &verneed_mem));
816 if (verneed != 0 && vernaux != 0 && vernaux->vna_other == *versym)
818 GElf_Shdr header_mem;
819 GElf_Shdr* verneed_section_header = gelf_getshdr(verneed_section,
821 size_t verneed_stridx = verneed_section_header->sh_link;
822 version.
str(elf_strptr(elf_handle,
825 if (*versym & 0x8000)
832 if (!verneed || verneed->vn_next == 0)
860 bool get_def_version,
863 Elf_Scn *versym_section = NULL,
864 *verdef_section = NULL,
865 *verneed_section = NULL;
873 GElf_Versym versym_mem;
874 Elf_Data* versym_data = (versym_section)
875 ? elf_getdata(versym_section, NULL)
877 GElf_Versym* versym = (versym_data)
878 ? gelf_getversym(versym_data, symbol_index, &versym_mem)
881 if (versym == 0 || *versym <= 1)
890 if (*versym == 0x8001)
898 verdef_section, version))
905 verneed_section, version))
924 size_t crc_section_index = crc_symbol->st_shndx;
925 GElf_Addr crc_symbol_address =
927 if (crc_section_index == SHN_ABS)
929 crc_value = crc_symbol_address;
933 Elf_Scn* kcrctab_section = elf_getscn(elf_handle, crc_section_index);
934 if (kcrctab_section == NULL)
937 GElf_Shdr sheader_mem;
938 GElf_Shdr* sheader = gelf_getshdr(kcrctab_section, &sheader_mem);
942 Elf_Data* kcrctab_data = elf_rawdata(kcrctab_section, NULL);
943 if (kcrctab_data == NULL)
946 if (crc_symbol_address < sheader->sh_addr)
949 size_t offset = crc_symbol_address - sheader->sh_addr;
950 if (offset +
sizeof(uint32_t) > kcrctab_data->d_size
951 || offset +
sizeof(uint32_t) > sheader->sh_size)
954 crc_value = *
reinterpret_cast<uint32_t*
>(
955 reinterpret_cast<char*
>(kcrctab_data->d_buf) + offset);
969 GElf_Ehdr* elf_header = gelf_getehdr(elf_handle, &eh_mem);
970 return (elf_header && elf_header->e_machine == EM_PPC64);
982 GElf_Ehdr* elf_header = gelf_getehdr(elf_handle, &eh_mem);
983 return (elf_header && elf_header->e_machine == EM_PPC);
995 GElf_Ehdr* elf_header = gelf_getehdr(elf_handle, &eh_mem);
996 return (elf_header && elf_header->e_machine == EM_ARM);
1007 #ifdef HAVE_EM_AARCH64_MACRO
1009 GElf_Ehdr* elf_header = gelf_getehdr(elf_handle, &eh_mem);
1010 return (elf_header && elf_header->e_machine == EM_AARCH64);
1026 GElf_Ehdr elf_header;
1027 gelf_getehdr(elf_handle, &elf_header);
1029 bool is_big_endian = (elf_header.e_ident[EI_DATA] == ELFDATA2MSB);
1032 ABG_ASSERT(elf_header.e_ident[EI_DATA] == ELFDATA2LSB);
1034 return is_big_endian;
1055 template <
typename T>
1058 unsigned char number_of_bytes,
1070 const uint8_t* cur = bytes;
1075 const uint8_t* msb = cur;
1079 for (uint i = 1; i < number_of_bytes; ++i)
1080 res = (res << 8) | ((T)msb[i]);
1086 const uint8_t* lsb = cur;
1089 for (uint i = 1; i < number_of_bytes; ++i)
1090 res = res | (((T)lsb[i]) << i * 8);
1146 return fn_desc_address;
1149 return fn_desc_address;
1155 return fn_desc_address;
1157 GElf_Shdr header_mem;
1159 GElf_Shdr* opd_sheader = gelf_getshdr(opd_section, &header_mem);
1163 size_t fn_desc_offset = fn_desc_address - opd_sheader->sh_addr;
1164 Elf_Data* elf_data = elf_rawdata(opd_section, 0);
1168 if (elf_data->d_size <= fn_desc_offset + 8)
1169 return fn_desc_address;
1173 uint8_t* bytes = (uint8_t*)elf_data->d_buf;
1177 GElf_Addr result = 0;
1179 is_big_endian, result));
1194 return (
find_section(elf_handle,
".modinfo", SHT_PROGBITS)
1196 ".gnu.linkonce.this_module",
1211 "__ksymtab_strings",
1228 GElf_Ehdr elf_header;
1229 gelf_getehdr(elf_handle, &elf_header);
1230 size_t num_segments = elf_header.e_phnum;
1231 GElf_Phdr *program_header = NULL;
1233 bool found_loaded_segment =
false;
1236 for (
unsigned i = 0; i < num_segments; ++i)
1238 program_header = gelf_getphdr(elf_handle, i, &ph_mem);
1239 if (program_header && program_header->p_type == PT_LOAD)
1241 if (!found_loaded_segment)
1243 result = program_header->p_vaddr;
1244 found_loaded_segment =
true;
1247 if (program_header->p_vaddr < result)
1250 result = program_header->p_vaddr;
1254 if (found_loaded_segment)
1256 load_address = result;
1270 unsigned char word_size = 0;
1271 GElf_Ehdr elf_header;
1272 gelf_getehdr(elf_handle, &elf_header);
1273 if (elf_header.e_ident[EI_CLASS] == ELFCLASS32)
1275 else if (elf_header.e_ident[EI_CLASS] == ELFCLASS64)
1290 GElf_Ehdr elf_header;
1291 gelf_getehdr(elf_handle, &elf_header);
1292 return elf_header.e_type == ET_EXEC;
1303 GElf_Ehdr elf_header;
1304 gelf_getehdr(elf_handle, &elf_header);
1305 return elf_header.e_type == ET_DYN;
1328 Elf_Scn* symbol_section = elf_getscn(elf_handle, sym->st_shndx);
1329 GElf_Addr addr = sym->st_value;
1331 if (!symbol_section)
1334 GElf_Ehdr elf_header;
1335 if (!gelf_getehdr(elf_handle, &elf_header))
1338 if (elf_header.e_type != ET_REL)
1341 GElf_Shdr section_header;
1342 if (!gelf_getshdr(symbol_section, §ion_header))
1345 return addr + section_header.sh_addr;
1361 GElf_Shdr sheader_mem;
1362 GElf_Shdr* sheader = gelf_getshdr(section, &sheader_mem);
1364 if (sheader->sh_addr <= addr && addr <= sheader->sh_addr + sheader->sh_size)
1399 Elf64_Sxword data_tag,
1400 vector<string>& dt_tag_data)
1402 size_t num_prog_headers = 0;
1404 if (elf_getphdrnum(elf, &num_prog_headers) < 0)
1408 for (
size_t i = 0; i < num_prog_headers; ++i)
1411 GElf_Phdr *phdr = gelf_getphdr(elf, i, &phdr_mem);
1412 if (phdr == NULL || phdr->p_type != PT_DYNAMIC)
1422 Elf_Scn *dynamic_section = gelf_offscn(elf, phdr->p_offset);
1424 GElf_Shdr *dynamic_section_header = gelf_getshdr(dynamic_section,
1426 if (dynamic_section_header == NULL
1427 || dynamic_section_header->sh_type != SHT_DYNAMIC)
1431 Elf_Data *data = elf_getdata(dynamic_section, NULL);
1436 size_t string_table_index = 0;
1437 ABG_ASSERT (elf_getshdrstrndx(elf, &string_table_index) >= 0);
1439 size_t dynamic_section_header_entry_size = gelf_fsize(elf,
1445 gelf_getshdr(elf_getscn(elf,
1446 dynamic_section_header->sh_link),
1450 size_t num_dynamic_section_entries =
1451 dynamic_section_header->sh_size / dynamic_section_header_entry_size;
1455 for (
size_t j = 0; j < num_dynamic_section_entries; ++j)
1457 GElf_Dyn dynamic_section_mem;
1458 GElf_Dyn *dynamic_section = gelf_getdyn(data,
1460 &dynamic_section_mem);
1461 if (dynamic_section->d_tag == data_tag)
1463 dt_tag_data.push_back(elf_strptr(elf,
1464 dynamic_section_header->sh_link,
1465 dynamic_section->d_un.d_val));
1473 const Dwfl_Callbacks&
1474 initialize_dwfl_callbacks(Dwfl_Callbacks& cb,
1475 char** debug_info_root_path)
1477 cb.find_debuginfo = dwfl_standard_find_debuginfo;
1478 cb.section_address = dwfl_offline_section_address;
1479 cb.debuginfo_path = debug_info_root_path;
1484 create_new_dwfl_handle(Dwfl_Callbacks& cb)
1486 dwfl_sptr handle(dwfl_begin(&cb), dwfl_deleter());
1503 int fd = open(path.c_str(), O_RDONLY);
1507 elf_version (EV_CURRENT);
1508 Elf* elf = elf_begin (fd, ELF_C_READ_MMAP, NULL);
1511 GElf_Ehdr* ehdr = gelf_getehdr (elf, &ehdr_mem);
1515 for (
int i = 0; i < ehdr->e_phnum; ++i)
1518 GElf_Phdr* phdr = gelf_getphdr (elf, i, &phdr_mem);
1520 if (phdr != NULL && phdr->p_type == PT_DYNAMIC)
1522 Elf_Scn* scn = gelf_offscn (elf, phdr->p_offset);
1524 GElf_Shdr* shdr = gelf_getshdr (scn, &shdr_mem);
1525 if (!(shdr == NULL || (shdr->sh_type == SHT_DYNAMIC
1526 || shdr->sh_type == SHT_PROGBITS)))
1531 size_t entsize = (shdr != NULL && shdr->sh_entsize != 0
1533 : gelf_fsize (elf, ELF_T_DYN, 1, EV_CURRENT));
1534 int maxcnt = (shdr != NULL
1535 ? shdr->sh_size / entsize : INT_MAX);
1536 Elf_Data* data = elf_getdata (scn, NULL);
1540 for (
int cnt = 0; cnt < maxcnt; ++cnt)
1543 GElf_Dyn* dyn = gelf_getdyn (data, cnt, &dynmem);
1547 if (dyn->d_tag == DT_NULL)
1550 if (dyn->d_tag != DT_SONAME)
1553 soname = elf_strptr (elf, shdr->sh_link, dyn->d_un.d_val);
Elf_Scn * find_section_by_name(Elf *elf_handle, const std::string &name)
Find and return a section by its name.
bool get_crc_for_symbol(Elf *elf_handle, GElf_Sym *crc_symbol, uint32_t &crc_value)
Return the CRC from the "__crc_" symbol.
unsigned char get_architecture_word_size(Elf *elf_handle)
Return the size of a word for the current architecture.
bool get_version_definition_for_versym(Elf *elf_handle, GElf_Versym *versym, Elf_Scn *verdef_section, elf_symbol::version &version)
Get the version definition (from the SHT_GNU_verdef section) of a given symbol represented by a point...
bool lookup_data_tag_from_dynamic_segment(Elf *elf, Elf64_Sxword data_tag, vector< string > &dt_tag_data)
Get data tag information of an ELF file by looking up into its dynamic segment.
bool address_is_in_opd_section(Elf *elf_handle, Dwarf_Addr addr)
Return true if an address is in the ".opd" section that is present on the ppc64 platform.
bool architecture_is_arm64(Elf *elf_handle)
Test if the architecture of the current binary is arm64.
bool address_is_in_section(Dwarf_Addr addr, Elf_Scn *section)
Test if a given address is in a given section.
Elf_Scn * find_relocation_section(Elf *elf_handle, Elf_Scn *target_section)
Return the .rel{a,} section corresponding to a given section.
bool architecture_is_big_endian(Elf *elf_handle)
Test if the endianness of the current binary is Big Endian.
bool is_dso(Elf *elf_handle)
Test if the elf file being read is a dynamic shared / object.
bool architecture_is_ppc32(Elf *elf_handle)
Test if the architecture of the current binary is ppc32.
bool get_binary_load_address(Elf *elf_handle, GElf_Addr &load_address)
Get the address at which a given binary is loaded in memory.
GElf_Addr maybe_adjust_et_rel_sym_addr_to_abs_addr(Elf *elf_handle, GElf_Sym *sym)
Translate a section-relative symbol address (i.e, symbol value) into an absolute symbol address by ad...
bool get_version_needed_for_versym(Elf *elf_handle, GElf_Versym *versym, Elf_Scn *verneed_section, elf_symbol::version &version)
Get the version needed (from the SHT_GNU_verneed section) to resolve an undefined symbol represented ...
Elf_Scn * find_strtab_for_symtab_section(Elf *elf_handle, Elf_Scn *symtab_section)
Return the string table used by the given symbol table.
bool get_soname_of_elf_file(const string &path, string &soname)
Fetch the SONAME ELF property from an ELF binary file.
bool get_version_for_symbol(Elf *elf_handle, size_t symbol_index, bool get_def_version, elf_symbol::version &version)
Return the version for a symbol that is at a given index in its SHT_SYMTAB section.
elf_symbol::binding stb_to_elf_symbol_binding(unsigned char stb)
Convert an elf symbol binding (given by the ELF{32,64}_ST_BIND macros) into an elf_symbol::binding va...
Elf_Scn * find_ksymtab_gpl_section(Elf *elf_handle)
Return the __ksymtab_gpl section of a linux kernel ELF file (either a vmlinux binary or a kernel modu...
Elf_Scn * find_ksymtab_section(Elf *elf_handle)
Return the __ksymtab section of a linux kernel ELF file (either a vmlinux binary or a kernel module).
Elf_Scn * find_symtab_section(Elf *elf_handle)
Find and return the .symtab section.
std::string e_machine_to_string(GElf_Half e_machine)
Convert the value of the e_machine field of GElf_Ehdr into a string. This is to get a string represen...
Elf_Scn * find_text_section(Elf *elf_handle)
Find and return the .text section.
bool architecture_is_ppc64(Elf *elf_handle)
Test if the architecture of the current binary is ppc64.
Elf_Scn * find_rodata_section(Elf *elf_handle)
Find and return the .rodata section.
Elf_Scn * find_opd_section(Elf *elf_handle)
Return the "Official Procedure descriptors section." This section is named .opd, and is usually prese...
bool is_executable(Elf *elf_handle)
Test if the elf file being read is an executable.
bool read_int_from_array_of_bytes(const uint8_t *bytes, unsigned char number_of_bytes, bool is_big_endian, T &result)
Read N bytes and convert their value into an integer type T.
Elf_Scn * find_data1_section(Elf *elf_handle)
Find and return the .data1 section.
GElf_Addr lookup_ppc64_elf_fn_entry_point_address(Elf *elf_handle, GElf_Addr fn_desc_address)
Lookup the address of the function entry point that corresponds to the address of a given function de...
elf_symbol::visibility stv_to_elf_symbol_visibility(unsigned char stv)
Convert an ELF symbol visiblity given by the symbols ->st_other data member as returned by the GELF_S...
bool find_symbol_table_section_index(Elf *elf_handle, size_t &symtab_index)
Find the index (in the section headers table) of the symbol table section.
bool get_symbol_versionning_sections(Elf *elf_handle, Elf_Scn *&versym_section, Elf_Scn *&verdef_section, Elf_Scn *&verneed_section)
Return the SHT_GNU_versym, SHT_GNU_verdef and SHT_GNU_verneed sections that are involved in symbol ve...
Elf_Scn * find_bss_section(Elf *elf_handle)
Find and return the .bss section.
bool read_uint64_from_array_of_bytes(const uint8_t *bytes, bool is_big_endian, uint64_t &result)
Read 8 bytes and convert their value into an uint64_t.
Elf_Scn * find_dynsym_section(Elf *elf_handle)
Find and return the .symtab section.
Elf_Scn * find_section(Elf *elf_handle, const std::string &name, Elf64_Word section_type)
Find and return a section by its name and its type.
elf_symbol::type stt_to_elf_symbol_type(unsigned char stt)
Convert an elf symbol type (given by the ELF{32,64}_ST_TYPE macros) into an elf_symbol::type value.
bool architecture_is_arm32(Elf *elf_handle)
Test if the architecture of the current binary is arm32.
Elf_Scn * find_symbol_table_section(Elf *elf_handle)
Find the symbol table.
Elf_Scn * find_data_section(Elf *elf_handle)
Find and return the .data section.
bool is_linux_kernel_module(Elf *elf_handle)
Test if the ELF binary denoted by a given ELF handle is a Linux Kernel Module.
Elf_Scn * find_ksymtab_strings_section(Elf *elf_handle)
Find the __ksymtab_strings section of a Linux kernel binary.
bool is_linux_kernel(Elf *elf_handle)
Test if the ELF binary denoted by a given ELF handle is a Linux Kernel binary (either vmlinux or a ke...
hash_table_kind find_hash_table_section_index(Elf *elf_handle, size_t &ht_section_index, size_t &symtab_section_index)
Get the offset offset of the hash table section.
This contains a set of ELF utilities used by the dwarf reader.
#define ABG_ASSERT(cond)
This is a wrapper around the 'assert' glibc call. It allows for its argument to have side effects,...
The abstraction of the version of an ELF symbol.
bool is_default() const
Getter for the 'is_default' property of the version.
const string & str() const
Getter for the version name.
binding
The binding of a symbol.
type
The type of a symbol.
visibility
The visibility of the symbol.
Toplevel namespace for libabigail.