Чому панель GCC працює з NOP?

Question 1

Я працюю з C короткий час, і зовсім недавно почав потрапляти в ASM. Коли я складаю програму:

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

Розбирання objdump має код, але nops після 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
...

З того, що я дізнався, nops нічого не робить, а оскільки після ret навіть не буде страчено.

Моє питання: навіщо турбуватися? Чи не може ELF (linux-x86) працювати з розділом .text (+ main) будь-якого розміру?

Буду вдячний за будь-яку допомогу, просто намагаючись навчитися.

Question 2

Перш за все, gccне завжди це робиться. Заповнення контролюється -falign-functions, що автоматично вмикається за допомогою -O2і -O3:

-falign-functions
-falign-functions=n

Вирівняйте початок функцій за наступним рівнем двох, більшим ніж n, пропускаючи до nбайтів. Наприклад, -falign-functions=32вирівнює функції до наступної 32-байтової межі, але -falign-functions=24буде вирівнюватися до наступної 32-байтової межі, лише якщо це можна зробити, пропустивши 23 байти або менше.

-fno-align-functionsі -falign-functions=1еквівалентні і означають, що функції не будуть вирівняні.

Деякі асемблери підтримують цей прапор лише тоді, коли n дорівнює двом; у такому випадку він округлюється.

Якщо n не вказано або дорівнює нулю, використовуйте машинно-залежний за замовчуванням.

Увімкнено на рівнях -O2, -O3.

Для цього може бути кілька причин, але головна на x86, мабуть, така:

Більшість процесорів отримують інструкції у вирівняних 16-байтових або 32-байтових блоках. Може бути вигідним вирівняти записи критичного циклу та записи підпрограми на 16, щоб мінімізувати кількість 16-байтових меж у коді. Крім того, переконайтеся, що в перших кількох інструкціях після критичного входу в цикл або підпрограми немає 16-байтової межі.

(Цитується з "Оптимізація підпрограм мовою збірки" Агнера Фога.)

редагувати: Ось приклад, який демонструє відступ:

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

При компіляції за допомогою gcc 4.4.5 із налаштуваннями за замовчуванням я отримую:

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

Вказівка -falign-functionsдає:

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

Question 3

Це робиться для вирівнювання наступної функції за 8, 16 або 32-байтовою межею.

З “Оптимізації підпрограм на мові асемблера” А.Фога:

11.5 Вирівнювання коду

Більшість мікропроцесорів отримують код у вирівняних 16-байтових або 32-байтових блоках. Якщо імпортнапрограма введення або мітка переходу виявляється ближче до кінця 16-байтового блоку, тоді їх мікропроцесор отримає лише кілька корисних байт коду під час отримання цього блоку коду. Можливо, йому доведеться отримати наступні 16 байт, перш ніж він зможе декодувати перші інструкції після позначки. Цього можна уникнути, вирівнявши важливі записи підпрограми та записи циклу на 16.

[...]

Вирівняти запис підпрограми настільки просто, як поставити стільки NOP, скільки потрібно перед входом підпрограми, щоб зробити адресу діленою на 8, 16, 32 або 64, як потрібно.

Question 4

Наскільки я пам’ятаю, інструкції складаються в процесор, а різні блоки процесора (завантажувач, декодер тощо) обробляють подальші інструкції. Коли RETінструкції виконуються, у конвеєр процесора вже завантажується декілька наступних інструкцій. Це припущення, але ви можете почати копати тут, і якщо ви дізнаєтесь (можливо, конкретну кількість NOPбезпечних слів, поділіться своїми результатами, будь ласка.