इन्वेंटरी प्रबंधन

पूर्णांक

द्विआधारी संकेतन

पूर्णांक एक ऐसी अवधारणा है जो पूर्ण संख्याओं को दर्शाती है, जैसे 4, -2, 0 या 64532।

किसी पूर्णांक को बाइटों के क्रम के रूप में दर्शाने के लिए द्विआधारी संकेतन का उपयोग किया जाता है। इस संकेतन में क्रम का हर बिट दो की एक अलग घात दर्शाता है। बिट का इंडेक्स दाएँ से बाएँ बढ़ने पर उसकी वैल्यू भी बढ़ती जाती है।

अचिह्नित संख्याएँ

अगर कोई संख्या केवल ऋणेतर हो सकती है, तो उसे अचिह्नित संख्या कहा जाता है।

अचिह्नित संख्या को दर्शाने के लिए उसके क्रम में जो बिट सेट हैं, उन सबसे जुड़ी दो की घातों को जोड़ दिया जाता है।

एक रजिस्टर में दर्शाए जा सकने वाले ऋणेतर पूर्णांकों की सीमा 0 (कोई बिट सेट नहीं) से लेकर 2⁶⁴ - 1 (सभी 64 बिट सेट होने का योग) तक होती है।

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

movzx इंस्ट्रक्शन (z शून्य के लिए) किसी 8-बिट या 16-बिट स्रोत ऑपरेंड का शून्य विस्तार करके उसे बड़े गंतव्य ऑपरेंड में बदल देता है। 32-बिट स्रोत ऑपरेंड का शून्य विस्तार साधारण mov से हमेशा गंतव्य ऑपरेंड के सभी 64 बिटों तक हो जाता है।

चिह्नित संख्याएँ

अगर कोई पूर्णांक धनात्मक या ऋणात्मक दोनों वैल्यू ले सकता है, तो उसे चिह्नित संख्या कहा जाता है।

ऋणात्मक संख्याओं को दर्शाने के लिए x86-64 दो का पूरक निरूपण इस्तेमाल करता है।

दो के पूरक में भी चिह्नित संख्याओं को उनके सेट बिटों से जुड़ी दो की घातों के योग के रूप में दर्शाया जाता है। लेकिन अगर सबसे ऊपरी बिट सेट हो, तो उसे बाकी बिटों में जोड़ने के बजाय घटाया जाता है।

यह बिट बाकी सबके योग से भी बड़ी वैल्यू दर्शाता है, इसलिए व्यवहार में इसका मतलब है कि जिस संख्या में यह बिट सेट हो, वह हमेशा ऋणात्मक होती है। इस खास बिट को चिह्न बिट कहा जाता है।

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

movsx इंस्ट्रक्शन (s चिह्न के लिए) किसी 8-बिट या 16-बिट स्रोत ऑपरेंड का चिह्न विस्तार करके उसे बड़े गंतव्य ऑपरेंड में बदल देता है। movsx का ही एक रूप movsxd यही काम 32-बिट स्रोत ऑपरेंड से 64-बिट गंतव्य ऑपरेंड के लिए करता है।

किसी संख्या का चिह्न बदलने के लिए neg इंस्ट्रक्शन का उपयोग किया जा सकता है।

इमीडिएट

पिछली किसी अवधारणा में बताया गया था कि 4 या -15 जैसी अचर संख्या कई इंस्ट्रक्शनों में स्रोत ऑपरेंड के रूप में इस्तेमाल की जा सकती है। ऐसी संख्याओं को इमीडिएट कहा जाता है।

इमीडिएट किसी रजिस्टर या मेमोरी में नहीं रहता। वह इंस्ट्रक्शन के अंदर ही एनकोड किया जाता है। ज़्यादातर इंस्ट्रक्शनों में इसके लिए रखी जगह सिर्फ 32 बिट चौड़ी होती है, चाहे गंतव्य ऑपरेंड कितना भी बड़ा हो।

जब गंतव्य ऑपरेंड 64 बिट चौड़ा होता है, तो उन 32 बिटों का चिह्न विस्तार करके उसे भर दिया जाता है। ऑपरेंड का ऊपरी आधा हिस्सा पूरी तरह इमीडिएट के सबसे ऊपरी बिट की प्रतियों से भर दिया जाता है। इसलिए इस तरह सिर्फ 32-बिट चिह्नित पूर्णांक की सीमा में आने वाली संख्या ही लिखी जा सकती है:

add rax, -1          ; the immediate is sign-extended, so all 64 bits of rax are affected
add rax, 2147483647  ; the largest immediate an instruction like this accepts

उस सीमा से बाहर की संख्या इमीडिएट के रूप में इस्तेमाल नहीं की जा सकती। इस नियम का अपवाद mov है, जो तब पूरा 64-बिट इमीडिएट ले सकता है जब गंतव्य ऑपरेंड एक रजिस्टर हो। अगर 64-बिट इमीडिएट की ज़रूरत हो, तो पहले mov से उसे किसी रजिस्टर में लोड कीजिए, फिर उस रजिस्टर का इस्तेमाल कीजिए:

mov rax, 3435973837           ; this works, mov can take a 64-bit immediate
mov rdx, 18446744073709551615 ; the largest immediate mov accepts
sub rdx, rax

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

mov rax, -1                   ; rax = 18446744073709551615
mov rax, 18446744073709551615 ; rax = -1

योग

दो संख्याओं का जोड़ add इंस्ट्रक्शन से निकाला जा सकता है।

एक ऑपरेंड वाला inc इंस्ट्रक्शन भी है, जो अपने ऑपरेंड की वैल्यू में 1 जोड़ देता है:

inc rax ; rax = rax + 1

दो पूर्णांकों का योग अचिह्नित और चिह्नित, दोनों तरह की संख्याओं के लिए एक ही तरह से काम करता है।

घटाव

दो पूर्णांकों का घटाव sub इंस्ट्रक्शन से किया जाता है।

एक ऑपरेंड वाला dec इंस्ट्रक्शन भी है, जो अपने ऑपरेंड की वैल्यू से 1 घटा देता है:

dec rax ; rax = rax - 1

दो पूर्णांकों का घटाव भी अचिह्नित और चिह्नित, दोनों तरह की संख्याओं के लिए एक ही तरह से काम करता है।

गुणा

x86-64 में दो संख्याओं का गुणा करने के लिए दो अलग इंस्ट्रक्शन हैं। सामान्यतः अचिह्नित गुणा में mul इंस्ट्रक्शन इस्तेमाल होता है, और चिह्नित गुणा में imul।

mul इंस्ट्रक्शन नीचे दिया गया एक-ऑपरेंड रूप लेता है, जिसमें src स्रोत ऑपरेंड है:

mul src

imul इंस्ट्रक्शन एक-ऑपरेंड, दो-ऑपरेंड या तीन-ऑपरेंड रूप ले सकता है:

imul src
imul dest, src
imul dest, src1, src2

एक-ऑपरेंड गुणा

एक-ऑपरेंड रूप में गुणा करने के लिए दो रजिस्टर अपने आप इस्तेमाल होते हैं: rax और rdx। अगर गुणा में दो 64-बिट संख्याएँ शामिल हों, तो नतीजे के निचले 64 बिट rax में और ऊपरी 64 बिट rdx में होंगे।

इसे आमतौर पर rdx:rax कहा जाता है, जो बताता है कि दोनों रजिस्टर साथ मिलकर काम करते हैं:

mul rcx ; rax = lower 64 bits of rax * rcx
        ; rdx = upper 64 bits of rax * rcx

बाकी ऑपरेंड आकारों के साथ भी ऐसा ही होता है। जैसे अगर दो 32-बिट संख्याओं का गुणा हो रहा हो, तो eax और edx इस्तेमाल होंगे।

अपवाद दो बाइटों के बीच के गुणा का है।

इस स्थिति में dl:al के बजाय ax इस्तेमाल होता है। ax के निचले हिस्से (al) में गुणनफल के निचले 8 बिट जाएँगे, और ऊपरी हिस्से (ah) में ऊपरी 8 बिट।

