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

8086-এর addressing mode আর effective address

8086 Addressing Modes and Effective Address

Taught in Bangla, this lesson explains how the 8086 forms a 16-bit effective address from base, index and displacement, then adds the segment to reach a 20-bit physical address. It covers the eight addressing modes, the ModR/M byte's 24 memory forms, default segments (BP means SS), override prefixes and I/O port addressing. Code assembled with NASM and run on Unicorn shows [bp] and [bx] reading different bytes, and in-page Python decodes ModR/M and solves exam address questions.

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

  • যেকোনো 8086 operand দেখে তার addressing mode, effective address আর physical address হিসাব করা
  • কোন segment default, কখন SS আর কখন DS, আর segment override prefix দিয়ে তা বদলানো
  • ModR/M byte-এর mod, reg, r/m field থেকে হাতে encode আর decode করা
  • বাজারঘরের দামের টেবিলে array আর struct-এর মতো data পড়তে কোন mode কেন সুবিধাজনক
  • NASM আর MASM-এর লেখার পার্থক্য, অবৈধ রূপ আর AI-এর সাধারণ ভুল চেনা

১ · 8085 থেকে 8086 — operand খোঁজার নিয়ম বড় হলো

পর্ব ১০-এ দেখেছেন, addressing mode হলো instruction-এর operand কোথায় পাওয়া যাবে তা বলার নিয়ম। 8085-এ pointer ছিল কার্যত একটিই, HL. Array-র i-তম ঘরে যেতে হলে DAD দিয়ে আলাদা যোগ করে নিতে হতো, কারণ indexed mode ছিল না। ১৯৭৮ সালে Intel-এর 8086 এই অভাব পূরণ করে চারটি register দিয়ে, যারা memory-র ঠিকানা ধরতে পারে: BX, BP, SI, DI. এর সঙ্গে instruction-এর ভেতরের একটি স্থির সংখ্যা যোগ করা যায়। এই তিন অংশের যোগফলকে বলে effective address (EA).

উপমা — পোস্ট অফিসের ঠিকানা: একটি চিঠির ঠিকানায় থাকে এলাকা (যেমন “মিরপুর”), তারপর বাড়ির নম্বর। 8086-এর segment সেই এলাকা, আর EA হলো এলাকার ভেতরে বাড়ির নম্বর। বাড়ির নম্বর আবার কয়েক ভাগে বলা যায়: “রোড ১২-র শুরু থেকে” (base), “ছয় নম্বর বাড়ি” (index), “তার দোতলা” (displacement). ডাকপিয়ন তিনটি যোগ করে বাড়ি খোঁজেন, তারপর এলাকার নাম মিলিয়ে চিঠি পৌঁছান। এলাকার নাম না লিখলে পোস্ট অফিস ধরে নেয় চিঠি স্থানীয়, ঠিক যেমন 8086 ধরে নেয় DS. শুধু একটি ব্যতিক্রম: “রোড” যদি BP হয়, এলাকা ধরে নেওয়া হয় SS.

বিষয়80858086
Memory-র ঠিকানা ধরা registerHL (আর LDAX-এ BC, DE)BX, BP, SI, DI
Register + স্থির সংখ্যানেই৮ বা ১৬ বিটের displacement
দুই register-এর যোগনেই (DAD দিয়ে আলাদা)base + index, এক instruction-এ
ঠিকানার মাপ১৬ বিট, ৬৪ KB১৬ বিটের EA + segment = ২০ বিট, ১ MB

Segment, BIU আর physical address-এর মূল কথা পর্ব ১৪ (8086-এর গঠন — BIU, EU, segment আর physical address)-এর বিষয়; এখানে এক লাইনে মনে করিয়ে দিই। 8086-এর register ১৬ বিটের, কিন্তু address bus ২০ বিটের, তাই memory ১ MB. ২০ বিটের physical address বানাতে একটি segment register-এর মানকে ১৬ দিয়ে গুণ করে (hex-এ শেষে একটি 0 বসিয়ে) তার সঙ্গে ১৬ বিটের offset যোগ করা হয়: PA = segment × 10H + offset. Memory operand-এর ক্ষেত্রে এই offset-ই EA. Addressing mode-এর সাধারণ তত্ত্ব Computer Architecture পর্ব ২৮-এ, আর segment-এর OS-দিক Operating Systems পর্ব ৩৪-এ।

লেখার নিয়ম: এই পর্বে সংখ্যা Intel-এর ধরনে, শেষে H দিয়ে hex (যেমন 1020AH), আর segment:offset লেখা হবে 1000H:020AH. চালানো যায় এমন code NASM-এর ভাষায়, যেখানে hex লেখা হয় 020Ah বা 0x20A. সব সত্যিকারের run কোর্সের reference lab-এর run8086.py-এ: NASM 3.02 (cpu 8086) দিয়ে assemble, তারপর Unicorn-এর 16-বিট real mode-এ চালানো। Program বসে 1000H:0100H-এ, আর শুরুতে CS = DS = ES = SS = 1000H (Spec decision 13). Lab কীভাবে কাজ করে আর নিজে অনুশীলনের free tool কোনগুলো, তা পর্ব ০৬-এ।

পুরো পর্বে একটিই data: বাজারঘরের স্মার্ট স্কেলের চারটি পণ্যের একটি ছোট টেবিল। DS:0200H থেকে চারটি net ওজন (gram), আর তার ঠিক ৮ byte পরে, DS:0208H থেকে, সেই চারটির দাম (পয়সা), দর 6550 পয়সা/kg (reference README-র “বাজারঘর devices”). দামের সূত্র (net_g × 6550 + 500) / 1000. প্রতিটি word ছোট byte আগে বসে (little-endian).

পণ্য (i)ওজনের offsetওজনদামের offsetদাম
০0200H150 g = 0096H0208H983 পয়সা = 03D7H
১0202H1250 g = 04E2H020AH8188 পয়সা = 1FFCH
২0204H500 g = 01F4H020CH3275 পয়সা = 0CCBH
৩0206H1000 g = 03E8H020EH6550 পয়সা = 1996H

এই টেবিলে একটি ছোট নকশা লুকিয়ে আছে: ওজনের ঘর থেকে ৮ byte এগোলেই একই পণ্যের দাম। তাই base = টেবিলের শুরু, index = 2 × i, আর displacement = 08H হলে [bx+si+08h] দেয় i-তম পণ্যের দাম। পর্বের বাকিটা এই একটি operand-কে ঘিরে।

২ · Immediate, register আর direct — তিনটি সহজ রূপ

প্রথমে একটি program, যা একই টেবিল থেকে আটটি mode দিয়ে data আনে। নিচে NASM-এর NASM listing-এর byte আর run8086.py --trace-এর register একসঙ্গে (সত্যিকারের run, লেখকের lab-এ modes.asm; লাইন ছোট করতে CX, DX-এর বাইরের register বাদ):

$ python -B run8086.py modes.asm --trace
1000:0100  B8E204    mov ax,0x4e2        AX=04E2
1000:0103  89C1      mov cx,ax           AX=04E2 CX=04E2
1000:0105  8B160202  mov dx,[0x202]      DX=04E2
1000:0109  BB0002    mov bx,0x200        BX=0200
1000:010C  8B07      mov ax,[bx]         AX=0096
1000:010E  8B4708    mov ax,[bx+0x8]     AX=03D7
1000:0111  BE0200    mov si,0x2          SI=0002
1000:0114  8B840802  mov ax,[si+0x208]   AX=1FFC
1000:0118  8B00      mov ax,[bx+si]      AX=04E2
1000:011A  8B4008    mov ax,[bx+si+0x8]  AX=1FFC
[exit code 0 via HLT, 11 instructions]

Immediate addressing: মান instruction-এর ভেতরেই। mov ax,1250 হলো B8 E2 04: opcode, তারপর 1250 = 04E2H, ছোট byte আগে। এমন মানকে বলে immediate. Memory-তে কোনো data পড়া হয় না, শুধু instruction-এর byte. Segment-এর প্রশ্নও ওঠে না। mov bx,0200h-ও immediate, যদিও 0200H পরে একটি ঠিকানা হিসেবে কাজে লাগবে; এই মুহূর্তে এটি শুধু একটি সংখ্যা, যা BX-এ বসে।

Register addressing: operand একটি register-এ। mov cx,ax = 89 C1, দুই byte, কোনো memory cycle নেই। দ্বিতীয় byte C1 = 11 000 001: প্রথম দুই বিট 11 মানে “দুটোই register”, পরের তিন বিট AX (000), শেষ তিন বিট CX (001). এই byte-এর নাম ModR/M byte; ৩ নম্বর অংশে এটিকে পুরো খুলে দেখবেন। ৮ বিটের অর্ধেক register (AL, AH, BL…) দিয়েও register addressing চলে, যেমন mov cl,ah.

Direct addressing: instruction-এর ভেতরে memory-র ১৬ বিটের offset. mov dx,[0202h] = 8B 16 02 02: EA = 0202H, segment DS (default), PA = 1000H × 10H + 0202H = 10202H, আর DX = 04E2H, অর্থাৎ ১ নম্বর পণ্যের ওজন ১২৫০ g. Direct addressing-এর এই রূপ 8085-এর LDA 2050H-এর মতো, পার্থক্য দুটি: ঠিকানা segment-এর ভেতরের offset, আর যেকোনো ১৬ বিটের register-এ আনা যায়।

একটি ছোট রহস্য: NASM mov dx,[0202h]-কে ৪ byte বানায়, কিন্তু mov ax,[0208h]-কে ৩ byte: A1 08 02 (লেখকের lab-এ all24.asm-এর listing). কারণ 8086-এ accumulator (AL বা AX) আর direct memory-র মধ্যে MOV-এর জন্য আলাদা ছোট opcode আছে (A0–A3), যেখানে ModR/M byte লাগে না। 8085-এর accumulator-কেন্দ্রিক নকশার একটি ছাপ রয়ে গেছে এখানে।

MASM বা TASM-এ লেখা বইয়ে একটি ফাঁদ আছে, যা NASM-এ নেই। MASM-এ table dw 150, … ঘোষণার পরে mov ax, table লিখলে assembler সেটিকে memory থেকে পড়া (direct) ধরে, কারণ MASM নামের সঙ্গে তার ধরন মনে রাখে; ঠিকানা চাইলে লিখতে হয় mov ax, offset table. NASM-এ নিয়ম একটাই: বন্ধনী মানে memory. mov ax,table ঠিকানা দেয় (immediate), mov ax,[table] data দেয় (direct). এই পর্বের সব code NASM-এ; MASM-এর রূপগুলো Microsoft-এর MASM নথির নিয়ম থেকে লেখা, lab-এ চালানো হয়নি (lab-এ MASM নেই)। ৭ নম্বর অংশে পুরো তুলনার টেবিল।

৩ · Register indirect, based আর indexed — ModR/M byte-এর ভেতরে

