Fortified the tree of binary portions.

2 files changed, 101 insertions, 3 deletions

diff --git a/src/arch/vmpa.c b/src/arch/vmpa.c
index 4f9b87f..c32c836 100644
--- a/src/arch/vmpa.c
+++ b/src/arch/vmpa.c
@@ -46,6 +46,14 @@ static char *_phys_t_to_string(phys_t, MemoryDataSize, char [VMPA_MAX_LEN], size
 
 
 
+/* ------------------------ DEFINITION D'UNE ZONE EN MEMOIRE ------------------------ */
+
+
+/* Compare une couverture mémoire avec une localisation simple. */
+static int _cmp_mrange_with_vmpa(const mrange_t *, const vmpa2t *, bool);
+
+
+
 /* ---------------------------------------------------------------------------------- */
 /*                        DEFINITION D'UNE POSITION EN MEMOIRE                        */
 /* ---------------------------------------------------------------------------------- */
@@ -874,8 +882,9 @@ int cmp_mrange(const mrange_t *a, const mrange_t *b)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : a = première définition à analyser.                          *
-*                b = seconde définition à analyser.                           *
+*  Paramètres  : a   = première définition à analyser.                        *
+*                b   = seconde définition à analyser.                         *
+*                inc = indique si l'adresse peut être une fin de zone.        *
 *                                                                             *
 *  Description : Compare une couverture mémoire avec une localisation simple. *
 *                                                                             *
@@ -885,7 +894,7 @@ int cmp_mrange(const mrange_t *a, const mrange_t *b)
 *                                                                             *
 ******************************************************************************/
 
-int cmp_mrange_with_vmpa(const mrange_t *a, const vmpa2t *b)
+static int _cmp_mrange_with_vmpa(const mrange_t *a, const vmpa2t *b, bool inclusive)
 {
     int result;                             /* Bilan à retourner           */
     phys_t diff;                            /* Espace entre deux adresses  */
@@ -914,6 +923,9 @@ int cmp_mrange_with_vmpa(const mrange_t *a, const vmpa2t *b)
         else if (diff < a->length)
             result = 0;
 
+        else if (diff == a->length && inclusive)
+            result = 0;
+
         else
             result = 1;
 
@@ -926,6 +938,86 @@ int cmp_mrange_with_vmpa(const mrange_t *a, const vmpa2t *b)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : a = première définition à analyser.                          *
+*                b = seconde définition à analyser.                           *
+*                                                                             *
+*  Description : Compare une couverture mémoire avec une localisation simple. *
+*                                                                             *
+*  Retour      : Bilan de la comparaison : -1, 0 ou 1 (-1 par défaut).        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+int cmp_mrange_with_vmpa(const mrange_t *a, const vmpa2t *b)
+{
+    int result;                             /* Bilan à retourner           */
+
+    result = _cmp_mrange_with_vmpa(a, b, false);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = première définition à analyser.                          *
+*                b = seconde définition à analyser.                           *
+*                                                                             *
+*  Description : Compare une couverture mémoire avec une localisation simple. *
+*                                                                             *
+*  Retour      : Bilan de la comparaison : -1, 0 ou 1 (-1 par défaut).        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+int cmp_mrange_with_vmpa_inclusive(const mrange_t *a, const vmpa2t *b)
+{
+    int result;                             /* Bilan à retourner           */
+
+    result = _cmp_mrange_with_vmpa(a, b, true);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : range = zone mémoire à consulter.                            *
+*                sub   = éventuelle sous-région à valider.                    *
+*                                                                             *
+*  Description : Indique si une zone en contient une autre ou non.            *
+*                                                                             *
+*  Retour      : Bilan de la comparaison : -1, 0 ou 1 (-1 par défaut).        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+int mrange_includes_mrange(const mrange_t *range, const mrange_t *sub)
+{
+    int result;                             /* Bilan à retourner           */
+    vmpa2t end;                             /* Seconde extrémité           */
+
+    result = cmp_mrange_with_vmpa(range, get_mrange_addr(sub));
+
+    if (result == 0)
+    {
+        compute_mrange_end_addr(sub, &end);
+
+        result = cmp_mrange_with_vmpa_inclusive(range, &end);
+
+    }
+
+    return result;
+
+}
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : range = zone mémoire à consulter.                            *
 *                sub   = éventuelle sous-région à valider.                    *
 *                                                                             *
diff --git a/src/arch/vmpa.h b/src/arch/vmpa.h
index 996a7fb..6305f79 100644
--- a/src/arch/vmpa.h
+++ b/src/arch/vmpa.h
@@ -203,6 +203,12 @@ static inline int cmp_mrange_with_vmpa_swapped(const vmpa2t *k, const mrange_t *
     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 *);