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

आपको सी के ज्ञान के साथ-साथ कोडांतरक के ज्ञान की आवश्यकता होगी। यदि आप विधानसभा भाषा नहीं जानते हैं, तो एक एमुलेटर लिखना इसे सीखने का सबसे अच्छा तरीका है। आपको हेक्साडेसिमल गणित (इसे बेस 16 या सिर्फ "हेक्स" के रूप में भी जाना जाता है) में मास्टर करने की आवश्यकता होगी। मैं इस विषय पर बात करूंगा।

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

ट्यूटोरियल का पूरा स्रोत कोड github पर अपलोड किया गया है। यदि आपको गिट के साथ काम करने में महारत हासिल नहीं है, तो जीथब पृष्ठ पर "डाउनलोड ज़िप" बटन है जो आपको सभी कोड के साथ संग्रह डाउनलोड करने की अनुमति देता है।

बाइनरी और हेक्साडेसिमल संख्याओं का परिचय

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

आपने जाना या सुना होगा कि कंप्यूटर बाइनरी डेटा के साथ काम करते हैं। कंप्यूटर गीक्स बेस -10 दशमलव गणित और बाइनरी कॉल बेस -2 कहते हैं। बाइनरी नोटेशन में, संख्या के प्रत्येक अंक में केवल दो मान हो सकते हैं, शून्य या एक। बाइनरी कोड में, गणना निम्नानुसार है: 0, 1, 10, 11, 100, 101, 110, 111, 1000। ये दशमलव संख्या नहीं हैं, इसलिए आप उन्हें "शून्य, एक, दस, ग्यारह, एक सौ, एक सौ एक" नहीं कह सकते। उन्हें "शून्य, एक, एक-शून्य, एक-एक, एक-शून्य-शून्य", आदि के रूप में उच्चारित किया जाता है। मैं शायद ही कभी द्विआधारी संख्या को ज़ोर से पढ़ता हूं, लेकिन यदि आवश्यक हो, तो आपको स्पष्ट रूप से उपयोग की गई संख्या प्रणाली को इंगित करने की आवश्यकता है। बाइनरी नोटेशन में दस, ग्यारह और एक सौ का कोई अर्थ नहीं है।

दशमलव संकेतन में, एक संख्या में निम्नलिखित अंक होते हैं: इकाइयां, दसियों, सैकड़ों, हजारों, हजारों के दसियों, आदि। बाइनरी सिस्टम में, निम्नलिखित अंक: इकाइयां, ड्यूज, फोर, आठ, आदि। कंप्यूटर विज्ञान में, प्रत्येक बाइनरी बिट के मूल्य को थोड़ा कहा जाता है। 8 बिट्स एक बाइट बनाते हैं।

बाइनरी शब्दों में, संख्याओं की एक स्ट्रिंग बहुत जल्दी लंबी हो जाती है। द्विआधारी शब्दों में दशमलव संख्या 20,000 का प्रतिनिधित्व करने के लिए, 16 अंकों की आवश्यकता होती है: 0b100111000100000। इस समस्या को ठीक करने के लिए, हेक्साडेसिमल संख्या प्रणाली का उपयोग करना सुविधाजनक है, जिसे बेस -16 (या हेक्स) के रूप में भी जाना जाता है। बेस -16 में, प्रत्येक अंक में 16 मान होते हैं। शून्य से नौ तक के मानों के लिए, आधार -10 के रूप में समान वर्णों का उपयोग किया जाता है, लेकिन शेष 6 मूल्यों के लिए, ए से एफ तक वर्णमाला के पहले 6 अक्षरों के रूप में प्रतिस्थापन का उपयोग किया जाता है।

