Comprendre le code d'assemblage généré par un simple programme C

Pax a produit une réponse définitive. Toutefois, pour être complet, je pensais que je voudrais ajouter une note sur l'obtention de GCC lui-même pour vous montrer le montage, il génère.

La -S option de GCC dit-il arrêter la compilation et l'écriture de l'assemblée à un fichier. Normalement, il se passe de ce fichier à l'assembleur ou pour certaines cibles écrit le fichier de l'objet directement lui-même.

Pour l'exemple de code dans la question:

#include <stdio.h>

void function(int a, int b, int c) {
   char buffer1[5];
   char buffer2[10];
}

void main() {
  function(1,2,3);
}

la commande gcc -S q3654898.c crée un fichier nommé q3654898.s:

 .fichier "q3654898.c" 
.texte 
.globl _function 
.def _function; .scl 2; .type 32; .endef 
_function: 
pushl %ebp 
movl %esp, %ebp 
subl $40, %esp 
laisser 
ret 
.def ___principaux; .scl 2; .type 32; .endef 
.globl _main 
.def _main; .scl 2; .type 32; .endef 
_main: 
pushl %ebp 
movl %esp, %ebp 
subl $24, %esp 
andl $-16, %esp 
movl $0, %eax 
addl $15, %eax 
addl $15, %eax 
shrl $4, %eax 
sall $4, %eax 
movl %eax, -4(%ebp) 
movl -4(%ebp), %eax 
appelez __alloca 
appelez ___principaux 
movl $3, 8(%esp) 
movl $2, 4(%esp) 
movl $1, (%esp) 
appel _function 
laisser 
ret 

Une chose qui est évident, c'est que mon GCC (gcc (GCC) 3.4.5 (mingw-vista spécial r3)) n'inclut pas la pile de vérifier le code par défaut. J'imagine qu'il y a une option de ligne de commande, ou que si je n'ai jamais eu l'occasion de pousser mon MinGW installer jusqu'à un plus actuelle de la GCC qu'il le pouvait.

Edit: Poussé à le faire par Pax, voici une autre façon d'obtenir GCC de faire plus de travail.

C:\Documents and Settings\Ross\Mes Documents\test>gcc-Wa,-al q3654898.c 
q3654898.c: In function `main': 
q3654898.c:8: avertissement: le type de retour de la 'main' n'est pas `int' 
GAZ d'INSCRIPTION C:\DOCUME~1\Ross\LOCALS~1\Temp/ccLg8pWC.s page 1 


1 .fichier "q3654898.c" 
2 .texte 
3 .globl _function 
4 .def _function; .scl 2; .type 
32; .endef 
5 _function: 
6 0000 55 pushl %ebp 
7 0001 89E5 movl %esp, %ebp 
8 0003 83EC28 subl $40, %esp 
9 0006 C9 laisser 
10 0007 C3 ret 
11 .def ___principaux; .scl 2; .type 
32; .endef 
12 .globl _main 
13 .def _main; .scl 2; .type 32; 
.endef 
14 _main: 
15 0008 55 pushl %ebp 
16 0009 89E5 movl %esp, %ebp 
17 000 b 83EC18 subl $24, %esp 
18 000e 83E4F0 andl $-16, %esp 
19 0011 B8000000 movl $0, %eax 
19 00 
20 0016 83C00F addl $15, %eax 
21 0019 83C00F addl $15, %eax 
22 001c C1E804 shrl $4, %eax 
23 001f C1E004 sall $4, %eax 
24 0022 8945FC movl %eax, -4(%ebp) 
25 0025 8B45FC movl -4(%ebp), %eax 
26 0028 E8000000 appel __alloca 
26 00 
27 002d E8000000 appel ___principaux 
27 00 
28 0032 C7442408 movl $3, 8(%esp) 
28 03000000 
29 003a C7442404 movl $2, 4(%esp) 
29 02000000 
30 0042 C7042401 movl $1, (%esp) 
30 000000 
31 0049 E8B2FFFF appel _function 
31 FF 
32 004e C9 laisser 
33 004f C3 ret 

C:\Documents and Settings\Ross\Mes Documents\test> 

Ici, nous voyons une sortie liste produite par l'assembleur. (Son nom est GASparce que c'est la version Gnu de la classique *nix assembleur as. Il y a de l'humour là, quelque part.)

Chaque ligne a la plupart des champs suivants: un numéro de ligne, une adresse de la section en cours d'octets stockés à cette adresse, et le texte source de l'assemblée fichier source.
Les adresses sont les décalages dans la partie de chaque section fournies par ce module. Ce module a seulement contenu dans le .text section qui stocke le code exécutable. Vous trouverez généralement la mention des sections nommé .data et .bss. Beaucoup d'autres noms sont utilisés et certains ont des besoins spéciaux. Lisez le manuel de l'éditeur de liens si vous voulez vraiment le savoir.

Je tiens à ajouter que pour des choses simples, GCC assemblée de sortie est souvent plus facile à lire si vous mettez un peu d'optimisation. Voici l'exemple de code à nouveau...

void function(int a, int b, int c) {
   char buffer1[5];
   char buffer2[10];
}

/* corrected calling convention of main() */
int main() {
   function(1,2,3);
   return 0;
}

c'est ce que je reçois sans optimisation (OSX 10.6, gcc 4.2.1+Pomme patchs)

.globl _function
_function:
    pushl   %ebp
    movl    %esp, %ebp
    pushl   %ebx
    subl    $36, %esp
    call    L4
"L00000000001$pb":
L4:
    popl    %ebx
    leal    L___stack_chk_guard$non_lazy_ptr-"L00000000001$pb"(%ebx), %eax
    movl    (%eax), %eax
    movl    (%eax), %edx
    movl    %edx, -12(%ebp)
    xorl    %edx, %edx
    leal    L___stack_chk_guard$non_lazy_ptr-"L00000000001$pb"(%ebx), %eax
    movl    (%eax), %eax
    movl    -12(%ebp), %edx
    xorl    (%eax), %edx
    je      L3
    call    ___stack_chk_fail
L3:
    addl    $36, %esp
    popl    %ebx
    leave
    ret
.globl _main
_main:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $24, %esp
    movl    $3, 8(%esp)
    movl    $2, 4(%esp)
    movl    $1, (%esp)
    call    _function
    movl    $0, %eax
    leave
    ret

Ouf, un diable d'une bouchée! Mais regardez ce qui se passe avec -O sur la ligne de commande...

    .text
.globl _function
_function:
    pushl   %ebp
    movl    %esp, %ebp
    leave
    ret
.globl _main
_main:
    pushl   %ebp
    movl    %esp, %ebp
    movl    $0, %eax
    leave
    ret

Bien sûr, vous courez le risque que votre code soit rendue complètement méconnaissable, notamment à des niveaux d'optimisation et avec plus de trucs compliqués. Même ici, nous voyons que l'appel à function a été rejeté comme inutile. Mais je trouve que ne pas avoir à lire à travers des dizaines de inutiles pile déversements est généralement plus que la valeur d'un peu plus de me gratter la tête au-dessus du flux de contrôle.