Warum funktioniert das GCC-Pad mit NOPs?

Ich habe eine kurze Zeit mit C gearbeitet und vor kurzem angefangen, mich mit ASM zu beschäftigen. Wenn ich ein Programm kompiliere:

int main(void)
  {
  int a = 0;
  a += 1;
  return 0;
  }

Die objdump-Demontage hat den Code, aber nops nach dem ret:

...
08048394 <main>:
 8048394:       55                      push   %ebp
 8048395:       89 e5                   mov    %esp,%ebp
 8048397:       83 ec 10                sub    $0x10,%esp
 804839a:       c7 45 fc 00 00 00 00    movl   $0x0,-0x4(%ebp)
 80483a1:       83 45 fc 01             addl   $0x1,-0x4(%ebp)
 80483a5:       b8 00 00 00 00          mov    $0x0,%eax
 80483aa:       c9                      leave  
 80483ab:       c3                      ret    
 80483ac:       90                      nop
 80483ad:       90                      nop
 80483ae:       90                      nop
 80483af:       90                      nop
...

Nach dem, was ich gelernt habe, tun Nops nichts, und da nach Ret würde nicht einmal ausgeführt werden.

Meine Frage ist: Warum sich die Mühe machen? Konnte ELF (Linux-x86) nicht mit einem Textabschnitt (+ main) beliebiger Größe arbeiten?

Ich würde mich über jede Hilfe freuen, nur um zu lernen.

Erstens gccmacht das nicht immer so. Die Polsterung wird gesteuert durch -falign-functions, die automatisch aktiviert wird durch -O2und -O3:

-falign-functions
-falign-functions=n

Richten Sie den Funktionsstart auf die nächste Zweierpotenz aus, die größer als ist n, und überspringen Sie bis zu nBytes. Zum Beispiel -falign-functions=32ausrichtet Funktionen auf die nächste 32-Byte - Grenze, sondern -falign-functions=24würden auf die nächste 32-Byte - Grenze ausgerichtet nur dann , wenn dies durch das Überspringen 23 Bytes oder weniger durchgeführt werden.

-fno-align-functionsund -falign-functions=1sind äquivalent und bedeuten, dass Funktionen nicht ausgerichtet werden.

Einige Assembler unterstützen dieses Flag nur, wenn n eine Zweierpotenz ist. In diesem Fall wird es aufgerundet.

Wenn n nicht angegeben ist oder Null ist, verwenden Sie einen maschinenabhängigen Standard.

Aktiviert auf den Ebenen -O2, -O3.

Es kann mehrere Gründe dafür geben, aber der Hauptgrund für x86 ist wahrscheinlich folgender:

Die meisten Prozessoren rufen Anweisungen in ausgerichteten 16-Byte- oder 32-Byte-Blöcken ab. Es kann vorteilhaft sein, kritische Schleifeneinträge und Unterprogrammeinträge um 16 auszurichten, um die Anzahl der 16-Byte-Grenzen im Code zu minimieren. Stellen Sie alternativ sicher, dass in den ersten Anweisungen nach einem kritischen Schleifen- oder Unterprogrammeintrag keine 16-Byte-Grenze vorhanden ist.

(Zitiert aus "Optimieren von Unterprogrammen in Assemblersprache" von Agner Fog.)

edit: Hier ist ein Beispiel, das das Auffüllen demonstriert:

// align.c
int f(void) { return 0; }
int g(void) { return 0; }

Beim Kompilieren mit gcc 4.4.5 mit Standardeinstellungen erhalte ich:

align.o:     file format elf64-x86-64

Disassembly of section .text:

0000000000000000 <f>:
   0:   55                      push   %rbp
   1:   48 89 e5                mov    %rsp,%rbp
   4:   b8 00 00 00 00          mov    $0x0,%eax
   9:   c9                      leaveq 
   a:   c3                      retq   

000000000000000b <g>:
   b:   55                      push   %rbp
   c:   48 89 e5                mov    %rsp,%rbp
   f:   b8 00 00 00 00          mov    $0x0,%eax
  14:   c9                      leaveq 
  15:   c3                      retq   

Angabe -falign-functionsergibt:

align.o:     file format elf64-x86-64

Disassembly of section .text:

0000000000000000 <f>:
   0:   55                      push   %rbp
   1:   48 89 e5                mov    %rsp,%rbp
   4:   b8 00 00 00 00          mov    $0x0,%eax
   9:   c9                      leaveq 
   a:   c3                      retq   
   b:   eb 03                   jmp    10 <g>
   d:   90                      nop
   e:   90                      nop
   f:   90                      nop

0000000000000010 <g>:
  10:   55                      push   %rbp
  11:   48 89 e5                mov    %rsp,%rbp
  14:   b8 00 00 00 00          mov    $0x0,%eax
  19:   c9                      leaveq 
  1a:   c3                      retq   

Dies geschieht, um die nächste Funktion an der 8-, 16- oder 32-Byte-Grenze auszurichten.

Aus "Optimieren von Unterprogrammen in Assemblersprache" von A.Fog:

11.5 Ausrichtung des Codes

Die meisten Mikroprozessoren rufen Code in ausgerichteten 16-Byte- oder 32-Byte-Blöcken ab. Wenn sich ein wichtiger Subroutineneintrag oder eine Sprungbezeichnung am Ende eines 16-Byte-Blocks befindet, erhält der Mikroprozessor beim Abrufen dieses Codeblocks nur wenige nützliche Codebytes. Möglicherweise müssen auch die nächsten 16 Bytes abgerufen werden, bevor die ersten Anweisungen nach dem Label dekodiert werden können. Dies kann vermieden werden, indem wichtige Unterprogrammeinträge und Schleifeneinträge um 16 ausgerichtet werden.

[...]

Das Ausrichten eines Unterprogrammeintrags ist so einfach wie das Platzieren so vieler NOPs wie nötig vor dem Unterprogrammeintrag, um die Adresse wie gewünscht durch 8, 16, 32 oder 64 teilbar zu machen.

Soweit ich mich erinnere, werden Anweisungen in der CPU weitergeleitet, und verschiedene CPU-Blöcke (Lader, Decoder usw.) verarbeiten nachfolgende Anweisungen. Wenn RETAnweisungen ausgeführt werden, werden bereits einige nächste Anweisungen in die CPU-Pipeline geladen. Es ist eine Vermutung, aber Sie können hier anfangen zu graben und wenn Sie es herausfinden (vielleicht die spezifische Anzahl von NOPs, die sicher sind, teilen Sie bitte Ihre Ergebnisse mit.