हेक्साडेसिमल प्रणाली में खाता निम्नानुसार किया जाता है: 0 1 2 3 4 5 6 7 7 9 ABCDEF 10 12, आदि। हेक्साडेसिमल में, दसियों, सैकड़ों और इतने पर दशमलव के समान अर्थ नहीं है, इसलिए लोग अलग से संख्या का उच्चारण करते हैं। उदाहरण के लिए, $ A57 को "A-पाँच-सात" कहा जाता है। स्पष्टता के लिए, आप हेक्स को भी जोड़ सकते हैं, उदाहरण के लिए, "ए-फाइव-सेवन-हेक्स।" हेक्साडेसिमल संख्या प्रणाली में, दशमलव संख्या 20,000 के बराबर $ 4E20 है - बाइनरी सिस्टम के 16 बिट्स की तुलना में बहुत अधिक कॉम्पैक्ट रूप।

मुझे लगता है कि हेक्साडेसिमल प्रणाली को बाइनरी से हेक्साडेसिमल और इसके विपरीत में एक बहुत ही प्राकृतिक रूपांतरण के कारण चुना गया था। प्रत्येक हेक्स अंक एक समान द्विआधारी संख्या के 4 बिट्स (4 बिट्स) से मेल खाता है। 2 हेक्स अंक एक बाइट (8 बिट) बनाते हैं। एक एकल हेक्साडेसिमल अंक को कुतरना कहा जा सकता है, और कुछ लोग इसे y के माध्यम से "nybble" भी लिखते हैं।

प्रत्येक हेक्स अंक 4 बाइनरी अंक है
हेक्स	एक	5	7
बाइनरी	1010	0101	0111

सी कोड लिखते समय, यह माना जाता है कि संख्या दशमलव (बेस -10) है, जब तक कि इसे अन्यथा चिह्नित नहीं किया जाता है। सी संकलक को यह बताने के लिए कि संख्या द्विआधारी है, हम संख्या शून्य और अक्षर b को लोअरकेस में 0b1101101 , इस प्रकार: 0b1101101 । हेक्साडेसिमल संख्या को निचले मामले में शून्य और x की शुरुआत में जोड़कर C कोड में लिखा जा सकता है: 0xA57 । कुछ विधानसभा भाषाओं में हेक्स संख्या को इंगित करने के लिए $A57 साइन: $A57 का उपयोग किया जाता है।

यदि आप इसके बारे में सोचते हैं, तो बाइनरी, हेक्साडेसिमल और दशमलव संख्याओं के बीच संबंध काफी स्पष्ट है, लेकिन पहले इंजीनियर के लिए, जिन्होंने कंप्यूटर के आविष्कार से पहले इस बारे में सोचा था, यह अंतर्दृष्टि का क्षण बन जाना चाहिए था।

समझ गए ये सब? बहुत बढ़िया।

प्रोसेसर का संक्षिप्त परिचय

यदि आप यह पहले से ही जानते हैं, तो आप अनुभाग को सुरक्षित रूप से छोड़ सकते हैं।

केंद्रीय प्रसंस्करण इकाई (सीपीयू) एक मशीन है जिसे कार्यक्रमों को चलाने के लिए डिज़ाइन किया गया है। सीपीयू के मूलभूत ब्लॉक रजिस्टर और निर्देश हैं। एक सॉफ्टवेयर डेवलपर के रूप में, आप इन रजिस्टरों को चर के रूप में मान सकते हैं। हमारे 8080 प्रोसेसर में, अन्य रजिस्टरों में, ए, बी, सी, डी, और ई नामक 8-बिट रजिस्टर हैं। इन रजिस्टरों की व्याख्या निम्नलिखित सी कोड के रूप में की जा सकती है:

 unsigned char A, B, C, D, E;

सभी प्रोसेसरों में एक प्रोग्राम काउंटर (प्रोग्राम काउंटर, पीसी) भी होता है। आप इसे एक पॉइंटर के रूप में ले सकते हैं।

 unsigned char* pc;

