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

8086 assembly program — NASM, flag আর loop দিয়ে আসল কোড

8086 Assembly Programs — Real Code with NASM, Flags and Loops

Taught in Bangla, this lesson writes complete 8086 programs: the NASM .COM layout beside a MASM .EXE example, printing with INT 21h functions 09h and 02h, array sum and even count with CX, SI and LOOP, largest value with signed and unsigned jumps, factorial and Fibonacci, string length and BCD addition. Each program is assembled with NASM and run on Unicorn with register and memory dumps, ending with an order total that uses MUL and DIV.

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

  • একটি NASM .COM program আর একই কাজের MASM .EXE program-এর কাঠামো পাশাপাশি পড়া, আর কোন লাইন কেন আছে তা বলা
  • INT 21h-এর AH = 09h আর 02h দিয়ে লেখা ও সংখ্যা ছাপা, আর $ না থাকলে কী হয় তা বোঝা
  • CX, SI আর LOOP দিয়ে array-র যোগফল, সবচেয়ে বড় ও ছোট মান আর জোড় সংখ্যা গোনার program লেখা
  • MUL আর DIV দিয়ে factorial, Fibonacci আর বাজারঘরের অর্ডারের মোট দাম বের করা, ১৬ বিটের সীমা মাথায় রেখে
  • প্রতিটি program কোর্সের 8086 runner-এ চালিয়ে register, flag আর মেমরি মিলিয়ে দেখা

১ · Program-এর কাঠামো — NASM-এর .COM আর MASM-এর .EXE

আগের তিনটি পর্বে আপনি 8086-এর ভেতরটা (পর্ব ১৪), operand খোঁজার নিয়ম (পর্ব ১৫) আর নির্দেশের দলগুলো (পর্ব ১৬) দেখেছেন। এবার সেগুলো জুড়ে পুরো program লেখার পালা। 8085-এ একই কাজ করেছিলেন পর্ব ১১-এ: সেখানে loop, array আর BCD ছিল ৮ বিটের register আর হাতে লেখা গুণ-ভাগ দিয়ে। 8086-এ একই সমস্যা অনেক ছোট কোডে হয়, কারণ ১৬ বিটের register, MUL, DIV আর LOOP আছে।

উপমা — চিঠি আর খাম: একটি program শুধু নির্দেশের তালিকা নয়। পোস্ট অফিসে চিঠি পাঠাতে খামের ওপর ঠিকানা, ভেতরে চিঠি আর নিয়মমতো ভাঁজ লাগে। .COM program হলো পোস্টকার্ড: এক পাতায় সব, ঠিকানা ছাপা জায়গায় (০১০০H) লেখা শুরু। .EXE program হলো খাম: ভেতরে আলাদা পাতা (code, data, stack), আর খামের মাথায় একটি পাতা (header) বলে দেয় কোন পাতা কোথায় বসবে। পোস্টম্যান, মানে DOS-এর loader, দুটিই বিলি করতে জানে।

লেখার নিয়ম আগের মতো: prose-এ hex লেখা হবে Intel-এর ধরনে, শেষে H দিয়ে (010CH), আর segment:offset লেখা হবে 1000H:0100H ধাঁচে। কোডের ভেতরে NASM-এর নিয়মে ছোট হাতের h থাকবে (09h), মানে একই। নিচে কোর্সের reference lab-এর প্রথম 8086 program, hello.asm. এটি NASM-এ লেখা আর সত্যিই চলে:

; প্রথম 8086 program: একটি লেখা ছাপা আর DOS-এ ফেরা
        org 100h
        mov ah, 09h
        mov dx, msg
        int 21h                 ; print the $-terminated string at DS:DX
        mov ax, 4C00h
        int 21h                 ; exit, code 0
msg:    db 'Hello from 8086!', 13, 10, '$'

একই কাজ বহু বই আর পরীক্ষার প্রশ্নে লেখা হয় Microsoft-এর MASM (বা Borland-এর TASM)-এর ধাঁচে। নিচের রূপটি তুলনার জন্য; কোর্সের lab-এ MASM নেই, তাই এটি চালানো হয়নি:

; MASM/TASM ধাঁচ — উদাহরণ, চালানো হয়নি
.MODEL SMALL
.STACK 100h
.DATA
msg     DB 'Hello from 8086!', 13, 10, '$'
.CODE
MAIN    PROC
        MOV AX, @DATA       ; data segment-এর ঠিকানা
        MOV DS, AX          ; DS নিজে ঠিক করতে হয়
        MOV AH, 09h
        LEA DX, msg         ; বা MOV DX, OFFSET msg
        INT 21h
        MOV AX, 4C00h
        INT 21h
MAIN    ENDP
        END MAIN            ; শুরুর জায়গা MAIN

দুটি লেখার মূল নির্দেশ হুবহু এক: mov ah, 09h, DX-এ লেখার offset, int 21h, তারপর 4C00h দিয়ে বেরোনো। পার্থক্য সব assembler directive-এ, অর্থাৎ যে লাইনগুলো CPU-র নির্দেশ নয়, assembler-কে বলে কোথায় কী বসাতে হবে:

বিষয়NASM (.COM, এই কোর্স)MASM/TASM (.EXE)
শুরুর ঠিকানাorg 100hEND MAIN-এ নাম দেওয়া label
Segmentএকটিই; CS = DS = ES = SS.CODE, .DATA, .STACK আলাদা
DS ঠিক করালাগে না, loader করে দেয়MOV AX, @DATA আর MOV DS, AX
Label-এর offsetmov dx, msgMOV DX, OFFSET msg বা LEA DX, msg
মেমরির মাপword [si]WORD PTR [SI]
Procedureশুধু label আর retPROC … ENDP
Datadb, dw (label-এর পরে কোলন)DB, DW (কোলন ছাড়া নাম)

এই পর্বের সব চালানো program .COM ধাঁচের। কোর্সের reference lab-এর run8086.py NASM 3.02 দিয়ে source-কে flat binary বানায়, আর Unicorn-এর ১৬ বিট real mode-এ চালায়। Lab-এর নিয়ম (Spec decision 13): program বসে 1000H:0100H-এ, CS = DS = ES = SS = 1000H, SP = FFFEH, আর FLAGS = 0202H (IF = 1). নিচের ছবিতে দুটি কাঠামোর মেমরি-চিত্র দেখুন।

ছবি ১৭.১ — .COM আর .EXE program মেমরিতে কীভাবে বসে

বাঁয়ে: lab-এর .COM, একটি 64 KB segment; ডানে: MASM-এর SMALL model, আলাদা segment. ওপরে ছোট ঠিকানা।

.COM আর .EXE program-এর মেমরি-চিত্র .COM (NASM) .EXE (MASM) 0000H: PSP lab: INT 20h 0100H: code org 100h data: msg, nums ফাঁকা stack ওপরে ওঠে ↑ FFFEH: stack 0000H word CS=DS=ES=SS = 1000H IP=0100H SP=FFFEH PSP শুরুতে DS, ES CODE segment CS:IP = MAIN DATA segment DS = @DATA STACK segment SS:SP loader header পড়ে segment বসায় প্রতিটি segment ≤ 64 KB
ছবি ১৭.১ — বাঁয়ের কলামে কোর্সের lab-এর ঠিক অবস্থা (Spec decisions 13–14): segment 1000H-এর শুরুতে ২৫৬ byte-এর PSP-এর জায়গা, যেখানে lab শুধু INT 20h বসায়; 0100H থেকে program, আর stack-এর মাথায় একটি 0000H word, যাতে শেষ RET 1000H:0000H-এ গিয়ে INT 20h দিয়ে বেরোয়। ডানের কলাম MASM-এর SMALL memory model-এর সরল ছবি; আসল ক্রম আর মাপ linker ঠিক করে, আর এটি lab-এ চালানো হয়নি।

MASM-এর program-এ MOV AX, @DATA আর MOV DS, AX কেন লাগে, এখন বোঝা সহজ। .EXE program চালু হলে DOS DS আর ES-কে PSP-তে রাখে, data segment-এ নয়। Program নিজে DS না বদলালে msg-এর offset ভুল segment-এ খোঁজা হবে, আর পর্দায় আবর্জনা আসবে। আর segment register-এ সরাসরি সংখ্যা রাখার নির্দেশ নেই (পর্ব ১৪), তাই দুই ধাপে: আগে AX, তারপর DS. .COM program-এ এই ঝামেলা নেই, কারণ সব একই segment-এ। Object file, relocation আর loader কীভাবে কাজ করে, তার সাধারণ তত্ত্ব আছে Programming Languages & Compilers পর্ব ৭৪-এ।

Program লেখার পদ্ধতি — কোড লেখার আগে register-এর পরিকল্পনা

8085-এর পর্বে যে পদ্ধতি দেখেছেন, এখানেও তাই চলে: সমস্যাটি বাংলায় এক লাইনে লেখা, একটি ছোট flowchart, তারপর কোন register কোন কাজ করবে তার তালিকা, তারপর কোড, আর শেষে কাগজে dry run আর runner-এর instruction trace মিলিয়ে দেখা। 8086-এ register-এর পরিকল্পনা সহজ, কারণ বেশ কিছু নির্দেশ নির্দিষ্ট register চায়, আর সেগুলো আগে থেকেই ঠিক করে দেয় কোন register কোথায় বসবে। এই পর্বের program-গুলোর পরিকল্পনা এক টেবিলে:

ProgramCXSIAXঅন্য
Array-র যোগফলপাকের সংখ্যাপরের wordচলতি যোগফল—
সবচেয়ে বড়বাকি তুলনাপরের wordএখন পর্যন্ত বড়—
জোড় গোনাপাকের সংখ্যাপরের wordছাপার জন্যBX = গুনতি
Factorialগুনতি আর গুণক—গুণফলDX = উঁচু অর্ধেক
অর্ডারের দামজিনিসের সংখ্যাপরের ওজনদামDI = মোট, BX = দর বা ভাজক

আরেকটি অভ্যাস কাজে দেয়: যে register একটি routine নষ্ট করতে পারে, সেটি আগে জেনে রাখা। MUL আর DIV সবসময় DX বদলায়, INT 21h-এর জন্য AH বদলাতে হয়, আর LOOP CX ছাড়া কিছু চেনে না। তাই loop-এর গুনতি কখনো DX-এ রাখবেন না, আর চলতি ফল AX-এ থাকলে ছাপার আগে বাঁচিয়ে রাখুন।

২ · লেখা ছাপা — INT 21h-এর AH = 09h আর 02h