दो-ऑपरेंड गुणा

imul के दो-ऑपरेंड रूप में गंतव्य ऑपरेंड स्पष्ट रूप से दिया जाता है और यह सामान्य सिंटैक्स का पालन करता है। इसमें rdx इस्तेमाल नहीं होता। इसके बजाय नतीजे को गंतव्य ऑपरेंड में फिट होने लायक छोटा कर दिया जाता है।

imul r8, r9 ; r8 = lower 64 bits of r8 * r9

तीन-ऑपरेंड गुणा

imul के तीन-ऑपरेंड रूप में दो स्रोत ऑपरेंड होते हैं, जिनमें दूसरा हमेशा एक इमीडिएट (अचर संख्या) होता है। दोनों स्रोत ऑपरेंडों का गुणा किया जाता है और नतीजे को छोटा करके गंतव्य ऑपरेंड में रख दिया जाता है:

imul r8, r9, 100 ; r8 = lower 64 bits of r9 * 100

ध्यान दीजिए कि गुणा में गंतव्य ऑपरेंड इस्तेमाल नहीं होता। वह सिर्फ नतीजा लेता है।

ओवरफ्लो को संभालना

दो-ऑपरेंड और तीन-ऑपरेंड, दोनों गुणा नतीजे को गंतव्य ऑपरेंड के आकार में फिट होने लायक छोटा कर देते हैं। एक-ऑपरेंड गुणा पूरी सीमा बनाए रखता है, लेकिन वह आमतौर पर दो रजिस्टरों, rdx और rax, में बाँटा जाता है।

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

movzx eax, di ; di and si hold unsigned 16-bit numbers
movzx ecx, si
mul ecx       ; the 32-bit product fits in eax, and edx is cleared

भाग

गुणा की तरह भाग के लिए भी दो इंस्ट्रक्शन हैं। अचिह्नित भाग में div इंस्ट्रक्शन इस्तेमाल होता है, और चिह्नित भाग में idiv।

दोनों इंस्ट्रक्शन सिर्फ एक ऑपरेंड के साथ काम करते हैं:

div src
idiv src

16-बिट, 32-बिट और 64-बिट भाग में क्रमशः dx:ax, edx:eax और rdx:rax को भाज्य माना जाता है। इन स्थितियों में दोनों रजिस्टर साथ मिलकर एक 2N-बिट वैल्यू बनाते हैं, जहाँ N उस काम का आकार है (16-बिट, 32-बिट या 64-बिट)। फिर इस वैल्यू को स्रोत ऑपरेंड से भाग दिया जाता है। काम के आकार के हिसाब से भागफल ax, eax या rax में लिखा जाता है, और शेष dx, edx या rdx में।

बाइटों के बीच का भाग खास है: इसमें dl:al के बजाय ax इस्तेमाल होता है। ax के निचले 8 बिट (al) में भाग का भागफल जाएगा, और ऊपरी 8 बिट (ah) में शेष।

ध्यान दीजिए कि भाग से पहले भाज्य के सभी बिट ठीक से सेट होने चाहिए। rdx में सेट कोई भी बिट (या 8-बिट भाग में ah में सेट बिट) उस वैल्यू में जुड़ता है जिसका भाग किया जा रहा है।

अचिह्नित भाग में, जब जिस वैल्यू का भाग करना है वह निचले आधे हिस्से में समा जाए, तो ऊपरी आधा हिस्सा शून्य कर देना चाहिए। इन बिटों को शून्य करने वाला कोई भी इंस्ट्रक्शन चलेगा। जैसे 32-बिट भाग में mov edx, 0 ऊपरी बिटों को शून्य कर देता है।

चिह्नित भाग में इसके बजाय वैल्यू का चिह्न विस्तार करना चाहिए। इस काम को अपने आप करने वाले इंस्ट्रक्शन भी हैं: cbw, cwd, cdq और cqo। पहला al के चिह्न के हिसाब से ah के बिट सेट करता है। बाकी तीन क्रमशः ax से dx, eax से edx और rax से rdx तक चिह्न विस्तार करते हैं।