Computed the end of routines with no limit.

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

5 files changed, 237 insertions, 0 deletions

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);