এবার ঠিকানা আর instruction-এ লেখা থাকে না, থাকে register-এ। Register indirect addressing-এ EA = একটি register-এর মান: mov ax,[bx] (= 8B 07), BX = 0200H, তাই AX = 0096H = ১৫০ g. 8086-এ এই কাজ পারে শুধু চারটি register: BX, BP, SI, DI. এর সঙ্গে একটি স্থির সংখ্যা যোগ করলে নাম বদলায়। সেই স্থির সংখ্যাকে বলে displacement, ৮ বা ১৬ বিটের, signed.

  • Based addressing: EA = BX বা BP + displacement. mov ax,[bx+08h] = 8B 47 08; EA = 0200H + 08H = 0208H, AX = 03D7H = ৯৮৩ পয়সা। Base ধরে রাখে একটি record বা stack frame-এর শুরু, displacement বলে ভেতরের কোন field.
  • Indexed addressing: EA = SI বা DI + displacement. mov ax,[si+0208h] = 8B 84 08 02; EA = 0002H + 0208H = 020AH, AX = 1FFCH = ৮১৮৮ পয়সা। এখানে displacement-ই array-র শুরু, আর SI চলমান index. এটিই indexed addressing-এর ক্লাসিক রূপ।

দুটির পার্থক্য register-এর ভূমিকায়, যন্ত্রে নয়: CPU দুটিকেই “register + displacement” হিসেবে যোগ করে। কিন্তু পরীক্ষায় নাম আলাদা লিখতে হয়, আর ৫ নম্বর অংশে দেখবেন BP-র ক্ষেত্রে segment-ও আলাদা।

এবার byte-এর ভেতরে তাকাই। ModR/M byte তিন ভাগে: mod (২ বিট), reg (৩ বিট), r/m (৩ বিট). mod বলে displacement কত বড়: 00 = নেই, 01 = ৮ বিট (sign-extended), 10 = ১৬ বিট, 11 = দুটোই register. reg বলে অন্য operand কোন register. আর r/m-এর আটটি কোড আটটি ঠিকানা-ছাঁচ (Intel 8086 Family User’s Manual-এর টেবিল; প্রতিটি সারি NASM listing দিয়ে মেলানো):

r/mmod 00mod 01 / 10Default segment
000[BX+SI][BX+SI+disp]DS
001[BX+DI][BX+DI+disp]DS
010[BP+SI][BP+SI+disp]SS
011[BP+DI][BP+DI+disp]SS
100[SI][SI+disp]DS
101[DI][DI+disp]DS
110[disp16] (direct)[BP+disp]DS / SS
111[BX][BX+disp]DS

৮ × ৩ = ২৪টি memory-রূপ, আর এর বাইরে কিছু নেই। r/m 110-এর সারিটি খেয়াল করুন: mod 00-এ সেখানে [BP] বসার কথা ছিল, কিন্তু Intel ঘরটি দিয়েছে direct addressing-কে। তাহলে mov ax,[bp] কীভাবে লেখা হয়? Assembler সেটিকে বানায় [bp+00h], mod 01 আর শূন্য displacement: 8B 46 00, তিন byte. নিচের stepper-এ একটি পুরো instruction-এর byte খোলা হলো।

126  prefix28B  opcode340  ModR/M408  disp85mov ax,[es:bx+si+08h]
Decode-এর হিসাব
বিট
অর্থ
Segment
EA (BX=0200H, SI=0002H)
  1. প্রথম byte 26. এটি opcode নয়, segment override prefix: “পরের instruction-এর memory operand ES দিয়ে।” এমন byte-এর সাধারণ নাম instruction prefix.
  2. 8B = MOV r16, r/m16. দিক বিট (বিট ১) = 1, তাই গন্তব্য reg-field-এর register, উৎস memory. 89 হলে দিক উল্টো: memory ← register.
  3. 40 = 01 000 000: প্রথম দুই বিট mod = 01. মানে একটি ৮ বিটের displacement আসছে, যা sign-extend হয়ে ১৬ বিটে যোগ হবে।
  4. reg = 000, r/m = 000. reg 000 মানে AX (গন্তব্য). r/m 000 মানে [BX+SI]. BP নেই, তাই default segment হতো DS; কিন্তু prefix থাকায় ES. BX = 0200H আর SI = 0002H হলে এ পর্যন্ত যোগফল 0202H.
  5. 08 = displacement. EA = 0200H + 0002H + 08H = 020AH. NASM-এর listing-এও এই instruction 268B4008, ৪ byte (লেখকের lab-এ all24.asm).
  6. পুরো instruction. mov ax,[es:bx+si+08h]. ES = 2000H হলে PA = 20000H + 020AH = 2020AH. একই byte-এর prefix ছাড়া রূপ 8B 40 08 পড়ত DS:020AH, অর্থাৎ 1020AH.

হাতে decode করা পরীক্ষায় দরকারি দক্ষতা, আর ভুলও সহজ। নিচের ছোট decoder একই নিয়ম দিয়ে byte থেকে instruction, mode আর segment বলে। এর ফল লেখকের lab-এ NASM 3.02-এর listing-এর ২৬টি mov লাইনের সঙ্গে মেলানো হয়েছে (check_a.py: ২৬টি মিল, ০টি অমিল)।

# ModR/M byte থেকে addressing mode: mod (2 বিট), reg (3 বিট), r/m (3 বিট)
RM = ["BX+SI", "BX+DI", "BP+SI", "BP+DI", "SI", "DI", "BP", "BX"]
R16 = ["AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"]
PREFIX = {0x26: "ES", 0x2E: "CS", 0x36: "SS", 0x3E: "DS"}

def mode_name(rm, mod):
    if "+" in RM[rm]: return "based-indexed" + (" + disp" if mod else "")
    if mod == 0: return "register indirect"
    return "based" if RM[rm] in ("BX", "BP") else "indexed"

def decode(code):
    b = bytes.fromhex(code)
    seg = PREFIX.get(b[0])
    b = b[1:] if seg else b                 # segment override prefix
    op, modrm = b[0], b[1]                  # 8B: reg <- r/m,  89: r/m <- reg
    mod, reg, rm = modrm >> 6, modrm >> 3 & 7, modrm & 7
    if mod == 3:
        dst, src = (R16[reg], R16[rm]) if op == 0x8B else (R16[rm], R16[reg])
        return f"MOV {dst},{src}", "register", "-"
    if mod == 0 and rm == 6:                # [BP]-এর ঘরে শুধু disp16
        ea, name = f"{b[2] | b[3] << 8:04X}h", "direct"
    else:
        b += bytes(2)                       # disp না থাকলে শূন্য
        d = [0, b[2] - 256 * (b[2] > 127), b[2] | b[3] << 8][mod]
        ea = RM[rm] + ("" if mod == 0 else f"+{d:0{2 * mod}X}h" if d >= 0 else f"-{-d:X}h")
        name = mode_name(rm, mod)
    used = seg or ("SS" if "BP" in ea else "DS")
    text = f"MOV {R16[reg]},[{ea}]" if op == 0x8B else f"MOV [{ea}],{R16[reg]}"
    return text, name, f"{mod:02b} {reg:03b} {rm:03b} {used}" + ("*" if seg else "")

for code in ["8B07", "8B4708", "8B840802", "8B00", "8B4008", "8B4600",
             "8B160202", "3E8B5600", "268B4008", "8B47FE", "894008", "89C1"]:
    text, name, info = decode(code)
    print(f"{code:9}{text:20}{name:22}{info}")
print("* = segment override prefix")

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

8B07     MOV AX,[BX]         register indirect     00 000 111 DS
8B4708   MOV AX,[BX+08h]     based                 01 000 111 DS
8B840802 MOV AX,[SI+0208h]   indexed               10 000 100 DS
8B00     MOV AX,[BX+SI]      based-indexed         00 000 000 DS
8B4008   MOV AX,[BX+SI+08h]  based-indexed + disp  01 000 000 DS
8B4600   MOV AX,[BP+00h]     based                 01 000 110 SS
8B160202 MOV DX,[0202h]      direct                00 010 110 DS
3E8B5600 MOV DX,[BP+00h]     based                 01 010 110 DS*
268B4008 MOV AX,[BX+SI+08h]  based-indexed + disp  01 000 000 ES*
8B47FE   MOV AX,[BX-2h]      based                 01 000 111 DS
894008   MOV [BX+SI+08h],AX  based-indexed + disp  01 000 000 DS
89C1     MOV CX,AX           register              -
* = segment override prefix

তিনটি জিনিস দেখুন। প্রথমত, 8B4600 আর 8B160202: দুটিরই r/m = 110, কিন্তু mod আলাদা, তাই একটি [BP+00h] আর অন্যটি direct. দ্বিতীয়ত, 8B47FE: displacement FEH-কে signed ধরা হয়, তাই −2, আর [bx-2]-এর জন্য ১৬ বিটের displacement লাগেনি; এক byte বাঁচল। তৃতীয়ত, 3E8B5600: DS-এর prefix বসলে [BP]-এর default SS বদলে DS হয়। কোন mode কোন নামে ডাকা হয়, তা বই ভেদে একটু আলাদা হতে পারে; কিন্তু EA-র সূত্র আর segment-এর নিয়ম সব বইয়ে এক।

৪ · Based-indexed আর displacement — EA থেকে physical address

Based-indexed addressing-এ একসঙ্গে একটি base (BX বা BP) আর একটি index (SI বা DI), ইচ্ছা হলে সঙ্গে displacement: EA = base + index + displacement, ফল ১৬ বিটে। বাজারঘরের টেবিলে mov ax,[bx+si+08h] (BX = 0200H, SI = 0002H) সরাসরি ১ নম্বর পণ্যের দাম আনে। দুটি register-এর ভূমিকা আলাদা: BX বলে কোন টেবিল, SI বলে কোন সারি, আর 08H বলে সারির ভেতরে কোন column. C-তে shop->price[i]-এর মতো একটি struct-এর ভেতরের array, যেখানে compiler ঠিক এমন তিন অংশ দিয়েই ঠিকানা বানায় (C কোর্সের পর্ব ২২).

ছবি ১৫.১ — EA থেকে physical address: দুই ধাপের যোগ

উদাহরণ: mov ax,[bx+si+08h], BX = 0200H, SI = 0002H, DS = 1000H

8086-এর effective address আর physical address BaseIndexDisplacement BX=0200HSI=0002H08H + EA = 020AH ১৬ বিট, segment-এর ভেতরে DS = 1000H BP থাকলে SS, prefix থাকলে সেটি × 10H = 10000H + PA = 1020AH ২০ বিট, address bus-এ যায় 00000HDSESSSFFFFFH 10000H20000H30000H
ছবি ১৫.১ — ডান দিকের পথ EU-র কাজ: instruction থেকে base, index আর displacement নিয়ে ১৬ বিটের EA. বাঁ দিকের পথ BIU-র: segment register-কে ১৬ দিয়ে গুণ। দুই পথ মিলে ২০ বিটের physical address. নিচের দাগে এই পর্বের run-গুলোর তিনটি segment: DS = 1000H, ES = 2000H, SS = 3000H (মাপমতো নয়; প্রতিটি segment ৬৪ KB লম্বা).

