Computed the end of routines with no limit.

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

11 files changed, 309 insertions, 8 deletions

diff --git a/ChangeLog b/ChangeLog
index 67b76b1..01a22cf 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,25 @@
+09-07-18  Cyrille Bagard <nocbos@gmail.com>
+
+	* src/analysis/binary.c:
+	Compute the end of routines with no limit.
+
+	* src/analysis/line.c:
+	* src/analysis/line.h:
+	Look for a code line in a list of lines.
+
+	* src/analysis/prototype.c:
+	* src/analysis/prototype.h:
+	Compare routines for qsort().
+
+	* src/arch/instruction.c:
+	* src/arch/instruction.h:
+	* src/arch/instruction-int.h:
+	* src/arch/x86/instruction.c:
+	Add a function which tells if an instruction is a return from a call.
+
+	* src/format/elf/symbol.c:
+	Clean the code. Only match with real functions when loading symbols.
+
 09-07-16  Cyrille Bagard <nocbos@gmail.com>
 
 	* src/gtkext/gtkgraphview.c:
diff --git a/src/analysis/binary.c b/src/analysis/binary.c
index 09b7212..396dbe0 100644
--- a/src/analysis/binary.c
+++ b/src/analysis/binary.c
@@ -91,6 +91,12 @@ void disassemble_openida_binary(openida_binary *);
 /* Etablit les liens entres les différentes lignes de code. */
 void establish_links_in_openida_binary(const openida_binary *);
 
+/* S'assure que toutes les routines ont une taille définie. */
+void limit_all_routines_in_openida_binary(const openida_binary *);
+
+/* Cherche l'adresse de fin d'une routine. */
+vmpa_t find_best_ending_address_for_routine(GRenderingLine *, size_t, const vmpa_t *, const off_t *, size_t);
+
 
 
 /******************************************************************************
@@ -629,6 +635,7 @@ void disassemble_openida_binary(openida_binary *binary)
     }
 
     establish_links_in_openida_binary(binary);
+    limit_all_routines_in_openida_binary(binary);
 
     line = g_rendering_line_find_by_address(binary->lines, NULL, get_exe_entry_point(binary->format));
     if (line != NULL) g_rendering_line_add_flag(line, RLF_ENTRY_POINT);
@@ -733,3 +740,126 @@ void establish_links_in_openida_binary(const openida_binary *binary)
     }
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = binaire dont le contenu est à lier.                 *
+*                                                                             *
+*  Description : S'assure que toutes les routines ont une taille définie.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void limit_all_routines_in_openida_binary(const openida_binary *binary)
+{
+    GBinRoutine **routines;                 /* Liste des routines trouvées */
+    size_t routines_count;                  /* Nombre de ces routines      */
+    size_t i;                               /* Boucle de parcours          */
+    vmpa_t *starts;                         /* Adresses de départ          */
+    off_t *lengths;                         /* Tailles des routines        */
+    GRenderingLine *line;                   /* Ligne de départ / d'arrivée */
+    vmpa_t start;                           /* Adresse de début de routine */
+    vmpa_t last;                            /* Meilleur dernière adresse   */
+    GArchInstruction *instr;                /* Instruction à ausculter     */
+    off_t length;                           /* Taille du code              */
+
+    routines = get_all_exe_routines(binary->format, &routines_count);
+    if (routines_count == 0) return;
+
+    qsort(routines, routines_count, sizeof(GBinRoutine *), g_binary_routine_rcompare);
+
+    starts = (vmpa_t *)calloc(routines_count, sizeof(vmpa_t));
+    lengths = (off_t *)calloc(routines_count, sizeof(off_t));
+
+    for (i = 0; i < routines_count; i++)
+    {
+        starts[i] = g_binary_routine_get_address(routines[i]);
+        lengths[i] = g_binary_routine_get_size(routines[i]);
+    }
+
+    for (i = 0; i < routines_count; i++)
+    {
+        if (lengths[i] > 0) continue;
+
+        start = g_binary_routine_get_address(routines[i]);
+        line = g_rendering_line_find_by_address(binary->lines, NULL, start);
+
+        last = find_best_ending_address_for_routine(line, i, starts, lengths, routines_count);
+
+        line = g_rendering_line_find_by_address(binary->lines, NULL, last);
+        line = g_rendering_line_loop_for_code(line, NULL);
+
+        instr = g_code_line_get_instruction(G_CODE_LINE(line));
+        g_arch_instruction_get_location(instr, NULL, &length, NULL);
+
+        lengths[i] = last - start + length;
+        g_binary_routine_set_size(routines[i], lengths[i]);
+
+    }
+
+    free(starts);
+    free(lengths);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line    = ligne de départ du parcours.                       *
+*                index   = indice de la routine traitée dans la liste.        *
+*                starts  = adresse de départ des autres routines.             *
+*                lengths = taille des différentes routines, valides ou nulles.*
+*                count   = quantité de routines présentes.                    *
+*                                                                             *
+*  Description : Cherche l'adresse de fin d'une routine.                      *
+*                                                                             *
+*  Retour      : Plus grande adresse de dernière instruction de routine.      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+vmpa_t find_best_ending_address_for_routine(GRenderingLine *line, size_t index, const vmpa_t *starts, const off_t *lengths, size_t count)
+{
+    vmpa_t result;                          /* Haute adresse à remonter    */
+    GRenderingLine *iter;                   /* Boucle de parcours #1       */
+    vmpa_t candidate;                       /* Candidat potentiel          */
+    size_t i;                               /* Boucle de parcours #2       */
+    GArchInstruction *instr;                /* Instruction à ausculter     */
+
+    result = starts[index];
+
+    for (iter = line; iter != NULL; iter = g_rendering_line_get_next_iter(line, iter, NULL))
+    {
+        if (!G_IS_CODE_LINE(iter)) continue;
+
+        candidate = get_rendering_line_address(iter);
+
+        /* Regarde si on n'empiète pas sur une autre routine */
+
+        for (i = 0; i < count; i++)
+        {
+            if (i == index) continue;
+
+            if (starts[i] <= candidate && candidate < (starts[i] + lengths[i]))
+                break;
+
+        }
+
+        if (i != count) break;
+        else result = candidate;
+
+        /* Retour de fonction ? */
+
+        instr = g_code_line_get_instruction(G_CODE_LINE(iter));
+        if (g_arch_instruction_is_return(instr)) break;
+
+    }
+
+    return result;
+
+}
diff --git a/src/analysis/line.c b/src/analysis/line.c
index 740673a..cd54db0 100644
--- a/src/analysis/line.c
+++ b/src/analysis/line.c
@@ -34,6 +34,7 @@
 #include <sys/param.h>
 
 
