👨🏿‍🔬 ⛑️ 😯 जेआईटी संकलन के बारे में थोड़ा सा या एक अनुकूलित ब्रेनफैक दुभाषिया लिखना 👩🏻‍🤝‍👨🏿 🤛🏼 🕢

ब्रेनफैक भाषा का सार यह है कि हम हमेशा टेप की कोशिकाओं के माध्यम से चलते हैं, उनमें मूल्यों को कम या बढ़ाते हैं। चक्रों में, हम एक छोर से दूसरे छोर तक दौड़ सकते हैं, कुछ गिन सकते हैं, अक्सर कई नेस्टेड चक्रों का उपयोग कर सकते हैं। यह अनुमान लगाना कठिन नहीं है कि इस भाषा की व्याख्या अपेक्षाकृत धीमी है। बेशक, आधुनिक कंप्यूटरों पर यह व्यावहारिक रूप से ध्यान देने योग्य नहीं है, लेकिन ... मेरा सुझाव है कि एक छोटा सा परीक्षण करें: आपके द्वारा लिखे गए दुभाषिया को लें, और इसे न चलाएं:

>+>+>+>+>++<[>[<+++>- >>>>> >+>+>+>+>++<[>[<+++>- >>>>> >+>+>+>+>++<[>[<+++>- >>>>> >+>+>+>+>++<[>[<+++>- >>>>> +++[->+++++<]>[-]< <<<<< ]<<]>[-] <<<<< ]<<]>[-] <<<<< ]<<]>[-] <<<<< ]<<]>.

निष्पादन की समाप्ति की प्रतीक्षा है? सहमत हूँ कि यह उतना तेज़ नहीं था जितना एक बार में लग सकता है। खैर, देखते हैं कि एक दुभाषिया कैसे बनाया जाता है जो कुछ सेकंड में इस कोड को निष्पादित नहीं करेगा।

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

इसलिए, जैसा कि सभी जानते हैं, ब्रेनफैक भाषा के वाक्य विन्यास में केवल 8 ऑपरेटर होते हैं। वर्तमान सेल में मेमोरी सेल और एक पॉइंटर का एक सेट होता है। वास्तव में, कार्यक्रम के निष्पादन के परिणामस्वरूप, हमें ब्रेनफॉक कोड को x86 प्रोसेसर के कोडांतरक निर्देशों (उनके मशीन कोड) में बदलने की आवश्यकता है। ऐसा करने के लिए, विधानसभा की भाषा के साथ-साथ मशीन कोड (ओपकोड) बनाने के नियमों के बारे में कुछ भी जानना अच्छा है। हम एक या अधिक x86 प्रोसेसर निर्देशों के साथ प्रत्येक ब्रेनफक कमांड को बदल देंगे।

सबसे पहले, आपको मेमोरी कोशिकाओं की एक सरणी बनाने और इसके लिए एक संकेतक प्राप्त करने की आवश्यकता है। यह गतिशील मेमोरी आवंटन फ़ंक्शन का उपयोग करके किया जा सकता है। तो, पास्कल प्रोग्रामिंग भाषा में (और आगे के कोड इस पर होंगे), इसे इस तरह किया जा सकता है:

 Var Stack : Pointer; Begin GetMem(Stack,30000); //    brainfuck - 30000 End;

इसके बाद, आपको ब्रेनफक की कमांड को संभालने के लिए एक रणनीति पर विचार करने की आवश्यकता है। मैंने निम्नलिखित प्रयोग किया:

मान लेते हैं कि ईएसआई रजिस्टर में कोशिकाओं की एक सरणी के लिए एक पॉइंटर संग्रहीत किया जाएगा।

 mov esi, Stack

फिर, बाकी टीमें होंगी:

Brainfuck	कोडांतरक	opcode
+	inc बाइट [esi]	एफई 06
-	डिक बाइट [esi]	एफई 0 ई
>	inc esi	46
<	deci	4E
[	cmp बाइट [esi], 0	80 3 ई 00
	जेई "] +1"	0F 84 xx xx xx xx या 74 xx
]	jmp "["	E9 xx xx xx xx या EB xx

टीमों के लिए। ' और ',', तो आपको एक प्रतीक आउटपुट प्रक्रिया और एक जल प्रतीक समारोह की आवश्यकता होगी। उन्हें इस तरह लागू किया जा सकता है:

 procedure WriteChar(S: Char); begin Write(S); end; function ReadChar: Char; var c : char; begin Read(c ); ReadChar := c; end;

फिर, हम सहमत हो सकते हैं कि निष्पादन योग्य कोड के प्रारंभ में EDX रजिस्टर में वर्ण मुद्रण प्रक्रिया का पता होता है

 mov edx, offset WriteChar

और EBX रजिस्टर चरित्र इनपुट फ़ंक्शन का पता है:

 mov ebx, offset ReadChar

फिर, 'को संभालें।' यह निम्नानुसार संभव है:

 mov al,[esi] 8A 06 ;  AL    cbw 66 98 ;    EAX push eax 50 ;     () call edx FF D2 ;  WriteChar

