সরাসরি পর্বে যান
পর্ব ১৮ · ৮৫-এর মধ্যে · মডিউল ৩

8086-এর procedure, stack frame আর macro

8086 Procedures, Stack Frames and Macros

Taught in Bangla, this lesson covers 8086 procedures: near and far CALL with RET and RETF, passing parameters in registers, memory and the stack, caller versus callee cleanup, and BP-based stack frames with locals. Programs assembled with NASM and run on Unicorn show the stack during recursive factorial, a NASM listing compares macro and procedure size, a macro label bug is reproduced, and a procedure that keeps state in a global is shown to be non-reentrant.

এই পর্বে যা শিখবেন

  • Near আর far CALL/RET-এর encoding আর প্রতিটির পরে stack-এ কী থাকে, তা বলা
  • Register, মেমরি আর stack দিয়ে parameter পাঠানো, আর caller বনাম callee-র stack পরিষ্কারের নিয়ম বোঝা
  • BP দিয়ে stack frame বানানো, [bp+n]-এ parameter আর [bp-n]-এ local variable খুঁজে পাওয়া
  • Recursive factorial-এর প্রতিটি frame ধাপে ধাপে ট্রেস করা আর stack-এর গভীরতা হিসাব করা
  • NASM %macro আর MASM MACRO লেখা, macro আর procedure-এর লাভ-ক্ষতি মাপা, আর reentrant procedure চেনা

১ · Procedure কেন — একই কাজ, একটি কপি

বাজারঘরের smart scale প্রতিবার ওজন বদলালে দাম হিসাব করে: price = (net_g × 6550 + 500) ÷ 1000 পয়সা (reference lab-এর README, “বাজারঘর devices”). দোকানের program-এ এই হিসাব লাগে অনেক জায়গায়: ওজন দেখানোর সময়, রসিদ ছাপার সময়, দিনের মোট বিক্রির হিসাবে। প্রতিটি জায়গায় একই সাতটি নির্দেশ লিখে রাখা যায়, আবার একবার লিখে বারবার “ডেকে” আনাও যায়। দ্বিতীয় পথের নাম procedure: নাম দেওয়া এক টুকরো কোড, যাকে CALL দিয়ে ডাকা হয় আর কাজ শেষে RET দিয়ে ডাকার জায়গার পরে ফেরা হয়। 8085-এর ভাষায় একে বলা হতো subroutine; 8086-এর বই আর MASM-এ “procedure” শব্দটি বেশি চলে, মানে একই।

উপমা — দোকানের হিসাবরক্ষক আর দামের কার্ড: বাজারঘরে দুইভাবে দাম বের করা যায়। এক, দোকানে একজন হিসাবরক্ষক বসেন। যেকোনো কর্মচারী তাঁর কাছে ওজন লেখা চিরকুট পাঠান, তিনি হিসাব করে দাম লিখে ফেরত দেন, আর কর্মচারী ঠিক যেখানে কাজ থামিয়েছিলেন সেখান থেকে আবার শুরু করেন। হিসাবরক্ষক একজনই, কিন্তু প্রতিবার ডাকতে আর ফিরতে একটু সময় যায়: এটি procedure. দুই, প্রতিটি কাউন্টারে দাম বের করার নিয়ম ছাপানো একটি কার্ড রাখা থাকে, কর্মচারী নিজেই সেখানে দেখে হিসাব করেন। কাউকে ডাকতে হয় না, কিন্তু যত কাউন্টার তত কার্ড ছাপাতে হয়: এটি macro. এই পর্বের শেষে দেখবেন, দুটির লাভ-ক্ষতি সত্যিই byte গুনে মাপা যায়।

পূর্বজ্ঞান এক লাইনে: 8085-এর stack, CALL, RET, PUSH আর POP পর্ব ১২-এ (এখানে আবার শেখানো হবে না, শুধু তুলনা); 8086-এর register, SS:SP আর physical address পর্ব ১৪-এ; BP দিলে ডিফল্ট segment কেন SS, তা পর্ব ১৫-এ; MUL আর DIV-এর register-এর নিয়ম পর্ব ১৬-এ; আর NASM-এর .COM program-এর কাঠামো পর্ব ১৭-এ। লেখার নিয়ম আগের মতো: hex Intel-এর ধরনে শেষে H দিয়ে (FFFEH), কোডে NASM-এর ধরনে ছোট h দিয়ে (0FFFEh). Stack-এর ঠিকানা লেখা হবে শুধু offset দিয়ে, কারণ lab-এ পুরো সময় SS = 1000H (Spec decision 13).

বিষয়8085 (পর্ব ১২)8086 (এই পর্ব)
ডাকার ধরনএকটিই: ১৬ বিটের ঠিকানায় CALLnear (একই segment) আর far (অন্য segment)
ফেরার ঠিকানাPC, ২ bytenear: IP (২ byte); far: CS আর IP (৪ byte)
Stack-এর ভেতরে পড়াSP-ভিত্তিক ঠিকানা নেই; XTHL, LXI H,0 / DAD SP-এর মতো কৌশলBP দিয়ে সরাসরি: [bp+4], [bp-2]
ফেরার সময় parameter সরানোনেইRET n: ফিরে SP-তে n যোগ
শর্তযুক্ত ডাকআছে (CZ, CNC …)নেই; Jcc দিয়ে ঘুরিয়ে CALL

শেষ সারিটি অনেকে ভুলে যান: 8085-এর মতো CZ বা RNC জাতীয় শর্তযুক্ত CALL/RET 8086-এ নেই। Intel এর বদলে দিয়েছে আরও শক্তিশালী একটি জিনিস: BP register দিয়ে stack-এর যেকোনো word সরাসরি পড়া আর লেখা। এই ক্ষমতাই 8086-এ C-এর মতো ভাষার function-কে সহজ করেছে, আর এই পর্বের বেশিরভাগ জুড়ে আছে সেটিই।

MASM-এ (অনেক বই আর পরীক্ষার প্রশ্ন যে ধাঁচে লেখা) procedure-এর শুরু আর শেষ directive দিয়ে চিহ্নিত হয়, আর ধরন বলে দিতে হয় NEAR না FAR. NASM-এ এমন কিছু নেই: procedure মানে শুধু একটি label, আর ফেরার নির্দেশ কোনটি হবে (ret না retf), তা programmer নিজে লেখেন। নিচের MASM কোডটি শুধু লেখার ধরন দেখাতে (উদাহরণ, চালানো হয়নি; কোর্সের lab শুধু NASM চালায়):

; MASM style - not run (the course lab uses NASM)
PRICE_P  PROC NEAR          ; FAR here would make RET assemble as RETF
         MOV  CX, 6550
         MUL  CX
         ADD  AX, 500
         ADC  DX, 0
         MOV  CX, 1000
         DIV  CX
         RET
PRICE_P  ENDP
         ...
         CALL PRICE_P       ; NASM: call price_p (label only)

২ · Near আর far CALL — stack-এ কী যায়

8086-এর ঠিকানা segment:offset জোড়ায় (পর্ব ১৪)। তাই একটি procedure দুই রকম জায়গায় থাকতে পারে। একই code segment-এ থাকলে CS বদলাতে হয় না, শুধু IP বদলায়: একে বলে near call (Intel-এর manual-এ intrasegment). অন্য segment-এ থাকলে CS আর IP দুটিই বদলাতে হয়: far call (intersegment). ফেরার সময় একই কথা উল্টো দিকে: near ফেরায় stack থেকে শুধু IP তোলা হয়, far ফেরায় IP আর CS দুটিই। Intel-এর 8086 family user's manual-এর encoding এই রকম:

নির্দেশOpcodeStack-এ কী হয়নতুন CS:IP
near direct CALLE8 + ১৬ বিটের দূরত্বIP pushCS একই; IP = পরের IP + দূরত্ব
near indirect CALLFF /2IP pushIP = register বা মেমরির word
far direct CALL9A + offset + segmentCS push, তারপর IP pushনির্দেশে লেখা segment:offset
far indirect CALLFF /3CS push, তারপর IP pushমেমরির দুই word (offset, segment)
near RET · RET nC3 · C2 + nIP pop; তারপর SP += nCS একই
far RETF · RETF nCB · CA + nIP pop, CS pop; তারপর SP += nstack থেকে

Near direct CALL-এ ঠিকানাটি লেখা থাকে দূরত্ব হিসেবে, পরের নির্দেশের IP থেকে কত byte. এতে program-কে segment-এর ভেতরে যেকোনো জায়গায় সরালেও নির্দেশের byte বদলাতে হয় না। দুটি রূপ একসঙ্গে দেখতে নিচের ছোট program-টি একই “দ্বিগুণ করা”-র কাজ একবার near আর একবার far procedure দিয়ে করে। এখানে far procedure-টিও একই segment-এ (1000H), শুধু ডাকার ধরন আলাদা, যাতে stack-এর পার্থক্যটি পরিষ্কার দেখা যায়।

; far86.asm - near vs far CALL: what goes on the stack
        org 100h
        mov ax, 1250
        call near_dbl       ; E8 rel16: pushes IP
        call 1000h:far_dbl  ; 9A off seg: pushes CS, then IP
        hlt

near_dbl:
        add ax, ax
        ret                 ; C3: pops IP

far_dbl:
        add ax, ax
        retf                ; CB: pops IP, then CS

সত্যিকারের run (run8086.py, NASM 3.02, Unicorn 2.1.4; trace থেকে শুধু AX, CS, IP, SP রাখা হয়েছে, যাতে লাইন ছোট থাকে):

$ python -B run8086.py far86.asm --trace --mem 1000:FFFA,4
1000:0100 B8E204     mov ax,0x4e2       AX=04E2 CS=1000 IP=0103 SP=FFFE
1000:0103 E80600     call 0x10c         AX=04E2 CS=1000 IP=010C SP=FFFC
1000:010C 01C0       add ax,ax          AX=09C4 CS=1000 IP=010E SP=FFFC
1000:010E C3         ret                AX=09C4 CS=1000 IP=0106 SP=FFFE
1000:0106 9A0F010010 call word 0x1000:word 0x10f AX=09C4 CS=1000 IP=010F SP=FFFA
1000:010F 01C0       add ax,ax          AX=1388 CS=1000 IP=0111 SP=FFFA
1000:0111 CB         retf               AX=1388 CS=1000 IP=010B SP=FFFE
----
----
1000:FFFA  0B 01 00 10
[exit code 0 via HLT, 8 instructions]

NASM-এর অনুবাদ দেখুন। E8 06 00: দূরত্ব 0006H, আর পরের নির্দেশ 0106H-এ, তাই লক্ষ্য 0106H + 0006H = 010CH. 9A 0F 01 00 10: আগে offset 010FH, তারপর segment 1000H, দুটিই little-endian. শেষ লাইনের মেমরিতে 0B 01 00 10: far call রেখে গেছে IP = 010BH (নিচের ঠিকানায়) আর CS = 1000H (ওপরের ঠিকানায়)। নিচের stepper-এ চারটি মুহূর্ত ধরে দেখুন।

নির্দেশের পরে
নির্দেশ
CS:IP
SP
FFFCH-এর word
FFFAH-এর word
AX
  1. Near call: দুই byte. CPU পরের নির্দেশের IP, 0106H, stack-এ রাখে: SP = FFFEH − 2 = FFFCH. তারপর IP = 010CH. CS ছোঁয়া হয়নি, তাই একটি word-ই যথেষ্ট।
  2. Near ret. add ax,ax AX-কে 09C4H (2500) করেছে। ret FFFCH থেকে 0106H তুলে IP-তে দেয়, SP = FFFEH. মেমরিতে 0106H রয়ে যায়; pop মোছে না, শুধু SP সরায়।
  3. Far call: চার byte. আগে CS (1000H) যায় FFFCH-এ, পুরোনো 0106H-এর ওপর লিখে; তারপর IP (010BH) যায় FFFAH-এ। SP = FFFAH. নতুন CS:IP নির্দেশ থেকে: 1000H:010FH.
  4. Retf. উল্টো ক্রমে: আগে IP = 010BH, তারপর CS = 1000H, SP আবার FFFEH. AX = 1388H = 5000, স্কেলের capacity-র সমান। Near procedure-এ ভুল করে retf দিলে সে CS হিসেবে একটি আবর্জনা word তুলত।