8086 নিজে পর্দা চেনে না। কোনো অক্ষর দেখাতে program DOS-এর সাহায্য নেয় INT 21h নির্দেশ দিয়ে। এটি একটি software interrupt: CPU interrupt vector table থেকে DOS-এর একটি routine-এর ঠিকানা নেয় আর সেখানে যায়। কোন কাজ চাই, তা বলা হয় AH-এ। Interrupt-এর ভেতরের কাজ, vector table আর নিজের ISR লেখা আসবে পর্ব ২০-এ (8086-এর interrupt); এখানে শুধু তিনটি service ব্যবহার করবেন। কোর্সের lab একটি ছোট DOS stub দিয়ে এগুলো চালায় (Spec decision 14):

AHকাজইনপুট
09h$ পর্যন্ত একটি লেখা ছাপাDS:DX = লেখার শুরু
02hএকটি অক্ষর ছাপাDL = অক্ষরের ASCII কোড
4Chprogram শেষ, DOS-এ ফেরাAL = exit code (0 = সফল)

AH = 09h-এর নিয়মটি অদ্ভুত কিন্তু সরল: DS:DX থেকে শুরু করে একের পর এক byte ছাপা হয়, যতক্ষণ না $ (24H) আসে; $ নিজে ছাপা হয় না। একে বলে $-terminated string. hello.asm-এ msg-এর শেষে 13, 10 হলো CR আর LF: কার্সর লাইনের শুরুতে ফেরা আর এক লাইন নামা। NASM-এর আসল byte আর ধাপে ধাপে চলা:

$ python -B run8086.py hello.asm --bin --trace --mem 010Ch,19
bytes (31): B4 09 BA 0C 01 CD 21 B8 00 4C CD 21 48 65 6C 6C 6F 20 66 72
            6F 6D 20 38 30 38 36 21 0D 0A 24
1000:0100  B409     mov ah,0x9      AX=0900 DX=0000 IP=0102 --I------
1000:0102  BA0C01   mov dx,0x10c    AX=0900 DX=010C IP=0105 --I------
1000:0105  CD21     int byte 0x21   AX=0900 DX=010C IP=0107 --I------
---- INT 21h AH=09h serviced by the DOS stub
1000:0107  B8004C   mov ax,0x4c00   AX=4C00 DX=010C IP=010A --I------
1000:010A  CD21     int byte 0x21   AX=4C00 DX=010C IP=010C --I------
----
Hello from 8086!
----
1000:010C  48 65 6C 6C 6F 20 66 72 6F 6D 20 38 30 38 36 21
1000:011C  0D 0A 24
[exit code 0 via INT 21h/4Ch, 5 instructions]

(সত্যিকারের run: run8086.py, NASM 3.02, Unicorn 2.1.4; লাইন ছোট রাখতে trace-এ শুধু AX, DX, IP আর flag রাখা, অন্য register পুরো সময় শুরুর মানে।) মাত্র পাঁচটি নির্দেশ চলেছে, অথচ ১৮টি অক্ষর ছাপা হয়েছে: ছাপার loop-টি DOS-এর ভেতরে। mov dx, msg-এর অনুবাদ BA 0C 01: assembler msg-এর জায়গায় তার offset 010CH বসিয়েছে, কারণ org 100h-এর পরে কোড ১২ byte লম্বা। এবার service-এর ভেতরে কী হয়, ধাপে ধাপে:

এই ধাপে
কাজ
AX · DX
পড়া ঘর
byte
IP
  1. mov ah,09h. AH-এ service নম্বর 09h, তাই AX = 0900H. এখনো কিছু ছাপা হয়নি; শুধু DOS-কে কী চাই তা ঠিক হলো।
  2. mov dx,msg. DX = 010CH, লেখার offset. DS = 1000H, তাই লেখা শুরু physical address 10000H + 010CH = 1010CH-এ।
  3. প্রথম byte. DOS 1010CH থেকে 48H পড়ে, যা 'H'-এর ASCII কোড, আর পর্দায় পাঠায়। তারপর ঠিকানা এক বাড়ায়।
  4. ষোলোতম byte. একই কাজ চলতে থাকে; 1011BH-এর 21H = '!' ছাপার পরে পর্দায় পুরো Hello from 8086!. কোনো byte-এ থামার প্রশ্ন ওঠেনি, কারণ কোনোটি 24H নয়।
  5. CR আর LF. 0DH কার্সরকে লাইনের শুরুতে নেয়, 0AH এক লাইন নামায়। এ দুটি অক্ষর দেখা যায় না, কিন্তু ছাপা byte হিসেবে গোনা হয়: মোট ১৮টি।
  6. $ পেয়ে থামা। 1011EH-এ 24H. DOS এটি ছাপে না, শুধু থামে। লেখার মাপ কোথাও বলা নেই; শেষ চেনার একমাত্র উপায় এই চিহ্ন।
  7. Program-এ ফেরা। IP = 0107H, পরের নির্দেশ mov ax,4C00h. Lab-এর stub AX আর DX বদলায়নি; আসল DOS-এ AL বদলে যেতে পারে, তাই ফেরার পরে AL-এর ওপর ভরসা না করাই নিরাপদ।

$-এর নিয়মের দুটি ফাঁদ আছে: লেখার ভেতরেই $ থাকলে বাকিটা ছাপা হয় না, আর শেষে $ ভুলে গেলে DOS মেমরির পরের আবর্জনা ছাপতে থাকে। নিচের মডেলে তিনটি ঘটনাই চালিয়ে দেখুন:

# INT 21h AH=09h-এর মডেল: DS:DX থেকে শুরু করে '$' (24H) পর্যন্ত ছাপা
mem = bytearray(0x100000)                     # 1 MB, শুরুতে সব 00H

def load(seg, off, data):
    base = (seg << 4) + off
    mem[base:base + len(data)] = data

def int21_09(ds, dx, limit=24):
    p = (ds << 4) + dx                        # physical address
    out = bytearray()
    while mem[p] != 0x24:                     # '$' না আসা পর্যন্ত
        out.append(mem[p])
        p += 1
        if len(out) >= limit:                 # নিরাপত্তার সীমা (DOS-এ নেই)
            return bytes(out), None
    return bytes(out), p

cases = [(0x010C, b"Hello from 8086!\r\n$"),  # hello.asm-এর msg
         (0x0200, b"Total $ 124.46\r\n$"),    # লেখার ভেতরেই '$'
         (0x0300, b"price=81.88 Tk\r\n")]     # শেষে '$' নেই
for off, data in cases:
    load(0x1000, off, data)
    text, end = int21_09(0x1000, off)
    start = (0x1000 << 4) + off
    where = f"'$' পাওয়া গেল {end:05X}H-এ" if end else "২৪ byte-এও '$' নেই"
    print(f"DS:DX = 1000H:{off:04X}H -> {start:05X}H; {where}")
    print(f"   ছাপা হলো {len(text)} byte: {text!r}")

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

DS:DX = 1000H:010CH -> 1010CH; '$' পাওয়া গেল 1011EH-এ
   ছাপা হলো 18 byte: b'Hello from 8086!\r\n'
DS:DX = 1000H:0200H -> 10200H; '$' পাওয়া গেল 10206H-এ
   ছাপা হলো 6 byte: b'Total '
DS:DX = 1000H:0300H -> 10300H; ২৪ byte-এও '$' নেই
   ছাপা হলো 24 byte: b'price=81.88 Tk\r\n\x00\x00\x00\x00\x00\x00\x00\x00'

প্রথম জোড়া লাইন সত্যিকারের run-এর সঙ্গে মেলে: 1010CH থেকে শুরু, 1011EH-এ $, ১৮টি byte. দ্বিতীয়টিতে “Total $ 124.46” লেখার ভেতরের $-এ থেমে গেছে, পর্দায় শুধু Total . তৃতীয়টিতে $ নেই, তাই লেখার পরের 00H byte-ও “ছাপা” হচ্ছে; মডেল ২৪ byte-এ থামিয়েছে, আসল DOS থামত না, কোথাও একটি 24H না পাওয়া পর্যন্ত চলত। কোর্সের lab এই ভুলে সোজা থেমে যায়: error: INT 21h/09h: no '$' terminator (সত্যিকারের run). তাই দাম বা নাম ছাপাতে $ চিহ্ন ব্যবহার করতে চাইলে AH = 02h দিয়ে অক্ষর ধরে ধরে ছাপাই নিরাপদ।

সংখ্যা ছাপা আরেকটু কঠিন। AX-এ 1500 থাকলে DOS-এর কোনো service সেটি দশমিকে ছাপে না; program-কে নিজে অঙ্কে ভাঙতে হয়। Reference lab-এর ছোট routine print_u16 (ফাইল print_u16.inc) এটি করে: AX-কে বারবার 10 দিয়ে ভাগ করে ভাগশেষগুলো stack-এ রাখে (প্রথমে আসে একক অঙ্ক), তারপর উল্টো ক্রমে বের করে প্রতিটির সঙ্গে '0' (30H) যোগ করে AH = 02h দিয়ে ছাপে। newline routine CR আর LF ছাপে। এই পর্বের প্রায় সব program শেষে %include "print_u16.inc" লিখে এদের ব্যবহার করে। CALL, RET আর register বাঁচানোর নিয়ম, অর্থাৎ procedure কীভাবে কাজ করে, তা পর্ব ১৮-তে (8086-এর procedure, stack frame আর macro); 8085-এর একই ধারণা দেখেছেন পর্ব ১২-এ।

৩ · Loop আর array — যোগফল আর জোড় সংখ্যা গোনা

বাজারের দোকানদার খাতার পাতা ধরে ধরে যোগ করেন: আঙুল থাকে বর্তমান লাইনে (SI), মাথায় থাকে কয় লাইন বাকি (CX), আর ক্যালকুলেটরে চলতি যোগফল (AX). 8086-এ ঠিক এই তিনটি register দিয়ে array-র loop লেখা হয়। মূল নির্দেশ LOOP: CX থেকে ১ বিয়োগ করে, ফল শূন্য না হলে label-এ লাফায়। দুটি কাজ এক নির্দেশে, আর কোনো flag বদলায় না। CX এখানে loop counter, 8085-এর DCR C আর JNZ-এর জোড়ার জায়গায়।

; Word array-এর যোগফল: 120 + 250 + 75 + 1000 + 55 = 1500
        org 100h
        mov si, nums            ; SI -> first element
        mov cx, COUNT           ; loop counter
        xor ax, ax              ; AX = running sum
next:   add ax, [si]
        add si, 2               ; next word
        loop next               ; CX = CX - 1, jump if CX != 0
        mov [total], ax
        call print_u16          ; prints 1500
        call newline
        mov ax, 4C00h
        int 21h
nums:   dw 120, 250, 75, 1000, 55
COUNT   equ ($ - nums) / 2
total:  dw 0
%include "print_u16.inc"

COUNT equ ($ - nums) / 2 লাইনটি খেয়াল করুন। $ এখানে NASM-এর ভাষায় “বর্তমান ঠিকানা” (DOS-এর $-এর সঙ্গে সম্পর্ক নেই)। পাঁচটি word দশ byte, তাই COUNT = 5. Array-তে একটি সংখ্যা যোগ করলে COUNT নিজেই বদলায়, হাতে গুনতে হয় না। সত্যিকারের run আর শেষে মেমরি:

$ python -B run8086.py sum_array.asm --mem 011Dh,12
1500
----
1000:011D  78 00 FA 00 4B 00 E8 03 37 00 DC 05
[exit code 0 via INT 21h/4Ch, 88 instructions]

প্রথম দশটি byte array: 0078H = 120, 00FAH = 250, 004BH = 75, 03E8H = 1000, 0037H = 55, প্রতিটি little-endian ক্রমে। শেষ দুটি total: DC 05 = 05DCH = 1500. এবার loop-এর পাঁচটি পাক:

0106xor ax,ax0108add ax,[si]010Aadd si,2010Dloop next010Fmov [total],ax
ধাপের শেষে
[SI]-এর মান
AX
SI
CX
LOOP
0127H
  1. প্রস্তুতি। SI = 011DH (প্রথম সংখ্যার offset), CX = 5, আর xor ax,ax AX-কে শূন্য করে। mov ax,0-এর চেয়ে এটি এক byte ছোট (31 C0), তবে flag বদলায়: ZF = 1.
  2. পাক ১। AX = 0 + 120 = 0078H. SI দুই বাড়ে, কারণ প্রতিটি সংখ্যা word, দুই byte. LOOP CX-কে 4 করে, শূন্য নয়, তাই 0108H-এ ফেরে।
  3. পাক ২। AX = 120 + 250 = 370 = 0172H. CX = 3. Runner-এর trace-এ এই যোগের পরে AF = 1, কারণ নিচের nibble-এ 8H + AH = 12H, carry হয়েছে; loop-এর কাজে তার কোনো ভূমিকা নেই।
  4. পাক ৩। AX = 370 + 75 = 445 = 01BDH. SI = 0123H, CX = 2.
  5. পাক ৪। AX = 445 + 1000 = 1445 = 05A5H. ১৬ বিটের register-এ সহজে আঁটে; 8085-এ এমন যোগে দুই byte আলাদা করে carry সামলাতে হতো।
  6. পাক ৫, loop শেষ। AX = 1445 + 55 = 1500 = 05DCH. LOOP CX-কে 0 করে, তাই আর লাফায় না; IP চলে যায় পরের নির্দেশে, 010FH.
  7. ফল মেমরিতে। mov [total],ax: 10127H-এ DC 05. তারপর print_u16 “1500” ছাপে। মোট ৮৮টি নির্দেশ চলেছে, যার বেশিরভাগ ছাপার routine-এ।

একই কাঠামোয় অন্য প্রশ্নও করা যায়: array-তে কয়টি জোড় সংখ্যা? জোড় সংখ্যার বিট ০ সবসময় 0. TEST দুটি operand-এর AND করে শুধু flag বসায়, ফল কোথাও লেখে না; বিট ০ = 0 হলে ZF = 1.

; even.asm - count the even words in an array (TEST + JNZ)
        org 100h
        mov si, nums
        mov cx, COUNT
        xor bx, bx              ; BX = even count
next:   test word [si], 1       ; bit 0 = 1 means odd; ZF = 1 means even
        jnz odd
        inc bx
odd:    add si, 2
        loop next
        mov ax, bx
        call print_u16          ; prints 3
        call newline
        mov ax, 4C00h
        int 21h
nums:   dw 120, 250, 75, 1000, 55
COUNT   equ ($ - nums) / 2
%include "print_u16.inc"

সত্যিকারের run ছাপে 3 (120, 250 আর 1000 জোড়; 75 আর 55 বিজোড়), শেষে BX = 0003H, ৬৩টি নির্দেশ। Trace-এ পাঁচটি test-এর পরে ZF ক্রমে 1, 1, 0, 1, 0. NASM-এ word লিখতেই হয়, কারণ [si] আর 1 থেকে assembler মাপ বুঝতে পারে না (MASM-এ WORD PTR). ভাগের বদলে বিট দেখা দ্রুত আর সরল, ঠিক যেমন C-তে x & 1 (C পর্ব ০৯)।

সংখ্যাগুলো word না হয়ে byte হলে একটি নতুন সমস্যা আসে। ধরুন তিন দিনে বাজারঘরে বিক্রি হওয়া ডিমের সংখ্যা byte হিসেবে রাখা: 200, 150, 100. যোগফল 450, যা ৮ বিটে আঁটে না। সমাধান 8085-এর মতোই: ৮ বিটে যোগ, আর বেরিয়ে যাওয়া carry উঁচু byte-এ জমা করা। 8086-এ এর জন্য ADC (add with carry):

; bytesum.asm - sum of BYTE values that can pass 255 (ADD + ADC)
        org 100h
        mov si, vals
        mov cx, 3
        xor ax, ax              ; AH:AL = 16-bit sum
next:   add al, [si]            ; 8-bit add, carry -> CF
        adc ah, 0               ; carry goes into AH
        inc si                  ; bytes: +1
        loop next
        call print_u16          ; prints 450
        call newline
        mov ax, 4C00h
        int 21h
vals:   db 200, 150, 100
%include "print_u16.inc"

সত্যিকারের run ছাপে 450. Trace-এ দ্বিতীয় পাকে add al,[si]-এর পরে AX = 005EH আর CF = 1 (C8H + 96H = 15EH, নবম বিট বেরিয়ে গেছে), আর adc ah,0-এর পরে AX = 015EH. শেষ পাকে AL = C2H, AX = 01C2H = 450. দুটি জিনিস লক্ষ করুন। SI এখানে প্রতি পাকে এক বাড়ে, কারণ data byte. আর adc লাইনটি মুছে চালালে runner ছাপে 194 = 450 − 256: carry নীরবে হারিয়ে গেছে, কোনো error ছাড়াই। পরীক্ষায় “যোগফল ২৫৫ ছাড়াতে পারে” কথাটি থাকলেই এই ADC-এর লাইন চাই।

সাবধান — CX = 0 দিয়ে LOOP: LOOP আগে CX কমায়, পরে দেখে। CX = 0 থেকে শুরু করলে প্রথম পাকেই 0 − 1 = FFFFH, আর loop চলে ৬৫৫৩৬ বার। সত্যিকারের run: mov cx,0, তারপর inc ax আর loop-এর জোড়া ১৩১০৭৫টি নির্দেশ চালিয়ে AX = 0000H-এ শেষ হয় (৬৫৫৩৬ বার যোগ করে ঘুরে আসা)। খালি array সম্ভব হলে loop-এর আগে JCXZ (CX = 0 হলে লাফ) দিয়ে পাহারা দিন।

৪ · সবচেয়ে বড় মান — CMP, flag আর শর্তের লাফ

পরীক্ষার সবচেয়ে প্রচলিত program: array-র সবচেয়ে বড় সংখ্যা। কৌশলটি দাঁড়িপাল্লার মতো: প্রথম জিনিসটি পাল্লায় রাখুন, তারপর পরেরটি তুলে তুলনা করুন; ভারী হলে সেটি রাখুন, না হলে আগেরটিই থাকুক। 8086-এ তুলনার নির্দেশ CMP: এটি প্রথম operand থেকে দ্বিতীয়টি বিয়োগ করে, ফল ফেলে দেয়, শুধু flag রাখে। তারপর একটি conditional branch flag দেখে সিদ্ধান্ত নেয়।

; largest.asm - largest unsigned word in an array (CMP + JAE)
        org 100h
        mov si, nums            ; SI -> first element
        mov cx, COUNT - 1       ; compare the other 4
        mov ax, [si]            ; AX = best so far = 120
next:   add si, 2
        cmp ax, [si]            ; AX - [SI], only flags change
        jae keep                ; CF = 0: AX >= [SI], keep AX
        mov ax, [si]            ; new largest
keep:   loop next
        call print_u16          ; prints 1000
        call newline
        mov ax, 4C00h
        int 21h
nums:   dw 120, 250, 75, 1000, 55
COUNT   equ ($ - nums) / 2
%include "print_u16.inc"

সত্যিকারের run ছাপে 1000, শেষে SI = 0126H, ৯০টি নির্দেশ। CX = COUNT − 1 = 4, কারণ প্রথম সংখ্যাটি তুলনা ছাড়াই AX-এ বসেছে; পাঁচ রাখলে loop array পেরিয়ে COUNT-এর পরের byte পড়ত, এক ঘর বেশি ধরার off-by-one ভুল। JAE (Jump if Above or Equal) লাফায় যখন CF = 0, অর্থাৎ unsigned অর্থে AX ≥ [SI]. Trace-এর NDISASM লেখে jnc: একই opcode (73H)-এর আরেক নাম। নিচের stepper-এ runner-এর প্রতিটি তুলনার flag:

0106mov ax,[si]0108add si,2010Bcmp ax,[si]010Djae keep010Fmov ax,[si]0111keep: loop next
এই পাকে
SI
CMP
CF ZF SF
runner-এর ছাপ
JAE
AX পরে
CX (LOOP-এর পরে)
  1. শুরু। প্রথম সংখ্যা 120 AX-এ, এখন পর্যন্ত “সবচেয়ে বড়”। CX = 4, কারণ বাকি চারটির সঙ্গে তুলনা হবে। MOV flag ছোঁয় না, তাই ছাপে শুধু IF.
  2. 120 − 250. ধার লাগে, তাই CF = 1; ফল FF7EH, বিট ১৫ = 1, তাই SF = 1. CF = 1 মানে AX ছোট, JAE লাফায় না, mov ax,[si] চলে: AX = 250.
  3. 250 − 75. ধার নেই, CF = 0; ফল ধনাত্মক, SF = 0. JAE লাফায় keep-এ, AX = 250 অক্ষত।
  4. 250 − 1000. আবার CF = 1 আর SF = 1. নতুন বড় মান: AX = 1000 = 03E8H.
  5. 1000 − 55, শেষ। CF = 0, AX অক্ষত। LOOP CX-কে 0 করে বেরিয়ে আসে, print_u16 ছাপে 1000. চারবারের দুবার নতুন মান নেওয়া হয়েছে।

এখানে SF আর CF সবসময় একসঙ্গে বদলেছে, কিন্তু সেটি এই সংখ্যাগুলোর কাকতাল। সংখ্যা signed হলে, যেমন cold room-এর তাপমাত্রা, JAE ভুল উত্তর দেবে; তখন লাগবে JGE (SF = OF হলে লাফ)। নিচের মডেলটি একই loop-কে flag ধরে চালায়, তারপর FFFFH আর 0001H-এর তুলনা দেখায়:

