पहला भाग यहाँ है ।

8080 प्रोसेसर disassembler

परिचित

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

प्रत्येक प्रोसेसर में एक निर्माता-लिखित संदर्भ गाइड होता है। आमतौर पर इसे "प्रोग्रामर एनवायरनमेंट मैनुअल" जैसा कुछ कहा जाता है। 8080 मैनुअल को इंटेल 8080 माइक्रो कंप्यूटर सिस्टम यूजर मैनुअल कहा जाता है। इसे हमेशा "डेटा बुक" कहा जाता है, इसलिए मैं इसे भी कहूंगा। मैं http://www.datasheetarchive.com/ से 8080 संदर्भ डाउनलोड करने में सक्षम था। यह पीडीएफ कम गुणवत्ता वाला स्कैन है, इसलिए यदि आप एक बेहतर संस्करण पाते हैं, तो इसका उपयोग करें।

चलो शुरू करते हैं और अंतरिक्ष आक्रमणकारियों ROM पर एक नज़र डालते हैं। (इंटरनेट पर ROM फ़ाइल पाई जा सकती है।) मैं मैक ओएस एक्स पर काम करता हूं, इसलिए मैं सिर्फ अपनी सामग्री को देखने के लिए हेक्सडंप कमांड का उपयोग करता हूं। आगे के काम के लिए, अपने प्लेटफॉर्म के लिए हेक्स एडिटर ढूंढें। यहाँ आक्रमणकारियों की पहली 128 बाइट्स हैं। फ़ाइल:

$ hexdump -v invaders.h 0000000 00 00 00 c3 d4 18 00 00 f5 c5 d5 e5 c3 8c 00 00 0000010 f5 c5 d5 e5 3e 80 32 72 20 21 c0 20 35 cd cd 17 0000020 db 01 0f da 67 00 3a ea 20 a7 ca 42 00 3a eb 20 0000030 fe 99 ca 3e 00 c6 01 27 32 eb 20 cd 47 19 af 32 0000040 ea 20 3a e9 20 a7 ca 82 00 3a ef 20 a7 c2 6f 00 0000050 3a eb 20 a7 c2 5d 00 cd bf 0a c3 82 00 3a 93 20 0000060 a7 c2 82 00 c3 65 07 3e 01 32 ea 20 c3 3f 00 cd 0000070 40 17 3a 32 20 32 80 20 cd 00 01 cd 48 02 cd 13 ...

यह अंतरिक्ष आक्रमणकारियों के कार्यक्रम की शुरुआत है। प्रत्येक हेक्साडेसिमल संख्या कार्यक्रम के लिए एक कमांड या डेटा है। इन हेक्स कोड का क्या अर्थ है यह समझने के लिए हम एक संदर्भ या अन्य संदर्भ जानकारी का उपयोग कर सकते हैं। आइए ROM इमेज कोड को थोड़ा और एक्सप्लोर करें।

इस कार्यक्रम का पहला बाइट $ 00 है। तालिका को देखते हुए, हम देखते हैं कि यह एनओपी है, साथ ही साथ निम्नलिखित दो कमांड भी हैं। (लेकिन निराश मत हो, अंतरिक्ष आक्रमणकारियों ने संभवतः इन कमांड का उपयोग सिस्टम को पावर-अप के बाद थोड़ा शांत करने के लिए देरी के रूप में किया था।)

चौथा आदेश $ C3 है, अर्थात्, तालिका द्वारा न्याय करना, यह JMP है। JMP कमांड की परिभाषा में कहा गया है कि इसे दो-बाइट का पता मिलता है, यानी अगले दो बाइट्स JMP हॉप एड्रेस हैं। फिर दो और NOP आए ... तो, आप जानते हैं क्या? मुझे केवल पहले कुछ निर्देशों पर हस्ताक्षर करने दें ...

  0000 00 NOP 0001 00 NOP 0002 00 NOP 0003 c3 d4 18 JMP $18d4 0006 00 NOP 0007 00 NOP 0008 f5 PUSH PSW 0009 c5 PUSH B 000a d5 PUSH D 000b e5 PUSH H 000c c3 8c 00 JMP $008c 000f 00 NOP 0010 f5 PUSH PSW 0011 c5 PUSH B 0012 d5 PUSH D 0013 e5 PUSH H 0014 3e 80 MVI A,#0x80 0016 32 72 20 STA $2072

इस प्रक्रिया को स्वचालित करने का कोई तरीका प्रतीत होता है ...