সাবধান: ডাকা আর ফেরার ধরন মিলতেই হবে। Near CALL দুই byte রাখে; procedure যদি RETF দিয়ে ফেরে, তাহলে ফেরার IP-র পরের word-টি, যা হয়তো একটি parameter, CS হয়ে যায়, আর CPU সম্পূর্ণ অন্য segment-এ লাফ দেয়। উল্টোটায় (far call, near ret) CS stack-এ পড়ে থাকে, আর caller-এর প্রতিটি পরের POP এক word সরে যায়। MASM এই ভুল আটকাতে PROC FAR-এর ভেতরের RET-কে নিজেই RETF বানায়; NASM-এ দায়িত্ব পুরোটা আপনার।

আরেকটি রূপ মনে রাখার মতো: indirect call. call bx বা call [table+bx] লিখলে লক্ষ্য ঠিকানা চলার সময় register বা মেমরি থেকে আসে। Menu-র কোন বোতামে কোন কাজ, তা একটি টেবিলে রেখে এভাবে ডাকা যায়; C-এর function pointer আর পর্ব ২০-এর interrupt vector table একই ধারণার রূপ।

৩ · Parameter পাঠানো — register, মেমরি আর stack

Procedure-কে কাজের জন্য তথ্য দিতে হয়: কত গ্রাম, কোন দর। এই তথ্যকে বলে argument বা parameter. 8086-এ তিনটি পথ চালু ছিল, আর প্রতিটির নিজের লাভ-ক্ষতি আছে:

পথউদাহরণলাভসমস্যা
RegisterAX = ওজন, তারপর call price_pসবচেয়ে দ্রুত, মেমরি লাগে নাregister মাত্র কয়েকটি; procedure ভেতরে register নষ্ট করলে caller বিপদে
নির্দিষ্ট মেমরিmov [w], ax, তারপর callঅনেক data পাঠানো যায়একই ঘর সবার: recursion আর interrupt-এ ভাঙে (অংশ ৭)
Stackpush করে callপ্রতিটি ডাক নিজের কপি পায়; recursion চলেএকটু ধীর; কে stack পরিষ্কার করবে, তা আগে ঠিক করতে হয়

কোন পথে, কোন ক্রমে, আর কে পরিষ্কার করবে, এই নিয়মের সেটকে বলে calling convention. একই program-এর সব অংশ, আর একাধিক ভাষায় লেখা অংশ জুড়লে সবাইকে, একই নিয়ম মানতে হয়। আধুনিক ABI-তে এই চুক্তি কেমন দাঁড়িয়েছে, তা পড়তে পারেন Programming Languages & Compilers পর্ব ৭১-এ। এখানে আমরা stack-এর পথটি হাতে করে দেখি। Smart scale-এর দাম, দুটি parameter stack-এ: আগে দর, তারপর ওজন।

; call2.asm - near CALL with two stack parameters (BP frame)
        org 100h
        mov ax, 6550        ; rate, paisa per kg
        push ax             ; 2nd parameter
        mov ax, 1250        ; net weight, g
        push ax             ; 1st parameter
        call price          ; near CALL: pushes IP only
        add sp, 4           ; caller removes 2 parameters
        hlt

price:  push bp
        mov bp, sp          ; [bp+4] = weight, [bp+6] = rate
        mov ax, [bp+4]
        mul word [bp+6]     ; DX:AX = weight x rate
        add ax, 500         ; round half up
        adc dx, 0
        mov cx, 1000
        div cx              ; AX = paisa
        pop bp
        ret

সত্যিকারের run (AX, DX, BP, SP, IP রাখা; শেষে stack-এর দশটি byte):

$ python -B run8086.py call2.asm --trace --mem 1000:FFF6,10
1000:0100 B89619     mov ax,0x1996      AX=1996 DX=0000 BP=0000 SP=FFFE IP=0103
1000:0103 50         push ax            AX=1996 DX=0000 BP=0000 SP=FFFC IP=0104
1000:0104 B8E204     mov ax,0x4e2       AX=04E2 DX=0000 BP=0000 SP=FFFC IP=0107
1000:0107 50         push ax            AX=04E2 DX=0000 BP=0000 SP=FFFA IP=0108
1000:0108 E80400     call 0x10f         AX=04E2 DX=0000 BP=0000 SP=FFF8 IP=010F
1000:010F 55         push bp            AX=04E2 DX=0000 BP=0000 SP=FFF6 IP=0110
1000:0110 89E5       mov bp,sp          AX=04E2 DX=0000 BP=FFF6 SP=FFF6 IP=0112
1000:0112 8B4604     mov ax,[bp+0x4]    AX=04E2 DX=0000 BP=FFF6 SP=FFF6 IP=0115
1000:0115 F76606     mul word [bp+0x6]  AX=EE6C DX=007C BP=FFF6 SP=FFF6 IP=0118
1000:0118 05F401     add ax,0x1f4       AX=F060 DX=007C BP=FFF6 SP=FFF6 IP=011B
1000:011B 83D200     adc dx,0x0         AX=F060 DX=007C BP=FFF6 SP=FFF6 IP=011E
1000:011E B9E803     mov cx,0x3e8       AX=F060 DX=007C BP=FFF6 SP=FFF6 IP=0121
1000:0121 F7F1       div cx             AX=1FFC DX=0000 BP=FFF6 SP=FFF6 IP=0123
1000:0123 5D         pop bp             AX=1FFC DX=0000 BP=0000 SP=FFF8 IP=0124
1000:0124 C3         ret                AX=1FFC DX=0000 BP=0000 SP=FFFA IP=010B
1000:010B 83C404     add sp,0x4         AX=1FFC DX=0000 BP=0000 SP=FFFE IP=010E
----
----
1000:FFF6  00 00 0B 01 E2 04 96 19 00 00
[exit code 0 via HLT, 17 instructions]

ফল AX = 1FFCH = 8188 পয়সা = 81.88 টাকা, README-র মানের সঙ্গে হুবহু। আর SP শেষে আবার FFFEH: stack যেমন ছিল তেমন ফিরেছে। এবার ভেতরে কী ঘটল, ধাপে ধাপে।

নির্দেশের পরে (SS = 1000H)
নির্দেশ
SP · BP
AX · DX
stack
  1. দ্বিতীয় parameter আগে। দর 6550 = 1996H stack-এ যায়, SP = FFFCH. শেষ parameter আগে push করার কারণ পরের ধাপগুলোতে বোঝা যাবে।
  2. প্রথম parameter. ওজন 1250 = 04E2H, SP = FFFAH. এখন প্রথম parameter stack-এর মাথার কাছে, নিচের ঠিকানায়।
  3. Near call. ফেরার ঠিকানা 010BH (add sp,4-এর ঠিকানা) stack-এ, SP = FFF8H, IP = 010FH. Procedure এখন জানে না parameter কোথায়, শুধু জানে তারা SP-র ওপরে।
  4. push bp. Caller-এর BP (এখানে 0000H) বাঁচিয়ে রাখা হলো, কারণ BP এখনই বদলানো হবে। SP = FFF6H.
  5. mov bp,sp: frame তৈরি। BP = FFF6H, আর এখন থেকে BP নড়বে না। ওপরে গুনলে: [bp+2] ফেরার ঠিকানা, [bp+4] ওজন, [bp+6] দর। শেষেরটি আগে push করায় প্রথম parameter সবসময় [bp+4]-এ।
  6. Parameter পড়া। mov ax,[bp+4] দিল 1250, তারপর mul word [bp+6]: 1250 × 6550 = 8187500 = 007CEE6CH, DX:AX-এ। BP-ভিত্তিক ঠিকানা বলে segment SS (পর্ব ১৫)।
  7. গোল করে ভাগ। 500 যোগ, তারপর div cx (CX = 1000): AX = 1FFCH = 8188 পয়সা। এই সময়েও SP আর BP বদলায়নি; frame স্থির।
  8. pop bp. Caller-এর BP ফিরে এল (0000H), SP = FFF8H, ঠিক ফেরার ঠিকানার ওপর। এই ক্রম ভুল হলে ret ভুল word তুলবে।
  9. ret. IP = 010BH, SP = FFFAH. Procedure ফিরেছে, কিন্তু দুটি parameter এখনো stack-এ বসে আছে।
  10. add sp,4: caller পরিষ্কার করে। দুই word = ৪ byte বাদ, SP = FFFEH, শুরুর মান। মেমরিতে পুরোনো byte রয়ে গেছে (00 00 0B 01 E2 04 96 19), কিন্তু SP-র নিচের সবকিছু এখন “খালি” জায়গা।

নিচের ব্লক একই ধাপগুলো Python-এ একটি ছোট stack মডেল দিয়ে চালায়। এটি কোনো 8086 নয়, শুধু SP, BP আর word-এর হিসাব; উদ্দেশ্য হলো সত্যিকারের run-এর সংখ্যাগুলো নিজে বানিয়ে মেলানো।

# call2.asm-এর stack-এর ছোট মডেল: SS = 1000H, শুরুতে SP = FFFEH
mem = {0xFFFE: 0x0000}                 # lab-এর শুরুর word (Spec decision 13)
r = {"SP": 0xFFFE, "BP": 0x0000, "AX": 0, "IP": 0x0100}

def push(v):
    r["SP"] = (r["SP"] - 2) & 0xFFFF
    mem[r["SP"]] = v

def pop():
    v = mem[r["SP"]]
    r["SP"] = (r["SP"] + 2) & 0xFFFF
    return v                            # মেমরি মোছে না, শুধু SP সরে

def show(what):
    top = " ".join(f"{a:04X}H={mem[a]:04X}" for a in sorted(mem) if a >= r["SP"])
    print(f"{what:15} SP={r['SP']:04X} BP={r['BP']:04X} | {top}")

push(6550);   show("push 6550")
push(1250);   show("push 1250")
push(0x010B); show("call price")      # ফেরার ঠিকানা = CALL-এর পরের IP
push(r["BP"]); show("push bp")
r["BP"] = r["SP"]; show("mov bp,sp")
w, rate = mem[r["BP"] + 4], mem[r["BP"] + 6]
r["AX"] = (w * rate + 500) // 1000
print(f"  [bp+4]={w}  [bp+6]={rate}  AX={r['AX']} paisa = {r['AX']/100:.2f} Tk")
r["BP"] = pop(); show("pop bp")
r["IP"] = pop(); show("ret")
r["SP"] += 4;    show("add sp,4")
print(f"IP={r['IP']:04X}H, stack balanced: {r['SP'] == 0xFFFE}")
print("left in memory:", " ".join(f"{mem[a]:04X}" for a in sorted(mem)))

আসল আউটপুট (ব্রাউজারের Python):

push 6550       SP=FFFC BP=0000 | FFFCH=1996 FFFEH=0000
push 1250       SP=FFFA BP=0000 | FFFAH=04E2 FFFCH=1996 FFFEH=0000
call price      SP=FFF8 BP=0000 | FFF8H=010B FFFAH=04E2 FFFCH=1996 FFFEH=0000
push bp         SP=FFF6 BP=0000 | FFF6H=0000 FFF8H=010B FFFAH=04E2 FFFCH=1996 FFFEH=0000
mov bp,sp       SP=FFF6 BP=FFF6 | FFF6H=0000 FFF8H=010B FFFAH=04E2 FFFCH=1996 FFFEH=0000
  [bp+4]=1250  [bp+6]=6550  AX=8188 paisa = 81.88 Tk
pop bp          SP=FFF8 BP=0000 | FFF8H=010B FFFAH=04E2 FFFCH=1996 FFFEH=0000
ret             SP=FFFA BP=0000 | FFFAH=04E2 FFFCH=1996 FFFEH=0000
add sp,4        SP=FFFE BP=0000 | FFFEH=0000
IP=010BH, stack balanced: True
left in memory: 0000 010B 04E2 1996 0000

প্রতিটি SP আর BP-র মান সত্যিকারের trace-এর সঙ্গে মেলে, আর শেষ লাইন 0000 010B 04E2 1996 0000 হলো runner-এর --mem 1000:FFF6,10-এর 00 00 0B 01 E2 04 96 19 00 00, word হিসেবে পড়া। “stack balanced: True” মানে caller আর procedure মিলে যত push করেছে, তত word সরিয়েছে। যেকোনো procedure-এর প্রথম পরীক্ষা এটিই: ডাকার আগে আর পরে SP সমান কি না।