# largest.asm-এর loop: CMP শুধু flag বদলায়, JAE দেখে CF
nums = [120, 250, 75, 1000, 55]               # dw 120, 250, 75, 1000, 55
mem = {0x011E + 2 * i: v for i, v in enumerate(nums)}

def cmp16(a, b):                              # a - b, ফল ফেলে দিয়ে flag রাখা
    res = (a - b) & 0xFFFF
    cf = int(a < b)                           # unsigned ধার লাগলে CF = 1
    zf = int(res == 0)
    sf = res >> 15                            # ফলের বিট ১৫
    return cf, zf, sf

si, cx = 0x011E, len(nums) - 1
ax = mem[si]                                  # প্রথমটিই এখন পর্যন্ত বড়
print(f"শুরু: AX = {ax}, CX = {cx}")
while True:
    si += 2
    old = ax
    cf, zf, sf = cmp16(ax, mem[si])
    if cf == 0:
        what = "JAE লাফায়: AX অক্ষত"
    else:
        what = "JAE লাফায় না: AX = নতুন মান"
        ax = mem[si]
    print(f"SI={si:04X}H cmp {old:4}, {mem[si]:4}: "
          f"CF={cf} ZF={zf} SF={sf} -> {what}")
    cx -= 1                                   # LOOP: CX - 1, শূন্য না হলে ফেরা
    if cx == 0:
        break
print(f"সবচেয়ে বড়: AX = {ax} = {ax:04X}H")

# একই তুলনা signed অর্থে: -1 (FFFFH) আর 1
cf, zf, sf = cmp16(0xFFFF, 1)
print(f"cmp FFFFH, 0001H: CF={cf} SF={sf} -> JAE বলে FFFFH বড়, JGE বলে ছোট")

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

শুরু: AX = 120, CX = 4
SI=0120H cmp  120,  250: CF=1 ZF=0 SF=1 -> JAE লাফায় না: AX = নতুন মান
SI=0122H cmp  250,   75: CF=0 ZF=0 SF=0 -> JAE লাফায়: AX অক্ষত
SI=0124H cmp  250, 1000: CF=1 ZF=0 SF=1 -> JAE লাফায় না: AX = নতুন মান
SI=0126H cmp 1000,   55: CF=0 ZF=0 SF=0 -> JAE লাফায়: AX অক্ষত
সবচেয়ে বড়: AX = 1000 = 03E8H
cmp FFFFH, 0001H: CF=0 SF=1 -> JAE বলে FFFFH বড়, JGE বলে ছোট

চারটি তুলনার CF, ZF আর SF stepper আর runner-এর trace-এর সঙ্গে মেলে। শেষ লাইনটি আলাদা একটি সত্যিকারের run দিয়েও যাচাই করা: mov ax,0FFFFh, cmp ax,1-এর পরে ছাপ --I-S----; jae (jnc) লাফিয়েছে, jge (jnl) লাফায়নি। Unsigned অর্থে FFFFH = 65535, 1-এর চেয়ে বড়; signed অর্থে FFFFH = −1, 1-এর চেয়ে ছোট। CPU জানে না সংখ্যাটি কোন অর্থে; কোন লাফ বসাবেন, সেটি programmer-এর সিদ্ধান্ত। ছোট মান খুঁজতে শুধু jae-এর জায়গায় jbe বসে (অনুশীলন ১)।

তুলনা (CMP a, b-এর পরে)UnsignedSigned
a > bJA (CF = 0 আর ZF = 0)JG (ZF = 0 আর SF = OF)
a ≥ bJAE (CF = 0)JGE (SF = OF)
a < bJB (CF = 1)JL (SF ≠ OF)
a ≤ bJBE (CF = 1 বা ZF = 1)JLE (ZF = 1 বা SF ≠ OF)
a = b, a ≠ bJE (ZF = 1), JNE (ZF = 0): দুই অর্থেই এক

এই টেবিলের শর্তগুলো Intel-এর 8086 manual-এর; flag-এর অর্থ (CF, ZF, SF, OF) এসেছে পর্ব ১৪-এ। শর্তের লাফগুলো 8086-এ সব short: লাফের দূরত্ব −128 থেকে +127 byte. এর চেয়ে দূরে যেতে হলে উল্টো শর্তের ছোট লাফের পরে একটি JMP বসাতে হয়। If, while আর for কীভাবে এমন লাফে ভাঙে, তার সাধারণ তত্ত্ব আছে Computer Architecture পর্ব ২৯-এ।

৫ · গুণ দিয়ে loop — factorial আর Fibonacci

8085-এ গুণ মানে ছিল বারবার যোগ বা shift-add (পর্ব ১১)। 8086-এ MUL আছে: ১৬ বিটের রূপে AX-কে operand দিয়ে গুণ করে ৩২ বিটের ফল রাখে DX:AX-এ, উঁচু অর্ধেক DX-এ। Factorial n! = n × (n − 1) × … × 1, তাই CX-কে n থেকে নামিয়ে আনলে সে একসঙ্গে গুনতি আর গুণক দুটিই।

; factloop.asm - n! with a loop and MUL (no recursion)
        org 100h
        mov cx, 8               ; n = 8
        mov ax, 1               ; AX = running product
again:  mul cx                  ; DX:AX = AX * CX
        loop again              ; 8*7*6*5*4*3*2*1
        call print_u16          ; prints 40320
        call newline
        mov ax, 40320
        mov bx, 9
        mul bx                  ; 9! = 362880 needs 32 bits
        hlt
%include "print_u16.inc"
$ python -B run8086.py factloop.asm --regs
40320
----
AX=8980 BX=0009 CX=0000 DX=0005 SI=0000 DI=0000 BP=0000 SP=FFFE CS=1000
DS=1000 ES=1000 SS=1000 IP=0118 O-I-S---C
[exit code 0 via HLT, 100 instructions]
MUL-এর পরে
নির্দেশ
DX:AX
দশমিকে
CF · OF
  1. 1 × 8. AX শুরুতে 1, CX = 8. mul cx: DX:AX = 0000:0008H. গুণক নির্দেশে লেখা হয় না, সবসময় AX; লেখা হয় শুধু অন্য operand.
  2. 8 × 7 = 56. LOOP CX-কে 7 করে ফিরেছে। ফল 0038H, DX = 0. ফল ১৬ বিটে আঁটলে CF = OF = 0.
  3. 56 × 6 = 336 = 0150H. একই পথ। Factorial-এর গুণক উল্টো ক্রমে আসছে (৮, ৭, ৬…), কিন্তু গুণে ক্রম বদলালে ফল বদলায় না।
  4. 336 × 5 = 1680 = 0690H.
  5. 1680 × 4 = 6720 = 1A40H.
  6. 6720 × 3 = 20160 = 4EC0H.
  7. 20160 × 2 = 40320 = 9D80H. বিট ১৫ এখন 1, কিন্তু unsigned অর্থে ঠিক মান; DX এখনো 0, তাই CF = OF = 0.
  8. 40320 × 1, loop শেষ। শেষ পাকে CX = 1 দিয়ে গুণ, AX বদলায় না; LOOP CX-কে 0 করে বেরিয়ে আসে, print_u16 ছাপে 40320 = 8!.
  9. 9! আর ১৬ বিটে আঁটে না। 40320 × 9 = 362880 = 58980H: DX = 0005H, AX = 8980H. DX শূন্য নয়, তাই MUL CF = OF = 1 বসায়। ১৬ বিটে factorial সর্বোচ্চ 8!.

শেষ ছাপে O-I-S---C: OF আর CF সংকেত দিচ্ছে ফলের উঁচু অর্ধেক কাজে লেগেছে। SF-এর 1 দেখে কিছু ভাববেন না: Intel-এর manual অনুযায়ী MUL-এর পরে SF, ZF, AF আর PF অনির্ধারিত (undefined), যেকোনো মান থাকতে পারে, আর অন্য CPU বা emulator-এ আলাদা হতে পারে। Reference lab-এ factorial.asm একই কাজ recursion দিয়ে করে আর 0! থেকে 8! পর্যন্ত ছাপে (1 1 2 6 24 120 720 5040 40320); recursion আর stack frame পর্ব ১৮-এর বিষয়।

Fibonacci ধারায় প্রতিটি সংখ্যা আগের দুটির যোগফল। দুটি register-এ পরপর দুটি সংখ্যা রাখলে একটি যোগ আর একটি অদলবদলই যথেষ্ট:

; fib.asm - first 12 Fibonacci numbers
        org 100h
        xor ax, ax              ; F0 = 0
        mov bx, 1               ; F1 = 1
        mov cx, 12
next:   call print_u16
        push ax
        mov ah, 02h
        mov dl, ' '
        int 21h
        pop ax
        add ax, bx              ; AX = F(n) + F(n+1)
        xchg ax, bx             ; AX = F(n+1), BX = F(n+2)
        loop next
        call newline
        mov ax, 4C00h
        int 21h
%include "print_u16.inc"

সত্যিকারের run ছাপে 0 1 1 2 3 5 8 13 21 34 55 89 , শেষে BX = 00E9H = 233, পরের Fibonacci সংখ্যা। XCHG দুটি register-এর মান এক নির্দেশে অদলবদল করে, তৃতীয় register ছাড়াই। push ax আর pop ax দরকার, কারণ ফাঁকা অক্ষর ছাপতে AH-এ 02h বসাতে হয়, যা AX-এর অর্ধেক; না বাঁচালে চলতি সংখ্যা নষ্ট হতো। ১৬ বিটে আঁটে F(24) = 46368 পর্যন্ত; F(25) = 75025 > 65535.

৬ · String-এর দৈর্ঘ্য আর BCD যোগ

String মানে মেমরিতে পরপর কয়েকটি ASCII byte. দৈর্ঘ্য জানতে শেষ চিহ্ন পর্যন্ত গুনতে হয়। নিচের program $ পর্যন্ত গোনে, তারপর দৈর্ঘ্য আর লেখা দুটিই ছাপে:

; strlen.asm - length of a $-terminated string, then print it
        org 100h
        mov si, msg
        xor cx, cx              ; CX = length
next:   cmp byte [si], '$'
        je done
        inc cx
        inc si
        jmp next
done:   mov ax, cx
        call print_u16          ; prints 15: 13 letters + CR + LF
        call newline
        mov ah, 09h
        mov dx, msg
        int 21h                 ; prints the string itself
        mov ax, 4C00h
        int 21h
msg:    db 'Bazarghar 1kg', 13, 10, '$'
%include "print_u16.inc"
$ python -B run8086.py strlen.asm --regs
15
Bazarghar 1kg
----
AX=4C00 BX=0000 CX=000F DX=0122 SI=0131 DI=0000 BP=0000 SP=FFFE CS=1000
DS=1000 ES=1000 SS=1000 IP=0122 --I----P-
[exit code 0 via INT 21h/4Ch, 130 instructions]