নিচের stepper একই হিসাব ধাপে ধাপে করে। শেষ মান সত্যিকারের trace থেকে: mov ax,[bx+si+0x8] AX=1FFC, আর --mem 1000:020A,2 দেখায় FC 1F.

1mov bx,0200h        ; BB 00 022mov si,0002h        ; BE 02 003mov ax,[bx+si+08h]  ; 8B 40 08
EA আর PA-র হিসাব
এখন পর্যন্ত EA
Segment
Segment × 10H
PA
AX
  1. প্রস্তুতি. BX-এ টেবিলের শুরু 0200H, SI-তে 2 × i = 0002H, অর্থাৎ ১ নম্বর পণ্য। AX-এ আগের instruction-এর মান 04E2H রয়ে গেছে (trace-এ mov ax,[bx+si]-এর পরে)।
  2. Base. EU ModR/M byte 40 decode করে বোঝে r/m = 000, মানে BX+SI. প্রথম অংশ BX = 0200H.
  3. Index যোগ. 0200H + 0002H = 0202H. এটি ১ নম্বর পণ্যের ওজনের ঘর; displacement না থাকলে ([bx+si]) এখানেই থামত আর AX = 04E2H = ১২৫০ g পেত।
  4. Displacement যোগ. 0202H + 08H = 020AH. এটিই effective address: ১৬ বিটের offset, segment-এর ভেতরে। এখনো কোনো memory পড়া হয়নি।
  5. Segment বাছাই. EA-তে BP নেই আর কোনো prefix নেই, তাই default segment DS. DS = 1000H, ১৬ দিয়ে গুণ করলে 10000H (hex-এ শেষে একটি শূন্য).
  6. Physical address. 10000H + 020AH = 1020AH, ২০ বিট। BIU এই ঠিকানা address bus-এ দেয়। একই ঘর অন্য segment:offset জোড়ায়ও লেখা যায়: 1020H:000AH বা 0FFFH:021AH; lab-এ তিনটি জোড়াই FC 1F দেখায়।
  7. Data এল. 1020AH-এ FC, 1020BH-এ 1F; ছোট byte আগে, তাই AX = 1FFCH = ৮১৮৮ পয়সা = ৮১.৮৮ টাকা, ১২৫০ g-এর দাম। Intel-এর টেবিলে এই instruction-এর সময় 8 + 11 = ১৯ clock (নিচে দেখুন)।

এখন একটি ছোট হিসাবযন্ত্র, যা যেকোনো register-অবস্থায় EA, segment আর PA বের করে। প্রতিটি সারির register-এর মান এই পর্বের সত্যিকারের run থেকে নেওয়া (modes.asm, bpss.asm, esovr.asm, wrap.asm), আর প্রতিটি PA-তে run-এর memory dump একই data দেখিয়েছে।

# EA (16 বিট) আর physical address (20 বিট): PA = segment × 10h + EA
def pa(regs, base=None, index=None, disp=0, seg=None):
    ea = (regs.get(base, 0) + regs.get(index, 0) + disp) & 0xFFFF   # 16 বিটে মোড়ে
    if seg is None:                                  # default segment
        seg = "SS" if base == "BP" else "DS"
    phys = (regs[seg] * 0x10 + ea) & 0xFFFFF        # 8086-এ 20 বিট
    return ea, seg, phys

def show(label, regs, **kw):
    ea, seg, phys = pa(regs, **kw)
    print(f"{label:16} EA={ea:04X}h  {seg}={regs[seg]:04X}h  PA={phys:05X}h")

# modes.asm-এর শেষ অবস্থা (run8086.py)
r = {"DS": 0x1000, "SS": 0x1000, "ES": 0x1000, "BX": 0x0200, "SI": 0x0002}
show("[0202h]", r, disp=0x0202)
show("[BX]", r, base="BX")
show("[BX+08h]", r, base="BX", disp=8)
show("[SI+0208h]", r, index="SI", disp=0x208)
show("[BX+SI+08h]", r, base="BX", index="SI", disp=8)
# bpss.asm: SS আলাদা, BX = BP = 03FEh
r = {"DS": 0x1000, "SS": 0x3000, "ES": 0x1000, "BX": 0x03FE, "BP": 0x03FE}
show("[BP]", r, base="BP")
show("[BX]", r, base="BX")
show("[DS:BP]", r, base="BP", seg="DS")
# esovr.asm: ES = 2000h, DI = 0040h
show("[ES:DI]", {"ES": 0x2000, "DI": 0x40}, index="DI", seg="ES")
# wrap.asm: FFF0h + 0010h + 08h ছাড়িয়ে যায় 16 বিট
show("wrap [BX+SI+08h]", {"DS": 0x1000, "BX": 0xFFF0, "SI": 0x10},
     base="BX", index="SI", disp=8)

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

[0202h]          EA=0202h  DS=1000h  PA=10202h
[BX]             EA=0200h  DS=1000h  PA=10200h
[BX+08h]         EA=0208h  DS=1000h  PA=10208h
[SI+0208h]       EA=020Ah  DS=1000h  PA=1020Ah
[BX+SI+08h]      EA=020Ah  DS=1000h  PA=1020Ah
[BP]             EA=03FEh  SS=3000h  PA=303FEh
[BX]             EA=03FEh  DS=1000h  PA=103FEh
[DS:BP]          EA=03FEh  DS=1000h  PA=103FEh
[ES:DI]          EA=0040h  ES=2000h  PA=20040h
wrap [BX+SI+08h] EA=0008h  DS=1000h  PA=10008h

শেষ সারিটি পরীক্ষার প্রিয় ফাঁদ। FFF0H + 0010H + 08H = 10008H, কিন্তু EA ১৬ বিটের, তাই উপরের 1 হারিয়ে যায় আর EA = 0008H; ঠিকানা segment-এর শেষ পেরিয়ে পরের segment-এ যায় না, একই segment-এর শুরুতে ঘুরে আসে (wrap-around). Lab-এ wrap.asm আগে DS:0008H-এ 1250 রেখে তারপর এই operand পড়ে; trace-এ mov ax,[bx+si+0x8] AX=04E2. সূত্রে & 0xFFFF ঠিক এই কাজটি করে। আর ৬ নম্বর থেকে ৮ নম্বর সারি: একই EA 03FEH দুটি আলাদা ঘর দেখায়, segment কোনটি তার ওপর নির্ভর করে। পরের অংশ এর বিষয়।

EA-কে data ছাড়াই পেতে চাইলে আছে LEA: lea ax,[bx+si+08h] একই যোগ করে, কিন্তু memory-তে যায় না, শুধু EA-টি register-এ রাখে। সত্যিকারের run (lea.asm): 8D4008 lea ax,[bx+si+0x8] AX=020A, আর পরের 8B5008 mov dx,[bx+si+0x8] DX=1FFC. একই ModR/M byte 40/50-এর ছাঁচ, একটি দেয় ঠিকানা, অন্যটি সেই ঠিকানার data. LEA-র পুরো ব্যবহার পর্ব ১৬ (8086-এর instruction set)-এ।

৫ · Default segment আর segment override

প্রতিটি memory operand-এর একটি default segment আছে, যা instruction-এ লেখা না থাকলেও CPU নিজে বেছে নেয়। Intel-এর নিয়ম (8086 Family User’s Manual-এর segment-override টেবিল):

কোন ধরনের memory কাজDefaultOverride চলে?Offset আসে
Instruction fetchCSনাIP
Stack: PUSH, POP, CALL, RETSSনাSP
EA-তে BP আছেSSহ্যাঁ: CS, DS, ESEA
অন্য সব data (BX, SI, DI, direct)DSহ্যাঁ: CS, SS, ESEA
String instruction-এর উৎসDSহ্যাঁSI
String instruction-এর গন্তব্যESনাDI

BP কেন SS-এর দিকে যায়? কারণ BP-র কাজ stack-এর ভেতরে পড়া: একটি procedure নিজের parameter আর local variable খোঁজে [bp+4], [bp-2] দিয়ে, আর সেগুলো থাকে stack-এ (stack frame-এর পুরো ছবি পর্ব ১৮-এ)। ছোট .COM program-এ SS = DS, তাই পার্থক্য চোখে পড়ে না। কিন্তু MASM-এর .EXE program-এ stack সাধারণত আলাদা segment-এ, আর তখন [bp] আর [bx] একই সংখ্যা নিয়েও আলাদা ঘর পড়ে। নিচের run-এ ঠিক এটাই করা হলো: SS = 3000H আর DS = 1000H, দুই segment-এর একই offset 03FEH-এ দুটি আলাদা মান।

1mov word [03FEh],81882mov ax,3000h3mov ss,ax4mov sp,0400h5mov ax,12506push ax7mov bp,sp8mov bx,bp9mov ax,[bp]10mov cx,[bx]11mov dx,[ds:bp]12mov si,[ss:bx]
Register আর memory
SS SP
BP BX
AX CX
DX SI
এই ধাপের PA
  1. দামের ঘর তৈরি. mov word [03FEh],8188 (= C7 06 FE 03 FC 1F) DS:03FEH-এ 1FFCH লেখে: PA = 10000H + 03FEH = 103FEH. এটি direct addressing আর immediate উৎস একসঙ্গে।
  2. আলাদা stack segment. Segment register-এ সরাসরি immediate বসানো যায় না, তাই আগে AX = 3000H, তারপর mov ss,ax. এখন SS = 3000H, DS আগের মতো 1000H, ঠিক একটি .EXE program-এর মতো।
  3. SP = 0400H. Stack-এর শীর্ষ এখন 3000H:0400H, PA 30400H.
  4. push ax (AX = 1250 = 04E2H). SP কমে 03FEH, আর SS:03FEH-এ বসে E2 04: PA = 30000H + 03FEH = 303FEH. Stack-এর কাজ সবসময় SS, override করা যায় না। Lab-এর dump: 3000:03FE E2 04.
  5. দুটি pointer, একই সংখ্যা. mov bp,sp আর mov bx,bp: BP = BX = 03FEH. সংখ্যা এক, কিন্তু দেখুন পরের দুই ধাপে কী হয়।
  6. mov ax,[bp]. Byte 8B 46 00: আসলে [BP+00H]. BP আছে, তাই segment SS: PA 303FEH, AX = 04E2H = ১২৫০ g, stack-এ রাখা ওজন।
  7. mov cx,[bx]. Byte 8B 0F. BX-এর default DS: PA 103FEH, CX = 1FFCH = ৮১৮৮ পয়সা, দামের ঘর। একই EA, ভিন্ন ঘর, ভিন্ন মান।
  8. mov dx,[ds:bp]. NASM আগে 3E prefix বসায়: 3E 8B 56 00. BP থাকা সত্ত্বেও segment এখন DS: DX = 1FFCH.
  9. mov si,[ss:bx]. উল্টো দিকে: 36 8B 37, BX-কে SS দিয়ে: SI = 04E2H. শেষ trace-লাইন: AX=04E2 BX=03FE CX=1FFC DX=1FFC SI=04E2 … SS=3000, মোট ১৩টি instruction (HLT সহ).

