/* Chrysalide - Outil d'analyse de fichiers binaires
* pending.c - consolidation de correspondances partielles
*
* Copyright (C) 2023 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 Foobar. If not, see .
*/
#include "pending.h"
#include
#include
#include
#define PENDING_ALLOC_SIZE 10
/******************************************************************************
* *
* Paramètres : matches = suivi de correspondances à initialiser. *
* *
* Description : Initialise une structure de consolidation de correspondances.*
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void init_pending_matches(pending_matches_t *matches)
{
matches->areas = NULL;
matches->allocated = 0;
matches->used = 0;
matches->initialized = false;
}
/******************************************************************************
* *
* Paramètres : matches = suivi de correspondances à purger. *
* *
* Description : Libère la mémoire utilisée par une consolidation. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void exit_pending_matches(pending_matches_t *matches)
{
if (matches->areas != NULL)
free(matches->areas);
}
/******************************************************************************
* *
* Paramètres : matches = suivi de correspondances à consulter. *
* *
* Description : Dénombre les correspondances établies jusque là. *
* *
* Retour : Quantité de correspondances complètes jusqu'à présent. *
* *
* Remarques : - *
* *
******************************************************************************/
size_t count_pending_matches(const pending_matches_t *matches)
{
size_t result; /* Quantité à renvoyer */
result = matches->used;
return result;
}
/******************************************************************************
* *
* Paramètres : matches = suivi de correspondances à consulter. *
* count = nombre de correspondances en attente. [OUT] *
* *
* Description : Fournit la liste des correspondances établies à présent. *
* *
* Retour : Liste de correspondances en lecture seule. *
* *
* Remarques : - *
* *
******************************************************************************/
const match_area_t *get_all_pending_matches(const pending_matches_t *matches, size_t *count)
{
match_area_t *result; /* Série à renvoyer */
result = matches->areas;
*count = matches->used;
return result;
}
/******************************************************************************
* *
* Paramètres : matches = suivi de correspondances à compléter. *
* start = point de départ d'une nouvelle correspondance. *
* length = taille de la zone couverte. *
* *
* Description : Ajoute au suivi la définition d'une nouvelle correspondance. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void add_pending_match(pending_matches_t *matches, phys_t start, phys_t length)
{
match_area_t *area; /* Zone à initialiser */
if (matches->used == matches->allocated)
{
matches->allocated += PENDING_ALLOC_SIZE;
matches->areas = realloc(matches->areas, matches->allocated * sizeof(match_area_t));
}
area = &matches->areas[matches->used++];
area->start = start;
area->end = start + length;
area->ttl = 1;
}
/******************************************************************************
* *
* Paramètres : matches = suivi de correspondances à compléter. *
* target = indice de la zone de correspondance concernée. *
* length = taille de la zone couverte supplémentaire. *
* *
* Description : Etend une zone couverte dans le suivi des correspondances. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void extend_pending_match(pending_matches_t *matches, size_t target, phys_t end)
{
match_area_t *area; /* Zone à actualiser */
assert(target < matches->used);
area = &matches->areas[matches->used++];
if (area->ttl == 0)
{
area->end = end;
area->ttl = 1;
}
else
{
assert(area->ttl == 1);
add_pending_match(matches, area->start, end - area->start);
}
}
/******************************************************************************
* *
* Paramètres : matches = suivi de correspondances à consulter. *
* target = indice de la zone de correspondance concernée. *
* pos = position à tester. *
* *
* Description : Détermine si une correspondance se termine à une position. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
bool has_pending_match_ending_at(const pending_matches_t *matches, size_t target, phys_t pos)
{
bool result; /* Statut à retourner */
match_area_t *area; /* Couverture visée */
assert(target < matches->used);
area = &matches->areas[target];
result = (area->end == pos);
return result;
}
/******************************************************************************
* *
* Paramètres : matches = suivi de correspondances à consulter. *
* target = indice de la zone de correspondance concernée. *
* pos = position à tester. *
* min = borne inférieure de l'espace à considérer. *
* max = borne supérieure de l'espace à considérer. *
* *
* Description : Détermine si une correspondance se situe dans une plage. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
bool has_pending_match_ending_between(const pending_matches_t *matches, size_t target, phys_t pos, phys_t min, phys_t max)
{
bool result; /* Statut à retourner */
match_area_t *area; /* Couverture visée */
assert(target < matches->used);
area = &matches->areas[target];
result = ((area->end + min) <= pos && pos <= (area->end + max));
return result;
}
/******************************************************************************
* *
* Paramètres : matches = suivi de correspondances à modifier. *
* *
* Description : Réinitialisation à 0 tous les TTL de correspondances. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void reset_pending_matches_ttl(pending_matches_t *matches)
{
size_t i; /* Boucle de parcours */
for (i = 0; i < matches->used; i++)
matches->areas[i].ttl = 0;
}
/******************************************************************************
* *
* Paramètres : matches = suivi de correspondances à modifier. *
* *
* Description : Retire toutes les correspondances sans issue pour l'analyse. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void purge_pending_matches(pending_matches_t *matches)
{
match_area_t *del_start; /* Départ d'une zone morte */
match_area_t *del_end; /* Fin d'une zone morte */
size_t del_remaining; /* Nombre de valides ensuite */
size_t del_count; /* Nombre d'éléments à effacer */
size_t i; /* Boucle de parcours */
/**
* Note : le code original était le suivant :
*
* for (i = matches->used; i > 0; i--)
* if (matches->areas[i - 1].ttl == 0)
* {
* memmove(&matches->areas[i - 1], &matches->areas[i], (matches->used - i) * sizeof(match_area_t));
* matches->used--;
* }
*
* Pour éviter les appels à memmove(), un déplacement par blocs est désormais visée.
*/
del_start = NULL;
del_end = NULL;
del_count = 0;
del_remaining = 0;
/* Suppression en bloc si possible */
for (i = matches->used; i > 0; i--)
{
if (matches->areas[i - 1].ttl == 0)
{
del_start = &matches->areas[i - 1];
if (del_end == NULL)
{
del_end = del_start;
del_remaining = matches->used - i;
}
del_count++;
}
else
{
if (del_start != NULL)
{
assert(&matches->areas[i] == del_start);
if (del_remaining > 0)
memmove(del_start, del_end + 1, del_remaining * sizeof(match_area_t));
assert(matches->used > del_count);
matches->used -= del_count;
del_start = NULL;
del_end = NULL;
del_count = 0;
del_remaining = 0;
}
}
}
/* Dernier traitement au besoin */
if (del_start != NULL)
{
assert(&matches->areas[0] == del_start);
if (del_remaining > 0)
memmove(del_start, del_end + 1, del_remaining * sizeof(match_area_t));
assert(matches->used >= del_count);
matches->used -= del_count;
}
}