কে পরিষ্কার করবে — caller না procedure?

call2.asm-এ caller নিজে add sp,4 দিয়েছে। বিকল্প হলো procedure নিজে ret 4 দিয়ে ফেরা: RET n আগে IP তোলে, তারপর SP-তে n যোগ করে। দুটি প্রথাই ইতিহাসে চলেছে। C ভাষার প্রচলিত নিয়মে (প্রায়ই “cdecl” বলা হয়) parameter ডান থেকে বাঁয়ে push হয় আর caller পরিষ্কার করে; এতে printf-এর মতো যত খুশি parameter-এর function সম্ভব, কারণ কতগুলো push হয়েছে তা শুধু caller জানে। Pascal-ধাঁচের নিয়মে procedure RET n দিয়ে পরিষ্কার করে; প্রতিটি ডাকের জায়গায় add sp-এর তিন byte বাঁচে, কিন্তু parameter-এর সংখ্যা নির্দিষ্ট হতেই হয়। নিয়ম যা-ই হোক, দুই পক্ষ একসঙ্গে পরিষ্কার করলে বা কেউই না করলে SP সরে যায়, আর পরের RET ভুল ঠিকানায় যায়।

৪ · Stack frame — BP, local variable আর register রক্ষা

একটি ডাকের জন্য stack-এর যে অংশটুকু ব্যবহার হয়, parameter থেকে local variable পর্যন্ত, তাকে বলে stack frame. 8086-এ frame-এর নোঙর BP: procedure-এর শুরুতে push bp / mov bp,sp, তারপর যতই push-pop হোক, BP একই জায়গায় থাকে। এই শুরুর কয়েকটি নির্দেশকে বলে prologue, আর শেষের উল্টো কাজগুলোকে epilogue.

প্রশ্ন আসে, SP তো আছেই, BP কেন? দুটি কারণ। এক, SP প্রতিটি PUSH-এ বদলায়, তাই একই parameter-এর দূরত্ব বারবার বদলাত। দুই, আর এটি 8086-এর নিজস্ব সীমা: 8086-এ মেমরির ঠিকানা বানাতে base হিসেবে শুধু BX আর BP, index হিসেবে শুধু SI আর DI চলে (পর্ব ১৫)। SP সেখানে নেই। Course lab-এ mov ax, [sp+4] assemble করতে দিলে NASM 3.02 থেমে যায়:

$ python -B run8086.py spbase.asm
error: NASM failed:
../pm86/spbase.asm:3: error: invalid 16-bit effective address

তাই 8086-এ stack-এর ভেতরে পড়ার একমাত্র স্বাভাবিক পথ BP, আর BP দিয়ে তৈরি ঠিকানা ডিফল্টভাবে SS ধরে, যাতে DS আলাদা হলেও frame ঠিক জায়গায় পাওয়া যায়। Reference lab-এর stack_frame.asm পুরো একটি frame দেখায়: তিনটি parameter, একটি local variable আর একটি সংরক্ষিত register. Procedure-টি weighted(a, b, c) = 100·a + 10·b + c হিসাব করে:

        mov ax, 3
        push ax                 ; c  -> [bp+8]  (pushed first = highest address)
        mov ax, 2
        push ax                 ; b  -> [bp+6]
        mov ax, 1
        push ax                 ; a  -> [bp+4]  (pushed last)
        call weighted           ; callee removes the 3 arguments (ret 6)
        mov [result], ax
...
weighted:
        push bp
        mov bp, sp
        sub sp, 2               ; one local word at [bp-2]
        push bx                 ; callee-saved register
        mov ax, [bp+4]          ; a
        mov bx, 100
        mul bx
        mov [bp-2], ax          ; local = 100*a
        mov ax, [bp+6]          ; b
        mov bx, 10
        mul bx
        add ax, [bp-2]
        add ax, [bp+8]          ; + c
        pop bx
        mov sp, bp              ; drop the local
        pop bp
        ret 6

সত্যিকারের run (reference lab-এর উদাহরণ; প্রথম ২৪টি নির্দেশ, AX, BX, BP, SP, IP রাখা; program-টি শেষে 123 আর 65534 ছাপে):

$ python -B run8086.py examples/8086/stack_frame.asm --trace
1000:0100 B80300     mov ax,0x3         AX=0003 BX=0000 BP=0000 SP=FFFE IP=0103
1000:0103 50         push ax            AX=0003 BX=0000 BP=0000 SP=FFFC IP=0104
1000:0104 B80200     mov ax,0x2         AX=0002 BX=0000 BP=0000 SP=FFFC IP=0107
1000:0107 50         push ax            AX=0002 BX=0000 BP=0000 SP=FFFA IP=0108
1000:0108 B80100     mov ax,0x1         AX=0001 BX=0000 BP=0000 SP=FFFA IP=010B
1000:010B 50         push ax            AX=0001 BX=0000 BP=0000 SP=FFF8 IP=010C
1000:010C E81600     call 0x125         AX=0001 BX=0000 BP=0000 SP=FFF6 IP=0125
1000:0125 55         push bp            AX=0001 BX=0000 BP=0000 SP=FFF4 IP=0126
1000:0126 89E5       mov bp,sp          AX=0001 BX=0000 BP=FFF4 SP=FFF4 IP=0128
1000:0128 83EC02     sub sp,0x2         AX=0001 BX=0000 BP=FFF4 SP=FFF2 IP=012B
1000:012B 53         push bx            AX=0001 BX=0000 BP=FFF4 SP=FFF0 IP=012C
1000:012C 8B4604     mov ax,[bp+0x4]    AX=0001 BX=0000 BP=FFF4 SP=FFF0 IP=012F
1000:012F BB6400     mov bx,0x64        AX=0001 BX=0064 BP=FFF4 SP=FFF0 IP=0132
1000:0132 F7E3       mul bx             AX=0064 BX=0064 BP=FFF4 SP=FFF0 IP=0134
1000:0134 8946FE     mov [bp-0x2],ax    AX=0064 BX=0064 BP=FFF4 SP=FFF0 IP=0137
1000:0137 8B4606     mov ax,[bp+0x6]    AX=0002 BX=0064 BP=FFF4 SP=FFF0 IP=013A
1000:013A BB0A00     mov bx,0xa         AX=0002 BX=000A BP=FFF4 SP=FFF0 IP=013D
1000:013D F7E3       mul bx             AX=0014 BX=000A BP=FFF4 SP=FFF0 IP=013F
1000:013F 0346FE     add ax,[bp-0x2]    AX=0078 BX=000A BP=FFF4 SP=FFF0 IP=0142
1000:0142 034608     add ax,[bp+0x8]    AX=007B BX=000A BP=FFF4 SP=FFF0 IP=0145
1000:0145 5B         pop bx             AX=007B BX=0000 BP=FFF4 SP=FFF2 IP=0146
1000:0146 89EC       mov sp,bp          AX=007B BX=0000 BP=FFF4 SP=FFF4 IP=0148
1000:0148 5D         pop bp             AX=007B BX=0000 BP=0000 SP=FFF6 IP=0149
1000:0149 C20600     ret word 0x6       AX=007B BX=0000 BP=0000 SP=FFFE IP=010F

ছবি ১৮.১ — weighted(1, 2, 3)-এর stack frame, push bx-এর পরে

ওপরে বড় ঠিকানা; নীল = caller-এর রাখা; হলুদ = CPU-র রাখা; সবুজ = procedure-এর নিজের

weighted procedure-এর stack frame FFFCH FFFAH FFF8H FFF6H FFF4H FFF2H FFF0H c = 0003H b = 0002H a = 0001H ফেরার IP 010FH পুরোনো BP 0000H local 0064H (100) সংরক্ষিত BX [bp+8] [bp+6] [bp+4] [bp+2] [bp-2] BP SP ↓ stack নিচের ঠিকানার দিকে বাড়ে
ছবি ১৮.১ — push bx-এর পরে (IP = 012CH) stack-এর ছবি, trace-এর মান দিয়ে। BP-র ওপরে সব ধনাত্মক দূরত্ব: caller-এর জগৎ (parameter) আর ফেরার ঠিকানা। BP-র নিচে ঋণাত্মক দূরত্ব: procedure-এর নিজের জগৎ (local variable, সংরক্ষিত register). Local-এর মান 0064H লেখা হয় একটু পরে, mov [bp-2],ax-এ।

ছবিটি মুখস্থ করার মতো, কারণ পরীক্ষায় প্রায়ই “stack frame আঁকুন” বলা হয়। লক্ষ করার বিষয় চারটি:

  • sub sp,2 মানে জায়গা নেওয়া। কোনো মান লেখা হয় না, SP শুধু দুই byte নামে; সেই ঘরটিই local variable, যার ঠিকানা [bp-2]. বেশি local লাগলে বেশি বিয়োগ: sub sp,6 = তিনটি word.
  • push bx আর pop bx. Procedure BX ব্যবহার করে, তাই শুরুতে রেখে শেষে ফিরিয়ে দেয়। এমন register-কে বলে callee-saved. AX এখানে ফেরত মান বহন করে, তাই সেটি রক্ষা করা হয় না; যে register procedure নষ্ট করতে পারে, সেগুলো caller-saved, দরকার হলে caller নিজে বাঁচাবে।
  • mov sp,bp. এক নির্দেশে সব local বাদ: যত local-ই থাকুক, SP আবার BP-তে। তারপর pop bp, আর SP ঠিক ফেরার ঠিকানার ওপর।
  • ret 6 = C2 06 00. ফিরে তিনটি parameter (৬ byte) সরিয়ে দেয়, তাই trace-এ ret-এর পরেই SP = FFFEH. Caller-কে আর কিছু করতে হয়নি, আর program-টি শেষে SP ছাপে 65534 = FFFEH.

একটি ইতিহাসের টীকা: এই prologue আর epilogue এত প্রচলিত যে Intel পরের chip 80186-এ (১৯৮২) এর জন্য দুটি নির্দেশ যোগ করে, ENTER আর LEAVE. 8086-এ সেগুলো নেই, আর lab-এর NASM cpu 8086 দিয়ে assemble করে বলে (Spec decision 13) সত্যিই থামে: enter.asm:5: error: no instruction for this cpu level. একই ফাইল --cpu 186 দিয়ে চালালে C8 02 00 00 (enter 2,0) আর C9 (leave) তৈরি হয় আর চলে। AI-র লেখা “8086 program”-এ ENTER দেখলে বুঝবেন সেটি 8086-এর নয়।

আরেকটি সূক্ষ্মতা reference lab-এর সঙ্গে জড়িত। কেউ কেউ frame-এর ঠিকানা মনে রাখতে push sp লেখেন। আসল 8086-এ এই নির্দেশ SP কমানোর পরের মান রাখে, অথচ Unicorn একটি ৩৮৬-শ্রেণির CPU বলে আগের মান রাখে; এটি Spec decision 15-এর চারটি নথিভুক্ত পার্থক্যের একটি। তাই এই কোর্সের কোনো উদাহরণ push sp-এর ওপর নির্ভর করে না, আর আপনিও তা এড়িয়ে চলুন: mov bp,sp দুই chip-এ একই কাজ করে।

৫ · Recursion — frame-এর ওপর frame

Stack-এ parameter রাখার আসল পুরস্কার recursion: একটি procedure নিজেকেই ডাকে, আর প্রতিটি ডাক নিজের আলাদা frame পায়, তাই একটির n অন্যটির n-এ হাত দেয় না। ক্লাসিক উদাহরণ factorial: fact(n) = n × fact(n − 1), আর fact(1) = fact(0) = 1, যেখানে নিজেকে আর ডাকা হয় না; একে বলে base case. Reference lab-এর factorial.asm এই procedure দিয়ে 0 থেকে 8 পর্যন্ত সবগুলো ছাপে, সত্যিকারের run:

$ python -B run8086.py examples/8086/factorial.asm
1 1 2 6 24 120 720 5040 40320
[exit code 0 via INT 21h/4Ch, 879 instructions]

৮৭৯টি নির্দেশ ট্রেস করা কঠিন, তাই একই fact procedure হুবহু রেখে শুধু fact(3) ডাকার একটি ছোট program বানানো হলো:

; fact3.asm - recursive factorial, fact(3), frames on the stack
        org 100h
        mov ax, 3
        push ax             ; argument n = 3
        call fact           ; result in AX
        add sp, 2
        hlt

fact:   push bp
        mov bp, sp          ; [bp+4] = n
        mov ax, [bp+4]
        cmp ax, 1
        jbe .one
        dec ax
        push ax             ; argument n-1
        call fact           ; AX = fact(n-1)
        add sp, 2
        mul word [bp+4]     ; DX:AX = AX * n
        jmp .done
.one:   mov ax, 1
.done:  pop bp
        ret

সত্যিকারের run-এর ৩৮টি trace লাইনের কয়েকটি (AX, BP, SP, IP রাখা) আর সবচেয়ে গভীর বিন্দু থেকে শুরু করে stack-এর ২০ byte:

$ python -B run8086.py fact3.asm --trace --mem 1000:FFEC,20
1000:0100 B80300     mov ax,0x3         AX=0003 BP=0000 SP=FFFE IP=0103
1000:0103 50         push ax            AX=0003 BP=0000 SP=FFFC IP=0104
1000:0104 E80400     call 0x10b         AX=0003 BP=0000 SP=FFFA IP=010B
1000:010B 55         push bp            AX=0003 BP=0000 SP=FFF8 IP=010C
1000:010C 89E5       mov bp,sp          AX=0003 BP=FFF8 SP=FFF8 IP=010E
...
1000:0118 E8F0FF     call 0x10b         AX=0001 BP=FFF2 SP=FFEE IP=010B
1000:010B 55         push bp            AX=0001 BP=FFF2 SP=FFEC IP=010C
1000:010C 89E5       mov bp,sp          AX=0001 BP=FFEC SP=FFEC IP=010E
1000:010E 8B4604     mov ax,[bp+0x4]    AX=0001 BP=FFEC SP=FFEC IP=0111
1000:0111 83F801     cmp ax,0x1         AX=0001 BP=FFEC SP=FFEC IP=0114
1000:0114 760D       jna 0x123          AX=0001 BP=FFEC SP=FFEC IP=0123
1000:0123 B80100     mov ax,0x1         AX=0001 BP=FFEC SP=FFEC IP=0126
1000:0126 5D         pop bp             AX=0001 BP=FFF2 SP=FFEE IP=0127
1000:0127 C3         ret                AX=0001 BP=FFF2 SP=FFF0 IP=011B
1000:011B 83C402     add sp,0x2         AX=0001 BP=FFF2 SP=FFF2 IP=011E
1000:011E F76604     mul word [bp+0x4]  AX=0002 BP=FFF2 SP=FFF2 IP=0121
...
1000:0126 5D         pop bp             AX=0006 BP=0000 SP=FFFA IP=0127
1000:0127 C3         ret                AX=0006 BP=0000 SP=FFFC IP=0107
1000:0107 83C402     add sp,0x2         AX=0006 BP=0000 SP=FFFE IP=010A
----
----
1000:FFEC  F2 FF 1B 01 01 00 F8 FF 1B 01 02 00 00 00 07 01
1000:FFFC  03 00 00 00
[exit code 0 via HLT, 39 instructions]
এই ধাপের শেষে
কী ঘটল
SP · BP
AX
জীবিত frame
stack (word)
  1. প্রথম ডাক। Caller 3 push করে, call fact রাখে 0107H, prologue রাখে পুরোনো BP 0000H. BP = SP = FFF8H, [bp+4] = 3. এক frame = n + ফেরার ঠিকানা + BP = ৬ byte.
  2. নিজেকে ডাকা। 3 > 1, তাই dec ax, 2 push, আবার call fact. এবার ফেরার ঠিকানা 011BH (procedure-এর ভেতরের add sp,2), আর সংরক্ষিত BP = FFF8H, আগের frame-এর নোঙর। নতুন BP = FFF2H.
  3. সবচেয়ে গভীরে। fact(1)-এর frame, BP = SP = FFECH. তিনটি frame একসঙ্গে বেঁচে আছে, মোট ১৮ byte. সংরক্ষিত BP-গুলো একটি শিকল বানায়: FFECH → FFF2H → FFF8H → 0000H.
  4. Base case. [bp+4] = 1, jbe .one লাফ দেয়: AX = 1. তারপর pop bp (BP = FFF2H, আগের frame-এর নোঙর ফিরল) আর ret (IP = 011BH). SP = FFF0H: parameter 1 এখনো stack-এ।
  5. fact(2) গুণ করে। add sp,2 parameter সরায় (SP = FFF2H), আর mul word [bp+4]: BP আবার fact(2)-এর frame দেখায়, তাই [bp+4] = 2. AX = 1 × 2 = 2.
  6. fact(3) গুণ করে। fact(2) ফিরল, BP = FFF8H, [bp+4] = 3. AX = 2 × 3 = 6. প্রতিটি স্তর নিজের n ঠিকঠাক পেয়েছে, কারণ n ছিল তার নিজের frame-এ।
  7. শেষ। শেষ ret যায় 0107H-এ, caller-এর add sp,2 দিয়ে SP = FFFEH, BP = 0000H. ফল AX = 6. Runner-এর dump দেখায় frame-গুলো মেমরিতে পড়ে আছে: F2 FF 1B 01 01 00 F8 FF ….

এবার একই frame-এর হিসাব Python-এ। মডেলটি fact-এর প্রতিটি ডাকে stack-এ তিনটি word রাখে, সবচেয়ে গভীর মুহূর্তের ছবি তুলে রাখে, তারপর সংরক্ষিত BP-র শিকল ধরে হাঁটে, যেভাবে একটি debugger “backtrace” দেখায়।

# fact3.asm-এর recursive fact(n): প্রতিটি ডাকে stack-এ একটি frame
mem, sp, bp = {}, 0xFFFE, 0x0000
deepest = None

def push(v):
    global sp
    sp -= 2; mem[sp] = v

def fact(n, ret):                       # ret = ডাকার জায়গার পরের IP
    global sp, bp, deepest
    push(n); push(ret)                  # caller: push n, তারপর call
    push(bp); bp = sp                   # callee: push bp / mov bp,sp
    if mem[bp + 4] <= 1:
        ax = 1                          # base case
        deepest = (sp, bp, dict(mem))
    else:
        ax = fact(mem[bp + 4] - 1, 0x011B) * mem[bp + 4]  # mul word [bp+4]
    bp = mem[sp]; sp += 4               # pop bp, ret
    sp += 2                             # caller: add sp,2
    return ax & 0xFFFF

print("fact(3) =", fact(3, 0x0107), f"; SP after = {sp:04X}H")
dsp, dbp, dmem = deepest
print(f"deepest point: SP={dsp:04X}H BP={dbp:04X}H")
for a in range(dsp, 0xFFFE, 2):
    tag = {0: "saved BP", 2: "return IP", 4: "n"}[(a - dsp) % 6]
    print(f"  {a:04X}H: {dmem[a]:04X}  {tag}")
chain, b = [], dbp                      # BP-chain: debugger-এর backtrace
while b:
    chain.append(f"{b:04X}H(n={dmem[b + 4]})"); b = dmem[b]
print("BP chain:", " -> ".join(chain))
for n in (3, 8):
    print(f"fact({n}): {n} frames x 6 bytes = {6 * n} bytes of stack")

আসল আউটপুট (ব্রাউজারের Python):

fact(3) = 6 ; SP after = FFFEH
deepest point: SP=FFECH BP=FFECH
  FFECH: FFF2  saved BP
  FFEEH: 011B  return IP
  FFF0H: 0001  n
  FFF2H: FFF8  saved BP
  FFF4H: 011B  return IP
  FFF6H: 0002  n
  FFF8H: 0000  saved BP
  FFFAH: 0107  return IP
  FFFCH: 0003  n
BP chain: FFECH(n=1) -> FFF2H(n=2) -> FFF8H(n=3)
fact(3): 3 frames x 6 bytes = 18 bytes of stack
fact(8): 8 frames x 6 bytes = 48 bytes of stack

নয়টি word সত্যিকারের dump F2 FF 1B 01 01 00 F8 FF 1B 01 02 00 00 00 07 01 03 00-এর সঙ্গে হুবহু মেলে। “BP chain” লাইনটি দেখায় কেন push bp শুধু BP বাঁচানোর কৌশল নয়: প্রতিটি frame আগের frame-এর ঠিকানা মনে রাখে, তাই যেকোনো মুহূর্তে কে কাকে ডেকেছে, তা মেমরি পড়েই বলা যায়। আর শেষ দুটি লাইন stack-এর খরচ: fact(n)-এর জন্য ৬n byte. Reference lab-এর factorial.asm-এর fact(8) তাই ৪৮ byte নেয়।

8 পর্যন্ত কেন থামা? fact(9) = 362880, যা ১৬ বিটে (সর্বোচ্চ 65535) আঁটে না। fact3.asm-এ 3-এর জায়গায় 9 দিয়ে সত্যিকারের run-এর শেষ register: AX=8980 DX=0005. 362880 = 58980H, তাই MUL-এর পূর্ণ ফল DX:AX-এ ঠিকই আছে, কিন্তু procedure ফেরত মান হিসেবে শুধু AX দেয়, আর caller পায় 8980H = 35200, ভুল সংখ্যা। Procedure-এর চুক্তিতে ফেরত মানের মাপও লিখে রাখতে হয়।

সাবধান — stack-এর কোনো দেয়াল নেই: 8086 SP-র কোনো সীমা পরীক্ষা করে না। Lab-এর .COM মডেলে program বসে 0100H থেকে আর stack নামে FFFEH থেকে, একই 64 KB-তে (Spec decision 13). খুব গভীর recursion-এ stack নামতে নামতে program-এর data, শেষে code-এর ওপরেই লিখে ফেলবে, কোনো সতর্কবার্তা ছাড়া। এই stack overflow এমবেডেড firmware-এর পরিচিত বিপদ; stack-এর মাপ কীভাবে আগে থেকে হিসাব করা হয়, তা পর্ব ৩৯-এ (এমবেডেড memory — stack-এর আকার, heap এড়ানো আর static allocation).

Recursion আর stack-এর সাধারণ তত্ত্ব, RISC-V-এর চোখে, আছে Computer Architecture পর্ব ৩০-এ। সেখানে ফেরার ঠিকানা প্রথমে register-এ যায় (link register), stack-এ নয়; 8086-এ CALL সবসময় stack-এ লেখে। একই ধারণা, আলাদা নকশা।

৬ · Macro — assembler-এর হাতের কপি

Procedure চলার সময় (run time) ডাকা হয়। Macro সম্পূর্ণ আলাদা জিনিস: এটি assembler-এর জন্য একটি ছাঁচ। Source-এ macro-র নাম যেখানে লেখা, assembler সেখানে ছাঁচের নির্দেশগুলো বসিয়ে দেয়, %1, %2-এর জায়গায় দেওয়া argument বসিয়ে। একে বলে macro expansion. ফলে CPU কোনো macro দেখেই না; সে দেখে সাধারণ নির্দেশ, যেন programmer নিজেই কপি করে লিখেছেন। NASM আর MASM-এ লেখার ধরন:

কাজNASMMASM/TASM
শুরু%macro PRICE 2 (২টি parameter)PRICE MACRO W, R
Parameter ব্যবহার%1, %2নাম দিয়ে: W, R
নিজস্ব label%%ok:LOCAL OK, তারপর OK:
শেষ%endmacroENDM
ব্যবহারPRICE 150, 6550PRICE 150, 6550

নিচের program একই দামের হিসাব দুইভাবে করে: দুবার macro দিয়ে, একবার procedure দিয়ে। তিনটি ওজনই README-র: 150 g, 1250 g আর 500 g.

; mac86.asm - the same job as a macro and as a procedure
        org 100h
%macro PRICE 2              ; PRICE weight_g, rate_paisa -> AX
        mov ax, %1
        mov cx, %2
        mul cx
        add ax, 500
        adc dx, 0
        mov cx, 1000
        div cx
%endmacro
        PRICE 150, 6550     ; expanded here (9.83 Tk)
        mov [r1], ax
        PRICE 1250, 6550    ; expanded again (81.88 Tk)
        mov [r2], ax
        mov ax, 500
        call price_p        ; one copy, called (32.75 Tk)
        mov [r3], ax
        hlt

