Bonjour ,

je voudrais connaître votre avis quant à une question que je me pose par rapport à la génération de codes qu'un compilateur pourrait produire.

Si nous avons ce code ci, en un langage quelconque :

int square(int n) {
    return n * n;
}

void foo() {
    int sqr = square(8);
    char chr = sqr;
    printf("%c", chr);
}

Le code assembleur (x86-64 gcc 8.1), que me donne mon désassembleur à partir de ce code, utilise la pile d'appel pour stocker les "variables" au sein de l’occurrence d'utilisation. C'est à dire dans le bloc en cours. Enfin, une pile quoi .

Cependant, d'autres assembleurs, dit à "macro" use d'instructions de stockage de valeurs dans la mémoire, de manière constante dans le programme, sans utiliser la pile. Exemple, NASM :

MyInt dd 73
MyChar db 'a'

...

mov DWORD eax, [MyInt]
mov BYTE ebx, [MyChar]

Les appréciations d’appellation de type (int, char, ...) ne représentent qu'au final la taille qu'il représente pour la mémoire.

____

Ma question : pourquoi un compilateur n'utiliserait pas le type de déclaration de variables, hors de pile, tel que l'exemple ci-dessus ?

Quels seraient les avantages ainsi que les inconvénients ?

J'ai cru comprendre qu'il n'y avait aucune affectation au niveau des performances et de la rapidité, après tout, ces valeurs sont, comme pour la pile, stockée en mémoire. Seul ("seul" ?) différence : ces adresses restent constante lors de l'exécution.

Je me demande donc quel "méthode" serait la plus performante, et à préférer, pour la réalisation d'un compilateur. Ou s'il y avait aussi une "cohabitation" possible entre ces différentes façons de procéder.

Je vous remercie par avance !