দৃশ্যমান অক্ষর ১৩টি, কিন্তু program বলছে ১৫: CR আর LF-ও গোনা হয়েছে। এটি ভুল না ঠিক, তা নির্ভর করে প্রশ্নে “দৈর্ঘ্য” বলতে কী বোঝানো হয়েছে; পরীক্ষায় শর্তটি লিখে দেওয়াই ভালো। C-র strlen শেষ চিহ্ন হিসেবে 00H খোঁজে, DOS-এর AH = 09h খোঁজে 24H; বাকি সব এক। এই loop-কে আরও ছোট করা যায় REPNE SCASB দিয়ে, যা পর্ব ১৯-এ (8086-এর string instruction).

BCD যোগে 8086-এর DAA কাজ করে AL-এর ওপর, ঠিক 8085-এর মতো নিয়মে (পর্ব ১১)। Reference lab-এর bcd.asm-এর প্রথম অংশ (বাকিটা অঙ্ক ছাপার কোড):

        mov al, 75h
        add al, 48h             ; AL = BDh (binary sum)
        daa                     ; AL = 23h, CF = 1
        mov bl, al
        mov dl, '0'
        adc dl, 0               ; hundreds digit from CF
        ...
        mov dl, bl
        shr dl, 1               ; 8086: shift by 1 or by CL only
        shr dl, 1
        shr dl, 1
        shr dl, 1               ; high digit 2
        ...
        mov ah, 0
        mov al, '7'
        add al, '5'             ; AL = 6Ch
        aaa                     ; AH = 1, AL = 2  (CF = AF = 1)
        or ax, 3030h            ; to ASCII: AH = '1', AL = '2'
$ python -B run8086.py bcd.asm --trace     (৫৪টির মধ্যে ৪টি লাইন; শুধু AX আর flag)
1000:0102  0448   add al,0x48    AX=00BD  O-I-S--P-
1000:0104  27     daa            AX=0023  --I---A-C
1000:0132  37     aaa            AX=0102  --I---APC
1000:0133  0D3030 or ax,0x3030   AX=3132  --I------
----
123
12

Packed BCD-এ 75 + 48: binary যোগফল BDH, DAA 06H আর 60H যোগ করে AL = 23H আর CF = 1, অর্থাৎ 123. দ্বিতীয় অংশ unpacked BCD: '7' (37H) + '5' (35H) = 6CH, আর AAA AH = 01H, AL = 02H বানায়; or ax,3030h দুটিকে ASCII '1' আর '2' করে। চারটি shr dl,1 কেন? 8086-এ shift-এর গুনতি হয় 1, নয়তো CL. shr dl,4 লিখলে NASM cpu 8086-এ থামে: error: no instruction for this cpu level (সত্যিকারের run); immediate গুনতি এসেছে 80186-এ। আর CL দিয়ে বড় গুনতি দিলে lab-এর Unicorn গুনতিকে ৫ বিটে কেটে দেয়, আসল 8086 কাটে না: Spec decision 15-এর চারটি পার্থক্যের একটি।

৭ · বাজারঘরের অর্ডারের মোট দাম — সব কৌশল একসঙ্গে

এবার কোর্সের চলমান উদাহরণ। বাজারঘরের smart scale-এ আলুর দর 65.50 টাকা/kg = 6550 পয়সা/kg, আর একটি জিনিসের দাম (reference lab-এর README, “বাজারঘর devices”):

দাম (পয়সা) = (net গ্রাম × 6550 + 500) ÷ 1000, পূর্ণসংখ্যার ভাগ

+500 দিয়ে অর্ধেক বা তার বেশি হলে ওপরের দিকে গোল করা হয়। একজন ক্রেতা তিনবার মাপলেন: 150 g, 1250 g আর 500 g. Program প্রতিটির দাম পয়সায় ছাপে, তারপর মোট টাকায়:

; order86.asm - Bazarghar order total: price = (g*6550+500)/1000 paisa
        org 100h
        mov si, items
        mov cx, NITEMS
        xor di, di              ; DI = total paisa
item:   mov ax, [si]            ; net grams
        mov bx, RATE
        mul bx                  ; DX:AX = grams * 6550
        add ax, 500
        adc dx, 0               ; round half up
        mov bx, 1000
        div bx                  ; AX = paisa, DX = remainder
        add di, ax
        call print_u16          ; this item's price in paisa
        call newline
        add si, 2
        loop item
        mov ax, di
        xor dx, dx
        mov bx, 100
        div bx                  ; AX = taka, DX = paisa part
        call print_u16          ; 124
        mov ah, 02h
        push dx
        mov dl, '.'
        int 21h
        pop ax                  ; AX = 46
        call print_u16
        call newline
        mov ax, 4C00h
        int 21h
RATE    equ 6550                ; paisa per kg (65.50 Tk)
items:  dw 150, 1250, 500       ; net grams of three items
NITEMS  equ ($ - items) / 2
%include "print_u16.inc"
$ python -B run8086.py order86.asm --regs
983
8188
3275
124.46
----
AX=4C00 BX=0064 CX=0000 DX=002E SI=014C DI=309E BP=0000 SP=FFFE CS=1000
DS=1000 ES=1000 SS=1000 IP=0146 --I----P-
[exit code 0 via INT 21h/4Ch, 324 instructions]

তিনটি দামই README-এর মানের সঙ্গে মেলে: 9.83, 81.88 আর 32.75 টাকা। মোট DI = 309EH = 12446 পয়সা। শেষ ভাগে 12446 ÷ 100: AX = 124 (টাকা), DX = 002EH = 46 (পয়সা), শেষ register-এর ছাপেও DX = 002E রয়ে গেছে। এখানে তিনটি জিনিস একসঙ্গে কাজ করছে। MUL BX-এর ফল ৩২ বিটের: 150 × 6550 = 982500 = 000EFDE4H, তাই DX = 000EH, AX = FDE4H. ADD AX,500-এর carry যায় DX-এ ADC DX,0 দিয়ে। আর DIV BX DX:AX-কে ভাগ করে ভাগফল AX-এ, ভাগশেষ DX-এ রাখে। নিচের মডেল একই হিসাব ১৬ বিটের register-এর মাপে করে, আর দুটি বিপদও খোঁজে:

# order86.asm-এর হিসাব ১৬ বিটের register-এর মাপে: MUL -> DX:AX, DIV -> AX, DX
RATE = 6550                                   # পয়সা/kg (65.50 টাকা)

def price(grams):
    prod = grams * RATE                       # MUL BX: ৩২ বিটের গুণফল
    dx, ax = prod >> 16, prod & 0xFFFF
    dividend = prod + 500                     # ADD AX,500 আর ADC DX,0
    q, r = divmod(dividend, 1000)             # DIV BX
    if q > 0xFFFF:
        return dx, ax, None, None             # ভাগফল AX-এ আঁটে না: divide error
    return dx, ax, q, r

total = 0
for g in [150, 1250, 500]:
    dx, ax, q, r = price(g)
    total += q
    print(f"{g:5} g: DX:AX = {dx:04X}:{ax:04X}H -> AX = {q} পয়সা (ভাগশেষ {r})")
taka, paisa = divmod(total, 100)
print(f"মোট {total} পয়সা = {total:04X}H -> {taka}.{paisa:02d} টাকা")

# ভুল ছাপার ঝুঁকি: পয়সার অংশ 0-9 হলে print_u16 একটি অঙ্কই ছাপে
bad = [g for g in range(1, 5001) if price(g)[2] % 100 < 10]
print(f"1-5000 g-এর মধ্যে {len(bad)}টি ওজনে পয়সার অংশ এক অঙ্কের; যেমন "
      f"{bad[0]} g, {bad[1]} g, 2000 g -> {price(2000)[2]} পয়সা")

# DIV-এর সীমা: ভাগফল ১৬ বিটে না আঁটলে
for g in [10005, 10006]:
    q = price(g)[2]
    print(f"{g} g:", f"{q} পয়সা" if q is not None else "ভাগফল > FFFFH, divide error")

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

  150 g: DX:AX = 000E:FDE4H -> AX = 983 পয়সা (ভাগশেষ 0)
 1250 g: DX:AX = 007C:EE6CH -> AX = 8188 পয়সা (ভাগশেষ 0)
  500 g: DX:AX = 0031:F8F8H -> AX = 3275 পয়সা (ভাগশেষ 500)
মোট 12446 পয়সা = 309EH -> 124.46 টাকা
1-5000 g-এর মধ্যে 499টি ওজনে পয়সার অংশ এক অঙ্কের; যেমন 1 g, 16 g, 2000 g -> 13100 পয়সা
10005 g: 65533 পয়সা
10006 g: ভাগফল > FFFFH, divide error

প্রথম তিন লাইনের DX:AX runner-এর trace-এর mul bx-এর পরের মানের সঙ্গে হুবহু মেলে (000E:FDE4, 007C:EE6C, 0031:F8F8), ভাগশেষ 0, 0 আর 500-ও (trace-এ DX = 0000, 0000, 01F4H). চতুর্থ লাইন মোট। পঞ্চম লাইন একটি লুকানো ভুল ধরেছে: পয়সার অংশ 0 থেকে 9 হলে print_u16 একটি অঙ্কই ছাপে। 2000 g আলু, 13100 পয়সা: সত্যিকারের run ছাপে 131.0, অথচ হওয়ার কথা 131.00 (সমাধান অনুশীলন ২-এ)। শেষ দুই লাইন DIV-এর সীমা: ভাগফল AX-এ, তাই 65535-এর বেশি হলে আঁটে না। 10005 g পর্যন্ত চলে (সত্যিকারের run: 65533, 655.33), কিন্তু 10006 g দিলে runner থামে: error: divide error (INT 0) at 1000:0118 and no INT 0 handler installed.

এই divide error শূন্য দিয়ে ভাগ না করেও ঘটে, শুধু ভাগফল বড় হলে। 8086 তখন type 0 interrupt তোলে, যা পর্ব ২০-এ। Spec decision 15 মনে রাখুন: lab-এর Unicorn ফেরার ঠিকানা হিসেবে DIV-এর নিজের ঠিকানা রাখে (এখানে 1000H:0118H), আসল 8086 রাখে পরের নির্দেশের ঠিকানা। বাজারঘরের scale-এর ধারণক্ষমতা 5000 g, তাই একবারের মাপে এই সীমা আসে না; কিন্তু মোট দাম DI-তে ১৬ বিটে, অর্থাৎ 65535 পয়সা = 655.35 টাকার বেশি হলে চুপচাপ ঘুরে যাবে। আসল firmware-এ এমন যোগফলের জন্য ৩২ বিট রাখা হয়, যা মডিউল ৫ থেকে Cortex-M-এ সহজ।

