Used real virtual addresses when describing ELF items.

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@496 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

6 files changed, 130 insertions, 65 deletions

diff --git a/src/format/elf/elf.c b/src/format/elf/elf.c
index f188734..bf5a7a2 100644
--- a/src/format/elf/elf.c
+++ b/src/format/elf/elf.c
@@ -57,17 +57,23 @@ static void g_elf_format_class_init(GElfFormatClass *);
 /* Initialise une instance de format d'exécutable ELF. */
 static void g_elf_format_init(GElfFormat *);
 
+/* Supprime toutes les références externes. */
+static void g_elf_format_dispose(GElfFormat *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_elf_format_finalize(GElfFormat *);
+
 /* Indique le type d'architecture visée par le format. */
 static const char *g_elf_format_get_target_machine(const GElfFormat *);
 
 /* Etend la définition des portions au sein d'un binaire. */
 static void g_elf_format_refine_portions(const GElfFormat *, GBinPortion *);
 
-/* Fournit la position correspondant à une adresse virtuelle. */
-static bool g_elf_format_translate_address_into_offset(const GElfFormat *, vmpa_t, off_t *);
+/* Fournit l'emplacement correspondant à une position physique. */
+static bool g_elf_format_translate_offset_into_vmpa(const GElfFormat *, phys_t, vmpa2t *);
 
-/* Fournit l'adresse virtuelle correspondant à une position. */
-static bool g_elf_format_translate_offset_into_address(const GElfFormat *, off_t, vmpa_t *);
+/* Fournit l'emplacement correspondant à une position physique. */
+static bool g_elf_format_translate_address_into_vmpa(const GElfFormat *, virt_t, vmpa2t *);
 
 
 
@@ -118,6 +124,18 @@ G_DEFINE_TYPE(GElfFormat, g_elf_format, G_TYPE_EXE_FORMAT);
 
 static void g_elf_format_class_init(GElfFormatClass *klass)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GExeFormatClass *exe;                   /* Version en exécutable       */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_elf_format_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_elf_format_finalize;
+
+    exe = G_EXE_FORMAT_CLASS(klass);
+
+    exe->translate_phys = (translate_phys_fc)g_elf_format_translate_offset_into_vmpa;
+    exe->translate_virt = (translate_virt_fc)g_elf_format_translate_address_into_vmpa;
 
 }
 
@@ -143,8 +161,43 @@ static void g_elf_format_init(GElfFormat *format)
     exe_format->get_machine = (get_target_machine_fc)g_elf_format_get_target_machine;
     exe_format->refine_portions = (refine_portions_fc)g_elf_format_refine_portions;
 
