भागों एक और दो ।

8080 प्रोसेसर एमुलेटर

एमुलेटर खोल

8080 प्रोसेसर एमुलेटर बनाने के लिए आपके पास अब सभी आवश्यक ज्ञान होना चाहिए।

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

इसके साथ शुरू करने के लिए, मैं एक मेमोरी संरचना बनाऊंगा जिसमें एक डिस्सेम्बलर लिखते समय मेरे लिए आवश्यक हर चीज के लिए फ़ील्ड होंगे। मेमोरी बफर के लिए भी एक जगह होगी, जो रैम होगी।

typedef struct ConditionCodes { uint8_t z:1; uint8_t s:1; uint8_t p:1; uint8_t cy:1; uint8_t ac:1; uint8_t pad:3; } ConditionCodes; typedef struct State8080 { uint8_t a; uint8_t b; uint8_t c; uint8_t d; uint8_t e; uint8_t h; uint8_t l; uint16_t sp; uint16_t pc; uint8_t *memory; struct ConditionCodes cc; uint8_t int_enable; } State8080;

अब एक त्रुटि कॉल के साथ एक प्रक्रिया बनाएं जो प्रोग्राम को एक त्रुटि के साथ समाप्त करेगा। यह कुछ इस तरह दिखेगा:

  void UnimplementedInstruction(State8080* state) { // pc    ,     printf ("Error: Unimplemented instruction\n"); exit(1); } int Emulate8080Op(State8080* state) { unsigned char *opcode = &state->memory[state->pc]; switch(*opcode) { case 0x00: UnimplementedInstruction(state); break; case 0x01: UnimplementedInstruction(state); break; case 0x02: UnimplementedInstruction(state); break; case 0x03: UnimplementedInstruction(state); break; case 0x04: UnimplementedInstruction(state); break; /*....*/ case 0xfe: UnimplementedInstruction(state); break; case 0xff: UnimplementedInstruction(state); break; } state->pc+=1; //  }

आइए कुछ ऑपकोड लागू करें।

  void Emulate8080Op(State8080* state) { unsigned char *opcode = &state->memory[state->pc]; switch(*opcode) { case 0x00: break; //NOP -  ! case 0x01: //LXI B, state->c = opcode[1]; state->b = opcode[2]; state->pc += 2; //   2  break; /*....*/ case 0x41: state->b = state->c; break; //MOV B,C case 0x42: state->b = state->d; break; //MOV B,D case 0x43: state->b = state->e; break; //MOV B,E } state->pc+=1; }

वहां तुम जाओ। प्रत्येक ओपकोड के लिए, हम राज्य और मेमोरी को बदलते हैं, जैसा कि एक वास्तविक 8080 पर निष्पादित कमांड करेगा।

8080 में लगभग 7 प्रकार हैं, इस पर निर्भर करता है कि आप उन्हें कैसे वर्गीकृत करते हैं:

डेटा ट्रांसफर
अंक-संबंधी
बूलियन
शाखाओं में
अनेकता
इनपुट-आउटपुट
विशेष

आइए उनमें से प्रत्येक को व्यक्तिगत रूप से देखें।

अंकगणित समूह

अंकगणितीय निर्देश 8080 प्रोसेसर के 256 ऑपकोड में से कई हैं, जिसमें विभिन्न प्रकार के जोड़ और घटाव शामिल हैं। अधिकांश अंकगणितीय निर्देश रजिस्टर ए के साथ काम करते हैं और परिणाम को ए में रजिस्टर करते हैं (रजिस्टर ए को संचायक भी कहा जाता है)।

यह ध्यान रखना दिलचस्प है कि ये आदेश स्थिति कोड को प्रभावित करते हैं। निष्पादित कोड के परिणाम के आधार पर राज्य कोड (झंडे भी कहा जाता है) निर्धारित किए जाते हैं। सभी कमांड फ्लैग को प्रभावित नहीं करते हैं, और सभी टीमें झंडे को प्रभावित नहीं करती हैं जो एक ही बार में सभी झंडे को प्रभावित करती हैं।

झंडे 8080

8080 के प्रोसेसर में झंडे को Z, S, P, CY और AC कहा जाता है।

परिणाम शून्य होने पर Z (शून्य, शून्य) मान 1 लेता है
S (साइन) 1 मान लेता है जब गणितीय कमांड का बिट 7 (सबसे महत्वपूर्ण बिट, सबसे महत्वपूर्ण बिट, MSB) दिया जाता है
पी (समता, समता) सेट किया जाता है जब परिणाम समान होता है, और जब यह विषम होता है, तो रीसेट हो जाता है
CY (कैरी) का मान 1 तब होता है, जब कमांड के परिणामस्वरूप, उच्च ऑर्डर बिट में स्थानांतरण या उधार लिया जाता है
एसी (ऑक्सिलरी कैरी) का इस्तेमाल मुख्य रूप से बीसीडी (बाइनरी कोडेड दशमलव) गणित के लिए किया जाता है। अधिक जानकारी के लिए, मैनुअल देखें, अंतरिक्ष आक्रमणकारियों में इस ध्वज का उपयोग नहीं किया जाता है।

सशर्त शाखा आदेशों में राज्य कोड का उपयोग किया जाता है, उदाहरण के लिए, जेड जेड केवल झंडे सेट होने पर शाखा करता है।

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

पंजीकरण फॉर्म

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

  case 0x80: //ADD B { //      , //      uint16_t answer = (uint16_t) state->a + (uint16_t) state->b; //  :    , //    , //      if ((answer & 0xff) == 0) state->cc.z = 1; else state->cc.z = 0; //  :   7 , //    , //      if (answer & 0x80) state->cc.s = 1; else state->cc.s = 0; //   if (answer > 0xff) state->cc.cy = 1; else state->cc.cy = 0; //    state->cc.p = Parity( answer & 0xff); state->a = answer & 0xff; } //  ADD     case 0x81: //ADD C { uint16_t answer = (uint16_t) state->a + (uint16_t) state->c; state->cc.z = ((answer & 0xff) == 0); state->cc.s = ((answer & 0x80) != 0); state->cc.cy = (answer > 0xff); state->cc.p = Parity(answer&0xff); state->a = answer & 0xff; }

मैं 16-बिट संख्या के साथ 8-बिट गणित कमांड का अनुकरण करता हूं। इससे उन मामलों पर नज़र रखना आसान हो जाता है जहां गणना एक कैरी उत्पन्न करती है।

तत्काल मूल्यों के लिए फार्म

तत्काल मानों के लिए फॉर्म लगभग समान है, सिवाय इसके कि कमांड के बाद बाइट जोड़ा का स्रोत है। चूँकि "opcode" मेमोरी में करंट कमांड का पॉइंटर है, इसलिए opcode [1] तुरंत अगली बाइट होगी।

  case 0xC6: //ADI  { uint16_t answer = (uint16_t) state->a + (uint16_t) opcode[1]; state->cc.z = ((answer & 0xff) == 0); state->cc.s = ((answer & 0x80) != 0); state->cc.cy = (answer > 0xff); state->cc.p = Parity(answer&0xff); state->a = answer & 0xff; }

स्मृति के लिए आकार

मेमोरी के रूप में, एक बाइट जोड़ा जाएगा जिसमें एचएल रजिस्टरों की एक जोड़ी में संग्रहीत पता इंगित करता है।

  case 0x86: //ADD M { uint16_t offset = (state->h<<8) | (state->l); uint16_t answer = (uint16_t) state->a + state->memory[offset]; state->cc.z = ((answer & 0xff) == 0); state->cc.s = ((answer & 0x80) != 0); state->cc.cy = (answer > 0xff); state->cc.p = Parity(answer&0xff); state->a = answer & 0xff; }

नोट

शेष अंकगणितीय निर्देशों को एक समान तरीके से लागू किया जाता है। अतिरिक्त:

संदर्भ मैनुअल के अनुसार कैरी (एडीसी, एसीआई, एसबीबी, एसयूआई) के साथ विभिन्न संस्करणों में, हम गणना में कैरी बिट्स का उपयोग करते हैं।
INX और DCX रजिस्टर जोड़े को प्रभावित करते हैं; ये कमांड फ्लैग को प्रभावित नहीं करते हैं।
DAD रजिस्टरों की एक जोड़ी का एक और कमांड है, यह केवल कैरी फ्लैग को प्रभावित करता है
INR और DCR कैरी फ़्लैग को प्रभावित नहीं करते हैं

शाखा समूह

आपके द्वारा राज्य कोड से निपटने के बाद, शाखा समूह आपके लिए पर्याप्त स्पष्ट हो जाएगा। दो प्रकार की शाखाएं हैं - संक्रमण (JMP) और कॉल (CALL)। JMP बस पीसी को जंप डेस्टिनेशन के मान पर सेट करता है। कॉल का उपयोग रूटीन के लिए किया जाता है, यह स्टैक पर वापसी पता लिखता है, और फिर पीसी को गंतव्य का पता बताता है। आरईटी कॉल से लौटता है, स्टैक से पता प्राप्त करता है और इसे पीसी पर लिखता है।

जेएमपी और कॉल दोनों ही पूर्ण पते पर जाते हैं जो ओपकोड के बाद बाइट्स में एन्कोडेड होते हैं।

जेएमपी

JMP कमांड शाखाएं बिना गंतव्य पते के बिना शर्त। सभी स्थिति कोड (एसी को छोड़कर) के लिए सशर्त शाखा कमांड भी हैं:

JNZ और JZ शून्य के लिए
प्रवास के लिए जेएनसी और जेसी
समानता के लिए जेपीओ और जेपीई
संकेत के लिए जेपी (प्लस) और जेएम (माइनस)

यहाँ उनमें से कुछ का कार्यान्वयन है:

  case 0xc2: //JNZ  if (0 == state->cc.z) state->pc = (opcode[2] << 8) | opcode[1]; else //    state->pc += 2; break; case 0xc3: //JMP  state->pc = (opcode[2] << 8) | opcode[1]; break;

कॉल और आरईटी

कॉल कॉल के बाद स्टैक पर निर्देश के पते को धक्का देता है, और फिर गंतव्य पते पर कूदता है। आरईटी स्टैक से पता प्राप्त करता है और इसे पीसी पर बचाता है। CALL और RET के सशर्त संस्करण सभी राज्यों के लिए मौजूद हैं।

शून्य के लिए सीजेड, सीएनजेड, आरजेड, आरएनजेड
ट्रांसफर के लिए सीएनसी, सीसी, आरएनसी, आरसी
CPO, CPE, RPO, समता के लिए RPE
साइन के लिए सीपी, सीएम, आरपी, आरएम

  case 0xcd: //CALL  { uint16_t ret = state->pc+2; state->memory[state->sp-1] = (ret >> 8) & 0xff; state->memory[state->sp-2] = (ret & 0xff); state->sp = state->sp - 2; state->pc = (opcode[2] << 8) | opcode[1]; } break; case 0xc9: //RET state->pc = state->memory[state->sp] | (state->memory[state->sp+1] << 8); state->sp += 2; break;

नोट

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

तार्किक समूह

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

बूलियन ऑपरेशन

और, OR, NOT (CMP) और "एक्सक्लूसिव या" (XOR) बुलियन ऑपरेशन कहलाते हैं। या और मैंने पहले समझाया। नहीं कमांड (8080 प्रोसेसर के लिए इसे CMA कहा जाता है, या संचायक को पूरक करता है) बस थोड़ा मूल्यों को बदलता है - सभी इकाइयां शून्य हो जाती हैं, और शून्य बन जाते हैं।

मैं XOR को "अंतर पहचानकर्ता" के रूप में देखता हूं। उसकी सत्य तालिका इस प्रकार है:

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

और, OR, और XOR में रजिस्टरों, मेमोरी और तात्कालिक मूल्यों के लिए एक फॉर्म है। (CMP के पास केवल केस-संवेदी कमांड है)। यहाँ opcodes की एक जोड़ी का कार्यान्वयन है:

  case 0x2F: //CMA (not) state->a = ~state->a //  ,  CMA     break; case 0xe6: //ANI  { uint8_t x = state->a & opcode[1]; state->cc.z = (x == 0); state->cc.s = (0x80 == (x & 0x80)); state->cc.p = parity(x, 8); state->cc.cy = 0; //  ,  ANI  CY state->a = x; state->pc++; //   } break;

चक्रीय शिफ्ट कमांड

ये कमांड रजिस्टरों में बिट्स के क्रम को बदलते हैं। दाईं ओर एक शिफ्ट उन्हें एक बिट से दाईं ओर ले जाती है, और बाईं ओर एक शिफ्ट - एक बिट द्वारा छोड़ दिया जाता है:

(0b00010000) = 0b00001000

(0b00000001) = 0b00000010

वे बेकार लग रहे हैं, लेकिन वास्तव में ऐसा नहीं है। उन्हें दो की शक्तियों से गुणा और विभाजित करने के लिए इस्तेमाल किया जा सकता है। उदाहरण के तौर पर बाईं पारी को लें। 0b00000001 दशमलव 1 है, और इसे बाईं ओर शिफ्ट करने से यह 0b00000010 हो जाता है, 0b00000010 दशमलव 2। यदि हम बाईं ओर दूसरी पारी करते हैं, तो हमें 0b00000100 मिलता है, यही है 4. बाईं ओर एक और पारी, और हम 8. से गुणा करते हैं। यह किसी भी के साथ काम करेगा। संख्याओं द्वारा: 5 ( 0b00000101 ) जब बाईं ओर शिफ्ट किया जाता है तो 10 ( 0b00001010 ) देता है। एक और बाईं पारी 20 ( 0b00010100 ) देती है। दाईं ओर शिफ्ट वही करता है, लेकिन विभाजन के लिए।

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

ये कमांड साइक्लीक रूप से ड्राइव को घुमाते हैं और केवल कैरी फ्लैग को प्रभावित करते हैं। यहाँ कुछ आदेश दिए गए हैं:

  case 0x0f: //RRC { uint8_t x = state->a; state->a = ((x & 1) << 7) | (x >> 1); state->cc.cy = (1 == (x&1)); } break; case 0x1f: //RAR { uint8_t x = state->a; state->a = (state->cc.cy << 7) | (x >> 1); state->cc.cy = (1 == (x&1)); } break;

तुलना

सीएमपी और सीपीआई का कार्य केवल झंडे सेट करना है (शाखाओं के लिए)। वे झंडे को घटाकर ऐसा करते हैं, लेकिन परिणाम को संग्रहीत नहीं करते हैं।

समान रूप से: यदि दो संख्याएँ समान हैं, तो Z ध्वज सेट है, क्योंकि एक दूसरे से उनका घटाव शून्य देता है।
की तुलना में अधिक: यदि A की तुलना की जा रही वैल्यू से अधिक है, तो CY झंडे को साफ कर दिया जाता है (क्योंकि घटाव बिना उधार लिए किया जा सकता है)।
छोटा: यदि A तुलना किए गए मान से कम है, तो CY ध्वज सेट किया जाता है (क्योंकि A को घटाव को पूरा करने के लिए उधार पूरा करना होगा)।

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

  case 0xfe: //CPI  { uint8_t x = state->a - opcode[1]; state->cc.z = (x == 0); state->cc.s = (0x80 == (x & 0x80)); //  ,    p -   state->cc.p = parity(x, 8); state->cc.cy = (state->a < opcode[1]); state->pc++; } break;

सीएमसी और एसटीसी

वे तार्किक समूह को पूरा करते हैं। उनका उपयोग कैरी फ़्लैग को सेट करने और साफ़ करने के लिए किया जाता है।

इनपुट-आउटपुट और विशेष कमांड का समूह

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

ईआई और डीआई इंटरप्ट को संभालने के लिए प्रोसेसर की क्षमता को सक्षम या अक्षम करते हैं। मैंने प्रोसेसर राज्य संरचना में बाधा_ सक्षम ध्वज को जोड़ा, और इन आदेशों का उपयोग करके इसे सेट / रीसेट किया।
ऐसा लगता है कि रिम और सिम मुख्य रूप से धारावाहिक I / O के लिए उपयोग किए जाते हैं। यदि आप रुचि रखते हैं, तो आप मैनुअल पढ़ सकते हैं, लेकिन इन आदेशों का उपयोग अंतरिक्ष आक्रमणकारियों में नहीं किया जाता है। मैं उनका अनुकरण नहीं करूंगा।
HLT एक पड़ाव है। मुझे नहीं लगता कि हमें इसका अनुकरण करने की आवश्यकता है, लेकिन जब आप इस आदेश को देखते हैं, तो आप अपना पद छोड़ सकते हैं (या बाहर निकलें (0)) कोड।
IN और OUT ऐसे कमांड हैं जिन्हें 8080 प्रोसेसर उपकरण बाहरी उपकरणों के साथ संचार करने के लिए उपयोग करता है। जबकि हम उन्हें लागू कर रहे हैं, लेकिन वे कुछ भी नहीं करेंगे लेकिन अपने डेटा को छोड़ दें। (बाद में हम उनके पास लौट आएंगे)।
एनओपी "कोई ऑपरेशन नहीं" है। एनओपी का एक अनुप्रयोग पैनल टाइमिंग को नियंत्रित करना है (इसे निष्पादित करने के लिए चार सीपीयू चक्र लगते हैं)।

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

ढेर समूह

हमने स्टैक समूह की अधिकांश टीमों के लिए पहले ही यांत्रिकी पूरी कर ली है। यदि आपने मेरे साथ काम किया, तो इन आदेशों को लागू करना आसान होगा।

PUSH और POP

PUSH और POP केवल रजिस्टर जोड़े के साथ काम करते हैं। PUSH स्टैक में रजिस्टर की एक जोड़ी लिखता है, और POP स्टैक के ऊपर से 2 बाइट्स लेता है और उन्हें रजिस्टर की एक जोड़ी में लिखता है।

PUSH और POP के लिए चार ऑपकोड हैं, प्रत्येक जोड़े के लिए एक: BC, DE, HL और PSW। PSW ड्राइव फ्लैग रजिस्टर और स्टेटस कोड की एक विशेष जोड़ी है। यहां बीसी और पीएसडब्ल्यू के लिए पीयूएसएच और पीओपी का मेरा कार्यान्वयन है। इसमें कोई टिप्पणी नहीं है - मुझे नहीं लगता है कि यहां कुछ विशेष रूप से मुश्किल है।

  case 0xc1: //POP B { state->c = state->memory[state->sp]; state->b = state->memory[state->sp+1]; state->sp += 2; } break; case 0xc5: //PUSH B { state->memory[state->sp-1] = state->b; state->memory[state->sp-2] = state->c; state->sp = state->sp - 2; } break; case 0xf1: //POP PSW { state->a = state->memory[state->sp+1]; uint8_t psw = state->memory[state->sp]; state->cc.z = (0x01 == (psw & 0x01)); state->cc.s = (0x02 == (psw & 0x02)); state->cc.p = (0x04 == (psw & 0x04)); state->cc.cy = (0x05 == (psw & 0x08)); state->cc.ac = (0x10 == (psw & 0x10)); state->sp += 2; } break; case 0xf5: //PUSH PSW { state->memory[state->sp-1] = state->a; uint8_t psw = (state->cc.z | state->cc.s << 1 | state->cc.p << 2 | state->cc.cy << 3 | state->cc.ac << 4 ); state->memory[state->sp-2] = psw; state->sp = state->sp - 2; } break;

SPHL और XTHL

स्टैक ग्रुप में दो और टीमें हैं- SPHL और XTHL।

SPHL एचएल को एसपी (एसपी को नया पता प्राप्त करने के लिए मजबूर करता है) ले जाता है।
XTHL स्वैप करता है कि एचएल रजिस्टरों की एक जोड़ी के साथ स्टैक के शीर्ष पर क्या है। आपको ऐसा करने की आवश्यकता क्यों होगी? मुझे नहीं पता

बाइनरी संख्याओं के बारे में थोड़ा अधिक

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

हस्ताक्षरित और अहस्ताक्षरित

जब हमने हेक्स संख्या के बारे में बात करना शुरू किया, तो हमने उन्हें अहस्ताक्षरित माना - अर्थात, हेक्साडेसिमल संख्या के प्रत्येक द्विआधारी अंक का एक सकारात्मक मूल्य था, और प्रत्येक को दो (इकाइयों, दो, चार, आदि) की शक्ति माना जाता था।

हम नकारात्मक संख्याओं के कंप्यूटर भंडारण के मुद्दे से निपटते हैं। यदि आप जानते हैं कि प्रश्न के डेटा में एक संकेत है, अर्थात वे नकारात्मक हो सकते हैं, तो आप संख्या के सबसे महत्वपूर्ण बिट (सबसे महत्वपूर्ण बिट, एमएसबी) द्वारा एक नकारात्मक संख्या को पहचान सकते हैं। यदि डेटा का आकार एक बाइट है, तो किसी दिए गए MSB बिट मान के साथ प्रत्येक संख्या नकारात्मक है, और शून्य MSB के साथ प्रत्येक सकारात्मक है।

ऋणात्मक संख्या का मान एक अतिरिक्त कोड के रूप में संग्रहीत किया जाता है। यदि हमारे पास एक हस्ताक्षरित संख्या है और MSB एक के बराबर है, और हम यह पता लगाना चाहते हैं कि संख्या क्या है, तो हम इसे निम्नानुसार परिवर्तित कर सकते हैं: हेक्स-नंबरों के लिए बाइनरी "NOT" प्रदर्शन करें, और फिर एक जोड़ें।

उदाहरण के लिए, एक हेक्स संख्या 0x80 के लिए, MSB बिट सेट है, अर्थात यह नकारात्मक है। संख्या 0x80 का बाइनरी "नहीं" 0x7f है, या दशमलव 127. 127 + 1 = 128 है। अर्थात्, 0x80 दशमलव में -128 है। दूसरा उदाहरण: 0xC5। नहीं (0xC5) = 0x3A = दशमलव 58 +1 = दशमलव 59। अर्थात्, 0xC5 दशमलव -59 है।

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

  उदाहरण 1

      दशमलव हेक्स बाइनरी    
       -3 0xFD 1111 1101    
    + 10 0x0A +0000 1010    
    ----- -----------    
        7 0x07 1 0000 0111    
                        ^ यह कैरी बिट में दर्ज है

    उदाहरण 2    

      दशमलव हेक्स बाइनरी    
      -59 0xC5 1100 0101    
    + 33 0x21 +0010 0001    
    ----- -----------    
      -26 0xE6 1110 0110

उदाहरण 1 में, हम देखते हैं कि 7. में 10 और -3 परिणाम जोड़ते हैं। इसके अलावा परिणाम को स्थानांतरित किया गया था, इसलिए सी ध्वज को सेट किया जा सकता है। उदाहरण 2 में, इसके अतिरिक्त परिणाम नकारात्मक था, इसलिए हम इसे डिकोड करते हैं: नहीं (0xE6) = 0x19/25 + 1 = 26. 0xE6 = -26 मस्तिष्क का विस्फोट!

यदि आप चाहते हैं, तो विकिपीडिया पर अतिरिक्त कोड के बारे में अधिक पढ़ें।

डेटा प्रकार

सी में, डेटा प्रकार और इस प्रकार के लिए उपयोग किए जाने वाले बाइट्स की संख्या के बीच एक संबंध है। वास्तव में, हम केवल पूर्णांकों में रुचि रखते हैं। मानक / पुराने स्कूल C डेटा प्रकार चार, इंट, और लंबे होते हैं, साथ ही साथ उनके मित्र ने अहस्ताक्षरित char, अहस्ताक्षरित int, और अहस्ताक्षरित लंबे। समस्या यह है कि विभिन्न प्लेटफार्मों पर और विभिन्न कंपाइलरों में इन प्रकारों के अलग-अलग आकार हो सकते हैं।

इसलिए, हमारे प्लेटफ़ॉर्म के लिए डेटा प्रकार का चयन करना सबसे अच्छा है जो डेटा के आकार को स्पष्ट रूप से घोषित करता है। यदि आपके प्लेटफ़ॉर्म में stdint.h है, तो आप int8_t, uint8_t, आदि का उपयोग कर सकते हैं।

पूर्णांक का आकार अधिकतम संख्या निर्धारित करता है जिसे इसमें संग्रहीत किया जा सकता है। अहस्ताक्षरित पूर्णांक के मामले में, आप 8 बिट्स में 0 से 255 तक संख्याओं को संग्रहीत कर सकते हैं। यदि आप हेक्स में अनुवाद करते हैं, तो यह 0x00 से 0xFF तक है। चूंकि 0xFF में "सभी बिट्स सेट" हैं, और यह दशमलव 255 से मेल खाती है, यह पूरी तरह से तार्किक है कि एकल-बाइट अहस्ताक्षरित पूर्णांक का अंतराल 0-255 है। अंतराल हमें बताते हैं कि पूर्णांक के सभी आकार ठीक उसी तरह काम करेंगे - संख्याएं उस संख्या के अनुरूप होती हैं जो सभी बिट सेट होने पर प्राप्त की जाती हैं।

टाइप	अंतराल	हेक्स
8-बिट अहस्ताक्षरित	0-255	0x0-0xFF
8-बिट पर हस्ताक्षर किए	-128-127	0x80-0x7F
16-बिट अहस्ताक्षरित	0-65,535	0x0-0xFFFF
16-बिट पर हस्ताक्षर किए	-32,768-32,767	0x8000-0x7FFF
32-बिट अहस्ताक्षरित	0-4294967295	0x0-0xFFFFFFFF
32-बिट पर हस्ताक्षर किए	-2147483648-2147483647	0x80000000-0x7FFFFFFF

इससे भी अधिक दिलचस्प बात यह है कि प्रत्येक हस्ताक्षरित डेटा प्रकार में -1 एक संख्या है जिसमें सभी बिट सेट हैं (हस्ताक्षरित बाइट के लिए 0xFF, हस्ताक्षरित 16-बिट संख्या के लिए 0xFFFF और हस्ताक्षरित 32-बिट संख्या के लिए 0xFFFFFFFF)। यदि डेटा को अहस्ताक्षरित माना जाता है, तो सभी दिए गए बिट्स के लिए, इस प्रकार के डेटा के लिए अधिकतम संभव संख्या प्राप्त की जाती है।

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

संकेत: डेटा प्रकारों को परिवर्तित करने के लिए डीबगर का उपयोग करें

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

# /c, gdb
(gdb) print /c 0xFD
$1 = -3 '?'

# /x, gdb hex
# "p" "print"
(gdb) p /c 0xA
$2 = 10 '\n'

# 2 " "
(gdb) p /c 0xC5
$3 = -59 '?'
(gdb) p /c 0xC5+0x21
$4 = -26 '?'

# print , gdb
(gdb) p 0x21
$9 = 33

# , gdb,
# ,
(gdb) p 0xc5
$5 = 197 #
(gdb) p /c 0xc5
$3 = -59 '?' #
(gdb) p 0xfd
$6 = 253

# ( 32- )
(gdb) p /x -3
$7 = 0xfffffffd

# 1
(gdb) print (char) 0xff
$1 = -1 '?'
# 1
(gdb) print (unsigned char) 0xff
$2 = 255 '?'

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

सीपीयू एमुलेटर समाप्ति

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

यदि आप पूर्ण अनुकरण करने का निर्णय लेते हैं, तो आपको कुछ और साधनों की आवश्यकता होगी। मैं उनके बारे में अगले भाग में बात करूंगा।

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

ROM अंतरिक्ष आक्रमणकारियों के साथ एमुलेटर लॉन्च करें
UnimplementedInstruction()यदि कमांड तैयार नहीं है तो कॉल बाहर निकलता है
इस निर्देश का अनुकरण करें
गोटो १

, , — . , :

  int Emulate8080Op(State8080* state) { unsigned char *opcode = &state->memory[state->pc]; Disassemble8080Op(state->memory, state->pc); switch (*opcode) { case 0x00: //NOP /* ... */ } /*    */ printf("\tC=%d,P=%d,S=%d,Z=%d\n", state->cc.cy, state->cc.p, state->cc.s, state->cc.z); printf("\tA $%02x B $%02x C $%02x D $%02x E $%02x H $%02x L $%02x SP %04x\n", state->a, state->b, state->c, state->d, state->e, state->h, state->l, state->sp); }

.

: , 50 , 8080. , :


0x00	NOP
0x01	LXI B,D16
0x05	DCR B
0x06	MVI B,D8
0x09	DAD B
0x0d	DCR C
0x0e	MVI C,D8
0x0f	RRC
0x11	LXI D,D16
0x13	INX D
0x19	DAD D
0x1a	LDAX D
0x21	LXI H,D16
0x23	INX H
0x26	MVI H,D8
0x29	DAD H
0x31	LXI SP,D16
0x32	STA adr
0x36	MVI M,D8
0x3a	LDA adr
0x3e	MVI A,D8
0x56	MOV D,M
0x5e	MOV E,M
0x66	MOV H,M
0x6f	MOV L,A
0x77	MOV M,A
0x7a	MOV A,D
0x7b	एमओवी ए, ई
0x7c	एमओवी ए, एच
0x7E	एमओवी ए, एम
0xa7	ANA ए
0xaf	XRA ए
0xc1	पॉप बी
0xc2	Jnz adr
0xc3	जेएमपी एडीआर
0xc5	पूष बी
0xc6	ADI D8
0xc9	आरईटी
0xcd	एड्र को बुलाओ
0xd1	पॉप डी
0xd3	OUT D8
0xd5	पूष D
0xe1	पॉप एच
0xe5	पूष ह
0xe6	ANI D8
0xeb	XCHG
0xf1	पीओपी PSW
0xf5	PUSH PSW
0xfb	ईआई
0xFE	CPI D8

ये केवल 50 निर्देश हैं, और उनमें से 10 ऐसे आंदोलन हैं जो तुच्छ रूप से लागू किए गए हैं।

डिबगिंग

. , . , ( , ), , .

— , . , , . , . . , , , :

अगली टीम के लिए
अपने राज्य के साथ अपने एमुलेटर को कॉल करना
मेरे भाग्य से मेरा बुलाना
हमारे दो राज्यों की तुलना करें
किसी भी मतभेद में त्रुटियों की तलाश
गोटो ३

एक अन्य तरीका इस साइट को मैन्युअल रूप से उपयोग करना है । यह एक 8080 जावास्क्रिप्ट प्रोसेसर एमुलेटर है जिसमें ROM स्पेस इनवेस्टर्स भी शामिल है। यहाँ प्रक्रिया है:

अंतरिक्ष आक्रमणकारियों को पुनः प्रारंभ करें अंतरिक्ष आक्रमणकारियों बटन पर क्लिक करके
कमांड निष्पादित करने के लिए "रन 1" बटन दबाएं।
हम अपने एमुलेटर में निम्न कमांड निष्पादित करते हैं
प्रोसेसर की स्थिति की तुलना अपने साथ करें
यदि स्थिति मेल खाती है, तो गोटो 2
यदि स्थितियां मेल नहीं खाती हैं, तो आपका निर्देश अनुकरण गलत है। इसे ठीक करें, और फिर चरण 1 से फिर से शुरू करें।

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

यदि आप चरणबद्ध तरीके से अपने कोड को निष्पादित करते हैं, तो पहले 30 हजार निर्देशों में से अधिकांश को $ 1a5f के चक्र में निष्पादित किया जाता है। यदि आप एमुलेटर में जावास्क्रिप्ट को देखते हैं, तो आप देख सकते हैं कि यह कोड डेटा को स्क्रीन पर कॉपी करता है। मुझे यकीन है कि इस कोड को अक्सर कहा जाता है।

स्क्रीन के पहले प्रतिपादन के बाद, 50 हजार कमांड के बाद, प्रोग्राम इस अंतहीन लूप में फंस जाता है:

  0ada LDA $20c0 0add ANA A 0ade JNZ $0ada

यह तब तक इंतजार करता है जब तक कि $ 20c0 में स्मृति में मान शून्य में बदल जाता है। चूंकि इस लूप में कोड $ 20c0 नहीं बदलता है, यह कहीं और से संकेत होना चाहिए। यह एक आर्केड मशीन के "लोहा" का अनुकरण करने के बारे में बात करने का समय है।

इससे पहले कि हम अगले अनुभाग पर जाएं, सुनिश्चित करें कि आपका सीपीयू एमुलेटर इस अंतहीन लूप में आता है।

संदर्भ के लिए, मेरे स्रोत देखें ।

पूर्ण 8080 अनुकरण

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

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

मैं आपको कई कारणों से पहली बार इस प्रक्रिया से परिचित कराता हूं:

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

इस प्रकार मैंने अपने एमुलेटर के साथ इस परीक्षण का उपयोग किया। आप इसका उपयोग कर सकते हैं या इसे एकीकृत करने के लिए बेहतर तरीके के साथ आ सकते हैं।

टेस्ट असेंबली

मैंने कुछ चीजों की कोशिश की, लेकिन परिणामस्वरूप मैं इस अच्छे पृष्ठ का उपयोग करने पर बस गया । मैंने पाठ cpudiag.asm को बाएँ फलक में चिपका दिया और बिल्ड बिना किसी समस्या के पूरा हो गया। मुझे यह पता लगाने में एक मिनट का समय लगा कि परिणाम कैसे डाउनलोड किया जाए, लेकिन निचले बाएँ में "सुंदर कोड बनाएँ" बटन पर क्लिक करके, मैंने test.bin नामक एक फ़ाइल डाउनलोड की, जिसका कोड 8080 संकलित है। मैं अपने डिस्क्लेमर का उपयोग करके इसे सत्यापित करने में सक्षम था। मेरी वेबसाइट पर दर्पण से

cpudiag.asm डाउनलोड करें। मेरी साइट से

cpudiag.bin (संकलित कोड 8080) डाउनलोड करें ।

मेरे एमुलेटर पर एक परीक्षण अपलोड करना

invaders.* .

. -, ORG 00100H , , , 0x100 hex. 8080, , . , , , 0x100.

-, , . hex- JMP $0100 , . ( PC 0x100.)

-, . , STACK EQU TEMPP+256 , . , $6ad, PUSH . , 0x100, , , «0x7» , .

, DAA , , ( JMP).

  ReadFileIntoMemoryAt(state, "/Users/kpmiller/Desktop/invaders/cpudiag.bin", 0x100); //  ,   JMP 0x100 state->memory[0]=0xc3; state->memory[1]=0; state->memory[2]=0x01; //Fix the stack pointer from 0x6ad to 0x7ad // this 0x06 byte 112 in the code, which is // byte 112 + 0x100 = 368 in memory state->memory[368] = 0x7; //  DAA state->memory[0x59c] = 0xc3; //JMP state->memory[0x59d] = 0xc2; state->memory[0x59e] = 0x05;

जाहिर है, यह परीक्षण सीपी / एम ओएस की मदद पर निर्भर करता है। मुझे पता चला कि CP / M के पास $ 0005 पर कुछ कोड है जो कंसोल को संदेश प्रिंट करता है, और इस व्यवहार को संभालने के लिए मेरे CALL एमुलेशन को बदल दिया है। मुझे यकीन नहीं है कि अगर सब कुछ सही निकला, लेकिन यह उन दो संदेशों के लिए काम करता है जिन्हें प्रोग्राम प्रिंट करने की कोशिश कर रहा है। इस परीक्षण को चलाने के लिए मेरा कॉल अनुकरण इस तरह दिखता है:

  case 0xcd: //CALL  #ifdef FOR_CPUDIAG if (5 == ((opcode[2] << 8) | opcode[1])) { if (state->c == 9) { uint16_t offset = (state->d<<8) | (state->e); char *str = &state->memory[offset+3]; // - while (*str != '$') printf("%c", *str++); printf("\n"); } else if (state->c == 2) { //    ,   ,    printf ("print char routine called\n"); } } else if (0 == ((opcode[2] << 8) | opcode[1])) { exit(0); } else #endif { uint16_t ret = state->pc+2; state->memory[state->sp-1] = (ret >> 8) & 0xff; state->memory[state->sp-2] = (ret & 0xff); state->sp = state->sp - 2; state->pc = (opcode[2] << 8) | opcode[1]; } break;

इस परीक्षण के साथ, मुझे अपने एमुलेटर में कई समस्याएं मिलीं। मुझे यकीन नहीं है कि उनमें से कौन खेल में शामिल होगा, लेकिन अगर वे थे, तो उन्हें ढूंढना बहुत मुश्किल होगा।

मैंने आगे बढ़कर सभी opcodes (DAA और उनके दोस्तों के अपवाद के साथ) को लागू किया। मेरी चुनौतियों में समस्याओं को ठीक करने और नए लोगों को लागू करने में मुझे 3-4 घंटे लगे। यह निश्चित रूप से मैनुअल प्रक्रिया से तेज था जिसे मैंने ऊपर वर्णित किया था - इससे पहले कि मैं इस परीक्षण को पाता, मैंने मैनुअल प्रक्रिया पर 4 घंटे से अधिक समय बिताया। यदि आप इस स्पष्टीकरण का पता लगा सकते हैं, तो मैं मैन्युअल रूप से तुलना करने के बजाय इस पद्धति का उपयोग करने की सलाह देता हूं। हालांकि, मैनुअल प्रक्रिया को जानना भी एक महान कौशल है, और यदि आप किसी अन्य प्रोसेसर का अनुकरण करना चाहते हैं, तो आपको इसे वापस करना चाहिए।

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

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