এই পর্বে যা শিখবেন
- 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আর MASMMACROলেখা, 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 (এই পর্ব) |
|---|---|---|
| ডাকার ধরন | একটিই: ১৬ বিটের ঠিকানায় CALL | near (একই segment) আর far (অন্য segment) |
| ফেরার ঠিকানা | PC, ২ byte | near: 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 এই রকম:
| নির্দেশ | Opcode | Stack-এ কী হয় | নতুন CS:IP |
|---|---|---|---|
near direct CALL | E8 + ১৬ বিটের দূরত্ব | IP push | CS একই; IP = পরের IP + দূরত্ব |
near indirect CALL | FF /2 | IP push | IP = register বা মেমরির word |
far direct CALL | 9A + offset + segment | CS push, তারপর IP push | নির্দেশে লেখা segment:offset |
far indirect CALL | FF /3 | CS push, তারপর IP push | মেমরির দুই word (offset, segment) |
near RET · RET n | C3 · C2 + n | IP pop; তারপর SP += n | CS একই |
far RETF · RETF n | CB · CA + n | IP pop, CS pop; তারপর SP += n | stack থেকে |
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 |
- Near call: দুই byte. CPU পরের নির্দেশের IP, 0106H, stack-এ রাখে: SP = FFFEH − 2 = FFFCH. তারপর IP = 010CH. CS ছোঁয়া হয়নি, তাই একটি word-ই যথেষ্ট।
- Near ret.
add ax,axAX-কে 09C4H (2500) করেছে।retFFFCH থেকে 0106H তুলে IP-তে দেয়, SP = FFFEH. মেমরিতে 0106H রয়ে যায়; pop মোছে না, শুধু SP সরায়। - Far call: চার byte. আগে CS (1000H) যায় FFFCH-এ, পুরোনো 0106H-এর ওপর লিখে; তারপর IP (010BH) যায় FFFAH-এ। SP = FFFAH. নতুন CS:IP নির্দেশ থেকে: 1000H:010FH.
- 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-এ তিনটি পথ চালু ছিল, আর প্রতিটির নিজের লাভ-ক্ষতি আছে:
| পথ | উদাহরণ | লাভ | সমস্যা |
|---|---|---|---|
| Register | AX = ওজন, তারপর call price_p | সবচেয়ে দ্রুত, মেমরি লাগে না | register মাত্র কয়েকটি; procedure ভেতরে register নষ্ট করলে caller বিপদে |
| নির্দিষ্ট মেমরি | mov [w], ax, তারপর call | অনেক data পাঠানো যায় | একই ঘর সবার: recursion আর interrupt-এ ভাঙে (অংশ ৭) |
| Stack | push করে 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 যেমন ছিল তেমন ফিরেছে। এবার ভেতরে কী ঘটল, ধাপে ধাপে।
| নির্দেশ | |
| SP · BP | |
| AX · DX | |
| stack |
- দ্বিতীয় parameter আগে। দর 6550 = 1996H stack-এ যায়, SP = FFFCH. শেষ parameter আগে push করার কারণ পরের ধাপগুলোতে বোঝা যাবে।
- প্রথম parameter. ওজন 1250 = 04E2H, SP = FFFAH. এখন প্রথম parameter stack-এর মাথার কাছে, নিচের ঠিকানায়।
- Near call. ফেরার ঠিকানা 010BH (
add sp,4-এর ঠিকানা) stack-এ, SP = FFF8H, IP = 010FH. Procedure এখন জানে না parameter কোথায়, শুধু জানে তারা SP-র ওপরে। push bp. Caller-এর BP (এখানে 0000H) বাঁচিয়ে রাখা হলো, কারণ BP এখনই বদলানো হবে। SP = FFF6H.mov bp,sp: frame তৈরি। BP = FFF6H, আর এখন থেকে BP নড়বে না। ওপরে গুনলে: [bp+2] ফেরার ঠিকানা, [bp+4] ওজন, [bp+6] দর। শেষেরটি আগে push করায় প্রথম parameter সবসময় [bp+4]-এ।- Parameter পড়া।
mov ax,[bp+4]দিল 1250, তারপরmul word [bp+6]: 1250 × 6550 = 8187500 = 007CEE6CH, DX:AX-এ। BP-ভিত্তিক ঠিকানা বলে segment SS (পর্ব ১৫)। - গোল করে ভাগ। 500 যোগ, তারপর
div cx(CX = 1000): AX = 1FFCH = 8188 পয়সা। এই সময়েও SP আর BP বদলায়নি; frame স্থির। pop bp. Caller-এর BP ফিরে এল (0000H), SP = FFF8H, ঠিক ফেরার ঠিকানার ওপর। এই ক্রম ভুল হলেretভুল word তুলবে।ret. IP = 010BH, SP = FFFAH. Procedure ফিরেছে, কিন্তু দুটি parameter এখনো stack-এ বসে আছে।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-এর নিজের
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) |
- প্রথম ডাক। Caller 3 push করে,
call factরাখে 0107H, prologue রাখে পুরোনো BP 0000H. BP = SP = FFF8H, [bp+4] = 3. এক frame = n + ফেরার ঠিকানা + BP = ৬ byte. - নিজেকে ডাকা। 3 > 1, তাই
dec ax, 2 push, আবারcall fact. এবার ফেরার ঠিকানা 011BH (procedure-এর ভেতরেরadd sp,2), আর সংরক্ষিত BP = FFF8H, আগের frame-এর নোঙর। নতুন BP = FFF2H. - সবচেয়ে গভীরে। fact(1)-এর frame, BP = SP = FFECH. তিনটি frame একসঙ্গে বেঁচে আছে, মোট ১৮ byte. সংরক্ষিত BP-গুলো একটি শিকল বানায়: FFECH → FFF2H → FFF8H → 0000H.
- Base case. [bp+4] = 1,
jbe .oneলাফ দেয়: AX = 1. তারপরpop bp(BP = FFF2H, আগের frame-এর নোঙর ফিরল) আরret(IP = 011BH). SP = FFF0H: parameter 1 এখনো stack-এ। - fact(2) গুণ করে।
add sp,2parameter সরায় (SP = FFF2H), আরmul word [bp+4]: BP আবার fact(2)-এর frame দেখায়, তাই [bp+4] = 2. AX = 1 × 2 = 2. - fact(3) গুণ করে। fact(2) ফিরল, BP = FFF8H, [bp+4] = 3. AX = 2 × 3 = 6. প্রতিটি স্তর নিজের n ঠিকঠাক পেয়েছে, কারণ n ছিল তার নিজের frame-এ।
- শেষ। শেষ
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-এ লেখার ধরন:
| কাজ | NASM | MASM/TASM |
|---|---|---|
| শুরু | %macro PRICE 2 (২টি parameter) | PRICE MACRO W, R |
| Parameter ব্যবহার | %1, %2 | নাম দিয়ে: W, R |
| নিজস্ব label | %%ok: | LOCAL OK, তারপর OK: |
| শেষ | %endmacro | ENDM |
| ব্যবহার | PRICE 150, 6550 | PRICE 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 0NASM-এর 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 | |
| ফল |
- Assembler একটি macro-র নাম দেখে।
PRICEকোনো 8086 নির্দেশ নয়; NASM জানে এটি আগে%macroদিয়ে সংজ্ঞায়িত। এখনো কোনো byte তৈরি হয়নি। - Expansion. ছাঁচের সাতটি লাইন এই জায়গায় বসে,
%1-এর জায়গায় 150,%2-এর জায়গায় 6550. Listing-এ এগুলো<1>চিহ্নে, offset 0000H থেকে 0012H: ১৯ byte. - আবার ব্যবহার, আবার কপি। দ্বিতীয়
PRICEআরও ১৯ byte বসায় (0016H–0028H). যতবার লিখবেন, ততবার কপি; ১০ বার লিখলে ১৯০ byte. - Procedure ডাকা।
call price_pমাত্র তিন byte (E8 04 00), আর procedure-এর দেহ ১৭ byte একবারই, 0036H থেকে 0046H. যত ডাকই হোক, দেহের কপি একটি। - চলার সময়, macro. CPU-র কাছে এগুলো সাধারণ নির্দেশ, পরপর চলে। কোনো
CALL,RETবা stack-এর লেনদেন নেই; SP পুরো সময় FFFEH. ফল AX = 03D7H = 983 পয়সা। - চলার সময়, 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 পর্ব ৭৮-এ।
| বিষয় | Macro | Procedure |
|---|---|---|
| কে কাজ করে | assembler, assemble-এর সময় | CPU, চলার সময় |
| কোডের মাপ | প্রতি ব্যবহারে পুরো কপি | দেহ একবার, প্রতি ডাকে কয়েক byte |
| গতি | CALL/RET-এর বাড়তি কাজ নেই | প্রতিটি ডাকে CALL, RET, parameter-এর push |
| Stack | লাগে না | ফেরার ঠিকানা আর parameter-এর জন্য লাগে |
| Parameter | লেখা বদলে বসানো (সংখ্যা, register-এর নাম, এমনকি নির্দেশ) | চলার সময়ের মান (register বা stack) |
| Debug | listing-এ খুলে দেখতে হয় | একটি ঠিকানায় একটি 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-কে কাজে লাগাতে প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:
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-এ চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — 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 0Tare আগে 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-সহ)। -
ভুল খুঁজুন — হারিয়ে যাওয়া
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 bxBX = 0000H রাখে FFFAH-এ।retstack-এর মাথা থেকে 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 মিলিয়ে দেখুন। -
আগে বলুন, তারপর চালান — frame-এর মান: stack_frame.asm-এর
weightedprocedure-কে (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-এ রয়ে যাওয়া byte1000:FFF0 00 00 90 01 00 00 0F 01 04 00 05 00 06 00: সংরক্ষিত BX, local 0190H, পুরোনো BP, ফেরার ঠিকানা, তারপর 4, 5, 6. -
রূপান্তর আর হিসাব — 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 0LOCAL POS-এর NASM রূপ%%pos; নাম দেওয়া parameter-এর জায়গায়%1,%2. সত্যিকারের run:1000:011B E2 04 E2 04, দুটি ফলই 1250, ১০টি নির্দেশ (HLT-সহ)। দ্বিতীয়বার 150 − 1400 ঋণাত্মক, বিয়োগে borrow হয় (CF = 1), তাইJNCলাফ দেয় না আরNEGচিহ্ন উল্টায়। Assembled bytesB8 78 05 2D 96 00 73 02 F7 D8: একটি expansion ১০ byte (mov ৩ + sub ৩ + jnc ২ + neg ২)।%%না দিলে দ্বিতীয় expansion-এ “label inconsistently redefined” ত্রুটি আসত।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রম8086-এ দুটি stack parameter নিয়ে একটি near procedure ডাকা আর ফেরার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Caller দ্বিতীয় parameter push করে, তারপর প্রথমটি
CALLফেরার IP stack-এ রেখে procedure-এ লাফ দেয়- Procedure
push bpআরmov bp,spদিয়ে frame বানায় - Procedure
[bp+4]আর[bp+6]থেকে parameter পড়ে কাজ করে pop bpআরretদিয়ে caller-এর কাছে ফেরে- 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] ত্রুটি দেবে
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Near আর far: near
CALL(E8H) IP রাখে,RET(C3H) তোলে; farCALL(9AH) CS তারপর IP রাখে,RETF(CBH) IP তারপর CS তোলে। ধরন মিলতেই হবে। - Frame:
push bp,mov bp,sp,sub sp,n; near procedure-এ [bp+2] ফেরার IP, [bp+4] প্রথম parameter, [bp−2] প্রথম local. 8086-এ[sp+n]নেই। - পরিষ্কার: caller
add sp,nবা procedureret n, ঠিক একজন; ডাকার আগে আর পরে SP সমান। - Recursion: প্রতিটি ডাক নিজের frame পায়; fact(n)-এ ৬n byte stack; 8086 stack-এর সীমা পরীক্ষা করে না।
- Macro বনাম procedure: macro assemble-এর সময় কপি (
%macro/%endmacro,%%label; MASMMACRO/ENDM,LOCAL); procedure চলার সময় ডাকা। Reentrant মানে অস্থায়ী মান stack-এ, global-এ নয়।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ১২ · 8085-এর stack আর subroutineতুলনার জন্য৮ বিটের পূর্বসূরিতে CALL, RET, PUSH আর POP.
- Computer Architecture পর্ব ৩০ · Procedure আর stackপাশের ট্র্যাকRISC-V-এর চোখে function call, link register আর frame.
- Programming Languages & Compilers পর্ব ৭১ · Calling convention আর ABIপাশের ট্র্যাকCompiler-এর দিক থেকে parameter, register আর stack-এর চুক্তি।
- C প্রোগ্রামিং পর্ব ২৭ · Preprocessor আর macroপাশের ট্র্যাক#define-এর macro, তার ফাঁদ আর inline function.