summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/analysis/disass/fetch.c20
-rw-r--r--src/arch/vmpa.c246
-rw-r--r--src/arch/vmpa.h81
-rw-r--r--src/glibext/gbufferline.c6
4 files changed, 186 insertions, 167 deletions
diff --git a/src/analysis/disass/fetch.c b/src/analysis/disass/fetch.c
index 4686fe2..1f93465 100644
--- a/src/analysis/disass/fetch.c
+++ b/src/analysis/disass/fetch.c
@@ -56,8 +56,8 @@ GArchInstruction *load_raw_binary(const GLoadedBinary *binary, const vmpa2t *bas
GArchProcessor *proc; /* Architecture du binaire */
off_t bin_length; /* Taille des données à lire */
bin_t *bin_data; /* Données binaires à lire */
- vmpa2t *pos; /* Boucle de parcours */
- vmpa2t *prev; /* Boucle de parcours */
+ vmpa2t pos; /* Boucle de parcours */
+ vmpa2t prev; /* Boucle de parcours */
off_t old_phy; /* Ancienne position physique */
GArchInstruction *instr; /* Instruction décodée */
off_t new_phy; /* Nouvelle position physique */
@@ -70,23 +70,23 @@ GArchInstruction *load_raw_binary(const GLoadedBinary *binary, const vmpa2t *bas
end = bin_length;
- pos = local_dup_vmpa(base);
- prev = local_dup_vmpa(base);
+ copy_vmpa(&pos, base);
+ copy_vmpa(&prev, base);
- old_phy = get_phy_addr(prev);
+ old_phy = get_phy_addr(&prev);
while (old_phy < end)
{
- instr = g_db_instruction_new_from_data(bin_data, pos, end, proc);
+ instr = g_db_instruction_new_from_data(bin_data, &pos, end, proc);
if (instr == NULL) break;
- new_phy = get_phy_addr(pos);
+ new_phy = get_phy_addr(&pos);
- g_arch_instruction_set_location(instr, prev, new_phy - old_phy);
+ g_arch_instruction_set_location(instr, &prev, new_phy - old_phy);
g_arch_instruction_add_to_list(&result, instr);
- copy_vmpa(prev, pos);
- old_phy = get_phy_addr(prev);
+ copy_vmpa(&prev, &pos);
+ old_phy = get_phy_addr(&prev);
//done += (new_phy - old_phy);
//gtk_extended_status_bar_update_activity(statusbar, id, done * 1.0 / sum);
diff --git a/src/arch/vmpa.c b/src/arch/vmpa.c
index 4ee0b99..93bbfc8 100644
--- a/src/arch/vmpa.c
+++ b/src/arch/vmpa.c
@@ -33,35 +33,52 @@
+/******************************************************************************
+* *
+* Paramètres : addr = élément à initialiser. *
+* phy = position dans la mémoire physique. *
+* virt = adresse dans la mémoire virtuelle. *
+* *
+* Description : Initialise une localisation dans l'espace mémoire/physique. *
+* *
+* Retour : Adressage alloué en mémoire. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+void init_vmpa(vmpa2t *addr, off_t phy, uint64_t virt)
+{
+ addr->physical = phy;
+ addr->virtual = virt;
+}
-#if 0
/******************************************************************************
* *
-* Paramètres : src = définition à copier. *
+* Paramètres : phy = position dans la mémoire physique. *
+* virt = adresse dans la mémoire virtuelle. *
* *
-* Description : Crée la copie d'un adressage mémoire en local. *
+* Description : Crée une localisation dans l'adressage mémoire. *
* *
-* Retour : Adressage alloué sur la pile. *
+* Retour : Adressage alloué en mémoire. *
* *
* Remarques : - *
* *
******************************************************************************/
-inline vmpa2t *local_dup_vmpa(const vmpa2t *src)
+vmpa2t *make_vmpa(off_t phy, uint64_t virt)
{
- vmpa2t *result; /* Adressage à retourner */
+ vmpa2t *result; /* Structure à retourner */
- result = alloca(sizeof(vmpa2t));
+ result = (vmpa2t *)calloc(1, sizeof(vmpa2t));
- copy_vmpa(result, src);
+ init_vmpa(result, phy, virt);
return result;
}
-#endif
/******************************************************************************
@@ -80,92 +97,133 @@ inline vmpa2t *local_dup_vmpa(const vmpa2t *src)
void copy_vmpa(vmpa2t *dest, const vmpa2t *src)
{
dest->physical = src->physical;
- dest->virtual= src->virtual;
-
- dest->last_phys_size = src->last_phys_size;
- dest->last_virt_size = src->last_virt_size;
-
- strncpy(dest->phys_cache, src->phys_cache, VMPA_MAX_SIZE);
- dest->phys_cache[VMPA_MAX_SIZE - 1] = '\0';
-
- strncpy(dest->virt_cache, src->virt_cache, VMPA_MAX_SIZE);
- dest->virt_cache[VMPA_MAX_SIZE - 1] = '\0';
+ dest->virtual = src->virtual;
}
+/******************************************************************************
+* *
+* Paramètres : a = première définition à analyser. *
+* b = seconde définition à analyser. *
+* *
+* Description : Compare entre elles deux adresses physiques. *
+* *
+* Retour : Bilan de la comparaison : -1, 0 ou 1. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+int cmp_vmpa_by_phy(const vmpa2t *a, const vmpa2t *b)
+{
+ int result; /* Bilan à retourner */
+ if (a->physical != VMPA_NO_PHYSICAL && b->physical != VMPA_NO_PHYSICAL)
+ {
+ if (a->physical < b->physical) result = -1;
+ else if (a->physical > b->physical) result = 1;
+ else result = 0;
+ }
+ else
+ {
+ if (a->physical == VMPA_NO_PHYSICAL && b->physical == VMPA_NO_PHYSICAL) result = 0;
+ else if (a->physical == VMPA_NO_PHYSICAL) result = -1;
+ else result = 1;
+ }
+ return result;
-
-
-
-
-
-
+}
/******************************************************************************
* *
-* Paramètres : phy = position dans la mémoire physique. *
-* virt = adresse dans la mémoire virtuelle. *
+* Paramètres : a = première définition à analyser. *
+* b = seconde définition à analyser. *
* *
-* Description : Crée une localisation dans l'adressage mémoire. *
+* Description : Compare entre elles deux adresses virtuelles. *
* *
-* Retour : Adressage alloué en mémoire. *
+* Retour : Bilan de la comparaison : -1, 0 ou 1. *
* *
* Remarques : - *
* *
******************************************************************************/
-vmpa2t *make_vmpa(off_t phy, uint64_t virt)
+int cmp_vmpa_by_virt(const vmpa2t *a, const vmpa2t *b)
{
- vmpa2t *result; /* Structure à retourner */
-
- result = (vmpa2t *)calloc(1, sizeof(vmpa2t));
+ int result; /* Bilan à retourner */
- result->physical = phy;
- result->virtual = virt;
+ if (a->virtual != VMPA_NO_VIRTUAL && b->virtual != VMPA_NO_VIRTUAL)
+ {
+ if (a->virtual < b->virtual) result = -1;
+ else if (a->virtual > b->virtual) result = 1;
+ else result = 0;
+ }
+ else
+ {
+ if (a->virtual == VMPA_NO_VIRTUAL && b->virtual == VMPA_NO_VIRTUAL) result = 0;
+ else if (a->virtual == VMPA_NO_VIRTUAL) result = -1;
+ else result = 1;
+ }
return result;
}
-
-
-
/******************************************************************************
* *
-* Paramètres : addr = élément à initialiser. *
-* phy = position dans la mémoire physique. *
-* virt = adresse dans la mémoire virtuelle. *
+* Paramètres : addr = élément à modifier. *
+* qty = quantité d'unités de décallage. *
* *
-* Description : Initialise une localisation dans l'espace mémoire/physique. *
+* Description : Décalle une position d'une certaine quantité. *
* *
-* Retour : Adressage alloué en mémoire. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-void init_vmpa(vmpa2t *addr, off_t phy, uint64_t virt)
+void advance_vmpa(vmpa2t *addr, off_t qty)
{
- addr->physical = phy;
- addr->virtual = virt;
+ if (addr->physical != VMPA_NO_PHYSICAL)
+ addr->physical += qty;
+ if (addr->virtual != VMPA_NO_VIRTUAL)
+ addr->virtual =+ qty;
+}
- MDS_UNDEFINED;
+/******************************************************************************
+* *
+* Paramètres : a = première élément à venir consulter. *
+* b = second élément à traiter en parallèle. *
+* *
+* Description : Calcule au mieux la distance entre deux coordonnées. *
+* *
+* Retour : Distance absolue entre deux localisations. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+off_t compute_vmpa_diff(const vmpa2t *a, const vmpa2t *b)
+{
+ off_t result; /* Valeur à retourner */
-}
+ result = VMPA_NO_PHYSICAL;
+ if (a->physical != VMPA_NO_PHYSICAL && b->physical != VMPA_NO_PHYSICAL)
+ result = (b->physical > a->physical ? b->physical - a->physical : a->physical- b->physical);
+ else if (a->virtual != VMPA_NO_VIRTUAL && b->virtual != VMPA_NO_VIRTUAL)
+ result = (off_t)(b->virtual > a->virtual ? b->virtual - a->virtual : a->virtual- b->virtual);
+ return result;
+}
/******************************************************************************
@@ -235,6 +293,7 @@ bool send_vmpa(const vmpa2t *addr, int fd, int flags)
* *
* Paramètres : addr = adresse virtuelle ou physique à traiter. *
* msize = taille de cette adresse, réelle ou désirée. *
+* buffer = tampon de sortie utilisé à constituer. [OUT] *
* length = transmission de la taille du résultat ou NULL. [OUT]*
* *
* Description : Transforme une adresse physique en chaîne de caractères. *
@@ -245,45 +304,38 @@ bool send_vmpa(const vmpa2t *addr, int fd, int flags)
* *
******************************************************************************/
-const char *vmpa2_phys_to_string(vmpa2t *addr, MemoryDataSize msize, size_t *length)
+char *vmpa2_phys_to_string(const vmpa2t *addr, MemoryDataSize msize, char buffer[VMPA_MAX_LEN], size_t *length)
{
size_t ret; /* Retour de l'impression */
- if (addr->phys_cache[0] == '\0' || addr->last_phys_size != msize)
+ switch (msize)
{
- switch (msize)
- {
- case MDS_8_BITS:
- ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->physical);
- break;
-
- case MDS_16_BITS:
- ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->physical);
- break;
-
- case MDS_32_BITS:
- ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->physical);
- break;
+ case MDS_8_BITS:
+ ret = snprintf(buffer, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->physical);
+ break;
- case MDS_64_BITS:
- ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->physical);
- break;
+ case MDS_16_BITS:
+ ret = snprintf(buffer, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->physical);
+ break;
- default:
- ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE, "???");
- break;
+ case MDS_32_BITS:
+ ret = snprintf(buffer, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->physical);
+ break;
- }
+ case MDS_64_BITS:
+ ret = snprintf(buffer, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->physical);
+ break;
- addr->last_phys_size = msize;
- addr->last_phys_len = ret;
+ default:
+ ret = snprintf(buffer, VMPA_MAX_SIZE, "???");
+ break;
}
if (length != NULL)
- *length = addr->last_phys_size;
+ *length = ret;
- return addr->phys_cache;
+ return buffer;
}
@@ -292,6 +344,7 @@ const char *vmpa2_phys_to_string(vmpa2t *addr, MemoryDataSize msize, size_t *len
* *
* Paramètres : addr = adresse virtuelle ou physique à traiter. *
* msize = taille de cette adresse, réelle ou désirée. *
+* buffer = tampon de sortie utilisé à constituer. [OUT] *
* length = transmission de la taille du résultat ou NULL. [OUT]*
* *
* Description : Transforme une adresse virtuelle en chaîne de caractères. *
@@ -302,44 +355,37 @@ const char *vmpa2_phys_to_string(vmpa2t *addr, MemoryDataSize msize, size_t *len
* *
******************************************************************************/
-const char *vmpa2_virt_to_string(vmpa2t *addr, MemoryDataSize msize, size_t *length)
+char *vmpa2_virt_to_string(const vmpa2t *addr, MemoryDataSize msize, char buffer[VMPA_MAX_LEN], size_t *length)
{
size_t ret; /* Retour de l'impression */
- if (addr->virt_cache[0] == '\0' || addr->last_virt_size != msize)
+ switch (msize)
{
- switch (msize)
- {
- case MDS_8_BITS:
- ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->virtual);
- break;
-
- case MDS_16_BITS:
- ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->virtual);
- break;
-
- case MDS_32_BITS:
- ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->virtual);
- break;
+ case MDS_8_BITS:
+ ret = snprintf(buffer, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->virtual);
+ break;
- case MDS_64_BITS:
- ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->virtual);
- break;
+ case MDS_16_BITS:
+ ret = snprintf(buffer, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->virtual);
+ break;
- default:
- ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE, "???");
- break;
+ case MDS_32_BITS:
+ ret = snprintf(buffer, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->virtual);
+ break;
- }
+ case MDS_64_BITS:
+ ret = snprintf(buffer, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->virtual);
+ break;
- addr->last_virt_size = msize;
- addr->last_virt_len = ret;
+ default:
+ ret = snprintf(buffer, VMPA_MAX_SIZE, "???");
+ break;
}
if (length != NULL)
- *length = addr->last_virt_size;
+ *length = ret;
- return addr->virt_cache;
+ return buffer;
}
diff --git a/src/arch/vmpa.h b/src/arch/vmpa.h
index 461780c..7f417b5 100644
--- a/src/arch/vmpa.h
+++ b/src/arch/vmpa.h
@@ -25,7 +25,6 @@
#define _ARCH_VMPA_H
-#include <alloca.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
@@ -37,82 +36,57 @@
+/* Taille de la plus longue chaîne de représentation */
+#define VMPA_MAX_LEN (sizeof(STR(ULLONG_MAX)) + 1)
+/* Constitution guidée de tampons pour impression */
+#define VMPA_BUFFER(name) char name[VMPA_MAX_LEN]
-#define VMPA_MAX_SIZE (sizeof(STR(ULLONG_MAX)) + 1)
-
-
+#define VMPA_NO_PHYSICAL ((off_t)-1)
+#define VMPA_NO_VIRTUAL ((uint64_t)-2)
/* Adresse mémoire ou position physique */
-struct _vmpa2_t
+typedef struct _vmpa2t
{
off_t physical; /* Position physique */
uint64_t virtual; /* Adresse virtuelle */
- MemoryDataSize last_phys_size; /* Dernière taille demandée #1 */
- MemoryDataSize last_virt_size; /* Dernière taille demandée #2 */
- size_t last_phys_len; /* Dernière taille fournie #1 */
- size_t last_virt_len; /* Dernière taille fournie #2 */
- char phys_cache[VMPA_MAX_SIZE]; /* Impression physique cachée */
- char virt_cache[VMPA_MAX_SIZE]; /* Impression virtuelle cachée */
-
-};
-
-
-
-/* Adresse mémoire ou position physique */
-typedef struct _vmpa2_t vmpa2_t;
-
-
-typedef struct _vmpa2_t vmpa2t;
-
-
-
-
-/* Crée la copie d'un adressage mémoire en local. */
-//inline vmpa2t *local_dup_vmpa(const vmpa2t *) __attribute__((always_inline));
-
-
-
-#define local_dup_vmpa(src) \
- ({ \
- vmpa2t *__result; \
- __result = alloca(sizeof(vmpa2t)); \
- copy_vmpa(__result, src); \
- __result; \
- })
-
-
-
-/* Copie la définition d'un adressage dans un autre. */
-void copy_vmpa(vmpa2t *, const vmpa2t *);
-
-
-
+} vmpa2t;
/* Initialise une localisation dans l'espace mémoire/physique. */
void init_vmpa(vmpa2t *, off_t, uint64_t);
-
-
-
/* Crée une localisation dans l'adressage mémoire. */
vmpa2t *make_vmpa(off_t, uint64_t);
+#define delete_vmpa(a) free(a)
+/* Copie la définition d'un adressage dans un autre. */
+void copy_vmpa(vmpa2t *, const vmpa2t *);
-#define cmp_vmpa(a, b) 0
+/* Compare entre elles deux adresses physiques. */
+int cmp_vmpa_by_phy(const vmpa2t *, const vmpa2t *);
+/* Compare entre elles deux adresses virtuelles. */
+int cmp_vmpa_by_virt(const vmpa2t *, const vmpa2t *);
+#define are_equal(a, b) \
+ (cmp_vmpa_by_phy(a, b) == 0 && cmp_vmpa_by_virt(a, b) == 0)
-#define get_phy_addr(a) a->physical
-#define get_virt_addr(a) a->virtual
+#define get_phy_addr(a) (a)->physical
+#define get_virt_addr(a) (a)->virtual
+#define dup_vmpa(src) \
+ make_vmpa(get_phy_addr(src), get_virt_addr(src))
+/* Décalle une position d'une certaine quantité. */
+void advance_vmpa(vmpa2t *, off_t);
+/* Calcule au mieux la distance entre deux coordonnées. */
+off_t compute_vmpa_diff(const vmpa2t *, const vmpa2t *);
/* Lit la définition d'une adresse depuis un flux réseau. */
bool recv_vmpa(vmpa2t *, int, int);
@@ -121,11 +95,10 @@ bool recv_vmpa(vmpa2t *, int, int);
bool send_vmpa(const vmpa2t *, int, int);
/* Transforme une adresse physique en chaîne de caractères. */
-const char *vmpa2_phys_to_string(vmpa2t *, MemoryDataSize, size_t *);
+char *vmpa2_phys_to_string(const vmpa2t *, MemoryDataSize, char [VMPA_MAX_LEN], size_t *);
/* Transforme une adresse virtuelle en chaîne de caractères. */
-const char *vmpa2_virt_to_string(vmpa2t *, MemoryDataSize, size_t *);
-
+char *vmpa2_virt_to_string(const vmpa2t *, MemoryDataSize, char [VMPA_MAX_LEN], size_t *);
diff --git a/src/glibext/gbufferline.c b/src/glibext/gbufferline.c
index 201c64b..fbca259 100644
--- a/src/glibext/gbufferline.c
+++ b/src/glibext/gbufferline.c
@@ -418,7 +418,7 @@ vmpa_t g_buffer_line_get_address(const GBufferLine *line)
void g_buffer_line_fill_for_instr(GBufferLine *line, MemoryDataSize psize, MemoryDataSize vsize, const bin_t *content, off_t length, bool full)
{
size_t len; /* Taille de l'élément inséré */
- char *address; /* Adresse au format texte */
+ VMPA_BUFFER(address); /* Adresse au format texte */
char *bin_code; /* Tampon du code binaire */
off_t start; /* Début de traitement */
off_t end; /* Limite de traitement */
@@ -428,10 +428,10 @@ void g_buffer_line_fill_for_instr(GBufferLine *line, MemoryDataSize psize, Memor
/* Adresse physique puis virtuelle */
- address = vmpa2_phys_to_string(line->addr, psize, &len);
+ vmpa2_phys_to_string(line->addr, psize, address, &len);
g_buffer_line_insert_text(line, BLC_PHYSICAL, address, len, RTT_RAW);
- address = vmpa2_virt_to_string(line->addr, vsize, &len);
+ vmpa2_virt_to_string(line->addr, vsize, address, &len);
g_buffer_line_insert_text(line, BLC_VIRTUAL, address, len, RTT_RAW);
/* Code brut */
generated by cgit v0.11.2-87-g4458 at 2024-12-25 18:03:29 (GMT)