price_p:                    ; AX = weight_g -> AX = paisa
        mov cx, 6550
        mul cx
        add ax, 500
        adc dx, 0
        mov cx, 1000
        div cx
        ret
r1: dw 0
r2: dw 0
r3: dw 0

NASM-এর listing ফাইল (-l) দেখায় assembler আসলে কী বানিয়েছে। <1> চিহ্নের লাইনগুলো macro থেকে খোলা; বাঁয়ের সংখ্যা ফাইলের ভেতরের offset (lab program-কে 0100H-এ বসায়, তাই আসল IP এর সঙ্গে 100H যোগ করে):

$ nasm -f bin --before "cpu 8086" -l mac86.lst -o mac86.com mac86.asm
    12                                          PRICE 150, 6550     ; expanded here (9.83 Tk)
     4 00000000 B89600              <1>  mov ax, %1
     5 00000003 B99619              <1>  mov cx, %2
     6 00000006 F7E1                <1>  mul cx
     7 00000008 05F401              <1>  add ax, 500
     8 0000000B 83D200              <1>  adc dx, 0
     9 0000000E B9E803              <1>  mov cx, 1000
    10 00000011 F7F1                <1>  div cx
    13 00000013 A3[4700]                        mov [r1], ax
    14                                          PRICE 1250, 6550    ; expanded again (81.88 Tk)
     4 00000016 B8E204              <1>  mov ax, %1
     5 00000019 B99619              <1>  mov cx, %2
     6 0000001C F7E1                <1>  mul cx
     7 0000001E 05F401              <1>  add ax, 500
     8 00000021 83D200              <1>  adc dx, 0
     9 00000024 B9E803              <1>  mov cx, 1000
    10 00000027 F7F1                <1>  div cx
    15 00000029 A3[4900]                        mov [r2], ax
    16 0000002C B8F401                          mov ax, 500
    17 0000002F E80400                          call price_p        ; one copy, called (32.75 Tk)
    18 00000032 A3[4B00]                        mov [r3], ax
    19 00000035 F4                              hlt
    20                                  
    21                                  price_p:                    ; AX = weight_g -> AX = paisa
    22 00000036 B99619                          mov cx, 6550
    23 00000039 F7E1                            mul cx
    24 0000003B 05F401                          add ax, 500
    25 0000003E 83D200                          adc dx, 0
    26 00000041 B9E803                          mov cx, 1000
    27 00000044 F7F1                            div cx
    28 00000046 C3                              ret

Listing-এর লেখায় %1 রয়ে গেছে, কিন্তু byte-এ বসানো মান স্পষ্ট: প্রথম কপিতে B8 96 00 = mov ax,0096h (150), দ্বিতীয়টিতে B8 E2 04 (1250). সত্যিকারের run (run8086.py mac86.asm --mem 0147h,6) ২৭টি নির্দেশ চালায় আর তিনটি ফল রাখে: D7 03 FC 1F CB 0C, অর্থাৎ 03D7H = 983, 1FFCH = 8188, 0CCBH = 3275 পয়সা: 9.83, 81.88 আর 32.75 টাকা, তিনটিই README-র মান। হিসাব এক, কিন্তু কোড তৈরির পথ আলাদা। পার্থক্যটি ধাপে ধাপে:

এই ধাপে
কখন
কী ঘটে
byte (offset)
SP
ফল
  1. Assembler একটি macro-র নাম দেখে। PRICE কোনো 8086 নির্দেশ নয়; NASM জানে এটি আগে %macro দিয়ে সংজ্ঞায়িত। এখনো কোনো byte তৈরি হয়নি।
  2. Expansion. ছাঁচের সাতটি লাইন এই জায়গায় বসে, %1-এর জায়গায় 150, %2-এর জায়গায় 6550. Listing-এ এগুলো <1> চিহ্নে, offset 0000H থেকে 0012H: ১৯ byte.
  3. আবার ব্যবহার, আবার কপি। দ্বিতীয় PRICE আরও ১৯ byte বসায় (0016H–0028H). যতবার লিখবেন, ততবার কপি; ১০ বার লিখলে ১৯০ byte.
  4. Procedure ডাকা। call price_p মাত্র তিন byte (E8 04 00), আর procedure-এর দেহ ১৭ byte একবারই, 0036H থেকে 0046H. যত ডাকই হোক, দেহের কপি একটি।
  5. চলার সময়, macro. CPU-র কাছে এগুলো সাধারণ নির্দেশ, পরপর চলে। কোনো CALL, RET বা stack-এর লেনদেন নেই; SP পুরো সময় FFFEH. ফল AX = 03D7H = 983 পয়সা।
  6. চলার সময়, procedure. call ফেরার ঠিকানা 0132H stack-এ রাখে (SP = FFFCH), IP যায় 0136H-এ, দেহ চলে, ret ফেরে 0132H-এ। দুটি বাড়তি নির্দেশ আর stack-এর দুটি লেনদেন: এটুকুই procedure-এর দাম। ফল 0CCBH = 3275.

এবার মাপের হিসাব। নিচের ব্লক NASM-এর মতো একটি খুবই ছোট macro expander চালায় (শুধু %1, %2 আর %% বোঝে), তারপর listing থেকে পাওয়া byte সংখ্যা দিয়ে macro আর procedure-এর মোট মাপ তুলনা করে।

# NASM-এর %macro-র মতো ছোট expander: %1, %2-এর জায়গায় argument, %% = নিজস্ব label
PRICE = ["mov ax, %1", "mov cx, %2", "mul cx", "add ax, 500",
         "adc dx, 0", "mov cx, 1000", "div cx"]
CLAMP = ["cmp ax, 5000", "jbe %%ok", "mov ax, 5000", "%%ok:"]
count = 0

def expand(body, *args):
    global count
    count += 1                          # প্রতিটি ব্যবহারে নতুন নম্বর
    out = []
    for line in body:
        line = line.replace("%%", f"..@{count}.")
        for i, a in enumerate(args, 1):
            line = line.replace(f"%{i}", str(a))
        out.append(line)
    return out

src = [("PRICE", 150, 6550), ("CLAMP",), ("PRICE", 1250, 6550)]
for name, *args in src:
    body = PRICE if name == "PRICE" else CLAMP
    print(f"; {name} {', '.join(map(str, args))}".rstrip())
    for line in expand(body, *args):
        print("    " + line)

# NASM listing থেকে মাপ: macro-র এক কপি 19 byte;
# procedure-এর দেহ 17 byte, প্রতি ডাক mov ax,imm (3) + call (3) = 6 byte
for k in (1, 2, 3, 10):
    print(f"{k:2} uses: macro {19 * k:3} bytes, procedure {17 + 6 * k:3} bytes")

আসল আউটপুট (ব্রাউজারের Python):

; PRICE 150, 6550
    mov ax, 150
    mov cx, 6550
    mul cx
    add ax, 500
    adc dx, 0
    mov cx, 1000
    div cx
; CLAMP
    cmp ax, 5000
    jbe ..@2.ok
    mov ax, 5000
    ..@2.ok:
; PRICE 1250, 6550
    mov ax, 1250
    mov cx, 6550
    mul cx
    add ax, 500
    adc dx, 0
    mov cx, 1000
    div cx
 1 uses: macro  19 bytes, procedure  23 bytes
 2 uses: macro  38 bytes, procedure  29 bytes
 3 uses: macro  57 bytes, procedure  35 bytes
10 uses: macro 190 bytes, procedure  77 bytes

প্রথম অংশ listing-এর <1> লাইনগুলোর মতোই, শুধু %1-এর জায়গায় সংখ্যা বসানো, ঠিক যেমন byte-এ দেখা গেছে; আর CLAMP-এর %%ok হয়ে গেছে ..@2.ok: প্রতিটি expansion-এর নিজের নাম। শেষ চার লাইন হিসাবের সার: একবার ব্যবহারে macro ছোট (১৯ বনাম ২৩ byte), কিন্তু দুবার থেকেই procedure ছোট, আর ১০ বারে ১৯০ বনাম ৭৭ byte. বিপরীতে, macro প্রতিবার CALL আর RET-এর কাজ বাঁচায়। কত clock বাঁচে, তা Intel-এর 8086 manual-এর টেবিলের বিষয়; কোর্সের lab clock মাপে না (Spec decision 16).

Macro-র ভেতরের label — একটি সত্যিকারের ভুল

ধরুন smart scale-এর capacity 5000 g-এর বেশি ওজন কেটে 5000 করতে একটি macro লিখলেন, ভেতরে সাধারণ label ok: দিয়ে, আর দুবার ব্যবহার করলেন। দুটি expansion-এ একই নামের দুটি label তৈরি হয়। NASM 3.02 সত্যিই থামে:

$ python -B run8086.py maclab.asm
error: NASM failed:
../pm86/maclab.asm:13: error: label `ok' inconsistently redefined
../pm86/maclab.asm:7: ... from macro `CLAMP5000' defined here
../pm86/maclab.asm:13: info: label `ok' originally defined here

সমাধান %%ok: NASM প্রতিটি expansion-এ নতুন নাম বানায়। nasm -E (শুধু preprocess) দিয়ে দেখা যায়: প্রথম কপিতে ..@1.ok, দ্বিতীয়টিতে ..@2.ok. ঠিক করা program চলে আর 5100 থেকে BX=1388 (5000) দেয়, পরে 1250 অক্ষত রাখে (AX=04E2). MASM-এ একই কাজ LOCAL directive করে। Macro-র নাম আর label একে অপরকে নষ্ট না করার এই সমস্যার সাধারণ নাম hygiene; C-এর #define-এ একই ধরনের ফাঁদ C প্রোগ্রামিং পর্ব ২৭-এ, আর ভাষার নকশার দিক থেকে macro-র পুরো গল্প Programming Languages & Compilers পর্ব ৭৮-এ।

বিষয়MacroProcedure
কে কাজ করেassembler, assemble-এর সময়CPU, চলার সময়
কোডের মাপপ্রতি ব্যবহারে পুরো কপিদেহ একবার, প্রতি ডাকে কয়েক byte
গতিCALL/RET-এর বাড়তি কাজ নেইপ্রতিটি ডাকে CALL, RET, parameter-এর push
Stackলাগে নাফেরার ঠিকানা আর parameter-এর জন্য লাগে
Parameterলেখা বদলে বসানো (সংখ্যা, register-এর নাম, এমনকি নির্দেশ)চলার সময়ের মান (register বা stack)
Debuglisting-এ খুলে দেখতে হয়একটি ঠিকানায় একটি breakpoint
কখন ভালোছোট, বারবার লাগে এমন টুকরো (২–৩ নির্দেশ)বড় কাজ, বহু জায়গা থেকে ডাকা, recursion

৭ · Reentrancy — একই procedure একসঙ্গে দুবার

একটি procedure-এর একটি ডাক শেষ হওয়ার আগেই যদি আবার তাকে ডাকা হয়, তাহলে দুটি ডাক একসঙ্গে “জীবিত”। এটা ঘটে recursion-এ, আর ঘটে interrupt-এ: main program একটি procedure-এর মাঝখানে, এমন সময় interrupt এল, আর তার handler (ISR) একই procedure ডাকল। যে procedure এই অবস্থায়ও ঠিক কাজ করে, তাকে বলে reentrant. শর্তটি সরল: সব অস্থায়ী মান register-এ বা নিজের stack frame-এ রাখতে হবে, কোনো নির্দিষ্ট মেমরি-ঘরে নয়।

ভুলটি দেখতে fact-এর একটি “সহজ” সংস্করণ লেখা হলো, যেটি n রাখে একটি global word-এ, stack-এ নয়:

; reent.asm - factorial that keeps n in a global word: NOT reentrant
        org 100h
        mov ax, 4
        call factg          ; expect 24
        mov [r_bad], ax
        hlt

factg:  mov [n], ax         ; saves n in ONE fixed memory word
        cmp ax, 1
        jbe .one
        dec ax
        call factg          ; the inner call overwrites [n]
        mul word [n]        ; uses the inner call's n, not ours
        ret
.one:   mov ax, 1
        ret
n:      dw 0
r_bad:  dw 0

সত্যিকারের run (AX, SP, IP রাখা; শুরুর তিনটি আর শেষের লাইনগুলো; শেষে [n] আর [r_bad]):

$ python -B run8086.py reent.asm --trace --mem 011Fh,4
1000:0100 B80400     mov ax,0x4         AX=0004 SP=FFFE IP=0103
1000:0103 E80400     call 0x10a         AX=0004 SP=FFFC IP=010A
1000:010A A31F01     mov [0x11f],ax     AX=0004 SP=FFFC IP=010D
...
1000:0113 E8F4FF     call 0x10a         AX=0001 SP=FFF6 IP=010A
1000:010A A31F01     mov [0x11f],ax     AX=0001 SP=FFF6 IP=010D
1000:010D 83F801     cmp ax,0x1         AX=0001 SP=FFF6 IP=0110
1000:0110 7609       jna 0x11b          AX=0001 SP=FFF6 IP=011B
1000:011B B80100     mov ax,0x1         AX=0001 SP=FFF6 IP=011E
1000:011E C3         ret                AX=0001 SP=FFF8 IP=0116
1000:0116 F7261F01   mul word [0x11f]   AX=0001 SP=FFF8 IP=011A
1000:011A C3         ret                AX=0001 SP=FFFA IP=0116
1000:0116 F7261F01   mul word [0x11f]   AX=0001 SP=FFFA IP=011A
1000:011A C3         ret                AX=0001 SP=FFFC IP=0116
1000:0116 F7261F01   mul word [0x11f]   AX=0001 SP=FFFC IP=011A
1000:011A C3         ret                AX=0001 SP=FFFE IP=0106
1000:0106 A32101     mov [0x121],ax     AX=0001 SP=FFFE IP=0109
----
----
1000:011F  01 00 01 00
[exit code 0 via HLT, 30 instructions]

fact(4) হওয়ার কথা 24, এসেছে 1. কারণ trace-এই লেখা: প্রতিটি নতুন ডাক mov [0x11f],ax দিয়ে একই ঘরে নিজের n লিখেছে, আর সবচেয়ে ভেতরের ডাক সেখানে রেখে গেছে 1. ফেরার পথে প্রতিটি স্তর mul word [0x11f] করেছে সেই 1 দিয়ে, নিজের n দিয়ে নয়: 1 × 1 × 1 × 1. Stack-এ শুধু ফেরার ঠিকানা ছিল (dump-এ 16 01-গুলো), n ছিল না। সেকশন ৫-এর fact একই কাজ ঠিক করে, কারণ n ছিল প্রতিটি frame-এর [bp+4]-এ।

এমবেডেড firmware-এ এই ভুলের দাম বেশি, কারণ সেখানে দ্বিতীয় ডাক আসে interrupt থেকে, অনিয়মিত সময়ে। ধরুন smart scale-এর main loop একটি global buffer-এ দাম লিখে UART-এ পাঠানোর জন্য একটি procedure ডাকে, আর মাঝপথে tare বোতামের interrupt এসে একই procedure দিয়ে “TARE set” লিখতে চায়। Buffer একটিই, তাই main loop-এর অর্ধেক লেখা বার্তা নষ্ট হয়। ভুলটি হাজারবার পরীক্ষায় ধরা না পড়ে হঠাৎ একদিন দেখা দিতে পারে। নিয়মগুলো সংক্ষেপে:

Interrupt-এর ভেতর থেকে কী ডাকা নিরাপদ, তা 8086-এর জন্য পর্ব ২০-এ (8086-এর interrupt — vector table, INT আর ISR), আর আধুনিক microcontroller-এ shared data আর ISR-এর নিয়ম পর্ব ৪৩-এ (Interrupt আর ISR নকশা — latency, priority আর shared data).

আরও গভীরে: 8086-এর যুগের সবচেয়ে বিখ্যাত non-reentrant কোড ছিল MS-DOS নিজেই: INT 21h-এর service চলার মাঝে আবার INT 21h ডাকলে DOS-এর ভেতরের stack আর অবস্থা নষ্ট হতো। তাই memory-তে থেকে যাওয়া program-গুলো (TSR) DOS-এর একটি অনথিভুক্ত “InDOS” flag দেখে নিশ্চিত হতো যে DOS ব্যস্ত নয়, তারপরই ডাকত। আজকের এমবেডেড C-তে একই সমস্যা strtok-এর মতো লুকানো static অবস্থার function-এ, আর RTOS-এ একই function একাধিক task থেকে ডাকলে। আরেকটি পরিবর্তন: আধুনিক x86-64 compiler অপ্টিমাইজ করার সময় প্রায়ই frame pointer বাদ দেয় (GCC-র -fomit-frame-pointer) আর SP-ভিত্তিক ঠিকানা ব্যবহার করে, যা 8086-এ অসম্ভব ছিল, কারণ সেখানে [sp+4] লেখাই যায় না।

পরীক্ষা ও ইন্টারভিউতে: “Near আর far CALL-এ stack-এ কত byte যায়?” → near ২ (IP), far ৪ (CS তারপর IP). “RET 6 কী করে?” → IP pop করে তারপর SP-তে 6 যোগ: তিনটি word parameter সরায়। “Procedure-এ প্রথম stack parameter কোথায়?” → push bp / mov bp,sp-এর পরে near procedure-এ [bp+4], far-এ [bp+6]. “Macro আর procedure-এর পার্থক্য?” → macro assemble-এর সময় কপি হয় (বড় কোড, CALL/RET নেই), procedure চলার সময় ডাকা হয় (ছোট কোড, stack লাগে)। “Reentrant procedure কী?” → শেষ হওয়ার আগে আবার ডাকলেও ঠিক কাজ করে; অস্থায়ী মান stack-এ রাখে, global-এ নয়।

৮ · AI-এর যুগে procedure আর macro যাচাই

AI assistant 8086-এর procedure লিখে দিতে পারে চোখের পলকে, আর দেখতেও সুন্দর হয়। কিন্তু এই বিষয়ের ভুলগুলো চুপচাপ থাকে: program assemble হয়, চলে, শুধু stack এক word সরে যায় বা ফল ভুল আসে। নিচের ভুলগুলো সবচেয়ে বেশি দেখা যায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
8086 program-এ ENTER, LEAVE, PUSHA বা [sp+4] লেখেNASM-এ cpu 8086 দিয়ে assemble করা: “no instruction for this cpu level” বা “invalid 16-bit effective address”
Parameter-এর দূরত্ব ভুল: near procedure-এ প্রথমটি [bp+2] বা far-এ [bp+4] ধরেStack নিজে আঁকা: ফেরার ঠিকানা ২ বা ৪ byte, তার নিচে পুরোনো BP
Caller add sp আর procedure ret n দুটিই দেয়, বা কোনোটিই নাRunner-এ ডাকার আগে আর পরে SP মেলানো
push আর pop-এর ক্রম উল্টো, বা একটি pop বাদTrace-এ ret-এর ঠিক আগে SP ফেরার ঠিকানার ঘরে কি না দেখা
8085-এর CZ/RNC বা Z80-এর শর্তযুক্ত call 8086-এ ব্যবহার করেIntel-এর 8086 manual-এর নির্দেশ তালিকা; NASM assemble করলে ধরা পড়ে
Macro-র ভেতরে সাধারণ label রাখে, বা NASM আর MASM-এর macro লেখা মিশিয়ে ফেলেMacro দুবার ব্যবহার করে assemble করা; nasm -E দিয়ে expansion দেখা
CALL বা RET-এর clock সংখ্যা উৎস ছাড়া বলেIntel-এর টেবিলের সঙ্গে মেলানো; lab-এর ফল “মাপা সময়” নয় (Spec decision 16)

AI-কে কাজে লাগাতে প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:

আমি Intel 8086 (80186 বা 386 নয়) শিখছি, NASM syntax-এ, .COM program (org 100h), SS = 1000H, শুরুতে SP = FFFEH. ১. দুটি word parameter stack-এ নিয়ে (প্রথমটি ওজন, দ্বিতীয়টি দর) দাম = (ওজন × দর + 500) / 1000 হিসাব করে AX-এ ফেরত দেয় এমন একটি near procedure লেখো। push bp / mov bp,sp ব্যবহার করবে, ENTER/LEAVE নয়। ২. প্রতিটি নির্দেশের পরে SP, BP আর stack-এর word-গুলো একটি টেবিলে দেখাও। প্রথম parameter কোন [bp+n]-এ, কেন? ৩. Caller না procedure stack পরিষ্কার করবে, তা স্পষ্ট বলো, আর দেখাও ডাকার আগে আর পরে SP সমান। ৪. একই কাজ NASM %macro দিয়ে লেখো, আর বলো দুবার ব্যবহারে কোনটি বেশি byte নেয়। কোনো clock সংখ্যা দিলে Intel-এর 8086 manual-এর টেবিলের উৎস বলো, না জানলে "নিশ্চিত নই" বলো।

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১8086-এ near আর far দুই রকম CALL কেন রাখতে হলো, আর এই দ্বৈততা DOS-যুগের programmer-দের জীবনে কী প্রভাব ফেলেছিল?

কারণটি সরাসরি segmentation থেকে আসে (পর্ব ১৪)। IP ১৬ বিটের, তাই একটি code segment-এর ভেতরে 64 KB-এর বেশি জায়গা নেই। ছোট program-এর পুরো code এক segment-এ আঁটে, আর সেখানে সব ডাক near: ফেরার ঠিকানা দুই byte, নির্দেশ তিন byte (E8 + দূরত্ব), আর CS কখনো বদলায় না। কিন্তু program বড় হলে, বা লাইব্রেরি আলাদা segment-এ থাকলে, ডাকতে হয় অন্য segment-এ, যেখানে CS-ও বদলাতে হয়। তখন ফেরার জন্য CS-ও মনে রাখতে হয়, তাই far call পাঁচ byte-এর নির্দেশ আর stack-এ চার byte. Intel দুটিই রাখল, কারণ সব ডাক far করলে ছোট program অকারণে বড় আর ধীর হতো, আর সব ডাক near করলে 64 KB-এর বেশি code লেখাই যেত না।

এই সিদ্ধান্তের ফল DOS-যুগের C compiler-গুলোতে স্পষ্ট দেখা যায়। তারা “memory model” নামে কয়েকটি বিকল্প দিত, সাধারণত tiny, small, medium, compact, large আর huge নামে। Small model-এ code আর data দুটিই এক এক segment-এ, সব ডাক near. Medium-এ code বহু segment-এ, তাই function ডাক far, কিন্তু data near. Large-এ দুটিই far. একটি লাইব্রেরি এক model-এ compile করে অন্য model-এর program-এ জুড়লে near আর far মিলত না, আর ফল হতো ঠিক এই পর্বের সাবধান-বাক্সের দুর্ঘটনা: ভুল RET, stack এক word সরে যাওয়া, অদ্ভুত crash. Programmer-দের function-এর ঘোষণায় near আর far শব্দ লিখতে হতো, যা আজকের C-তে নেই।

৩২ বিটের 80386 আর পরের OS-গুলো একটি সমতল (flat) ঠিকানার জায়গা দিয়ে এই ঝামেলা প্রায় শেষ করল: offset নিজেই ৩২ বিট, তাই একটি segment-এ 4 GB, আর সব ডাক কার্যত near. আজকের ARM Cortex-M-ও flat: একটি BL নির্দেশে যেকোনো কাছের function ডাকা যায়, ফেরার ঠিকানা link register-এ। তবু near আর far-এর ধারণা পুরোপুরি হারায়নি: অনেক RISC নির্দেশে লাফের দূরত্বের সীমা থাকে, আর linker-কে দূরের লক্ষ্যের জন্য ছোট “veneer” কোড বসাতে হয়, যা 8086-এর far call-এর আধুনিক আত্মীয়।

মূল উপলব্ধি: Near আর far call ছিল ১৬ বিটের offset দিয়ে 1 MB ছোঁয়ার দাম; ছোট program-এ সাশ্রয়ী, কিন্তু বড় program-এ near-far মেলানোর দায় programmer আর compiler-এর ঘাড়ে চাপিয়েছিল।

প্র ০২Caller-এর stack পরিষ্কার (C-এর প্রথা) বনাম procedure-এর RET n (Pascal-এর প্রথা): কোনটি কখন ভালো, আর কেন দুটিই দীর্ঘদিন টিকে ছিল?

দুটি প্রথাই একই সমস্যার সমাধান: ডাকের পরে parameter-এর জায়গা ফেরত দেওয়া। Procedure-এর RET n দিয়ে পরিষ্কার করলে কাজটি এক জায়গায়, procedure-এর শেষে, একবারই লেখা হয়। একটি procedure একশো জায়গা থেকে ডাকা হলে একশোটি add sp,n (প্রতিটি তিন byte) বাঁচে। 8086-এর RET n নির্দেশ ঠিক এই কাজের জন্যই, আর Pascal ভাষার compiler-গুলো এই প্রথা নিয়েছিল; parameter বাঁ থেকে ডানে push হতো। সেই সময়ের মেমরি-স্বল্প যন্ত্রে এই সাশ্রয় বাস্তব ছিল। Microsoft-এর ১৬ বিটের Windows API-ও এই ধাঁচের একটি নিয়ম ব্যবহার করত বলে প্রচলিত বিবরণ আছে, আর পরে ৩২ বিটের Windows-এর “stdcall”-ও callee-পরিষ্কারের নিয়ম রেখেছে।

কিন্তু callee-পরিষ্কারের একটি মৌলিক সীমা আছে: procedure-কে আগে থেকে জানতে হয় কত byte parameter আসবে, কারণ n নির্দেশের ভেতরে লেখা একটি স্থির সংখ্যা। C ভাষার printf প্রতিবার আলাদা সংখ্যক argument নেয়; সেখানে শুধু caller জানে সে কতগুলো push করেছে। তাই C-এর প্রথাগত নিয়মে parameter ডান থেকে বাঁয়ে push হয়, যাতে প্রথম parameter (যেমন format string) সবসময় [bp+4]-এর মতো একটি জানা জায়গায় থাকে, আর caller নিজে add sp,n করে। এই পর্বের call2.asm ঠিক এই ধাঁচের, আর stack_frame.asm Pascal-ধাঁচের ret 6.

দুটি প্রথা একসঙ্গে টিকে থাকার মূল কারণ সামঞ্জস্য। একটি লাইব্রেরি একবার একটি নিয়মে compile হলে, তাকে ডাকা প্রতিটি program-কে সেই নিয়ম মানতেই হয়; নিয়ম বদলানো মানে সব পুরোনো binary ভাঙা। তাই compiler-গুলো function-এর ঘোষণায় নিয়মের নাম লেখার সুযোগ দিত। আধুনিক 64 বিটের ABI-তে প্রথম কয়েকটি parameter register-এ যায়, stack-এ নয়, আর এই বিতর্ক অনেকটাই মিটে গেছে (Programming Languages & Compilers পর্ব ৭১)। এমবেডেড ARM-এর AAPCS-ও প্রথম চারটি argument register-এ পাঠায়। তবু ভিন্ন ভাষা বা assembly আর C জুড়তে গেলে আজও প্রথম প্রশ্ন একই: কে পরিষ্কার করবে?

মূল উপলব্ধি: Callee-পরিষ্কার কোড ছোট করে, caller-পরিষ্কার পরিবর্তনশীল সংখ্যক argument সম্ভব করে; কোনটি “ঠিক” তার চেয়ে জরুরি হলো সব পক্ষ একই নিয়ম মানছে কি না।

প্র ০৩Microsoft-এর assembler-এর নামই “Macro Assembler”. Assembly-র যুগে macro এত গুরুত্বপূর্ণ ছিল কেন, আর আজকের এমবেডেড C-তে macro আর inline function-এর মধ্যে কীভাবে বেছে নেবেন?

Assembly-তে প্রতিটি কাজ কয়েকটি নির্দেশে ভাঙতে হয়। “একটি string ছাপানো” মানে DX-এ ঠিকানা, AH-এ 09H, তারপর INT 21h; এই তিন লাইন program-এ পঞ্চাশবার আসে। Macro সেই তিন লাইনকে একটি নামে বেঁধে দেয়, আর source পড়া সহজ হয়, ভুলও কমে। তার ওপর macro এমন কিছু পারে যা procedure পারে না: parameter হিসেবে register-এর নাম, এমনকি পুরো নির্দেশ নিতে পারে, শর্ত দিয়ে আলাদা কোড বানাতে পারে, আর ছোট কাজে CALL ও RET-এর বাড়তি কাজ বাঁচায়। এজন্য MASM, TASM আর NASM সবাই শক্তিশালী macro ভাষা রেখেছে, আর MASM নামের “M”-টি সেই গুরুত্বেরই ইঙ্গিত।

দামটিও এই পর্বে মাপা: PRICE macro প্রতিবার ১৯ byte, দশবার ব্যবহারে ১৯০ byte, যেখানে procedure লাগে ৭৭ byte. আর macro-র ভুল খোঁজা কঠিন: debugger-এ macro-র নাম নেই, আছে খোলা নির্দেশ; label-এর নাম মিলে গেলে (এই পর্বের ok-এর ঘটনা) assembler থামে, কিন্তু register নষ্ট করার মতো ভুল চুপচাপ থাকে। এই সমস্যাগুলো C-এর #define-এও আছে, যেমন #define SQ(x) x*x-এ SQ(a+1) খুলে হয় a+1*a+1.

এমবেডেড C-তে আজ সাধারণ নিয়ম হলো: যেখানে সম্ভব static inline function, যেখানে আসলেই লেখা বদলানো দরকার সেখানে macro. Inline function-এর type পরীক্ষা হয়, argument একবারই মূল্যায়ন হয়, debugger-এ নাম দেখা যায়, আর optimization চালু থাকলে compiler নিজে ঠিক করে কপি বসাবে না ডাকবে; কোডের মাপ আর গতির হিসাবটি সে-ই করে, যা 8086-এর programmer হাতে করতেন। Register-এর ঠিকানা, bit mask বা compile-এর সময়ের শর্তের মতো জায়গায় macro এখনো প্রচলিত (পর্ব ৩৫ আর ৩৬-এ দেখবেন)। ছোট flash-এর microcontroller-এ বড় কাজ macro দিয়ে বারবার কপি করলে flash দ্রুত ফুরোয়; বাজারঘরের scale-এর firmware-এ দামের হিসাব একটি function হওয়াই উচিত।

মূল উপলব্ধি: Macro লেখা বাঁচায় আর চলার সময় বাঁচায়, কিন্তু কোডের মাপ আর debug-এর সহজতা দিয়ে দাম দেয়; আজকের compiler সেই হিসাব inline function দিয়ে অনেকটাই নিজে করে।

প্র ০৪Recursion পাঠ্যবইয়ে সুন্দর, অথচ অনেক এমবেডেড coding standard একে নিষেধ করে। কেন, আর 8086-এর stack-এর অভিজ্ঞতা এ বিষয়ে কী শেখায়?

এই পর্বের fact(3) তিনটি frame নিয়েছে, প্রতিটি ৬ byte. সংখ্যাটি ছোট, কিন্তু মূল কথা হলো stack-এর খরচ নির্ভর করে input-এর ওপর: fact(n)-এর জন্য ৬n byte. যে function-এর গভীরতা চলার সময়ের data-র ওপর নির্ভর করে, তার সর্বোচ্চ stack ব্যবহার আগে থেকে নিশ্চিত করে বলা কঠিন। একটি PC-তে OS stack-এর সীমা পেরোলে program-টি থামিয়ে দেয়, অন্তত ত্রুটি জানা যায়। কিন্তু 8086-এ কোনো সীমা পরীক্ষাই নেই, আর অনেক ছোট microcontroller-এও MPU না থাকলে নেই। Stack নামতে নামতে অন্য data-র ওপর লিখে ফেলে, আর ভুলটি দেখা দেয় সম্পূর্ণ অন্য জায়গায়, অনেক পরে।

এজন্য নিরাপত্তা-সংবেদনশীল এমবেডেড কোডের নিয়মগুলো সাধারণত recursion নিষেধ করে। বহুল ব্যবহৃত MISRA C নির্দেশিকার ২০১২ সংস্করণে একটি নিয়ম (Rule 17.2) বলে, function প্রত্যক্ষ বা পরোক্ষভাবে নিজেকে ডাকবে না। উদ্দেশ্য একটাই: যাতে প্রতিটি task-এর সর্বোচ্চ stack ব্যবহার static analysis দিয়ে, কোড না চালিয়েই, হিসাব করা যায়। Call graph-এ কোনো চক্র না থাকলে সবচেয়ে গভীর পথের frame-গুলো যোগ করলেই উত্তর পাওয়া যায়; চক্র থাকলে যায় না। Compiler-গুলো প্রতিটি function-এর frame-এর মাপ জানাতে পারে (যেমন GCC-র -fstack-usage), আর এই সংখ্যা দিয়ে পর্ব ৩৯-এ stack-এর মাপ ঠিক করা দেখবেন।

তাহলে recursion-এর কাজ কীভাবে হয়? বেশিরভাগ ক্ষেত্রে একটি loop দিয়েই: factorial একটি loop আর একটি গুণফল দিয়ে লেখা যায়, যেখানে stack-এর খরচ স্থির। গাছের মতো data-র জন্য নিজের তৈরি নির্দিষ্ট মাপের একটি stack (array) ব্যবহার করা যায়, যার উপচে পড়া কোড নিজে পরীক্ষা করে। পাঠ্যবইয়ে recursion শেখার মূল্য তবু কমে না: এটি stack frame বোঝার সবচেয়ে ভালো উপায়, আর এই পর্বের BP-শিকল দেখায় debugger কীভাবে backtrace বানায়। শুধু পণ্যের firmware-এ এর জায়গা হিসাব করে ঠিক করতে হয়।

মূল উপলব্ধি: Recursion-এর প্রতিটি স্তর stack-এ জায়গা নেয়, আর সেই মোট পরিমাণ input-এর ওপর নির্ভর করে; যেখানে stack উপচে পড়া চুপচাপ ঘটে, সেখানে আগে থেকে হিসাবযোগ্য loop বেশি নিরাপদ।

প্র ০৫BP-র শিকল (saved BP → saved BP → …) শুধু parameter খোঁজার কৌশল, নাকি এর আরও বড় ভূমিকা আছে? আধুনিক compiler কেন কখনো কখনো একে বাদ দেয়?

প্রতিটি frame-এর শুরুতে push bp আগের frame-এর BP রাখে, আর mov bp,sp নতুন frame-এর নোঙর বানায়। ফলে মেমরিতে একটি linked list তৈরি হয়: বর্তমান BP থেকে শুরু করে [bp] পড়লে আগের frame, তার [bp] পড়লে তারও আগেরটি, আর প্রতিটি frame-এর [bp+2]-এ ফেরার ঠিকানা। এই পর্বের frames.py ঠিক এই শিকল ধরে হেঁটেছে: FFECH → FFF2H → FFF8H. একটি debugger একই কাজ করে “call stack” বা backtrace দেখায়: কোন function কাকে ডেকেছে, আর প্রতিটি কোন লাইনে থেমে আছে। Program crash করলে এই তালিকাই প্রথম সূত্র। Profiler-গুলোও এভাবে সময়ের হিসাব function অনুযায়ী ভাগ করে।

অর্থাৎ BP-র শিকল একটি frame pointer-এর শিকল, আর এর মূল্য programmer-এর জন্য, শুধু CPU-র জন্য নয়। 8086-এ এটি বাধ্যতামূলকও ছিল, কারণ [sp+n] লেখা যায় না, তাই stack-এর ভেতরের data পড়তে BP লাগতই। ৩২ বিটের 80386-এ ESP দিয়ে সরাসরি ঠিকানা বানানো সম্ভব হলো। তখন compiler-রা দেখল, BP-কে frame-এর কাজ থেকে মুক্তি দিলে একটি বাড়তি সাধারণ register পাওয়া যায়, আর প্রতিটি function-এর শুরু-শেষের দুই-তিনটি নির্দেশ বাঁচে। x86-এর মতো কম register-এর CPU-তে একটি বাড়তি register অনেক সময় গতিতে স্পষ্ট পার্থক্য আনত। তাই optimization চালু থাকলে GCC-র মতো compiler প্রায়ই frame pointer বাদ দেয়।

বাদ দেওয়ার দাম হলো backtrace-এর জন্য অন্য তথ্য লাগে: compiler প্রতিটি function-এর জন্য আলাদা টেবিল (unwind তথ্য) তৈরি করে, যা দেখে debugger বোঝে কোন মুহূর্তে frame কত বড়। এমবেডেড কাজে, যেখানে crash-এর পরে শুধু একটি stack dump হাতে থাকে, অনেক দল ইচ্ছা করে frame pointer চালু রাখে, কারণ শিকলটি থাকলে কয়েক লাইনের কোড দিয়েই ফেরার ঠিকানার তালিকা বের করা যায়। Cortex-M-এর HardFault handler-এ stack-এ রাখা register পড়ে কারণ খোঁজা পর্ব ৬১-এ দেখবেন, যা একই ধারণার রূপ।

মূল উপলব্ধি: BP-র শিকল parameter খোঁজার পাশাপাশি program-এর ডাকের ইতিহাস মেমরিতে লিখে রাখে; একে বাদ দিলে একটি register আর কয়েকটি নির্দেশ বাঁচে, কিন্তু debug করার সহজ পথটি হারায়।

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি program-এর উত্তর কোর্সের 8086 runner-এ চালিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — net ওজনের procedure: একটি near procedure net_wt লিখুন, যা stack-এ দুটি parameter নেয়, gross (প্রথম) আর tare (দ্বিতীয়), আর AX-এ net = gross − tare ফেরত দেয়। Procedure নিজে stack পরিষ্কার করবে। gross = 1400 g, tare = 150 g দিয়ে ডাকুন। শেষে AX আর SP কত?
    ; ex1.asm - net = gross - tare, parameters on the stack, callee cleans
            org 100h
            mov ax, 150
            push ax             ; tare  -> [bp+6]
            mov ax, 1400
            push ax             ; gross -> [bp+4]
            call net_wt
            mov [net], ax
            hlt
    net_wt: push bp
            mov bp, sp
            mov ax, [bp+4]
            sub ax, [bp+6]
            pop bp
            ret 4               ; remove 2 parameters
    net:    dw 0

    Tare আগে push করায় gross থাকে [bp+4]-এ আর tare [bp+6]-এ। ret 4 (C2 04 00) ফিরে দুটি word সরায়, তাই caller-এ কোনো add sp নেই। সত্যিকারের run: AX=04E2 SP=FFFE, 1000:011C E2 04 (net = 1250 g, README-র সঙ্গে মেলে), আর stack-এ রয়ে যাওয়া 1000:FFF6 00 00 0B 01 78 05 96 00: পুরোনো BP, ফেরার ঠিকানা 010BH, gross 0578H, tare 0096H. ১৩টি নির্দেশ (HLT-সহ)।

  2. ভুল খুঁজুন — হারিয়ে যাওয়া pop: নিচের program-এ price_p শুরুতে push bx করে কিন্তু শেষে pop bx ভুলে গেছে। Program-টি ক্র্যাশ না করে “ঠিকঠাক” শেষ হয়, অথচ [r]-এ 8188 নেই। কেন? mov ax,1250 / call price_p / mov [r],ax / hlt; price_p: push bx / mov bx,6550 / mul bx / add ax,500 / adc dx,0 / mov bx,1000 / div bx / ret.

    call ফেরার ঠিকানা 0106H রাখে FFFCH-এ, তারপর push bx BX = 0000H রাখে FFFAH-এ। ret stack-এর মাথা থেকে word তোলে, অর্থাৎ 0000H, ফেরার ঠিকানা নয়। IP = 0000H, আর lab-এর .COM মডেলে 1000H:0000H-এ বসানো আছে INT 20h (Spec decision 13), তাই program “স্বাভাবিকভাবে” শেষ হয়। সত্যিকারের run-এর শেষ দুই trace লাইন: ret … SP=FFFC IP=0000, তারপর 1000:0000 CD20; ফল [exit code 0 via INT 20h, 11 instructions], 1000:011C 00 00: mov [r],ax কখনো চলেনি, যদিও AX-এ ঠিকই 1FFCH ছিল। SP = FFFCH-এ থেমেছে, stack অসমান। BX-এ অন্য মান থাকলে CPU সেই ঠিকানায় লাফ দিত, যা আরও খারাপ। ঠিক রূপ: ret-এর আগে pop bx. শিক্ষা: “শেষ হয়েছে” মানেই “ঠিক হয়েছে” নয়; ডাকার আগে আর পরে SP মিলিয়ে দেখুন।

  3. আগে বলুন, তারপর চালান — frame-এর মান: stack_frame.asm-এর weighted procedure-কে (push bp, mov bp,sp, sub sp,2, push bx, local [bp−2] = 100·a, তারপর AX = local + 10·b + c, pop bx, mov sp,bp, pop bp, ret 6) a = 4, b = 5, c = 6 দিয়ে ডাকা হলো (c প্রথমে push, a শেষে; শুরুতে SP = FFFEH, call-এর ঠিকানা 010CH, তিন byte). push bx-এর পরে BP আর SP কত? [bp+4], [bp+6], [bp+8] আর [bp−2]-এ (local লেখার পরে) কী? ফল AX আর ফেরার পরে SP কত?

    তিনটি push: SP = FFF8H. Call: ফেরার ঠিকানা 010FH যায় FFF6H-এ। push bp: FFF4H, আর BP = FFF4H. sub sp,2: SP = FFF2H; push bx: SP = FFF0H. তাই BP = FFF4H, SP = FFF0H. [bp+4] = FFF8H-এ a = 4, [bp+6] = FFFAH-এ b = 5, [bp+8] = FFFCH-এ c = 6, [bp−2] = FFF2H-এ 400 = 0190H. AX = 400 + 50 + 6 = 456 = 01C8H, আর ret 6-এর পরে SP = FFFEH. সত্যিকারের run (ex3.asm): AX=01C8 … SP=FFFE, আর stack-এ রয়ে যাওয়া byte 1000:FFF0 00 00 90 01 00 00 0F 01 04 00 05 00 06 00: সংরক্ষিত BX, local 0190H, পুরোনো BP, ফেরার ঠিকানা, তারপর 4, 5, 6.

  4. রূপান্তর আর হিসাব — MASM থেকে NASM macro: একটি বইয়ে লেখা MASM macro: ABSDIFF MACRO A, B / LOCAL POS / MOV AX, A / SUB AX, B / JNC POS / NEG AX / POS: / ENDM. এটিকে NASM-এ লিখুন, ABSDIFF 1400, 150 আর ABSDIFF 150, 1400 দুবার ব্যবহার করুন, ফল দুটি মেমরিতে রাখুন। দুটি ফল কত, আর একটি expansion কত byte?
    ; ex4.asm - ABSDIFF macro with a local label
            org 100h
    %macro ABSDIFF 2            ; AX = |%1 - %2|
            mov ax, %1
            sub ax, %2
            jnc %%pos
            neg ax
    %%pos:
    %endmacro
            ABSDIFF 1400, 150
            mov [d1], ax
            ABSDIFF 150, 1400
            mov [d2], ax
            hlt
    d1:     dw 0
    d2:     dw 0

    LOCAL POS-এর NASM রূপ %%pos; নাম দেওয়া parameter-এর জায়গায় %1, %2. সত্যিকারের run: 1000:011B E2 04 E2 04, দুটি ফলই 1250, ১০টি নির্দেশ (HLT-সহ)। দ্বিতীয়বার 150 − 1400 ঋণাত্মক, বিয়োগে borrow হয় (CF = 1), তাই JNC লাফ দেয় না আর NEG চিহ্ন উল্টায়। Assembled bytes B8 78 05 2D 96 00 73 02 F7 D8: একটি expansion ১০ byte (mov ৩ + sub ৩ + jnc ২ + neg ২)। %% না দিলে দ্বিতীয় expansion-এ “label inconsistently redefined” ত্রুটি আসত।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রম8086-এ দুটি stack parameter নিয়ে একটি near procedure ডাকা আর ফেরার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Caller দ্বিতীয় parameter push করে, তারপর প্রথমটি
  2. CALL ফেরার IP stack-এ রেখে procedure-এ লাফ দেয়
  3. Procedure push bp আর mov bp,sp দিয়ে frame বানায়
  4. Procedure [bp+4] আর [bp+6] থেকে parameter পড়ে কাজ করে
  5. pop bp আর ret দিয়ে caller-এর কাছে ফেরে
  6. Caller add sp,4 দিয়ে দুটি parameter সরায়

8086-এ SP = FFFEH অবস্থায় একটি far CALL চলল। এর ঠিক পরে SP কত, আর stack-এর মাথায় (SP যেখানে নির্দেশ করে) কী আছে?

  • FFFCH, ফেরার IP
  • FFFAH, ফেরার IP
  • FFFAH, ফেরার CS
  • FFF8H, FLAGS

8086-এর একটি near procedure শুরু হয় push bp আর mov bp,sp দিয়ে। Caller ডাকার আগে দুটি word parameter push করেছিল, শেষেরটি প্রথম parameter. প্রথম parameter কোন ঠিকানায়?

  • [bp]
  • [bp+2]
  • [bp+4]
  • [bp+6]

8086-এর RET 6 নির্দেশ কী করে?

  • IP pop করে, তারপর SP-তে 6 যোগ করে
  • আগে SP-তে 6 যোগ করে, তারপর IP pop করে
  • ফেরার আগে AX-এ 6 রাখে
  • ছয়বার পরপর ফেরে

একটি NASM macro-র দেহ ১৯ byte-এর কোড বানায়। একই কাজের procedure-এর দেহ ১৭ byte, আর প্রতিটি ডাকে (argument রাখা আর CALL) ৬ byte লাগে। কাজটি তিনবার লাগলে মোট কত byte?

  • macro ৫৭, procedure ৬৯
  • macro ১৯, procedure ৩৫
  • macro ৫৭, procedure ১৭
  • macro ৫৭, procedure ৩৫

একটি 8086 procedure নিজের অস্থায়ী মান একটি নির্দিষ্ট মেমরি word-এ রাখে (mov [tmp],ax) আর নিজেকে recursive-ভাবে ডাকে। মূল সমস্যা কী?

  • NASM এমন নির্দেশ assemble করবে না
  • ফেরার ঠিকানা হারিয়ে program আটকে যাবে
  • ভেতরের ডাক বাইরের ডাকের মান মুছে দেয়, তাই procedure reentrant নয়
  • প্রতিটি ডাকে stack overflow হবে

8086-এর জন্য লেখা একটি program-এ mov ax, [sp+4] আর enter 2,0 আছে। NASM-এ cpu 8086 দিয়ে assemble করলে কী হবে?

  • দুটিই ঠিকঠাক assemble হবে
  • দুটিই ত্রুটি দেবে: SP base হতে পারে না, ENTER 80186-এর
  • শুধু ENTER ত্রুটি দেবে
  • শুধু [sp+4] ত্রুটি দেবে

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. Near আর far: near CALL (E8H) IP রাখে, RET (C3H) তোলে; far CALL (9AH) CS তারপর IP রাখে, RETF (CBH) IP তারপর CS তোলে। ধরন মিলতেই হবে।
  2. Frame: push bp, mov bp,sp, sub sp,n; near procedure-এ [bp+2] ফেরার IP, [bp+4] প্রথম parameter, [bp−2] প্রথম local. 8086-এ [sp+n] নেই।
  3. পরিষ্কার: caller add sp,n বা procedure ret n, ঠিক একজন; ডাকার আগে আর পরে SP সমান।
  4. Recursion: প্রতিটি ডাক নিজের frame পায়; fact(n)-এ ৬n byte stack; 8086 stack-এর সীমা পরীক্ষা করে না।
  5. Macro বনাম procedure: macro assemble-এর সময় কপি (%macro/%endmacro, %%label; MASM MACRO/ENDM, LOCAL); procedure চলার সময় ডাকা। Reentrant মানে অস্থায়ী মান stack-এ, global-এ নয়।

পরের পর্বে: পর্ব ১৯ (8086-এর string instruction — MOVS, CMPS, SCAS আর REP). একটি নির্দেশে পুরো block কপি, খোঁজা আর তুলনা: SI, DI, CX আর DF ধাপে ধাপে, সত্যিকারের run দিয়ে।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান