/* Chrysalide - Outil d'analyse de fichiers binaires
* vmpa.h - prototypes des adressages virtuels ou physiques
*
* Copyright (C) 2014-2019 Cyrille Bagard
*
* This file is part of Chrysalide.
*
* Chrysalide is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* Chrysalide is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Chrysalide. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _ARCH_VMPA_H
#define _ARCH_VMPA_H
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include "../common/cpp.h"
#include "../common/datatypes.h"
#include "../common/packed.h"
#include "../common/sqlite.h"
/* ---------------------- DEFINITION D'UNE POSITION EN MEMOIRE ---------------------- */
/* Taille de la plus longue chaîne de représentation */
#define VMPA_MAX_LEN (2 + sizeof(XSTR(UINT64_MAX)) + 1)
/* Constitution guidée de tampons pour impression */
#define VMPA_BUFFER(name) char name[VMPA_MAX_LEN]
/* Types pour respectivement une position physique et une adresse virtuelle */
//#define phys_t uint64_t
//#define virt_t uint64_t
/* Equivalents pour GLib */
#define G_TYPE_PHYS uint64_t
#define G_TYPE_VIRT uint64_t
#define G_TYPE_PHYS_T G_TYPE_UINT64
#define G_TYPE_VIRT_T G_TYPE_UINT64
#define PHYS_CAST(v) ((uint64_t)v)
#define VIRT_CAST(v) ((uint64_t)v)
#define VMPA_NO_PHYSICAL ((phys_t)-1)
#define VMPA_NO_VIRTUAL ((virt_t)-2)
/* Adresse mémoire ou position physique */
typedef struct _vmpa2t
{
phys_t physical; /* Position physique */
virt_t virtual; /* Adresse virtuelle */
} vmpa2t;
/* Initialise une localisation dans l'espace mémoire/physique. */
void init_vmpa(vmpa2t *, phys_t, virt_t);
/* Crée une localisation dans l'adressage mémoire. */
vmpa2t *make_vmpa(phys_t, virt_t);
/* Copie une localisation dans l'adressage mémoire. */
vmpa2t *dup_vmpa(const vmpa2t *);
/* Supprime une localisation de l'espace mémoire. */
void delete_vmpa(vmpa2t *);
/* Copie la définition d'un adressage dans un autre. */
void copy_vmpa(vmpa2t *, const vmpa2t *);
/* Calcule une empreinte de localisation dans l'espace mémoire. */
uint32_t hash_vmpa(const vmpa2t *);
/* 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 *);
/* Compare deux localisations selon leurs parties définies. */
int cmp_vmpa(const vmpa2t *, const vmpa2t *);
#define get_phy_addr(a) (a)->physical
#define get_virt_addr(a) (a)->virtual
#define has_phys_addr(a) ((a)->physical != VMPA_NO_PHYSICAL)
#define has_virt_addr(a) ((a)->virtual != VMPA_NO_VIRTUAL)
#define is_invalid_vmpa(a) (!has_phys_addr(a) && !has_virt_addr(a))
#define reset_virt_addr(a) (a)->virtual = VMPA_NO_VIRTUAL
/* Décalle une position d'une certaine quantité. */
void advance_vmpa(vmpa2t *, phys_t);
/* Décalle une position d'une certaine quantité. */
void deminish_vmpa(vmpa2t *, phys_t);
/* Aligne une localisation sur un nombre d'octets donné. */
void align_vmpa(vmpa2t *, phys_t);
/* Calcule au mieux la distance entre deux coordonnées. */
phys_t compute_vmpa_diff(const vmpa2t *, const vmpa2t *);
/* Lit la définition d'une adresse depuis un tampon. */
bool unpack_vmpa(vmpa2t *, packed_buffer_t *);
/* Ecrit la définition d'une adresse dans un tampon. */
bool pack_vmpa(const vmpa2t *, packed_buffer_t *);
/* Transforme une adresse physique en chaîne de caractères. */
char *vmpa2_phys_to_string(const vmpa2t *, MemoryDataSize, char [VMPA_MAX_LEN], size_t *);
/* Transforme une adresse virtuelle en chaîne de caractères. */
char *vmpa2_virt_to_string(const vmpa2t *, MemoryDataSize, char [VMPA_MAX_LEN], size_t *);
/* Transforme une localisation en chaîne de caractères. */
char *vmpa2_to_string(const vmpa2t *, MemoryDataSize, char [VMPA_MAX_LEN], size_t *);
/* Transforme une chaîne de caractères en position physique. */
vmpa2t *string_to_vmpa_phy(const char *);
/* Transforme une chaîne de caractères en adresse virtuelle. */
vmpa2t *string_to_vmpa_virt(const char *);
/* Donne les éléments requis pour la construction d'une table. */
char *create_vmpa_db_table(const char *);
#if 0 // FIXME
/* Charge les valeurs utiles pour une localisation. */
bool load_vmpa(vmpa2t *, const char *, const bound_value *, size_t);
/* Constitue les champs destinés à une insertion / modification. */
bool store_vmpa(const vmpa2t *, const char *, bound_value **, size_t *);
#endif
/* ------------------------ DEFINITION DE POSITION AVEC BITS ------------------------ */
/* Adresse mémoire ou position physique */
typedef struct _ext_vmpa_t
{
vmpa2t base; /* Vision macroscopique */
uint8_t consumed_extra_bits; /* Avancée supplémentaire */
} ext_vmpa_t;
#define init_evmpa_from_vmpa(d, s) \
do \
{ \
copy_vmpa(&(d)->base, (s)); \
(d)->consumed_extra_bits = 0; \
} \
while (0)
#define copy_evmpa(d, s) \
do \
{ \
copy_vmpa(&(d)->base, &(s)->base); \
(d)->consumed_extra_bits = (s)->consumed_extra_bits; \
} \
while (0)
#define advance_evmpa_bits(a, q) \
do \
{ \
uint8_t __sum; \
__sum = (a)->consumed_extra_bits + q; \
if (__sum > 8) \
{ \
advance_vmpa(&(a)->base, __sum / 8); \
(a)->consumed_extra_bits = __sum % 8; \
} \
else \
(a)->consumed_extra_bits = __sum; \
} \
while (0)
#define align_evmpa_on_byte(a) \
do \
{ \
if ((a)->consumed_extra_bits > 0) \
{ \
advance_vmpa(&(a)->base, 1); \
(a)->consumed_extra_bits = 0; \
} \
} \
while (0);
/* ------------------------ AIDES FONCTIONNELLES AUXILIAIRES ------------------------ */
/* Construit une désignation de symbole avec décalage. */
char *make_symbol_offset(const char *, phys_t);
/* ------------------------ DEFINITION D'UNE ZONE EN MEMOIRE ------------------------ */
/* Couverture mémoire */
typedef struct _mrange_t
{
vmpa2t addr; /* Adresse physique/virtuelle */
phys_t length; /* Taille de la couverture */
} mrange_t;
#define UNUSED_MRANGE_PTR (mrange_t []) { { { 0 }, 0 } }
#define get_mrange_addr(r) &(r)->addr
#define get_mrange_length(r) (r)->length
#define set_mrange_length(r, l) (r)->length = l
/* Initialise une plage dans l'espace mémoire/physique. */
void init_mrange(mrange_t *, const vmpa2t *, phys_t);
/* Copie la définition d'une plage mémoire dans une autre. */
void copy_mrange(mrange_t *, const mrange_t *);
/* Compare deux couvertures mémoire selon leurs propriétés. */
int cmp_mrange(const mrange_t *, const mrange_t *);
/* Compare une couverture mémoire avec une localisation simple. */
int cmp_mrange_with_vmpa(const mrange_t *, const vmpa2t *);
static inline int cmp_mrange_with_vmpa_swapped(const vmpa2t *k, const mrange_t *r)
{
return cmp_mrange_with_vmpa(r, k);
}
/* Compare une couverture mémoire avec une localisation simple. */
int cmp_mrange_with_vmpa_inclusive(const mrange_t *, const vmpa2t *);
/* Indique si une zone en contient une autre ou non. */
int mrange_includes_mrange(const mrange_t *, const mrange_t *);
/* Indique si une zone en contient une autre ou non. */
bool mrange_contains_mrange(const mrange_t *, const mrange_t *);
/* Indique si une localisation est incluse dans une zone ou non. */
bool mrange_contains_addr(const mrange_t *, const vmpa2t *);
/* Indique si une localisation est incluse dans une zone ou non. */
bool mrange_contains_addr_inclusive(const mrange_t *, const vmpa2t *);
/* Détermine si deux zones mémoire se chevauchent ou non. */
bool mrange_intersects_mrange(const mrange_t *, const mrange_t *);
/* Calcule la position extérieure finale d'une couverture. */
void compute_mrange_end_addr(const mrange_t *, vmpa2t *);
/* Lit la définition d'une couverture depuis un tampon. */
bool unpack_mrange(mrange_t *, packed_buffer_t *);
/* Ecrit la définition d'une couverture dans un tampon. */
bool pack_mrange(const mrange_t *, packed_buffer_t *);
/* Transforme un emplacement physique en chaîne de caractères. */
char *mrange_phys_to_string(const mrange_t *, MemoryDataSize, bool, char [VMPA_MAX_LEN], size_t *);
/* Transforme un emplacement virtuel en chaîne de caractères. */
char *mrange_virt_to_string(const mrange_t *, MemoryDataSize, bool, char [VMPA_MAX_LEN], size_t *);
/* Transforme une taille d'emplacement en chaîne de caractères. */
char *mrange_length_to_string(const mrange_t *, MemoryDataSize, char [VMPA_MAX_LEN], size_t *);
#endif /* _ARCH_VMPA_H */