Trouver pile la taille d'image

Ma première réaction aurait été, pourquoi quelqu'un voudrait cela? Il devrait être considéré comme une mauvaise pratique pour une fonction C pour déterminer dynamiquement la taille de la frame de pile. Le point de l'ensemble de cdecl (la classique convention d'appel C), c'est que la fonction elle-même (le "destinataire de l'appel') n'a pas connaissance de la taille de la frame de pile. Tout détournement de cette philosophie peut causer votre code à la pause lors de la commutation sur une autre plate-forme, une adresse différente de la taille (ex: à partir de 32 bits à 64 bits), un compilateur différent ou de même les différents paramètres du compilateur (en particulier les optimisations).

D'autre part, depuis gcc offre déjà cette fonction __builtin_frame_address, il sera intéressant de voir comment beaucoup d'informations peuvent être dérivées à partir de là.

De la la documentation:

Le cadre d'adresse est normalement l'adresse du premier mot poussé sur la pile par la fonction.

Sur x86, une fonction commence généralement par:

push ebp       ; bp for 16-bit, ebp for 32-bit, rbp for 64-bit

En d'autres termes, __builtin_frame_address renvoie la de la base de pointeur de l'appelant cadre de pile.
Malheureusement, le pointeur de la base, dit que peu ou rien sur l'endroit où toute la trame de pile commence ou se termine;
la base d'un pointeur sur un emplacement qui est quelque part au milieu de la trame de pile (entre le paramètres et la variables locales).

Si vous êtes uniquement intéressé par la partie de la trame de pile qui contient les variables locales, alors la fonction elle-même dispose de toutes les connaissances. La taille de cette partie est la différence entre le pointeur de pile et le pointeur de la base.

register char * const basepointer  asm("ebp");
register char * const stackpointer asm("esp");

size_localvars = basepointer - stackpointer;

Veuillez garder à l'esprit que gcc semble allouer de l'espace sur la pile dès le début qui est utilisé pour contenir des paramètres pour d'autres fonctions appelées depuis l'intérieur de l'appelé. Strictement parlant, que l'espace appartient à la pile d'images de ces autres fonctions, mais la limite n'est pas claire. Si c'est un problème, dépend de votre objectif, ce que vous allez faire avec le calcul de la pile la taille d'image?

Comme pour l'autre partie (les paramètres), cela dépend. Si votre fonction a un nombre fixe de paramètres, il vous suffit de mesurer la taille de l' (formel) paramètres. Il ne garantit pas que l'appelant poussa le même nombre de paramètres sur la pile, mais en supposant que l'appelant compilé sans les mises en garde contre le destinataire de l'appel du prototype, il devrait être OK.

void callee(int a, int b, int c, int d)
{
    size_params = sizeof d + (char *)&d - (char *)&a;
}

Vous pouvez combiner les deux techniques pour obtenir la pleine structure de pile (y compris l'adresse de retour et enregistré base pointer):

register char * const stackpointer asm("esp");

void callee(int a, int b, int c, int d)
{
    total_size = sizeof d + (char *)&d - stackpointer;
}

Si en revanche, votre fonction a un nombre variable de paramètre (une "points de suspension", comme printf a), alors la taille des paramètres n'est connue que de l'appelant. À moins que le destinataire de l'appel a un moyen de calculer la taille et le nombre de paramètres (dans le cas d'une printfde style de la fonction, par l'analyse de la chaîne de format), vous devez laisser l'appelant passer que l'information sur le destinataire de l'appel.

EDIT:
Veuillez noter que ceci ne fonctionne que pour laisser une fonction de mesure de son propre cadre de pile. Un destinataire ne peut pas calculer son appelant pile de la taille de l'image; le destinataire de l'appel devrez demander à l'appelant pour l'information.

Toutefois, le destinataire de l'appel peut faire une supposition éclairée au sujet de la taille de l'appelant variables locales. Ce bloc commence là où le destinataire de l'appel des paramètres de la fin (sizeof d + (char *)&d), et se termine à l'appelant de la base de pointeur (__builtin_frame_address(1)). L'adresse de début peut être légèrement inexacte en raison de l'adresse de l'alignement imposé par le compilateur; la taille calculée peut inclure un morceau de inutilisés espace de pile.

void callee(int a, int b, int c, int d)
{
   size_localvars_of_caller = __builtin_frame_address(1) - sizeof d - (char *)&d;
}