আরও গভীরে: .COM ফাইলে কোনো header নেই; DOS ফাইলটি PSP-র ঠিক পরে, offset 0100H-এ, হুবহু কপি করে CS = DS = ES = SS = PSP-র segment দিয়ে চালায়। 0100H আর ২৫৬ byte-এর PSP-র ধারণা এসেছে CP/M থেকে, যেখানে program চলত 0100H থেকে, আর প্রথম ২৫৬ byte ছিল সিস্টেমের “zero page”; প্রথম দিকের DOS ইচ্ছা করেই CP/M-এর program সহজে আনার মতো করে বানানো হয়েছিল। .EXE ফাইলের শুরুতে থাকে “MZ” চিহ্নের header আর relocation-এর তালিকা: segment-এর মান যেহেতু চালানোর মুহূর্তে ঠিক হয়, loader প্রতিটি @DATA-র মতো segment-ঠিকানায় load segment যোগ করে দেয়। এজন্যই .EXE program 64 KB-এর বেশি হতে পারে, .COM পারে না।

পরীক্ষা ও ইন্টারভিউতে: “INT 21h-এ AH = 09h কী করে” → DS:DX থেকে $ পর্যন্ত লেখা ছাপে, $ নিজে ছাপে না। “LOOP কী করে” → CX − 1, শূন্য না হলে লাফ, flag অক্ষত; CX = 0 থেকে শুরু করলে ৬৫৫৩৬ পাক। “MASM-এ MOV AX,@DATA কেন” → .EXE শুরুতে DS PSP-তে থাকে, data segment-এ আনতে হয়, আর segment register-এ সরাসরি সংখ্যা রাখা যায় না। “MUL BX-এর ফল কোথায়” → DX:AX; DX ≠ 0 হলে CF = OF = 1. “সবচেয়ে বড় signed সংখ্যা খুঁজতে কোন লাফ” → JGE/JL, JAE/JB নয়।

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

“8086-এ array-র সবচেয়ে বড় সংখ্যা খোঁজার program লিখুন” — AI assistant-কে বললে কয়েক সেকেন্ডে সুন্দর কোড আসে। সমস্যা হলো, সেই কোড প্রায়ই এক assembler-এর লেখা অন্য assembler-এ মেশানো, বা ৩২ বিটের x86 থেকে ধার করা। সাধারণ ভুলগুলো আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
MASM-এর OFFSET, WORD PTR, .DATA NASM কোডে মেশায়, বা উল্টোটাযে assembler-এ চালাবেন, সেটিতে assemble করা; NASM ভুল লাইনের নম্বরসহ থামে
shr al, 4, push 5, imul ax, bx, 3-এর মতো 80186/386-এর নির্দেশ দেয়NASM-এ cpu 8086 (lab নিজেই বসায়, Spec decision 13): “no instruction for this cpu level”
Signed সংখ্যায় JA/JB, বা unsigned-এ JG/JLFFFFH আর 0001H-এর মতো একটি সীমার উদাহরণ দিয়ে চালানো
MUL-এর পরে শুধু AX দেখে, DX ভুলে যায়; DIV-এর আগে DX শূন্য করে নাRunner-এর --regs-এ DX দেখা; বড় মান দিয়ে divide error খোঁজা
লেখার শেষে $ দেয় না, বা MASM-এ DS ঠিক করে নাচালালে lab থামে বা আবর্জনা আসে; data-র ঘোষণা পড়ে দেখা
নির্দেশের clock সংখ্যা উৎস ছাড়া বলেIntel-এর manual-এর টেবিল দেখা; lab কোনো clock মাপে না (Spec decision 16)

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

আমি Intel 8086 (80186 বা 386 নয়) শিখছি। NASM syntax, .COM program (org 100h), শুধু 8086-এর নির্দেশ। ১. একটি word array (dw 120, 250, 75, 1000, 55)-এর সবচেয়ে বড় unsigned সংখ্যা খুঁজে AX-এ রাখার program লেখো। CX আর LOOP ব্যবহার করো, আর প্রতিটি CMP-এর পরে CF আর ZF কী হবে তা টেবিলে দেখাও। ২. সংখ্যাগুলো signed হলে কোন লাফ বদলাতে হবে, আর কেন? FFFFH আর 0001H দিয়ে উদাহরণ দাও। ৩. INT 21h AH=09h আর AH=02h-এর ইনপুট কী কী? লেখার শেষে কী লাগে? ৪. MASM ধাঁচ আর NASM ধাঁচ মেশাবে না; কোনো নির্দেশ 8086-এ না থাকলে বলে দাও। Clock সংখ্যা লাগলে Intel-এর manual থেকে দাও, না জানলে বলো "নিশ্চিত নই"।

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

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

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

প্র ০১DOS কেন লেখার শেষ চিহ্ন হিসেবে $ বেছে নিল, যখন C-তে 00H আর অন্য ভাষায় শুরুতে দৈর্ঘ্য লেখার নিয়ম? প্রতিটি পদ্ধতির ঝুঁকি কী?

সবচেয়ে প্রচলিত ব্যাখ্যা ইতিহাসের। ১৯৭০-এর দশকের শেষে ৮ বিটের কম্পিউটারে সবচেয়ে জনপ্রিয় operating system ছিল Digital Research-এর CP/M. CP/M-এর BDOS-এর function 9, “print string”, লেখার শেষ চিনত $ দেখে। ১৯৮১ সালে IBM PC-র জন্য যখন DOS এল, তার প্রথম দিকের নকশা ইচ্ছা করেই CP/M-এর মতো রাখা হয়েছিল, যাতে CP/M-এর program সহজে নতুন যন্ত্রে আনা যায়; তাই INT 21h-এর AH = 09h একই function নম্বর আর একই $ চিহ্ন পেল, শুধু register বদলাল। CP/M-এর নকশাকার ঠিক কেন $ বেছেছিলেন, তার কোনো প্রাথমিক নথি আমরা পাইনি, তাই এটি অনুমানের বিষয়।

তিনটি পদ্ধতির তুলনা শিক্ষণীয়। $-terminated লেখায় $ নিজে রাখা যায় না: “Total $ 124.46” ছাপতে গেলে লেখা মাঝপথে কাটা পড়ে, যা এই পর্বের মডেলে দেখেছেন। C-র NUL-terminated string-এ একই সমস্যা 00H-এর জন্য, কিন্তু সাধারণ লেখায় 00H প্রায় আসে না বলে সমস্যা কম চোখে পড়ে। দুটির একই বড় ঝুঁকি: শেষ চিহ্ন হারালে পড়া চলতে থাকে মেমরির শেষ পর্যন্ত। C-তে এটি buffer over-read, যা বহু নিরাপত্তা-ত্রুটির উৎস; কোর্সের lab এমন অবস্থায় থেমে যায়, আসল DOS আবর্জনা ছাপতে থাকে। শুরুতে দৈর্ঘ্য লেখার (length-prefixed) পদ্ধতি, যেমন পুরোনো Pascal-এর string, শেষ চিহ্নের ঝামেলা দূর করে আর দৈর্ঘ্য এক ধাপে জানায়; কিন্তু দৈর্ঘ্যের ঘর এক byte হলে লেখা ২৫৫ অক্ষরের বেশি হতে পারে না।

এমবেডেড কাজে এর সরাসরি প্রভাব আছে। বাজারঘরের smart scale UART দিয়ে যে লাইন পাঠায়, গ্রাহক সেটি চেনে লাইনের শেষের LF দেখে: আরেকটি terminator. MQTT-র মতো আধুনিক protocol প্রায় সবসময় দৈর্ঘ্য আগে পাঠায় (পর্ব ৭৩), কারণ binary data-য় যেকোনো byte আসতে পারে, কোনো চিহ্নকেই নিরাপদে “শেষ” বলা যায় না। আর C-তে strlen-এর বদলে সীমাসহ ফাংশন ব্যবহার করা নিরাপদ firmware-এর নিয়ম।

মূল উপলব্ধি: শেষ চিহ্ন দিয়ে লেখা চেনা সহজ কিন্তু ভঙ্গুর: চিহ্নটি লেখায় রাখা যায় না, আর হারালে পড়া থামে না; দৈর্ঘ্য আগে বলে দেওয়া নিরাপদ, তবে তারও সীমা আছে।

প্র ০২.COM আর .EXE দুই রকম ফাইল কেন টিকে ছিল? একটি ছোট program-এর জন্য কোনটি সুবিধার, আর আজকের firmware-এ এই পার্থক্যের প্রতিধ্বনি কোথায়?

.COM হলো সবচেয়ে সরল executable: ফাইলের byte-গুলোই হুবহু মেমরির ছবি। DOS একটি খালি জায়গা খোঁজে, প্রথম ২৫৬ byte-এ PSP বানায় (কমান্ড লাইন, ফেরার ঠিকানা ইত্যাদি), তারপর ফাইলটি 0100H থেকে কপি করে চালায়। কোনো header নেই, কোনো relocation নেই, তাই loader-এর কাজ প্রায় শূন্য। এই সরলতার দাম: code, data আর stack সব একটি 64 KB-এর segment-এ, আর ফাইলের আকার তার চেয়ে কম হতেই হবে। CP/M-এর জগৎ থেকে আসা program আর ছোট utility-র জন্য এটুকুই যথেষ্ট ছিল, আর CP/M-এও program চলত 0100H থেকে।

.EXE এল বড় program-এর জন্য। এর শুরুতে একটি header থাকে, যার প্রথম দুটি byte “MZ”; প্রচলিত বিবরণ অনুযায়ী এটি DOS-এর একজন প্রথম দিকের নির্মাতা Mark Zbikowski-র নামের আদ্যক্ষর। Header বলে দেয় program কত বড়, stack কোথায়, শুরুর CS:IP কত, আর একটি relocation-এর তালিকা দেয়। Assembler আর linker জানে না program মেমরির কোথায় বসবে, তাই MOV AX, @DATA-র মতো নির্দেশে segment-এর জায়গায় একটি আপেক্ষিক মান বসায়; loader চালানোর মুহূর্তে আসল load segment যোগ করে প্রতিটি ঠিক করে। ফলে program একাধিক segment জুড়ে বড় হতে পারে, আলাদা stack পেতে পারে। দাম: শুরুতে DS নিজে ঠিক করার দায়, আর একটু জটিল loader.

ছোট পরীক্ষার program-এর জন্য .COM অনেক সুবিধার: এক segment, সব offset ছোট, কোনো segment গোনার ঝামেলা নেই; এজন্যই কোর্সের lab এই ধাঁচ বেছেছে (Spec decision 13). আজকের firmware-এ একই দুই ধারা দেখা যায়। Microcontroller-এর flash-এ যে .bin ফাইল লেখা হয়, তা .COM-এর মতো কাঁচা byte, নির্দিষ্ট ঠিকানায় বসবে বলে আগেই link করা। আর ELF ফাইল .EXE-র মতো: header, section, symbol আর relocation-এর তথ্যসহ, যা debugger আর loader পড়ে। Embedded Linux-এ program ELF হিসেবেই চলে। এর বিস্তার পর্ব ৩৭-এ (cross-compilation আর build) আর Programming Languages & Compilers পর্ব ৭৪-এ।

মূল উপলব্ধি: .COM কাঁচা মেমরি-ছবি, সরল কিন্তু 64 KB-এ বাঁধা; .EXE header আর relocation দিয়ে বড় হওয়ার স্বাধীনতা কেনে। আজকের .bin আর ELF-এ সেই একই আপস টিকে আছে।

প্র ০৩পরীক্ষার বই MASM-এ লেখা, এই কোর্স NASM-এ। দুই assembler-এর এই পার্থক্য কোথা থেকে এল, আর একটি থেকে অন্যটিতে নিরাপদে অনুবাদের নিয়ম কী?

Microsoft-এর MASM এসেছিল IBM PC-র শুরুর যুগে, ১৯৮১ সালের দিকে, আর DOS-এর জগতে দীর্ঘদিন প্রধান assembler ছিল। পরে Borland-এর TASM MASM-এর লেখা প্রায় পুরোটাই মেনে নিল। ফলে ১৯৮০ আর ১৯৯০-এর দশকের পাঠ্যবই, আর তার ধারায় আজকের অনেক বিশ্ববিদ্যালয় ও চাকরির পরীক্ষার প্রশ্ন MASM-এর ধাঁচে: .MODEL SMALL, OFFSET, WORD PTR, PROC. NASM তৈরি হয় ১৯৯৬ সালের দিকে, খোলা সোর্সের assembler হিসেবে, Simon Tatham আর Julian Hall-এর হাতে। এর লক্ষ্য ছিল আরও সরল আর নিয়মিত লেখা: একটি নাম মানে সবসময় তার ঠিকানা, আর মেমরি মানে সবসময় বন্ধনী।

পার্থক্যের মূলে একটি দর্শন। MASM নামের সঙ্গে “ধরন” মনে রাখে: msg DB … লিখলে msg একটি byte-ভেরিয়েবল, আর MOV AL, msg মানে মেমরি থেকে পড়া; ঠিকানা চাইলে OFFSET msg. NASM-এ msg শুধু একটি সংখ্যা, ঠিকানা; মেমরি পড়তে [msg] লিখতেই হয়, আর মাপ অস্পষ্ট হলে byte বা word. এই কারণে একই দেখতে লাইন দুই assembler-এ ভিন্ন অর্থ পেতে পারে, আর ভুল চুপচাপ হয়: MASM-এর MOV DX, msg NASM-এ নিলে ঠিকানা আসে (যা ঠিক), কিন্তু MASM-এর MOV AX, count NASM-এ নিলে মান না এসে ঠিকানা আসবে।

নিরাপদ অনুবাদের নিয়ম কয়েকটি। ঠিকানা চাইলে MASM-এর OFFSET x হয় NASM-এর x; মান চাইলে MASM-এর x হয় NASM-এর [x]. WORD PTR [bx] হয় word [bx], আর ES:[DI] হয় [es:di]. .MODEL, .DATA, .CODE, PROC/ENDP সরিয়ে .COM-এ org 100h, আর DS ঠিক করার দুটি লাইন বাদ। তারপর সবচেয়ে জরুরি ধাপ: চালিয়ে দেখা, কারণ চোখে পড়া অনুবাদ প্রায়ই একটি বন্ধনী হারায়। এই পর্বের সব MASM কোড তাই “উদাহরণ, চালানো হয়নি” লেখা, আর প্রতিটির পাশে NASM-এর চালানো রূপ আছে।

মূল উপলব্ধি: MASM নামের সঙ্গে ধরন মনে রাখে, NASM নামকে শুধু ঠিকানা ধরে; অনুবাদে OFFSET, বন্ধনী আর PTR-এর তিনটি নিয়ম মানলে আর শেষে চালিয়ে দেখলে দুই জগতের মধ্যে নিরাপদে চলাফেরা করা যায়।

প্র ০৪8086-এ LOOP-এর মতো “এক নির্দেশে দুই কাজ” কেন রাখা হলো? আধুনিক CPU আর microcontroller-এ loop কীভাবে লেখা হয়?

১৯৭০-এর দশকে মেমরি দামি আর ধীর ছিল, আর program-এর প্রতিটি byte আনতে bus-এর সময় লাগত। তাই CISC নকশার একটি লক্ষ্য ছিল ঘন কোড: প্রচলিত কাজের ধারা এক নির্দেশে ভরা। LOOP দুই byte-এ CX কমানো, শূন্য পরীক্ষা আর লাফ তিনটিই করে; একই কাজ DEC CX আর JNZ দিয়ে করলে তিন byte লাগে। 8086-এর ৬ byte-এর queue-র কাছে প্রতিটি বাঁচানো byte মানে কম fetch. সঙ্গে আছে LOOPE/LOOPNE (ZF-ও দেখে) আর JCXZ, আর পর্ব ১৯-এর REP prefix, যা একটি string নির্দেশকে CX বার চালায়। একটি সূক্ষ্ম সুবিধাও আছে: LOOP কোনো flag বদলায় না, তাই loop-এর ভেতরের ADC-এর মতো carry-নির্ভর হিসাব ভাঙে না; DEC CX কিন্তু ZF, SF বদলায়।

CPU-র নকশা পরে অন্য দিকে গেল। ১৯৮০-র দশকের RISC আন্দোলনের যুক্তি ছিল: সরল, একই মাপের নির্দেশ দ্রুত decode আর pipeline করা যায়, আর compiler বেশিরভাগ সময় জটিল নির্দেশ ব্যবহারই করে না। পরের x86 CPU-গুলো পুরোনো নির্দেশ রেখে দিয়েছে সামঞ্জস্যের জন্য, কিন্তু অনেক আধুনিক x86 প্রসেসরে LOOP সাধারণ যোগ-বিয়োগ আর লাফের জোড়ার চেয়ে ধীর বলে বিভিন্ন optimization নির্দেশিকায় উল্লেখ আছে, তাই compiler সাধারণত এটি এড়ায়। কোনো নির্দিষ্ট CPU-র সঠিক cycle সংখ্যা জানতে সেই CPU-র নির্মাতার নথি দেখতে হবে; কোর্সের lab কোনো cycle মাপে না (Spec decision 16).

ARM Cortex-M-এ, যা মডিউল ৫ থেকে আসবে, loop সাধারণত SUBS (বিয়োগ করে flag বসায়) আর BNE-এর জোড়া; Thumb নির্দেশ ঘন বলে কোড ছোটই থাকে। বেশ কিছু DSP আর কিছু microcontroller-এ hardware loop থাকে, যেখানে loop-এর গুনতি আর সীমা আলাদা register-এ বসিয়ে দিলে লাফের খরচ প্রায় শূন্য: LOOP-এর ধারণারই আধুনিক রূপ। আর C-তে for লিখলে কোন ধাঁচ আসবে, তা compiler ঠিক করে; C পর্ব ৪৬-এ C থেকে তৈরি assembly পড়ার পদ্ধতি আছে।

মূল উপলব্ধি: LOOP ছিল দামি মেমরির যুগে কোড ছোট রাখার CISC সমাধান; আজকের CPU সরল নির্দেশের জোড়া বা আলাদা hardware loop দিয়ে একই কাজ করে, আর গতির প্রশ্নে সবসময় নির্দিষ্ট chip-এর নথি দেখতে হয়।

প্র ০৫বাজারঘরের দাম কেন পয়সায় পূর্ণসংখ্যা হিসেবে রাখা হলো, দশমিক বিন্দুর সংখ্যায় নয়? x86-এর BCD নির্দেশগুলোর ভাগ্যে কী ঘটল?

টাকার হিসাবে প্রতিটি পয়সা মিলতে হয়। দশমিক ভগ্নাংশ যেমন 0.10 binary-তে ঠিকঠাক লেখা যায় না, ঠিক যেমন ১/৩ দশমিকে অসীম; তাই binary floating point-এ বারবার যোগ করলে ছোট ছোট গোলমাল জমে, আর বিলের শেষ অঙ্ক ভুল হতে পারে। তার ওপর 8086-এ floating point-এর hardware-ই ছিল না: সেজন্য আলাদা 8087 coprocessor লাগত, নয়তো software-এ ধীর হিসাব। সবচেয়ে সরল আর নির্ভুল সমাধান হলো সবচেয়ে ছোট একক, পয়সায় পূর্ণসংখ্যা রাখা, আর শুধু ছাপার সময় ১০০ দিয়ে ভাগ করে বিন্দু বসানো। এই পর্বের program ঠিক তাই করেছে: 12446 পয়সা, ছাপায় 124.46. গোল করার নিয়মও স্পষ্ট লেখা, +500 তারপর ভাগ, যাতে দোকান আর ক্রেতা একই উত্তর পান।

পূর্ণসংখ্যারও সীমা আছে, যা এই পর্বে দুবার দেখা গেছে: ১৬ বিটের যোগফল 655.35 টাকায় ঘুরে যায়, আর DIV-এর ভাগফল 65535 পেরোলে divide error. তাই নকশার সময় সবচেয়ে বড় সম্ভাব্য মান হিসাব করে বিটের মাপ বাছতে হয়; firmware-এ সাধারণত ৩২ বিট। দশমিক ভগ্নাংশ লাগলে এমবেডেড জগতে fixed-point গণিত চলে, যা পর্ব ৪০-এ (fixed-point গণিত)।

দশমিক নির্ভুলতার আরেক পুরোনো পথ ছিল BCD, প্রতি nibble-এ একটি দশমিক অঙ্ক। ক্যালকুলেটর, ক্যাশ রেজিস্টার আর সাত-খণ্ডের display-এর যুগে এটি স্বাভাবিক ছিল, কারণ প্রতিটি অঙ্ক সরাসরি দেখানো যায়। 8085 আর 8086 তাই DAA, আর 8086 DAS, AAA, AAS, AAM, AAD রেখেছিল। কিন্তু binary গুণ-ভাগ দ্রুত হয়ে যাওয়ায় BCD-র দরকার কমল। AMD-র নকশা করা ৬৪ বিটের x86 (x86-64) মোডে এই ছয়টি BCD নির্দেশ আর বৈধ নয়; ৩২ আর ১৬ বিটের মোডে সামঞ্জস্যের জন্য টিকে আছে। এই পর্বের AAM-কে অবশ্য অনুশীলন ২-এ কাজে লাগানো হয়েছে: দুই অঙ্কের সংখ্যা ভাঙার ছোট কৌশল হিসেবে।