Disassembler, भाग १

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

यहाँ 8080 कोड disassembly एल्गोरिथम है:

कोड को बफ़र में पढ़ें
हमें बफ़र की शुरुआत में एक पॉइंटर मिलता है
ओपोड निर्धारित करने के लिए पॉइंटर में बाइट का उपयोग करें।
यदि डेटा के रूप में opcode के बाद बाइट्स का उपयोग करना आवश्यक हो, तो opcode का नाम प्रदर्शित करें
पॉइंटर को इस कमांड द्वारा प्रयुक्त बाइट्स की संख्या में ले जाएँ (1, 2 या 3 बाइट्स)
यदि बफर समाप्त नहीं होता है, तो चरण 3 पर जाएं

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

  /* *codebuffer -       8080 pc -          */ int Disassemble8080Op(unsigned char *codebuffer, int pc) { unsigned char *code = &codebuffer[pc]; int opbytes = 1; printf ("%04x ", pc); switch (*code) { case 0x00: printf("NOP"); break; case 0x01: printf("LXI B,#$%02x%02x", code[2], code[1]); opbytes=3; break; case 0x02: printf("STAX B"); break; case 0x03: printf("INX B"); break; case 0x04: printf("INR B"); break; case 0x05: printf("DCR B"); break; case 0x06: printf("MVI B,#$%02x", code[1]); opbytes=2; break; case 0x07: printf("RLC"); break; case 0x08: printf("NOP"); break; /* ........ */ case 0x3e: printf("MVI A,#0x%02x", code[1]); opbytes = 2; break; /* ........ */ case 0xc3: printf("JMP $%02x%02x",code[2],code[1]); opbytes = 3; break; /* ........ */ } printf("\n"); return opbytes; }

इस प्रक्रिया को लिखने और प्रत्येक ओपकोड का अध्ययन करने की प्रक्रिया में, मैंने 8080 प्रोसेसर के बारे में बहुत कुछ सीखा।

मैंने महसूस किया कि अधिकांश टीमें एक बाइट लेती हैं, बाकी दो या तीन। ऊपर दिया गया कोड मानता है कि कमांड आकार में एक बाइट है, लेकिन दो और तीन-बाइट के निर्देश "ओपबाइट्स" चर के मूल्य को बदल देते हैं ताकि कमांड का सही आकार वापस आ जाए।
8080 में ए, बी, सी, डी, ई, एच और एल नामों के साथ रजिस्टर है। इसमें एक प्रोग्राम काउंटर (प्रोग्राम काउंटर, पीसी) और एक अलग स्टैक पॉइंटर (स्टैक पॉइंटर, एसपी) भी है।
कुछ निर्देश जोड़े में रजिस्टरों के साथ काम करते हैं: बी और सी एक जोड़ी हैं, साथ ही डीई और एचएल भी।
ए एक विशेष रजिस्टर है, इसके साथ कई निर्देश काम करते हैं।
एचएल भी एक विशेष रजिस्टर है, इसका उपयोग स्मृति को डेटा के प्रत्येक पढ़ने और लिखने के लिए एक पते के रूप में किया जाता है।
मैं "RST" टीम के बारे में उत्सुक हो गया, इसलिए मैंने गाइड को थोड़ा पढ़ा। मैंने देखा कि यह निश्चित स्थानों में कोड को निष्पादित करता है और संदर्भ में व्यवधान का उल्लेख किया गया है। आगे पढ़ने पर, यह पता चला कि ROM की शुरुआत में यह सभी कोड सर्विस सर्विस रूट (ISRs) था। प्रोग्राम को RST कमांड का उपयोग करके प्रोग्रामेटिक रूप से उत्पन्न किया जा सकता है, या तीसरे पक्ष के स्रोतों (8080 प्रोसेसर नहीं) द्वारा उत्पन्न किया जा सकता है।

इस सब को एक कार्यशील कार्यक्रम में बदलने के लिए, मैंने बस एक प्रक्रिया तैयार की है जो निम्नलिखित चरणों को पूरा करती है:

यह संकलित कोड 8080 से भरी फाइल खोलता है
इसे मेमोरी बफर में पढ़ता है
मेमोरी बफर के माध्यम से गुजरता है, जिससे Disassemble8080Op होता है
Disassemble8080Op द्वारा लौटाया गया PC बढ़ता है
बफर के अंत में बाहर निकलता है