Override-এর সবচেয়ে সাধারণ ব্যবহার ES: data যখন অন্য segment-এ লিখতে হয়। ধরা যাক বাজারঘরের দোকানের display-এর জন্য একটি buffer আছে 2000H segment-এ। চারটি দাম টেবিল থেকে পড়ে buffer-এ বসাতে হবে: উৎস DS-এ, গন্তব্য ES-এ। সত্যিকারের run (esovr.asm), শেষ অবস্থা: 2000:0040 D7 03 FC 1F CB 0C 96 19, [exit code 0 via HLT, 30 instructions].

1mov ax,2000h / mov es,ax2mov bx,0200h / mov si,03mov di,0040h4next: mov ax,[bx+si+08h]5mov [es:di],ax ; 26 89 056add si,2 / add di,27cmp si,8 / jne next8hlt
Pointer, data আর buffer
SI DI
উৎস PA
গন্তব্য PA
AX
2000H:0040H…
  1. দুই segment প্রস্তুত. ES = 2000H (buffer), DS = 1000H (টেবিল, lab-এর শুরুর মান). BX = 0200H, SI = 0 (পণ্য ০), DI = 0040H (buffer-এর offset).
  2. পড়া: [bx+si+08h]. EA = 0200H + 0 + 08H = 0208H, default DS: PA 10208H. AX = 03D7H = ৯৮৩ পয়সা।
  3. লেখা: [es:di]. Byte 26 89 05: prefix 26 (ES), 89 (memory ← register), ModR/M 05 = 00 000 101 = [DI]. EA = 0040H, PA = 20000H + 0040H = 20040H. Prefix না দিলে লেখা যেত DS:0040H-এ, অর্থাৎ 10040H-এ: buffer-এ নয়, program-এর নিজের segment-এর শুরুর এলাকায়, কোনো error ছাড়াই।
  4. Pointer এগোল. SI = 0002H, DI = 0042H. cmp si,8 সমান নয়, তাই jne লাফ দেয় ৪ নম্বর লাইনে।
  5. দ্বিতীয় পাক. EA = 020AH, PA 1020AH থেকে AX = 1FFCH; লেখা 20042H-এ। Trace-এ দ্বিতীয় পাকের প্রথম লাইন: mov ax,[bx+si+0x8] AX=1FFC … DI=0042.
  6. তৃতীয় আর চতুর্থ পাক. 1020CH থেকে 0CCBH যায় 20044H-এ, 1020EH থেকে 1996H যায় 20046H-এ। চতুর্থ পাকের পরে SI = 0008H, cmp-এ ZF = 1, লাফ নেই।
  7. শেষ. Buffer-এ চারটি দাম, little-endian: D7 03 FC 1F CB 0C 96 19. মোট instruction: শুরুর ৫টি + ৪ পাক × ৬টি + HLT = ৩০, run-এর শেষ লাইনের সঙ্গে মেলে।

এই কাজের জন্য 8086-এর নিজস্ব string instruction আছে (MOVSW, যেখানে উৎস DS:SI আর গন্তব্য ES:DI নিজে থেকেই); সেগুলো পর্ব ১৯ (8086-এর string instruction)-এ।

যে রূপ চলে না: 16-বিট addressing-এ base শুধু BX বা BP, index শুধু SI বা DI, প্রতিটি থেকে বড়জোর একটি, আর কোনো গুণ (scale) নেই। ModR/M-এর আট ঘরে এর বাইরে কিছু আঁটে না। NASM 3.02 প্রতিটি অবৈধ রূপে থামে (সত্যিকারের run, bad.asm):

bad.asm:2: error: invalid 16-bit effective address    ; mov ax,[cx]
bad.asm:3: error: invalid 16-bit effective address    ; mov ax,[bx+bp]
bad.asm:4: error: invalid 16-bit effective address    ; mov ax,[si+di]
bad.asm:5: error: invalid 16-bit effective address    ; mov ax,[bx*2]
bad.asm:7: error: invalid 16-bit effective address    ; mov ax,[sp]

(ডান দিকের মন্তব্য লাইন চেনার জন্য যোগ করা।) [sp] নেই বলেই stack-এর ভেতরে পড়তে BP লাগে: আগে mov bp,sp, তারপর [bp+…]. ৮০৩৮৬ থেকে ৩২ বিটের addressing-এ যেকোনো register আর ×২, ×৪, ×৮ গুণ এসেছে, কিন্তু 8086-এ নয়।

Operand-এর জোড়াতেও তিনটি নিষেধ আছে, যা প্রায়ই পরীক্ষায় “ভুল খুঁজুন” হয়ে আসে। NASM 3.02-এর সত্যিকারের বার্তা (bad2.asm):

bad2.asm:2: error: invalid combination of opcode and operands   ; mov ds,2345h
bad2.asm:3: error: invalid combination of opcode and operands   ; mov [0200h],[0208h]
bad2.asm:4: error: invalid combination of opcode and operands   ; mov es,ds
  • Segment register-এ immediate নেই: mov ds,2345h চলে না; আগে একটি general register-এ, তারপর mov ds,ax. এজন্যই এই পর্বের প্রতিটি program-এ mov ax,2000h / mov es,ax জোড়া।
  • দুটি memory operand একসঙ্গে নেই: একটি instruction-এ ModR/M মাত্র একটি, তাই memory-ও একটিই। Memory থেকে memory-তে নিতে register হয়ে যেতে হয় (বা string instruction, পর্ব ১৯).
  • Segment থেকে segment-এ সরাসরি নেই: mov es,ds চলে না; push ds / pop es বা একটি general register দিয়ে।

একটি অদ্ভুত ব্যতিক্রম: mov cs,ax NASM কোনো error ছাড়াই 8E C8 বানিয়ে দিল, কিন্তু Intel-এর manual CS-কে MOV-এর গন্তব্য হিসেবে অনুমোদন করে না, আর পরের x86 CPU-গুলোতে এটি invalid opcode বলে জানা যায়। CS বদলানোর বৈধ পথ far JMP, far CALL, RET বা interrupt. Assembler গ্রহণ করল মানেই instruction নিরাপদ, এমন নয়। আরেকটি ছোট বিষয় listing-এ চোখে পড়ে: add si,2 = 83 C6 02, যেখানে immediate মাত্র এক byte. Opcode 83-এর immediate ৮ বিটের, যা CPU sign-extend করে ১৬ বিটে নেয়; ছোট সংখ্যার জন্য এক byte বাঁচানোর আরেকটি কৌশল, ঠিক disp8-এর মতো।

সময়ের দাম (datasheet-এর মান): কোর্সের lab 8086-এর clock গোনে না (Spec decision 16), তাই নিচের সংখ্যাগুলো Intel 8086 Family User’s Manual-এর instruction-timing টেবিল থেকে, মাপা নয়। EA হিসাব করতে EU-র নিজের সময় লাগে, যা instruction-এর মূল সময়ের সঙ্গে যোগ হয়।

EA-র অংশউদাহরণEA clock
শুধু displacement (direct)[0202h]6
শুধু base বা index[bx], [si]5
base বা index + displacement[bx+08h], [si+0208h]9
base + index: BP+DI, BX+SI[bx+si]7
base + index: BP+SI, BX+DI[bx+di]8
base + index + disp: BP+DI, BX+SI[bx+si+08h]11
base + index + disp: BP+SI, BX+DI[bp+si+08h]12
segment override থাকলে[es:di]+2

একই টেবিলে MOV reg,mem = 8 + EA, MOV mem,reg = 9 + EA, MOV reg,reg = 2, MOV reg,imm = 4. তাই mov ax,[bx+si+08h] = 8 + 11 = ১৯ clock, আর mov [es:di],ax = 9 + 5 + 2 = ১৬ clock. Intel-এর টেবিলের নোট অনুযায়ী 8086-এ বিজোড় ঠিকানার word পড়তে আরও ৪ clock লাগে, কারণ তখন দুটি bus cycle লাগে (পর্ব ২১-এ BHE̅ আর A0-এর হিসাব). এই টেবিল ধরে নেয় instruction আগেই queue-তে আছে; queue খালি থাকলে বা bus ব্যস্ত থাকলে আসল সময় আরও বেশি হতে পারে।

এই সংখ্যা থেকে একটি বাস্তব সিদ্ধান্ত বের হয়। বাজারঘরের দামের loop-এ প্রতিটি পড়া [bx+si+08h] দিয়ে করলে EA-র জন্য প্রতিবার ১১ clock. বিকল্প: loop-এর আগে একবার lea si,[bx+08h] করে SI-কে সরাসরি দামের অংশে বসানো, তারপর ভেতরে শুধু [si], যার EA ৫ clock. চার পাকে Intel-এর টেবিল অনুযায়ী প্রায় ২৪ clock বাঁচে, আর instruction-ও এক byte ছোট হয় (displacement নেই)। ছোট loop-এ এই লাভ নগণ্য, কিন্তু হাজার বার ঘোরা loop-এ চোখে পড়ার মতো। Compiler-এর optimizer ঠিক এই কাজটি করে, যার নাম strength reduction. তবে মনে রাখুন, এগুলো datasheet-এর হিসাব; কোর্সের lab সময় মাপে না।

৬ · I/O port addressing — memory-র বাইরের আলাদা জগৎ

8086-এ memory ছাড়াও একটি আলাদা ঠিকানা-জগৎ আছে: I/O port, ৬৪K পর্যন্ত, যেখানে keypad, display বা timer chip-এর register বসে। এখানে segment নেই, EA নেই; শুধু IN আর OUT instruction এখানে পৌঁছায়। এই নকশার নাম port-mapped I/O. Port-এর ঠিকানা দুইভাবে বলা যায় (সত্যিকারের NASM listing, io.asm):

00000000 E440       in al, 40h     ; fixed port (0-255)
00000002 E642       out 42h, al
00000004 BA0003     mov dx, 0300h
00000007 EC         in al, dx      ; variable port (0-65535) in DX
00000008 EE         out dx, al
00000009 ED         in ax, dx      ; 16-bit transfer
  • Fixed (direct) port: port নম্বর instruction-এর দ্বিতীয় byte-এ, তাই ০ থেকে ২৫৫. in al,40h = E4 40, ঠিক 8085-এর IN 01H-এর মতো।
  • Variable (indirect) port: port নম্বর DX-এ, তাই পুরো ১৬ বিট, ০ থেকে ৬৫৫৩৫, আর instruction মাত্র ১ byte (EC). DX এখানে register indirect-এর pointer-এর মতো কাজ করে। ২৫৫-এর বেশি port-এ যাওয়ার এটিই একমাত্র পথ।

