Exécution d'allocation de compilateur de mémoire sur la pile de différentes tailles

Question

J'ai construis mon propre compilateur et une grande partie de celui-ci est évidemment l'allocateur de registre, ce qui correspond à des variables temporaires avec des registres de la machine aussi efficacement que possible. Sur une architecture telle que x86, il n'y a pas beaucoup de registres donc il y a un certain nombre de déversements dans lequel les variables doivent être stockées dans la mémoire (la pile). Il y a aussi des variables stockées dans la mémoire, car ils sont trop volumineux pour tenir dans un registre.

Le allocateur de registre est effectivement invoqué à nouveau d'affecter les variables en mémoire efficacement, de sorte que l'espace est partagé possible. Le vrai problème est qu'il n'y a aucun moyen de contraindre l'allocateur de registre pour placer deux variables dans la mémoire à côté de l'autre (puisque je peux alors donner de plus grandes variables en nombre de variables plus petites) et pour permettre à l'allocateur de déplacer les variables plus petites autour de sorte que les variables plus grandes peuvent tenir, et je me demande s'il y a des algorithmes autour de gérer cela, sinon je dois diviser la mémoire en différentes zones, chacune des variables tenant d'une taille différente.

Voici un exemple pour illustrer ceci:

void f(){
    int32_t a, b;
    //something happens to a and b...
    int64_t c;
    //something happens to c...
}

Il y a quelques hypothèses à faire ici dans le but de l'exemple ... que les variables ne sont pas optimisés loin, a et b ne sont plus utiles une fois c a été défini et que toutes les variables sont affectées à la pile Mémoire. Il est clair que je veux « c » utiliser la même mémoire que « a » et « b » juste utilisé et donc allouer seulement 8 octets, mais la version actuelle de mon compilateur allouera un 16 complet octets.

Ma question est, comment puis-je allouer des variables dans la mémoire de tailles différentes de manière efficace?

Answer 1

Il est clair que l'allocateur de registres ne sont pas suffisamment général pour allouer de l'espace de la pile, car il n'a pas de sens pour fusionner les registres adjacents au-moins sur un x86.

Pourquoi ne pas l'étendre à faire cela? Ou, mieux encore, diviser ou sous-classe pour gérer directement les allocations et enregistrer la pile.

En ce qui concerne la pile allocateur, il est généralement pas efficace du temps d'exécution, ni particulièrement efficace de l'espace pour réduire au minimum la pile utilisée dans le (rare) cas que deux variables pourraient partager la même répartition en raison de la portée ne se chevauchent pas. Les opérations à allouer et désallouer l'espace supplémentaire de pile à la transition de la portée est peu susceptible d'être la peine. Même dans les plus critiques du traitement en temps réel, on est généralement beaucoup plus intéressés par la robustesse et la vitesse que rasant quelques octets d'espace de pile.