GCC पैड NOP के साथ क्यों कार्य करता है?

Question 1

मैं थोड़ी देर के लिए सी के साथ काम कर रहा हूं और हाल ही में एएसएम में आना शुरू हुआ। जब मैं एक कार्यक्रम संकलित करता हूं:

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

Objdump disassembly में कोड होता है, लेकिन रिट के बाद नोड्स:

...
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
...

मैंने जो सीखा है उससे कुछ भी नहीं होता है, और चूंकि रिट के बाद भी निष्पादित नहीं किया जाएगा।

मेरा सवाल है: क्यों परेशान? ELF (linux-x86) किसी भी आकार के .text सेक्शन (+ मुख्य) के साथ काम नहीं कर सकता है?

मैं किसी भी मदद की सराहना करता हूं, बस सीखने की कोशिश कर रहा हूं।

Question 2

सबसे पहले, gccहमेशा ऐसा नहीं करता है। पैडिंग द्वारा नियंत्रित किया जाता है -falign-functions, जो स्वचालित रूप से चालू होता है -O2और -O3:

-falign-functions
-falign-functions=n

बाइट्स पर nलंघन से , अगले पावर-ऑफ-टू में कार्यों की शुरुआत को संरेखित करें n। उदाहरण के लिए, -falign-functions=32अगले 32-बाइट सीमा के लिए फ़ंक्शंस संरेखित करता है, लेकिन अगली 32-बाइट सीमा के -falign-functions=24लिए संरेखित करेगा केवल अगर यह 23 बाइट्स या कम को लंघन द्वारा किया जा सकता है।

-fno-align-functionsऔर -falign-functions=1समतुल्य हैं और इसका मतलब है कि कार्यों को संरेखित नहीं किया जाएगा।

कुछ एसेंबलर्स केवल इस झंडे का समर्थन करते हैं जब n दो की शक्ति है; उस मामले में, यह गोल है।

यदि n निर्दिष्ट नहीं है या शून्य है, तो मशीन-निर्भर डिफ़ॉल्ट का उपयोग करें।

स्तरों पर सक्षम -O2, -O3।

ऐसा करने के कई कारण हो सकते हैं, लेकिन x86 पर मुख्य शायद यही है:

अधिकांश प्रोसेसर 16-बाइट या 32-बाइट ब्लॉक में निर्देश प्राप्त करते हैं। कोड में 16-बाइट सीमाओं की संख्या को कम करने के लिए महत्वपूर्ण लूप प्रविष्टियों और सबरूटीन प्रविष्टियों को 16 से संरेखित करना फायदेमंद हो सकता है। वैकल्पिक रूप से, सुनिश्चित करें कि एक महत्वपूर्ण लूप प्रविष्टि या सबरूटीन प्रविष्टि के बाद पहले कुछ निर्देशों में कोई 16-बाइट सीमा नहीं है।

(Agner Fog द्वारा "असेंबली भाषा में उप-भाषा का अनुकूलन" से उद्धृत।)

संपादित करें: यहाँ एक उदाहरण है जो पैडिंग प्रदर्शित करता है:

// 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-बाइट सीमा द्वारा अगले फ़ंक्शन को संरेखित करने के लिए किया जाता है।

A.Fog द्वारा "असेंबली भाषा में उप-भाषा का अनुकूलन" से:

11.5 कोड का संरेखण

अधिकांश माइक्रोप्रोसेसर 16-बाइट या 32-बाइट ब्लॉक में कोड लाते हैं। यदि कोई आयातकर्ता जुबेरूटीन एंट्री या जंप लेबल 16-बाइट ब्लॉक के अंत के पास होता है तो कोड के उस ब्लॉक को लाते समय थीमोप्रोसेसर केवल कुछ उपयोगी बाइट्स प्राप्त करेगा। इटाले को अगले 16 बाइट्स लाने हैं, इससे पहले कि लैलाबेल के बाद पहले निर्देशों को डिकोड किया जा सके। यह महत्वपूर्ण सबरूटीन प्रविष्टियों और लूप प्रविष्टियों को 16 से संरेखित करके बचा जा सकता है।

[...]

एक सबरूटीन प्रविष्टि को संरेखित करना उतना ही सरल है जितना कि वांछित के रूप में 8, 16, 32 या 64 द्वारा पता को विभाज्य बनाने के लिए थिसुब्रुटीन प्रविष्टि से पहले एनओपी के रूप में आवश्यक है।

Question 4

जहाँ तक मुझे याद है, निर्देश सीपीयू और अलग-अलग सीपीयू ब्लॉक (लोडर, डिकोडर और इस तरह की) प्रक्रिया में बाद के निर्देशों में दिए गए हैं। जब RETनिर्देशों को निष्पादित किया जा रहा है, तो कुछ अगले निर्देश पहले से ही सीपीयू पाइपलाइन में लोड किए गए हैं। यह एक अनुमान है, लेकिन आप यहां खुदाई शुरू कर सकते हैं और यदि आपको पता चलता है (शायद विशिष्ट संख्या NOPजो सुरक्षित हैं, तो कृपया अपने निष्कर्ष साझा करें।