और कमांड "," इस तरह:

 call ebx FF D3;  ReadChar mov [esi],al 88 06;

सादगी के लिए, हम एक स्थिर ExBuf सरणी बनाएंगे, जहां हम अपने सभी ऑपकोड डालेंगे, और फिर सरणी की शुरुआत में नियंत्रण स्थानांतरित करेंगे। Ptr वैरिएबल दर्ज किए गए अंतिम ओपकोड का सूचक होगा।

 Var ExBuf : Array [1..65535] of Byte; Ptr : Word; Tmp : LongInt;

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

  ptr := 1; ExBuf[ptr] := $BE; inc(ptr); // mov esi,Stack asm mov edx,Stack mov Tmp,edx end; Move(Tmp,ExBuf[ptr],4); inc(ptr,4); ExBuf[ptr] := $BA; inc(ptr); // mov edx,offset WriteChar asm mov edx, offset WriteChar mov Tmp, edx end; Move(Tmp,ExBuf[ptr],4); inc(ptr,4); ExBuf[ptr] := $BB; inc(ptr); // mov ebx,offset ReadChar asm mov edx, offset ReadChar mov Tmp, edx end; Move(Tmp,ExBuf[ptr],4); inc(ptr,4);

सब कुछ, इनिशियलाइज़ेशन किया जाता है। अब आपको एक Brainfuck कोड प्रोसेसिंग रूटीन लिखने की जरूरत है। पहली टीमों के लिए, यह इस तरह हो सकता है:

 Procedure JITCode(S: Char); Begin Case S of '+': Begin ExBuf[ptr] := $FE; //inc byte ptr [esi] ExBuf[ptr+1] := $06; Inc(ptr,2); End; '-': Begin ExBuf[ptr] := $FE; //dec byte ptr [esi] ExBuf[ptr+1] := $0E; Inc(ptr,2); End; '>': Begin ExBuf[ptr] := $46; //inc esi Inc(ptr); End; '<': Begin ExBuf[ptr] := $4E; //dec esi Inc(ptr); End; '.': Begin ExBuf[ptr] := $8A; //mov al,[esi] ExBuf[ptr+1] := $06; Inc(ptr,2); ExBuf[ptr] := $66; //cbw ExBuf[ptr+1] := $98; Inc(ptr,2); ExBuf[ptr] := $50; //push eax Inc(ptr); ExBuf[ptr] := $FF; //call edx ExBuf[ptr+1] := $D2; Inc(ptr,2); End; ',': Begin ExBuf[ptr] := $FF; //call ReadChar ExBuf[ptr+1] := $D3; Inc(ptr,2); ExBuf[ptr] := $88; //mov [esi],al ExBuf[ptr+1] := $06; Inc(ptr,2); End; End;

प्रक्रिया के इनपुट के लिए, हम बारी-बारी से ब्रेनफक कोड पास करते हैं, जो मशीन कोड में परिवर्तित हो जाते हैं और धीरे-धीरे एक्सक्यूफ सरणी में प्रवेश कर जाते हैं।

लूप कमांड '[' और '] के साथ स्थिति कुछ अधिक जटिल है। जैसा कि हम सभी को याद है, x86 प्रोसेसर में कई एड्रेसिंग मोड होते हैं, और तदनुसार, कई पास या शॉर्ट जंप कमांड होते हैं। इसलिए, यदि जंप इंस्ट्रक्शन और लेबल के बीच के ऑपकोड की कुल लंबाई 127 बाइट्स से अधिक नहीं है, तो आप शॉर्ट जंप का उपयोग कर सकते हैं। यदि यह अधिक है, तो निकट संक्रमण (निकट) की टीम पहले से ही आवश्यक होगी। मैंने इसे इस प्रकार लागू किया: जब '[' कमांड का सामना होता है, तो मैं xxx कमांड के पास जेई उत्पन्न करता हूं और कमांड बफर की वर्तमान स्थिति को एक अतिरिक्त एरे में स्टोर करता हूं। बाद में, जब कमांड ']' कोड में आ जाता है, तो मैं लूप की शुरुआत और अंत (बाइट लंबाई) के बीच के अंतर की गणना करता हूं, और अगर यह 127 बाइट्स से कम है, तो मैं संग्रहीत स्थिति पर लौटता हूं, xxx के पास पुरानी जीप को जेई शॉर्ट xxx के साथ मिटा देता हूं और बाकी कोड को स्थानांतरित करता हूं चार बाइट्स आगे। इसे ध्यान में रखते हुए, यह ऊपर वर्णित JITCode प्रक्रिया को पूरा करने के लिए बना हुआ है:

  '[': Begin ExBuf[ptr] := $80; //cmp byte ptr [esi],0 ExBuf[ptr+1] := $3E; ExBuf[ptr+2] := $00; Inc(ptr,3); ExBuf[ptr] := $0F; //je near xxx ExBuf[ptr+1] := $84; Inc(ptr,2); bstack[bcnt] := ptr; inc(bcnt); Inc(ptr,4); End; ']': Begin Tmp := ptr - bstack[bcnt-1]; If Tmp > 122 then begin ExBuf[ptr] := $E9; //jmp Inc(ptr); Inc(Tmp); Move(Tmp,ExBuf[bstack[bcnt-1]],4); Tmp := -Tmp-9; Move(Tmp,ExBuf[ptr],4); Inc(ptr,4); Dec(bcnt); end else begin ExBuf[ptr] := $EB; //jmp short Inc(ptr); ExBuf[bstack[bcnt-1]-2] := $74; // je short xxx Dec(Tmp,2); Move(Tmp,ExBuf[bstack[bcnt-1]-1],1); Tmp := -Tmp-5; Move(Tmp,ExBuf[ptr],1); Inc(ptr); Move(ExBuf[bstack[bcnt-1]+4],ExBuf[bstack[bcnt-1]],ptr-bstack[bcnt-1]-4); Dec(ptr,4); Dec(bcnt); end; End;