দুই রূপেই data যায় শুধু AL (৮ বিট) বা AX (১৬ বিট) দিয়ে; in bl,dx বলে কিছু নেই। কোর্সের lab-এ কোনো I/O device নেই: run-এ in al,40h-এর পরে AL = 00 আর out কোথাও যায় না (trace-এ সব register 0000, [exit code 0 via HLT, 7 instructions]). তাই এখানে শুধু encoding শেখার জন্য এই run; আসল port-এর আচরণ নির্ভর করে hardware-এর ওপর।

একটি কাল্পনিক উদাহরণে দুই রূপের পার্থক্য পরিষ্কার হয় (উদাহরণ, চালানো হয়নি). ধরা যাক বাজারঘরের স্মার্ট স্কেলের একটি পুরোনো 8086-ভিত্তিক সংস্করণে ১২ বিটের ADC-র ফল পড়া যায় port 0300H থেকে। 0300H ২৫৫-এর বেশি, তাই in ax,0300h লেখা যায় না; লিখতে হবে mov dx,0300h, তারপর in ax,dx. README-র load-cell মডেলে ১২৫০ g-এ raw = 400 + 0.7 × 1250 = 1275 count, অর্থাৎ AX-এ আসত 04FBH, যার উপরের চার বিট শূন্য, কারণ ADC ১২ বিটের। আর display-এর একটি latch যদি port 42H-এ থাকে, তবে out 42h,al-ই যথেষ্ট, এক byte কম। নকশাকারীরা তাই প্রায়ই সবচেয়ে বেশি ব্যবহৃত device-গুলোকে ০–২৫৫-এর মধ্যে রাখতেন। ঠিকানা কীভাবে decode হয় আর কোন chip কোন port পায়, তা পর্ব ২৩-এ। Memory-mapped I/O-র সঙ্গে তুলনা আর address decoding পর্ব ২৩ (I/O interfacing)-এ, আর 8255-এর মতো chip-এর port পর্ব ২৪-এ।

Size না লিখলে কী হয়: mov [0200h],5-এ assembler জানে না 5 কি byte না word. MASM এখানে word ptr বা byte ptr চায়। লেখকের lab-এ NASM 3.02 কোনো সতর্কতা ছাড়াই (-w+all দিয়েও) byte ধরে নিল: C6 06 00 02 05. আগে সেখানে দাম 1FFCH থাকলে ফল হলো 05 1F, আর পরের mov ax,[0200h] দিল AX = 1F05H, অর্থাৎ ৭৯৪১ পয়সা, কোনো error ছাড়াই ভুল দাম (nosize2.asm). নিয়ম: immediate দিয়ে memory-তে লিখলে সবসময় word বা byte লিখুন (NASM-এ mov word [0200h],5 = C7 06 00 02 05 00).

৭ · পুরো শ্রেণিবিভাগ আর পরীক্ষার হিসাব

সব mode এক টেবিলে। Byte NASM 3.02-এর listing থেকে; default segment Intel-এর নিয়মে।

ModeNASM উদাহরণByteEASegment
immediatemov ax,1250B8 E2 04——
registermov cx,ax89 C1——
directmov dx,[0202h]8B 16 02 02disp16DS
register indirectmov ax,[bx]8B 07BXDS
basedmov ax,[bp+08h]8B 46 08BP + dispSS
indexedmov ax,[si+0208h]8B 84 08 02SI + dispDS
based-indexedmov ax,[bp+di]8B 03BP + DISS
based-indexed + dispmov ax,[bx+si+08h]8B 40 08BX + SI + dispDS
I/O fixed / variablein al,40h / in al,dxE4 40 / EC—port

অনেক বই আরও কয়েকটি নাম যোগ করে: string instruction-এর SI/DI (string addressing, পর্ব ১৯), jmp/call-এর লক্ষ্যে IP-এর সঙ্গে দূরত্ব যোগ (relative বা intrasegment direct, পর্ব ১৬), আর CLC, CBW-এর মতো implied. যত নামই থাকুক, memory operand-এর হিসাব সবসময় এই একটি সূত্র: EA = base + index + disp, PA = segment × 10H + EA.

MASM-এ লেখা বই পড়তে গেলে নিচের অনুবাদ কাজে লাগবে। NASM-এর রূপগুলো এই পর্বে assemble করা; MASM-এর রূপগুলো Microsoft-এর MASM নথির নিয়ম থেকে, lab-এ চালানো নয়।

কাজNASMMASM / TASM
টেবিলের ঠিকানাmov bx,tablemov bx, offset table
টেবিলের প্রথম wordmov ax,[table]mov ax, table
Segment overridemov ax,[es:di]mov ax, es:[di]
Immediate-এর মাপmov word [bx],5mov word ptr [bx], 5
Based-indexed + dispmov ax,[table+bx+si]mov ax, table[bx][si]

এখন পরীক্ষার ধরনের প্রশ্ন। ধরা যাক DS = 2345H, SS = 4000H, ES = 6000H, BX = 1200H, BP = 0F00H, SI = 0034H, DI = 0100H. প্রতিটি operand-এর EA আর PA কত? নিচের ব্লক operand-এর লেখা থেকেই হিসাব করে, আর অবৈধ জোড়া ধরে ফেলে। প্রতিটি বৈধ PA লেখকের lab-এ যাচাই করা: exam.asm একই register বসিয়ে প্রতিটি operand দিয়ে একটি চিহ্ন-মান (1111H, 2222H …) লেখে, আর memory dump সেই মান ঠিক হিসাব করা PA-তে দেখায়।

# পরীক্ষার ধরনের PA প্রশ্ন: operand লেখা থেকেই EA, segment আর PA
import re
R = {"DS": 0x2345, "SS": 0x4000, "ES": 0x6000, "CS": 0x1000,
     "BX": 0x1200, "BP": 0x0F00, "SI": 0x0034, "DI": 0x0100}
OK = [set(), {"BX"}, {"BP"}, {"SI"}, {"DI"}, {"BX", "SI"}, {"BX", "DI"},
      {"BP", "SI"}, {"BP", "DI"}]                    # 8086-এ বৈধ জোড়া

def solve(text):
    m = re.fullmatch(r"\[(?:(\w\w):)?(.*)\]", text.upper())
    seg, terms = m.group(1), re.findall(r"[+-]?[^+-]+", m.group(2))
    regs, disp = set(), 0
    for t in terms:
        name = t.lstrip("+-")
        if name in R:
            regs.add(name)
        else:
            disp += int(name.rstrip("H"), 16) * (-1 if t[0] == "-" else 1)
    if regs not in OK:
        return f"{text:16} অবৈধ: {'+'.join(sorted(regs))} একসঙ্গে চলে না"
    ea = (sum(R[x] for x in regs) + disp) & 0xFFFF
    seg = seg or ("SS" if "BP" in regs else "DS")
    pa = (R[seg] * 16 + ea) & 0xFFFFF
    return f"{text:16} EA={ea:04X}h  {seg}:{ea:04X}h  PA={pa:05X}h"

for q in ["[bx+si+20h]", "[bp+di+10h]", "[es:bx+di]", "[bx-10h]",
          "[5000h]", "[bp]", "[ds:bp+si]", "[bx+bp]", "[si+di+2]"]:
    print(solve(q))

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

[bx+si+20h]      EA=1254h  DS:1254h  PA=246A4h
[bp+di+10h]      EA=1010h  SS:1010h  PA=41010h
[es:bx+di]       EA=1300h  ES:1300h  PA=61300h
[bx-10h]         EA=11F0h  DS:11F0h  PA=24640h
[5000h]          EA=5000h  DS:5000h  PA=28450h
[bp]             EA=0F00h  SS:0F00h  PA=40F00h
[ds:bp+si]       EA=0F34h  DS:0F34h  PA=24384h
[bx+bp]          অবৈধ: BP+BX একসঙ্গে চলে না
[si+di+2]        অবৈধ: DI+SI একসঙ্গে চলে না

হাতে প্রথমটি: EA = 1200H + 0034H + 20H = 1254H; DS × 10H = 23450H; PA = 23450H + 1254H = 246A4H. দ্বিতীয়টিতে BP আছে, তাই DS নয়, SS: 40000H + 1010H = 41010H; এখানে ভুল segment ধরলে উত্তর হতো 24460H. Lab-এর dump (একটি অংশ): 246A:0004 11 11, 4101:0000 22 22, 2438:0004 77 77; অর্থাৎ 246A4H, 41010H আর 24384H-এ ঠিক সেই চিহ্ন-মান। শেষ দুটি NASM-এও থামে: invalid 16-bit effective address.

আরেকটি প্রিয় প্রশ্ন: একটি segment কোথা থেকে কোথা? EA ০ থেকে FFFFH পর্যন্ত যেতে পারে, তাই DS = 2345H-এর segment শুরু 23450H-এ আর শেষ 23450H + FFFFH = 3344FH-এ, মোট ৬৪ KB. SS = 4000H-এর segment 40000H থেকে 4FFFFH. দুটি segment একে অপরের ওপর পড়তেও পারে: DS = 1000H আর ES = 1010H হলে দ্বিতীয়টি প্রথমটির মাত্র 100H byte পরে শুরু, তাই 1000H:0150H আর 1010H:0050H একই ঘর, 10150H. এই পর্বের run-এও তিনটি আলাদা জোড়া 1000H:020AH, 1020H:000AH আর 0FFFH:021AH একই 1020AH দেখিয়েছে। নিয়মটি মনে রাখার সহজ পথ: segment এক বাড়ালে শুরু ১৬ byte সরে, তাই একটি physical address-কে বহু segment:offset জোড়ায় লেখা যায়, কিন্তু প্রতিটি জোড়ার physical address মাত্র একটি।

C থেকে mode: compiler যখন ১৬ বিটের x86-এর জন্য C অনুবাদ করে, প্রতিটি C রূপ প্রায় স্বাভাবিকভাবে একটি mode-এ যায়। নিচের টেবিল সেই ছাঁচ দেখায়; ঠিক কোন register compiler বাছবে, তা compiler আর optimization-এর ওপর নির্ভর করে, তাই এগুলো উদাহরণ, কোনো নির্দিষ্ট compiler-এর আউটপুট নয়। ডান দিকের প্রতিটি instruction NASM 3.02-এ assemble করে দেখা হয়েছে (লেখকের lab-এ ctab.asm).

C-তে8086-এর সম্ভাব্য রূপMode
x = 1250;mov ax,1250immediate
global totalmov ax,[total]direct
*pmov ax,[bx]register indirect
s->pricemov ax,[bx+2]based
price[i] (global array)mov ax,[price+si]indexed
local variable বা parametermov ax,[bp-2], [bp+4]based, SS
shop->price[i]mov ax,[bx+si+08h]based-indexed + disp

