कंडीशनल
RFLAGs
rflags नाम का एक विशेष रजिस्टर होता है।
इसके बिट विभिन्न शर्तों के लिए फ्लैग की तरह काम करते हैं।
इनमें से कुछ नीचे दिए गए हैं:
| नाम |
प्रतीक |
बिट |
| carry |
CF |
0 |
| zero |
ZF |
6 |
| sign |
SF |
7 |
| overflow |
OF |
11 |
तुलना के निर्देश
rflags के फ्लैग सीधे नहीं बदले जाते।
इसके बजाय, उन्हें कई अलग-अलग निर्देश सेट करते हैं।
उदाहरण के लिए, जब परिणाम शून्य होता है, तो कई अंकगणितीय या बिटवाइज़ ऑपरेशन ZF को सेट करते हैं।
शर्तों की जाँच के लिए सबसे आम निर्देशों में से एक है cmp।
यह दो ऑपरेंड लेता है और फ्लैग अपडेट करता है, लेकिन अपने ऑपरेंड नहीं बदलता।
CMP निर्देश
cmp निर्देश पहले ऑपरेंड में से दूसरा ऑपरेंड घटाता है और परिणाम के अनुसार फ्लैग सेट करता है।
यदि A पहला ऑपरेंड है और B दूसरा:
| फ्लैग |
कब सेट होता है |
| CF |
A < B (अनसाइन्ड) |
| ZF |
A == B |
| SF |
A < B (साइन्ड, कोई ओवरफ्लो नहीं) |
| OF |
साइन्ड घटाव में ओवरफ्लो |
ब्रांचिंग
डिफ़ॉल्ट रूप से, x86-64 में कोड ऊपर से नीचे क्रम से चलता है।
लेकिन ऐसी कई स्थितियाँ होती हैं जहाँ इस व्यवहार को बदलना ज़रूरी होता है।
उदाहरण के लिए, किसी शर्त के आधार पर निर्देशों का कोई अलग समूह चलाने के लिए।
उच्च-स्तरीय भाषाओं में यह आमतौर पर if...else कंडीशनल जैसे एब्स्ट्रैक्शन के ज़रिए किया जाता है।
लेकिन x86-64 में ये मौजूद नहीं होते।
इसके बजाय, x86-64 ऐसे निर्देश देता है जो असल में निष्पादन को कोड की किसी दूसरी जगह पर स्थानांतरित कर देते हैं।
इसे branching कहते हैं।
हम ऐसे दो निर्देश पहले ही देख चुके हैं: call और ret।
जब किसी फंक्शन को कॉल किया जाता है, तो निष्पादन कॉल करने वाले से कॉल किए गए फंक्शन को चला जाता है।
और लौटते समय, निष्पादन वापस कॉल करने वाले को चला जाता है।
अगर कोई ret नहीं मिलता, तो निष्पादन एक फंक्शन से आगे अगले फंक्शन में चलता रहता है।
इसका इस्तेमाल कभी-कभी कोड के प्रवाह को अनुकूलित करने के लिए किया जा सकता है।
बिना शर्त जंप
jmp निर्देश प्रोग्राम के निष्पादन को बिना किसी शर्त के कोड के किसी दूसरे बिंदु पर स्थानांतरित कर देता है।
इसका एकमात्र ऑपरेंड एक लेबल होता है, जिसमें उस बिंदु का एड्रेस होता है जहाँ से निष्पादन आगे जारी रहेगा।
उदाहरण के लिए, इस फंक्शन को देखिए:
fn:
mov rax, 5
jmp end
add rax, 10
end:
ret
जब fn को कॉल किया जाता है, तो निष्पादन mov rax, 5 से शुरू होता है।
इससे उस बिंदु पर rax की वैल्यू 5 हो जाती है।
अगला निर्देश jmp end है, जो निष्पादन को लेबल end पर स्थानांतरित कर देता है।
end के बाद अगला निर्देश ret है, जो निष्पादन को वापस कॉल करने वाले फंक्शन पर स्थानांतरित कर देता है।
ध्यान दीजिए कि चूँकि add rax, 10 jmp end के बाद और end से पहले है, यह कभी चलाया नहीं जाता।
जब fn लौटता है, तब rax की वैल्यू 5 होती है।
शर्तीय जंप
jcc निर्देशों का समूह प्रोग्राम के निष्पादन को किसी दूसरे बिंदु पर केवल तभी स्थानांतरित करता है जब कोई विशेष शर्त पूरी होती है।
अन्यथा, निष्पादन क्रम से आगे बढ़ता रहता है।
हर शर्त rflags के एक या अधिक फ्लैग से जुड़ी होती है।
jcc के कुछ रूप जाँचते हैं कि कोई फ्लैग सेट है, और कुछ जाँचते हैं कि वह क्लियर है।
jcc में cc शब्दशः नहीं है, बल्कि उस विशेष प्रत्यय की ओर संकेत करता है जो जाँचे जाने वाले फ्लैग से जुड़ा होता है।
कई प्रत्यय हैं, और उनमें से कई वही शर्त जाँचते हैं जो कोई दूसरा प्रत्यय जाँचता है।
इनमें से कुछ सीधे किसी फ्लैग की ओर संकेत करते हैं, जिससे निर्देश किसी लेबल पर जंप करता है यदि वह विशेष फ्लैग सेट हो:
| प्रत्यय |
कब जंप करता है |
| z |
ZF == 1 |
| c |
CF == 1 |
| s |
SF == 1 |
| o |
OF == 1 |
कई अन्य इस तरह चुने गए हैं कि वे cmp निर्देश में अपने अर्थ की ओर संकेत करें।
उदाहरण के लिए:
| निर्देश |
प्रत्यय |
कब जंप करता है |
| cmp A, B |
e |
A == B |
| cmp A, B |
l |
A < B (साइन्ड) |
| cmp A, B |
b |
A < B (अनसाइन्ड) |
| cmp A, B |
g |
A > B (साइन्ड) |
| cmp A, B |
a |
A > B (अनसाइन्ड) |
शर्त में समानता शामिल करने के लिए l, b, g या a के बाद e जोड़ना संभव है:
cmp rcx, r8
jge two ; this jumps to 'two' if rcx is greater than, or equal to, r8 in a signed comparison
jbe two ; this jumps to 'two' if rcx is lesser than, or equal to, r8 in an unsigned comparison
सभी प्रत्ययों के लिए ऐसे रूप भी होते हैं जो उलटा व्यवहार जाँचते हैं।
उनका सिंटैक्स वही होता है, लेकिन प्रत्यय से पहले एक n होता है।
उदाहरण के लिए, jnz तब जंप करता है जब ZF सेट न हो।
इसी तरह, jnae तब जंप करता है जब A, B से >= न हो (A और B को अनसाइन्ड पूर्णांक मानते हुए)।
कुछ प्रत्यय एक ही शर्तों के दूसरे नाम होते हैं।
उदाहरण के लिए, jz (प्रत्यय z, ZF के लिए) और je (प्रत्यय e, बराबरी के लिए) दोनों तब जंप करते हैं जब ZF सेट हो।
इसका कारण यह है कि cmp में ZF तब सेट होता है जब घटाने का परिणाम शून्य होता है, और इसका मतलब है कि दोनों ऑपरेंड बराबर हैं।
लेकिन कुछ अन्य प्रत्यय फ्लैग के किसी संयोजन को जाँचते हैं, और उनकी जगह सीधे किसी एक फ्लैग वाले प्रत्यय का उपयोग नहीं किया जा सकता।
अपनी तुलना का अर्थ जो प्रत्यय सबसे अच्छी तरह बताता हो, उसे चुनिए।
स्थानीय लेबल
लेबल पूरी सोर्स फाइल में दिखाई देते हैं, वे किसी फंक्शन तक ही सीमित नहीं होते।
इसलिए किसी लेबल के नाम को दोबारा इस्तेमाल करना संभव नहीं है।
किसी स्थानीय लेबल का व्यवहार उतारने के लिए NASM में एक विशेष संकेतन है, जिसमें लेबल से पहले एक बिंदु (.) लगाकर उसे घोषित किया जाता है।
यह संकेतन ऐसा लेबल परिभाषित करता है जिसमें अपने आप पिछले बिना बिंदु वाले लेबल का नाम शामिल हो जाता है:
section .text
fn1:
...
.example: ; this is fn1.example
...
ret
fn2:
...
.example: ; this is fn2.example
...
ret
फिर भी कोड में कहीं से भी पूरा लेबल नाम इस्तेमाल करके इस लेबल पर जंप करना संभव है, उदाहरण के लिए jmp fn1.example।
लेकिन जो जंप लेबल के बिंदु से शुरू होने वाले हिस्से का इस्तेमाल करता है, वह ऊपरी फंक्शन के अंदर वाले लेबल पर जाता है।
उदाहरण के लिए, .example ऐसे व्यवहार करता है जैसे वह उस फंक्शन तक ही सीमित हो:
section .text
fn1:
...
.example:
...
jmp .example ; this jumps to fn1.example
fn2:
...
.example:
...
jmp .example ; this jumps to fn2.example
सीखने का अभ्यास
