संकलन। 9: निष्पादन योग्य कोड

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

यहां कोई जटिल एल्गोरिदम नहीं हैं: द्वारा और बड़े, केवल दूसरे के साथ आदेशों की एक प्रणाली को प्रतिस्थापित करते हैं।

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

1. कोड चयन
2. लोडर
3. पी कोड बदलता है
4. पीढ़ी
5. क्या हुआ था?

कोड चयन

मैं यह मानकर चलता हूं कि आप इस पोस्ट को एक ऐसे कंप्यूटर पर पढ़ रहे हैं जिसमें x86 या x64 प्रोसेसर है। मैं मोबाइल उपकरणों के उपयोगकर्ताओं से माफी माँगता हूँ: फैशनेबल गैजेट के लिए कोड तैयार करना दिलचस्प होगा, लेकिन प्रयोगों के लिए इस तरह की प्रतिलिपि प्राप्त करना मेरे लिए बहुत मुश्किल है।



हम एक "क्रॉस-प्लेटफ़ॉर्म" कोड उत्पन्न करने की कोशिश करेंगे जो x86 और x64 पर समान रूप से कार्यात्मक है। हम मशीन कोड पर ध्यान केंद्रित करते हैं, और बूटलोडर के साथ ईएलएफ प्रारूप और बातचीत के आंतरिक पर नहीं; इसलिए, हम डॉस प्रारूप COM के समान एक "ठोस टुकड़ा" में कोड बनाएंगे। इसे डिस्क से पढ़ें और रन हमारा खुद का बूटलोडर होगा।



हम केवल 32-बिट रजिस्टर का उपयोग करेंगे, इसलिए एक ही कार्यक्रम, भले ही गणना के दौरान ओवरफ्लो हो, x64 और x86 पर समान परिणाम देगा।



बाहरी दुनिया ( ECHO



और INPUT



कमांड) के साथ संवाद करने के लिए, उत्पन्न कोड को किसी तरह ऑपरेटिंग सिस्टम के कार्यों को कॉल करना होगा। वह उनके पते को कैसे जानता है?

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



/ EBP



में स्थानांतरित पते को बचाएं।



एक और दिलचस्प बिंदु मेमोरी तक पहुंच है (चर चर करने के लिए)। विशिष्ट x86 निरपेक्ष संबोधन के बजाय, x64 ने RIP



सापेक्ष "रोमिंग निरपेक्ष" पेश किया। वास्तव में कोड क्रॉस-प्लेटफ़ॉर्म प्राप्त करने के लिए, आपको स्पष्ट सापेक्ष पते का उपयोग करना होगा।

आगे की हलचल के बिना, हम एक ही EBP



/ RBP



- यानी के संबंध में EBP



हुए चरों की कोशिकाओं को संबोधित करेंगे। संचार क्षेत्र के तुरंत बाद, ऑफसेट 0x18



, चर क्षेत्र शुरू होता है।



उत्पन्न पी-कोड चार "अमूर्त भौतिक रजिस्टरों" R01..R04



का उपयोग करता है, जो स्वाभाविक रूप से वास्तविक रजिस्टरों EAX,ECX,EDX,EBX



: यानी से मेल खाते हैं। इस रजिस्टर की संख्या "सार" की संख्या से घटाकर प्राप्त की जाती है। यदि हम बाकी प्रोसेसर रजिस्टर का उपयोग करना चाहते हैं, तो संख्याओं के बीच पत्राचार अधिक जटिल होगा।



जिस तरह से x86 और x64 पर फंक्शन को पैरामीटर पास किया जाता है वह बहुत अलग है। X86 पर, डिफ़ॉल्ट पैरामीटर स्टैक ( cdecl ) के माध्यम से पारित किए जाते हैं, लेकिन आप ECX,EDX,EAX



( फास्टकॉल ) रजिस्टरों में अधिकतम तीन मापदंडों gcc



पास करने के लिए पूछ सकते हैं। X64 पर, रजिस्टरों RDI,RSI,RDX,RCX,R8,R9



छह पैरामीटर दिए गए हैं और gcc



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

