🔉 🥟 👩🏾‍🚀 संकलन। 10: ईएलएफ में संकलन 📐 👨🏼‍🤝‍👨🏻 👇

पिछली बार, हमने अपने प्रारूप में एक फ़ाइल में j- स्क्रिप्ट को संकलित करने के लिए खुद को सीमित कर दिया था, जिसे एक विशेष लोडर की आवश्यकता थी। इसके अलावा, हमने कल्पना की कि निष्पादन योग्य कोड अनुकूलन के एक जोड़े थे जो पड़ोसी आदेशों के विश्लेषण की आवश्यकता थी।

पोस्ट में आगे:

पीपहोल अनुकूलन
मानक सुविधाएँ
ईएलएफ को आउटपुट
यह कैसे काम करता है?
क्या हुआ था?

पीपहोल अनुकूलन

नियोजित अनुकूलन को लागू करने के लिए, सबसे पहले, हम सामान्य वेक्टर code

को प्रत्येक कमांड के लिए उत्पन्न मशीन कोड के छोटे वैक्टर में विभाजित करते हैं, और अंत में हम उन्हें एक साथ गोंद देंगे।

दूसरे, दो पास हमारे लिए पर्याप्त नहीं हैं: पहली पास पर हम प्रत्येक कमांड के लिए मशीन कोड उत्पन्न करते हैं, दूसरे पर - हम अनुकूलन करते हैं, तीसरे पर - हम "पॉलिश" करते हैं, जोप्स और लाइनों के ऑफसेट में भरते हैं। इसके साथ ही, जंप ऑफ़सेट्स की गणना के साथ, हम पास के जंप को शॉर्ट्स के साथ बदल देंगे, यदि संभव हो तो, ताकि तीसरे पास पर कोड को और कम किया जा सके और एक और पास की आवश्यकता होगी - चौथा; इस पर हम फिर से कोड में कमी के कारण बदल चुके जम्पसूट्स को सही करेंगे।

प्रत्येक टीम को उत्पन्न POP

की संख्या को स्टोर करना होगा, क्योंकि मशीन कोड द्वारा अकेले समझना मुश्किल है कि क्या अंतिम बाइट POP

निर्देश है, या केवल मूल्य से मेल खाता है। जनरेट किए गए PUSH