+#include "line_code.h"
 #include "../common/dllist.h"
 
 
@@ -732,3 +733,47 @@ GRenderingLine *g_rendering_line_find_by_address(GRenderingLine *lines, const GR
     return result;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : start = première ligne de l'ensemble à parcourir.            *
+*                last  = dernière élément imposé du parcours ou NULL.         *
+*                                                                             *
+*  Description : Donne la première ligne de code correspondant à une adresse. *
+*                                                                             *
+*  Retour      : Ligne de code pour l'adresse donnée, NULL si aucune trouvée. *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GRenderingLine *g_rendering_line_loop_for_code(GRenderingLine *start, const GRenderingLine *last)
+{
+    GRenderingLine *result;                 /* Trouvaille à retourner      */
+    vmpa_t reference;                       /* Adresse à conserver         */
+
+    result = start;
+    reference = start->offset;
+
+    lines_list_for_each(result, start)
+    {
+        if (G_IS_CODE_LINE(result)) break;
+
+        if (result->offset != reference)
+        {
+            result = NULL;
+            break;
+        }
+
+        if (result == last)
+        {
+            result = NULL;
+            break;
+        }
+
+    }
+
+    return result;
+
+}
diff --git a/src/analysis/line.h b/src/analysis/line.h
index 5f22db2..621ab60 100644
--- a/src/analysis/line.h
+++ b/src/analysis/line.h
@@ -131,6 +131,9 @@ GRenderingLine *g_rendering_line_find_by_y(GRenderingLine *, const GRenderingLin
 /* Recherche une ligne d'après sa position en mémoire/physique. */
 GRenderingLine *g_rendering_line_find_by_address(GRenderingLine *, const GRenderingLine *, vmpa_t);
 
+/* Donne la première ligne de code correspondant à une adresse. */
+GRenderingLine *g_rendering_line_loop_for_code(GRenderingLine *, const GRenderingLine *);
+
 
 
 #endif  /* _ANALYSIS_LINE_H */
diff --git a/src/analysis/prototype.c b/src/analysis/prototype.c
index d68a485..72ee809 100644
--- a/src/analysis/prototype.c
+++ b/src/analysis/prototype.c
@@ -161,6 +161,59 @@ void g_binary_routine_finalize(GBinRoutine *routine)
 }
 #endif
 
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = premières informations à consulter.                      *
+*                b = secondes informations à consulter.                       *
+*                                                                             *
+*  Description : Etablit la comparaison ascendante entre deux routines.       *
+*                                                                             *
+*  Retour      : Bilan : -1 (a < b), 0 (a == b) ou 1 (a > b).                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+int g_binary_routine_compare(const GBinRoutine **a, const GBinRoutine **b)
+{
+    int result;                             /* Bilan à renvoyer            */
+
+    if ((*a)->addr < (*b)->addr) result = -1;
+    else if((*a)->addr > (*b)->addr) result = 1;
+    else result = 0;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = premières informations à consulter.                      *
+*                b = secondes informations à consulter.                       *
+*                                                                             *
+*  Description : Etablit la comparaison descendante entre deux routines.      *
+*                                                                             *
+*  Retour      : Bilan : -1 (a < b), 0 (a == b) ou 1 (a > b).                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+int g_binary_routine_rcompare(const GBinRoutine **a, const GBinRoutine **b)
+{
+    int result;                             /* Bilan à renvoyer            */
+
+    if ((*a)->addr > (*b)->addr) result = -1;
+    else if((*a)->addr < (*b)->addr) result = 1;
+    else result = 0;
+
+    return result;
+
+}
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : routine = routine à mettre à jour.                           *
diff --git a/src/analysis/prototype.h b/src/analysis/prototype.h
index fe6d0a4..2a9439e 100644
--- a/src/analysis/prototype.h
+++ b/src/analysis/prototype.h
@@ -64,6 +64,12 @@ GType g_bin_routine_get_type(void);
 /* Crée une représentation de routine. */
 GBinRoutine *g_binary_routine_new(void);
 
+/* Etablit la comparaison ascendante entre deux routines. */
+int g_binary_routine_compare(const GBinRoutine **, const GBinRoutine **);
+
+/* Etablit la comparaison descendante entre deux routines. */
+int g_binary_routine_rcompare(const GBinRoutine **, const GBinRoutine **);
+
 /* Définit la position physique / en mémoire d'une routine. */
 void g_binary_routine_set_address(GBinRoutine *, vmpa_t);
 
diff --git a/src/arch/instruction-int.h b/src/arch/instruction-int.h
index 6ae0597..db6a3bf 100644
--- a/src/arch/instruction-int.h
+++ b/src/arch/instruction-int.h
@@ -36,6 +36,9 @@ typedef const char * (* get_instruction_text_fc) (const GArchInstruction *, cons
 /* Informe sur une éventuelle référence à une autre instruction. */
 typedef InstructionLinkType (* get_instruction_link_fc) (const GArchInstruction *, vmpa_t *);
 
+/* Indique si l'instruction correspond à un retour de fonction. */
+typedef bool (* is_instruction_return_fc) (const GArchInstruction *);
+
 
 /* Définition générique d'une instruction d'architecture (instance) */
 struct _GArchInstruction
@@ -52,6 +55,7 @@ struct _GArchInstruction
 
     get_instruction_text_fc get_text;       /* Texte humain équivalent     */
     get_instruction_link_fc get_link;       /* Référence à une instruction */
+    is_instruction_return_fc is_return;     /* Retour de fonction ou pas ? */
 
 };
 
diff --git a/src/arch/instruction.c b/src/arch/instruction.c
index 69644dc..e0cea9f 100644
--- a/src/arch/instruction.c
+++ b/src/arch/instruction.c
@@ -321,3 +321,22 @@ InstructionLinkType g_arch_instruction_get_link(const GArchInstruction *instr, v
     return instr->get_link(instr, addr);
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instruction à consulter.                             *
+*                                                                             *
+*  Description : Indique si l'instruction correspond à un retour de fonction. *
+*                                                                             *
+*  Retour      : true si l'instruction est un 'return' quelconque ou false.   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_arch_instruction_is_return(const GArchInstruction *instr)
+{
+    return instr->is_return(instr);
+
+}
diff --git a/src/arch/instruction.h b/src/arch/instruction.h
index b8be830..c0cb9f6 100644
--- a/src/arch/instruction.h
+++ b/src/arch/instruction.h
@@ -25,6 +25,7 @@
 #define _ARCH_INSTRUCTION_H
 
 
+#include <stdbool.h>
 #include <glib-object.h>
 #include <sys/types.h>
 
@@ -90,6 +91,9 @@ char *g_arch_instruction_get_text(const GArchInstruction *, const exe_format *,
 /* Informe sur une éventuelle référence à une autre instruction. */
 InstructionLinkType g_arch_instruction_get_link(const GArchInstruction *, vmpa_t *);
 
+/* Indique si l'instruction correspond à un retour de fonction. */
+bool g_arch_instruction_is_return(const GArchInstruction *instr);
+
 
 
 #endif  /* _ARCH_INSTRUCTION_H */
diff --git a/src/arch/x86/instruction.c b/src/arch/x86/instruction.c
index 0321e88..0af29c1 100644
--- a/src/arch/x86/instruction.c
+++ b/src/arch/x86/instruction.c
@@ -326,6 +326,8 @@ static const char *x86_get_instruction_text(const GX86Instruction *, const exe_f
 /* Informe sur une éventuelle référence à une autre instruction. */
 static InstructionLinkType x86_get_instruction_link(const GX86Instruction *, vmpa_t *);
 
+/* Indique si l'instruction correspond à un retour de fonction. */
+static bool x86_instruction_is_return(const GX86Instruction *);
 
 
 
@@ -372,6 +374,7 @@ static void g_x86_instruction_init(GX86Instruction *instr)
 
     parent->get_text = (get_instruction_text_fc)x86_get_instruction_text;
     parent->get_link = (get_instruction_link_fc)x86_get_instruction_link;
+    parent->is_return = (is_instruction_return_fc)x86_instruction_is_return;
 
 }
 
@@ -622,3 +625,22 @@ static InstructionLinkType x86_get_instruction_link(const GX86Instruction *instr
     return result;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instruction à consulter.                             *
+*                                                                             *
+*  Description : Indique si l'instruction correspond à un retour de fonction. *
+*                                                                             *
+*  Retour      : true si l'instruction est un 'return' quelconque ou false.   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool x86_instruction_is_return(const GX86Instruction *instr)
+{
+    return (instr->type == XOP_RET);
+
+}
diff --git a/src/format/elf/symbol.c b/src/format/elf/symbol.c
index 4fd56fe..35943e9 100644
--- a/src/format/elf/symbol.c
+++ b/src/format/elf/symbol.c
@@ -30,11 +30,6 @@
 #include <string.h>
 
 
-#include "../../arch/processor.h" /* FIXME : remove me ! */
-#include "../../arch/instruction.h" /* FIXME : remove me ! */
-#include "../../arch/instruction-int.h" /* FIXME : remove me ! */
-
-
 #include "elf-int.h"
 #include "helper_mips.h"
 #include "section.h"
@@ -254,9 +249,7 @@ bool load_elf_symbol_table_32(elf_format *format, const off_t *sym_start, const
     {
         memcpy(&symbol, &EXE_FORMAT(format)->content[iter], sizeof(Elf32_Sym));
 
-        if (!(ELF32_ST_TYPE(symbol.st_info) == STT_FUNC
-              || (ELF32_ST_TYPE(symbol.st_info) == STT_NOTYPE
-                  && ELF32_ST_BIND(symbol.st_info) == STB_GLOBAL))) continue;
+        if (!(ELF32_ST_TYPE(symbol.st_info) == STT_FUNC)) continue;
 
         if (symbol.st_value == 0) continue;