दोनों प्रोसेसर पर, बुलाया फ़ंक्शन को EAX,ECX,EDX



की सामग्री को खराब करने का अधिकार है, इसलिए उन्हें कॉल (यदि वे जीवित हैं) से पहले सहेजने की आवश्यकता होगी, और बाद में बहाल किया जाएगा। इस प्रकार, भौतिक रजिस्टरों की जीवन शक्ति के बारे में जानकारी, जिसका उपयोग हमने उनकी नियुक्ति के दौरान किया था, को कोड बनाते समय भी इसकी आवश्यकता होती है।



क्या कोड उत्पन्न किया जाएगा, हल किया गया; यह छोटी बात पर निर्भर करता है कि इसका क्या उद्देश्य था।

लोडर

हम एक आधार के रूप में लंबे समय तक चलने वाले पी-कोड दुभाषिया को छोड़ देते हैं, सभी पतियों को छोड़ दें (इनपुट की जाँच करें, फ़ाइल को मेमोरी में मैप कर रहे हैं), और पेट (कमांड्स के कार्यान्वयन और कार्यान्वयन का चक्र) को रीड कोड के लिए कॉल के साथ बदलें, जैसे कि यह एक नियमित sys-function थे।

#include <fcntl.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/mman.h>

#include <sys/stat.h>



const char * fdata = NULL ; //



int input() { int d; scanf( " %d " , &d); return d; }

void echoi( int i) { printf( " %d " , i); }

void echos( int offset) { printf( " %s " , fdata+offset); }



void * linkarea[ 1000 ] = {( void *)input, ( void *)echoi, ( void *) echos};



int main( int argc, char ** argv) {



if (argc!= 2 ) {

printf( "Missing code file name. \n " );

exit( 1 );

}



int fd = open(argv[ 1 ], O_RDONLY);

if (fd< 0 ) {

printf( "Cannot open code file. \n " );

exit( 1 );

}

struct stat finfo;

fstat(fd, &finfo);

fdata = ( const char *)mmap( 0 , finfo.st_size, PROT_READ|PROT_EXEC, MAP_PRIVATE, fd, 0 );

if (!fdata) {

printf( "Cannot read code file. \n " );

exit( 1 );

}



(( void (*)( void **)) fdata)(linkarea); //



munmap(( void *)fdata, finfo.st_size);

close(fd);

return 0 ;

}







ध्यान दें कि #include "jsk.h"



गायब हो गया, जिसने कमांड परिभाषाओं को परिभाषित किया: नए बूटलोडर को न तो j- स्क्रिप्ट के बारे में कुछ पता है, और न ही हमारे पी-कोड के बारे में।

पी कोड बदलता है

अब चूंकि पी-कोड एक आंतरिक प्रतिनिधित्व बन गया है, जो संकलक के बाहर से अदृश्य है, प्रत्येक कमांड को 4 बाइट्स में संपीड़ित करने का कोई अर्थ नहीं है; इसलिए, न तो चालाक union



और न ही क्षेत्र आकार प्रतिबंधों की आवश्यकता है। int



क्षेत्रों के साथ एक नियमित संरचना घोषणा के साथ jsk.h



बदलें:

struct command {

enum opcodes {

hlt, store, jz, echo, mov, load, input, add, sub, mul, div,

eq, ne, ge, le, gt, lt

};

opcodes opcode;

regnum dest, src1, src2;

int imm;

command(opcodes opcode, regnum dest, regnum src1, regnum src2) :

opcode(opcode), dest(dest), src1(src1), src2(src2) {}

command(opcodes opcode, regnum dest, int imm) :

opcode(opcode), dest(dest), imm(imm) {}

};