यह कुछ इस तरह दिख सकता है:

  int main (int argc, char**argv) { FILE *f= fopen(argv[1], "rb"); if (f==NULL) { printf("error: Couldn't open %s\n", argv[1]); exit(1); } //         fseek(f, 0L, SEEK_END); int fsize = ftell(f); fseek(f, 0L, SEEK_SET); unsigned char *buffer=malloc(fsize); fread(buffer, fsize, 1, f); fclose(f); int pc = 0; while (pc < fsize) { pc += Disassemble8080Op(buffer, pc); } return 0; }

दूसरे भाग में, हम ROM अंतरिक्ष आक्रमणकारियों को अलग करके प्राप्त आउटपुट की जांच करेंगे।

मेमोरी आवंटन

इससे पहले कि हम एक प्रोसेसर एमुलेटर लिखना शुरू करें, हमें एक और पहलू का अध्ययन करने की आवश्यकता है। सभी सीपीयू में निश्चित संख्या में पतों के साथ संवाद करने की क्षमता होती है। पुराने प्रोसेसर में 16-, 24- या 32-बिट पते थे। 8080 में 16 पते के संपर्क हैं, इसलिए पते 0- $ FFFF की सीमा में हैं।

खेल के मेमोरी आवंटन को समझने के लिए, हमें एक छोटी जांच करने की आवश्यकता है। यहाँ और यहाँ जानकारी के टुकड़ों को इकट्ठा करने के बाद, मुझे पता चला कि ROM पते 0 पर स्थित है, और खेल में 8 KB RAM $ 2000 से शुरू होती है।

पृष्ठों में से एक के लेखक ने पाया कि वीडियो बफर रैम में $ 2,400 के पते से शुरू होता है, और हमें यह भी बताया कि 8080 इनपुट-आउटपुट पोर्ट का उपयोग नियंत्रण और ऑडियो उपकरण के साथ संवाद करने के लिए कैसे किया जाता है। बहुत बढ़िया!

आक्रमणकारियों के अंदर। ज़िप रोम, जो इंटरनेट पर पाया जा सकता है, चार फाइलें हैं: आक्रमणकारियों। ई। एफ। एफ, जीजी और। एच। गुग्लिंग के बाद, मुझे एक जानकारीपूर्ण लेख आया जो बताता है कि इन फाइलों को स्मृति में कैसे रखा जाए:

Space Invaders, (C) Taito 1978, Midway 1979

: Intel 8080, 2 ( Zilog Z80)

: $cf (RST 8) vblank, $d7 (RST $10) vblank.

: 256(x)*224(y), 60 , .
.
: 7168 , 1 (32 ).

: SN76477 .

:
ROM
$0000-$07ff: invaders.h
$0800-$0fff: invaders.g
$1000-$17ff: invaders.f
$1800-$1fff: invaders.e

RAM
$2000-$23ff:
$2400-$3fff:

$4000-:

अभी भी कुछ उपयोगी जानकारी है, लेकिन हम अभी तक इसका उपयोग करने के लिए तैयार नहीं हैं।

खूनी विवरण

यदि आप जानना चाहते हैं कि प्रोसेसर के पते का आकार क्या है, तो आप इसकी विशेषताओं को देखकर इसे समझ सकते हैं। विनिर्देश 8080 हमें बताता है कि प्रोसेसर में 16 पता संपर्क हैं, अर्थात, यह 16-बिट पते का उपयोग करता है। (ऐनक के बजाय, यह मैनुअल, विकिपीडिया, गूगल, और इतने पर पढ़ने के लिए पर्याप्त है ...)

इंटरनेट पर अंतरिक्ष आक्रमणकारियों के हार्डवेयर के बारे में काफी जानकारी है। यदि आप इस जानकारी को खोजने में असमर्थ थे, तो आप इसे कुछ तरीकों से प्राप्त कर सकते हैं:

एमुलेटर में चल रहे कोड को देखें और यह पता करें कि यह क्या करता है। नोट्स लें और ध्यान से देखें। यह समझने के लिए पर्याप्त सरल होना चाहिए, उदाहरण के लिए, जहां, खेल की राय में, रैम स्थित होना चाहिए। उस स्थान को निर्धारित करना भी आसान है जहां वह वीडियो मेमोरी की तलाश में है (हम इस अध्ययन में कुछ समय बिताएंगे)।
आर्केड मशीन के सर्किट आरेख का पता लगाएं और सीपीयू के पते के संपर्कों से संकेतों को ट्रैक करें। देखें कि वे कहां जा रहे हैं। उदाहरण के लिए, A15 (सबसे पुराना पता) केवल ROM पर जा सकता है। इससे हम यह निष्कर्ष निकाल सकते हैं कि ROM के पते $ 8000 से शुरू होते हैं।

यह बहुत ही रोचक और जानकारीपूर्ण हो सकता है कि इसे कोड निष्पादन का अवलोकन करके स्वयं पता लगाना है। पहली बार किसी को यह सब करना पड़ा।

कमांड लाइन विकास

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

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

मुझे लगता है कि जो कोई भी निचले स्तर पर प्रोग्राम करना चाहता है, उसे पता होना चाहिए कि कमांड लाइन से सरल प्रोग्राम कैसे बनाएं। आप विचार कर सकते हैं कि मैं आपको चिढ़ाता हूं, लेकिन यदि आप Visual Studio के बाहर कार्य नहीं कर सकते हैं तो आपके कुलीन हैकर कौशल बहुत अधिक नहीं हैं।

मैक पर, आप संकलन करने के लिए टेक्स्टएडिट और टर्मिनल का उपयोग कर सकते हैं। लिनक्स पर, आप gedit और Konsole का उपयोग कर सकते हैं। विंडोज पर, आप साइबरविन और टूल्स इंस्टॉल कर सकते हैं, और फिर एन ++ या किसी अन्य टेक्स्ट एडिटर का उपयोग कर सकते हैं। यदि आप वास्तव में शांत होना चाहते हैं, तो ये सभी प्लेटफ़ॉर्म vi और टेक्स्ट संपादन के लिए emacs का समर्थन करते हैं।

कमांड लाइन का उपयोग करके एकल फ़ाइल से प्रोग्राम संकलित करना एक तुच्छ कार्य है। मान लीजिए कि आपने अपना प्रोग्राम 8080dis.c नामक फ़ाइल में सहेजा है। इस टेक्स्ट फ़ाइल के साथ फ़ोल्डर में जाएं और इसे इस तरह संकलित करें: cc 8080dis.c । यदि आप आउटपुट फ़ाइल का नाम निर्दिष्ट नहीं करते हैं, तो इसे a.out कहा जाएगा, और आप इसे टाइप करके चला सकते हैं ./a.out ।

वह, वास्तव में, सब है।

डिबगर का उपयोग करना

यदि आप यूनिक्स-आधारित प्रणालियों में से एक पर काम कर रहे हैं, तो यहां GDB का उपयोग करके कमांड-लाइन प्रोग्राम डिबगिंग का एक संक्षिप्त परिचय है। आपको इस तरह के कार्यक्रम को संकलित करने की आवश्यकता है: cc -g -O0 8080dis.c । -g पैरामीटर डिबगिंग जानकारी उत्पन्न करता है (यानी, आप स्रोत पाठ के आधार पर डीबगिंग कर सकते हैं), और -O0 पैरामीटर ऑप्टिमाइज़ेशन को अक्षम करता है ताकि जब आप प्रोग्राम के माध्यम से कदम -O0 , तो डिबगर स्रोत पाठ के साथ पूर्ण अनुसार कोड को सही तरीके से ट्रैक कर सके।

यहां डिबगिंग सत्र की शुरुआत का एनोटेट लॉग है। मेरी टिप्पणी एक पाउंड चिह्न (#) के साथ चिह्नित लाइनों में हैं।

  $ gdb a.out GNU gdb 6.3.50-20050815 (Apple version gdb-1708) (Mon Aug 8 20:32:45 UTC 2011) Copyright 2004 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "x86_64-apple-darwin"...Reading symbols for shared libraries .. done #  ,       (gdb) b Disassemble8080Op Breakpoint 1 at 0x1000012ef: file 8080dis.c, line 7. #   "invaders.h"    (gdb) run invaders.h Starting program: /Users/bob/Desktop/invaders/a.out invaders.h Reading symbols for shared libraries +........................ done Breakpoint 1, Disassemble8080Op (codebuffer=0x100801000 "", pc=0) at 8080dis.c:7 7 unsigned char *code = &codebuffer[pc]; #gdb  n  "next".    "next" (gdb) n 8 int opbytes = 1; #p -    "print",     *code (gdb) p *code $1 = 0 '\0' (gdb) n 9 printf("%04x ", pc); #    "", gdb     ,    "next" (gdb) 10 switch (*code) (gdb) n #   ,    "NOP" 12 case 0x00: printf("NOP"); break; (gdb) n 285 printf("\n"); #c -  "continue",        (gdb) c Continuing. 0000 NOP #     Disassemble8080Op.   *opcode, # ,      NOP,    . Breakpoint 1, Disassemble8080Op (codebuffer=0x100801000 "", pc=1) at 8080dis.c:7 7 unsigned char *code = &codebuffer[pc]; (gdb) c Continuing. 0001 NOP Breakpoint 1, Disassemble8080Op (codebuffer=0x100801000 "", pc=2) at 8080dis.c:7 7 unsigned char *code = &codebuffer[pc]; (gdb) n 8 int opbytes = 1; (gdb) p *code $2 = 0 '\0' #  NOP,   (gdb) c Continuing. 0002 NOP Breakpoint 1, Disassemble8080Op (codebuffer=0x100801000 "", pc=3) at 8080dis.c:7 7 unsigned char *code = &codebuffer[pc]; (gdb) n 8 int opbytes = 1; #   ! (gdb) p *code $3 = 195 '?' # print     ,    /x    (gdb) p /x *code $4 = 0xc3 (gdb) n 9 printf("%04x ", pc); (gdb) 10 switch (*code) (gdb) # C3 -  JMP. . 219 case 0xc3: printf("JMP $%02x%02x",code[2],code[1]); opbytes = 3; break; (gdb) 285 printf("\n");

डिस्सेम्बलर, भाग 2

आक्रमणकारियों के लिए disassembler चलाएँ। ROM फ़ाइल और प्रदर्शित जानकारी को देखें।

  0000 NOP 0001 NOP 0002 NOP 0003 JMP $18d4 0006 NOP 0007 NOP 0008 PUSH PSW 0009 PUSH B 000a PUSH D 000b PUSH H 000c JMP $008c 000f NOP 0010 PUSH PSW 0011 PUSH B 0012 PUSH D 0013 PUSH H 0014 MVI A,#$80 0016 STA $2072 0019 LXI H,#$20c0 001c DCR M 001d CALL $17cd 0020 IN #$01 0022 RRC 0023 JC $0067 0026 LDA $20ea 0029 ANA A 002a JZ $0042 002d LDA $20eb 0030 CPI #$99 0032 JZ $003e 0035 ADI #$01 0037 DAA 0038 STA $20eb 003b CALL $1947 003e SRA A 003f STA $20ea /* 0000000 00 00 00 c3 d4 18 00 00 f5 c5 d5 e5 c3 8c 00 00 0000010 f5 c5 d5 e5 3e 80 32 72 20 21 c0 20 35 cd cd 17 0000020 db 01 0f da 67 00 3a ea 20 a7 ca 42 00 3a eb 20 0000030 fe 99 ca 3e 00 c6 01 27 32 eb 20 cd 47 19 af 32 */

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

मैंने ऊपर उल्लेख किया है कि यह कोड अंतरिक्ष आक्रमणकारियों के खेल के लिए ISR कोड है। इंटरप्ट के लिए कोड 0, 1, 2, ... 7 पता $ 0, $ 8, $ 20, ... $ 38 से शुरू होता है। ऐसा लगता है कि 8080 सिर्फ प्रत्येक ISR के लिए 8 बाइट्स देता है। कभी-कभी अंतरिक्ष आक्रमणकारी कार्यक्रम अधिक स्थान के साथ किसी अन्य पते पर जाने से इस प्रणाली को बायपास करता है। (यह $ 000c पर होता है)।

इसके अलावा, ISR 2 इसके लिए आवंटित मेमोरी से अधिक लंबा लगता है। उसका कोड $ 0018 हो जाता है (यह ISR 3 के लिए जगह है)। मुझे लगता है कि अंतरिक्ष आक्रमणकारियों को कुछ भी देखने की उम्मीद नहीं है जो 3 का उपयोग करता है।

इंटरनेट से अंतरिक्ष आक्रमणकारियों ROM फ़ाइल में चार भाग होते हैं। मैं इसे नीचे बताऊंगा, लेकिन अब, अगले भाग पर जाने के लिए, हमें इन चार फाइलों को एक में मिलाना होगा। यूनिक्स पर:

  cat invaders.h > invaders cat invaders.g >> invaders cat invaders.f >> invaders cat invaders.e >> invaders

अब परिणामी "आक्रमणकारियों" फ़ाइल के साथ disassembler चलाएं। जब कोई कार्यक्रम $ 0000 से शुरू होता है, तो पहली चीज जो $ 18d4 पर स्विच होती है। मैं इस कार्यक्रम की शुरुआत पर विचार करूंगा। आइए इस कोड पर एक नज़र डालें।

  18d4 LXI SP,#$2400 18d7 MVI B,#$00 18d9 CALL $01e6

तो, यह दो ऑपरेशन करता है और $ 01e6 कॉल करता है। मैं इस कोड में बदलाव के साथ कोड का हिस्सा डालने जा रहा हूं:

  01e6 LXI D,#$1b00 01e9 LXI H,#$2000 01ec JMP $1a32 ..... 1a32 LDAX D 1a33 MOV M,A 1a34 INX H 1a35 INX D 1a36 DCR B 1a37 JNZ $1a32 1a3a RET

जैसा कि हमने अंतरिक्ष आक्रमणकारियों स्मृति आवंटन से देखा, इनमें से कुछ पते दिलचस्प हैं। $ 2000 एक "कार्यशील रैम" कार्यक्रम की शुरुआत है। $ 2,400 वीडियो मेमोरी की शुरुआत है।

आइए कोड पर टिप्पणी जोड़ें कि यह स्पष्ट करें कि यह सीधे स्टार्टअप पर क्या करता है:

  18d4 LXI SP,#$2400 ; SP=$2400 -      18d7 MVI B,#$00 ; B=0 18d9 CALL $01e6 ..... 01e6 LXI D,#$1b00 ; DE=$1B00 01e9 LXI H,#$2000 ; HL=$2000 01ec JMP $1a32 ..... 1a32 LDAX D ; A = (DE),   ,       $1B00 1a33 MOV M,A ;  A  (HL),     $2000 1a34 INX H ; HL = HL + 1 ( $2001) 1a35 INX D ; DE = DE + 1 ( $1B01) 1a36 DCR B ; B = B - 1 ( 0xff,      0) 1a37 JNZ $1a32 ; ,   ,     b=0 1a3a RET

ऐसा लगता है कि यह कोड $ 1b00 से $ 2000 तक 256 बाइट्स कॉपी करेगा। क्यों? मुझे नहीं पता आप अधिक विस्तार से कार्यक्रम का अध्ययन कर सकते हैं और यह दर्शाता है कि यह क्या करता है

यहां एक समस्या है। यदि हमारे पास कोड युक्त मेमोरी का एक मनमाना टुकड़ा है, तो डेटा संभवतः इसके साथ वैकल्पिक होगा।

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

जबकि हम इसके बारे में शायद ही कुछ कर सकते हैं। बस ध्यान रखें कि ऐसी समस्या मौजूद है। यदि आप इस तरह से कुछ देखते हैं:

एक टीम के लिए बिल्कुल अच्छे कोड से संक्रमण जो असंतुष्ट सूची में नहीं है
अर्थहीन कोड स्ट्रीम (उदा। POP B POP B POP B POP B POP C XTHL XTHL XTHL)

यहाँ, शायद, वहाँ डेटा है जो कुछ असंतुष्ट कोड को बर्बाद कर दिया है। यदि ऐसा होता है, तो आपको ऑफसेट से फिर से शुरू करने की आवश्यकता है।

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

अंतरिक्ष आक्रमणकारियों कोड का एक विस्तृत विश्लेषण यहां पाया जा सकता है ।

एन्डियन

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

छोटे-एंडियन में: $ DD $ CC $ BB $ AA

बिग-एंडियन: $ AA $ BB $ CC $ DD

मैंने मोटोरोला प्रोसेसर पर प्रोग्रामिंग शुरू कर दी जिसमें बड़े-एंडियन का उपयोग किया गया था, इसलिए यह मुझे अधिक "प्राकृतिक" लग रहा था, लेकिन फिर मुझे छोटे-एंडियन की भी आदत हो गई।

मेरे असंतुष्ट और एमुलेटर पूरी तरह से एंडियन समस्या से बचते हैं क्योंकि वे एक समय में केवल एक बाइट पढ़ते हैं। यदि आप चाहते हैं, उदाहरण के लिए, ROM से पते को पढ़ने के लिए 16-बिट रीडर का उपयोग करना है, तो ध्यान दें कि यह कोड CPU सीपीयू के बीच पोर्टेबल नहीं है।

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