सीपीयू के लिए, एक प्रोग्राम हेक्साडेसिमल संख्याओं का एक क्रम है। 8080 में प्रत्येक विधानसभा भाषा निर्देश कार्यक्रम में 1-3 बाइट्स से मेल खाती है। यह पता लगाने के लिए कि कौन सी कमांड किस नंबर से मेल खाती है, प्रोसेसर मैनुअल (या इंटरनेट से 8080 प्रोसेसर के बारे में कोई अन्य जानकारी) उपयोगी है।

आदेशों (निर्देशों) के नाम अक्सर इन आदेशों के द्वारा किए गए कार्यों से होते हैं। 8080 में लोड करने के लिए एमएनओनिक एमओवी (चाल) है, और एडीडी का उपयोग इसके अतिरिक्त करने के लिए किया जाता है।

उदाहरण

अनुदेश काउंटर द्वारा इंगित वर्तमान स्मृति मान 0x79 है। यह 8080 प्रोसेसर के एमओवी निर्देश MOV A,C साथ अनुपालन करता है। सी कोड में यह विधानसभा कोड A=C; जैसा दिखता A=C; ।

यदि इसके बजाय पीसी में मान 0x80 होगा, तो प्रोसेसर ADD B को निष्पादित करेगा ADD B सी में, यह स्ट्रिंग A = A + B; मेल खाती है A = A + B; ।

8080 प्रोसेसर निर्देशों की एक पूरी सूची यहां पाई जा सकती है । हमारे एमुलेटर को लागू करने के लिए, हम इस जानकारी का उपयोग करेंगे।

समय

सीपीयू में, प्रत्येक निर्देश के निष्पादन के लिए एक निश्चित समय (समय) की आवश्यकता होती है, जिसे चक्रों में मापा जाता है। आधुनिक प्रोसेसर में, यह जानकारी प्राप्त करना मुश्किल हो सकता है, क्योंकि समय कई अलग-अलग पहलुओं पर निर्भर करता है। लेकिन 8080 जैसे पुराने प्रोसेसर में, समय स्थिर है और यह जानकारी अक्सर प्रोसेसर निर्माता द्वारा प्रदान की जाती है। उदाहरण के लिए, MOV रजिस्टर करने के लिए रजिस्टर से स्थानांतरण निर्देश 1 चक्र लेता है।

प्रोसेसर में कुशल कोड लिखने के लिए समय की जानकारी उपयोगी है। एक प्रोग्रामर उन निर्देशों से बचने की कोशिश कर सकता है जिन्हें पूरा करने के लिए कई चक्र लगते हैं।

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

तार्किक संचालन

बाइनरी और हेक्साडेसिमल संख्याओं के विषय को बंद करने से पहले, हमें तार्किक संचालन के बारे में बात करनी चाहिए। आप शायद पहले से ही अपने कोड में तर्क का उपयोग करने के लिए उपयोग किए जाते हैं, उदाहरण के लिए, इस तरह के निर्माणों में if ((conditionA) and (conditionB)) जैसे if ((conditionA) and (conditionB)) । सीधे हार्डवेयर के साथ काम करने वाले कार्यक्रमों में, आपको अक्सर संख्याओं के व्यक्तिगत बिट्स में हेरफेर करना पड़ता है।

और ऑपरेशन

यहां दो एकल-बिट संख्याओं के बीच AND (ऑपरेशन) (AND) (सत्य तालिका) के सभी संभावित परिणाम दिए गए हैं।

एक्स	y	परिणाम
0	0	0
0	1	0
1	0	0
1	1	1

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

	बाइनरी								हेक्स
स्रोत x	0	1	1	0	1	0	1	1	$ 6 बी
स्रोत y	1	1	0	1	0	0	1	0	$ डी 2
x और y	0	1	0	0	0	0	1	0	$ 42

सी में, तार्किक और ऑपरेशन एक सरल एम्परसेंड है "और"।

ऑपरेशन OR (OR)

OR ऑपरेशन इसी तरह से काम करता है। अंतर केवल इतना है कि परिणाम एक के बराबर होगा यदि एक्स या वाई के मूल्यों में से कम से कम एक बराबर है।

