diff options
Diffstat (limited to 'plugins/elf/symbols.c')
-rw-r--r-- | plugins/elf/symbols.c | 891 |
1 files changed, 891 insertions, 0 deletions
diff --git a/plugins/elf/symbols.c b/plugins/elf/symbols.c new file mode 100644 index 0000000..292913b --- /dev/null +++ b/plugins/elf/symbols.c @@ -0,0 +1,891 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * symbols.c - gestion des symboles d'un ELF + * + * Copyright (C) 2009-2017 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "symbols.h" + + +#include <assert.h> +#include <malloc.h> +#include <string.h> + + +#include <i18n.h> +#include <arch/raw.h> +#include <common/extstr.h> +#include <core/global.h> +#include <core/params.h> +#include <format/mangling/demangler.h> +#include <gui/panels/log.h> + + +#include "dynamic.h" +#include "elf-int.h" +#include "helper_arm.h" +#include "loading.h" +#include "program.h" +#include "section.h" + + + + + + + + + + +/* Enregistre un point d'entrée au sein d'un binaire ELF. */ +static void register_elf_entry_point(GElfFormat *, virt_t, phys_t, GBinRoutine *); + +/* Enumère tous les points d'entrée principaux d'un binaire ELF. */ +static bool load_all_elf_basic_entry_points(GElfFormat *); + + + + + + + + + +/* -------------------------- DETAIL DES SYMBOLES INTERNES -------------------------- */ + + +/* Assure le chargement des symboles internes ELF en différé. */ +static bool do_elf_internal_symbol_loading(GElfLoading *, GElfFormat *, phys_t *); + +/* Charge tous les symboles internes possibles. */ +static bool load_elf_internal_symbols(GElfFormat *, wgroup_id_t, GtkStatusStack *); + + + +/* -------------------------- DETAIL DES SYMBOLES EXTERNES -------------------------- */ + + +/* Retrouve un élément donné dans la section dynamique. */ +static bool find_elf_dynamic_item(const GElfFormat *, const elf_shdr *, int32_t, elf_dyn *); + +/* Charge tous les éléments dynamiques externes possibles. */ +static bool load_elf_external_symbols(GElfFormat *, const elf_shdr *); + + + + + + + + + + + + + +/****************************************************************************** +* * +* Paramètres : format = description de l'exécutable à compléter. * + status = barre de statut à tenir informée. * +* * +* Description : Charge en mémoire la liste humaine des symboles. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool load_elf_symbols(GElfFormat *format, GtkStatusStack *status) +{ + bool result; /* Bilan à retourner */ + wgroup_id_t gid; /* Identifiant pour les tâches */ + + elf_shdr *sections; /* Groupe de sections trouvées */ + size_t count; /* Quantité de données */ + + result = true; + + gid = g_work_queue_define_work_group(get_work_queue()); + + /* Symboles internes */ + + result &= load_elf_internal_symbols(format, gid, status); + + + + + /* Symboles externes */ + + if (find_elf_sections_by_type(format, SHT_DYNAMIC, §ions, &count)) + { + log_variadic_message(LMT_INFO, _("Binary is dynamically linked")); + + result &= load_elf_external_symbols(format, §ions[0]); + + free(sections); + + } + else log_variadic_message(LMT_INFO, _("Binary is statically linked")); + + + + + /* Symboles d'entrée, si encore besoin */ + + /** + * Le tri en préalable + */ + + + + + + result &= load_all_elf_basic_entry_points(format); + + return result; + +} + + + + + +/****************************************************************************** +* * +* Paramètres : format = description de l'exécutable à compléter. * +* vaddr = adresse virtuelle du symbole à insérer. * +* len = taille de la routine à ajouter. * +* routine = représentation de la fonction repérée. * +* * +* Description : Enregistre un point d'entrée au sein d'un binaire ELF. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void register_elf_entry_point(GElfFormat *format, virt_t vaddr, phys_t len, GBinRoutine *routine) +{ + GBinFormat *base; /* Version basique du format */ + virt_t final_vaddr; /* Adresse virtuelle retenue */ + bool status; /* Bilan d'une opération */ + vmpa2t addr; /* Localisation d'une routine */ + mrange_t range; /* Couverture mémoire associée */ + GBinSymbol *symbol; /* Nouveau symbole construit */ + + /* Localisation complète du symbole */ + + if (ELF_HDR(format, format->header, e_machine) == EM_ARM) + final_vaddr = vaddr & ~0x1; + else + final_vaddr = vaddr; + + status = g_exe_format_translate_address_into_vmpa(G_EXE_FORMAT(format), final_vaddr, &addr); + if (!status) return; + + /* Comptabilisation en tant que symbole */ + + if (g_binary_format_find_symbol_at(G_BIN_FORMAT(format), &addr, &symbol)) + g_object_unref(G_OBJECT(routine)); + + else + { + base = G_BIN_FORMAT(format); + + init_mrange(&range, &addr, len); + + symbol = G_BIN_SYMBOL(routine); + + g_binary_symbol_set_range(symbol, &range); + g_binary_symbol_set_target_type(symbol, STP_ENTRY_POINT); + + g_binary_format_add_symbol(base, symbol); + + /* Comptabilisation pour le désassemblage brut */ + g_binary_format_register_code_point(base, vaddr, true); + + } + +} + + +/****************************************************************************** +* * +* Paramètres : format = description de l'exécutable à consulter. * +* * +* Description : Enumère tous les points d'entrée principaux d'un binaire ELF.* +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool load_all_elf_basic_entry_points(GElfFormat *format) +{ + virt_t ep; /* Point d'entrée détecté */ + GBinRoutine *routine; /* Routine à associer à un pt. */ + elf_phdr dynamic; /* En-tête de programme DYNAMIC*/ + elf_dyn item_a; /* Premier élément DYNAMIC */ + elf_dyn item_b; /* Second élément DYNAMIC */ + const GBinContent *content; /* Contenu binaire à lire */ + phys_t length; /* Taille totale du contenu */ + bool status; /* Bilan d'une opération */ + vmpa2t pos; /* Tête de lecture courante */ + uint32_t virt_32; /* Adresse virtuelle sur 32b */ + uint64_t virt_64; /* Adresse virtuelle sur 64b */ + + /* Point d'entrée principal éventuel */ + + ep = ELF_HDR(format, format->header, e_entry); + + if (ep != 0x0) + { + routine = try_to_demangle_routine("entry_point"); + register_elf_entry_point(format, ep, 0, routine); + } + + /* Chargemet de l'en-tête de programme DYNAMIC */ + + if (!find_elf_dynamic_program_header(format, &dynamic)) + goto laebep_exit; + + /* Détection des constructeurs & destructeurs */ + + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_INIT, &item_a)) + { + ep = ELF_DYN(format, item_a, d_un.d_ptr); + + if (ep != 0x0) + { + routine = try_to_demangle_routine("init_function"); + register_elf_entry_point(format, ep, 0, routine); + } + + } + + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_FINI, &item_a)) + { + ep = ELF_DYN(format, item_a, d_un.d_ptr); + + if (ep != 0x0) + { + routine = try_to_demangle_routine("termination_function"); + register_elf_entry_point(format, ep, 0, routine); + } + + } + + void load_entry_points_from_array(GElfFormat *fmt, const elf_dyn *ar, const elf_dyn *sz, const char *prefix) + { + unsigned int i; /* Boucle de parcours */ + char fullname[64]; /* Désignation humaine */ + + assert(sizeof(fullname) >= (strlen(prefix) + sizeof(XSTR(UINT64_MAX) + 1))); + + content = G_BIN_FORMAT(fmt)->content; + + status = g_exe_format_translate_address_into_vmpa(G_EXE_FORMAT(format), + ELF_DYN(fmt, *ar, d_un.d_val), + &pos); + if (!status) return; + + length = get_phy_addr(&pos) + ELF_DYN(fmt, *sz, d_un.d_val); + + for (i = 0; get_phy_addr(&pos) < length; i++) + { + /** + * Selon la libc d'Android (https://www.codeaurora.org/.../android/bionic/linker/README.TXT) : + * + * DT_INIT_ARRAY + * Points to an array of function addresses that must be + * called, in-order, to perform initialization. Some of + * the entries in the array can be 0 or -1, and should + * be ignored. + * + * On étend le principe aux sections DT_FINI_ARRAY et DT_PREINIT_ARRAY. + */ + + if (fmt->is_32b) + { + status = g_binary_content_read_u32(content, &pos, fmt->endian, &virt_32); + status &= (virt_32 != 0x0 && virt_32 != 0xffffffff); + ep = virt_32; + } + else + { + status = g_binary_content_read_u64(content, &pos, fmt->endian, &virt_64); + status &= (virt_64 != 0x0 && virt_64 != 0xffffffffffffffff); + ep = virt_64; + } + + if (!status) break; + + snprintf(fullname, sizeof(fullname), "%s%u", prefix, i); + + routine = try_to_demangle_routine(fullname); + register_elf_entry_point(fmt, ep, 0, routine); + + } + + } + + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_INIT_ARRAY, &item_a)) + { + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_INIT_ARRAYSZ, &item_b)) + { + load_entry_points_from_array(format, &item_a, &item_b, "init_array_function_"); + } + + } + + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_FINI_ARRAY, &item_a)) + { + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_FINI_ARRAYSZ, &item_b)) + { + load_entry_points_from_array(format, &item_a, &item_b, "fini_array_function_"); + } + + } + + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_PREINIT_ARRAY, &item_a)) + { + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_PREINIT_ARRAYSZ, &item_b)) + { + load_entry_points_from_array(format, &item_a, &item_b, "preinit_array_function_"); + } + + } + + /* Identification de l'entrée de la PLT */ + + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_PLTGOT, &item_a)) + { + status = g_exe_format_translate_address_into_vmpa(G_EXE_FORMAT(format), + ELF_DYN(format, item_a, d_un.d_val), + &pos); + + if (status) + { + content = G_BIN_FORMAT(format)->content; + + /* On saute le premier élément... */ + if (format->is_32b) + status = g_binary_content_read_u32(content, &pos, format->endian, &virt_32); + else + status = g_binary_content_read_u64(content, &pos, format->endian, &virt_64); + + while (1) + { + if (format->is_32b) + { + status = g_binary_content_read_u32(content, &pos, format->endian, &virt_32); + ep = virt_32; + } + else + { + status = g_binary_content_read_u64(content, &pos, format->endian, &virt_64); + ep = virt_64; + } + + if (!status) break; + + if (ep != 0x0) + { + routine = try_to_demangle_routine("plt_entry"); + register_elf_entry_point(format, ep, 0, routine); + break; + } + + } + + } + + } + + laebep_exit: + + return true; + +} + + + + + + + + + +/****************************************************************************** +* * +* Paramètres : format = description de l'exécutable à consulter. * +* sym = section comprenant les symboles à venir lire. * +* index = indice de l'entrée à venir lire. * +* symbol = ensemble d'informations lues. [OUT] * +* * +* Description : Récupère la définition complète d'un symbole donné. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool get_elf_symbol_by_index(GElfFormat *format, const elf_shdr *sym, off_t index, elf_sym *symbol) +{ + phys_t sym_start; /* Début de section */ + phys_t sym_size; /* Taille de section */ + phys_t offset; /* Emplacement à venir lire */ + + get_elf_section_content(format, sym, &sym_start, &sym_size, NULL); + + offset = sym_start + index * ELF_SIZEOF_SYM(format); + if ((offset + ELF_SIZEOF_SYM(format)) > (sym_start + sym_size)) return NULL; + + return read_elf_symbol(format, &offset, symbol); + +} + + +/****************************************************************************** +* * +* Paramètres : format = description de l'exécutable à consulter. * +* sym = section comprenant les symboles à venir lire. * +* str = section de chaînes de caractères pour les noms. * +* index = indice de l'entrée à venir lire. * +* * +* Description : Récupère la désignation d'un symbole donné. * +* * +* Retour : Nom du symbole trouvé, ou NULL si erreur ou non adapté. * +* * +* Remarques : - * +* * +******************************************************************************/ + +const char *get_elf_symbol_name(GElfFormat *format, const elf_shdr *sym, const elf_shdr *str, off_t index) +{ + const char *result; /* Résultat à retourner */ + elf_sym symbol; /* Symbole aux infos visées */ + + result = NULL; + + if (get_elf_symbol_by_index(format, sym, index, &symbol)) + result = extract_name_from_elf_string_section(format, str, ELF_SYM(format, symbol, st_name)); + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* DETAIL DES SYMBOLES INTERNES */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : loading = chargement de symboles internes en cours. * +* format = format ELF à compléter. * +* iter = tête de lecture évoluant avec le temps. [OUT] * +* * +* Description : Assure le chargement des symboles internes ELF en différé. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool do_elf_internal_symbol_loading(GElfLoading *loading, GElfFormat *format, phys_t *iter) +{ + bool result; /* Bilan à retourner */ + elf_sym sym; /* Symbole aux infos visées */ + virt_t virt; /* Adresse virtuelle */ + const elf_shdr *section; /* Groupe de sections trouvées */ + bool use_virt; /* Choix de construction de nom*/ + const elf_shdr *strtab; /* Section .strtab trouvée */ + bool has_strtab; /* Présence de cette section */ + phys_t first; /* Position du premier élément */ + const char *name; /* Nom du symbole trouvé */ + GBinFormat *base; /* Version basique du format */ + vmpa2t addr; /* Localisation d'une routine */ + GBinSymbol *symbol; /* Nouveau symbole construit */ + char alt_name[6 + VMPA_MAX_LEN]; /* Nom abstrait de substitution*/ + virt_t final_virt; /* Adresse virtuelle retenue */ + mrange_t range; /* Couverture mémoire associée */ + GBinRoutine *routine; /* Nouvelle routine trouvée */ + + result = read_elf_symbol(format, iter, &sym); + if (!result) goto geslp_done; + + /* On rejette les symboles qui ne sont pas définis au sein du binaire */ + + if (ELF_SYM(format, sym, st_shndx) == 0) goto geslp_done; + + /* Résolution précise d'adresse */ + + virt = ELF_SYM(format, sym, st_value); + if (virt == 0) goto geslp_done; + + + /* TODO */ + + //init_vmpa(&addr, VMPA_NO_PHYSICAL, ELF_SYM(format, sym, st_value)); + + + //init_mrange(&range, &addr, 0); + + + /* Première ébauche de nom */ + + g_elf_loading_get_internal_info(loading, §ion, &use_virt, &strtab, &has_strtab, &first); + + if (!has_strtab) + name = NULL; + + else + name = get_elf_symbol_name(format, section, strtab, + ((*iter - first) / ELF_SIZEOF_SYM(format)) - 1); + + /* Traitements particuliers */ + + base = G_BIN_FORMAT(format); + + switch (ELF_ST_TYPE(format, sym)) + { + case STT_OBJECT: + + /* Ajustement de la position */ + + if (!g_exe_format_translate_address_into_vmpa(G_EXE_FORMAT(format), virt, &addr)) + { + symbol = NULL; + break; + } + + /* Création d'un nom unique ? */ + + if (name == NULL) + { + strcpy(alt_name, "obj_"); + + if (use_virt) + vmpa2_virt_to_string(&addr, MDS_UNDEFINED, alt_name + 4, NULL); + else + vmpa2_phys_to_string(&addr, MDS_UNDEFINED, alt_name + 4, NULL); + + name = alt_name; + + } + + + /* TODO */ + + symbol = NULL; + + + break; + + case STT_FUNC: + + /* Ajustement de la position */ + + if (ELF_HDR(format, format->header, e_machine) == EM_ARM) + final_virt = virt & ~0x1; + else + final_virt = virt; + + if (!g_exe_format_translate_address_into_vmpa(G_EXE_FORMAT(format), final_virt, &addr)) + { + symbol = NULL; + break; + } + + init_mrange(&range, &addr, ELF_SYM(format, sym, st_size)); + + /* Création d'un nom unique ? */ + + if (name == NULL) + { + strcpy(alt_name, "func_"); + + if (use_virt) + vmpa2_virt_to_string(&addr, MDS_UNDEFINED, alt_name + 5, NULL); + else + vmpa2_phys_to_string(&addr, MDS_UNDEFINED, alt_name + 5, NULL); + + name = alt_name; + + } + + /* Routine */ + + routine = try_to_demangle_routine(name); + symbol = G_BIN_SYMBOL(routine); + + g_binary_symbol_set_range(symbol, &range); + + /* Comptabilisation pour le désassemblage brut */ + + g_binary_format_register_code_point(G_BIN_FORMAT(format), virt, false); + + break; + + default: + symbol = NULL; + break; + + } + + if (symbol != NULL) + g_binary_format_add_symbol(base, symbol); + + geslp_done: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : format = description de l'exécutable à compléter. * +* gid = groupe de travail impliqué. * + status = barre de statut à tenir informée. * +* * +* Description : Charge tous les symboles internes possibles. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool load_elf_internal_symbols(GElfFormat *format, wgroup_id_t gid, GtkStatusStack *status) +{ + bool result; /* Bilan à retourner */ + bool no_name; /* Choix de construction de nom*/ + activity_id_t msg; /* Message de progression */ + GWorkQueue *queue; /* Gestionnaire de différés */ + elf_shdr *dynsym_sections; /* Groupe de sections trouvées */ + size_t count; /* Quantité de données */ + elf_shdr *symtab_sections; /* Groupe de sections trouvées */ + size_t i; /* Boucle de parcours */ + + result = true; + + /* Charge tous les symboles définis dans une section */ + void add_all_symbols_from_section(const elf_shdr *section, bool use_virt, GWorkQueue *wq, activity_id_t id) + { + phys_t start; /* Début de la zone à traiter */ + phys_t size; /* Taille de cette même zone */ + phys_t sym_size; /* Taille de chaque symbole lu */ + guint runs_count; /* Qté d'exécutions parallèles */ + phys_t run_size; /* Volume réparti par exécution*/ + guint i; /* Boucle de parcours */ + phys_t begin; /* Début de zone de traitement */ + phys_t end; /* Fin d'un zone de traitement */ + GElfLoading *loading; /* Tâche de chargement à lancer*/ + + get_elf_section_content(format, section, &start, &size, NULL); + + sym_size = ELF_SIZEOF_SYM(format); + + runs_count = g_get_num_processors(); + + run_size = size / (sym_size * runs_count); + + gtk_status_stack_extend_activity(status, id, size / sym_size); + + for (i = 0; i < runs_count; i++) + { + begin = start + i * run_size * sym_size; + + if ((i + 1) == runs_count) + end = start + size; + else + end = begin + run_size * sym_size; + + loading = g_elf_loading_new(format, section, use_virt, start, begin, end, + id, do_elf_internal_symbol_loading); + + g_work_queue_schedule_work(wq, G_DELAYED_WORK(loading), gid); + + } + + } + + if (!g_generic_config_get_value(get_main_configuration(), MPK_FORMAT_NO_NAME, &no_name)) + return false; + + msg = gtk_status_stack_add_activity(status, _("Loading internal symbols..."), 0); + + queue = get_work_queue(); + + if (find_elf_sections_by_type(format, SHT_DYNSYM, &dynsym_sections, &count)) + for (i = 0; i < count; i++) + add_all_symbols_from_section(&dynsym_sections[i], no_name, queue, msg); + + if (find_elf_sections_by_type(format, SHT_SYMTAB, &symtab_sections, &count)) + for (i = 0; i < count; i++) + add_all_symbols_from_section(&symtab_sections[i], no_name, queue, msg); + + g_work_queue_wait_for_completion(queue, gid); + + gtk_status_stack_remove_activity(status, msg); + + if (dynsym_sections != NULL) free(dynsym_sections); + if (symtab_sections != NULL) free(symtab_sections); + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* DETAIL DES SYMBOLES EXTERNES */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : format = informations chargées à consulter. * +* dynamic = section de type SHT_DYNAMIC. * +* type = sorte d'élément recherché. * +* item = élément retrouvé dans la section. [OUT] * +* * +* Description : Retrouve un élément donné dans la section dynamique. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool find_elf_dynamic_item(const GElfFormat *format, const elf_shdr *section, int32_t type, elf_dyn *item) +{ + bool result; /* Bilan à retourner */ + const GBinContent *content; /* Contenu binaire à lire */ + phys_t pos; /* Position de lecture */ + vmpa2t tmp; /* Position écrasable */ + int32_t tag32; /* Type de l'entrée (32 bits) */ + int64_t tag64; /* Type de l'entrée (64 bits) */ + + result = true; + + content = G_BIN_FORMAT(format)->content; + + for (pos = ELF_SHDR(format, *section, sh_offset); + result; + pos += ELF_SIZEOF_DYN(format)) + { + init_vmpa(&tmp, pos, VMPA_NO_VIRTUAL); + + if (format->is_32b) + { + result = g_binary_content_read_s32(content, &tmp, format->endian, &tag32); + if (tag32 == type) break; + } + else + { + result = g_binary_content_read_s64(content, &tmp, format->endian, &tag64); + if (tag64 == type) break; + } + + } + + if (result) + { + init_vmpa(&tmp, pos, VMPA_NO_VIRTUAL); + + if (format->is_32b) + { + result = g_binary_content_read_s32(content, &tmp, format->endian, &item->dyn32.d_tag); + result &= g_binary_content_read_s32(content, &tmp, format->endian, &item->dyn32.d_un.d_val); + } + else + { + result = g_binary_content_read_s64(content, &tmp, format->endian, &item->dyn64.d_tag); + result &= g_binary_content_read_s64(content, &tmp, format->endian, &item->dyn64.d_un.d_val); + } + + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : format = informations chargées à consulter. * +* dynamic = section de type SHT_DYNAMIC. * +* * +* Description : Charge tous les éléments dynamiques externes possibles. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool load_elf_external_symbols(GElfFormat *format, const elf_shdr *section) +{ + bool result; /* Bilan à retourner */ + elf_dyn item; /* Elément dynamique */ + elf_shdr relxxx; /* Section .rel.xxx trouvée */ + elf_shdr dynsym; /* Section .dynsym trouvée */ + elf_shdr dynstr; /* Section .dynstr trouvée */ + + result = true; + + /* Section .rel.plt */ + if (find_elf_dynamic_item(format, section, DT_JMPREL, &item)) + { + result &= find_elf_section_by_virtual_address(format, ELF_DYN(format, item, d_un.d_ptr), &relxxx); + + if (result) + result = find_elf_section_by_index(format, ELF_SHDR(format, relxxx, sh_link), &dynsym); + + if (result) + result = find_elf_section_by_index(format, ELF_SHDR(format, dynsym, sh_link), &dynstr); + + if (result) + switch (ELF_HDR(format, format->header, e_machine)) + { + case EM_ARM: + result = load_elf_arm_relocated_symbols(format, &relxxx, &dynsym, &dynstr); + break; + + default: + break; + + } + + } + + return result; + +} |