En langage C, la fonction principale appelle une autre fonction et assemble le Code pour comprendre

Compréhension de la pile

Parce que la fonction principale est en cours d'exécution,Besoin de sauter de la fonction principale à la fonction appelée,Il s'agit de sauvegarder l'état actuel de la fonction,Entrée dans l'opération de la fonction appelée.Cette opération d'enregistrement de l'état nécessite une pile.
La pile est structurée comme suit:：

Il y a quelques points à noter sur la compréhension de la pile：

• La pile passe de l'adresse haute à l'adresse basse
• rspC'est un registre de pile,Il y a l'adresse du pointeur en haut de la pile
• Le pointeur vers le Haut de la pile n'est disponible que si vous avez besoin d'augmenter ou de réduire la taille de la pile,Pour se déplacer vers une adresse plus basse,Sinon, l'entrée et la sortie de la pile sont basées sur l'offset du pointeur supérieur de la pile,Le pointeur supérieur de la pile n'a pas besoin de se déplacer.

Exemple de code

Fonction principalecall_proc.c

#include"proc.h"
long call_proc()
{
    
        long  x1 = 1; int  x2 = 2;
        short x3 = 3; char x4 = 4;
        proc(x1, &x1, x2, &x2, x3, &x3, x4, &x4);
        return (x1+x2)*(x3-x4);
}

Fonction moduléeproc.c

void proc(long  a1, long  *a1p,
          int   a2, int   *a2p,
          short a3, short *a3p,
          char  a4, char  *a4p)
{
    
        *a1p += a1;
        *a2p += a2;
        *a3p += a3;
        *a4p += a4;
}

Code d'assemblage

Utilisation de la mise en œuvregcc -Og -S xxx.c Générer le Code d'assemblage des deux call_proc.sEtproc.sComme suit( Liste uniquement les sections clés )：
call_proc.s

.file   "call_proc.c"
        .text
        .globl  call_proc
        .type   call_proc, @function 
call_proc: 
.LFB0:
        .cfi_startproc
        endbr64
        pushq   %rbx
        .cfi_def_cfa_offset 16
        .cfi_offset 3, -16
        subq    $32, %rsp
        .cfi_def_cfa_offset 48
        movl    $40, %ebx
        movq    %fs:(%rbx), %rax
        movq    %rax, 24(%rsp)
        xorl    %eax, %eax
        movq    $1, 16(%rsp)
        movl    $2, 12(%rsp)
        movw    $3, 10(%rsp) 
        movb    $4, 9(%rsp)
        leaq    12(%rsp), %rcx
        leaq    16(%rsp), %rsi
        leaq    9(%rsp), %rax
        pushq   %rax  
        .cfi_def_cfa_offset 56
        pushq   $4    
        .cfi_def_cfa_offset 64
        leaq    26(%rsp), %r9
        movl    $3, %r8d
        movl    $2, %edx
        movl    $1, %edi
        call    [email protected]
        movslq  28(%rsp), %rcx
        addq    32(%rsp), %rcx
        movswl  26(%rsp), %edx
        movsbl  25(%rsp), %eax
        subl    %eax, %edx
        movslq  %edx, %rax
        imulq   %rcx, %rax
        addq    $16, %rsp
        .cfi_def_cfa_offset 48
        movq    24(%rsp), %rdi
        xorq    %fs:(%rbx), %rdi
        jne     .L4
        addq    $32, %rsp
        .cfi_remember_state
        .cfi_def_cfa_offset 16
        popq    %rbx
        .cfi_def_cfa_offset 8
        ret

proc.s

       .file   "proc.c"
        .text
        .globl  proc
        .type   proc, @function
proc:
.LFB0:
        .cfi_startproc
        endbr64
        movq    16(%rsp), %rax
        addq    %rdi, (%rsi)
        addl    %edx, (%rcx)
        addw    %r8w, (%r9)
        movl    8(%rsp), %edx
        addb    %dl, (%rax)
        ret
        .cfi_endproc

Analyse du Code d'assemblage

Analyse d'abordcall_proc.sCode d'assemblage dans

Changer la taille de la pile

subq $32, %rsp //Oui.rspDiminution32Octets, Parce que la direction de croissance de la pile est grande adresse à petite adresse , équivalent à augmenter la capacité de la pile 

Enregistrer les variables locales

// Empiler les variables locales ,rsp Le numéro précédent est l'offset du pointeur supérieur de la pile 
movq    $1, 16(%rsp) 
movl    $2, 12(%rsp)
movw    $3, 10(%rsp)
movb    $4, 9(%rsp)

Après ce qui précède,Le schéma de la pile est le suivant:：

Enregistrer les paramètres formels de la fonction modulée

Parce que la fonction à moduler a 8Paramètres formels, Mais au mieux, 6 Les paramètres formels peuvent être enregistrés , Donc deux sont sauvegardés dans la pile , Et les deux dernières valeurs du paramètre formel .

 // Enregistrer les paramètres formels dans le registre 
 leaq    12(%rsp), %rcx  //load effective adress, Opérande utilisé pour assigner directement une adresse mémoire à une destination 
 leaq    16(%rsp), %rsi
 
 // Enregistrer les paramètres formels dans la pile ,
 leaq    9(%rsp), %rax
 pushq   %rax  // Pile de données dans le registre 
 pushq   $4  //  Presser la pile immédiatement 
 
 // Enregistrer les paramètres formels dans le registre 
 leaq    26(%rsp), %r9
 movl    $3, %r8d
 movl    $2, %edx
 movl    $1, %edi

La relation correspondante entre les paramètres et les paramètres formels est illustrée dans la figure ci - dessous. ：

Appeler la fonction appelée

call    [email protected]

Avant d'appeler la fonction appelée , Empiler la prochaine instruction d'exécution du Code d'appel , Pour faciliter le retour de la fonction modulée à la fonction principale , Peut être exécuté vers le bas .

Retour

... // Une série d'opérations logiques 
ret

Code d'assemblage de la fonction appelée

Opérations logiques

movq    16(%rsp), %rax

//  Extraire les opérandes directement du Registre 
addq    %rdi, (%rsi)
addl    %edx, (%rcx)
addw    %r8w, (%r9)

// Extraire les opérandes de la pile 
movl    8(%rsp), %edx
addb    %dl, (%rax)

Retour

ret

Résumé

• Appels de fonctions imbriqués , La pile est nécessaire pour enregistrer les variables locales 、Ginseng、 Adresse de l'instruction au retour
• C Les paramètres de la langue sont pressés dans la pile de droite à gauche

RÉFÉRENCES

C Mise en œuvre sous - jacente de l'appel de fonction linguistique
Dans le langage d'assemblagemovEtleaQuelle est la différence entre？