X86 / x64 निर्देश सेट की एक विशेषता इसकी विविधता और गैर-ऑर्थोगोनलिटी है। लगभग किसी भी ऑपरेशन को तीन से चार अलग-अलग तरीकों से एन्कोड किया जा सकता है। हम प्रत्येक पी-टीम के लिए संभव कार्यान्वयन के सबसे कॉम्पैक्ट को चुनने की कोशिश करेंगे। (यह सहकर्मी -to- पीयर ऑप्टिमाइज़ेशन - पीपहोल ऑप्टिमाइज़ेशन का सीमित मामला है, जो कार्यक्रम को समग्र रूप से नहीं, बल्कि आसन्न टीमों के छोटे ब्लॉकों के साथ पेश करता है। सामान्य तौर पर, प्रत्येक टीम को स्वतंत्र रूप से इसके चारों ओर संसाधित किया जाता है।)



उदाहरण के लिए, n-कमांड add



को MOD ​​में, INC



, DEC



, ADD



के तीन रूपों में से एक में या LEA



के तीन रूपों में से एक में तर्कों के संयोजन के आधार पर संकलित किया जा सकता है।



कुछ स्थानीय अनुकूलन, जैसे कि mul r, r, 2



को add r, r, r



बदलना mul r, r, 2



निष्पादन योग्य कोड में अनुवादित होने से पहले, आसानी से पी-कोड स्तर पर किया जाता है। एक ही चरण में - भौतिक रजिस्टर चुनने के बाद, लेकिन अंतिम अनुवाद से पहले - हम रजिस्टरों से छुटकारा पा लेंगे, जिसका मूल्य उन सभी स्थानों पर जाना जाता है जहां उनका उपयोग किया जाता है: अनुवाद के दौरान हम ज्ञात मूल्य का उपयोग करेंगे।

// :

// ...

if (i->cmd.opcode==command::mul) { //

if (i->known.count(i->cmd.src1)) std::swap(i->cmd.src1, i->cmd.src2);

if (i->known.count(i->cmd.src2)) switch (i->known[i->cmd.src2]) {

case - 1 : i->cmd = command(command::sub, i->cmd.dest, 0 , i->cmd.src1); break ;

case 0 : i->cmd = command(command::mov, i->cmd.dest, 0 ); break ;

case 1 : nopOut(i); break ;

case 2 : i->cmd = command(command::add, i->cmd.dest, i->cmd.src1, i->cmd.src1); break ;

}

}



// , ,

void postalloc() {

std::vector< bool > needed(lastreg+ 1 );

foreach(i, pcode) {

if (i->has2src()) {

if (!i->known.count(i->cmd.src1)) needed[i->cmd.src1]= true ;

if (!i->known.count(i->cmd.src2)) needed[i->cmd.src2]= true ;

else // src2 :

if (i->cmd.opcode==command::div && i->known[i->cmd.src2]!= 2 )

needed[i->cmd.src2]= true ; //

}

if (i->readsdest() && !i->known.count(i->cmd.dest))

needed[i->cmd.dest]= true ;

}

foreach(i, pcode)

if (i->writesdest() && !needed[i->cmd.dest])

nopOut(i);

}



// :

// ...

postalloc();

// NOP-

simpleopt();

// : , known

foreach(i, pcode) {

std::map<regnum, int > known;

if (i->known.count(i->cmd.dest))

known[physmap[i->cmd.dest]] = i->known[i->cmd.dest];

i->cmd.dest = physmap[i->cmd.dest];

if (i->has2src()) {

if (i->known.count(i->cmd.src1))

known[physmap[i->cmd.src1]] = i->known[i->cmd.src1];

if (i->known.count(i->cmd.src2))

known[physmap[i->cmd.src2]] = i->known[i->cmd.src2];

i->cmd.src1 = physmap[i->cmd.src1];

i->cmd.src2 = physmap[i->cmd.src2];

}

i->known = known;

}

break ;



पीढ़ी

सभी उत्पन्न कोड एक बड़े वेक्टर std::vector<char> code;



में संग्रहीत किए जाएंगे std::vector<char> code;





struct commandn



हमें कुछ नए क्षेत्रों की आवश्यकता है। int offset, length;



code



वेक्टर में कमांड की स्थिति निर्धारित करेगा। इसके अलावा, JZ



और ECHO



कमांड के लिए, ऑफ़सेट वैल्यू जो int needfixat;



क्षेत्र में कोड जनरेशन के अंत तक ज्ञात नहीं है int needfixat;