एक्स	y	परिणाम
0	0	0
0	1	1
1	0	1
1	1	1

	बाइनरी								हेक्स
स्रोत x	0	1	1	0	1	0	1	1	$ 6 बी
स्रोत y	1	1	0	1	0	0	1	0	$ डी 2
एक्स या वाई	1	1	1	1	1	0	1	1	$ एफबी

सी में, एक तार्किक या ऑपरेशन एक ऊर्ध्वाधर बार द्वारा इंगित किया गया है "" |

यह महत्वपूर्ण क्यों है?

कई पुराने प्रोसेसर में, और विशेष रूप से आर्केड मशीनों में, खेल को अक्सर संख्या के केवल एक बिट के साथ काम करने की आवश्यकता होती है। अक्सर एक समान कोड होता है:

  /*  1:     */ char *buttons_ptr = (char *)0x2043; char buttons = *buttons_ptr; if (buttons & 0x4) HandleLeftButton(); /*  2:  LED-    */ char * LED_pointer = (char *) 0x2089; char led = *LED_pointer; led = led | 0x40; //,  LED   6 *LED_pointer = led; /*  3:   LED- */ char * LED_pointer = (char *) 0x2089; char led = *LED_pointer; led = led & 0xBF; //  6 *LED_pointer = led;

उदाहरण 1 में, मेमोरी में आवंटित $ 2043 का पता कंट्रोल पैनल के बटनों का पता है। यह कोड दबाए गए बटन को पढ़ता है और प्रतिक्रिया करता है। (बेशक, अंतरिक्ष आक्रमणकारियों में यह कोड असेंबली भाषा में होगा!)

उदाहरण 2 में, खेल एक एलईडी संकेतक को प्रकाश में लाना चाहता है, जो कि स्मृति में आवंटित $ 2089 पते के बिट 6 में स्थित है। कोड को मौजूदा मान पढ़ना चाहिए, केवल एक बिट बदलना चाहिए, और इसे वापस लिखना चाहिए।

उदाहरण 3 में, आपको उदाहरण 2 से संकेतक को बंद करने की आवश्यकता है, इसलिए कोड को पता 2089 के बिट 6 को रीसेट करना चाहिए। यह संकेतक नियंत्रण बाइट के लिए AND ऑपरेशन करके एक मान के साथ किया जा सकता है जिसके लिए केवल बिट 6 शून्य है। इसलिए हम केवल 6 को प्रभावित करेंगे, शेष बिटों को अपरिवर्तित छोड़ देंगे।

इसे आमतौर पर "मास्क" कहा जाता है। सी में, एक मुखौटा आमतौर पर NOT ऑपरेटर का उपयोग करते हुए लिखा जाता है, जिसे एक टिल्ड ("~") द्वारा दर्शाया जाता है। इसलिए, 0xBF लिखने के बजाय, मैं सिर्फ ~0x40 और एक ही नंबर प्राप्त करता ~0x40 , लेकिन बहुत प्रयास किए बिना।

विधानसभा भाषा का परिचय

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

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

कोडांतरक भाषा के बारे में आपको जो सबसे महत्वपूर्ण बात जानना है, वह यह है कि प्रत्येक पंक्ति एक प्रोसेसर कमांड में अनुवादित है।

सी भाषा से ऐसे निर्माण पर विचार करें:

 int a = b + 100;

असेंबली भाषा में, इस कार्य को निम्न क्रम में करना होगा:

चर बी के पते को रजिस्टर 1 में लोड करें
इस मेमोरी एड्रेस की सामग्री को रजिस्टर 2 में लोड करें
2 रजिस्टर करने के लिए प्रत्यक्ष मूल्य 0x64 जोड़ें
चर A के पते को रजिस्टर 1 में लोड करें
रजिस्टर 1 में संग्रहीत पते पर रजिस्टर 2 की सामग्री लिखें