-    exe_format->translate_addr = (translate_addr_fc)g_elf_format_translate_address_into_offset;
-    exe_format->translate_off = (translate_off_fc)g_elf_format_translate_offset_into_address;
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = instance d'objet GLib à traiter.                    *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_elf_format_dispose(GElfFormat *format)
+{
+    G_OBJECT_CLASS(g_elf_format_parent_class)->dispose(G_OBJECT(format));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = instance d'objet GLib à traiter.                    *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_elf_format_finalize(GElfFormat *format)
+{
+    G_OBJECT_CLASS(g_elf_format_parent_class)->finalize(G_OBJECT(format));
 
 }
 
@@ -393,11 +446,11 @@ static void g_elf_format_refine_portions(const GElfFormat *format, GBinPortion *
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : format  = description de l'exécutable à consulter.           *
-*                addr    = adresse virtuelle à retrouver.                     *
-*                pos     = position correspondante. [OUT]                     *
+*  Paramètres  : format = description de l'exécutable à consulter.            *
+*                off    = position physique à retrouver.                      *
+*                pos    = position correspondante. [OUT]                      *
 *                                                                             *
-*  Description : Fournit la position correspondant à une adresse virtuelle.   *
+*  Description : Fournit l'emplacement correspondant à une position physique. *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -405,14 +458,14 @@ static void g_elf_format_refine_portions(const GElfFormat *format, GBinPortion *
 *                                                                             *
 ******************************************************************************/
 
-static bool g_elf_format_translate_address_into_offset(const GElfFormat *format, vmpa_t addr, off_t *pos)
+static bool g_elf_format_translate_offset_into_vmpa(const GElfFormat *format, phys_t off, vmpa2t *pos)
 {
     bool result;                            /* Bilan à retourner           */
 
-    result = translate_address_into_offset_using_elf_sections(format, addr, pos);
+    result = translate_offset_into_vmpa_using_elf_sections(format, off, pos);
 
     if (!result)
-        result = translate_address_into_offset_using_elf_programs(format, addr, pos);
+        result = translate_offset_into_vmpa_using_elf_programs(format, off, pos);
 
     return result;
 
@@ -421,11 +474,11 @@ static bool g_elf_format_translate_address_into_offset(const GElfFormat *format,
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : format  = description de l'exécutable à consulter.           *
-*                pos     = position dans le flux binaire à retrouver.         *
-*                addr    = adresse virtuelle correspondante. [OUT]            *
+*  Paramètres  : format = description de l'exécutable à consulter.            *
+*                addr   = adresse virtuelle à retrouver.                      *
+*                pos    = position correspondante. [OUT]                      *
 *                                                                             *
-*  Description : Fournit l'adresse virtuelle correspondant à une position.    *
+*  Description : Fournit l'emplacement correspondant à une adresse virtuelle. *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -433,14 +486,14 @@ static bool g_elf_format_translate_address_into_offset(const GElfFormat *format,
 *                                                                             *
 ******************************************************************************/
 
-static bool g_elf_format_translate_offset_into_address(const GElfFormat *format, off_t pos, vmpa_t *addr)
+static bool g_elf_format_translate_address_into_vmpa(const GElfFormat *format, virt_t addr, vmpa2t *pos)
 {
     bool result;                            /* Bilan à retourner           */
 
-    result = translate_offset_into_address_using_elf_sections(format, pos, addr);
+    result = translate_address_into_vmpa_using_elf_sections(format, addr, pos);
 
     if (!result)
-        /* TODO : prgm... */;
+        result = translate_address_into_vmpa_using_elf_programs(format, addr, pos);
 
     return result;
 
diff --git a/src/format/elf/program.c b/src/format/elf/program.c
index 95afd31..47293bd 100644
--- a/src/format/elf/program.c
+++ b/src/format/elf/program.c
@@ -107,11 +107,11 @@ bool find_elf_program_by_index(const GElfFormat *format, uint16_t index, elf_phd
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : format  = description de l'exécutable à consulter.           *
-*                addr    = adresse virtuelle à retrouver.                     *
-*                pos     = position correspondante. [OUT]                     *
+*  Paramètres  : format = description de l'exécutable à consulter.            *
+*                off    = position physique à retrouver.                      *
+*                pos    = position correspondante. [OUT]                      *
 *                                                                             *
-*  Description : Fournit la position correspondant à une adresse virtuelle.   *
+*  Description : Fournit l'emplacement correspondant à une position physique. *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -119,11 +119,12 @@ bool find_elf_program_by_index(const GElfFormat *format, uint16_t index, elf_phd
 *                                                                             *
 ******************************************************************************/
 
-bool translate_address_into_offset_using_elf_programs(const GElfFormat *format, vmpa_t addr, off_t *pos)
+bool translate_offset_into_vmpa_using_elf_programs(const GElfFormat *format, phys_t off, vmpa2t *pos)
 {
     bool result;                            /* Bilan à retourner           */
     uint16_t i;                             /* Boucle de parcours          */
     elf_phdr program;                       /* Programme à analyser        */
+    virt_t addr;                            /* Adresse virtuelle calculée  */
 
     result = false;
 
@@ -131,10 +132,11 @@ bool translate_address_into_offset_using_elf_programs(const GElfFormat *format,
     {
         find_elf_program_by_index(format, i, &program);
 
-        if (ELF_PHDR(format, program, p_vaddr) <= addr
-            && addr < (ELF_PHDR(format, program, p_vaddr) + ELF_PHDR(format, program, p_filesz)))
+        if (ELF_PHDR(format, program, p_offset) <= off
+            && off < (ELF_PHDR(format, program, p_offset) + ELF_PHDR(format, program, p_filesz)))
         {
-            *pos = ELF_PHDR(format, program, p_offset) + addr - ELF_PHDR(format, program, p_vaddr);
+            addr = ELF_PHDR(format, program, p_vaddr) + ELF_PHDR(format, program, p_offset) - off;
+            init_vmpa(pos, off, addr);
             result = true;
         }
 
@@ -147,11 +149,11 @@ bool translate_address_into_offset_using_elf_programs(const GElfFormat *format,
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : format  = description de l'exécutable à consulter.           *
-*                addr    = adresse virtuelle à retrouver.                     *
-*                pos     = position correspondante. [OUT]                     *
+*  Paramètres  : format = description de l'exécutable à consulter.            *
+*                addr   = adresse virtuelle à retrouver.                      *
+*                pos    = position correspondante. [OUT]                      *
 *                                                                             *
-*  Description : Fournit l'emplacement correspondant à une position physique. *
+*  Description : Fournit l'emplacement correspondant à une adresse virtuelle. *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -159,12 +161,12 @@ bool translate_address_into_offset_using_elf_programs(const GElfFormat *format,
 *                                                                             *
 ******************************************************************************/
 
-bool translate_offset_into_vmpa_using_elf_programs(const GElfFormat *format, phys_t off, vmpa2t *addr)
+bool translate_address_into_vmpa_using_elf_programs(const GElfFormat *format, virt_t addr, vmpa2t *pos)
 {
     bool result;                            /* Bilan à retourner           */
     uint16_t i;                             /* Boucle de parcours          */
     elf_phdr program;                       /* Programme à analyser        */
-    virt_t virt;                            /* Adresse virtuelle calculée  */
+    phys_t off;                             /* Position physique calculée  */
 
     result = false;
 
@@ -172,11 +174,11 @@ bool translate_offset_into_vmpa_using_elf_programs(const GElfFormat *format, phy
     {
         find_elf_program_by_index(format, i, &program);
 
-        if (ELF_PHDR(format, program, p_offset) <= off
-            && off < (ELF_PHDR(format, program, p_offset) + ELF_PHDR(format, program, p_filesz)))
+        if (ELF_PHDR(format, program, p_vaddr) <= addr
+            && addr < (ELF_PHDR(format, program, p_vaddr) + ELF_PHDR(format, program, p_filesz)))
         {
-            virt = ELF_PHDR(format, program, p_vaddr) + ELF_PHDR(format, program, p_offset) - off;
-            init_vmpa(addr, off, virt);
+            off = ELF_PHDR(format, program, p_offset) + addr - ELF_PHDR(format, program, p_vaddr);
+            init_vmpa(pos, off, addr);
             result = true;
         }
 
diff --git a/src/format/elf/program.h b/src/format/elf/program.h
index f2f724f..fb399ba 100644
--- a/src/format/elf/program.h
+++ b/src/format/elf/program.h
@@ -36,12 +36,12 @@ const char *get_elf_program_type_desc(uint32_t);
 /* Recherche un programme donné au sein de binaire par indice. */
 bool find_elf_program_by_index(const GElfFormat *, uint16_t, elf_phdr *);
 
-/* Fournit la position correspondant à une adresse virtuelle. */
-bool translate_address_into_offset_using_elf_programs(const GElfFormat *, vmpa_t, off_t *);
-
 /* Fournit l'emplacement correspondant à une position physique. */
 bool translate_offset_into_vmpa_using_elf_programs(const GElfFormat *, phys_t, vmpa2t *);
 
+/* Fournit l'emplacement correspondant à une adresse virtuelle. */
+bool translate_address_into_vmpa_using_elf_programs(const GElfFormat *, virt_t, vmpa2t *);
+
 
 
 #endif  /* _FORMAT_ELF_PROGRAM_H */
diff --git a/src/format/elf/section.c b/src/format/elf/section.c
index 36fca4d..3feb869 100644
--- a/src/format/elf/section.c
+++ b/src/format/elf/section.c
@@ -280,11 +280,11 @@ const char *extract_name_from_elf_string_section(const GElfFormat *format, const
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : format  = description de l'exécutable à consulter.           *
-*                addr    = adresse virtuelle à retrouver.                     *
-*                pos     = position correspondante. [OUT]                     *
+*  Paramètres  : format = description de l'exécutable à consulter.            *
+*                off    = position physique à retrouver.                      *
+*                pos    = position correspondante. [OUT]                      *
 *                                                                             *
-*  Description : Fournit la position correspondant à une adresse virtuelle.   *
+*  Description : Fournit l'emplacement correspondant à une position physique. *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -292,11 +292,12 @@ const char *extract_name_from_elf_string_section(const GElfFormat *format, const
 *                                                                             *
 ******************************************************************************/
 
-bool translate_address_into_offset_using_elf_sections(const GElfFormat *format, vmpa_t addr, off_t *pos)
+bool translate_offset_into_vmpa_using_elf_sections(const GElfFormat *format, phys_t off, vmpa2t *pos)
 {
     bool result;                            /* Bilan à retourner           */
     uint16_t i;                             /* Boucle de parcours          */
     elf_shdr section;                       /* Section à analyser          */
+    virt_t addr;                            /* Adresse virtuelle calculée  */
 
     result = false;
 
@@ -304,10 +305,11 @@ bool translate_address_into_offset_using_elf_sections(const GElfFormat *format,
     {
         find_elf_section_by_index(format, i, &section);
 
-        if (ELF_SHDR(format, section, sh_addr) <= addr
-            && addr < (ELF_SHDR(format, section, sh_addr) + ELF_SHDR(format, section, sh_size)))
+        if (ELF_SHDR(format, section, sh_offset) <= off
+            && off < (ELF_SHDR(format, section, sh_offset) + ELF_SHDR(format, section, sh_size)))
         {
-            *pos = ELF_SHDR(format, section, sh_offset) + addr - ELF_SHDR(format, section, sh_addr);
+            addr = ELF_SHDR(format, section, sh_addr) + off - ELF_SHDR(format, section, sh_offset);
+            init_vmpa(pos, off, addr);
             result = true;
         }
 
@@ -320,11 +322,11 @@ bool translate_address_into_offset_using_elf_sections(const GElfFormat *format,
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : format  = description de l'exécutable à consulter.           *
-*                pos     = position dans le flux binaire à retrouver.         *
-*                addr    = adresse virtuelle correspondante. [OUT]            *
+*  Paramètres  : format = description de l'exécutable à consulter.            *
+*                addr   = adresse virtuelle à retrouver.                      *
+*                pos    = position correspondante. [OUT]                      *
 *                                                                             *
-*  Description : Fournit l'adresse virtuelle correspondant à une position.    *
+*  Description : Fournit l'emplacement correspondant à une adresse virtuelle. *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -332,11 +334,12 @@ bool translate_address_into_offset_using_elf_sections(const GElfFormat *format,
 *                                                                             *
 ******************************************************************************/
 
-bool translate_offset_into_address_using_elf_sections(const GElfFormat *format, off_t pos, vmpa_t *addr)
+bool translate_address_into_vmpa_using_elf_sections(const GElfFormat *format, virt_t addr, vmpa2t *pos)
 {
     bool result;                            /* Bilan à retourner           */
     uint16_t i;                             /* Boucle de parcours          */
     elf_shdr section;                       /* Section à analyser          */
+    phys_t off;                             /* Position physique calculée  */
 
     result = false;
 
@@ -344,10 +347,11 @@ bool translate_offset_into_address_using_elf_sections(const GElfFormat *format,
     {
         find_elf_section_by_index(format, i, &section);
 
-        if (ELF_SHDR(format, section, sh_offset) <= pos
-            && pos < (ELF_SHDR(format, section, sh_offset) + ELF_SHDR(format, section, sh_size)))
+        if (ELF_SHDR(format, section, sh_addr) <= addr
+            && addr < (ELF_SHDR(format, section, sh_addr) + ELF_SHDR(format, section, sh_size)))
         {
-            *addr = ELF_SHDR(format, section, sh_addr) + pos - ELF_SHDR(format, section, sh_offset);
+            off = ELF_SHDR(format, section, sh_offset) + addr - ELF_SHDR(format, section, sh_addr);
+            init_vmpa(pos, off, addr);
             result = true;
         }
 
diff --git a/src/format/elf/section.h b/src/format/elf/section.h
index 59c2996..e300ee3 100644
--- a/src/format/elf/section.h
+++ b/src/format/elf/section.h
@@ -51,11 +51,11 @@ bool find_elf_section_content_by_name(const GElfFormat *, const char *, off_t *,
 /* Identifie une chaîne de caractères dans une section adéquate. */
 const char *extract_name_from_elf_string_section(const GElfFormat *, const elf_shdr *, off_t);
 
-/* Fournit la position correspondant à une adresse virtuelle. */
-bool translate_address_into_offset_using_elf_sections(const GElfFormat *, vmpa_t, off_t *);
+/* Fournit l'emplacement correspondant à une position physique. */
+bool translate_offset_into_vmpa_using_elf_sections(const GElfFormat *, phys_t, vmpa2t *);
 
-/* Fournit l'adresse virtuelle correspondant à une position. */
-bool translate_offset_into_address_using_elf_sections(const GElfFormat *, off_t, vmpa_t *);
+/* Fournit l'emplacement correspondant à une adresse virtuelle. */
+bool translate_address_into_vmpa_using_elf_sections(const GElfFormat *, virt_t, vmpa2t *);
 
 
 
diff --git a/src/format/elf/symbols.c b/src/format/elf/symbols.c
index 03812f1..b57c601 100644
--- a/src/format/elf/symbols.c
+++ b/src/format/elf/symbols.c
@@ -252,10 +252,10 @@ static bool load_all_elf_basic_entry_points(GElfFormat *format)
     elf_dyn item_b;                         /* Second élément DYNAMIC      */
     const bin_t *content;                   /* Contenu binaire à lire      */
     off_t length;                           /* Taille totale du contenu    */
+    bool status;                            /* Bilan d'une opération       */
     off_t pos;                              /* Tête de lecture courante    */
     uint32_t virt_32;                       /* Adresse virtuelle sur 32b   */
     uint64_t virt_64;                       /* Adresse virtuelle sur 64b   */
-    bool status;                            /* Bilan d'une opération       */
 
     /* Point d'entrée principal éventuel */
 
@@ -308,8 +308,10 @@ static bool load_all_elf_basic_entry_points(GElfFormat *format)
         content = G_BIN_FORMAT(fmt)->content;
         length = G_BIN_FORMAT(fmt)->length;
 
-        if (!translate_address_into_offset_using_elf_programs(fmt, ELF_DYN(fmt, *ar, d_un.d_val), &pos))
-            return;
+        status = g_exe_format_translate_address_into_offset(G_EXE_FORMAT(format),
+                                                            ELF_DYN(fmt, *ar, d_un.d_val),
+                                                            &pos);
+        if (!status) return;
 
         if ((pos + ELF_DYN(fmt, *sz, d_un.d_val)) < length)
             length = pos + ELF_DYN(fmt, *sz, d_un.d_val);
@@ -373,7 +375,11 @@ static bool load_all_elf_basic_entry_points(GElfFormat *format)
 
     if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_PLTGOT, &item_a))
     {
-        if (translate_address_into_offset_using_elf_programs(format, ELF_DYN(format, item_a, d_un.d_val), &pos))
+        status = g_exe_format_translate_address_into_offset(G_EXE_FORMAT(format),
+                                                            ELF_DYN(format, item_a, d_un.d_val),
+                                                            &pos);
+
+        if (status)
         {
             content = G_BIN_FORMAT(format)->content;
             length = G_BIN_FORMAT(format)->length;