हम अधूरे पूर्वाग्रह के सूचकांक को संग्रहित करेंगे।



तो, पी-कोड के माध्यम से पहले पास पर, हम कोड वेक्टर में सभी निष्पादन योग्य कोड उत्पन्न करते हैं; फिर कोड के माध्यम से दूसरी बार जाएं और लापता ऑफसेट को भरें। उसके बाद, हम सभी कोड और सभी लाइनों के परिणाम को प्रिंट करते हैं।



मैंने कम से कम इसे थोड़ा कम करने के लिए, सूची से सबसे निर्बाध टुकड़ों को हटाने की कोशिश की। पूरा संकलक कोड tyomitch.net.ru/jsk.y.natv.html पर उपलब्ध है



// : x86/x64

const char regsize = sizeof ( void *); // 4 8

//

if (regsize== 4 ) { // PUSH EBP / MOV EBP, [ESP+8] / PUSH EDI / PUSH ESI / PUSH EBX

code.push_back( 0x55 ); code.push_back( 0x8b ); code.push_back( 0x6c ); code.push_back( 0x24 );

code.push_back( 0x08 ); code.push_back( 0x57 ); code.push_back( 0x56 ); code.push_back( 0x53 );

} else { // PUSH EBP / MOV RBP, RDI / PUSH EBX

code.push_back( 0x55 ); code.push_back( 0x48 ); code.push_back( 0x8b ); code.push_back( 0xef );

code.push_back( 0x53 );

}

foreach(i, pcode) {

int imm, doffset, joffset;

bool jshort, saveAX, saveDX;

i->offset = code.size();

switch (i->cmd.opcode) {

case command::hlt:

if (regsize== 4 ) {

i->emit( 0x5b , 0x5e , 0x5f , 0x5d ); // POP EBX / POP ESI / POP EDI / POP EBP

i->emit( 0xc2 , 2 , 0 ); // RET 2

} else

i->emit( 0x5b , 0x5d , 0xc3 ); // POP EBX / POP EBP / RET

break ;

case command::store: // MOV [EBP+18+(imm-1)*4], dst

doffset = 0x18 +(i->cmd.imm- 1 )* 4 ;

if (i->known.count(i->cmd.dest)) {

i->emit( 0xc7 );

if (doffset< 128 )

i->emit( 0x45 , ( char )doffset);

else {

i->emit14( 0x85 , doffset);

}

i->emit4(i->known[i->cmd.dest]);

} else {

i->emit( 0x89 );

if (doffset< 128 )

i->emit( 0x45 |(i->cmd.dest- 1 )<< 3 , ( char )doffset);

else

i->emit14( 0x85 |(i->cmd.dest- 1 )<< 3 , doffset);

}

break ;

case command::jz:

joffset = i->tgt->offset - (i->offset+ 2 ); // JMP SHORT

jshort = i->tgt->offset && (joffset>=- 128 ); //

if (!i->cmd.dest) { // JMP off

if (jshort)

i->emit( 0xeb , ( char )joffset);

else {

i->emit( 0xe9 );

if (i->tgt->offset) //

i->emit4(joffset- 3 );

else {

i->needfixat = code.size();

i->emit4( 0 );

}

}

break ;

}

if (jshort && (i->cmd.dest== 2 )) { // JECXZ

i->emit( 0xe3 , ( char )joffset);

break ;

}

// OR dst, dst / JZ off

i->emit( 0x0b , 0xc0 |(i->cmd.dest- 1 )<< 3 |(i->cmd.dest- 1 ));

if (jshort && (joffset>=- 126 ))

i->emit( 0x74 , ( char )(joffset- 2 ));

else {

i->emit( 0x0f , 0x84 );

if (i->tgt->offset) //

i->emit4(joffset- 6 );

else {

i->needfixat = code.size();

i->emit4( 0 );

}

}

break ;

case command::echo: // PUSH live / PUSH dst / CALL [EBP+?] / ADD ESP, 4 / POP live

foreach(rp, i->onexitp) if (*rp!= 4 ) i->emit( 0x50 |(*rp- 1 ));

if (!i->cmd.dest) { // imm, [EBP+8]

if (regsize== 4 ) i->emit( 0x68 ); else i->emit( 0xbf );

i->needfixat = code.size();

i->emit4( 0 );

i->emit( 0xff , 0x55 , 2 *regsize);

} else {

if (i->known.count(i->cmd.dest)) { // imm, [EBP+4]

imm = i->known[i->cmd.dest];

if (regsize== 8 )

i->emit14( 0xbf , imm);

else if ((imm>=- 128 )&&(imm< 128 ))

i->emit( 0x6a , ( char )imm);

else

i->emit14( 0x68 , imm);

} else if (regsize== 4 ) // dst, [EBP+4]

i->emit( 0x50 |(i->cmd.dest- 1 ));

else

i->emit( 0x8b , 0xf8 |(i->cmd.dest- 1 ));

i->emit( 0xff , 0x55 , regsize);

}

if (regsize== 4 ) i->emit( 0x83 , 0xc4 , 4 );

foreachr(rp, i->onexitp) if (*rp!= 4 ) i->emit( 0x58 |(*rp- 1 ));

break ;

case command::mov: // MOV dst, imm

if (i->cmd.imm)

i->emit14( 0xb8 |(i->cmd.dest- 1 ), i->cmd.imm);

else // XOR dst, dst

i->emit( 0x33 , 0xc0 |(i->cmd.dest- 1 )<< 3 |(i->cmd.dest- 1 ));

break ;

case command::load: // MOV dst, [EBP+(3+i)*4]

doffset = 0x18 +(i->cmd.imm- 1 )* 4 ;

i->emit( 0x8b );

if (doffset< 128 )

i->emit( 0x45 |(i->cmd.dest- 1 )<< 3 , ( char )doffset);

else

i->emit14( 0x85 |(i->cmd.dest- 1 )<< 3 , doffset);

break ;

case command::input: // PUSH live / CALL [EBP+0] / XCHG EAX, dst / POP live

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 ));

