summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/analysis/disass/area.c1958
-rw-r--r--src/analysis/disass/area.h84
-rw-r--r--src/analysis/disass/fetch.c146
3 files changed, 189 insertions, 1999 deletions
diff --git a/src/analysis/disass/area.c b/src/analysis/disass/area.c
index 96de6f3..2786242 100644
--- a/src/analysis/disass/area.c
+++ b/src/analysis/disass/area.c
@@ -31,14 +31,14 @@
#include "../../analysis/contents/restricted.h"
+#include "../../arch/raw.h"
#include "../../common/bits.h"
#include "../../gui/panels/log.h"
-
/* Zone mémoire bien bornée */
-typedef struct _mem_area_v2
+typedef struct _mem_area
{
GBinFormat *format; /* Format du fichier binaire */
GBinContent *content; /* Données binaires à lire */
@@ -52,65 +52,37 @@ typedef struct _mem_area_v2
bitfield_t *processed; /* Octets traités dans la zone */
GArchInstruction **instructions; /* Instructions en place */
-
-
-
bool is_exec; /* Zone exécutable ? */
-} mem_area_v2;
-
+} mem_area;
/* Initialise une aire de données à partir d'une adresse donnée. */
-static void init_mem_area_from_addr_v2(mem_area_v2 *, const vmpa2t *, phys_t, const GLoadedBinary *);
+static void init_mem_area_from_addr(mem_area *, const vmpa2t *, phys_t, const GLoadedBinary *);
/* Libère d'une aire de données les ressources allouées. */
-static void fini_mem_area_v2(mem_area_v2 *);
+static void fini_mem_area(mem_area *);
/* Indique si une zone donnée est intégralement vierge ou non. */
-static bool is_range_blank_in_mem_area_v2(mem_area_v2 *, phys_t, phys_t);
+static bool is_range_blank_in_mem_area(mem_area *, phys_t, phys_t);
/* Marque une série d'octets comme ayant été traités. */
-static bool mark_range_in_mem_area_as_processed_v2(mem_area_v2 *, GArchInstruction *, bool);
-
-
+static bool mark_range_in_mem_area_as_processed(mem_area *, GArchInstruction *, bool);
/* Crée une instruction issue d'un désassemblage brut. */
-static GArchInstruction *load_raw_instruction_from_mem_area_v2(mem_area_v2 *, phys_t, vmpa2t *, phys_t *);
-
+static GArchInstruction *load_raw_instruction_from_mem_area(mem_area *, phys_t, vmpa2t *, phys_t *);
+/* S'assure de la présence d'un début de routine à un point. */
+static void update_address_as_routine(GBinFormat *, const vmpa2t *);
/* Procède au désassemblage d'un contenu binaire non exécutable. */
-static void load_data_from_mem_area_v2(mem_area_v2 *, GProcContext *, const vmpa2t *, GtkStatusStack *, activity_id_t);
+static void load_data_from_mem_area(mem_area *, GProcContext *, const vmpa2t *, GtkStatusStack *, activity_id_t);
/* S'assure qu'une aire contient toutes ses instructions. */
-static void fill_mem_area_v2(mem_area_v2 *, mem_area_v2 *, size_t, GProcContext *, GtkStatusStack *, activity_id_t);
+static void fill_mem_area(mem_area *, mem_area *, size_t, GProcContext *, GtkStatusStack *, activity_id_t);
/* Rassemble les instructions conservées dans une zone donnée. */
-static GArchInstruction *get_instructions_from_mem_area_v2(const mem_area_v2 *);
-
-
-
-
-
-
-/* S'assure de la présence d'un début de routine à un point. */
-static void update_address_as_routine(GBinFormat *, const vmpa2t *);
-
-
-/**
- * Content :: à passer en restricted.
-
- * Les sections croisées : pas de sens de les traiter ici, car au final une instruction sera à cheval
- * sur deux sections différentes -> incohérence au niveau de l'éditeur.
- * => régler le périmètres de segments règle donc tous les soucis.
-
- */
-
-
-
-
-
+static GArchInstruction *get_instructions_from_mem_area(const mem_area *);
@@ -129,7 +101,7 @@ static void update_address_as_routine(GBinFormat *, const vmpa2t *);
* *
******************************************************************************/
-static void init_mem_area_from_addr_v2(mem_area_v2 *area, const vmpa2t *addr, phys_t len, const GLoadedBinary *binary)
+static void init_mem_area_from_addr(mem_area *area, const vmpa2t *addr, phys_t len, const GLoadedBinary *binary)
{
GBinContent *content; /* Données binaires à lire */
@@ -166,7 +138,7 @@ static void init_mem_area_from_addr_v2(mem_area_v2 *area, const vmpa2t *addr, ph
* *
******************************************************************************/
-static void fini_mem_area_v2(mem_area_v2 *area)
+static void fini_mem_area(mem_area *area)
{
phys_t len; /* Etendue du parcours total */
phys_t i; /* Boucle de parcours */
@@ -202,7 +174,7 @@ static void fini_mem_area_v2(mem_area_v2 *area)
* *
******************************************************************************/
-static bool is_range_blank_in_mem_area_v2(mem_area_v2 *area, phys_t start, phys_t len)
+static bool is_range_blank_in_mem_area(mem_area *area, phys_t start, phys_t len)
{
bool result; /* Résultat à renvoyer */
@@ -229,7 +201,7 @@ static bool is_range_blank_in_mem_area_v2(mem_area_v2 *area, phys_t start, phys_
* *
******************************************************************************/
-static bool mark_range_in_mem_area_as_processed_v2(mem_area_v2 *area, GArchInstruction *instr, bool force)
+static bool mark_range_in_mem_area_as_processed(mem_area *area, GArchInstruction *instr, bool force)
{
bool result; /* Bilan d'action à renvoyer */
const vmpa2t *start; /* Adresse de départ de la zone*/
@@ -260,12 +232,6 @@ static bool mark_range_in_mem_area_as_processed_v2(mem_area_v2 *area, GArchInstr
}
-
-
-
-
-
-
/******************************************************************************
* *
* Paramètres : area = aire représentant à contenu à parcourir. *
@@ -281,7 +247,7 @@ static bool mark_range_in_mem_area_as_processed_v2(mem_area_v2 *area, GArchInstr
* *
******************************************************************************/
-static GArchInstruction *load_raw_instruction_from_mem_area_v2(mem_area_v2 *area, phys_t offset, vmpa2t *pos, phys_t *size)
+static GArchInstruction *load_raw_instruction_from_mem_area(mem_area *area, phys_t offset, vmpa2t *pos, phys_t *size)
{
GArchInstruction *result; /* Instruction à retourner */
GBinContent *content; /* Données binaires à lire */
@@ -296,7 +262,7 @@ static GArchInstruction *load_raw_instruction_from_mem_area_v2(mem_area_v2 *area
sz = area->packing_size;
- if (get_virt_addr(pos) % sz == 0 && is_range_blank_in_mem_area_v2(area, offset, sz))
+ if (get_virt_addr(pos) % sz == 0 && is_range_blank_in_mem_area(area, offset, sz))
{
*size = sz;
@@ -322,9 +288,61 @@ static GArchInstruction *load_raw_instruction_from_mem_area_v2(mem_area_v2 *area
}
+/******************************************************************************
+* *
+* Paramètres : format = format binaire en cours de traitement. *
+* addr = adresse d'une instruction présentée comme première. *
+* *
+* Description : S'assure de la présence d'un début de routine à un point. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void update_address_as_routine(GBinFormat *format, const vmpa2t *addr)
+{
+ GBinSymbol *symbol; /* Symbole présent ou créé */
+ bool found; /* Détection de symbole */
+ SymbolType sym_type; /* Type de symbole en place */
+ bool wrong_type; /* Analyse plus fine de ce type*/
+ mrange_t range; /* Etendue du symbole à créer */
+ VMPA_BUFFER(loc); /* Traduction de l'adresse */
+ char name[5 + VMPA_MAX_LEN]; /* Nom de symbole nouveau */
+ GBinRoutine *routine; /* Nouvelle routine trouvée */
+
+ found = g_binary_format_find_symbol_at(format, addr, &symbol);
+
+ if (found)
+ {
+ sym_type = g_binary_symbol_get_target_type(symbol);
+ wrong_type = (sym_type != STP_ROUTINE && sym_type != STP_ENTRY_POINT);
+ }
+
+ if (!found || (found && wrong_type))
+ {
+ init_mrange(&range, addr, 0);
+
+ vmpa2_virt_to_string(addr, MDS_UNDEFINED, loc, NULL);
+ snprintf(name, sizeof(name), "sub_%s", loc + 2);
+
+ routine = g_binary_routine_new();
+ g_binary_routine_set_name(routine, strdup(name));
+
+ g_binary_routine_set_range(routine, &range);
+ if (!found)
+ {
+ symbol = g_binary_symbol_new(STP_ROUTINE);
+ g_binary_symbol_attach_routine(symbol, routine);
+ g_binary_format_add_symbol(G_BIN_FORMAT(format), symbol);
+ }
+ else _g_binary_symbol_attach_routine(symbol, routine, STP_ROUTINE);
+ }
+}
/******************************************************************************
@@ -348,7 +366,7 @@ static GArchInstruction *load_raw_instruction_from_mem_area_v2(mem_area_v2 *area
* *
******************************************************************************/
-void load_code_from_mem_area_v2(mem_area_v2 *area, mem_area_v2 *list, size_t count, GProcContext *ctx, const vmpa2t *start, bool force, GtkStatusStack *status, activity_id_t id)
+void load_code_from_mem_area(mem_area *area, mem_area *list, size_t count, GProcContext *ctx, const vmpa2t *start, bool force, GtkStatusStack *status, activity_id_t id)
{
@@ -409,7 +427,7 @@ void load_code_from_mem_area_v2(mem_area_v2 *area, mem_area_v2 *list, size_t cou
* inutile.
*/
- if (!is_range_blank_in_mem_area_v2(area, i, 1))
+ if (!is_range_blank_in_mem_area(area, i, 1))
break;
/* Décodage d'une nouvelle instruction */
@@ -425,7 +443,7 @@ void load_code_from_mem_area_v2(mem_area_v2 *area, mem_area_v2 *list, size_t cou
{
if (i == init_diff && force)
{
- instr = load_raw_instruction_from_mem_area_v2(area, i, &pos, &diff);
+ instr = load_raw_instruction_from_mem_area(area, i, &pos, &diff);
forced_once = true;
}
@@ -442,7 +460,7 @@ void load_code_from_mem_area_v2(mem_area_v2 *area, mem_area_v2 *list, size_t cou
/* Progression dans les traitements */
- done = mark_range_in_mem_area_as_processed_v2(area, instr, false);
+ done = mark_range_in_mem_area_as_processed(area, instr, false);
if (!done)
{
@@ -452,7 +470,7 @@ void load_code_from_mem_area_v2(mem_area_v2 *area, mem_area_v2 *list, size_t cou
gtk_status_stack_update_activity_value(status, id, diff);
- assert(!is_range_blank_in_mem_area_v2(area, i, diff));
+ assert(!is_range_blank_in_mem_area(area, i, diff));
/* Enregistrement d'un éventuel début de routine */
@@ -472,7 +490,7 @@ void load_code_from_mem_area_v2(mem_area_v2 *area, mem_area_v2 *list, size_t cou
has_new_sym = g_binary_format_find_symbol_at(format, &sym_addr, &symbol);
if (has_new_sym)
- insert_extra_symbol_into_mem_areas_v2(list, count, symbol);
+ insert_extra_symbol_into_mem_areas(list, count, symbol);
}
@@ -501,7 +519,7 @@ void load_code_from_mem_area_v2(mem_area_v2 *area, mem_area_v2 *list, size_t cou
* *
******************************************************************************/
-static void load_data_from_mem_area_v2(mem_area_v2 *area, GProcContext *ctx, const vmpa2t *start, GtkStatusStack *status, activity_id_t id)
+static void load_data_from_mem_area(mem_area *area, GProcContext *ctx, const vmpa2t *start, GtkStatusStack *status, activity_id_t id)
{
phys_t diff; /* Volume de données traité */
phys_t alen; /* Taille de l'aire utilisée */
@@ -525,7 +543,7 @@ static void load_data_from_mem_area_v2(mem_area_v2 *area, GProcContext *ctx, con
{
/* On cherche à obtenir l'assurance que le traitement n'a jamais été fait */
- if (!is_range_blank_in_mem_area_v2(area, i, 1))
+ if (!is_range_blank_in_mem_area(area, i, 1))
break;
instr = NULL;
@@ -534,7 +552,7 @@ static void load_data_from_mem_area_v2(mem_area_v2 *area, GProcContext *ctx, con
/* Décodage d'une nouvelle instruction, sur mesure puis minimale */
- instr = load_raw_instruction_from_mem_area_v2(area, i, &pos, &diff);
+ instr = load_raw_instruction_from_mem_area(area, i, &pos, &diff);
/* On rencontre ici un morceau déjà traité. */
@@ -550,7 +568,7 @@ static void load_data_from_mem_area_v2(mem_area_v2 *area, GProcContext *ctx, con
/* Progression dans les traitements */
- done = mark_range_in_mem_area_as_processed_v2(area, instr, false);
+ done = mark_range_in_mem_area_as_processed(area, instr, false);
if (!done)
{
@@ -560,7 +578,7 @@ static void load_data_from_mem_area_v2(mem_area_v2 *area, GProcContext *ctx, con
gtk_status_stack_update_activity_value(status, id, diff);
- assert(!is_range_blank_in_mem_area_v2(area, i, diff));
+ assert(!is_range_blank_in_mem_area(area, i, diff));
/* On laisse une chance au code pour se reprendre... */
@@ -589,7 +607,7 @@ static void load_data_from_mem_area_v2(mem_area_v2 *area, GProcContext *ctx, con
* *
******************************************************************************/
-static void fill_mem_area_v2(mem_area_v2 *area, mem_area_v2 *list, size_t count, GProcContext *ctx, GtkStatusStack *status, activity_id_t id)
+static void fill_mem_area(mem_area *area, mem_area *list, size_t count, GProcContext *ctx, GtkStatusStack *status, activity_id_t id)
{
const vmpa2t *addr; /* Début de la zone à traiter */
phys_t len; /* Taille de la zone à remplir */
@@ -601,20 +619,20 @@ static void fill_mem_area_v2(mem_area_v2 *area, mem_area_v2 *list, size_t count,
for (i = 0; i < len; i++)
{
- if (is_range_blank_in_mem_area_v2(area, i, 1))
+ if (is_range_blank_in_mem_area(area, i, 1))
{
copy_vmpa(&start, addr);
advance_vmpa(&start, i);
if (area->is_exec && get_virt_addr(&start) % area->packing_size == 0)
- load_code_from_mem_area_v2(area, list, count, ctx, &start, false, status, id);
+ load_code_from_mem_area(area, list, count, ctx, &start, false, status, id);
- if (is_range_blank_in_mem_area_v2(area, i, 1))
- load_data_from_mem_area_v2(area, ctx, &start, status, id);
+ if (is_range_blank_in_mem_area(area, i, 1))
+ load_data_from_mem_area(area, ctx, &start, status, id);
}
- assert(!is_range_blank_in_mem_area_v2(area, i, 1));
+ assert(!is_range_blank_in_mem_area(area, i, 1));
}
@@ -633,7 +651,7 @@ static void fill_mem_area_v2(mem_area_v2 *area, mem_area_v2 *list, size_t count,
* *
******************************************************************************/
-static GArchInstruction *get_instructions_from_mem_area_v2(const mem_area_v2 *area)
+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*/
@@ -661,72 +679,6 @@ static GArchInstruction *get_instructions_from_mem_area_v2(const mem_area_v2 *ar
}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/******************************************************************************
-* *
-* Paramètres : list = listes de zones utable à consulter. *
-* count = nombre de zones mises en place. *
-* addr = adresse à retrouver dans les aires présentes. *
-* *
-* Description : Détermine une liste de zones contigües à traiter. *
-* *
-* Retour : Indice de la zone trouvée, ou nombre d'aires en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-mem_area_v2 *find_memory_area_by_addr_v2(mem_area_v2 *list, size_t count, const vmpa2t *addr)
-{
- mem_area_v2 *result; /* Elément trouvé à renvoyer */
-
- int find_mem_area(const vmpa2t *_addr, const mem_area_v2 *_area)
- {
- int status; /* Bilan à retourner */
-
- if (mrange_contains_addr(&_area->range, _addr))
- status = 0;
-
- else
- status = cmp_vmpa(_addr, get_mrange_addr(&_area->range));
-
- return status;
-
- }
-
- result = bsearch(addr, list, count, sizeof(mem_area_v2), (__compar_fn_t)find_mem_area);
-
- return result;
-
-}
-
-
-
-
-
-
-
-
/******************************************************************************
* *
* Paramètres : binary = binaire analysé contenant quantités d'infos. *
@@ -741,9 +693,9 @@ mem_area_v2 *find_memory_area_by_addr_v2(mem_area_v2 *list, size_t count, const
* *
******************************************************************************/
-mem_area_v2 *compute_memory_areas_v2(const GLoadedBinary *binary, phys_t bin_length, size_t *count)
+mem_area *compute_memory_areas(const GLoadedBinary *binary, phys_t bin_length, size_t *count)
{
- mem_area_v2 *result; /* Liste à renvoyer */
+ mem_area *result; /* Liste à renvoyer */
GExeFormat *format; /* Format de fichier associé */
mrange_t *exe_ranges; /* Liste de zones exécutables */
size_t exe_count; /* Nombre de ces zones */
@@ -753,7 +705,7 @@ mem_area_v2 *compute_memory_areas_v2(const GLoadedBinary *binary, phys_t bin_len
bool status; /* Bilan d'une conversion */
size_t i; /* Boucle de parcours #1 */
const vmpa2t *border; /* Nouvelle bordure rencontrée */
- mem_area_v2 *area; /* Zone avec valeurs à éditer */
+ mem_area *area; /* Zone avec valeurs à éditer */
vmpa2t tmp; /* Stockage temporaire */
GPortionLayer *layer; /* Couche première de portions */
GBinPortion **portions; /* Morceaux d'encadrement */
@@ -792,22 +744,22 @@ mem_area_v2 *compute_memory_areas_v2(const GLoadedBinary *binary, phys_t bin_len
if (cmp_vmpa(&last, border) < 0)
{
- result = (mem_area_v2 *)realloc(result, ++(*count) * sizeof(mem_area_v2));
+ result = (mem_area *)realloc(result, ++(*count) * sizeof(mem_area));
area = &result[*count - 1];
- init_mem_area_from_addr_v2(area, &last, compute_vmpa_diff(&last, border), binary);
+ init_mem_area_from_addr(area, &last, compute_vmpa_diff(&last, border), binary);
area->is_exec = false;
}
/* Insertion d'une zone exécutable déjà définie */
- result = (mem_area_v2 *)realloc(result, ++(*count) * sizeof(mem_area_v2));
+ result = (mem_area *)realloc(result, ++(*count) * sizeof(mem_area));
area = &result[*count - 1];
- init_mem_area_from_addr_v2(area, get_mrange_addr(&exe_ranges[i]),
+ init_mem_area_from_addr(area, get_mrange_addr(&exe_ranges[i]),
get_mrange_length(&exe_ranges[i]), binary);
area->is_exec = true;
@@ -826,11 +778,11 @@ mem_area_v2 *compute_memory_areas_v2(const GLoadedBinary *binary, phys_t bin_len
if (get_phy_addr(&tmp) < bin_length)
{
- result = (mem_area_v2 *)realloc(result, ++(*count) * sizeof(mem_area_v2));
+ result = (mem_area *)realloc(result, ++(*count) * sizeof(mem_area));
area = &result[*count - 1];
- init_mem_area_from_addr_v2(area, &tmp, bin_length - get_phy_addr(&tmp), binary);
+ init_mem_area_from_addr(area, &tmp, bin_length - get_phy_addr(&tmp), binary);
area->is_exec = false;
}
@@ -868,11 +820,11 @@ mem_area_v2 *compute_memory_areas_v2(const GLoadedBinary *binary, phys_t bin_len
/* Si le déccoupage actuel ne correspond pas au besoin des portions... */
if (cmp_vmpa(get_mrange_addr(&area->range), portion_start) != 0)
{
- fini_mem_area_v2(&result[j]);
+ fini_mem_area(&result[j]);
- result = (mem_area_v2 *)realloc(result, ++(*count) * sizeof(mem_area_v2));
+ result = (mem_area *)realloc(result, ++(*count) * sizeof(mem_area));
- memmove(&result[j + 2], &result[j + 1], (*count - j - 2) * sizeof(mem_area_v2));
+ memmove(&result[j + 2], &result[j + 1], (*count - j - 2) * sizeof(mem_area));
status = result[j].is_exec;
@@ -885,7 +837,7 @@ mem_area_v2 *compute_memory_areas_v2(const GLoadedBinary *binary, phys_t bin_len
new_length = compute_vmpa_diff(&tmp, portion_start);
- init_mem_area_from_addr_v2(area, &tmp, new_length, binary);
+ init_mem_area_from_addr(area, &tmp, new_length, binary);
area->is_exec = status;
/* Seconde moitié */
@@ -894,7 +846,7 @@ mem_area_v2 *compute_memory_areas_v2(const GLoadedBinary *binary, phys_t bin_len
area = &result[j + 1];
- init_mem_area_from_addr_v2(area, portion_start, length, binary);
+ init_mem_area_from_addr(area, portion_start, length, binary);
area->is_exec = status;
}
@@ -935,7 +887,7 @@ mem_area_v2 *compute_memory_areas_v2(const GLoadedBinary *binary, phys_t bin_len
if (length == 0)
continue;
- insert_extra_symbol_into_mem_areas_v2(result, *count, symbols[i]);
+ insert_extra_symbol_into_mem_areas(result, *count, symbols[i]);
}
@@ -953,6 +905,45 @@ mem_area_v2 *compute_memory_areas_v2(const GLoadedBinary *binary, phys_t bin_len
/******************************************************************************
* *
+* Paramètres : list = listes de zones utable à consulter. *
+* count = nombre de zones mises en place. *
+* addr = adresse à retrouver dans les aires présentes. *
+* *
+* Description : Détermine une liste de zones contigües à traiter. *
+* *
+* Retour : Indice de la zone trouvée, ou nombre d'aires en cas d'échec. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+mem_area *find_memory_area_by_addr(mem_area *list, size_t count, const vmpa2t *addr)
+{
+ mem_area *result; /* Elément trouvé à renvoyer */
+
+ int find_mem_area(const vmpa2t *_addr, const mem_area *_area)
+ {
+ int status; /* Bilan à retourner */
+
+ if (mrange_contains_addr(&_area->range, _addr))
+ status = 0;
+
+ else
+ status = cmp_vmpa(_addr, get_mrange_addr(&_area->range));
+
+ return status;
+
+ }
+
+ result = bsearch(addr, list, count, sizeof(mem_area), (__compar_fn_t)find_mem_area);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : areas = liste de zones délimitant des contenus à traiter. *
* count = nombre de zones à disposition. *
* symbol = élément nouveau à venir insérer dans les zones. *
@@ -965,14 +956,14 @@ mem_area_v2 *compute_memory_areas_v2(const GLoadedBinary *binary, phys_t bin_len
* *
******************************************************************************/
-void insert_extra_symbol_into_mem_areas_v2(mem_area_v2 *areas, size_t count, const GBinSymbol *symbol)
+void insert_extra_symbol_into_mem_areas(mem_area *areas, size_t count, const GBinSymbol *symbol)
{
SymbolType type; /* Type de symbole */
GArchInstruction *list; /* Ensemble à insérer */
GArchInstruction *iter; /* Boucle de parcours */
const mrange_t *range; /* Emplacement d'instruction */
const vmpa2t *addr; /* Départ de cet emplacement */
- mem_area_v2 *area; /* Zone d'accueil désignée */
+ mem_area *area; /* Zone d'accueil désignée */
VMPA_BUFFER(loc); /* Description d'un emplacement*/
phys_t start; /* Point de départ */
@@ -990,7 +981,7 @@ void insert_extra_symbol_into_mem_areas_v2(mem_area_v2 *areas, size_t count, con
/* Une aire d'accueil existe-t-elle ? */
- area = find_memory_area_by_addr_v2(areas, count, addr);
+ area = find_memory_area_by_addr(areas, count, addr);
if (area == NULL)
{
@@ -1016,7 +1007,7 @@ void insert_extra_symbol_into_mem_areas_v2(mem_area_v2 *areas, size_t count, con
/* Inscription d'une instruction de symbole (sans retour arrière possible :/ ) */
- mark_range_in_mem_area_as_processed_v2(area, iter, true);
+ mark_range_in_mem_area_as_processed(area, iter, true);
g_object_ref(G_OBJECT(iter));
@@ -1042,19 +1033,19 @@ void insert_extra_symbol_into_mem_areas_v2(mem_area_v2 *areas, size_t count, con
* *
******************************************************************************/
-void ensure_all_mem_areas_are_filled(mem_area_v2 *list, size_t count, GProcContext *ctx, GtkStatusStack *status, activity_id_t id)
+void ensure_all_mem_areas_are_filled(mem_area *list, size_t count, GProcContext *ctx, GtkStatusStack *status, activity_id_t id)
{
size_t i; /* Boucle de parcours */
for (i = 0; i < count; i++)
- fill_mem_area_v2(&list[i], list, count, ctx, status, id);
+ fill_mem_area(&list[i], list, count, ctx, status, id);
}
/******************************************************************************
* *
-* Paramètres : areas = série d'aires représentant à contenu à parcourir. *
+* Paramètres : list = série d'aires représentant du contenu à parcourir. *
* count = nombre de ces zones présentes. *
* *
* Description : Rassemble les instructions conservées dans des zones données.*
@@ -1065,7 +1056,7 @@ void ensure_all_mem_areas_are_filled(mem_area_v2 *list, size_t count, GProcConte
* *
******************************************************************************/
-GArchInstruction *collect_instructions_from_mem_areas_v2(const mem_area_v2 *list, size_t count)
+GArchInstruction *collect_instructions_from_mem_areas(const mem_area *list, size_t count)
{
GArchInstruction *result; /* Liste d'instr. à renvoyer */
size_t i; /* Boucle de parcours */
@@ -1075,7 +1066,7 @@ GArchInstruction *collect_instructions_from_mem_areas_v2(const mem_area_v2 *list
for (i = 0; i < count; i++)
{
- instr = get_instructions_from_mem_area_v2(&list[i]);
+ instr = get_instructions_from_mem_area(&list[i]);
g_arch_instruction_merge_lists(&result, &instr);
}
@@ -1084,1659 +1075,26 @@ GArchInstruction *collect_instructions_from_mem_areas_v2(const mem_area_v2 *list
}
-
-
-
-
-
-
-
-
-
-
-
-
-
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-//////////////////////////////////::://////////////////////////////////////////////////////////////////////
-
-
-
-
-/* Zone mémoire bien bornée */
-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 ?*/
-
- union
- {
- bool exec; /* Zone exécutable ? */
- GBinSymbol *symbol; /* Symbole associé à la zone */
- };
-
-} mem_area;
-
-
-/* Initialise une aire de données à partir d'une adresse donnée. */
-static void init_mem_area_from_addr(mem_area *, const vmpa2t *, phys_t);
-
-/* Initialise une aire de données à partir d'un espace donné. */
-static void init_mem_area_from_range(mem_area *, const mrange_t *);
-
-/* Initialise une aire de données à partir d'un morceau donné. */
-static void init_mem_area_from_bigger_area(mem_area *, const vmpa2t *, phys_t, const mem_area *);
-
-/* Copie certaines propriétés d'une aire à une autre. */
-static void copy_mem_area_properties(mem_area *, const mem_area *);
-
-/* Libère d'une aire de données les ressources allouées. */
-static void fini_mem_area(mem_area *);
-
-/* Indique si une zone donnée est intégralement vierge ou non. */
-static bool is_range_blank_in_mem_area(mem_area *, phys_t, phys_t, GArchInstruction *);
-
-/* Marque une série d'octets comme ayant été traités. */
-static bool mark_range_in_mem_area_as_processed(mem_area *, phys_t, phys_t, GArchInstruction *);
-
-
-
-
-/* S'assure de la présence d'un début de routine à un point. */
-//static void update_address_as_routine(GBinFormat *, const vmpa2t *);
-
-
-
-
-/* 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_blob_info *);
-
-
-
-/* Rassemble les instructions conservées dans une zone donnée. */
-static GArchInstruction *get_instructions_from_mem_area(const mem_area *);
-
-
-
-
-///////////////////////////////
-
-
-
-
-/* Insère un symbole dans un découpage en aires. */
-static bool insert_extra_symbol_into_mem_areas(mem_area **, size_t *, GBinSymbol *, size_t);
-
-
-
-
-/* Manipule la cartographie des octets traités d'une zone. */
-typedef bool (* visit_bytes_map_fc) (mem_area *, phys_t, phys_t, GArchInstruction *);
-
-
-
-
-
-/* Manipule la cartographie des octets d'aires de données. */
-static bool handle_bytes_map_in_mem_area(mem_area *, size_t, const mrange_t *, GArchInstruction *, visit_bytes_map_fc);
-
-/* Indique si une zone donnée est intégralement vierge ou non. */
-static bool is_range_blank_in_mem_areas(mem_area *, size_t, const mrange_t *);
-
-/* Marque une série d'octets comme ayant été traités. */
-static bool mark_range_in_mem_areas_as_processed(mem_area *, size_t, GArchInstruction *);
-
-
-
-
-
-
-
-/******************************************************************************
-* *
-* Paramètres : area = aire représentant à contenu à initialiser. *
-* addr = adresse de départ de l'espace à mettre en place. *
-* len = longueur de l'espace à créer. *
-* *
-* Description : Initialise une aire de données à partir d'une adresse donnée.*
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static void init_mem_area_from_addr(mem_area *area, const vmpa2t *addr, phys_t len)
-{
- size_t requested; /* Nombre de mots à allouer */
-
- init_mrange(&area->range, addr, len);
-
- requested = len / sizeof(unsigned long);
- if (len % sizeof(unsigned long) != 0) requested++;
-
- area->processed = (unsigned long *)calloc(requested, sizeof(unsigned long));
- area->instructions = (GArchInstruction **)calloc(len, sizeof(GArchInstruction *));
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : area = aire représentant à contenu à initialiser. *
-* range = espace limitant à associer à l'aire de données. *
-* *
-* Description : Initialise une aire de données à partir d'un espace donné. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static void init_mem_area_from_range(mem_area *area, const mrange_t *range)
-{
- phys_t len; /* Taille de la zone courante */
- size_t requested; /* Nombre de mots à allouer */
-
- copy_mrange(&area->range, range);
-
- len = get_mrange_length(range);
-
- requested = len / sizeof(unsigned long);
- if (len % sizeof(unsigned long) != 0) requested++;
-
- area->processed = (unsigned long *)calloc(requested, sizeof(unsigned long));
- area->instructions = (GArchInstruction **)calloc(len, sizeof(GArchInstruction *));
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : area = aire représentant à contenu à initialiser. *
-* addr = adresse de départ de l'espace à mettre en place. *
-* len = longueur de l'espace à créer. *
-* ref = aire de référence avant découpage. *
-* *
-* Description : Initialise une aire de données à partir d'un morceau donné. *
-* *
-* Retour : - *
-* *
-* Remarques : On considère que la zone de destination est inclue dans *
-* celle de référence. *
-* *
-******************************************************************************/
-
-static void init_mem_area_from_bigger_area(mem_area *area, const vmpa2t *addr, phys_t len, const mem_area *ref)
-{
- phys_t start; /* Point de départ de la copie */
- phys_t i; /* Boucle de parcours */
- size_t index; /* Cellule de tableau visée #1 */
- unsigned int remaining; /* Nombre de bits restants #1 */
- size_t ref_index; /* Cellule de tableau visée #2 */
- unsigned int ref_remaining; /* Nombre de bits restants #2 */
-
- init_mem_area_from_addr(area, addr, len);
-
- assert(mrange_contains_mrange(&ref->range, &area->range));
-
- start = compute_vmpa_diff(get_mrange_addr(&ref->range), get_mrange_addr(&area->range));
-
- for (i = 0; i < len; i++)
- {
- index = i / (sizeof(unsigned long) * 8);
- remaining = i % (sizeof(unsigned long) * 8);
-
- ref_index = (start + i) / (sizeof(unsigned long) * 8);
- ref_remaining = (start + i) % (sizeof(unsigned long) * 8);
-
- if (ref->processed[ref_index] & (1ul << ref_remaining))
- area->processed[index] |= (1ul << remaining);
-
- area->instructions[i] = ref->instructions[start + i];
-
- }
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : dest = aire délimitée représentant des données. *
-* src = aire délimitée contenant les informations à copier. *
-* *
-* Description : Copie certaines propriétés d'une aire à une autre. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static void copy_mem_area_properties(mem_area *dest, const mem_area *src)
-{
- dest->has_sym = src->has_sym;
-
- if (src->has_sym)
- dest->symbol = src->symbol;
- else
- dest->exec = src->exec;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : area = aire représentant à contenu à nettoyer en mémoire. *
-* *
-* Description : Libère d'une aire de données les ressources allouées. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static void fini_mem_area(mem_area *area)
-{
- free(area->processed);
-
-#if 0
- if (area->has_sym)
- g_object_unref(area->symbol); /* FIXME ?! */
-#endif
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : area = aire représentant à contenu à parcourir. *
-* start = début de la zone à manipuler. *
-* len = taille de cette même aire de données. *
-* instr = instruction à mémoriser pour la suite. *
-* *
-* Description : Indique si une zone donnée est intégralement vierge ou non. *
-* *
-* Retour : true si l'aire visée n'a jamais été traitée, false sinon. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-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 i; /* Boucle de parcours */
- size_t index; /* Cellule de tableau visée */
- unsigned int remaining; /* Nombre de bits restants */
-
- if (area->has_sym)
- return false;
-
- max = start + len;
-
- assert(max <= get_mrange_length(&area->range));
-
- result = true;
-
- for (i = start; i < max && result; i++)
- {
- index = i / (sizeof(unsigned long) * 8);
- remaining = i % (sizeof(unsigned long) * 8);
-
- result &= ((area->processed[index] & (1ul << remaining)) == 0);
-
- }
-
- return result;
-
-}
-
-
/******************************************************************************
* *
-* Paramètres : area = aire représentant à contenu à parcourir. *
-* start = début de la zone à manipuler. *
-* len = taille de cette même aire de données. *
-* instr = instruction à mémoriser pour la suite. *
-* *
-* Description : Marque une série d'octets comme ayant été traités. *
-* *
-* Retour : true. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-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 i; /* Boucle de parcours */
- size_t index; /* Cellule de tableau visée */
- unsigned int remaining; /* Nombre de bits restants */
-
- max = start + len;
-
- assert(max <= get_mrange_length(&area->range));
-
- for (i = start; i < max; i++)
- {
- index = i / (sizeof(unsigned long) * 8);
- remaining = i % (sizeof(unsigned long) * 8);
-
- //assert((area->processed[index] & (1ul << remaining)) == 0);
-
- area->processed[index] |= (1ul << remaining);
-
- }
-
- //assert(area->instructions[start] == NULL);
-
- area->instructions[start] = instr;
-
- return true;
-
-}
-
-
-
-
-
-
-
-
-
-
-
-/******************************************************************************
-* *
-* Paramètres : format = format binaire en cours de traitement. *
-* addr = adresse d'une instruction présentée comme première. *
-* *
-* Description : S'assure de la présence d'un début de routine à un point. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static void update_address_as_routine(GBinFormat *format, const vmpa2t *addr)
-{
- GBinSymbol *symbol; /* Symbole présent ou créé */
- bool found; /* Détection de symbole */
- SymbolType sym_type; /* Type de symbole en place */
- bool wrong_type; /* Analyse plus fine de ce type*/
- mrange_t range; /* Etendue du symbole à créer */
- VMPA_BUFFER(loc); /* Traduction de l'adresse */
- char name[5 + VMPA_MAX_LEN]; /* Nom de symbole nouveau */
- GBinRoutine *routine; /* Nouvelle routine trouvée */
-
- found = g_binary_format_find_symbol_at(format, addr, &symbol);
-
- if (found)
- {
- sym_type = g_binary_symbol_get_target_type(symbol);
- wrong_type = (sym_type != STP_ROUTINE && sym_type != STP_ENTRY_POINT);
- }
-
- if (!found || (found && wrong_type))
- {
- init_mrange(&range, addr, 0);
-
- vmpa2_virt_to_string(addr, MDS_UNDEFINED, loc, NULL);
- snprintf(name, sizeof(name), "sub_%s", loc + 2);
-
- routine = g_binary_routine_new();
- g_binary_routine_set_name(routine, strdup(name));
-
- g_binary_routine_set_range(routine, &range);
-
- if (!found)
- {
- symbol = g_binary_symbol_new(STP_ROUTINE);
- g_binary_symbol_attach_routine(symbol, routine);
- g_binary_format_add_symbol(G_BIN_FORMAT(format), symbol);
- }
- else _g_binary_symbol_attach_routine(symbol, routine, STP_ROUTINE);
-
- }
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : area = aire représentant à contenu à parcourir. *
-* list = liste de zones délimitant des contenus à traiter. *
-* count = nombre de zones à disposition. *
-* index = indice de l'aire à considérer pendant l'opération. *
-* binary = représentation de binaire chargé. *
-* ctx = contexte offert en soutien à un désassemblage. *
-* start = démarrage de l'exécution au sein de la zone. *
-* info = indications quant à la progression à afficher. *
-* *
-* Description : Procède au désassemblage d'un contenu binaire exécutable. *
-* *
-* Retour : Recalcul de rafraîchissement de l'aire de travail requis ? *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-bool load_code_from_mem_area(mem_area **list, size_t *count, size_t *index, const GLoadedBinary *binary, GProcContext *ctx, const vmpa2t *start, status_blob_info *info)
-{
- bool result; /* Besoin à retourner */
- mem_area *area; /* Zone de désassemblage */
-
-
-
- GBinFormat *format; /* Format du fichier binaire */
- GArchProcessor *proc; /* Architecture du binaire */
- GBinContent *content; /* Données binaires à lire */
-
- phys_t diff; /* Volume de données traité */
- phys_t alen; /* Taille de l'aire utilisée */
-
- phys_t i; /* Boucle de parcours */
-
-
- vmpa2t pos; /* Boucle de parcours */
- vmpa2t prev; /* Boucle de parcours */
-
- GArchInstruction *instr; /* Instruction décodée */
-
-
-
- mrange_t range; /* Couverture de l'instruction */
-
-
- vmpa2t sym_addr; /* Adresse de nouveau symbole */
- bool has_new_sym; /* Statut d'un dépilement */
-
- GBinSymbol *symbol; /* Symbole créé en parallèle */
- bool refresh; /* Besoin de rafraîchissement */
-
- result = false;
-
- /* On cherche à obtenir l'assurance que le traitement n'a jamais été fait */
-
- init_mrange(&range, start, 1);
- if (!is_range_blank_in_mem_areas(*list, *count, &range)) return false;
-
- /* Récupération des informations de base */
-
- format = G_BIN_FORMAT(g_loaded_binary_get_format(binary));
- proc = g_loaded_binary_get_processor(binary);
- content = g_binary_format_get_content(format);
- /* TODO : unref */
-
- area = (*list) + *index;
-
- diff = compute_vmpa_diff(get_mrange_addr(&area->range), start);
- alen = get_mrange_length(&area->range);
-
- /**
- * On copie la position courante à partir de l'aire plutôt que du
- * point de départ car cette première est potentiellement plus complète.
- */
-
- copy_vmpa(&pos, get_mrange_addr(&area->range));
- advance_vmpa(&pos, diff);
-
- for (i = diff; i < alen; i += diff)
- {
- /* S'il y a eu un point d'entrée en milieu de zone, on s'arrête ! */
- if (!is_range_blank_in_mem_area(area, i, 1, NULL)) break;
-
- /* Décodage d'une nouvelle instruction */
-
- copy_vmpa(&prev, &pos);
-
- instr = g_arch_processor_disassemble(proc, ctx, content, &pos, G_EXE_FORMAT(format));
-
- /* TODO : valider que la taille de l'instruction obtenue ne dépasse pas la zone */
-
- if (instr == NULL) break;
-
- /* Enregistrement des positions et adresses */
-
- diff = compute_vmpa_diff(&prev, &pos);
-
- assert(diff == 4 || diff == 2); /* FIXME */
-
- init_mrange(&range, &prev, diff);
-
- g_arch_instruction_set_range(instr, &range);
-
- /* Enregistrement d'un éventuel début de routine */
-
- if (g_arch_instruction_get_flags(instr) & AIF_ROUTINE_START)
- update_address_as_routine(format, &prev);
-
- /* Eventuel renvoi vers d'autres adresses */
-
- g_arch_instruction_call_hook(instr, IPH_FETCH, proc, ctx, format);
-
- /* Progression dans les traitements */
-
- mark_range_in_mem_areas_as_processed(*list, *count, instr);
-
- inc_progessive_status(info, diff);
-
- assert(!is_range_blank_in_mem_areas(*list, *count, &range));
-
- /* Insertion des symboles découverts en parallèle */
-
- for (has_new_sym = g_proc_context_pop_new_symbol_at(ctx, &sym_addr);
- has_new_sym;
- has_new_sym = g_proc_context_pop_new_symbol_at(ctx, &sym_addr))
- {
- has_new_sym = g_binary_format_find_symbol_at(format, &sym_addr, &symbol);
- assert(has_new_sym);
-
- refresh = insert_extra_symbol_into_mem_areas(list, count, symbol, *index);
-
- result |= refresh;
-
- /**
- * Si une insertion a été réalisée dans la même zone que celle courante ou avant,
- * en l'absence d'indication sur les localisations exactes, le plus simple
- * est de tout recharger.
- */
- if (refresh)
- {
- *index = find_memory_area_by_addr(*list, *count, &pos);
-
- area = (*list) + *index;
-
- diff = compute_vmpa_diff(get_mrange_addr(&area->range), &pos);
- alen = get_mrange_length(&area->range);
-
- i = 0;
-
- }
-
- /**
- * Si la zone modifiée se trouve bien après la zone courante, l'emplacement de la liste
- * peut potentiellement avoir évolué. Donc on ne recharge ici que le minimum.
- */
- else area = (*list) + *index;
-
- }
-
- assert(!is_range_blank_in_mem_areas(*list, *count, &range));
-
- /* Rupture du flot d'exécution ? */
- if (g_arch_instruction_get_flags(instr) & AIF_RETURN_POINT)
- break;
-
- }
-
- g_object_unref(G_OBJECT(content));
-
- g_object_unref(G_OBJECT(proc));
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : area = aire représentant à contenu à parcourir. *
-* list = liste de zones délimitant des contenus à traiter. *
-* count = nombre de zones à disposition. *
-* binary = représentation de binaire chargé. *
-* ctx = contexte offert en soutien à un désassemblage. *
-* start = démarrage de l'exécution au sein de la zone. *
-* info = indications quant à la progression à afficher. *
-* *
-* Description : Procède au désassemblage d'un contenu binaire non exécutable.*
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-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 */
- GBinContent *content; /* Données binaires à lire */
- GArchProcessor *proc; /* Architecture du binaire */
- SourceEndian endianness; /* Boutisme de cette machine */
- phys_t diff; /* Volume de données traité */
- phys_t alen; /* Taille de l'aire utilisée */
- phys_t i; /* Boucle de parcours */
- vmpa2t pos; /* Boucle de parcours */
- vmpa2t prev; /* Boucle de parcours */
- GArchInstruction *instr; /* Instruction décodée */
- mrange_t range; /* Couverture de l'instruction */
-
- /* On cherche à obtenir l'assurance que le traitement n'a jamais été fait */
-
- init_mrange(&range, start, 1);
- if (!is_range_blank_in_mem_areas(list, count, &range)) return;
-
- /* Récupération des informations de base */
-
- format = G_BIN_FORMAT(g_loaded_binary_get_format(binary));
- content = g_binary_format_get_content(format);
- /* TODO g_object_unref(G_OBJECT(format)); */
-
- proc = g_loaded_binary_get_processor(binary);
- endianness = g_arch_processor_get_endianness(proc);
- g_object_unref(G_OBJECT(proc));
-
- diff = compute_vmpa_diff(get_mrange_addr(&area->range), start);
- alen = get_mrange_length(&area->range);
-
- /**
- * On copie la position courante à partir de l'aire plutôt que du
- * point de départ car cette première est potentiellement plus complète.
- */
-
- copy_vmpa(&pos, get_mrange_addr(&area->range));
- advance_vmpa(&pos, diff);
-
- for (i = diff; i < alen; i += diff)
- {
- /* Décodage d'une nouvelle instruction, sur mesure */
-
- copy_vmpa(&prev, &pos);
-
- instr = NULL;
- /*
- 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(content, MDS_32_BITS, 1, &pos, endianness);
-
- }
- */
- 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(content, MDS_16_BITS, 1, &pos, endianness);
-
- }
-
- 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(content, MDS_8_BITS, 1, &pos, endianness);
- else
- {
- /**
- * On rencontre ici un morceau déjà traité.
- * On recherche donc la fin de cette partie à sauter, si elle existe.
- */
-
- //////////////
- return;
-
-
-
- for (i++; i < alen; i++)
- {
- advance_vmpa(&pos, 1);
- init_mrange(&range, &pos, 1);
-
- if (is_range_blank_in_mem_areas(list, count, &range))
- break;
-
- }
-
- diff = 0;
- continue;
-
- }
-
- }
-
- assert(instr != NULL);
-
- /* Enregistrement des positions et adresses */
-
- diff = compute_vmpa_diff(&prev, &pos);
-
- init_mrange(&range, &prev, diff);
-
- g_arch_instruction_set_range(instr, &range);
-
- /* Progression dans les traitements */
-
- mark_range_in_mem_areas_as_processed(list, count, instr);
-
- inc_progessive_status(info, diff);
-
- assert(!is_range_blank_in_mem_areas(list, count, &range));
-
-
-
- if (area->exec) break;
-
-
-
- }
-
- g_object_unref(G_OBJECT(content));
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : area = aire représentant à contenu à parcourir. *
-* list = liste de zones délimitant des contenus à traiter. *
-* count = nombre de zones à disposition. *
-* index = indice de l'aire à considérer pendant l'opération. *
-* binary = représentation de binaire chargé. *
-* ctx = contexte offert en soutien à un désassemblage. *
-* info = indications quant à la progression à afficher. *
-* *
-* Description : S'assure qu'une aire contient toutes ses instructions. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-void fill_mem_area(mem_area **list, size_t *count, size_t *index, const GLoadedBinary *binary, GProcContext *ctx, status_blob_info *info)
-{
- mem_area *area; /* Zone de désassemblage */
- phys_t len; /* Taille de la zone à remplir */
- phys_t i; /* Boucle de parcours */
- vmpa2t start; /* Adresse de départ de combles*/
- bool refresh; /* Besoin de rafraîchissement */
-
- area = (*list) + *index;
-
- /* 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 (area->exec && get_virt_addr(&start) % 4/*2 - FIXME */ == 0)
- {
- refresh = load_code_from_mem_area(list, count, index, binary, ctx, &start, info);
-
- /**
- * Mêmes commentaires que dans load_code_from_mem_area() :
- * - en cas de décalage avéré, on recharge tout.
- * - sinon, la liste a potentiellement été déplacée, donc on recharge un minimum.
- */
- if (refresh)
- {
- area = (*list) + *index;
- len = get_mrange_length(&area->range);
-
- i = compute_vmpa_diff(get_mrange_addr(&area->range), &start);
-
- }
- else area = (*list) + *index;
-
- }
-
- if (is_range_blank_in_mem_area(area, i, 1, NULL))
- load_data_from_mem_area(area, *list, *count, binary, ctx, &start, info);
-
- }
-
- assert(!is_range_blank_in_mem_area(area, i, 1, NULL));
-
- }
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : area = aire représentant à contenu à parcourir. *
-* *
-* Description : Rassemble les instructions conservées dans une zone donnée. *
-* *
-* Retour : Liste d'instructions prêtes à emploi. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-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 */
- GArchInstruction *instr; /* Instruction décodée */
-
- result = NULL;
-
- if (area->has_sym)
- switch (g_binary_symbol_get_target_type(area->symbol))
- {
- case STP_DATA:
- case STP_RO_STRING:
- 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;
-
- default:
- assert(false);
- break;
-
- }
-
- else
- {
- len = get_mrange_length(&area->range);
-
- 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);
- }
-
- }
-
- }
-
- return result;
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/******************************************************************************
-* *
-* Paramètres : format = format d'un exécutable à consulter. *
-* bin_length = quantité d'octets à traiter au total. *
-* count = nombre de zones mises en place. [OUT] *
-* *
-* Description : Détermine une liste de zones contigües à traiter. *
-* *
-* Retour : Liste de zones mémoire à libérer après usage. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-mem_area *compute_memory_areas(GExeFormat *format, phys_t bin_length, size_t *count)
-{
- mem_area *result; /* Liste à renvoyer */
- mrange_t *exe_ranges; /* Liste de zones exécutables */
- size_t exe_count; /* Nombre de ces zones */
- GBinSymbol **symbols; /* Symboles à représenter */
- size_t sym_count; /* Qté de symboles présents */
- vmpa2t *last; /* Dernière bordure rencontrée */
- size_t i; /* Boucle de parcours #1 */
- vmpa2t *border; /* Nouvelle bordure rencontrée */
- mem_area *area; /* Zone avec valeurs à éditer */
- vmpa2t tmp; /* Stockage temporaire */
-
-
- GBinPortion **portions; /* Morceaux d'encadrement */
- size_t portions_count; /* Taille de cette liste */
- const vmpa2t *portion_start; /* Point de départ de portion */
-
- size_t j; /* Boucle de parcours #2 */
- SymbolType type; /* Nature d'un symbole */
- const mrange_t *range; /* Couverture d'un symbole */
- const vmpa2t *start; /* Point de départ du symbole */
- phys_t length; /* Taille de ce même symbole */
- bool included; /* Inclusion dans une zone ? */
- mem_area orig; /* Copie de la zone réduite */
- phys_t old_length; /* Taille de zone originelle */
- phys_t new_length; /* Nouvelle taille déterminée */
- size_t next; /* Indice de zone suivante */
-
- result = NULL;
- *count = 0;
-
- /**
- * Le parcours n'est valide que si les listes, symboles et zones exécutables,
- * sont triées !
- */
-
- exe_ranges = g_exe_format_get_x_ranges(format, &exe_count);
-
- symbols = g_binary_format_get_symbols(G_BIN_FORMAT(format), &sym_count);
-
- /* Première étape : on comble les trous ! */
-
- last = make_vmpa(0, VMPA_NO_VIRTUAL);
-
- for (i = 0; i < exe_count; i++)
- {
- border = get_mrange_addr(&exe_ranges[i]);
-
- /* Zone tampon à constituer */
-
- if (cmp_vmpa_by_phy(last, border) < 0)
- {
- result = (mem_area *)realloc(result, ++(*count) * sizeof(mem_area));
-
- area = &result[*count - 1];
-
- init_mem_area_from_addr(area, last, compute_vmpa_diff(last, border));
- area->has_sym = false;
- area->exec = false;
-
- }
-
- /* Insertion d'une zone exécutable déjà définie */
-
- result = (mem_area *)realloc(result, ++(*count) * sizeof(mem_area));
-
- area = &result[*count - 1];
-
- init_mem_area_from_range(area, &exe_ranges[i]);
- area->has_sym = false;
- area->exec = true;
-
- /* Avancée du curseur */
-
- copy_vmpa(last, border);
-
- advance_vmpa(last, get_mrange_length(&exe_ranges[i]));
-
- }
-
- delete_vmpa(last);
-
- /* Extension finale complémentaire ? */
-
- area = &result[*count - 1];
-
- copy_vmpa(&tmp, get_mrange_addr(&area->range));
- advance_vmpa(&tmp, get_mrange_length(&area->range));
-
- if (get_phy_addr(&tmp) < bin_length)
- {
- result = (mem_area *)realloc(result, ++(*count) * sizeof(mem_area));
-
- area = &result[*count - 1];
-
- init_mem_area_from_addr(area, &tmp, bin_length - get_phy_addr(&tmp));
- area->has_sym = false;
- area->exec = false;
-
- }
-
- /* Seconde étape : on s'assure du découpage autour des portions pour respecter l'alignement */
-
- portions = NULL;//g_exe_format_get_portions_at_level(format, -1, &portions_count);
- portions_count = 0;
-
-
- for (i = 1; i < portions_count; i++)
- {
- portion_start = get_mrange_addr(g_binary_portion_get_range(portions[i]));
-
- for (j = 0; j < *count; j++)
- {
- area = &result[j];
-
- if (!mrange_contains_addr(&area->range, portion_start))
- continue;
-
- /* Si le déccoupage actuel ne correspond pas au besoin des portions... */
- if (cmp_vmpa(get_mrange_addr(&area->range), portion_start) != 0)
- {
- fini_mem_area(&result[j]);
-
- result = (mem_area *)realloc(result, ++(*count) * sizeof(mem_area));
-
- memmove(&result[j + 2], &result[j + 1], (*count - j - 2) * sizeof(mem_area));
-
- copy_mem_area_properties(&result[j + 1], &result[j]);
-
- /* Première moitié */
-
- area = &result[j];
-
- copy_vmpa(&tmp, get_mrange_addr(&area->range));
- length = get_mrange_length(&area->range);
-
- init_mem_area_from_addr(area, &tmp, compute_vmpa_diff(&tmp, portion_start));
-
- /* Seconde moitié */
-
- length -= get_mrange_length(&area->range);
-
- area = &result[j + 1];
-
- init_mem_area_from_addr(area, portion_start, length);
-
- }
-
- j = *count;
-
- }
-
- }
-
- /* Troisième étape : on insère les symboles existants */
-
- j = 0;
-
- for (i = 0; i < *count; i++)
- {
- /* Sélection et écartement des symboles */
-
- range = NULL; /* Pour GCC */
- length = 0; /* Pour GCC */
-
- for (; j < sym_count; j++)
- {
- type = g_binary_symbol_get_target_type(symbols[j]);
-
- /**
- * On ne garde que les symboles renvoyant directement une ou
- * plusieurs instructions, c'est à dire les symboles valides
- * pour un appel à g_binary_symbol_get_instruction().
- *
- * Les instructions des autres symboles sont obtenues et mises
- * en place durant la procédure de désassemblage.
- */
-
- if (type == STP_ROUTINE || type == STP_ENTRY_POINT || type == STP_CODE_LABEL)
- continue;
-
- range = g_binary_symbol_get_range(symbols[j]);
-
- length = get_mrange_length(range);
-
- if (length > 0)
- break;
-
- }
-
- if (j == sym_count)
- break;
-
- start = get_mrange_addr(range);
-
- /* Si un découpage s'impose... */
-
- if (mrange_contains_addr(&result[i].range, start))
- {
- copy_vmpa(&tmp, start);
- advance_vmpa(&tmp, length);
-
- included = mrange_contains_addr(&result[i].range, &tmp);
-
- memcpy(&orig, &result[i], sizeof(mem_area));
-
- fini_mem_area(&orig);
-
- /* Réduction de la zone de départ */
-
- copy_vmpa(&tmp, get_mrange_addr(&result[i].range));
- old_length = get_mrange_length(&result[i].range);
-
- new_length = compute_vmpa_diff(get_mrange_addr(&result[i].range), start);
-
- if (new_length == 0)
- {
- memmove(&result[i], &result[i + 1], (*count - i - 1) * sizeof(mem_area));
-
- (*count)--;
- next = i;
-
- }
- else
- {
- init_mem_area_from_addr(&result[i], &tmp, new_length);
- next = i + 1;
- }
-
- /* Insertion de la zone du symbole */
-
- result = (mem_area *)realloc(result, ++(*count) * sizeof(mem_area));
-
- memmove(&result[next + 1], &result[next], (*count - next - 1) * sizeof(mem_area));
-
- area = &result[next];
-
- init_mem_area_from_range(area, range);
-
- area->has_sym = true;
- area->symbol = symbols[j];
-
- /* Jointure finale... */
-
- if (included)
- {
- /* Simple extension pour rattraper la fin originelle */
-
- if ((old_length - new_length - length) > 0)
- {
- result = (mem_area *)realloc(result, ++(*count) * sizeof(mem_area));
-
- memmove(&result[next + 2], &result[next + 1], (*count - next - 2) * sizeof(mem_area));
-
- area = &result[next + 1];
-
- copy_vmpa(&tmp, start);
- advance_vmpa(&tmp, length);
-
- init_mem_area_from_addr(area, &tmp, old_length - new_length - length);
-
- copy_mem_area_properties(area, &orig);
-
- }
-
- i = next;
-
- }
- else
- {
- /* Suppression des éventuelles zones totalement recouvertes */
-
-
-
- /* Réduction de la zone d'arrivée */
-
-
- }
-
- j++;
-
- }
-
- }
-
- if (exe_ranges != NULL)
- free(exe_ranges);
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : list = liste de zones délimitant des contenus à traiter. *
-* count = nombre de zones à disposition. *
-* symbol = élément nouveau à venir insérer dans les zones. *
-* working = indice de l'aire de travail courante. *
-* *
-* Description : Insère un symbole dans un découpage en aires. *
-* *
-* Retour : Recalcul de rafraîchissement de l'aire de travail requis ? *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static bool insert_extra_symbol_into_mem_areas(mem_area **list, size_t *count, GBinSymbol *symbol, size_t working)
-{
- bool result; /* Besoin à renvoyer */
- const mrange_t *sym_range; /* Emplacement du symbole */
- size_t index; /* Zone trouvée à scinder */
- mem_area *area; /* Aire en cours de traitement */
- mem_area saved; /* Aire aux données copiées */
- mrange_t area_range; /* Emplacement d'une aire */
- vmpa2t area_pos; /* Position relative à une aire*/
- vmpa2t sym_pos; /* Position pour un symbole */
- phys_t diff; /* Décalage entre localisation */
- phys_t new_length; /* Nouvelle taille de zone */
-
- sym_range = g_binary_symbol_get_range(symbol);
-
- index = find_memory_area_by_addr(*list, *count, get_mrange_addr(sym_range));
- assert(index < *count);
-
- result = (working >= index);
-
- area = &(*list)[index];
-
- if (area->has_sym) return false;
-
- assert(!area->has_sym);
-
-
-
-
-
- saved = *area;
-
- copy_mrange(&area_range, &area->range);
-
- copy_vmpa(&area_pos, get_mrange_addr(&area_range));
- copy_vmpa(&sym_pos, get_mrange_addr(sym_range));
-
- /* Si le symbole est construit avec une localisation partielle, on complète ! */
- if (get_phy_addr(&sym_pos) == VMPA_NO_PHYSICAL || get_virt_addr(&sym_pos) == VMPA_NO_VIRTUAL)
- {
- assert(false);
-
- diff = compute_vmpa_diff(&area_pos, &sym_pos);
-
- copy_vmpa(&sym_pos, &area_pos);
- advance_vmpa(&sym_pos, diff);
-
- g_binary_symbol_fix_range(symbol, &sym_pos);
-
- }
-
- /* Si le symbole a une taille identique à la zone qui le contient, on remplace simplement... */
- if (get_mrange_length(&area_range) == get_mrange_length(sym_range))
- {
- assert((cmp_vmpa(&area_pos, &sym_pos) == 0));
-
- init_mem_area_from_range(area, sym_range);
-
- area->has_sym = true;
- area->symbol = symbol;
-
- goto iesima_done;
-
- }
-
- /* Si le symbole se trouve en début de zone... */
- if (cmp_vmpa(&area_pos, &sym_pos) == 0)
- {
- *list = (mem_area *)realloc(*list, ++(*count) * sizeof(mem_area));
-
- memmove(&(*list)[index + 1], &(*list)[index], (*count - index - 1) * sizeof(mem_area));
-
- /* Aire du symbole */
-
- area = &(*list)[index];
-
- init_mem_area_from_range(area, sym_range);
-
- area->has_sym = true;
- area->symbol = symbol;
-
- /* Aire raccourcie */
-
- copy_vmpa(&area_pos, get_mrange_addr(&saved.range));
- advance_vmpa(&area_pos, get_mrange_length(sym_range));
-
- //compute_mrange_end_addr(sym_range, &area_pos);
- new_length = get_mrange_length(&area_range) - get_mrange_length(sym_range);
-
- area = &(*list)[index + 1];
-
- init_mem_area_from_bigger_area(area, &area_pos, new_length, &saved);
-
- goto iesima_done;
-
- }
-
- compute_mrange_end_addr(&area->range, &area_pos);
- compute_mrange_end_addr(sym_range, &sym_pos);
-
- /* Si le symbole se trouve en fin de zone... */
- if (cmp_vmpa(&area_pos, &sym_pos) == 0)
- {
- *list = (mem_area *)realloc(*list, ++(*count) * sizeof(mem_area));
-
- memmove(&(*list)[index + 1], &(*list)[index], (*count - index - 1) * sizeof(mem_area));
-
- copy_vmpa(&area_pos, get_mrange_addr(&area_range));
- new_length = get_mrange_length(&area_range) - get_mrange_length(sym_range);
-
- area = &(*list)[index];
-
- init_mem_area_from_bigger_area(area, &area_pos, new_length, &saved);
-
- /* Aire du symbole */
-
- area = &(*list)[index + 1];
-
- init_mem_area_from_range(area, sym_range);
-
- area->has_sym = true;
- area->symbol = symbol;
-
- }
-
- /* Sinon il se trouve au milieu et on découpe en trois... */
- else
- {
- *count += 2;
- *list = (mem_area *)realloc(*list, *count * sizeof(mem_area));
-
- memmove(&(*list)[index + 2], &(*list)[index], (*count - index - 2) * sizeof(mem_area));
-
- /* Aire raccourcie #1 */
-
- copy_vmpa(&area_pos, get_mrange_addr(&area_range));
- new_length = compute_vmpa_diff(&area_pos, get_mrange_addr(sym_range));
-
- assert(new_length != 0); /* Symbole non présent au début */
-
- area = &(*list)[index];
-
- init_mem_area_from_bigger_area(area, &area_pos, new_length, &saved);
-
- /* Aire du symbole */
-
- area = &(*list)[index + 1];
-
- init_mem_area_from_range(area, sym_range);
-
- area->has_sym = true;
- area->symbol = symbol;
-
- /* Aire raccourcie #2 */
-
- copy_vmpa(&area_pos, get_mrange_addr(&saved.range));
- advance_vmpa(&area_pos, get_mrange_length(&(*list)[index].range));
- advance_vmpa(&area_pos, get_mrange_length(sym_range));
-
- //compute_mrange_end_addr(sym_range, &area_pos);
- new_length = get_mrange_length(&area_range) - get_mrange_length(sym_range) \
- - get_mrange_length(&(*list)[index].range);
-
- assert(new_length != 0); /* Symbole non présent à la fin */
-
- area = &(*list)[index + 2];
-
- init_mem_area_from_bigger_area(area, &area_pos, new_length, &saved);
-
- }
-
- fini_mem_area(&saved);
-
- iesima_done:
-
- return result;
-
-}
-
-
-
-
-
-
-
-
-
-/******************************************************************************
-* *
-* Paramètres : list = listes de zones utable à consulter. *
-* count = nombre de zones mises en place. *
-* addr = adresse à retrouver dans les aires présentes. *
-* *
-* Description : Détermine une liste de zones contigües à traiter. *
-* *
-* Retour : Indice de la zone trouvée, ou nombre d'aires en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-size_t find_memory_area_by_addr(mem_area *list, size_t count, const vmpa2t *addr)
-{
- size_t result; /* Trouvaille à retourner */
- mem_area *found; /* Elément trouvé éventuel */
-
- int find_mem_area(const vmpa2t *addr, const mem_area *area)
- {
- int status; /* Bilan à retourner */
-
- if (mrange_contains_addr(&area->range, addr))
- status = 0;
-
- else
- status = cmp_vmpa(addr, get_mrange_addr(&area->range));
-
- return status;
-
- }
-
- found = bsearch(addr, list, count, sizeof(mem_area), (__compar_fn_t)find_mem_area);
-
- result = (found != NULL ? found - list : count);
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : list = liste de zones délimitant des contenus à traiter. *
-* count = nombre de zones à disposition. *
-* range = aire des octets à manipuler. *
-* visitor = fonction opérationnelle finale à appeler. *
-* *
-* Description : Manipule la cartographie des octets d'aires de données. *
-* *
-* Retour : valeur retournée par le visiteur, voire false si erreur. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static bool handle_bytes_map_in_mem_area(mem_area *list, size_t count, const mrange_t *range, GArchInstruction *instr, visit_bytes_map_fc visitor)
-{
- bool result; /* Bilan à retourner */
- size_t found; /* Indice de la zone trouvée */
- mem_area *area; /* Aire à traiter trouvée */
- phys_t offset; /* Point de départ dans l'aire */
- phys_t remaining; /* Quantité restant à traiter */
- phys_t processed; /* Quantité traitée */
- vmpa2t start; /* Point de départ suivant */
-
- result = false;
-
- found = find_memory_area_by_addr(list, count, get_mrange_addr(range));
- if (found == count) return false;
-
- area = list + found;
-
- offset = compute_vmpa_diff(get_mrange_addr(&area->range), get_mrange_addr(range));
- remaining = get_mrange_length(range);
-
- /* Traitement intégral dans la zone trouvée */
-
- if ((offset + remaining) <= get_mrange_length(&area->range))
- result = visitor(area, offset, remaining, instr);
-
- else
- {
-
- printf("BUG_ON | off=%u remaining=%u length=%u\n",
- (unsigned int)offset,
- (unsigned int)remaining,
- (unsigned int)get_mrange_length(&area->range));
-
- printf("BUG_ON @ 0x%08x + %d\n",
- (unsigned int)get_virt_addr(get_mrange_addr(range)),
- (int)get_mrange_length(range)
- );
-
-
- assert(0);
-
- /* Traitement de la fin de la première aire */
-
- processed = get_mrange_length(&area->range) - offset;
-
- result = visitor(area, offset, processed, instr);
-
- /* Traitement des zones adjacentes suivantes */
-
- copy_vmpa(&start, get_mrange_addr(range));
-
- for (remaining -= processed; remaining > 0 && result; remaining -= processed)
- {
- advance_vmpa(&start, processed);
-
- found = find_memory_area_by_addr(list, count, &start);
- if (found == count)
- {
- result = false;
- break;
- }
-
- area = list + found;
-
- processed = get_mrange_length(&area->range);
- if (remaining < processed) processed = remaining;
-
- result = visitor(area, 0, processed, instr);
-
- }
-
- }
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : list = liste de zones délimitant des contenus à traiter. *
-* count = nombre de zones à disposition. *
-* range = aire des octets à manipuler. *
-* *
-* Description : Indique si une zone donnée est intégralement vierge ou non. *
-* *
-* Retour : true si l'aire visée n'a jamais été traitée, false sinon. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static bool is_range_blank_in_mem_areas(mem_area *list, size_t count, const mrange_t *range)
-{
- return handle_bytes_map_in_mem_area(list, count,
- range, NULL,
- is_range_blank_in_mem_area);
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : list = liste de zones délimitant des contenus à traiter. *
-* count = nombre de zones à disposition. *
-* instr = instruction désassemblée à conserver en mémoire. *
-* *
-* Description : Marque une série d'octets comme ayant été traités. *
-* *
-* Retour : true. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static bool mark_range_in_mem_areas_as_processed(mem_area *list, size_t count, GArchInstruction *instr)
-{
- return handle_bytes_map_in_mem_area(list, count,
- g_arch_instruction_get_range(instr), instr,
- mark_range_in_mem_area_as_processed);
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : areas = série d'aires représentant à contenu à parcourir. *
+* Paramètres : list = série d'aires représentant du contenu à libérer. *
* count = nombre de ces zones présentes. *
* *
-* Description : Rassemble les instructions conservées dans des zones données.*
+* Description : Libère la mémoire occupée par des zones de données. *
* *
-* Retour : Liste d'instructions prêtes à emploi. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-GArchInstruction *collect_instructions_from_mem_areas(mem_area *list, size_t count)
+void release_mem_areas(mem_area *list, size_t count)
{
- GArchInstruction *result; /* Liste d'instr. à renvoyer */
size_t i; /* Boucle de parcours */
- GArchInstruction *instr; /* Instruction(s) à insérer */
-
- result = NULL;
for (i = 0; i < count; i++)
- {
- instr = get_instructions_from_mem_area(&list[i]);
- g_arch_instruction_merge_lists(&result, &instr);
- }
+ fini_mem_area(&list[i]);
- return result;
+ free(list);
}
diff --git a/src/analysis/disass/area.h b/src/analysis/disass/area.h
index abfa509..99113f6 100644
--- a/src/analysis/disass/area.h
+++ b/src/analysis/disass/area.h
@@ -31,96 +31,30 @@
-
/* Zone mémoire bien bornée */
-typedef struct _mem_area_v2 mem_area_v2;
-
-
-
+typedef struct _mem_area mem_area;
/* Procède au désassemblage d'un contenu binaire exécutable. */
-void load_code_from_mem_area_v2(mem_area_v2 *, mem_area_v2 *, size_t, GProcContext *, const vmpa2t *, bool, GtkStatusStack *, activity_id_t);
-
-
-
+void load_code_from_mem_area(mem_area *, mem_area *, size_t, GProcContext *, const vmpa2t *, bool, GtkStatusStack *, activity_id_t);
/* Détermine une liste de zones contigües à traiter. */
-mem_area_v2 *find_memory_area_by_addr_v2(mem_area_v2 *, size_t, const vmpa2t *);
-
-
+mem_area *compute_memory_areas(const GLoadedBinary *, phys_t, size_t *);
/* Détermine une liste de zones contigües à traiter. */
-mem_area_v2 *compute_memory_areas_v2(const GLoadedBinary *, phys_t, size_t *);
+mem_area *find_memory_area_by_addr(mem_area *, size_t, const vmpa2t *);
/* Insère un symbole dans un découpage en aires. */
-void insert_extra_symbol_into_mem_areas_v2(mem_area_v2 *, size_t, const GBinSymbol *);
+void insert_extra_symbol_into_mem_areas(mem_area *, size_t, const GBinSymbol *);
/* S'assure que l'ensemble des aires est entièrement décodé. */
-void ensure_all_mem_areas_are_filled(mem_area_v2 *, size_t, GProcContext *, GtkStatusStack *, activity_id_t);
+void ensure_all_mem_areas_are_filled(mem_area *, size_t, GProcContext *, GtkStatusStack *, activity_id_t);
/* Rassemble les instructions conservées dans des zones données. */
-GArchInstruction *collect_instructions_from_mem_areas_v2(const mem_area_v2 *, size_t);
-
-
-
-
-
-#include <stdbool.h>
-
-
-
-
-#include "../binary.h"
-#include "../../format/executable.h"
-#include "../../gtkext/gtkextstatusbar.h"
-
-
-//////
-#include "../../arch/raw.h"
-#include "../../arch/instruction.h"
-
-
-
-/* Zone mémoire bien bornée */
-typedef struct _mem_area mem_area;
-
+GArchInstruction *collect_instructions_from_mem_areas(const mem_area *, size_t);
-
-
-
-
-
-/* Procède au désassemblage d'un contenu binaire exécutable. */
-bool load_code_from_mem_area(mem_area **, size_t *, size_t *, const GLoadedBinary *, GProcContext *, const vmpa2t *, status_blob_info *);
-
-
-
-
-
-/* S'assure qu'une aire qqcontient toutes ses instructions. */
-void fill_mem_area(mem_area **, size_t *, size_t *, const GLoadedBinary *, GProcContext *, status_blob_info *);
-
-
-
-/* Détermine une liste de zones contigües à traiter. */
-mem_area *compute_memory_areas(GExeFormat *, phys_t, size_t *);
-
-
-
-
-
-
-
-/* Détermine une liste de zones contigües à traiter. */
-size_t find_memory_area_by_addr(mem_area *, size_t, const vmpa2t *);
-
-
-
-
-
-/* Rassemble les instructions conservées dans des zones données. */
-GArchInstruction *collect_instructions_from_mem_areas(mem_area *, size_t);
+/* Libère la mémoire occupée par des zones de données. */
+void release_mem_areas(mem_area *, size_t);
diff --git a/src/analysis/disass/fetch.c b/src/analysis/disass/fetch.c
index ab3f3c7..9df9248 100644
--- a/src/analysis/disass/fetch.c
+++ b/src/analysis/disass/fetch.c
@@ -35,13 +35,7 @@
-
-
-
-
-
/* ------------------------- RECUPERATIONS EN TOILE DE FOND ------------------------- */
-/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */
#define G_TYPE_DELAYED_FETCHING g_delayed_fetching_get_type()
@@ -62,7 +56,7 @@ typedef struct _GDelayedFetching
GExeFormat *format; /* Format du fichier binaire */
GProcContext *ctx; /* Contexte de désassemblage */
- mem_area_v2 *areas; /* Zone de productions */
+ mem_area *areas; /* Zone de productions */
size_t count; /* Nombre de ces zones */
GtkStatusStack *status; /* Barre de statut */
@@ -100,29 +94,18 @@ static void g_delayed_fetching_finalize(GDelayedFetching *);
static GDelayedFetching *g_delayed_fetching_new(const GDelayedFetching *, DisassPriorityLevel, virt_t);
/* Assure la récupération d'instructions en différé. */
-static void g_delayed_fetching_process(GDelayedFetching *, GtkExtStatusBar *);
-
-
-
-
-
-
+static void g_delayed_fetching_process(GDelayedFetching *, GtkStatusStack *);
-
-/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */
/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */
+/* Poursuit l'analyse à partir des points d'entrée découverts. */
+static void follow_execution_flow(GProcContext *, const GDelayedFetching *);
-
-/* Suit un flot d'exécution pour désassembler du code. */
-static void follow_execution_flow(const GLoadedBinary *, GProcContext *, mem_area **, size_t *, status_blob_info *);
-
-
-
-
+/* Etudie le besoin d'attendre d'avantage de prochaines tâches. */
+static bool check_if_extra_wait_is_needed(GWorkQueue *, wgroup_id_t, GProcContext *);
@@ -131,12 +114,6 @@ static void follow_execution_flow(const GLoadedBinary *, GProcContext *, mem_are
/* ---------------------------------------------------------------------------------- */
-
-
-
-
-
-
/* Indique le type défini pour les tâches de récupération différée. */
G_DEFINE_TYPE(GDelayedFetching, g_delayed_fetching, G_TYPE_DELAYED_WORK);
@@ -280,8 +257,8 @@ static GDelayedFetching *g_delayed_fetching_new(const GDelayedFetching *template
/******************************************************************************
* *
-* Paramètres : fetching = récupération à mener. *
-* statusbar = barre de statut à tenir informée. *
+* Paramètres : fetching = récupération à mener. *
+* status = barre de statut à tenir informée. *
* *
* Description : Assure la récupération d'instructions en différé. *
* *
@@ -291,18 +268,18 @@ static GDelayedFetching *g_delayed_fetching_new(const GDelayedFetching *template
* *
******************************************************************************/
-static void g_delayed_fetching_process(GDelayedFetching *fetching, GtkExtStatusBar *statusbar)
+static void g_delayed_fetching_process(GDelayedFetching *fetching, GtkStatusStack *status)
{
vmpa2t addr; /* Conversion en pleine adresse*/
- mem_area_v2 *area; /* Zone trouvée à traiter */
+ mem_area *area; /* Zone trouvée à traiter */
if (!g_exe_format_translate_address_into_vmpa(fetching->format, fetching->virt, &addr))
- return/*init_vmpa(&addr, VMPA_NO_PHYSICAL, fetching->virt)*/;
+ return;
- area = find_memory_area_by_addr_v2(fetching->areas, fetching->count, &addr);
+ area = find_memory_area_by_addr(fetching->areas, fetching->count, &addr);
if (area != NULL)
- load_code_from_mem_area_v2(area, fetching->areas, fetching->count,
+ load_code_from_mem_area(area, fetching->areas, fetching->count,
fetching->ctx, &addr, fetching->level < 2,
fetching->status, fetching->id);
@@ -310,21 +287,9 @@ static void g_delayed_fetching_process(GDelayedFetching *fetching, GtkExtStatusB
-
-
-
-
-
-
-
-/* Poursuit l'analyse à partir des points d'entrée découverts. */
-static void follow_execution_flow_v2(GProcContext *, const GDelayedFetching *);
-
-/* Etudie le besoin d'attendre d'avantage de prochaines tâches. */
-static bool check_if_extra_wait_is_needed(GWorkQueue *, wgroup_id_t, GProcContext *);
-
-
-
+/* ---------------------------------------------------------------------------------- */
+/* DESASSEMBLAGE DE BINAIRE DIFFERE */
+/* ---------------------------------------------------------------------------------- */
/******************************************************************************
@@ -340,7 +305,7 @@ static bool check_if_extra_wait_is_needed(GWorkQueue *, wgroup_id_t, GProcContex
* *
******************************************************************************/
-static void follow_execution_flow_v2(GProcContext *ctx, const GDelayedFetching *template)
+static void follow_execution_flow(GProcContext *ctx, const GDelayedFetching *template)
{
GWorkQueue *queue; /* Gestionnaire de différés */
gint *remaining_counter; /* Compteur à considérer */
@@ -410,73 +375,6 @@ static bool check_if_extra_wait_is_needed(GWorkQueue *queue, wgroup_id_t id, GPr
}
-
-
-
-
-
-
-
-
-
-
-
-/******************************************************************************
-* *
-* Paramètres : binary = représentation de binaire chargé. *
-* ctx = contexte offert en soutien à un désassemblage. *
-* areas = liste de zones contenant des données à traiter. *
-* count = nombre de ces aires à disposition. *
-* info = informations liées à l'affichage de la progression. *
-* *
-* Description : Suit un flot d'exécution pour désassembler du code. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static void follow_execution_flow(const GLoadedBinary *binary, GProcContext *ctx, mem_area **areas, size_t *count, status_blob_info *info)
-{
-#if 0
- virt_t virt; /* Adresse de départ dépilée */
- vmpa2t addr; /* Conversion en pleine adresse*/
- GExeFormat *format; /* Format du fichier binaire */
- size_t index; /* Zone trouvée à traiter */
-
- while (g_proc_context_has_drop_points(ctx))
- {
- g_proc_context_pop_drop_point(ctx, &virt);
-
- format = g_loaded_binary_get_format(binary);
-
- if (!g_exe_format_translate_address_into_vmpa(format, virt, &addr))
- init_vmpa(&addr, VMPA_NO_PHYSICAL, virt);
-
- printf(" ++ point 0x%08x\n", (unsigned int)virt);
-
-
- printf("looking area for 0x%08x\n", (unsigned int)virt);
-
- index = find_memory_area_by_addr(*areas, *count, &addr);
- if (index == *count) continue;
-
- assert(index < *count);
-
- load_code_from_mem_area(areas, count, &index, binary, ctx, &addr, info);
-
-
-
- printf(" ++\n");
-
-
- }
-#endif
-}
-
-static GDelayedFetching template; /* Patron des tâches à venir */
-
/******************************************************************************
* *
* Paramètres : binary = représentation de binaire chargé. *
@@ -495,7 +393,7 @@ static GDelayedFetching template; /* Patron des tâches à venir
GArchInstruction *disassemble_binary_content(const GLoadedBinary *binary, GProcContext *ctx, wgroup_id_t gid, GtkStatusStack *status)
{
GArchInstruction *result; /* Instruction désassemblées */
- //GDelayedFetching template; /* Patron des tâches à venir */
+ GDelayedFetching template; /* Patron des tâches à venir */
GBinFormat *format; /* Format du fichier binaire */
GBinContent *content; /* Contenu binaire à manipuler */
phys_t length; /* Taille des données à lire */
@@ -515,7 +413,7 @@ GArchInstruction *disassemble_binary_content(const GLoadedBinary *binary, GProcC
length = g_binary_content_compute_size(content);
g_object_unref(G_OBJECT(content));
- template.areas = compute_memory_areas_v2(binary, length, &template.count);
+ template.areas = compute_memory_areas(binary, length, &template.count);
template.status = status;
@@ -537,7 +435,7 @@ GArchInstruction *disassemble_binary_content(const GLoadedBinary *binary, GProcC
(wait_for_incoming_works_cb)check_if_extra_wait_is_needed,
template.ctx);
- g_signal_connect(template.ctx, "drop-point-pushed", G_CALLBACK(follow_execution_flow_v2), &template);
+ g_signal_connect(template.ctx, "drop-point-pushed", G_CALLBACK(follow_execution_flow), &template);
template.id = gtk_status_stack_add_activity(status,
_("Disassembling following the execution flow..."),
@@ -567,7 +465,7 @@ GArchInstruction *disassemble_binary_content(const GLoadedBinary *binary, GProcC
gtk_status_stack_update_activity(status, template.id, _("Collecting disassembled instructions..."));
- result = collect_instructions_from_mem_areas_v2(template.areas, template.count);
+ result = collect_instructions_from_mem_areas(template.areas, template.count);
gtk_status_stack_remove_activity(status, template.id);
@@ -575,7 +473,7 @@ GArchInstruction *disassemble_binary_content(const GLoadedBinary *binary, GProcC
//g_object_unref(G_OBJECT(template.format));
- /* TODO / del(areas); */
+ release_mem_areas(template.areas, template.count);
return result;