Improved symbol resolving using fully defined locations.

6 files changed, 52 insertions, 46 deletions

diff --git a/src/arch/arm/v7/post.c b/src/arch/arm/v7/post.c
index 4037c05..5ac3c62 100644
--- a/src/arch/arm/v7/post.c
+++ b/src/arch/arm/v7/post.c
@@ -49,10 +49,10 @@ void post_process_ldr_instructions(GArchInstruction *instr, GArchProcessor *proc
     uint32_t addr;                          /* Adresse visée par le saut   */
     GBinFormat *bfmt;                       /* Version basique du format   */
     GArchOperand *new;                      /* Instruction de ciblage      */
-    vmpa2t target;
+    vmpa2t target;                          /* Défination finale précise   */
     mrange_t trange;                        /* Etendue du symbole à créer  */
-    VMPA_BUFFER(loc);
-    char name[5 + VMPA_MAX_LEN];
+    VMPA_BUFFER(loc);                       /* Espace pour une conversion  */
+    char name[5 + VMPA_MAX_LEN];            /* Etiquette à constituer      */
     GBinRoutine *routine;                   /* Nouvelle routine trouvée    */
     GBinSymbol *symbol;                     /* Nouveau symbole construit   */
 
@@ -67,7 +67,7 @@ void post_process_ldr_instructions(GArchInstruction *instr, GArchProcessor *proc
     {
         bfmt = G_BIN_FORMAT(format);
 
-        new = g_target_operand_new(MDS_32_BITS_UNSIGNED, addr);
+        new = g_target_operand_new(MDS_32_BITS_UNSIGNED, &target);
 
         if (!g_target_operand_resolve(G_TARGET_OPERAND(new), bfmt, true))
         {
@@ -88,8 +88,6 @@ void post_process_ldr_instructions(GArchInstruction *instr, GArchProcessor *proc
             g_binary_symbol_attach_routine(symbol, routine);
             g_binary_format_add_symbol(bfmt, symbol);
 
-
-
             g_target_operand_resolve(G_TARGET_OPERAND(new), bfmt, true);
 
         }
diff --git a/src/arch/dalvik/link.c b/src/arch/dalvik/link.c
index 3295c76..f92541b 100644
--- a/src/arch/dalvik/link.c
+++ b/src/arch/dalvik/link.c
@@ -80,8 +80,9 @@ typedef struct _case_comment
 void handle_dalvik_packed_switch_links(GArchInstruction *instr, GArchProcessor *proc, GProcContext *context, GExeFormat *format)
 {
     GArchOperand *op;                       /* Opérande numérique en place */
-    virt_t virt;                            /* Adresse virtuelle           */
+    bool defined;                           /* Adresse définie ?           */
     vmpa2t addr;                            /* Adresse de destination      */
+    virt_t virt;                            /* Adresse virtuelle           */
     GArchInstruction *switch_ins;           /* Instruction de branchements */
     const mrange_t *range;                  /* Zone d'occupation           */
     const vmpa2t *start_addr;               /* Adresse de référentiel      */
@@ -104,24 +105,25 @@ void handle_dalvik_packed_switch_links(GArchInstruction *instr, GArchProcessor *
 
     op = g_arch_instruction_get_operand(instr, 1);
 
-    virt = VMPA_NO_VIRTUAL;
+    defined = false;
 
     if (G_IS_TARGET_OPERAND(op))
-        virt = g_target_operand_get_addr(G_TARGET_OPERAND(op));
+    {
+        g_target_operand_get_addr(G_TARGET_OPERAND(op), &addr);
+        defined = true;
+    }
 
     else if (G_IS_IMM_OPERAND(op))
     {
-        if (!g_imm_operand_to_virt_t(G_IMM_OPERAND(op), &virt))
-            virt = VMPA_NO_VIRTUAL;
+        if (g_imm_operand_to_virt_t(G_IMM_OPERAND(op), &virt))
+        {
+            init_vmpa(&addr, VMPA_NO_PHYSICAL, virt);
+            defined = true;
+        }
     }
 
-    if (virt != VMPA_NO_VIRTUAL)
+    if (defined)
     {
-        /* TODO : utiliser format pour contruire une adresse avec une position physique,
-         * ce qui accélèrerait les recherches.
-         */
-        init_vmpa(&addr, VMPA_NO_PHYSICAL, virt);
-
         switch_ins = g_arch_processor_find_instr_by_address(proc, &addr);
 
         if (G_IS_DALVIK_SWITCH_INSTR(switch_ins))
diff --git a/src/arch/link.c b/src/arch/link.c
index 8b02aa8..0e11521 100644
--- a/src/arch/link.c
+++ b/src/arch/link.c
@@ -95,8 +95,9 @@ void handle_jump_as_link(GArchInstruction *instr, GArchProcessor *proc, GProcCon
 void handle_branch_as_link(GArchInstruction *instr, GArchProcessor *proc, GProcContext *context, GExeFormat *format, size_t index)
 {
     GArchOperand *op;                       /* Opérande numérique en place */
-    virt_t virt;                            /* Adresse virtuelle           */
+    bool defined;                           /* Adresse définie ?           */
     vmpa2t addr;                            /* Adresse de destination      */
+    virt_t virt;                            /* Adresse virtuelle           */
     instr_iter_t *iter;                     /* Parcours d'instructions     */
     GArchInstruction *target;               /* Ligne visée par la référence*/
 
@@ -104,21 +105,25 @@ void handle_branch_as_link(GArchInstruction *instr, GArchProcessor *proc, GProcC
 
     op = g_arch_instruction_get_operand(instr, index);
 
-    virt = VMPA_NO_VIRTUAL;
+    defined = false;
 
     if (G_IS_TARGET_OPERAND(op))
-        virt = g_target_operand_get_addr(G_TARGET_OPERAND(op));
+    {
+        g_target_operand_get_addr(G_TARGET_OPERAND(op), &addr);
+        defined = true;
+    }
 
     else if (G_IS_IMM_OPERAND(op))
     {
-        if (!g_imm_operand_to_virt_t(G_IMM_OPERAND(op), &virt))
-            virt = VMPA_NO_VIRTUAL;
+        if (g_imm_operand_to_virt_t(G_IMM_OPERAND(op), &virt))
+        {
+            init_vmpa(&addr, VMPA_NO_PHYSICAL, virt);
+            defined = true;
+        }
     }
 
-    if (virt != VMPA_NO_VIRTUAL)
+    if (defined)
     {
-        init_vmpa(&addr, VMPA_NO_PHYSICAL, virt);
-
         iter = g_arch_processor_get_iter_from_address(proc, &addr);
 
         if (iter != NULL)
diff --git a/src/arch/post.c b/src/arch/post.c
index 9a296d4..59ed40e 100644
--- a/src/arch/post.c
+++ b/src/arch/post.c
@@ -73,7 +73,7 @@ void post_process_target_resolution(GArchInstruction *instr, GArchProcessor *pro
 
         ptr_size = g_arch_processor_get_memory_size(proc);
 
-        new = g_target_operand_new(ptr_size, addr);
+        new = g_target_operand_new(ptr_size, &target);
 
         if (!g_target_operand_resolve(G_TARGET_OPERAND(new), bfmt, true))
         {
diff --git a/src/arch/target.c b/src/arch/target.c
index 4655351..63ae295 100644
--- a/src/arch/target.c
+++ b/src/arch/target.c
@@ -43,7 +43,7 @@ struct _GTargetOperand
     GArchOperand parent;                    /* Instance parente            */
 
     MemoryDataSize size;                    /* Taille de l'opérande        */
-    virt_t addr;                            /* Adresse de l'élément visé   */
+    vmpa2t addr;                            /* Adresse de l'élément visé   */
 
     GBinSymbol *symbol;                     /* Eventuel symbole associé    */
     phys_t diff;                            /* Position dans le symbole    */
@@ -171,7 +171,7 @@ static void g_target_operand_finalize(GTargetOperand *operand)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : size = taille des adresse mémoire virtuelles.                *
-*                addr = adresse virtuelle d'un élément à retrouver.           *
+*                addr = localisation d'un élément à retrouver.                *
 *                                                                             *
 *  Description : Crée un opérande réprésentant une valeur numérique.          *
 *                                                                             *
@@ -181,14 +181,14 @@ static void g_target_operand_finalize(GTargetOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_target_operand_new(MemoryDataSize size, virt_t addr)
+GArchOperand *g_target_operand_new(MemoryDataSize size, const vmpa2t *addr)
 {
     GTargetOperand *result;                 /* Opérande à retourner        */
 
     result = g_object_new(G_TYPE_TARGET_OPERAND, NULL);
 
     result->size = size;
-    result->addr = addr;
+    copy_vmpa(&result->addr, addr);
 
     return G_ARCH_OPERAND(result);
 
@@ -240,8 +240,7 @@ static void g_target_operand_print(const GTargetOperand *operand, GBufferLine *l
     }
     else
     {
-        init_vmpa(&tmp, VMPA_NO_PHYSICAL, operand->addr);
-        vmpa2_virt_to_string(&tmp, operand->size, value, &len);
+        vmpa2_virt_to_string(&operand->addr, operand->size, value, &len);
 
         g_buffer_line_append_text(line, BLC_MAIN, value, len, RTT_LABEL, G_OBJECT(operand));
 
@@ -271,19 +270,20 @@ MemoryDataSize g_target_operand_get_size(const GTargetOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = structure dont le contenu est à définir.           *
+*  Paramètres  : operand = structure dont le contenu est à consulter.         *
+*                addr    = localisation à renseigner. [OUT]                   *
 *                                                                             *
 *  Description : Fournit l'adresse en mémoire de l'élément visé.              *
 *                                                                             *
-*  Retour      : Adresse en mémoire virtuelle associée.                       *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-virt_t g_target_operand_get_addr(const GTargetOperand *operand)
+void g_target_operand_get_addr(const GTargetOperand *operand, vmpa2t *addr)
 {
-    return operand->addr;
+    copy_vmpa(addr, &operand->addr);
 
 }
 
@@ -305,17 +305,11 @@ virt_t g_target_operand_get_addr(const GTargetOperand *operand)
 bool g_target_operand_resolve(GTargetOperand *operand, GBinFormat *format, bool strict)
 {
     bool result;                            /* Bilan à retourner           */
-    vmpa2t addr;                            /* Adresse de recherche        */
 
     if (operand->symbol != NULL)
         g_object_unref(G_OBJECT(operand->symbol));
 
-    operand->symbol = NULL;
-    operand->diff = 0;
-
-    init_vmpa(&addr, VMPA_NO_PHYSICAL, operand->addr);
-
-    result = g_binary_format_resolve_symbol(format, &addr, strict, &operand->symbol, &operand->diff);
+    result = g_binary_format_resolve_symbol(format, &operand->addr, strict, &operand->symbol, &operand->diff);
 
     return result;
 
@@ -337,9 +331,16 @@ bool g_target_operand_resolve(GTargetOperand *operand, GBinFormat *format, bool
 
 GBinSymbol *g_target_operand_get_symbol(const GTargetOperand *operand, phys_t *diff)
 {
+    GBinSymbol *result;                     /* Symbole associé à retourner */
+
     if (diff != NULL)
         *diff = operand->diff;
 
-    return operand->symbol;
+    result = operand->symbol;
+
+    if (result != NULL)
+        g_object_ref(G_OBJECT(result));
+
+    return result;
 
 }
diff --git a/src/arch/target.h b/src/arch/target.h
index e1ea173..529dba8 100644
--- a/src/arch/target.h
+++ b/src/arch/target.h
@@ -55,13 +55,13 @@ typedef struct _GTargetOperandClass GTargetOperandClass;
 GType g_target_operand_get_type(void);
 
 /* Crée un opérande réprésentant une valeur numérique. */
-GArchOperand *g_target_operand_new(MemoryDataSize, virt_t);
+GArchOperand *g_target_operand_new(MemoryDataSize, const vmpa2t *);
 
 /* Renseigne la taille de la valeur indiquée à la construction. */
 MemoryDataSize g_target_operand_get_size(const GTargetOperand *);
 
 /* Fournit l'adresse en mémoire de l'élément visé. */
-virt_t g_target_operand_get_addr(const GTargetOperand *);
+void g_target_operand_get_addr(const GTargetOperand *, vmpa2t *);
 
 /* Tente une résolution de symbole. */
 bool g_target_operand_resolve(GTargetOperand *, GBinFormat *, bool);