টেবিলের শেষ সারি এই পর্বের পুরো গল্প। একটি struct-এর ঠিকানা BX-এ, struct-এর ভেতরে array-র শুরু displacement-এ (08H), আর array-র উপাদান SI-তে; ১৬ বিটের int হলে SI = 2 × i, কারণ 8086-এ scale নেই, তাই compiler-কে আগে shl si,1 বা add si,si দিয়ে i দ্বিগুণ করতে হয়। Local variable-এর সারিটিও খেয়াল করুন: BP-র default SS ঠিক এই সারির জন্যই বানানো, যা প্র ০২-এ আলোচনা করা হয়েছে। Cortex-M-এর Thumb-এ একই ছাঁচ দেখতে কেমন, তা পর্ব ২৯-এ।

পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:

  • Effective address আর physical address-এর পার্থক্য? EA ১৬ বিটের offset (base + index + disp); PA ২০ বিটের, segment × 10H + EA.
  • MOV AX,[BP+SI+05H] কোন segment ব্যবহার করে? SS, কারণ EA-তে BP আছে; mode: based-indexed with displacement.
  • 8086-এর ১৬ বিটের addressing-এ কোন register দিয়ে memory-র ঠিকানা দেওয়া যায়? BX, BP, SI, DI; base বা index থেকে একটি করে।
  • Segment override কী? Instruction-এর আগের একটি prefix byte (ES 26H, CS 2EH, SS 36H, DS 3EH), যা default segment বদলায়।
  • IN AL,DX আর IN AL,40H-এর পার্থক্য? DX দিয়ে ১৬ বিটের port (০–৬৫৫৩৫), ১ byte; সরাসরি নম্বরে ৮ বিটের port (০–২৫৫), ২ byte.

আরও গভীরে: 8086-এ segment × 10H + EA-র যোগফল ২০ বিট ছাড়ালে, যেমন FFFFH:0010H = 100000H, ২১তম বিট হারিয়ে ঠিকানা 00000H-এ ঘুরে যায়, কারণ address bus-এ A19-এর ওপরে কোনো লাইন নেই। পরের CPU (80286) আরও address line পাওয়ায় এই ঘোরা থেমে গেল, আর পুরোনো software-এর সামঞ্জস্যের জন্য IBM PC AT-এ A20 লাইনকে বন্ধ-খোলার একটি ব্যবস্থা (“A20 gate”) যোগ হয়েছিল বলে বহু সূত্রে লেখা আছে। কোর্সের lab-এর Unicorn একটি 386-ধরনের core (Spec decision 15), আর এর memory ঠিক ১ MiB পর্যন্ত বসানো, তাই এই ২০ বিটের ঘোরা lab-এ পরীক্ষা করা হয়নি; ১৬ বিটের EA-র ঘোরা (wrap.asm) অবশ্য 8086-এর মতোই দেখা গেছে।

8086-এর নকশা শুরু হয় ১৯৭৬ সালে, আর chip বাজারে আসে ১৯৭৮ সালে। ModR/M byte-এর mod-reg-r/m ছাঁচ সেই সময় থেকে আজকের x86-64 পর্যন্ত টিকে আছে। ১৯৮৫ সালের 80386 এর সঙ্গে একটি দ্বিতীয় byte (SIB: scale, index, base) যোগ করে, যাতে ৩২ বিটের addressing-এ যেকোনো register base হতে পারে আর index-কে ১, ২, ৪ বা ৮ দিয়ে গুণ করা যায়। কিন্তু real mode-এ চালু হওয়া প্রতিটি x86 CPU আজও 8086-এর এই ২৪টি রূপ বোঝে; কোর্সের lab-এর Unicorn ঠিক এভাবেই 8086-এর code চালায়।

৮ · AI-এর যুগে 8086-এর addressing যাচাই

AI assistant 8086-এর প্রশ্নের উত্তর দ্রুত দেয়, কিন্তু এই বিষয়ে তার ভুলগুলো চেনা ছাঁচের, আর প্রায় সবই NASM আর run8086.py এক মিনিটে ধরে ফেলে:

AI প্রায়ই যা করেকীভাবে ধরবেন
[bp+…]-এর segment DS ধরে PA হিসাবIntel-এর নিয়ম: BP থাকলে SS; bpss.asm-এর মতো SS ≠ DS রেখে run
32-বিট x86-এর রূপ 8086-এ লেখা: [eax], [bx*2], [si+di]NASM-এ cpu 8086 দিয়ে assemble: invalid 16-bit effective address
EA ১৬ বিটে না মুড়িয়ে ১৭ বিটের EA বলাEA-র ওপর & 0xFFFF; wrap.asm-এর trace
Segment-কে ১৬ দিয়ে গুণ না করে সরাসরি যোগহাতে লিখুন: segment-এর শেষে একটি hex শূন্য, তারপর যোগ
MASM আর NASM মিশিয়ে ফেলা (mov ax, table-এর অর্থ)কোন assembler, প্রথমেই বলুন; NASM-এ বন্ধনী মানে memory
8086-এর জন্য বানানো clock count, বা Pentium-এর সংখ্যা 8086-এর বলে চালানোIntel 8086 manual-এর টেবিল; lab clock গোনে না (Spec decision 16)

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

আমি Intel 8086 (16-বিট real mode) assembly শিখছি, NASM syntax-এ। 386 বা x86-64-এর addressing নয়। DS = 2345H, SS = 4000H, ES = 6000H, BX = 1200H, BP = 0F00H, SI = 0034H, DI = 0100H. ১. নিচের প্রতিটি operand-এর addressing mode, effective address, কোন segment, আর physical address একটি টেবিলে দাও: [bx+si+20h], [bp+di+10h], [es:bx+di], [bx-10h], [5000h], [bp], [ds:bp+si] ২. mov ax,[bx+si+20h] আর mov ax,[es:bx+di]-এর machine code (hex byte) দাও। ৩. [bx+bp] আর [si+di+2] কি বৈধ? কেন? ৪. প্রতিটি হিসাবের ধাপ দেখাও। নিশ্চিত না হলে অনুমান কোরো না, বলো।

উত্তর মেলানো সহজ, কারণ এগুলো ৭ নম্বর অংশের প্রশ্ন: সঠিক PA 246A4H, 41010H, 61300H, 24640H, 28450H, 40F00H আর 24384H, শেষ দুটি অবৈধ। দ্বিতীয় প্রশ্নের byte NASM-এ assemble করে listing থেকে মিলিয়ে নিন। AI-এর টেবিলে সবচেয়ে বেশি যে ভুল দেখা যায়, তা দ্বিতীয় সারিতে: BP থাকা সত্ত্বেও DS ধরে 24460H বলা। AI-কে সবচেয়ে ভালো কাজে লাগানো যায় নতুন অনুশীলন বানাতে আর ব্যাখ্যা চাইতে (“BP কেন SS?”); সংখ্যা সবসময় নিজের হিসাব আর run থেকে।

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

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

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

প্র ০১8086-এ আটটি ১৬ বিটের general register, অথচ memory-র ঠিকানা ধরতে পারে মাত্র চারটি: BX, BP, SI, DI. কেন এই সীমা, আর এর প্রভাব কী?

সীমার মূল কারণ বিটের হিসাব। ModR/M byte-এর r/m field মাত্র তিন বিটের, তাই সেখানে আটটি ঠিকানা-ছাঁচই আঁটে। Intel সেই আটটি ঘর ভাগ করেছে এভাবে: চারটি জোড়া (BX+SI, BX+DI, BP+SI, BP+DI), চারটি একক (SI, DI, BP, BX). mod-এর তিনটি মান (displacement নেই, ৮ বিট, ১৬ বিট) মিলে ২৪টি রূপ। যেকোনো register-কে base বা index হতে দিলে অনেক বেশি বিট লাগত, আর তখন instruction লম্বা হতো; ১৯৭০-এর দশকের memory আর ১৬ বিটের নকশায় প্রতিটি byte দামি ছিল। একটি ঘরের বাড়তি চাপও ছিল: direct addressing-কে জায়গা দিতে mod 00 আর r/m 110 থেকে [BP] সরাতে হয়েছে, তাই [bp] আসলে [bp+00h], এক byte বেশি।

প্রভাব programmer আর compiler দুজনের ওপরই পড়ে। AX, CX, DX দিয়ে memory পড়া যায় না, তাই একটি loop-এ যদি দুটি array (উৎস আর গন্তব্য) আর একটি গণক থাকে, তবে register বাছাই প্রায় বাধ্যতামূলক: SI উৎস, DI গন্তব্য, CX গণক, BX টেবিল। এই পর্বের ES-copy loop-এ ঠিক এটাই দেখেছেন। প্রতিটি register-এর একটি “বিশেষ ভূমিকা” থাকায় 8086-কে প্রায়ই অ-সমান (non-orthogonal) ISA বলা হয়। C compiler-এর জন্য এটি বড় চ্যালেঞ্জ ছিল, কারণ register allocation-এ শুধু “কয়টি register খালি” নয়, “কোনটি দিয়ে ঠিকানা দেওয়া যায়” তাও ভাবতে হতো।