की संख्या को स्टोर करने की कोई आवश्यकता नहीं है: मशीन कोड का पहला बाइट अनायास ही डिक्रिप्ट हो जाता है।

  struct commandn { // ... int offset; //    int needfixat; //  JZ, ECHO int popcnt; // INPUT, ECHO std::vector<unsigned char> code;//   // ... void pop_back(int c = 1) { code.resize(code.size()-c); } void pop_front(int c = 1) { code.erase(code.begin(), code.begin()+c); } }; // ... // ""    JZ: // ,     case command::jz: if(!i->cmd.dest) // JMP off i->emit(0xe9); else { // OR dst, dst / JZ off i->emit(0x0b, 0xc0|(i->cmd.dest-1)<<3|(i->cmd.dest-1)); i->emit(0x0f, 0x84); } i->needfixat = i->code.size(); i->emit4(0); break; // ... //  ECHO  INPUT   popcnt; //   --   case command::input: foreach(rp, i->onenterp) if(*rp!=4) i->emit(0x50|(*rp-1)); i->emit(0xff, 0x55, 0); if(i->cmd.dest!=1) i->emit(0x90|(i->cmd.dest-1)); foreachr(rp, i->onenterp) if(*rp!=4) { i->emit(0x58|(*rp-1)); i->popcnt++; } break; // ... //  :   ,    int offset = 0; foreach2(i,pcode,next) { i->offset = offset; //  "POP-PUSH" while(i->popcnt && ((next->code[0]&0xfc) == 0x50) && ((i->code.back()&3) == (next->code[0]&3)) && //  :     !((next->cmd.opcode==command::echo) && (next->cmd.dest==(next->code[0]&3)+1))) { i->pop_back(); next->pop_front(); i->popcnt--; if(next->needfixat) next->needfixat--; } //  "-JZ" if((i->cmd.opcode>=command::eq) && (next->cmd.opcode==command::jz) && (i->cmd.dest==next->cmd.dest) && !next->onexitp.count((physreg)next->cmd.dest)) { char cc = i->code[i->code.size()-5]; // cond code i->pop_back(6); // SETcc / MOVZX next->code.clear(); //    next->emit(0x0f, cc^0x11); next->needfixat = next->code.size(); next->emit4(0); } offset += i->code.size(); } //  :    offset = 0; foreach(i, pcode) { i->offset = offset; if(i->cmd.opcode==command::jz) { int joffset = i->tgt->offset-(i->offset+i->code.size()); if((joffset>=-128) && (joffset<128)) { //   if(!i->cmd.dest) { // JMP SHORT i->code.clear(); i->emit(0xeb, (char)joffset); } else if(i->code[0]==0x0b && i->code[1]==0xc9) { // OR ECX, ECX i->code.clear(); i->emit(0xe3, (char)joffset); // JECXZ } else { char cc = i->code[i->code.size()-5]; // cond code i->pop_back(6); i->emit(cc^0xf0, (char)joffset);// Jcc SHORT } i->needfixat = i->code.size()-1; //     } } offset += i->code.size(); } //  :     foreach(i, pcode) if(i->needfixat) if(i->cmd.opcode==command::jz) { int joffset = i->tgt->offset-(i->offset+i->code.size()); switch(i->code[i->needfixat]-1) { case 0xeb: case 0xe3: case 0x74: case 0x75: case 0x7c: case 0x7d: case 0x7e: case 0x7f: i->code[i->needfixat] = (char)joffset; break; // short default: i->fix4(joffset); } } else if (i->cmd.opcode==command::echo) i->fix4(offsets[i->cmd.imm]);

मानक सुविधाएँ

पिछली बार, मानक कार्य input,echoi,echos

का कार्यान्वयन हमारे बूटलोडर में था। इस समय कोई बूटलोडर नहीं होगा; कार्य कहाँ होंगे?

हम सिद्धांत रूप में, प्रत्येक उत्पन्न बाइनरी में अपने कोड को एम्बेड कर सकते हैं; लेकिन यह बदसूरत है। इसके बजाय, हम उन्हें एक अलग .o

फ़ाइल में संकलित करते हैं, जिसे तब हमारी फ़ाइल से जोड़ा जाएगा। इस दृष्टिकोण का लाभ प्लेटफ़ॉर्म की निर्भरता का अलगाव है: x86 और x64 के बीच के सभी अंतर, जो हमारे संकलक के दृष्टिकोण से, कॉलिंग फ़ंक्शंस के रास्ते में झूठ, एक प्लेटफ़ॉर्म-निर्भर लाइब्रेरी में छिपे हुए हैं, और हम खुद प्लेटफ़ॉर्म-स्वतंत्र कोड उत्पन्न करेंगे।

यह हमारे लिए सुविधाजनक है कि हमारे मानक कार्य ESI

में एक पैरामीटर को स्वीकार करते हैं और परिणाम को EAX

वापस करते हैं। तो चलिए करते हैं। यहाँ x64 के लिए कार्यान्वयन है:

 .global input,echoi,echos .text fd: .asciz "%d" fs: .asciz "%s" input: push %rax lea fd, %edi xor %eax, %eax mov %rsp, %rsi call scanf pop %rax ret echoi: lea fd, %edi echo: xor %eax, %eax jmp printf echos: movslq %esi, %rsi add %rbp, %rsi lea fs, %edi jmp echo

और यहाँ x86 के लिए है:

 .global input,echoi,echos .text fd: .asciz "%d" fs: .asciz "%s" input: push %eax push %esp push $fd call scanf pop %eax pop2: pop %eax pop %eax ret echoi: push %esi push $fd echo: call printf jmp pop2 echos: add %ebp, %esi push %esi push $fs jmp echo

ईएलएफ को आउटपुट

हमारा निष्पादन योग्य कोड लगभग तैयार है; यह केवल इसे "पैक" करने के लिए रहता है ताकि ओएस इसे लिंक कर सके और इसे चला सके।

स्मृति में, कोड में पहले के समान भाग शामिल होंगे: मानक कार्यों को कॉल करने के लिए कोड, डेटा, संचार क्षेत्र। .o

फ़ाइल प्रारूप और सीधे निष्पादन योग्य फ़ाइलों के बीच का अंतर यह है कि .o

में मेमोरी में प्रोग्राम पार्ट्स ( सेक्शन ) .o

संरेखण ज्ञात नहीं है; इसलिए, कंपाइलर एक सेक्शन से दूसरे एड्रेस में एक लिंक जेनरेट नहीं कर सकता है। इसके बजाय, कंपाइलर लिंकर के लिए एक संकेत उत्पन्न करता है - एक रिलोकेशन जो यह दर्शाता है कि लिंक करते समय गणना करने के लिए कौन सा पता है और कैसे गणना करें। इसलिए, ELF प्रारूप विनिर्देश में .o

फ़ाइलों को स्थानांतरित करने योग्य कहा जाता है।

डेटा को दो वर्गों में विभाजित करना संभव होगा: अलग-अलग आरंभीकृत और अपरिवर्तनीय (संचार क्षेत्र और रेखाएं), अलग-अलग असंगठित और परिवर्तनशील (पिस रजिस्टरों के लिए कोशिकाएं); लेकिन तब x86 पर हमारे पास दोनों डेटा अनुभागों के आधार पते को लगातार संग्रहीत करने के लिए पर्याप्त रजिस्टर नहीं होंगे, जिसका अर्थ है कि हमें प्रत्येक कॉल के लिए स्थानांतरण उत्पन्न करना होगा। अपने जीवन को सरल बनाएं और डेटा के एक खंड के साथ प्राप्त करें।

उसी कारण से, हम मानक कार्यों को कॉल करने के लिए संचार क्षेत्र का उपयोग करते हैं: सीधे कॉल करने के लिए, आपको प्रत्येक कॉल के लिए एक स्थानांतरण बनाना होगा। चलो x86 और x64 पर संचार क्षेत्र को 24-बाइट करें - फिर से, सादगी और क्रॉस-प्लेटफ़ॉर्म के लिए। X64 पर, यह केवल तीन पॉइंटर्स का एक सरणी होगा ( input,echoi,echos

); x86 पर, प्रत्येक सूचक 4-बाइट स्टब द्वारा पीछा किया जाएगा।

यह पता चला है कि हमारे पास हमेशा चार स्थान होंगे: संचार के क्षेत्र में मानक कार्यों के तीन पते, और कार्यक्रम RBP/EBP

पहले कमांड RBP/EBP

डेटा के आधार पते को RBP/EBP

में लोड करना। नतीजतन, "रिलोकेबल" कोड की पीढ़ी पिछली बार की "ठोस टुकड़ा" की पीढ़ी से शायद ही अलग होगी। कुछ मामलों में, यह और भी सरल हो जाएगा: चूंकि अब लाइनों को कोड से अलग-अलग संग्रहीत किया जाएगा, हम उनके ऑफसेट को ठीक चरण में याद कर सकते हैं; इस तरह हम पूरी तरह से "अस्थायी लाइन पहचानकर्ताओं" और संकलित कोड के आउटपुट से पहले उनके बंधन के चरण से छुटकारा पा लेंगे। इसके अलावा, मानक कार्यों को कॉल करने की विधि अब प्लेटफ़ॉर्म स्वतंत्र होगी।

  typedef std::map<std::string,int> stringmap; stringmap strings; int laststr = 24; //       std::vector<stringmap::iterator> strdata; //   // ... //    VAL: ID '(' ARGS ')' if (!$1.compare("echo")) { if(!$3.size()) yyerror("Input: too many arguments"); $$ = 0; foreach(i, $3) if(!i->dest) // string if(strings.count(i->str)) emit(command::echo, 0, strings[i->str]); else { strdata.push_back(strings.insert(stringmap::value_type(i->str,laststr)).first); emit(command::echo, 0, laststr); laststr += i->str.length()+1; } else emit(command::echo, i->dest, 0); } // ... // (    -) case command::hlt: i->emit(0x5b, 0x5e, 0x5f, 0x5d); // POP EBX / POP ESI / POP EDI / POP EBP i->emit(0xc3); // RET break; case command::echo: // PUSH live / MOV EDI, dst / CALL [EBP+?] / POP live foreach(rp, i->onexitp) if(*rp!=4) i->emit(0x50|(*rp-1)); if(!i->cmd.dest) { // imm / [EBP+16] i->emit14(0xbe, i->cmd.imm); i->emit(0xff, 0x55, 16); } else { if(i->known.count(i->cmd.dest)) // imm / [EBP+4] i->emit14(0xbe, i->known[i->cmd.dest]); else // dst / [EBP+8] i->emit(0x8b, 0xf0|(i->cmd.dest-1)); i->emit(0xff, 0x55, 8); } foreachr(rp, i->onexitp) if(*rp!=4) { i->emit(0x58|(*rp-1)); i->popcnt++; } break;

ELF में स्थानांतरण दो स्वरूपों में आते हैं: rel

या rela

। rel

प्रारूप अधिक कॉम्पैक्ट है, लेकिन लिंकर rel

साथ काम करना आसान है; इसलिए, जब x64 प्लेटफ़ॉर्म पर जा rel

, तो rel

पदावनत घोषित किया गया था । फिर भी, ld

का मेरा संस्करण 64-बिट कोड में rel

का समर्थन करता है, इसलिए हम वास्तव में rel

उत्पन्न करेंगे।

हम आठ मानक खंड उत्पन्न करेंगे: खाली, .shstrtab, .strtab, .symtab, .rel.text, .rel.data, .text, .data

। ईएलएफ हेडर और पहले छह खंडों में पूर्वनिर्धारित सामग्री है; केवल .text

और .data

उत्पन्न कोड के आधार पर भरे .data

।

 //  ELF #include <linux/elf.h> #if ELF_CLASS == ELFCLASS32 #define Elf_Shdr Elf32_Shdr #define Elf_Sym Elf32_Sym #define Elf_Rel Elf32_Rel #define ELF_R_INFO(s,t) (((s)<<8)+(unsigned char)(t)) #define R_32 R_386_32 #else #define Elf_Shdr Elf64_Shdr #define Elf_Sym Elf64_Sym #define Elf_Rel Elf64_Rel #define ELF_R_INFO(s,t) (((unsigned long)(s)<<32)+(t)) #define R_32 R_X86_64_32 #endif #define ST_GLOBAL_NOTYPE STB_GLOBAL<<4 // ... //    : //       //     // : PUSH EBP / PUSH EDI / PUSH ESI / PUSH EBX / MOV RBP, ... const char prolog[] = {0x55,0x57,0x56,0x53,0x48,0xc7,0xc5,0,0,0,0}; offset += sizeof(prolog); int alignment = ((offset+3)&~3) - offset; //   dword offset += alignment; const struct { elfhdr hdr; Elf_Shdr Shdr[8]; char shstrtab[64]; char strtab[24]; Elf_Sym symtab[6]; Elf_Rel reltext[1]; Elf_Rel reldata[3]; } elf = {{{ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3, ELF_CLASS, ELF_DATA, EV_CURRENT}, // identification ET_REL, ELF_ARCH, EV_CURRENT, 0, 0, sizeof(elfhdr), 0, sizeof(elfhdr), 0, 0, sizeof(Elf_Shdr),8, 1}, {{0, SHT_NULL}, {1, SHT_STRTAB, 0, 0, (char*)&elf.shstrtab-(char*)&elf, sizeof(elf.shstrtab), 0, 0, 1, 0}, {11, SHT_STRTAB, 0, 0, (char*)&elf.strtab-(char*)&elf, sizeof(elf.strtab), 0, 0, 1, 0}, {19, SHT_SYMTAB, 0, 0, (char*)&elf.symtab-(char*)&elf, sizeof(elf.symtab), 2, 2, 8,sizeof(Elf_Sym)}, {27, SHT_REL, 0, 0, (char*)&elf.reltext-(char*)&elf, sizeof(elf.reltext), 3, 6, 8, sizeof(Elf_Rel)}, {37, SHT_REL, 0, 0, (char*)&elf.reldata-(char*)&elf, sizeof(elf.reldata), 3, 7, 8, sizeof(Elf_Rel)}, {47, SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR, 0, sizeof(elf), offset, 0, 0, 4, 0}, {53, SHT_PROGBITS, SHF_ALLOC|SHF_WRITE, 0, sizeof(elf)+offset, laststr+lastspill*4, 0, 0, 4, 0}}, "\0.shstrtab\0.strtab\0.symtab\0.rel.text\0.rel.data\0.text\0.data", // shstrtab "\0main\0input\0echoi\0echos", // strtab {{}, #if ELF_CLASS == ELFCLASS32 {0, 0, 0, STT_SECTION, 0, 7}, {1, 0, 0, ST_GLOBAL_NOTYPE, 0, 6}, // main {6, 0, 0, ST_GLOBAL_NOTYPE, 0, 0}, // input {12, 0, 0, ST_GLOBAL_NOTYPE, 0, 0}, // echoi {18, 0, 0, ST_GLOBAL_NOTYPE, 0, 0}}, // echos #else {0, STT_SECTION, 0, 7, 0, 0}, {1, ST_GLOBAL_NOTYPE, 0, 6, 0, 0}, // main {6, ST_GLOBAL_NOTYPE, 0, 0, 0, 0}, // input {12, ST_GLOBAL_NOTYPE, 0, 0, 0, 0}, // echoi {18, ST_GLOBAL_NOTYPE, 0, 0, 0, 0}}, // echos #endif {{7, ELF_R_INFO(1,R_32)}}, // reltext {{0, ELF_R_INFO(3,1)}, // input {8, ELF_R_INFO(4,1)}, // echoi {16, ELF_R_INFO(5,1)}} // echos }; write(1, &elf, sizeof(elf)); //   write(1, prolog, sizeof(prolog)); foreach(i, pcode) write(1, &*i->code.begin(), i->code.size()); //   dword const char zero[24] = {}; write(1, zero, alignment); //   write(1, zero, 24); //   foreach(i, strdata) write(1, (*i)->first.c_str(), (*i)->first.length()+1); //     ftruncate(1, sizeof(elf)+offset+laststr+lastspill*4);

यह कैसे काम करता है?

अपरिवर्तनीय हेडर में, जिसे हम जेनरेट किए गए कोड में जोड़ते हैं, अस्पष्ट संख्याओं का एक गुच्छा। इन सबका मतलब क्या है?

क्रम में चलते हैं।

ELFMAG0,ELFMAG1,ELFMAG2,ELFMAG3

: चार "मैजिक बाइट्स" जिनमें से ELF फाइल शुरू होनी चाहिए;
ELF_CLASS,ELF_DATA,EV_CURRENT

: एक शब्द में " ELF_CLASS,ELF_DATA,EV_CURRENT

" (शब्द चौड़ाई), बाइट ऑर्डर के लिए पहचानकर्ता और ईएलएफ प्रारूप संस्करण। इन पहचानकर्ताओं के आधार पर, बाकी के हेडर को डिक्रिप्ट किया जाता है (इसके 32- और 64-बिट संस्करणों में, विभिन्न क्षेत्र आकार);
ET_REL

: ELF फ़ाइल का प्रकार ("स्थानांतरण योग्य", "निष्पादन योग्य", "गतिशील पुस्तकालय");
ELF_ARCH,EV_CURRENT

: प्रोसेसर पहचानकर्ता और फिर से प्रारूप का संस्करण;
0,0

: प्रवेश बिंदु पता और खंड तालिका ऑफसेट। स्थानांतरित फ़ाइलों में एक भी नहीं है;
sizeof(elfhdr)

: सेक्शन टेबल ऑफ़सेट। हमारे साथ, वह शीर्षासन के ठीक बाद जाएगी;
0

: झंडे x86 / x64 पर परिभाषित नहीं;
sizeof(elfhdr)

: हेडर का आकार;
0,0

: खंड तालिका में आकार और प्रविष्टियों की संख्या। हमारे पास यह तालिका नहीं है, लेकिन यह नहीं है;
sizeof(Elf_Shdr),8

अनुभाग तालिका में sizeof(Elf_Shdr),8

: आकार और प्रविष्टियों की संख्या;
1

: सभी वर्गों के नाम युक्त अनुभाग संख्या;
"\0.shstrtab\0.strtab\0.symtab\0.rel.text\0.rel.data\0.text\0.data"

: सभी वर्गों के नाम, एक के बाद एक। स्ट्रिंग का पहला वर्ण \0

होना चाहिए ताकि एक शून्य ऑफसेट एक खाली नाम इंगित करता है;
{0, SHT_NULL}

: मानक खंड नंबर 0 खाली होना चाहिए;
1

: अनुभाग नाम (ऑफसेट shstrtab

अंदर);
SHT_STRTAB

: अनुभाग प्रकार (इस मामले में, "पंक्ति तालिका");
0

: झंडे (पढ़ें, लिखें, निष्पादित करें) जो अनुभाग के लिए स्मृति सुरक्षा सेट करते हैं। सेवा अनुभागों के लिए, जैसे कि नाम तालिका, इसमें से किसी की भी आवश्यकता नहीं है;
0

: स्मृति में अनुभाग पता। स्थानांतरित फ़ाइलों में परिभाषित नहीं किया गया है;
(char*)&elf.shstrtab-(char*)&elf,sizeof(elf.shstrtab)

: फ़ाइल में अनुभाग ऑफसेट, और इसका आकार;
0,0

: दो अतिरिक्त फ़ील्ड, जिनमें से व्याख्या अनुभाग के प्रकार पर निर्भर करती है। तालिका के लिए कोई पंक्तियों को परिभाषित नहीं किया गया है;
1

: संरेखण ब्लॉक आकार; तार के लिए - 1 बाइट, अर्थात्। संरेखण के बिना;
0

: सेक्शन के अंदर रिकॉर्ड आकार। अनिश्चित लंबाई की पंक्तियों के रिकॉर्ड की तालिका में;
{11,SHT_STRTAB,0,0,(char*)&elf.strtab-(char*)&elf,sizeof(elf.strtab),0,0,1,0}

: एक और पंक्ति तालिका। यह केवल नाम में भिन्न है (11- .strtab

);
{19,SHT_SYMTAB,0,0,(char*)&elf.symtab-(char*)&elf,sizeof(elf.symtab),2,2,8,sizeof(Elf_Sym)}

: "प्रतीक तालिका" प्रकार का अनुभाग। अतिरिक्त फ़ील्ड की सामग्री: पहले दो - पात्रों के नाम के साथ अनुभाग की संख्या (पिछले एक, यानी। .strtab

), दूसरा दो - पहले वैश्विक प्रतीक की संख्या;
{27,SHT_REL,0,0,(char*)&elf.reltext-(char*)&elf,sizeof(elf.reltext),3,6,8,sizeof(Elf_Rel)}

प्रकार का अनुभाग "स्थानांतरण तालिका"। अतिरिक्त फ़ील्ड की सामग्री: प्रतीक तालिका (पिछले अनुभाग, यह भी नंबर 3 है) के लिए लिंक और स्थानांतरित खंड ( .text

, यह भी नंबर 6 है);
{37,SHT_REL,0,0,(char*)&elf.reldata-(char*)&elf,sizeof(elf.reldata),3,7,8,sizeof(Elf_Rel)}

एक और पुनर्वास तालिका। उसी प्रतीक तालिका (नंबर 3) और .data

अनुभाग (नंबर 7) का संदर्भ देता है;
{47,SHT_PROGBITS,SHF_ALLOC|SHF_EXECINSTR,0,sizeof(elf),offset,0,0,4,0}

: डेटा खंड ( SHT_PROGBITS

) निष्पादित करने की क्षमता ( SHF_EXECINSTR

) आकार की offset

;
{53,SHT_PROGBITS,SHF_ALLOC|SHF_WRITE,0,sizeof(elf)+offset,laststr+lastspill*4,0,0,4,0}

डालने के लिए कोशिकाएं;
"\0main\0input\0echoi\0echos"

: प्रतीक नाम (आयात और निर्यात), अनुभाग नामों के समान प्रारूप में;
{}

: वर्ण संख्या 0 रिक्त रहना चाहिए;
{0, 0, 0, STT_SECTION, 0, 7}

: एक अनाम (0) स्थानीय वर्ण सेक्शन ( STT_SECTION

) नंबर 7, अर्थात्। .data

;
{1, 0, 0, ST_GLOBAL_NOTYPE, 0, 6}

: वैश्विक (ST_GLOBAL_NOTYPE) चरित्र नाम main

(नाम ऑफ़सेट 1), खंड 0 6 में ऑफसेट 0 को इंगित करता है, अर्थात्। .text

;
{6, ST_GLOBAL_NOTYPE, 0, 0, 0, 0}

: एक वैश्विक वर्ण जिसका नाम input

(नाम ऑफसेट 6) है जो किसी भी अनुभाग से संबंधित नहीं है, अर्थात्। आयातित;
अन्य दो आयातित पात्र, echoi

और echoi

, को इसी तरह परिभाषित किया गया है।

प्रोग्रामर को भ्रमित करने के लिए, Elf32_Sym

और Elf64_Sym

एक ही फ़ील्ड से परिभाषित किया जाता है, लेकिन एक अलग क्रम में। हमारे पास कोड के दो संस्करणों को लिखने के अलावा कोई विकल्प नहीं है, और उनमें से किसी एक का चयन करने के #ifdef

का #ifdef

करें।

Relocations relocations triples से मिलकर बनता है "रीलोकेटेड फ़ील्ड की ऑफसेट, प्रतीक संख्या, बाध्यकारी प्रकार कोड"। पहला स्थानांतरण ( {7, ELF_R_INFO(1,R_32)}

) - कोड की शुरुआत से ऑफसेट 7 में, प्रस्तावना में; यह EBP/RBP

में लोड किए गए डेटा का आधार पता सेट करता है। यह स्थानांतरण प्रतीक संख्या 1, अर्थात् को दर्शाता है to .data

अनुभाग किसी भी आर्किटेक्चर पर, इसका आकार 32 बिट्स है। बाइंडिंग प्रकार कोड अलग है: R_386_32=1

पर R_386_32=1

, और x64 पर R_X86_64_32=10

।

तीन अन्य स्थानांतरण डेटा में हैं, 0.8.16 पर ऑफसेट में तीन आयातित कार्यों के पते प्राप्त करना। ये तीनों रीलोकेशन आयातित वर्णों (नं। 3,4,5) को संदर्भित करते हैं, और लंगर कोड 1 का उपयोग करते हैं, हमेशा मशीन शब्द ( R_386_32,R_X86_64_64

) के R_386_32,R_X86_64_64

।

पूर्ण संकलक कोड: tyomitch.net.ru/jsk.y.elf.html

यदि आप मैन्युअल रूप से बायनेरी इकट्ठा करने में रुचि रखते हैं, तो मैं आपको सलाह देता हूं कि आप ईएलएफ फाइलों के आकार को कम करने के तरीकों पर ध्यान दें, व्यावहारिक रूप से उपयोगी ट्रिक्स से लेकर पागल हैक्स; और एक ही समय में पूरी तरह से सिकुड़े हुए कार्यक्रमों के उदाहरण ।

परिणामी फ़ाइल 45 बाइट आकार में है: कोडांतरक की तुलना में पांच गुना छोटी और सी की तुलना में पचास गुना छोटी है। हमने वह सब कुछ फेंक दिया जो हम फ़ाइल से बाहर कर सकते थे; और जिसे फेंका नहीं जा सका, हम दो या तीन उद्देश्यों के लिए एक साथ उपयोग करते हैं।

इस फ़ाइल में लगभग आधे मान ईएलएफ मानक का उल्लंघन करते हैं; एक सामान्य प्रोग्रामर यह स्वीकार करने के लिए शर्मिंदा होगा कि ऐसा कार्यक्रम उसके हाथों का फल है। आश्चर्यजनक रूप से, लिनक्स इस दुःस्वप्न को एक पीआईडी असाइन करने के लिए सहमत है।

दूसरी ओर, इस फ़ाइल में हर बाइट के बारे में मैं बता सकता हूं कि इसकी आवश्यकता क्यों है। अक्सर आप एक ही बात कह सकते हैं कि आपके द्वारा संकलित फ़ाइलों के बारे में?

क्या हुआ था?

अब अंतिम बाइनरी दो स्वतंत्र घटकों से प्राप्त की जाती है जिन्हें हम अलग से संकलित कर सकते हैं।

 [tyomitch@home ~]$ as jskstd.s -o jskstd.o 
      

        
        
        
      

     [tyomitch@home ~]$ 
      

        
        
        
      

     [tyomitch@home ~]$ bison jsk.y 
      

        
        
        
      

     [tyomitch@home ~]$ c++ jsk.tab.c lex.yy.c -o jskc 
      

        
        
        
      

     [tyomitch@home ~]$ 
      

        
        
        
      

     [tyomitch@home ~]$ ./jskc < test.jsk > code.o 
      

        
        
        
      

     [tyomitch@home ~]$ cc jskstd.o code.o 
      

        
        
        
      

     [tyomitch@home ~]$ ./a.out 
      

        
        
        
      

        0  1000,     
      

        
        
        
      

      500? (1=, 2=, 3=) 1 
      

        
        
        
      

      249? (1=, 2=, 3=) 3 
      

        
        
        
      

     !  ! 
      

        
        
        
      

     [tyomitch@home ~]$ objdump -d code.o 
      

        
        
        
      

     code.o: file format elf64-x86-64 Disassembly of section .text: 0000000000000000 <main>: 0: 55 push %rbp 1: 57 push %rdi 2: 56 push %rsi 3: 53 push %rbx 4: 48 c7 c5 00 00 00 00 mov $0x0,%rbp b: 33 c0 xor %eax,%eax d: b9 e8 03 00 00 mov $0x3e8,%ecx 12: 50 push %rax 13: 51 push %rcx 14: be 18 00 00 00 mov $0x18,%esi 19: ff 55 10 callq *0x10(%rbp) 1c: 59 pop %rcx 1d: 58 pop %rax 1e: 50 push %rax 1f: 51 push %rcx 20: be 00 00 00 00 mov $0x0,%esi 25: ff 55 08 callq *0x8(%rbp) 28: be 38 00 00 00 mov $0x38,%esi 2d: ff 55 10 callq *0x10(%rbp) 30: 59 pop %rcx 31: 51 push %rcx 32: be e8 03 00 00 mov $0x3e8,%esi 37: ff 55 08 callq *0x8(%rbp) 3a: be 3f 00 00 00 mov $0x3f,%esi 3f: ff 55 10 callq *0x10(%rbp) 42: 59 pop %rcx 43: 58 pop %rax 44: 3b c1 cmp %ecx,%eax 46: 0f 8f 6c 00 00 00 jg b8 <main+0xb8> 4c: 8d 14 01 lea (%rcx,%rax,1),%edx 4f: d1 fa sar %edx 51: 50 push %rax 52: 51 push %rcx 53: 52 push %rdx 54: be 64 00 00 00 mov $0x64,%esi 59: ff 55 10 callq *0x10(%rbp) 5c: 5a pop %rdx 5d: 52 push %rdx 5e: 8b f2 mov %edx,%esi 60: ff 55 08 callq *0x8(%rbp) 63: be 6c 00 00 00 mov $0x6c,%esi 68: ff 55 10 callq *0x10(%rbp) 6b: ff 55 00 callq *0x0(%rbp) 6e: 93 xchg %eax,%ebx 6f: 5a pop %rdx 70: 59 pop %rcx 71: 58 pop %rax 72: 89 85 04 01 00 00 mov %eax,0x104(%rbp) 78: 83 fb 01 cmp $0x1,%ebx 7b: 75 0b jne 88 <main+0x88> 7d: 8b 85 04 01 00 00 mov 0x104(%rbp),%eax 83: 8d 4a ff lea 0xffffffffffffffff(%rdx),%ecx 86: eb bc jmp 44 <main+0x44> 88: 83 fb 02 cmp $0x2,%ebx 8b: 75 05 jne 92 <main+0x92> 8d: 8d 42 01 lea 0x1(%rdx),%eax 90: eb b2 jmp 44 <main+0x44> 92: 8b 85 04 01 00 00 mov 0x104(%rbp),%eax 98: 83 fb 03 cmp $0x3,%ebx 9b: 75 0d jne aa <main+0xaa> 9d: be 9f 00 00 00 mov $0x9f,%esi a2: ff 55 10 callq *0x10(%rbp) a5: 5b pop %rbx a6: 5e pop %rsi a7: 5f pop %rdi a8: 5d pop %rbp a9: c3 retq aa: 50 push %rax ab: 51 push %rcx ac: be bb 00 00 00 mov $0xbb,%esi b1: ff 55 10 callq *0x10(%rbp) b4: 59 pop %rcx b5: 58 pop %rax b6: eb 8c jmp 44 <main+0x44> b8: be dd 00 00 00 mov $0xdd,%esi bd: ff 55 10 callq *0x10(%rbp) c0: 5b pop %rbx c1: 5e pop %rsi c2: 5f pop %rdi c3: 5d pop %rbp c4: c3 retq 
      

        
        
        
      

       , , ,        llvm.     —  .

[tyomitch@home ~]$ as jskstd.s -o jskstd.o 
      

        
        
        
      

     [tyomitch@home ~]$ 
      

        
        
        
      

     [tyomitch@home ~]$ bison jsk.y 
      

        
        
        
      

     [tyomitch@home ~]$ c++ jsk.tab.c lex.yy.c -o jskc 
      

        
        
        
      

     [tyomitch@home ~]$ 
      

        
        
        
      

     [tyomitch@home ~]$ ./jskc < test.jsk > code.o 
      

        
        
        
      

     [tyomitch@home ~]$ cc jskstd.o code.o 
      

        
        
        
      

     [tyomitch@home ~]$ ./a.out 
      

        
        
        
      

        0  1000,     
      

        
        
        
      

      500? (1=, 2=, 3=) 1 
      

        
        
        
      

      249? (1=, 2=, 3=) 3 
      

        
        
        
      

     !  ! 
      

        
        
        
      

     [tyomitch@home ~]$ objdump -d code.o 
      

        
        
        
      

     code.o: file format elf64-x86-64 Disassembly of section .text: 0000000000000000 <main>: 0: 55 push %rbp 1: 57 push %rdi 2: 56 push %rsi 3: 53 push %rbx 4: 48 c7 c5 00 00 00 00 mov $0x0,%rbp b: 33 c0 xor %eax,%eax d: b9 e8 03 00 00 mov $0x3e8,%ecx 12: 50 push %rax 13: 51 push %rcx 14: be 18 00 00 00 mov $0x18,%esi 19: ff 55 10 callq *0x10(%rbp) 1c: 59 pop %rcx 1d: 58 pop %rax 1e: 50 push %rax 1f: 51 push %rcx 20: be 00 00 00 00 mov $0x0,%esi 25: ff 55 08 callq *0x8(%rbp) 28: be 38 00 00 00 mov $0x38,%esi 2d: ff 55 10 callq *0x10(%rbp) 30: 59 pop %rcx 31: 51 push %rcx 32: be e8 03 00 00 mov $0x3e8,%esi 37: ff 55 08 callq *0x8(%rbp) 3a: be 3f 00 00 00 mov $0x3f,%esi 3f: ff 55 10 callq *0x10(%rbp) 42: 59 pop %rcx 43: 58 pop %rax 44: 3b c1 cmp %ecx,%eax 46: 0f 8f 6c 00 00 00 jg b8 <main+0xb8> 4c: 8d 14 01 lea (%rcx,%rax,1),%edx 4f: d1 fa sar %edx 51: 50 push %rax 52: 51 push %rcx 53: 52 push %rdx 54: be 64 00 00 00 mov $0x64,%esi 59: ff 55 10 callq *0x10(%rbp) 5c: 5a pop %rdx 5d: 52 push %rdx 5e: 8b f2 mov %edx,%esi 60: ff 55 08 callq *0x8(%rbp) 63: be 6c 00 00 00 mov $0x6c,%esi 68: ff 55 10 callq *0x10(%rbp) 6b: ff 55 00 callq *0x0(%rbp) 6e: 93 xchg %eax,%ebx 6f: 5a pop %rdx 70: 59 pop %rcx 71: 58 pop %rax 72: 89 85 04 01 00 00 mov %eax,0x104(%rbp) 78: 83 fb 01 cmp $0x1,%ebx 7b: 75 0b jne 88 <main+0x88> 7d: 8b 85 04 01 00 00 mov 0x104(%rbp),%eax 83: 8d 4a ff lea 0xffffffffffffffff(%rdx),%ecx 86: eb bc jmp 44 <main+0x44> 88: 83 fb 02 cmp $0x2,%ebx 8b: 75 05 jne 92 <main+0x92> 8d: 8d 42 01 lea 0x1(%rdx),%eax 90: eb b2 jmp 44 <main+0x44> 92: 8b 85 04 01 00 00 mov 0x104(%rbp),%eax 98: 83 fb 03 cmp $0x3,%ebx 9b: 75 0d jne aa <main+0xaa> 9d: be 9f 00 00 00 mov $0x9f,%esi a2: ff 55 10 callq *0x10(%rbp) a5: 5b pop %rbx a6: 5e pop %rsi a7: 5f pop %rdi a8: 5d pop %rbp a9: c3 retq aa: 50 push %rax ab: 51 push %rcx ac: be bb 00 00 00 mov $0xbb,%esi b1: ff 55 10 callq *0x10(%rbp) b4: 59 pop %rcx b5: 58 pop %rax b6: eb 8c jmp 44 <main+0x44> b8: be dd 00 00 00 mov $0xdd,%esi bd: ff 55 10 callq *0x10(%rbp) c0: 5b pop %rbx c1: 5e pop %rsi c2: 5f pop %rdi c3: 5d pop %rbp c4: c3 retq 
      

        
        
        
      

       , , ,        llvm.     —  .

संकलन। 10: ईएलएफ में संकलन