break ;

case command::add:

// 1 ; src2

if (i->known.count(i->cmd.src1) || (i->cmd.src2==i->cmd.dest))

std::swap(i->cmd.src1, i->cmd.src2);

if (!i->cmd.src2) // MOV dst, src1

i->emit( 0x8b , 0xc0 |(i->cmd.dest- 1 )<< 3 |(i->cmd.src1- 1 ));

else if (i->known.count(i->cmd.src2)) {

imm = i->known[i->cmd.src2];

addimm :

if (i->cmd.dest==i->cmd.src1) // ADD dst, imm

if (imm== 1 ) // INC dst

i->emit( 0xff , 0xc0 |(i->cmd.dest- 1 ));

else if (imm==- 1 ) // DEC dst

i->emit( 0xff , 0xc8 |(i->cmd.dest- 1 ));

else if ((imm>=- 128 )&&(imm< 128 ))

i->emit( 0x83 , 0xc0 |(i->cmd.dest- 1 ), ( char )imm);

else // for imm=128 we might use SUB Edst, -128

i->emit114( 0x81 , 0xc0 |(i->cmd.dest- 1 ), imm);

else // LEA dst, [src1+imm]

if ((imm>=- 128 )&&(imm< 128 ))

i->emit( 0x8d , 0x40 |(i->cmd.dest- 1 )<< 3 |(i->cmd.src1- 1 ), ( char )imm);

else

i->emit114( 0x8d , 0x80 |(i->cmd.dest- 1 )<< 3 |(i->cmd.src1- 1 ), imm);

} else if (i->cmd.dest==i->cmd.src1) // ADD dst, src2

i->emit( 0x03 , 0xc0 |(i->cmd.dest- 1 )<< 3 |(i->cmd.src2- 1 ));

else // LEA dst, [src1+src2]

i->emit( 0x8d , (i->cmd.dest- 1 )<< 3 | 4 , (i->cmd.src1- 1 )<< 3 |(i->cmd.src2- 1 ));

break ;

case command::sub: // ...

case command::mul: // ...

case command::div:

if (i->known.count(i->cmd.src2) && i->known[i->cmd.src2]== 2 ) {

if (i->cmd.dest!=i->cmd.src1) // MOV dst, src1 / SAR dst, 1

i->emit( 0x8b , 0xc0 |(i->cmd.dest- 1 )<< 3 |(i->cmd.src1- 1 ));

i->emit( 0xd1 , 0xf8 |(i->cmd.dest- 1 ));

break ;

}

// EAX,EDX;

// EDI,ESI,

// MOV EDI, EAX / MOV EAX, src1 / MOV ESI, EDX / XOR EDX, EDX

// IDIV src2 / XCHG dst, EAX / MOV EDX, ESI / MOV EAX, EDI

saveAX = i->onexitp.count((physreg) 1 ) && (i->cmd.dest!= 1 );

saveDX = i->onexitp.count((physreg) 3 ) && (i->cmd.dest!= 3 );

if (saveAX || (i->cmd.src2== 1 )) i->emit( 0x8b , 0xf8 );

if (i->cmd.src1!= 1 )

if (i->known.count(i->cmd.src1))

i->emit14( 0xb8 , i->known[i->cmd.src1]);

else

i->emit( 0x8b , 0xc0 |(i->cmd.src1- 1 ));

if (saveDX || (i->cmd.src2== 3 )) i->emit( 0x8b , 0xf2 );

i->emit( 0x33 , 0xd2 );

if (i->cmd.src2== 1 ) // EDI

i->emit( 0xf7 , 0xff );

else if (i->cmd.src2== 3 ) // ESI

i->emit( 0xf7 , 0xfe );

else

i->emit( 0xf7 , 0xf8 |(i->cmd.src2- 1 ));

if (i->cmd.dest!= 1 )

i->emit( 0x90 |(i->cmd.dest- 1 ));

if (saveDX) i->emit( 0x8b , 0xd6 );

if (saveAX) i->emit( 0x8b , 0xc7 );

break ;

case command::eq: case command::ne: case command::ge:

case command::le: case command::gt: case command::lt:

// 1 ; src2

if (i->known.count(i->cmd.src1)) {

std::swap(i->cmd.src1, i->cmd.src2);

switch (i->cmd.opcode) {

case command::ge: i->cmd.opcode = command::le; break ;

case command::le: i->cmd.opcode = command::ge; break ;

case command::gt: i->cmd.opcode = command::lt; break ;

case command::lt: i->cmd.opcode = command::gt; break ;

}

}

// CMP src1, src2 / SETcc dstL / MOVZX dst, dstL

if (i->known.count(i->cmd.src2)) {

imm = i->known[i->cmd.src2];

if ((imm>=- 128 )&&(imm< 128 ))

i->emit( 0x83 , 0xf8 |(i->cmd.src1- 1 ), ( char )imm);

else if (i->cmd.src1== 1 )

i->emit14( 0x3d , imm);

else

i->emit114( 0x81 , 0xf8 |(i->cmd.src1- 1 ), imm);

} else

i->emit( 0x3b , 0xc0 |(i->cmd.src1- 1 )<< 3 |(i->cmd.src2- 1 ));

i->emit( 0x0f );

switch (i->cmd.opcode) {

case command::eq: i->emit( 0x94 ); break ;

case command::ne: i->emit( 0x95 ); break ;

// ...

}

i->emit( 0xc0 |(i->cmd.dest- 1 ));

i->emit( 0x0f , 0xb6 , 0xc0 |(i->cmd.dest- 1 )<< 3 |(i->cmd.dest- 1 ));

break ;

default :

yyerror( "unknown opcode" );

}

}

// --

int offset = code.size();

std::vector< int > offsets(strings.size()+ 1 );

foreach(i, strings) {

offsets[i->second] = offset;

offset += i->first.length();

offset++;

}

// :

foreach(i, pcode) if (i->needfixat)

if (i->cmd.opcode==command::jz)

i->fix4(i->tgt->offset-(i->offset+i->length));

else if (i->cmd.opcode==command::echo)

i->fix4(offsets[i->cmd.imm]);



write( 1 , &*code.begin(), code.size()); //

foreach(i, strings) //

write( 1 , i->first.c_str(), i->first.length()+ 1 );



क्या हुआ था?

हम संकलक को संकलित करते हैं, इसके साथ एक परीक्षण कार्यक्रम संकलित करते हैं, लोडर संकलित करते हैं, और चलाते हैं:



[tyomitch@home ~]$ bison jsk.y

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

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

[tyomitch@home ~]$ cc jskld.c -o jskld

[tyomitch@home ~]$ ./jskld code

0 1000,

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

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

! !







मुझे आश्चर्य है कि हमारे कार्यक्रम में क्या संकलित है?

 00:55 आरबीपी पुश करें
 01: 48 8b एफई मूव आरबीपी, आरडीआई
 04:39 rbx पुश करें
 05:33 c0 xor eax, eax
 07: b9 e8 03 00 00 mov ecx, 0x3e8
 0c: 50 पुश रक्स
 0d: 51 पुश आरसीएक्स
 0e: bf 80 01 00 00 mov edi, 0x180
 13: ff 55 10 कॉल qword ptr [rbp + 0x10]
 16: 59 पॉप आरसीएक्स
 17: 58 पॉप रैक्स
 18: 50 पुश रक्स
 19: 51 पुश आरसीएक्स
 1a: bf 00 00 00 00 mov edi, 0x0
 1f: ff 55 08 कॉल क्यूटर ptr [rbp + 0x8]
 22: 59 पॉप आरसीएक्स
 23: 58 पॉप रैक्स
 24: 50 पुश रक्स
 25: 51 पुश आरसीएक्स
 26: bf fa 00 00 00 mov edi, 0xfa
 2 बी: ff 55 10 कॉल qword ptr [rbp + 0x10]
 2 ई: 59 पॉप आरसीएक्स
 2f: 58 पॉप रैक्स
 30: 50 पुश रक्स
 31: 51 पुश आरसीएक्स
 32: bf e8 03 00 00 mov edi, 0x3e8
 37: ff 55 08 कॉल qword ptr [rbp + 0x8]
 3 ए: 59 पॉप आरसीएक्स
 3 बी: 58 पॉप रक्स
 3 सी: 50 पुश रक्स
 3 डी: 51 पुश आरसीएक्स
 3e: bf 01 01 00 00 mov edi, 0x101
 43: ff 55 10 कॉल qword ptr [rbp + 0x10]
 46: 59 पॉप आरसीएक्स
 47: 58 पॉप रैक्स
 48: 3 बी सी 1 सीएमपी ईएक्सएक्स, ईएक्सएक्स
 4 ए: 0 एफ 9 ई सी 2 सेटल डीएल
 4d: 0f b6 d2 movzx edx, dl
 50: 0 बी डी 2 या एडएक्स, एडएक्स
 52: 0f 84 97 00 00 00 0 जेईएफ
 ५ lea: c डी १४ ०१ लेटेक्स, [आरसीएक्स + रक्स * १]
 5 बी: डी 1 एफए सर एडक्स, 1
 5d: 50 पुश रक्स
 5e: 51 पुश आरसीएक्स
 5 एफ: 52 पुश आरडीएक्स
 60: bf bc 01 00 00 mov edi, 0x1bc
 65: ff 55 10 कॉल qword ptr [rbp + 0x10]
 68: 5 ए पॉप आरडीएक्स
 69: 59 पॉप आरसीएक्स
 6a: 58 पॉप रैक्स
 6 बी: 50 पुश रक्स
 6 सी: 51 पुश आरसीएक्स
 6d: 52 पुश rdx
 6e: 8b fa mov edi, edx
 70: ff 55 08 कॉल qword ptr [rbp + 0x8]
 73: 5 ए पॉप आरडीएक्स
 74: 59 पॉप आरसीएक्स
 75: 58 पॉप रैक्स
 76: 50 पुश रक्स
 77: 51 पुश आरसीएक्स
 78: 52 पुश आरडीएक्स
 79: bf 26 01 00 00 mov edi, 0x126
 7e: ff 55 10 कॉल qword ptr [rbp + 0x10]
 81: 5 ए पॉप आरडीएक्स
 82: 59 पॉप आरसीएक्स
 83: 58 पॉप रैक्स
 84: 50 पुश रक्स
 85: 51 पुश आरसीएक्स
 86: 52 पुश आरडीएक्स
 87: ff 55 00 कॉल qword ptr [rbp + 0x0]
 8a: 93 xchg ईबेक्स, ईएक्सएक्स
 8 बी: 5 ए पॉप आरडीएक्स
 8 सी: 59 पॉप आरसीएक्स
 8d: 58 पॉप रैक्स
 8e: 89 45 18 मूव डॉर्ड ptr [rbp + 0x18], ईएक्सएक्स
 91: 83 एफबी 01 सीएमपी ईबेक्स, 0x1
 94: 0f 94 c0 सेटी अल
 97: 0f b6 c0 movzx eax, अल
 9 ए: 0 बी सी 0 या ईईएक्स, ईएक्सएक्स
 9 सी: 0 एफ 84 08 00 00 00 जेई 0xaa
 a2: 8b 45 18 mov eax, dword ptr [rbp + 0x18]
 a5: 8d 4a ff lea ecx, [rdx-0x1]
 ए 8: ईब 9 ई जेएमपी 0x48
 आ: aa३ एफबी ०२ सीएमपी ईबेक्स, ० एक्स २
 विज्ञापन: 0f 94 c0 sete al
 b0: 0f b6 c0 movzx eax, al
 b3: 0b c0 या eax, eax
 बी 5: 0f 84 04 00 00 00 जेई 0xbf
 बी बी: ​​०३ सी २ ईएक्स, एडक्स जोड़ें
 बीडी: ईबे 89 जेएमपी 0x48
 bf: 8b 45 18 mov eax, dword ptr [rbp + 0x18]
 c2: 83 fb 03 सीएमपी ईबेक्स, 0x3
 c5: 0f 94 c2 sete dl
 c8: 0f b6 d2 movzx edx, dl
 cb: 0b d2 या edx, edx
 cd: 0f 84 0b 00 00 00 je 0xde
 d3: bf a0 01 00 00 mov edi, 0x1a0
 d8: ff 55 10 कॉल qword ptr [rbp + 0x10]
 db: 5b पॉप आरबीएक्स
 डीसी: 5 डी पॉप आरबीपी
 dd: c3 रिट
 डे: 50 पुश रक्स
 df: 51 पुश आरसीएक्स
 e0: bf c4 01 00 00 mov edi, 0x1c4
 e5: ff 55 10 कॉल qword ptr [rbp + 0x10]
 e8: 59 पॉप आरसीएक्स
 e9: 58 पॉप रक्स
 ea: e9 59 ff ff ff jmp 0x48
 ef: bf 59 01 00 00 mov edi, 0x159
 f4: ff 55 10 कॉल qword ptr [rbp + 0x10]
 f7: 5b पॉप आरबीएक्स
 f8: 5d पॉप आरबीपी
 f9: c3 रिट

नग्न आंखों से आप कम से कम दो प्रासंगिक अनुकूलन देख सकते हैं जिनके लिए एक से अधिक टीम के लिए "आंख" की आवश्यकता होती है:

• जब कोई आदेश POP reg
  
  
  
  में समाप्त होता है और PUSH reg
  
  
  
  में अगला शुरू होता है, तो इन दोनों निर्देशों को हटाया जा सकता है;
• संयोजन SETcc regl / MOVZX reg, regl / OR reg, reg / JZ offset
  
  
  
  को JZ
  
  
  
  आउटपुट में जीवित नहीं होने पर एकल JNcc offset
  
  
  
  स्टेटमेंट से बदला जा सकता है।

यह "बड़ी peephole अनुकूलन" है जो हम अगली बार करेंगे। शेष महत्वपूर्ण कार्य एक वास्तविक ईएलएफ उत्पन्न करना है, ताकि आपको एक मेकशिफ्ट बूटलोडर की आवश्यकता न हो।