यह व्यावहारिक रूप से सभी है, यह एक तैयार कार्य कार्यान्वयन है। बहुत कुछ बचा नहीं है - अंतिम रिट कमांड (प्रक्रिया से वापसी) के साथ लिखने के लिए। उसका ओपकोड 0xC3 है:

  ExBuf[ptr] := $C3; //retn

और मशीन निर्देशों के जनरेट किए गए बफर में नियंत्रण स्थानांतरित करें:

  asm mov edx,offset ExBuf call edx end;

लेकिन आइए देखें कि हमारे कार्यक्रम के अनुकूलन के साथ और क्या किया जा सकता है। एक विचार जो शाब्दिक रूप से सतह पर है: ब्रेनफक कोड में, एक ही प्रकार के दोहराया कमांड अक्सर पाए जाते हैं, उदाहरण के लिए ++++++++++++++ या <<<<। वर्तमान सेल को 11 से बढ़ाने या सेल पॉइंटर 4 को बाईं ओर ले जाने का क्या मतलब है। आप अतिरिक्त वर्ण दर्ज कर सकते हैं जो निम्नलिखित संकेत करेंगे:

<<<<< = द्वारा प्रतिस्थापित p # (prev) पॉइंटर को बाईं ओर # मानों द्वारा तुरंत स्थानांतरित करें

>>>>> = द्वारा प्रतिस्थापित n # (अगला) # मानों से सूचक को तुरंत घुमाते हुए

+++++ = द्वारा प्रतिस्थापित i # (inc) वर्तमान सेल को तुरंत बढ़ाकर #

- # d (dec) द्वारा प्रतिस्थापित वर्तमान सेल को तुरंत # से घटाया जाता है

[-], [+] = z (शून्य) द्वारा प्रतिस्थापित सेल मान को 0 पर सेट किया गया

इस तरह की प्रीप्रोसेसिंग दुभाषिया की शुरुआत में की जा सकती है। कभी-कभी, यह ब्रेनफक के लिए स्रोत कोड में एक महत्वपूर्ण कमी देता है, और परिणामस्वरूप, x86 कोड में कमी। इस प्रक्रिया के बाद, यह हमारी JITCode प्रक्रिया को पूरा करने के लिए बनी हुई है:

  'i': Begin ExBuf[ptr] := $80; //add byte ptr [esi],xx ExBuf[ptr+1] := $06; ExBuf[ptr+2] := Ord(Buf[i+1]); Inc(i); Inc(ptr,3); End; 'd': Begin ExBuf[ptr] := $80; //sub byte ptr [esi],xx ExBuf[ptr+1] := $2E; ExBuf[ptr+2] := Ord(Buf[i+1]); Inc(i); Inc(ptr,3); End; 'n': Begin ExBuf[ptr] := $83; //add esi,xx ExBuf[ptr+1] := $C6; ExBuf[ptr+2] := Ord(Buf[i+1]); Inc(i); Inc(ptr,3); End; 'p': Begin ExBuf[ptr] := $83; //sub esi,xx ExBuf[ptr+1] := $EE; ExBuf[ptr+2] := Ord(Buf[i+1]); Inc(i); Inc(ptr,3); End; 'z': Begin ExBuf[ptr] := $C6; //mov byte ptr [esi],0 ExBuf[ptr+1] := $06; ExBuf[ptr+2] := $00; Inc(ptr,3); End;

आप स्रोत कोड और संकलित Win32 संस्करण यहां डाउनलोड कर सकते हैं: rghost.ru/4249797

कार्यक्रम में चाबियाँ हैं:

-c - डिस्क पर एक OUT.BC फ़ाइल बनाएं जिसमें प्रीप्रोसेसर के बाद एक इंटरमीडिएट बाईटेकोड हो।

-b - मशीन कोड के उत्पन्न सरणी वाले डिस्क पर BF.BIN फ़ाइल बनाएँ। यदि आप इसे HIEW में खोलते हैं, तो आप सामान्य कोडांतरक कमांड देख सकते हैं।

सभी को शुभकामनाएँ।

जेआईटी संकलन के बारे में थोड़ा सा या एक अनुकूलित ब्रेनफैक दुभाषिया लिखना

More articles: