Assembly Language
ढेर
खोज…
टिप्पणियों
कंप्यूटर का ढेर किताबों के ढेर की तरह है। PUSH शीर्ष पर एक जोड़ता है और POP ऊपरवाले को दूर ले जाता है। वास्तविक जीवन की तरह स्टैक अंतहीन नहीं हो सकता है, इसलिए इसका अधिकतम आकार है। स्टैक का उपयोग एल्गोरिदम को छांटने के लिए किया जा सकता है, बड़ी मात्रा में डेटा को संभालने के लिए या किसी अन्य ऑपरेशन को करते समय रजिस्टरों के सुरक्षित मूल्यों के लिए।
ज़िलॉग Z80 स्टैक
रजिस्टर sp को स्टैक पॉइंटर के रूप में उपयोग किया जाता है, स्टैक में अंतिम संग्रहीत मूल्य (स्टैक के "शीर्ष") की ओर इशारा करता है। तो EX (sp),hl स्टैक के शीर्ष पर मूल्य के साथ hl मूल्य का आदान-प्रदान करेगा।
"टॉप" शब्द के विपरीत, ढेर कम से स्मृति में बढ़ता sp , और विज्ञप्ति ( "पॉप") मान में वृद्धि से sp ।
के लिए sp = $4844 मूल्यों के साथ 1 , 2 , 3 ढेर (पर संग्रहीत 3 अंतिम मान के रूप में ढेर पर धकेल दिया जा रहा है, तो यह के शीर्ष पर जा रहा है), स्मृति इस तरह दिखेगा:
| address | value bytes | comment (btw, all numbers are in hexadecimal)
| ---------- | ----------- | ---------------------------------
| 4840 | ?? ?? | free stack spaces to be used by next push/call
| 4842 | ?? ?? | or by interrupt call! (don't expect values to stay here)
| sp -> 4844 | 03 00 | 16 bit value "3" on top of stack
| 4846 | 02 00 | 16 bit value "2"
| 4848 | 01 00 | 16 bit value "1"
| 484A | ?? ?? | Other values in stack (up to it's origin)
| 484C | ?? ?? | like for example return address for RET instruction
उदाहरण, स्टैक के साथ निर्देश कैसे काम करते हैं:
LD hl,$0506
EX (sp),hl ; $0003 into hl, "06 05" bytes at $4844
POP bc ; like: LD c,(sp); INC sp; LD b,(sp); INC sp
; so bc is now $0506, and sp is $4846
XOR a ; a = 0, sets zero and parity flags
PUSH af ; like: DEC sp; LD (sp),a; DEC sp; LD (sp),f
; so at $4844 is $0044 (44 = z+p flags), sp is $4844
CALL $8000 ; sp is $4842, with address of next ins at top of stack
; pc = $8000 (jumping to sub-routine)
; after RET will return here, the sp will be $4844 again
LD (L1+1),sp ; stores current sp into LD sp,nn instruction (self modification)
DEC sp ; sp is $4843
L1 LD sp,$1234 ; restores sp to $4844 ($1234 was modified)
POP de ; de = $0044, sp = $4846
POP ix ; ix = $0002, sp = $4848
...
...
ORG $8000
RET ; LD pc,(sp); INC sp; INC sp
; jumps to address at top of stack, "returning" to caller
सारांश : PUSH स्टैक के शीर्ष पर मूल्य संग्रहीत करेगा, POP स्टैक के शीर्ष से मूल्य प्राप्त करेगा, यह एक LIFO (अंतिम में, पहले आउट) कतार है। CALL JP समान है, लेकिन यह स्टैक के शीर्ष पर CALL बाद अगले निर्देश के पते को भी धक्का देता है। RET भी JP समान है, पते को स्टैक से पॉप करने और इसे कूदने के लिए।
चेतावनी : जब रुकावटों को सक्षम किया जाता है, तो अवरोधक सिग्नल के दौरान sp को वैध होना चाहिए, बीच में हैंडलर रूटीन के लिए पर्याप्त खाली स्थान आरक्षित होना चाहिए, क्योंकि बाधा सिग्नल हैंडलर रूटीन को कॉल करने से पहले रिटर्न एड्रेस (वास्तविक pc ) को स्टोर करेगा, जो आगे के डेटा को स्टोर कर सकता है साथ ही ढेर। अगर कोई गड़बड़ी होती है, तो sp आगे कोई भी मूल्य "अप्रत्याशित रूप से" संशोधित हो सकता है।
उन्नत चाल: Z80 पर साथ PUSH 11 घड़ी चक्र (11t) ले रहे हैं और POP 10t ले, unrolled POP / PUSH सहित सभी रजिस्टर, गर्त EXX छाया वेरिएंट के लिए, स्मृति के ब्लॉक कॉपी करने के लिए सबसे तेज़ तरीका था, भी तेजी से unrolled से LDI । लेकिन आपको स्मृति भ्रष्टाचार से बचने के लिए बीच-बीच में संकेतों की नकल करनी थी। इसके अलावा अनियंत्रित PUSH ZX स्पेक्ट्रम पर विशेष मूल्य के साथ मेमोरी को भरने का सबसे तेज़ तरीका था (फिर से इंटरप्ट द्वारा भ्रष्टाचार का खतरा, अगर ठीक से समय पर नहीं, या DI तहत किया गया)।
