Resolved links in disassembled instructions.

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

1 files changed, 131 insertions, 147 deletions

diff --git a/src/analysis/disass/area.c b/src/analysis/disass/area.c
index 9d8dcf5..0ec4ad4 100644
--- a/src/analysis/disass/area.c
+++ b/src/analysis/disass/area.c
@@ -28,15 +28,15 @@
 
 
 
-#if 0
 
 
 /* Zone mémoire bien bornée */
-struct _mem_area
+typedef struct _mem_area
 {
     mrange_t range;                         /* Couverture de la zone       */
 
     unsigned long *processed;               /* Octets traités dans la zone */
+    GArchInstruction **instructions;        /* Instructions en place       */
 
     bool has_sym;                           /* Représentation via symbole ?*/
 
@@ -46,10 +46,10 @@ struct _mem_area
         GBinSymbol *symbol;                 /* Symbole associé à la zone   */
     };
 
-};
+} mem_area;
+
 
 
-#endif
 
 
 
@@ -76,10 +76,10 @@ static bool mark_range_in_mem_area_as_processed(mem_area *, phys_t, phys_t, GArc
 
 
 /* Procède au désassemblage d'un contenu binaire non exécutable. */
-static void load_data_from_mem_area(mem_area *, mem_area *, size_t, const GLoadedBinary *, GProcContext *, const vmpa2t *, status_info *);
+static void load_data_from_mem_area(mem_area *, mem_area *, size_t, const GLoadedBinary *, GProcContext *, const vmpa2t *, status_blob_info *);
 
 /* S'assure qu'une aire contient toutes ses instructions. */
-static void fill_mem_area(mem_area *, mem_area *, size_t, const GLoadedBinary *, GProcContext *, status_info *);
+static void fill_mem_area(mem_area *, mem_area *, size_t, const GLoadedBinary *, GProcContext *, status_blob_info *);
 
 
 
@@ -240,12 +240,12 @@ static void fini_mem_area(mem_area *area)
 static bool is_range_blank_in_mem_area(mem_area *area, phys_t start, phys_t len, GArchInstruction *instr)
 {
     bool result;                            /* Bilan à renvoyer            */
-	phys_t max;								/* Point d'arrêt de la boucle  */
+    phys_t max;                             /* Point d'arrêt de la boucle  */
     phys_t i;                               /* Boucle de parcours          */
     size_t index;                           /* Cellule de tableau visée    */
     unsigned int remaining;                 /* Nombre de bits restants     */
 
-	max = start + len;
+    max = start + len;
 
     assert(max <= get_mrange_length(&area->range));
 
@@ -282,12 +282,12 @@ static bool is_range_blank_in_mem_area(mem_area *area, phys_t start, phys_t len,
 
 static bool mark_range_in_mem_area_as_processed(mem_area *area, phys_t start, phys_t len, GArchInstruction *instr)
 {
-	phys_t max;								/* Point d'arrêt de la boucle  */
+    phys_t max;                             /* Point d'arrêt de la boucle  */
     phys_t i;                               /* Boucle de parcours          */
     size_t index;                           /* Cellule de tableau visée    */
     unsigned int remaining;                 /* Nombre de bits restants     */
 
-	max = start + len;
+    max = start + len;
 
     assert(max <= get_mrange_length(&area->range));
 
@@ -330,7 +330,7 @@ static bool mark_range_in_mem_area_as_processed(mem_area *area, phys_t start, ph
 *                                                                             *
 ******************************************************************************/
 
-void load_code_from_mem_area(mem_area *area, mem_area *list, size_t count, const GLoadedBinary *binary, GProcContext *ctx, const vmpa2t *start, status_info *info)
+void load_code_from_mem_area(mem_area *area, mem_area *list, size_t count, const GLoadedBinary *binary, GProcContext *ctx, const vmpa2t *start, status_blob_info *info)
 {
 
 
@@ -379,7 +379,7 @@ void load_code_from_mem_area(mem_area *area, mem_area *list, size_t count, const
     copy_vmpa(&pos, get_mrange_addr(&area->range));
     advance_vmpa(&pos, diff);
 
-	printf(" [%p] CODE start @ %u (len=%u)\n", area, (unsigned int)diff, (unsigned int)alen);
+    printf(" [%p] CODE start @ %u (len=%u)\n", area, (unsigned int)diff, (unsigned int)alen);
 
     for (i = diff; i < alen; i += diff)
     {
@@ -391,7 +391,7 @@ void load_code_from_mem_area(mem_area *area, mem_area *list, size_t count, const
 
         instr = g_arch_processor_disassemble(proc, ctx, bin_data, &pos, bin_length);
 
-		//printf(" @ 0x%08x -> %p\n", (uint32_t)get_virt_addr(&prev), instr);
+        //printf(" @ 0x%08x -> %p\n", (uint32_t)get_virt_addr(&prev), instr);
 
         if (instr == NULL) break;
 
@@ -414,15 +414,9 @@ void load_code_from_mem_area(mem_area *area, mem_area *list, size_t count, const
 
         mark_range_in_mem_areas_as_processed(list, count, instr);
 
-        //done += (new_phy - old_phy);
-        //gtk_extended_status_bar_update_activity(statusbar, id, done * 1.0 / sum);
-
-
-
-
-
-
+        inc_progessive_status(info, diff);
 
+        assert(!is_range_blank_in_mem_areas(list, count, &range));
 
     }
 
@@ -451,11 +445,11 @@ void load_code_from_mem_area(mem_area *area, mem_area *list, size_t count, const
 *                                                                             *
 ******************************************************************************/
 
-static void load_data_from_mem_area(mem_area *area, mem_area *list, size_t count, const GLoadedBinary *binary, GProcContext *ctx, const vmpa2t *start, status_info *info)
+static void load_data_from_mem_area(mem_area *area, mem_area *list, size_t count, const GLoadedBinary *binary, GProcContext *ctx, const vmpa2t *start, status_blob_info *info)
 {
     GBinFormat *format;                     /* Format du fichier binaire   */
     GArchProcessor *proc;                   /* Architecture du binaire     */
-	SourceEndian endianness;				/* Boutisme de cette machine   */
+    SourceEndian endianness;                /* Boutisme de cette machine   */
     off_t bin_length;                       /* Taille des données à lire   */
     bin_t *bin_data;                        /* Données binaires à lire     */
     phys_t diff;                            /* Volume de données traité    */
@@ -476,7 +470,7 @@ static void load_data_from_mem_area(mem_area *area, mem_area *list, size_t count
 
     format = G_BIN_FORMAT(g_loaded_binary_get_format(binary));
     proc = get_arch_processor_from_format(G_EXE_FORMAT(format));
-	endianness = g_arch_processor_get_endianness(proc);
+    endianness = g_arch_processor_get_endianness(proc);
     bin_data = g_loaded_binary_get_data(binary, &bin_length);
 
     diff = compute_vmpa_diff(get_mrange_addr(&area->range), start);
@@ -490,8 +484,8 @@ static void load_data_from_mem_area(mem_area *area, mem_area *list, size_t count
     copy_vmpa(&pos, get_mrange_addr(&area->range));
     advance_vmpa(&pos, diff);
 
-	printf(" [%p] DATA start @ 0x%08x -> %u (len=%u)\n",
-		   area, (unsigned int)get_phy_addr(&pos), (unsigned int)diff, (unsigned int)alen);
+    printf(" [%p] DATA start @ 0x%08x -> %u (len=%u)\n",
+           area, (unsigned int)get_phy_addr(&pos), (unsigned int)diff, (unsigned int)alen);
 
     for (i = diff; i < alen; i += diff)
     {
@@ -499,53 +493,50 @@ static void load_data_from_mem_area(mem_area *area, mem_area *list, size_t count
 
         copy_vmpa(&prev, &pos);
 
-		instr = NULL;
+        instr = NULL;
 
-		if (instr == NULL && (i + 4) <= alen)
-		{
-			init_mrange(&range, &pos, 4);
+        if (instr == NULL && (i + 4) <= alen)
+        {
+            init_mrange(&range, &pos, 4);
 
-			if (is_range_blank_in_mem_areas(list, count, &range))
-				instr = g_raw_instruction_new_array(bin_data, MDS_32_BITS, 1, &pos, bin_length, endianness);
+            if (is_range_blank_in_mem_areas(list, count, &range))
+                instr = g_raw_instruction_new_array(bin_data, MDS_32_BITS, 1, &pos, bin_length, endianness);
 
-		}
+        }
 
-		if (instr == NULL && (i + 2) <= alen)
-		{
-			copy_vmpa(&pos, &prev);
-			init_mrange(&range, &pos, 2);
+        if (instr == NULL && (i + 2) <= alen)
+        {
+            copy_vmpa(&pos, &prev);
+            init_mrange(&range, &pos, 2);
 
-			if (is_range_blank_in_mem_areas(list, count, &range))
-				instr = g_raw_instruction_new_array(bin_data, MDS_16_BITS, 1, &pos, bin_length, endianness);
+            if (is_range_blank_in_mem_areas(list, count, &range))
+                instr = g_raw_instruction_new_array(bin_data, MDS_16_BITS, 1, &pos, bin_length, endianness);
 
-		}
+        }
 
-		if (instr == NULL/* && (i + 1) <= alen*/)
-		{
-			copy_vmpa(&pos, &prev);
-			init_mrange(&range, &pos, 1);
+        if (instr == NULL/* && (i + 1) <= alen*/)
+        {
+            copy_vmpa(&pos, &prev);
+            init_mrange(&range, &pos, 1);
 
-			if (is_range_blank_in_mem_areas(list, count, &range))
-				instr = g_raw_instruction_new_array(bin_data, MDS_8_BITS, 1, &pos, bin_length, endianness);
-			else
-			{
-				printf("      break !!  0x%08x\n",
-					   (unsigned int)get_phy_addr(&pos));
-				assert(0);
-				break;
-			}
+            if (is_range_blank_in_mem_areas(list, count, &range))
+                instr = g_raw_instruction_new_array(bin_data, MDS_8_BITS, 1, &pos, bin_length, endianness);
+            else
+            {
+                printf("      break !!  0x%08x\n",
+                       (unsigned int)get_phy_addr(&pos));
+                assert(0);
+                break;
+            }
 
-		}
+        }
 
-		assert(instr != NULL);
+        assert(instr != NULL);
 
         /* Enregistrement des positions et adresses */
 
         diff = compute_vmpa_diff(&prev, &pos);
 
-		printf("   decomp @ 0x%08x  -> ++ %u\n",
-			   (unsigned int)get_phy_addr(&pos), (unsigned int)diff);
-
         init_mrange(&range, &prev, diff);
 
         g_arch_instruction_set_range(instr, &range);
@@ -554,10 +545,9 @@ static void load_data_from_mem_area(mem_area *area, mem_area *list, size_t count
 
         mark_range_in_mem_areas_as_processed(list, count, instr);
 
-		assert(!is_range_blank_in_mem_areas(list, count, &range));
+        inc_progessive_status(info, diff);
 
-        //done += (new_phy - old_phy);
-        //gtk_extended_status_bar_update_activity(statusbar, id, done * 1.0 / sum);
+        assert(!is_range_blank_in_mem_areas(list, count, &range));
 
     }
 
@@ -581,40 +571,40 @@ static void load_data_from_mem_area(mem_area *area, mem_area *list, size_t count
 *                                                                             *
 ******************************************************************************/
 
-static void fill_mem_area(mem_area *area, mem_area *list, size_t count, const GLoadedBinary *binary, GProcContext *ctx, status_info *info)
+static void fill_mem_area(mem_area *area, mem_area *list, size_t count, const GLoadedBinary *binary, GProcContext *ctx, status_blob_info *info)
 {
-	phys_t len;								/* Taille de la zone à remplir */
+    phys_t len;                             /* Taille de la zone à remplir */
     phys_t i;                               /* Boucle de parcours          */
-	vmpa2t start;							/* Adresse de départ de combles*/
+    vmpa2t start;                           /* Adresse de départ de combles*/
 
 
-	printf(" === FILLING | 0x%08x (%u)...\n",
-		   (unsigned int)get_phy_addr(get_mrange_addr(&area->range)),
-		   (unsigned int)get_phy_addr(get_mrange_addr(&area->range)));
+    printf(" === FILLING | 0x%08x (%u)...\n",
+           (unsigned int)get_phy_addr(get_mrange_addr(&area->range)),
+           (unsigned int)get_phy_addr(get_mrange_addr(&area->range)));
 
 
-	/* Les symboles se doivent d'être indépendants ! */
-	if (area->has_sym) return;
+    /* Les symboles se doivent d'être indépendants ! */
+    if (area->has_sym) return;
 
     len = get_mrange_length(&area->range);
 
     for (i = 0; i < len; i++)
     {
-		if (is_range_blank_in_mem_area(area, i, 1, NULL))
-		{
-			copy_vmpa(&start, get_mrange_addr(&area->range));
-			advance_vmpa(&start, i);
+        if (is_range_blank_in_mem_area(area, i, 1, NULL))
+        {
+            copy_vmpa(&start, get_mrange_addr(&area->range));
+            advance_vmpa(&start, i);
 
-			if (area->exec)
-				load_code_from_mem_area(area, list, count, binary, ctx, &start, info);
+            if (area->exec)
+                load_code_from_mem_area(area, list, count, binary, ctx, &start, info);
 
-			if (is_range_blank_in_mem_area(area, i, 1, NULL))
-				load_data_from_mem_area(area, list, count, binary, ctx, &start, info);
+            if (is_range_blank_in_mem_area(area, i, 1, NULL))
+                load_data_from_mem_area(area, list, count, binary, ctx, &start, info);
 
-		}
+        }
 
-		if (is_range_blank_in_mem_area(area, i, 1, NULL))
-			printf(" [%p] error with %u\n", area, (unsigned int)i);
+        if (is_range_blank_in_mem_area(area, i, 1, NULL))
+            printf(" [%p] error with %u\n", area, (unsigned int)i);
 
         assert(!is_range_blank_in_mem_area(area, i, 1, NULL));
 
@@ -638,51 +628,51 @@ static void fill_mem_area(mem_area *area, mem_area *list, size_t count, const GL
 static GArchInstruction *get_instructions_from_mem_area(const mem_area *area)
 {
     GArchInstruction *result;               /* Liste d'instr. à renvoyer   */
-	phys_t len;								/* Nombre d'instructions au max*/
-	phys_t i;								/* Boucle de parcours		   */
+    phys_t len;                             /* Nombre d'instructions au max*/
+    phys_t i;                               /* Boucle de parcours          */
     GArchInstruction *instr;                /* Instruction décodée         */
 
     result = NULL;
 
-	if (area->has_sym)
-		switch (g_binary_symbol_get_target_type(area->symbol))
-		{
-		    case STP_DATA:
-				result = g_binary_symbol_get_instruction(area->symbol);
-				g_object_ref(G_OBJECT(result));
-				break;
+    if (area->has_sym)
+        switch (g_binary_symbol_get_target_type(area->symbol))
+        {
+            case STP_DATA:
+                result = g_binary_symbol_get_instruction(area->symbol);
+                g_object_ref(G_OBJECT(result));
+                break;
 
-		    case STP_ROUTINE:
-				assert(false);
-				//instr = load_code_binary(binary, start, end, statusbar, id);
-				// + fill
-				break;
+            case STP_ROUTINE:
+                assert(false);
+                //instr = load_code_binary(binary, start, end, statusbar, id);
+                // + fill
+                break;
 
-		    default:
-				assert(false);
-				break;
+            default:
+                assert(false);
+                break;
 
-		}
+        }
 
-	else
-	{
-		len = get_mrange_length(&area->range);
+    else
+    {
+        len = get_mrange_length(&area->range);
 
-		for (i = 0; i < len; i++)
-		{
-			instr = area->instructions[i];
+        for (i = 0; i < len; i++)
+        {
+            instr = area->instructions[i];
 
-			if (instr != NULL)
-			{
-				g_object_ref(G_OBJECT(instr));
-				g_arch_instruction_add_to_list(&result, instr);
-			}
+            if (instr != NULL)
+            {
+                g_object_ref(G_OBJECT(instr));
+                g_arch_instruction_add_to_list(&result, instr);
+            }
 
-		}
+        }
 
-	}
+    }
 
-	return result;
+    return result;
 
 }
 
@@ -771,15 +761,15 @@ mem_area *compute_memory_areas(GExeFormat *format, phys_t bin_length, size_t *co
 
     for (i = 0; i < exe_count; i++)
     {
-		printf(" (init) AREA %zu :: 0x%08x + %u\n",
-			   i,
-			   (unsigned int)get_phy_addr(get_mrange_addr(&exe_ranges[i])),
-			   (unsigned int)get_mrange_length(&exe_ranges[i]));
+        printf(" (init) AREA %zu :: 0x%08x + %u\n",
+               i,
+               (unsigned int)get_phy_addr(get_mrange_addr(&exe_ranges[i])),
+               (unsigned int)get_mrange_length(&exe_ranges[i]));
 
-	}
+    }
 
 
-	printf("----------------\n");
+    printf("----------------\n");
 
 
 
@@ -850,12 +840,12 @@ mem_area *compute_memory_areas(GExeFormat *format, phys_t bin_length, size_t *co
 
     for (i = 0; i < *count; i++)
     {
-		printf(" (fini) AREA %zu :: 0x%08x + %u\n",
-			   i,
-			   (unsigned int)get_phy_addr(get_mrange_addr(&result[i].range)),
-			   (unsigned int)get_mrange_length(&result[i].range));
+        printf(" (fini) AREA %zu :: 0x%08x + %u\n",
+               i,
+               (unsigned int)get_phy_addr(get_mrange_addr(&result[i].range)),
+               (unsigned int)get_mrange_length(&result[i].range));
 
-	}
+    }
 
     printf("--------------------\n");
 
@@ -916,15 +906,15 @@ mem_area *compute_memory_areas(GExeFormat *format, phys_t bin_length, size_t *co
 
     for (i = 0; i < *count; i++)
     {
-		printf(" (sect) AREA %zu :: 0x%08x + %u\n",
-			   i,
-			   (unsigned int)get_phy_addr(get_mrange_addr(&result[i].range)),
-			   (unsigned int)get_mrange_length(&result[i].range));
+        printf(" (sect) AREA %zu :: 0x%08x + %u\n",
+               i,
+               (unsigned int)get_phy_addr(get_mrange_addr(&result[i].range)),
+               (unsigned int)get_mrange_length(&result[i].range));
 
-	}
+    }
 
 
-	//exit(0);
+    //exit(0);
 
 
 
@@ -1103,11 +1093,6 @@ mem_area *find_memory_area_by_addr(mem_area *list, size_t count, const vmpa2t *a
 }
 
 
-
-
-
-
-
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : list    = liste de zones délimitant des contenus à traiter.  *
@@ -1135,7 +1120,6 @@ static bool handle_bytes_map_in_mem_area(mem_area *list, size_t count, const mra
     result = false;
 
     area = find_memory_area_by_addr(list, count, get_mrange_addr(range));
-    if (area == NULL) printf("NOT FOUND!\n");
     if (area == NULL) return false;
 
     offset = compute_vmpa_diff(get_mrange_addr(&area->range), get_mrange_addr(range));
@@ -1148,7 +1132,7 @@ static bool handle_bytes_map_in_mem_area(mem_area *list, size_t count, const mra
 
     else
     {
-		assert(0);
+        assert(0);
 
         /* Traitement de la fin de la première aire */
 
@@ -1247,12 +1231,12 @@ static bool mark_range_in_mem_areas_as_processed(mem_area *list, size_t count, G
 *                                                                             *
 ******************************************************************************/
 
-void ensure_all_mem_areas_are_filled(mem_area *list, size_t count, const GLoadedBinary *binary, GProcContext *ctx, status_info *info)
+void ensure_all_mem_areas_are_filled(mem_area *list, size_t count, const GLoadedBinary *binary, GProcContext *ctx, status_blob_info *info)
 {
-	size_t i;								/* Boucle de parcours		   */
+    size_t i;                               /* Boucle de parcours          */
 
-	for (i = 0; i < count; i++)
-		fill_mem_area(&list[i], list, count, binary, ctx, info);
+    for (i = 0; i < count; i++)
+        fill_mem_area(&list[i], list, count, binary, ctx, info);
 
 }
 
@@ -1273,17 +1257,17 @@ void ensure_all_mem_areas_are_filled(mem_area *list, size_t count, const GLoaded
 GArchInstruction *collect_instructions_from_mem_areas(mem_area *list, size_t count)
 {
     GArchInstruction *result;               /* Liste d'instr. à renvoyer   */
-	size_t i;								/* Boucle de parcours		   */
+    size_t i;                               /* Boucle de parcours          */
     GArchInstruction *instr;                /* Instruction(s) à insérer    */
 
-	result = NULL;
+    result = NULL;
 
-	for (i = 0; i < count; i++)
-	{
-		instr = get_instructions_from_mem_area(&list[i]);
+    for (i = 0; i < count; i++)
+    {
+        instr = get_instructions_from_mem_area(&list[i]);
         g_arch_instruction_merge_lists(&result, &instr);
-	}
+    }
 
-	return result;
+    return result;
 
 }