পরে এই সীমা উঠে গেছে। ১৯৮৫ সালের 80386-এর ৩২ বিটের addressing-এ SIB byte এসে যেকোনো general register-কে base আর (ESP ছাড়া) index হতে দেয়, সঙ্গে ১, ২, ৪ বা ৮-এর scale, যাতে array[i]-এর জন্য আলাদা গুণ লাগে না। RISC নকশা (ARM, RISC-V) গোড়া থেকেই সব register-কে সমান রেখেছে। Cortex-M-এর ldr r0,[r1,r2,lsl #2] দেখায় একই ধারণা, কিন্তু কোনো register-এর ওপর বিশেষ নিষেধ ছাড়া।

মূল উপলব্ধি: তিন বিটের r/m field-এ ২৪টি রূপ ছিল ১৯৭৮ সালের একটি মিতব্যয়ী সমঝোতা; তার দাম register-এর বিশেষ ভূমিকা, যা পরের প্রজন্মের ISA ধীরে ধীরে সরিয়ে দিয়েছে।

প্র ০২BP থাকলে default segment কেন SS, যখন BX থাকলে DS? একটি নিয়ম সব register-এর জন্য এক রাখলে কী ক্ষতি হতো?

BP-র নাম base pointer, আর এর জন্মই stack frame-এর জন্য। একটি procedure শুরুতে push bp, mov bp,sp করে, তারপর [bp+4], [bp+6]-এ parameter আর [bp-2]-এ local variable পড়ে। এগুলো সব stack-এ, অর্থাৎ SS segment-এ। BP-র default SS না হলে প্রতিটি এমন instruction-এর আগে 36 prefix বসাতে হতো: প্রতিবার এক byte বেশি আর Intel-এর টেবিলে ২ clock বেশি। Pascal আর C-এর মতো ভাষায় প্রায় প্রতিটি local variable এভাবে পড়া হয়, তাই এই সাশ্রয় বড়।

এক নিয়মে সব register DS-এর হলে আরেকটি সমস্যা হতো। Program-এর data আর stack আলাদা segment-এ থাকলে, যা MASM-এর .EXE program-এ সাধারণ, local variable-এর ঠিকানা ভুল segment-এ যেত, ঠিক এই পর্বের bpss.asm-এর মতো: একই offset 03FEH, কিন্তু [bx] পেল দাম আর [bp] পেল ওজন। BX আর BP-কে আলাদা segment-এ নিয়ে Intel একসঙ্গে দুটি জগৎ সহজে ছুঁতে দিয়েছে: data-র জন্য BX/SI/DI, stack-এর জন্য BP.

কিন্তু এর একটি গোপন বিপদও আছে। C-তে একটি pointer, ধরা যাক local array-র ঠিকানা, কখনো stack-এ (SS) আর কখনো global data-য় (DS) থাকতে পারে। শুধু offset দিয়ে সেটি বোঝা যায় না। তাই ১৬ বিটের DOS compiler-গুলো “memory model” চালু করেছিল (small, medium, large ইত্যাদি), আর ছোট model-এ সাধারণত ধরে নিত SS = DS, যাতে near pointer দুই জায়গাতেই কাজ করে। আলাদা হলে far pointer (segment + offset) লাগত, যা ধীর। এই জটিলতাই পরে 32-বিট flat memory model-এ যাওয়ার একটি বড় কারণ, যেখানে সব segment-এর শুরু শূন্য।

মূল উপলব্ধি: BP → SS নিয়মটি high-level ভাষার stack frame-কে সস্তা করতে বানানো; তার দাম হলো একই offset দুই জায়গায় দুই অর্থ বহন করতে পারে, যা programmer-কে সবসময় মাথায় রাখতে হয়।

প্র ০৩Segment override একটি আলাদা prefix byte হিসেবে কেন রাখা হলো, ModR/M-এর ভেতরে কোনো field হিসেবে নয়? এর সুবিধা আর সীমা কী?

Prefix-এর সবচেয়ে বড় সুবিধা হলো এটি ঐচ্ছিক। বেশিরভাগ instruction default segment-এই কাজ করে, তাই ModR/M-এ segment-এর জন্য দুটি বিট রাখলে প্রতিটি memory instruction-এর খরচ বাড়ত, অথচ দরকার হয় কালেভদ্রে। Prefix শুধু তখনই এক byte যোগ করে, যখন সত্যিই দরকার: এই পর্বে mov [es:di],ax = 26 89 05, আর prefix ছাড়া 89 05. Intel-এর টেবিলে prefix-এর দাম ২ clock, কিন্তু যারা ব্যবহার করে না, তাদের কোনো দাম নেই। এই একই কৌশল x86 পরে বারবার ব্যবহার করেছে: REP, LOCK, 386-এর operand-size (66) আর address-size (67) prefix, আর x86-64-এর REX.

সীমাও আছে। প্রথমত, প্রতিটি prefix decoder-এর কাজ বাড়ায়: CPU-কে আগে দেখতে হয় byte-টি prefix কি না, তারপর আসল opcode. আধুনিক x86-এ একাধিক prefix মিলে instruction ১৫ byte পর্যন্ত লম্বা হতে পারে, আর এদের decode করা জটিল hardware চায়। দ্বিতীয়ত, কিছু কাজে override চলেই না: instruction fetch সবসময় CS:IP, stack-এর PUSH/POP সবসময় SS:SP, আর string instruction-এর গন্তব্য সবসময় ES:DI. যেমন MOVSB-এর উৎস DS:SI-কে prefix দিয়ে বদলানো যায়, গন্তব্য নয়। তৃতীয়ত, পুরোনো 8086/8088-এ interrupt আর একাধিক prefix-এর মিলনে একটি পরিচিত সমস্যা ছিল বলে Intel-এর নথি আর বহু বইয়ে উল্লেখ আছে: REP আর segment override একসঙ্গে থাকা string instruction interrupt-এর পরে ফেরার সময় সব prefix মনে রাখত না, তাই সাবধানী programmer এমন মিশ্রণ এড়াতেন।

এমবেডেড দৃষ্টিতে prefix-এর শিক্ষা হলো: encoding-এ যে জিনিস কম ব্যবহার হয়, তাকে জায়গা না দিয়ে আলাদা পথে আনা যায়। ARM Thumb-2 একই চিন্তায় ছোট ১৬ বিটের রূপ রেখেছে সাধারণ কাজের জন্য, আর দুর্লভ কাজ ৩২ বিটের রূপে।

মূল উপলব্ধি: Prefix byte নমনীয়তা দেয় শুধু যেখানে দরকার সেখানে দাম নিয়ে; কিন্তু fetch, stack আর string-গন্তব্যের মতো জায়গায় segment স্থির, যা মুখস্থ রাখতে হয়।

প্র ০৪8086-এ ঠিকানা দুই জায়গায় “ঘুরে” আসতে পারে: EA-র ১৬ বিটে আর physical address-এর ২০ বিটে। এই দুই ঘোরা কেন হয়, আর বাস্তবে এদের ফল কী হয়েছে?

প্রথম ঘোরা EU-র ভেতরে। EA-র যোগ হয় ১৬ বিটের adder-এ, তাই base + index + displacement ৬৫৫৩৫ ছাড়ালে উপরের carry হারিয়ে যায়। এই পর্বের wrap.asm-এ BX = FFF0H, SI = 0010H, disp = 08H মিলে 10008H হওয়ার কথা, কিন্তু EA হলো 0008H, আর data এল একই segment-এর শুরু থেকে: AX = 04E2H. অর্থাৎ একটি segment একটি বৃত্তের মতো: ৬৪ KB-র শেষ থেকে এক byte এগোলে আবার শুরুতে। এর ফল হলো ৬৪ KB-র চেয়ে বড় array-র শেষ মাথায় কোনো error ছাড়া ভুল ঘর পড়া। ১৬ বিটের DOS program-এ বড় data নিয়ে কাজ করলে programmer-কে নিজেই segment বদলাতে হতো, যার জন্য compiler-এর “huge” pointer ছিল।

দ্বিতীয় ঘোরা BIU-তে। Segment × 10H + EA সর্বোচ্চ FFFFH × 10H + FFFFH = 10FFEFH, যা ২০ বিটে ধরে না। 8086-এ address bus-এর মাত্র ২০টি লাইন (A0–A19), তাই উপরের বিট হারিয়ে ঠিকানা আবার 00000H-এর কাছে ঘুরে আসে। কিছু পুরোনো software এই আচরণের ওপর নির্ভর করত বলে জানা যায়। পরে 80286-এ ২৪টি address লাইন এলে real mode-এ FFFFH:0010H আর ঘুরত না, ১ MB-র ঠিক পরের ঘরে যেত। পুরোনো program না ভাঙতে IBM PC AT-এ A20 লাইনকে keyboard controller দিয়ে বন্ধ-খোলার ব্যবস্থা করা হয় বলে বহু সূত্রে লেখা আছে, যা “A20 gate” নামে পরিচিত। আর এই ফাঁক দিয়ে পাওয়া ১ MB-র ঠিক ওপরের প্রায় ৬৪ KB, পরে “high memory area” নামে DOS ব্যবহার করত।

কোর্সের lab এখানে সৎ থাকতে বাধ্য: Unicorn একটি 386-ধরনের core (Spec decision 15), আর lab-এর memory ঠিক ১ MiB পর্যন্ত বসানো, তাই ২০ বিটের ঘোরা lab-এ পরীক্ষা করা হয়নি। কিন্তু ১৬ বিটের EA-র ঘোরা সত্যিকারের run-এ দেখা গেছে। এমবেডেড firmware-এ এর সমতুল্য হলো integer overflow: একটি ৮ বা ১৬ বিটের buffer index-এর নীরব ঘোরা প্রায়ই buffer-এর অন্য অংশ নষ্ট করে।

মূল উপলব্ধি: নির্দিষ্ট বিট-প্রস্থের প্রতিটি adder একটি ঘোরার সীমা তৈরি করে; সেই সীমা কোথায় আর পেরোলে কী হয়, তা না জানলে ভুল নীরবে ঘটে, আর তার ওপর নির্ভর করা software পরের hardware-কেও বেঁধে রাখে।

প্র ০৫আধুনিক microcontroller-এ (যেমন ARM Cortex-M) segment নেই। তাহলে 8086-এর addressing mode শেখা আজ কেন কাজের?

কারণ segment চলে গেলেও addressing mode-এর ধারণা পুরোপুরি টিকে আছে, শুধু রূপ বদলেছে। Cortex-M-এর ঠিকানা-জগৎ ৩২ বিটের flat: একটি register-এই পুরো 4 GB-র যেকোনো ঘর, তাই segment register-এর দরকার নেই (পর্ব ৩১-এ বাজারঘর board-এর memory map). কিন্তু load আর store instruction-এর ঠিকানা এখনো base + offset বা base + index দিয়েই বলা হয়: ldr r0,[r1,#8] হলো 8086-এর [bx+08h], আর ldr r0,[r1,r2,lsl #2] হলো একটি scale-যুক্ত based-indexed. বাজারঘর board-এ একটি peripheral-এর register পড়তে compiler প্রায় সবসময় base হিসেবে peripheral-এর শুরুর ঠিকানা রাখে, আর register-এর offset বসায় displacement-এ, ঠিক এই পর্বের দামের টেবিলের +08h-এর মতো।

দ্বিতীয় কারণ C-এর সঙ্গে সম্পর্ক। x = *p হলো register indirect, s.price (s-এর ঠিকানা register-এ) হলো based, a[i] হলো indexed বা based-indexed, আর local variable হলো stack pointer বা frame pointer-এর সাপেক্ষে based. কোন C লেখা কোন mode-এ যায়, তা জানলে compiler-এর assembly পড়া সহজ হয়, আর বোঝা যায় কোন data-বিন্যাস দ্রুত (যেমন struct-এর মধ্যে field-এর ক্রম, যা displacement-কে ছোট রাখে). Cortex-M-এ immediate offset-এর সীমা আছে, তাই খুব বড় struct-এ compiler-কে বাড়তি instruction দিতে হয়: ঠিক যেমন 8086-এ disp8 থেকে disp16-এ গেলে এক byte বাড়ে।

তৃতীয় কারণ বাস্তব: পুরোনো x86-ভিত্তিক শিল্প-যন্ত্র, BIOS-এর code আর পরীক্ষার প্রশ্ন এখনো real mode আর segment নিয়ে চলে। আর debugging-এ, কোনো memory dump বা disassembly-তে একটি ঠিকানা দেখে “এটি কোন segment-এর, কোন register থেকে এল” বলতে পারা একই দক্ষতা, Cortex-M-এর HardFault-এর ঠিকানা খোঁজাতেও (পর্ব ৬১).

মূল উপলব্ধি: Segment ইতিহাসের অংশ, কিন্তু base + index + displacement আজও প্রতিটি CPU-র ভাষা; 8086-এ এটি শেখা মানে C-এর pointer, array আর struct কীভাবে machine-এ পৌঁছায়, তার স্পষ্ট ছবি পাওয়া।

অনুশীলন

প্রথমে নিজে হিসাব করুন বা লিখুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর NASM 3.02 আর কোর্সের run8086.py-এ যাচাই করা।

  1. নকশা ও বাস্তবায়ন — চারটি দামের যোগফল: বাজারঘরের টেবিল (চারটি ওজন, তারপর ৮ byte পরে চারটি দাম, word হিসেবে) program-এর ভেতরে table নামে রাখা। Based-indexed + displacement mode আর LOOP দিয়ে চারটি দাম যোগ করে মোট পয়সা ছাপার একটি NASM program লিখুন। কোন register কোন ভূমিকায়, তা ব্যাখ্যা করুন।
            org 100h
            mov bx, table           ; base: টেবিলের শুরু
            xor si, si              ; index: 0, 2, 4, 6
            xor ax, ax              ; মোট (পয়সা)
            mov cx, 4               ; গণক
    next:   add ax, [bx+si+08h]     ; i-তম পণ্যের দাম
            add si, 2
            loop next
            mov [total], ax
            call print_u16          ; reference lab-এর ছাপার routine
            mov ax, 4C00h
            int 21h
    table:  dw 150, 1250, 500, 1000         ; ওজন (g)
            dw 983, 8188, 3275, 6550        ; দাম (পয়সা)
    total:  dw 0
    %include "print_u16.inc"

    সত্যিকারের run (total.asm, reference lab-এর print_u16.inc-এর কপি সহ): ছাপে 18996, অর্থাৎ ১৮৯.৯৬ টাকা; [exit code 0 via INT 21h/4Ch, 86 instructions]. শেষে BX = 011DH: NASM টেবিলটি বসিয়েছে program-এর ঠিক পরে, offset 011DH-এ, তাই mov bx,table = BB 1D 01. ভূমিকা: BX টেবিল চেনায় (base), SI সারি বাছে (index), 08H দামের column-এ নিয়ে যায় (displacement), CX গোনে। add ax,[bx+si+08h] = 03 40 08: একই ModR/M 40, শুধু opcode ADD-এর। যোগফল ১৮৯৯৬ < ৬৫৫৩৫, তাই ১৬ বিটে আঁটে; আরও পণ্য থাকলে overflow-এর পাহারা লাগত।

  2. ভুল খুঁজুন — তিনটি ছোট program: (ক) দাম 0200H-এ 1FFCH আছে; দাম শূন্য থেকে ৫ পয়সা করতে একজন লিখলেন mov [0200h],5, তারপর mov ax,[0200h]. (খ) টেবিলের দুই অংশ যোগ করতে mov ax,[bx+bp]. (গ) একটি .EXE program-এ (SS = 3000H, DS = 1000H) DS-এর টেবিল পড়তে BX-এর বদলে BP ব্যবহার: mov bp,03FEh, mov cx,[bp]. প্রতিটিতে কী হয়?

    (ক) NASM 3.02 সতর্কতা ছাড়াই byte store বানায়: C6 06 00 02 05. শুধু নিচের byte বদলায়, ঘরে থাকে 05 1F, আর AX = 1F05H = ৭৯৪১ পয়সা (সত্যিকারের run, nosize2.asm). ঠিক রূপ mov word [0200h],5; MASM-এ mov word ptr ds:[0200h], 5. (খ) দুটি base একসঙ্গে চলে না; NASM: error: invalid 16-bit effective address. ঠিক রূপ mov ax,[bx+si] বা [bp+di], অর্থাৎ একটি base আর একটি index. (গ) Assemble হয়, চলেও, কিন্তু BP-র default SS, তাই পড়া হয় 303FEH থেকে, 103FEH থেকে নয়। bpss.asm-এর run-এ ঠিক এই অবস্থায় [bp] দিয়েছিল 04E2H (stack-এর ওজন), যেখানে [bx] দিয়েছিল 1FFCH (দাম). ঠিক রূপ mov cx,[bx], বা BP রাখতে চাইলে mov cx,[ds:bp] (3E prefix).

  3. হিসাব — physical address: DS = 2345H, SS = 4000H, ES = 6000H, BX = 1200H, BP = 0F00H, SI = 0034H, DI = 0100H. নিচের প্রতিটি instruction কোন physical address-এ লেখে, আর mode কী? (ক) mov word [bx+si+20h],1111h (খ) mov word [bp+di+10h],2222h (গ) mov word [es:bx+di],3333h (ঘ) mov word [bx-10h],4444h (ঙ) mov word [5000h],5555h (চ) mov word [bp],6666h (ছ) mov word [ds:bp+si],7777h.

    (ক) based-indexed + disp, DS: EA 1254H, PA 23450H + 1254H = 246A4H. (খ) based-indexed + disp, BP তাই SS: EA 1010H, PA 41010H. (গ) based-indexed, ES override: EA 1300H, PA 61300H. (ঘ) based, ঋণাত্মক displacement: EA 11F0H, PA 24640H. (ঙ) direct, DS: PA 28450H. (চ) based (আসলে [BP+00H]), SS: PA 40F00H. (ছ) based-indexed, DS override: EA 0F34H, PA 24384H. সত্যিকারের run (exam.asm) প্রতিটি PA-তে সেই চিহ্ন-মান দেখায়, যেমন 246A:0004 11 11, 4101:0000 22 22, 6130:0000 33 33, 2464:0000 44 44, 2845:0000 55 55, 40F0:0000 66 66, 2438:0004 77 77; মোট ১৯টি instruction. প্রতিটি dump-এর segment:offset আলাদা লেখা হলেও physical address-টি একই, যেমন 246AH:0004H = 246A4H.

  4. আগে বলুন, তারপর মেলান — encode আর mode: নিচের প্রতিটির machine code, mode আর default segment বলুন: (ক) mov ax,[bp+di+08h] (খ) mov ax,[0208h] (গ) mov ax,[di] (ঘ) mov word [bx+si+08h],5 (ঙ) in al,dx (চ) mov ax,[bx-2].

    (ক) 8B 43 08: ModR/M 01 000 011 (mod 01, reg AX, r/m BP+DI); based-indexed + disp, SS. (খ) A1 08 02: accumulator-এর ছোট রূপ, ModR/M নেই; direct, DS. (গ) 8B 05: 00 000 101; register indirect, DS. (ঘ) C7 40 08 05 00: opcode C7 (memory ← immediate), ModR/M 40, disp 08, তারপর word 0005H ছোট byte আগে; উৎস immediate, গন্তব্য based-indexed + disp, DS. (ঙ) EC: variable port, DX-এ ১৬ বিটের port নম্বর; memory-র segment নেই। (চ) 8B 47 FE: disp8 = FEH = −2, sign-extended; based, DS. সব byte NASM 3.02-এর listing থেকে মেলানো (all24.asm, io.asm).

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

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

ক্রম8086 যখন mov ax,[bx+si+08h] চালায় (BX = 0200H, SI = 0002H, DS = 1000H), ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Opcode 8B আর ModR/M 40 decode: mod 01, reg AX, r/m BX+SI
  2. EA = BX + SI + 08H = 020AH (১৬ বিটে)
  3. BP বা prefix নেই, তাই segment DS বাছাই
  4. PA = 1000H × 10H + 020AH = 1020AH
  5. 1020AH আর 1020BH থেকে FC 1F পড়ে AX = 1FFCH

8086-এ DS = 1000H, SS = 3000H, BP = 0020H, SI = 0010H হলে MOV AX,[BP+SI+05H] কোন physical address থেকে পড়ে?

  • 10035H
  • 30030H
  • 30035H
  • 03035H

8086-এর ১৬ বিটের addressing-এ নিচের কোন memory operand বৈধ?

  • [BX+BP]
  • [BP+DI+10H]
  • [CX]
  • [SI*2]

NASM-এ লেখা mov [es:di],ax instruction-এর machine code 26 89 05. প্রথম byte 26-এর কাজ কী?

  • এটি MOV-এর opcode
  • এটি DI-এর displacement
  • এটি ModR/M byte
  • এটি ES segment override prefix

8086-এ BX = FFF0H, SI = 0010H, DS = 1000H হলে MOV AX,[BX+SI+08H]-এর effective address কত?

  • 0008H
  • 10008H
  • 0000H
  • 20008H

8086-এর IN AL,DX আর IN AL,40H সম্পর্কে কোন কথাটি ঠিক?

  • দুটিতেই data যায় DX-এ
  • দুটিতেই port নম্বর DS × 10H-এর সঙ্গে যোগ হয়
  • প্রথমটি ১৬ বিটের port (০–৬৫৫৩৫) দেয়, দ্বিতীয়টি শুধু ০–২৫৫
  • দ্বিতীয়টি ১৬ বিটের port দেয়, প্রথমটি শুধু ০–২৫৫

8086-এ MOV AX,[BP] লিখলে assembler সাধারণত কোন রূপে encode করে?

  • mod 00, r/m 110, কোনো displacement ছাড়া
  • mod 01, r/m 110, displacement 00 (8B 46 00)
  • [SP]-এর রূপে
  • SS prefix 36 যোগ করে

NASM-এ table একটি word-টেবিলের নাম। mov ax,table আর mov ax,[table]-এর পার্থক্য কী?

  • প্রথমটি টেবিলের ঠিকানা (immediate), দ্বিতীয়টি টেবিলের প্রথম word (direct)
  • দুটিই টেবিলের প্রথম word পড়ে
  • প্রথমটি প্রথম word পড়ে, দ্বিতীয়টি ঠিকানা দেয়
  • প্রথমটি NASM-এ অবৈধ

শব্দকোষ

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

মনে রাখুন

  1. দুই সূত্র: EA = base (BX/BP) + index (SI/DI) + displacement, ১৬ বিটে মোড়ানো; PA = segment × 10H + EA, ২০ বিট।
  2. আট নাম: immediate, register, direct, register indirect, based, indexed, based-indexed, based-indexed + displacement; I/O-তে fixed (০–২৫৫) আর DX দিয়ে variable (০–৬৫৫৩৫) port.
  3. Segment: BP থাকলে SS, অন্যথায় DS; stack আর instruction fetch-এর segment স্থির; override prefix ES 26H, CS 2EH, SS 36H, DS 3EH.
  4. Encoding: ModR/M = mod (২) + reg (৩) + r/m (৩), ২৪টি memory-রূপ; [BP] আসলে [BP+00H], আর AX-direct-এর ছোট রূপ A1.
  5. অবৈধ: [AX], [CX], [DX], [SP], [BX+BP], [SI+DI], scale; immediate দিয়ে memory-তে লিখলে word/byte লিখুন।

পরের পর্বে: পর্ব ১৬ (8086-এর instruction set — data, arithmetic, logic আর control). এই পর্বের operand-গুলো নিয়ে কাজ করা instruction-এর দল: XCHG, XLAT, LEA, MUL, DIV, shift, rotate আর signed বনাম unsigned লাফ, প্রতিটির সত্যিকারের run সহ।

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

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