মূল উপলব্ধি: টাকার হিসাব সবচেয়ে ছোট এককে পূর্ণসংখ্যায় রাখলে নির্ভুল থাকে, তবে বিটের সীমা আগে থেকে হিসাব করতে হয়; BCD একসময় একই সমস্যার hardware-সমাধান ছিল, ৬৪ বিটের x86-এ যার নির্দেশগুলো বাদ পড়েছে।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — সবচেয়ে হালকা জিনিস: বাজারঘরের scale একটি দিনে পাঁচটি ওজন রেখেছে: dw 1250, 150, 5000, 500, 650 (গ্রাম)। সবচেয়ে কম ওজনটি খুঁজে দশমিকে ছাপার NASM .COM program লিখুন (ছাপার জন্য print_u16 আর newline ধরে নিন)। কোন লাফ ব্যবহার করবেন, আর কেন?
    ; smallest.asm - lightest item on the scale list (CMP + JBE)
            org 100h
            mov si, wts
            mov cx, N - 1
            mov ax, [si]            ; lightest so far
    next:   add si, 2
            cmp ax, [si]
            jbe keep                ; AX <= [SI]: keep
            mov ax, [si]
    keep:   loop next
            call print_u16
            call newline
            mov ax, 4C00h
            int 21h
    wts:    dw 1250, 150, 5000, 500, 650
    N       equ ($ - wts) / 2
    %include "print_u16.inc"

    সবচেয়ে বড়র program-এর একটি লাইন বদল: jae-এর জায়গায় jbe (Jump if Below or Equal), কারণ এখন AX ≤ [SI] হলে AX রাখতে হবে। ওজন কখনো ঋণাত্মক নয়, তাই unsigned লাফ ঠিক। সত্যিকারের run ছাপে 150, শেষে SI = 0126H, ৭৮টি নির্দেশ। CX = N − 1 = 4, কারণ প্রথম ওজন তুলনা ছাড়াই AX-এ বসেছে।

  2. ভুল খুঁজুন — 131.0 টাকা: order86.asm-এ শুধু একটি জিনিস, items: dw 2000, দিলে runner ছাপে 13100 আর তারপর 131.0. হিসাব কি ভুল, না ছাপা? কারণ কী, আর AAM দিয়ে কীভাবে ঠিক করবেন?

    হিসাব ঠিক: 2000 × 6550 = 13100000, +500, ÷ 1000 = 13100 পয়সা। ভুল ছাপায়: 13100 ÷ 100 দেয় AX = 131, DX = 0, আর print_u16 0-কে একটি অঙ্ক “0” হিসেবে ছাপে, অথচ পয়সার অংশ সবসময় দুই অঙ্কে চাই। একই ভুল 1 থেকে 5000 g-এর মধ্যে ৪৯৯টি ওজনে হয় (মডেলের আউটপুট)। সমাধান: পয়সার অংশ (0–99) AL-এ এনে AAM, যা AH = AL ÷ 10 আর AL = AL mod 10 করে; তারপর দুটিকে ASCII বানিয়ে আলাদা ছাপা:

            mov al, dl              ; AL = paisa part (0..99)
            aam                     ; AH = tens, AL = units
            or ax, 3030h            ; both digits to ASCII
            mov bx, ax
            mov ah, 02h
            mov dl, '.'
            int 21h
            mov dl, bh              ; tens digit
            int 21h
            mov dl, bl              ; units digit
            int 21h

    এই অংশ নিয়ে লেখা পুরো program (13100 পয়সা দিয়ে) সত্যিকারের run-এ ছাপে 131.00, শেষে BX = 3030H: দুটি অঙ্কই '0'.

  3. আগে বলুন, তারপর চালান — 9! কোথায় যায়: mov ax, 40320, mov bx, 9, mul bx, hlt. শেষে DX, AX, CF আর OF কত? ফলটি দশমিকে কত, আর শুধু AX ছাপলে কী আসত?

    40320 × 9 = 362880 = 58980H. ৩২ বিটের ফল DX:AX-এ: DX = 0005H, AX = 8980H. DX শূন্য নয়, তাই MUL CF = OF = 1 বসায়। সত্যিকারের run (factloop.asm-এর শেষ অংশ): AX=8980 BX=0009 DX=0005, ছাপ O-I-S---C; SF-এর মান MUL-এর পরে অনির্ধারিত, তাই তার ওপর ভরসা নয়। শুধু AX ছাপলে আসত 8980H = 35200, একটি পুরোপুরি ভুল সংখ্যা, কোনো সতর্কবার্তা ছাড়া; সেজন্য MUL-এর পরে CF বা DX দেখা জরুরি।

  4. হিসাব — loop-এর গুনতি: (ক) sum_array.asm-এ LOOP কয়বার লাফায় আর কয়বার লাফায় না? (খ) শেষে SI কত, আর কেন সেটি total-এর ঠিকানা? (গ) কেউ ভুল করে mov cx, 0 লিখলে loop-এর শরীর কয়বার চলবে? (ঘ) বাজারঘরের একটি জিনিসের দাম order86.asm-এর পদ্ধতিতে যে সবচেয়ে বড় ওজন পর্যন্ত divide error ছাড়া হিসাব হয়, সেটি কত?

    (ক) পাঁচ পাকে চারবার লাফায় (CX = 4, 3, 2, 1), শেষবার CX = 0, লাফায় না। (খ) SI = 011DH + 5 × 2 = 0127H; array-র ঠিক পরেই total ঘোষণা করা, তাই সেটিই। সত্যিকারের run-এ SI = 0127H আর mov [0x127],ax. (গ) ৬৫৫৩৬ বার: প্রথম LOOP 0 − 1 = FFFFH করে। সত্যিকারের run (inc ax আর loop): ১৩১০৭৫টি নির্দেশ = ২ + ৬৫৫৩৬ × ২ + ১ (hlt), আর AX ঘুরে 0000H. (ঘ) ভাগফল ≤ 65535 লাগবে: (g × 6550 + 500) ÷ 1000 ≤ 65535 থেকে g ≤ 10005. সত্যিকারের run-এ 10005 g → 65533 পয়সা, 10006 g → divide error. Python-এও একই সীমা মিলিয়ে দেখা।

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

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

ক্রমএকটি 8086 .COM program (NASM) লেখা থেকে শেষ হওয়া পর্যন্ত ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. org 100h দিয়ে source লেখা, শেষে data আর $
  2. NASM -f bin দিয়ে flat binary বানানো, label-এর জায়গায় offset বসে
  3. Loader binary-কে segment-এর 0100H-এ বসায়, CS = DS = ES = SS
  4. CPU CS:IP = segment:0100H থেকে নির্দেশ চালায়
  5. AH = 4Ch দিয়ে INT 21h: program শেষ, DOS-এ ফেরা

8086-এ DOS-এর INT 21h, AH = 09h service কোন ঠিকানা থেকে কতদূর পর্যন্ত লেখা ছাপে?

  • DS:SI থেকে 00H পর্যন্ত
  • DS:DX থেকে '$' (24H) পর্যন্ত, '$' বাদে
  • DS:DX থেকে CX সংখ্যক byte
  • শুধু DL-এর একটি অক্ষর

8086-এর LOOP next নির্দেশ ঠিক কী করে?

  • যেকোনো register এক কমিয়ে শূন্য হলে লাফায়
  • CX এক কমিয়ে CX = 0 হলে next-এ লাফায়
  • CX এক কমিয়ে CX ≠ 0 হলে next-এ লাফায়, flag অক্ষত
  • CX এক কমিয়ে ZF বসায়, তারপর JNZ-এর মতো লাফায়

8086-এ AX = FFFFH, তারপর cmp ax, 1. কোন লাফটি লাফাবে?

  • JAE আর JGE দুটিই লাফায়
  • JB লাফায়, JGE লাফায় না
  • কোনোটিই লাফায় না, কারণ CMP flag বদলায় না
  • JAE লাফায়, JGE লাফায় না

8086-এ AX = 0096H (150) আর BX = 1996H (6550). mul bx-এর পরে DX আর AX কত?

  • DX = 000EH, AX = FDE4H
  • DX অপরিবর্তিত, AX = FDE4H
  • DX = FDE4H, AX = 000EH
  • BX = 000EH, AX = FDE4H

MASM-এর .EXE program-এর শুরুতে MOV AX, @DATA আর MOV DS, AX কেন লেখা হয়?

  • AX-কে শূন্য করতে, যাতে ছাপা ঠিক হয়
  • শুরুতে DS PSP-তে থাকে; data segment দেখাতে DS বদলাতে হয়, আর সরাসরি সংখ্যা রাখা যায় না
  • Stack তৈরি করতে
  • .COM program-কে .EXE বানাতে

8086-এ mov al, 75h, add al, 48h, তারপর daa. শেষে AL আর CF কত?

  • AL = BDH, CF = 0
  • AL = 23H, CF = 0
  • AL = 23H, CF = 1
  • AL = 123H, CF = 0

শব্দকোষ

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

মনে রাখুন

  1. কাঠামো: NASM .COM: org 100h, এক segment, DS ঠিক করা লাগে না; MASM .EXE: .MODEL, .DATA, .CODE, শুরুতে MOV AX,@DATA আর MOV DS,AX.
  2. ছাপা: INT 21h: AH = 09h DS:DX থেকে $ পর্যন্ত, AH = 02h DL-এর একটি অক্ষর, AH = 4Ch বেরোনো; সংখ্যা ছাপতে 10 দিয়ে বারবার ভাগ।
  3. Loop: CX = গুনতি, SI = ঠিকানা (word হলে +2), LOOP = CX − 1 আর CX ≠ 0 হলে লাফ, flag অক্ষত; CX = 0 মানে ৬৫৫৩৬ পাক।
  4. তুলনা: CMP শুধু flag; unsigned-এ JA/JAE/JB/JBE (CF), signed-এ JG/JGE/JL/JLE (SF, OF).
  5. গুণ-ভাগ: MUL → DX:AX, DX ≠ 0 হলে CF = OF = 1; DIV DX:AX-কে ভাগ করে AX = ভাগফল, DX = ভাগশেষ, ভাগফল বড় হলে divide error. বাজারঘরের অর্ডার: 983 + 8188 + 3275 = 12446 পয়সা = 124.46 টাকা।

পরের পর্বে: পর্ব ১৮ (8086-এর procedure, stack frame আর macro). এই পর্বের print_u16 ভেতরে কীভাবে কাজ করে, stack-এ parameter পাঠানো, BP দিয়ে frame আর NASM-এর %macro, সত্যিকারের run দিয়ে।

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

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