Used real virtual addresses when describing ELF items.

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

9 files changed, 186 insertions, 82 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;
diff --git a/src/format/executable-int.h b/src/format/executable-int.h
index 59a513e..bb46248 100644
--- a/src/format/executable-int.h
+++ b/src/format/executable-int.h
@@ -46,6 +46,13 @@ typedef bool (* translate_off_fc) (const GExeFormat *, off_t, vmpa_t *);
 
 
 
+/* Fournit l'emplacement correspondant à une position physique. */
+typedef bool (* translate_phys_fc) (const GExeFormat *, phys_t, vmpa2t *);
+
+/* Fournit l'emplacement correspondant à une adresse virtuelle. */
+typedef bool (* translate_virt_fc) (const GExeFormat *, virt_t, vmpa2t *);
+
+
 
 /* Format d'exécutable générique (instance) */
 struct _GExeFormat
@@ -67,6 +74,9 @@ struct _GExeFormatClass
 {
     GBinFormatClass parent;                 /* A laisser en premier        */
 
+    translate_phys_fc translate_phys;       /* Correspondance phys -> vmpa */
+    translate_virt_fc translate_virt;       /* Correspondance virt -> vmpa */
+
 };
 
 
diff --git a/src/format/executable.c b/src/format/executable.c
index 319d3dd..1a66ffc 100644
--- a/src/format/executable.c
+++ b/src/format/executable.c
@@ -256,11 +256,11 @@ mrange_t *g_exe_format_get_x_ranges(GExeFormat *format, size_t *count)
 
 /******************************************************************************
 *                                                                             *
-*  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.                                        *
 *                                                                             *
@@ -268,20 +268,24 @@ mrange_t *g_exe_format_get_x_ranges(GExeFormat *format, size_t *count)
 *                                                                             *
 ******************************************************************************/
 
-bool g_exe_format_translate_address_into_offset(const GExeFormat *format, vmpa_t addr, off_t *pos)
+bool g_exe_format_translate_offset_into_vmpa(const GExeFormat *format, phys_t off, vmpa2t *pos)
 {
-    return format->translate_addr(format, addr, pos);
+    bool result;                            /* Bilan à retourner           */
+
+    result = G_EXE_FORMAT_GET_CLASS(format)->translate_phys(format, off, pos);
+
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  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.                                        *
 *                                                                             *
@@ -289,8 +293,12 @@ bool g_exe_format_translate_address_into_offset(const GExeFormat *format, vmpa_t
 *                                                                             *
 ******************************************************************************/
 
-bool g_exe_format_translate_offset_into_address(const GExeFormat *format, off_t pos, vmpa_t *addr)
+bool g_exe_format_translate_address_into_vmpa(const GExeFormat *format, virt_t addr, vmpa2t *pos)
 {
-    return format->translate_off(format, pos, addr);
+    bool result;                            /* Bilan à retourner           */
+
+    result = G_EXE_FORMAT_GET_CLASS(format)->translate_virt(format, addr, pos);
+
+    return result;
 
 }
diff --git a/src/format/executable.h b/src/format/executable.h
index 0607a0e..8b52ed6 100644
--- a/src/format/executable.h
+++ b/src/format/executable.h
@@ -38,6 +38,8 @@
 #define G_EXE_FORMAT_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_executable_format_get_type(), GExeFormatIface))
 #define G_EXE_FORMAT_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_EXE_FORMAT, GExeFormatClass))
 
+#define G_EXE_FORMAT_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_EXE_FORMAT, GExeFormatClass))
+
 
 /* Format d'exécutable générique (instance) */
 typedef struct _GExeFormat GExeFormat;
@@ -64,11 +66,30 @@ GBinPortion **g_exe_format_get_portions_at_level(GExeFormat *, unsigned int, siz
 /* Fournit les espaces mémoires des portions exécutables. */
 mrange_t *g_exe_format_get_x_ranges(GExeFormat *format, size_t *count);
 
-/* Fournit la position correspondant à une adresse virtuelle. */
-bool g_exe_format_translate_address_into_offset(const GExeFormat *, vmpa_t, off_t *);
-
-/* Fournit l'adresse virtuelle correspondant à une position. */
-bool g_exe_format_translate_offset_into_address(const GExeFormat *, off_t, vmpa_t *);
+/* Fournit l'emplacement correspondant à une position physique. */
+bool g_exe_format_translate_offset_into_vmpa(const GExeFormat *, phys_t, vmpa2t *);
+
+/* Fournit l'emplacement correspondant à une position physique. */
+bool g_exe_format_translate_address_into_vmpa(const GExeFormat *, virt_t, vmpa2t *);
+
+
+#define g_exe_format_translate_offset_into_address(fmt, off, addr)              \
+    ({                                                                          \
+        bool __result;                                                          \
+        vmpa2t __pos;                                                           \
+        __result = g_exe_format_translate_offset_into_vmpa(fmt, off, &__pos);   \
+        *addr = get_virt_addr(&__pos);                                          \
+        __result;                                                               \
+    })
+
+#define g_exe_format_translate_address_into_offset(fmt, addr, off)              \
+    ({                                                                          \
+        bool __result;                                                          \
+        vmpa2t __pos;                                                           \
+        __result = g_exe_format_translate_address_into_vmpa(fmt, addr, &__pos); \
+        *off = get_phy_addr(&__pos);                                            \
+        __result;                                                               \
+    })