कोड में, यह कुछ इस तरह दिखेगा:

  lea a1, #$1000 ;   a lea a2, #$1008 ;   b move.l d0,(a2) add.l d0, #$64 mov (a1),d0

यह निम्नलिखित ध्यान देने योग्य है:

उच्च-स्तरीय भाषा में, संकलक तय करता है कि चर को स्मृति में कहां रखा जाए। कोडांतरक में कोड लिखते समय, आप स्वयं प्रत्येक मेमोरी पते के लिए जिम्मेदार होते हैं जिसका आप उपयोग करेंगे।
अधिकांश विधानसभा भाषाओं में, कोष्ठक का अर्थ है "इस पते पर स्मृति।"
ज्यादातर असेंबलर भाषाओं में, # एक बीजीय संख्या को दर्शाता है, जिसे तत्काल मूल्य भी कहा जाता है। उदाहरण के लिए, ऊपर दिए गए उदाहरण के लाइन 1 में, कोड वास्तव में a1 रजिस्टर करने के लिए # 0x1000 का मान लिखता है। यदि कोड move.l a1, ($1000) जैसा move.l a1, ($1000) , तो a1 पता 0x1000 पर मेमोरी की सामग्री प्राप्त करेगा।
प्रत्येक प्रोसेसर की अपनी विधानसभा भाषा होती है, और एक प्रोसेसर से दूसरे प्रोसेसर में पोर्टिंग कोड मुश्किल हो सकता है।
यह एक वास्तविक प्रोसेसर असेंबली भाषा नहीं है, मैं इसके साथ एक उदाहरण के रूप में आया था।

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

ढेर

आइए विधानसभा भाषा के बारे में थोड़ा और बात करते हैं। किसी भी जटिल कंप्यूटर प्रोग्राम में असेंबलर सबरूटीन का उपयोग किया जाता है। अधिकांश सीपीयू में एक संरचना होती है जिसे स्टैक कहा जाता है।

स्टैक के रूप में एक स्टैक की कल्पना करें। यदि हमें कोई संख्या बचाने की आवश्यकता है, तो हम इसे स्टैक के शीर्ष पर रख देते हैं। जब हमें इसे वापस लाने की आवश्यकता होती है, तो हम इसे ढेर के ऊपर से लेते हैं। असेंबलर प्रोग्रामर स्टैक पर नंबर को पॉपिंग "पुश" कहते हैं और इसे पॉप आउट करने को "पॉप" कहा जाता है।

मान लीजिए कि मेरे कार्यक्रम को एक सबरूटिन को कॉल करने की आवश्यकता है। मैं समान कोड लिख सकता हूं:

  0x1000 move.l (sp), d0 ;  d0   0x1004 add.l sp, #4 ;     0x1008 move.l (sp), d1 ;  d1   0x1010 add.l sp, #4 ;  .. 0x1014 move.l (sp), a0 0x1018 add.l sp, #4 0x101C move.l (sp), a1 0x1020 add.l sp, #4 0x1024 move.l (sp), #0x1030 ;   0x1028 add.l sp, #4 0x102C jmp #0x2040 ;   - 0x2040 0x1030 move.l a1, (sp) ;    0x1034 sub.l sp, #4 ;    0x1038 move.l a0, (sp) ;    0x103c sub.l sp, #4  ..

ऊपर दिखाया गया कोड स्टैक पर मानों को d0, d1, a0 और a1 धकेलता है। अधिकांश प्रोसेसर स्टैक पॉइंटर का उपयोग करते हैं। स्टैक पॉइंटर के रूप में उपयोग किए गए सम्मेलन या कुछ निर्देशों के लिए फ़ंक्शन के साथ एक विशेष रजिस्टर द्वारा यह एक नियमित रजिस्टर हो सकता है।

68K श्रृंखला में प्रोसेसर पर, स्टैक पॉइंटर केवल कन्वेंशन द्वारा निर्धारित किया जाता है, अन्यथा यह एक नियमित रजिस्टर है। हमारे 8080 प्रोसेसर में, एसपी रजिस्टर एक विशेष रजिस्टर है। इसमें PUSH और POP कमांड्स होते हैं जो केवल एक कमांड में स्टैक से लिखते हैं और पॉप करते हैं।

हमारे एमुलेटर प्रोजेक्ट में, हम स्क्रैच से कोड नहीं लिखेंगे। लेकिन अगर आपको विधानसभा भाषा में कार्यक्रमों का विश्लेषण करने की आवश्यकता है, तो ऐसे निर्माणों को पहचानना सीखना अच्छा है।

उच्च स्तरीय भाषाएं

एक उच्च-स्तरीय भाषा में एक कार्यक्रम लिखते समय, प्रत्येक फ़ंक्शन कॉल के साथ रजिस्टर को बचाने और पुनर्स्थापित करने के सभी ऑपरेशन किए जाते हैं। हम उनके बारे में नहीं सोचते हैं, क्योंकि कंपाइलर उनके साथ व्यवहार करता है। उच्च-स्तरीय भाषा में फ़ंक्शन कॉल में बहुत अधिक मेमोरी और प्रोसेसर समय हो सकता है।

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

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

सम्मेलनों को बुलाओ

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

एक और निर्णय की जरूरत है। क्या पंजीयन कॉलिंग फ़ंक्शन या सबरूटीन की जिम्मेदारी को संरक्षित करता है? उपरोक्त उदाहरण में, कॉलिंग फ़ंक्शन द्वारा रजिस्टरों को संग्रहीत किया जाता है। लेकिन क्या होगा अगर हमारे पास 32 रजिस्टर हैं? 32 रजिस्टरों को सहेजना और पुनर्स्थापित करना जब एक रूटीन उपयोग करता है तो उनमें से एक छोटा सा अंश समय की बर्बादी होगी।

व्यापार-बंद मिश्रित दृष्टिकोण हो सकता है। मान लें कि हम एक ऐसी नीति चुनते हैं जिसमें एक रूटीन अपनी सामग्री को सहेजे बिना r10-r32 रजिस्टरों का उपयोग कर सकता है, लेकिन r1-r9 को नष्ट नहीं कर सकता है। एक समान स्थिति में, कॉलिंग फ़ंक्शन निम्न जानता है:

किसी फ़ंक्शन से लौटते समय, r1-r9 की सामग्री अपरिवर्तित रहेगी
मैं r10-r32 की सामग्री पर निर्भर नहीं कर सकता
अगर मुझे एक सबरूटीन कॉल करने के बाद r10-r32 में एक मूल्य की आवश्यकता है, तो इसे कॉल करने से पहले मुझे इसे कहीं और सहेजने की आवश्यकता है

इसी प्रकार, प्रत्येक दिनचर्या निम्नलिखित जानती है:

मैं r10-r32 को नष्ट कर सकता हूं
अगर मैं r1-r9 का उपयोग करना चाहता हूं, तो मुझे उस फ़ंक्शन पर लौटने से पहले सामग्री को सहेजने और इसे पुनर्स्थापित करने की आवश्यकता है, जिसने मुझे बुलाया था

ABI

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

एबीआई को जानने से कोड को डीबग करने में भी मदद मिलती है जब आपके पास स्रोत तक पहुंच नहीं होती है। एबीआई कार्यों के लिए मापदंडों के स्थान को परिभाषित करता है, इसलिए किसी भी उपप्रोग्राम पर विचार करते समय, आप इन पतों की जांच कर सकते हैं कि यह समझने के लिए कि फ़ंक्शन क्या है।

वापस एमुलेटर पर

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

यदि आप यह समझना चाहते हैं कि कार्यक्रम क्या करता है, तो उन पते को चिह्नित करके शुरू करना अच्छा होगा जो कॉल कमांड्स के लिए लक्षित हैं।

एक एमुलेटर आर्केड मशीन बनाना। भाग 1