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

8086-এর instruction set — data, arithmetic, logic আর control

8086 Instruction Set — Data Transfer, Arithmetic, Logic and Control

Taught in Bangla, this lesson works through the 8086 instruction groups with programs assembled by NASM and traced on Unicorn. It covers MOV rules, XCHG, XLAT, LEA and LDS, the fixed registers of MUL, IMUL, DIV and IDIV, a real divide error, BCD and ASCII adjust, shifts and rotates with count 1 or CL, and conditional jumps where JL and JB give opposite answers for a negative temperature. It also shows how the assembler handles short-only Jcc, and lists clock costs.

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

  • 8086-এর নির্দেশগুলোকে ছয়টি দলে সাজানো, আর প্রতিটি দল flag-কে কীভাবে ছোঁয় তা বলা
  • XCHG, XLAT, LEA আর LDS-এর কাজ, আর MOV-এর নিষেধগুলো চেনা
  • MUL, IMUL, DIV, IDIV-এর ফল কোন register-এ যায়, হাতে বের করা আর runner-এ মেলানো
  • সাতটি shift/rotate-এর পরে ফল, CF আর OF বলা; ROL আর RCL-এর পার্থক্য ধাপে ধাপে দেখা
  • signed আর unsigned তুলনার জন্য সঠিক শর্তযুক্ত লাফ বেছে নেওয়া, আর near ও far CALL/JMP-এ stack কী হয় বোঝা

১ · Instruction set-এর ছয়টি দল — 8085 থেকে কী বদলাল

একটি CPU যত রকম কাজ বোঝে, তার পুরো তালিকাকে বলে instruction set. প্রতিটি নির্দেশের একটি ছোট নাম থাকে, যাকে বলে mnemonic (MOV, ADD, JMP), আর মেমরিতে তা থাকে এক বা একাধিক byte হিসেবে, যার প্রথম অংশ opcode. 8085-এর নির্দেশ আপনি পর্ব ০৯-এ দেখেছেন। 8086-এর তালিকা অনেক বড়, কিন্তু ভয় পাওয়ার কিছু নেই: দলগুলো প্রায় একই, শুধু প্রতিটি দলে নতুন কিছু সদস্য এসেছে।

উপমা — দোকানের কর্মচারীর কাজের তালিকা: বাজারঘরের একজন কর্মচারীর কাজ ছয় রকম: মাল এক তাক থেকে অন্য তাকে সরানো (data transfer), দাম যোগ-গুণ করা (arithmetic), বস্তা খুলে বাছাই করা (logic আর shift), এক সারি মাল একসঙ্গে সরানো (string), খাতায় লেখা নিয়ম দেখে পরের কাজে যাওয়া (control transfer), আর দোকানের বাতি-পাখা চালু-বন্ধ করা (flag আর processor control). 8085 ছিল ছোট দোকানের একজন কর্মচারী; 8086 একই কাজ করে, তবে বড় বস্তায় (১৬ বিট) আর হাতে ক্যালকুলেটর নিয়ে (MUL, DIV).

পূর্বজ্ঞান এক লাইনে: register, segment আর flag পর্ব ১৪-এ; operand কোথা থেকে আসে, অর্থাৎ addressing mode আর effective address, পর্ব ১৫-এ। এখানে সেগুলো ধরে নিয়ে প্রশ্ন একটাই: নির্দেশটি কী করে, কোন register ছোঁয়, আর কোন flag বদলায়। লেখার নিয়ম আগের মতো: hex লেখা Intel-এর ধরনে, শেষে H (02FAH); কোডের ভেতরে NASM-এর নিয়মে ছোট হাতের h. সব program কোর্সের 8086 runner run8086.py-এ চলেছে: NASM 3.02 দিয়ে cpu 8086 মোডে assemble, Unicorn 2.1.4-এ চালানো (reference lab, Spec decision 13).

দলউদাহরণFlag8085-এ ছিল?
Data transferMOV XCHG XLAT LEA LDS LES PUSH POP IN OUT LAHF SAHF PUSHF POPFছোঁয় না (SAHF, POPF বাদে)MOV, XCHG, PUSH আছে; XLAT, LEA, LDS নতুন
ArithmeticADD ADC SUB SBB INC DEC NEG CMP MUL IMUL DIV IDIV CBW CWD DAA DAS AAA AAS AAM AADবদলায়গুণ-ভাগ, NEG, ASCII adjust নতুন
Logic, shift, rotateAND OR XOR NOT TEST SHL SHR SAR ROL ROR RCL RCRবদলায়শুধু A-র ১ বিট rotate ছিল
StringMOVS CMPS SCAS LODS STOS + REPCMPS, SCAS বদলায়নেই (পর্ব ১৯)
Control transferJMP CALL RET Jcc LOOP LOOPE LOOPNE JCXZ INT INTO IRETছোঁয় না (INT, IRET বাদে)far লাফ, LOOP, signed শর্ত নতুন
Flag আর processor controlCLC STC CMC CLD STD CLI STI HLT NOP WAIT LOCK ESCনির্দিষ্ট একটি flagSTC, CMC, EI/DI, HLT ছিল

একটি বড় পার্থক্য মাথায় রাখুন। 8085-এর বেশিরভাগ হিসাব accumulator A দিয়ে যেত। 8086-এ ADD, SUB, AND, CMP যেকোনো দুটি register বা register আর মেমরির মধ্যে চলে। তবে কিছু নির্দেশ এখনো নির্দিষ্ট register ছাড়া চলে না: গুণ-ভাগ AX আর DX চায়, XLAT BX আর AL চায়, LOOP CX চায়, shift-এর count CL-এ থাকে। এগুলোকে বলে implicit operand: নির্দেশে লেখা থাকে না, অথচ নির্দেশটি সেগুলো ছোঁয়। পরীক্ষার বেশিরভাগ ফাঁদ এখানেই।

8086-এর নির্দেশের দৈর্ঘ্যও এক নয়, prefix ছাড়া এক থেকে ছয় byte. এই পর্বের সত্যিকারের run থেকেই পাঁচ রকম পাওয়া যায়: xchg ax,bx এক byte (93), mul bl দুই (F6 E3), mov ax,1250 তিন (B8 E2 04), lds dx,[fptr] চার (C5 16 23 01), আর far call পাঁচ (9A 0F 01 00 10). প্রায়ই ব্যবহৃত কাজের জন্য ছোট রূপ রাখা হয়েছে, যেমন AX-এর সঙ্গে XCHG এক byte-এ। এজন্য 8086-কে CISC ধাঁচের বলা হয়: নানা দৈর্ঘ্যের, নানা কাজের নির্দেশ, কিছু নির্দেশ ভেতরে বহু ধাপে চলে। RISC-V-এর মতো আধুনিক নকশায় প্রায় সব নির্দেশ একই চার byte (Computer Architecture পর্ব ২৭)।

২ · Data transfer — MOV-এর নিয়ম, XCHG, XLAT, LEA আর LDS

MOV dest, src src-এর কপি dest-এ রাখে; src বদলায় না, কোনো flag-ও না। চলার আগেই তিনটি নিষেধ জানা দরকার, কারণ assembler সেগুলো ধরবে: মেমরি থেকে সরাসরি মেমরিতে MOV নেই; segment register-এ সরাসরি সংখ্যা রাখা যায় না; আর CS-এ MOV দিয়ে লেখা যায় না (CS বদলায় far লাফ, অংশ ৫)। নিচের তিনটি নির্দেশ এই সীমা পূরণে কাজে লাগে।

  • XCHG দুটি operand-এর মান অদলবদল করে, তৃতীয় কোনো register ছাড়াই।
  • XLAT একটি lookup table থেকে byte পড়ে: AL = [DS:BX + AL]. BX টেবিলের শুরু, AL ঘরের নম্বর।
  • LEA ঠিকানাটি হিসাব করে register-এ রাখে, মেমরি পড়ে না; MOV সেই ঠিকানার data পড়ে। LDS আর LES মেমরি থেকে একটি far pointer (offset আর segment) একসঙ্গে তোলে।

বাজারঘরের smart scale-এর display-এ সংখ্যা দেখাতে প্রতিটি অঙ্কের জন্য একটি seven-segment নকশা লাগে: কোন segment জ্বলবে তার বিট (common cathode, gfedcba ক্রমে)। অঙ্ক থেকে নকশা পেতে হিসাব নয়, টেবিল দেখাই সহজ, আর XLAT ঠিক এই কাজের নির্দেশ:

; data86.asm - XCHG, XLAT, LEA vs MOV, LDS, LAHF (8086, NASM)
        org 100h
        mov ax, 1250
        mov bx, 6550
        xchg ax, bx         ; swap, no third register
        mov bx, segtab      ; 7-segment codes for 0..9
        mov al, 5
        xlat                ; AL = [DS:BX + AL]
        lea si, [bx+4]      ; SI = the address BX + 4
        mov di, [bx+4]      ; DI = the word stored there
        lds dx, [fptr]      ; DX = offset, DS = segment
        lahf                ; AH = low byte of FLAGS
        hlt
segtab  db 3Fh, 06h, 5Bh, 4Fh, 66h, 6Dh, 7Dh, 07h, 7Fh, 6Fh
fptr    dw 0050h, 1010h

সত্যিকারের run (run8086.py, NASM 3.02, Unicorn 2.1.4; লাইন ছোট রাখতে শুধু দরকারি register):

$ python -B run8086.py data86.asm --trace --mem 0119h,14
1000:0100 B8E204     mov ax,0x4e2    AX=04E2 BX=0000 SI=0000 DI=0000 DX=0000 DS=1000
1000:0103 BB9619     mov bx,0x1996   AX=04E2 BX=1996 SI=0000 DI=0000 DX=0000 DS=1000
1000:0106 93         xchg ax,bx      AX=1996 BX=04E2 SI=0000 DI=0000 DX=0000 DS=1000
1000:0107 BB1901     mov bx,0x119    AX=1996 BX=0119 SI=0000 DI=0000 DX=0000 DS=1000
1000:010A B005       mov al,0x5      AX=1905 BX=0119 SI=0000 DI=0000 DX=0000 DS=1000
1000:010C D7         xlatb           AX=196D BX=0119 SI=0000 DI=0000 DX=0000 DS=1000
1000:010D 8D7704     lea si,[bx+0x4] AX=196D BX=0119 SI=011D DI=0000 DX=0000 DS=1000
1000:0110 8B7F04     mov di,[bx+0x4] AX=196D BX=0119 SI=011D DI=6D66 DX=0000 DS=1000
1000:0113 C5162301   lds dx,word [0x123] AX=196D BX=0119 SI=011D DI=6D66 DX=0050 DS=1010
1000:0117 9F         lahf            AX=026D BX=0119 SI=011D DI=6D66 DX=0050 DS=1010
1000:0119  3F 06 5B 4F 66 6D 7D 07 7F 6F 50 00 10 10
[exit code 0 via HLT, 11 instructions]

লাইন ধরে পড়ুন। XCHG-এর পরে AX = 1996H (দর 6550) আর BX = 04E2H (ওজন 1250): এক byte-এর নির্দেশে (93) অদলবদল। টেবিল বসেছে 0119H-এ; AL = 5 দিয়ে XLAT পড়ল 0119H + 5 = 011EH-এর byte, 6DH, অর্থাৎ অঙ্ক ৫-এর নকশা (a, c, d, f, g জ্বলে)। LEA si,[bx+4] দিল শুধু ঠিকানা 011DH; একই ঠিকানা দিয়ে MOV পড়ল সেখানকার word, 6D66H (66H আর 6DH, little-endian). LDS এক নির্দেশে DX = 0050H আর DS = 1010H বসাল। আর LAHF FLAGS-এর নিচের byte AH-এ আনল: 02H, কারণ বিট ১ সবসময় 1 আর বাকি status flag 0. লক্ষ করুন, পুরো program-এ কোনো status flag বদলায়নি; data transfer flag ছোঁয় না।

MASM আর NASM — একই নির্দেশ, আলাদা লেখা

অনেক বই MASM-এর ধরনে লেখে, এই কোর্সের কোড NASM-এ। পার্থক্যগুলো বেশিরভাগ লেখার ধাঁচে, মেশিন কোড একই। MASM-এ একটি নামের ঠিকানা নিতে লিখতে হয় mov bx, offset segtab; NASM-এ শুধু mov bx, segtab, কারণ NASM-এ বন্ধনী ছাড়া নাম মানেই ঠিকানা, আর [segtab] মানে সেই ঠিকানার data. মাপ বলতে MASM লেখে byte ptr [bx], NASM লেখে byte [bx]. NASM-এ xlat আর xlatb একই নির্দেশ (runner-এর disassembly xlatb দেখিয়েছে); MASM-এ xlat segtab লেখা যায়, যেখানে নামটি শুধু segment বোঝাতে কাজে লাগে। আর lea si,[bx+4] MASM-এ lea si,[bx+4] বা lea si,4[bx] দুইভাবেই লেখা চলে। পরীক্ষায় যে syntax-এ প্রশ্ন, উত্তরও সেই syntax-এ লিখুন।

নিষেধগুলোও assembler নিজেই ধরে। দুটি ভুল লাইন (shl ax, 4 আর mov [bx], [si]) দিয়ে সত্যিকারের run:

$ python -B run8086.py err1.asm
error: NASM failed:
~/lab\err1.asm:2: error: no instruction for this cpu level
~/lab\err1.asm:3: error: invalid combination of opcode and operands

দ্বিতীয় লাইনের অর্থ: মেমরি থেকে মেমরিতে MOV 8086-এ নেই, মাঝে একটি register লাগে। প্রথম লাইনের গল্প অংশ ৪-এ। বাকি data transfer নির্দেশ ছোট টেবিলে:

নির্দেশকাজমনে রাখার কথা
PUSH, POPSS:SP-তে word রাখা আর তোলাসবসময় ১৬ বিট; বিস্তারিত পর্ব ১৮-এ
PUSHF, POPFপুরো FLAGS stack-এlab-এ বিট ১২–১৫ 0 দেখায়, আসল 8086-এ 1 (Spec decision 15)
LAHF, SAHFFLAGS-এর নিচের byte ↔ AH8085-এর PSW-এর সঙ্গে মিল রাখতে রাখা
IN, OUTI/O port পড়া-লেখাশুধু AL/AX দিয়ে; port নম্বর ৮ বিট বা DX (পর্ব ১৫)
LESLDS-এর মতো, segment যায় ES-এstring নির্দেশের গন্তব্যের জন্য (পর্ব ১৯)

৩ · Arithmetic — যোগ-বিয়োগ থেকে গুণ-ভাগ

যোগ-বিয়োগের নির্দেশ 8085-এর মতোই ভাবা যায়, শুধু চওড়া ১৬ বিট: ADD, carry-সহ ADC, SUB, ধার-সহ SBB. CMP a, b আসলে a − b করে ফল ফেলে দেয়, শুধু flag রাখে (অংশ ৫-এ এর কাজ)। NEG two's complement নেয়: 0 − operand. আর INC/DEC এক বাড়ায়-কমায়, কিন্তু একটি ব্যতিক্রমসহ: এরা CF ছোঁয় না। ফলে একটি loop-এ ADC দিয়ে বহু byte যোগ করার সময় গোনার জন্য INC ব্যবহার করলে carry নষ্ট হয় না, এটাই নকশার উদ্দেশ্য। ছয়টি flag-এর অর্থ আর যোগের পরের মান পর্ব ১৪-এ ধাপে ধাপে দেখানো আছে, সেখান থেকে মিলিয়ে নিন।

MUL, IMUL, DIV, IDIV — কোন register-এ কী

8085-এ গুণ-ভাগ ছিল না; loop চালিয়ে বারবার যোগ বা বিয়োগ করতে হতো (পর্ব ১১)। 8086-এ চারটি নির্দেশ: unsigned MUL আর DIV, signed IMUL আর IDIV. চারটিরই নির্দেশে মাত্র একটি operand লেখা থাকে, যা register বা মেমরি, কখনো সরাসরি সংখ্যা নয়। অন্য operand আর ফলের জায়গা বাঁধা, আর operand-এর মাপ (byte না word) দেখে CPU ঠিক করে কোন জোড়া ব্যবহার হবে। পুরো নিয়মটি একটি ছবিতে:

ছবি ১৬.১ — গুণ আর ভাগে register-এর বাঁধা জায়গা

নীল = নির্দেশে লেখা নেই কিন্তু ব্যবহার হয়; হলুদ = নির্দেশে লেখা operand; সবুজ = ফল

MUL, IMUL, DIV, IDIV-এর register MUL / IMUL · ৮ বিট (r/m8) MUL / IMUL · ১৬ বিট (r/m16) DIV / IDIV · ৮ বিট (r/m8) DIV / IDIV · ১৬ বিট (r/m16) ALr/m8 AXr/m16 AHALr/m8 DXAXr/m16 AHAL DXAX AL = ভাগফলAH = ভাগশেষ AX = ভাগফলDX = ভাগশেষ ×× ÷÷ == →→ ফল ১৬ বিট: AX ফল ৩২ বিট: DX:AX ভাজ্য AX ভাজ্য DX:AX ভাগফল না আঁটলে: type 0
ছবি ১৬.১ — Intel-এর 8086 manual-এর নিয়ম। গুণে ফল সবসময় operand-এর দ্বিগুণ চওড়া, তাই কখনো overflow হয় না; ভাগে উল্টো, দ্বিগুণ চওড়া ভাজ্যকে ভাগ করে অর্ধেক চওড়া ভাগফল, তাই ভাগফল না আঁটলে CPU divide error (interrupt type 0) তোলে।

এবার একই বিট দুই অর্থে গুণ করে দেখি। AL = FEH: unsigned অর্থে 254, signed অর্থে −2 (পর্ব ০৫-এর two's complement). সঙ্গে ভাগ, sign extension-এর দুটি নির্দেশ CBW (AL → AX) আর CWD (AX → DX:AX):

; muldiv.asm - MUL, IMUL, DIV, IDIV: which registers (8086, NASM)
        org 100h
        mov al, 0FEh
        mov bl, 3
        mul bl              ; AX = AL x BL, unsigned: 254 x 3
        mov al, 0FEh
        imul bl             ; AX = AL x BL, signed: -2 x 3
        mov ax, 1000
        mov bl, 7
        div bl              ; AX / BL: AL = quotient, AH = remainder
        mov ax, -100
        idiv bl             ; signed: -100 / 7
        mov al, -100
        cbw                 ; AL -> AX with the sign
        cwd                 ; AX -> DX:AX with the sign
        hlt
$ python -B run8086.py muldiv.asm --trace     (১৪টির মধ্যে ৭টি লাইন; শুধু AX, DX আর flag)
1000:0104 F6E3       mul bl          AX=02FA DX=0000 O-I-S--PC
1000:0106 B0FE       mov al,0xfe     AX=02FE DX=0000 O-I-S--PC
1000:0108 F6EB       imul bl         AX=FFFA DX=0000 --I-S--P-
1000:010F F6F3       div bl          AX=068E DX=0000 --I-S--P-
1000:0114 F6FB       idiv bl         AX=FEF2 DX=0000 --I-S--P-
1000:0118 98         cbw             AX=FF9C DX=0000 --I-S--P-
1000:0119 99         cwd             AX=FF9C DX=FFFF --I-S--P-
নির্দেশের পরে
নির্দেশ
AH · AL
BL
AL-এর অর্থ
হিসাব
CF · OF
  1. শুরু। AL = FEH = 1111 1110b, BL = 03H. বিটগুলো জানে না তারা 254 না −2; কোন নির্দেশ চালানো হবে, তা-ই অর্থ ঠিক করবে।
  2. mul bl. unsigned গুণ: 254 × 3 = 762 = 02FAH, ফল পুরো AX-এ। AH = 02H, শূন্য নয়, অর্থাৎ ফলের উঁচু অর্ধেক কাজে লেগেছে, তাই CF = OF = 1. runner-এর ছাপ O-I-S--PC.
  3. mov al,0FEh. শুধু AL বদলাল; AH-এ আগের 02H রয়ে গেছে, AX = 02FEH. IMUL AH-কে কোনো কাজে নেয় না, শুধু ফল দিয়ে ঢেকে দেবে।
  4. imul bl. signed গুণ: −2 × 3 = −6 = FFFAH. AH = FFH শুধু AL-এর চিহ্নের বিস্তার, অর্থাৎ ফল AL-এ একাই আঁটে, তাই CF = OF = 0. একই বিট, ভিন্ন নির্দেশে ভিন্ন উত্তর।

একটি চরম উদাহরণ পরীক্ষায় প্রায়ই আসে: AX = BX = FFFFH. mul bx unsigned অর্থে 65535 × 65535 = 4294836225 = FFFE0001H, তাই DX = FFFEH, AX = 0001H, CF = OF = 1. একই বিটে imul bx মানে (−1) × (−1) = 1: DX = 0000H, AX = 0001H, CF = OF = 0. সত্যিকারের run-এ ঠিক তাই: mul bx → AX=0001 DX=FFFE O-I-----C, আর imul bx → AX=0001 DX=0000 --I------. AX-এর মান দুবারই 0001H; পার্থক্য পুরোটা DX-এ।

ভাগের লাইনগুলোও পড়ুন। div bl: 1000 ÷ 7 = 142, ভাগশেষ 6; AX = 068EH মানে AH = 06H (ভাগশেষ) আর AL = 8EH (142). idiv bl: −100 ÷ 7 = −14, ভাগশেষ −2; AX = FEF2H, AL = F2H (−14), AH = FEH (−2). 8086-এর signed ভাগ শূন্যের দিকে কাটে, আর ভাগশেষের চিহ্ন ভাজ্যের মতো। CBW AL = 9CH (−100)-কে AX = FF9CH বানাল, CWD চিহ্নের বিট DX-এ ছড়িয়ে দিল: DX = FFFFH. ১৬ বিটের signed সংখ্যা IDIV দিয়ে ভাগ করার আগে CWD লাগে ঠিক এই কারণে।

সাবধান — অনির্ধারিত flag: Intel-এর manual অনুযায়ী MUL/IMUL-এর পরে শুধু CF আর OF-এর অর্থ আছে; SF, ZF, AF, PF অনির্ধারিত (undefined). DIV/IDIV-এর পরে ছয়টি status flag-ই অনির্ধারিত। ওপরের ছাপে S আর P যা দেখাচ্ছে, তা Unicorn-এর নিজস্ব আচরণ, 8086-এর প্রতিশ্রুতি নয়। গুণ-ভাগের পরে ZF দেখে লাফ দেওয়া program অন্য CPU-তে ভুল করতে পারে।

নিজের সংখ্যা দিয়ে নিয়মটি পরখ করুন। নিচের মডেল চারটি নির্দেশের register-এর নিয়ম Python-এ লেখে; প্রথম সাতটি লাইন ওপরের runner-এর ফলের সঙ্গে মিলিয়ে দেখা হয়েছে, শেষ দুটি পরের অংশের।

# 8086-এর MUL/IMUL/DIV/IDIV: কোন register-এ কী যায় (run8086.py-র সঙ্গে মেলানো)
def s(v, bits):                       # unsigned বিট → signed সংখ্যা
    return v - (1 << bits) if v >> (bits - 1) else v

def mul(a, b, bits, signed=False):    # AX = AL×src, বা DX:AX = AX×src
    if signed:
        a, b = s(a, bits), s(b, bits)
    p = (a * b) & ((1 << 2 * bits) - 1)
    lo = p & ((1 << bits) - 1)
    fits = (s(p, 2 * bits) == s(lo, bits)) if signed else (p == lo)
    hi_name, lo_name = ("AH", "AL") if bits == 8 else ("DX", "AX")
    w = bits // 4
    return f"{hi_name}={p >> bits:0{w}X}H {lo_name}={lo:0{w}X}H  CF=OF={int(not fits)}"

def div(n, d, bits, signed=False):    # AX÷src (৮ বিট) বা DX:AX÷src (১৬ বিট)
    if signed:
        n, d = s(n, 2 * bits), s(d, bits)
    q = abs(n) // abs(d) * (1 if (n < 0) == (d < 0) else -1)   # শূন্যের দিকে কাটা
    r = n - q * d                     # ভাগশেষের চিহ্ন = ভাজ্যের চিহ্ন
    lim = (-(1 << bits - 1), (1 << bits - 1) - 1) if signed else (0, (1 << bits) - 1)
    if not lim[0] <= q <= lim[1]:
        return f"ভাগফল {q} আঁটে না → divide error (type 0)"
    qn, rn = ("AL", "AH") if bits == 8 else ("AX", "DX")
    w, m = bits // 4, (1 << bits) - 1
    return f"{qn}={q & m:0{w}X}H ({q})  {rn}={r & m:0{w}X}H ({r})"

print("mul  bl, AL=FEH BL=03H  :", mul(0xFE, 3, 8))
print("imul bl, AL=FEH BL=03H  :", mul(0xFE, 3, 8, signed=True))
print("imul bl, AL=80H BL=02H  :", mul(0x80, 2, 8, signed=True))
print("mul  bx, AX=03D4H BX=07D0H:", mul(980, 2000, 16))
print("div  bl, AX=03E8H BL=07H:", div(1000, 7, 8))
print("idiv bl, AX=FF9CH BL=07H:", div(0xFF9C, 7, 8, signed=True))
print("div  cx, DX:AX=001DE840H CX=0578H:", div(0x1DE840, 1400, 16))
print("div  bl, AX=1592H BL=04H:", div(5522, 4, 8))
print("div  bx, DX:AX=00001592H BX=0004H:", div(5522, 4, 16))

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

mul  bl, AL=FEH BL=03H  : AH=02H AL=FAH  CF=OF=1
imul bl, AL=FEH BL=03H  : AH=FFH AL=FAH  CF=OF=0
imul bl, AL=80H BL=02H  : AH=FFH AL=00H  CF=OF=1
mul  bx, AX=03D4H BX=07D0H: DX=001DH AX=E840H  CF=OF=1
div  bl, AX=03E8H BL=07H: AL=8EH (142)  AH=06H (6)
idiv bl, AX=FF9CH BL=07H: AL=F2H (-14)  AH=FEH (-2)
div  cx, DX:AX=001DE840H CX=0578H: AX=0578H (1400)  DX=0000H (0)
div  bl, AX=1592H BL=04H: ভাগফল 1380 আঁটে না → divide error (type 0)
div  bx, DX:AX=00001592H BX=0004H: AX=0564H (1380)  DX=0002H (2)

প্রথম দুই লাইন stepper-এর সঙ্গে মেলে। তৃতীয় লাইন একটি সূক্ষ্ম ঘটনা: −128 × 2 = −256 = FF00H; AL = 00H একা −256 বোঝাতে পারে না, তাই CF = OF = 1, যদিও AH = FFH দেখে চিহ্নের বিস্তার মনে হয়। নিয়মটি “AH কি AL-এর চিহ্নের হুবহু বিস্তার”, শুধু “AH = FFH” নয়। imul-এর এই ফল runner-এও একই: AX=FF00, CF আর OF দুটিই 1. চতুর্থ আর সপ্তম লাইন smart scale-এর ওজনের হিসাব, ঠিক নিচের stepper. শেষ দুই লাইন দেখায়, একই ভাগ ৮ বিটের ভাজকে ব্যর্থ, ১৬ বিটে সফল।

বাজারঘরের smart scale — ADC count থেকে গ্রাম

Reference lab-এর README (“বাজারঘর devices”) অনুযায়ী খালি platform-এ ADC দেয় 400 count, আর 2000 g ওজনে 1800 count. তাই গ্রাম = (raw − 400) × 2000 ÷ 1400. 1400 g আলু রাখলে raw = 1380. মাঝের গুণফল 980 × 2000 = 1960000, যা ১৬ বিটের সীমা 65535 অনেক ছাড়িয়ে যায়। 8086-এ এটি সমস্যা নয়: MUL bx ফল রাখে DX:AX-এ, আর DIV cx ঠিক সেই জোড়াকেই ভাগ করে।

; grams86.asm - scale: grams = (raw - 400) x 2000 / 1400
        org 100h
        mov ax, 1380        ; ADC raw counts
        sub ax, 400         ; minus the empty-platform zero
        mov bx, 2000
        mul bx              ; DX:AX = 980 x 2000
        mov cx, 1400
        div cx              ; AX = grams, DX = remainder
        hlt
$ python -B run8086.py grams86.asm --trace
1000:0100 B86405     mov ax,0x564    AX=0564 BX=0000 CX=0000 DX=0000 --I------
1000:0103 2D9001     sub ax,0x190    AX=03D4 BX=0000 CX=0000 DX=0000 --I----P-
1000:0106 BBD007     mov bx,0x7d0    AX=03D4 BX=07D0 CX=0000 DX=0000 --I----P-
1000:0109 F7E3       mul bx          AX=E840 BX=07D0 CX=0000 DX=001D O-I-S---C
1000:010B B97805     mov cx,0x578    AX=E840 BX=07D0 CX=0578 DX=001D O-I-S---C
1000:010E F7F1       div cx          AX=0578 BX=07D0 CX=0578 DX=0000 O-I-S---C
[exit code 0 via HLT, 7 instructions]
0100mov ax,13800103sub ax,4000106mov bx,20000109mul bx010Bmov cx,1400010Ediv cx
নির্দেশের পরে
DX · AX
BX · CX
অর্থ
CF · OF
  1. mov ax,1380. ADC-র raw মান 1380 = 0564H, 1400 g আলুর জন্য README-র মান।
  2. sub ax,400. খালি platform-এর 400 count বাদ: 980 = 03D4H. এটিই ওজনের অংশ।
  3. mov bx,2000. গুণক 2000 = 07D0H. MUL সরাসরি সংখ্যা নেয় না, তাই আগে register-এ।
  4. mul bx. AX × BX = 980 × 2000 = 1960000 = 1DE840H. উঁচু word DX = 001DH, নিচু word AX = E840H. DX শূন্য নয়, তাই CF = OF = 1: “ফল AX-এ একা আঁটেনি”, ভুল নয়।
  5. mov cx,1400. ভাজক 1400 = 0578H. DX:AX ছোঁয়া হয়নি, ভাজ্য তৈরি।
  6. div cx. 1960000 ÷ 1400 = 1400, ভাগশেষ 0: AX = 0578H (1400 g), DX = 0000H. ভাগফল ১৬ বিটে আঁটে, তাই কোনো divide error নেই। Flag-এর মান এখন অনির্ধারিত।

এখানে ভাগ নিখুঁত, ভাগশেষ 0. raw = 1000 হলে 600 × 2000 ÷ 1400 = 857, ভাগশেষ 200: README-র firmware অর্ধেকের বেশি ভাগশেষে এক বাড়ায় (half away from zero), আর 200 < 700, তাই 857 g-ই থাকে। দামের হিসাব (net × 6550 + 500) ÷ 1000 একই MUL-DIV জোড়ায় হয়, যা পর্ব ১৪-এ চালিয়ে দেখানো আছে।

Divide error — যখন ভাগফল আঁটে না

Smart scale প্রতি মাপে চারবার ADC চালিয়ে গড় করে: (sum + 2) ÷ 4 (README). চারবার 1380 মানে sum = 5520. কেউ ভাবলেন ভাজক 4 ছোট, তাই div bl যথেষ্ট:

$ python -B run8086.py avg4.asm --trace      (mov ax,5520 · add ax,2 · mov bl,4 · div bl)
1000:0100  B89015  mov ax,0x1590   AX=1590 ...
1000:0103  83C002  add ax,0x2      AX=1592 ...
1000:0106  B304    mov bl,0x4      AX=1592 BX=0004 ...
1000:0108  F6F3    div bl          AX=1592 BX=0004 ...  IP=0108
----
error: divide error (INT 0) at 1000:0108 and no INT 0 handler installed

5522 ÷ 4 = 1380, কিন্তু div bl-এর ভাগফল যায় AL-এ, যার সীমা 255. CPU তাই divide error তোলে, অর্থাৎ interrupt type 0; শূন্য দিয়ে ভাগেও একই ঘটনা। এই lab-এ কোনো type 0 handler বসানো নেই, তাই run থামে (Spec decision 15). আর একটি পার্থক্য লক্ষ করুন: ছাপে IP = 0108H, অর্থাৎ DIV-এরই ঠিকানা। Unicorn একটি 386-ধাঁচের core, আর 386 থেকে এই নিয়ম; আসল 8086 stack-এ রাখে পরের নির্দেশের ঠিকানা (Spec decision 15). Handler লেখা আর vector table-এর গল্প পর্ব ২০-এ। ঠিক সমাধান অনুশীলন ২-এ।

BCD আর ASCII adjust — এক লাইনে করে

দাম বা ওজন display-এ দেখাতে দশমিক অঙ্ক লাগে। Packed BCD-এ এক byte-এ দুই অঙ্ক, unpacked BCD-এ এক byte-এ এক অঙ্ক (ASCII '0'–'9'-ও তাই)। 8086-এ binary যোগ-বিয়োগের পরে ঠিক করার ছয়টি নির্দেশ আছে: DAA আর DAS (packed, যোগ আর বিয়োগের পরে), AAA আর AAS (unpacked), AAM (গুণের পরে, AL-কে AH = AL ÷ 10, AL = AL mod 10 করে), আর AAD (ভাগের আগে, উল্টো কাজ)। Reference lab-এর bcd.asm চালালে সত্যিই ছাপে 123 (75H + 48H, তারপর DAA, CF = 1) আর 12 ('7' + '5', তারপর AAA). DAA-র ভেতরে কখন 06H বা 60H যোগ হয়, সেই নিয়ম 8085-এর মতোই, যা পর্ব ০৯-এ ধাপে ধাপে আছে।

৪ · Logic, shift আর rotate — বিট ধরে কাজ

AND, OR, XOR, NOT বিট ধরে কাজ করে, ঠিক C-র &, |, ^, ~-এর মতো (C কোর্সের পর্ব ০৯)। AND একটি bitmask দিয়ে বিট মুছে দেয় (and al,0Fh নিচের nibble রাখে), OR বিট জ্বালায়, XOR উল্টায়। TEST হলো AND, কিন্তু ফল ফেলে দিয়ে শুধু flag রাখে, যেমন CMP হলো SUB. এই চারটি (NOT বাদে) CF আর OF-কে সবসময় 0 করে, আর ZF, SF, PF ফল অনুযায়ী বসায়। একটি পুরোনো কৌশল: xor ax,ax AX শূন্য করে, mov ax,0-এর চেয়ে ছোট নির্দেশে (দুই byte বনাম তিন)।

Shift আর rotate register-এর বিটগুলোকে বাঁয়ে বা ডানে সরায়। কোন বিট বেরিয়ে যায় আর খালি ঘরে কী ঢোকে, সেটিই সাতটি নির্দেশের পার্থক্য:

নির্দেশদিকখালি ঘরে ঢোকেবেরোনো বিট যায়গাণিতিক অর্থ
SHL = SALবাঁয়ে0CF× 2
SHRডানে0CFunsigned ÷ 2
SARডানেচিহ্নের বিট নিজেইCFsigned ÷ 2, নিচের দিকে কাটা
ROLবাঁয়েবেরোনো MSBCF-এও কপি—
RORডানেবেরোনো LSBCF-এও কপি—
RCLবাঁয়েপুরোনো CFCF৯ বা ১৭ বিটের চক্র
RCRডানেপুরোনো CFCF৯ বা ১৭ বিটের চক্র

ছবি ১৬.২ — চারটি প্রতিনিধি: SHL, SAR, ROL, RCL

নীল = ৮ বা ১৬ বিটের register; হলুদ = CF; তীর = বিট কোথায় যায়

SHL, SAR, ROL আর RCL-এ বিটের পথ SHLSARROLRCL CFCFCFCF MSB · · · · · LSBMSB · · · · · LSB MSB · · · · · LSBMSB · · · · · LSB 0 চিহ্নের বিট থাকে, কপিও হয় MSB ঘুরে LSB-তে পুরোনো CF ঘুরে LSB-তে ৮ বিটের RCL আসলে CF-সহ ৯ বিটের চাকা
ছবি ১৬.২ — SHL-এ MSB যায় CF-এ, ডানে 0. SAR-এ LSB যায় ডান পাশের CF-এ, আর MSB (চিহ্ন) নিজের জায়গায় থেকে পাশের ঘরেও কপি হয়। ROL-এ MSB একসঙ্গে CF-এ আর LSB-তে যায়। RCL-এ MSB যায় CF-এ, আর আগের CF ঢোকে LSB-তে: CF চাকার একটি দাঁত।

একটি মান, 96H = 1001 0110b, আর শুরুতে CF = 1 (STC দিয়ে) নিয়ে সাতটি নির্দেশ একে একে চালানো হলো, প্রতিবার AL নতুন করে 96H. শেষে mov cl,4 আর shr al,cl. সত্যিকারের run থেকে শুধু shift/rotate-এর লাইন:

$ python -B run8086.py shift7.asm --trace      (২৫টির মধ্যে ৮টি লাইন; AX আর flag)
1000:0103 D0E0       shl al,1        AX=002C O-I-----C
1000:0108 D0E8       shr al,1        AX=004B O-I----P-
1000:010D D0F8       sar al,1        AX=00CB --I-S----
1000:0112 D0C0       rol al,1        AX=002D O-I-S---C
1000:0117 D0C8       ror al,1        AX=004B O-I-S----
1000:011C D0D0       rcl al,1        AX=002D O-I-S---C
1000:0121 D0D8       rcr al,1        AX=00CB --I-S----
1000:0127 D2E8       shr al,cl       AX=0009 --I----P-

দুটি জিনিস লক্ষ করুন। প্রথমত, ROL থেকে RCR পর্যন্ত S অক্ষরটি SAR-এর পর থেকে ঝুলে আছে: rotate শুধু CF আর OF বদলায়, SF, ZF, PF ছোঁয় না। দ্বিতীয়ত, count 1 হলে OF-এর একটি নির্দিষ্ট অর্থ আছে: বাঁয়ে সরালে “নতুন MSB ≠ CF”, অর্থাৎ চিহ্ন বদলে গেছে; count 1-এর বেশি হলে Intel OF-কে অনির্ধারিত বলে। নিয়মগুলো Python-এ লিখে মেলানো যায়:

# ৮ বিটের সাতটি shift/rotate, count = 1: ফল, CF আর OF (run8086.py-র shift7.asm-এর সঙ্গে মেলানো)
def op1(name, al, cf):
    msb, lsb = al >> 7, al & 1
    if name == "SHL": r, c = (al << 1) & 0xFF, msb
    if name == "SHR": r, c = al >> 1, lsb
    if name == "SAR": r, c = (al >> 1) | (al & 0x80), lsb      # চিহ্নের বিট থাকে
    if name == "ROL": r, c = ((al << 1) | msb) & 0xFF, msb
    if name == "ROR": r, c = (al >> 1) | (lsb << 7), lsb
    if name == "RCL": r, c = ((al << 1) | cf) & 0xFF, msb      # CF ঢোকে, MSB বেরোয়
    if name == "RCR": r, c = (al >> 1) | (cf << 7), lsb
    if name in ("SHL", "ROL", "RCL"):
        of = (r >> 7) ^ c                # বাঁয়ে: নতুন MSB ≠ CF হলে OF = 1
    elif name == "SAR":
        of = 0
    elif name == "SHR":
        of = msb                         # SHR: পুরোনো MSB
    else:
        of = (r >> 7) ^ ((r >> 6) & 1)   # ডানে rotate: ফলের ওপরের দুই বিট
    return r, c, of

al, cf = 0x96, 1
print(f"শুরু: AL = {al:02X}H = {al:08b}b, CF = {cf}")
for name in ("SHL", "SHR", "SAR", "ROL", "ROR", "RCL", "RCR"):
    r, c, of = op1(name, al, cf)
    print(f"{name} al,1 -> {r:02X}H = {r:08b}b  CF={c} OF={of}")

print("ROL বনাম RCL, AL = 81H, CF = 0, তিনবার:")
for name in ("ROL", "RCL"):
    v, c, steps = 0x81, 0, []
    for _ in range(3):
        v, c, _of = op1(name, v, c)
        steps.append(f"{v:02X}H/CF={c}")
    print(f"  {name}:", " -> ".join(steps))

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

শুরু: AL = 96H = 10010110b, CF = 1
SHL al,1 -> 2CH = 00101100b  CF=1 OF=1
SHR al,1 -> 4BH = 01001011b  CF=0 OF=1
SAR al,1 -> CBH = 11001011b  CF=0 OF=0
ROL al,1 -> 2DH = 00101101b  CF=1 OF=1
ROR al,1 -> 4BH = 01001011b  CF=0 OF=1
RCL al,1 -> 2DH = 00101101b  CF=1 OF=1
RCR al,1 -> CBH = 11001011b  CF=0 OF=0
ROL বনাম RCL, AL = 81H, CF = 0, তিনবার:
  ROL: 03H/CF=1 -> 06H/CF=0 -> 0CH/CF=0
  RCL: 02H/CF=1 -> 05H/CF=0 -> 0AH/CF=0

সাতটি লাইনের প্রতিটি ফল, CF আর OF runner-এর ছাপের সঙ্গে মেলে (যেমন SHR: AX=004B, O-I----P-, CF = 0). SAR-এ CBH: চিহ্নের 1 থেকে গেছে, তাই −106 থেকে −53, ঠিক ÷ 2. শেষের দুই লাইন নিচের stepper-এর বিষয়, আর এটিও আলাদা run-এ (rot86.asm) মেলানো।

rot86.asm, প্রতিটি নির্দেশের পরে
নির্দেশ
AL (binary)
AL
CF · OF
  1. শুরু। AL = 81H = 1000 0001b, CLC দিয়ে CF = 0. দুই প্রান্তেই একটি করে 1.
  2. rol al,1. MSB-র 1 বেরিয়ে একসঙ্গে LSB-তে আর CF-এ যায়: 0000 0011b = 03H, CF = 1. নতুন MSB 0 আর CF 1 আলাদা, তাই OF = 1.
  3. আবার rol. MSB 0, তাই LSB-তে আর CF-এ 0 যায়: 06H, CF = 0. ROL-এ কোনো বিট হারায় না, শুধু ঘোরে।
  4. তৃতীয় rol. 0CH, CF = 0. আটবার ঘোরালে AL আবার 81H হবে: চাকা ৮ বিটের।
  5. নতুন শুরু। একই 81H, CF = 0. এবার RCL: CF চাকার নবম দাঁত।
  6. rcl al,1. MSB-র 1 যায় CF-এ, আর আগের CF (0) ঢোকে LSB-তে: 0000 0010b = 02H, CF = 1. ROL-এর 03H থেকে পার্থক্য এখানেই।
  7. আবার rcl. CF-এর 1 এবার ঢুকল LSB-তে: 0000 0101b = 05H, CF = 0. আগের ধাপের বেরোনো বিট এক ধাপ পরে ফিরে এল।
  8. তৃতীয় rcl. 0AH, CF = 0. ৮ বিটের RCL আসলে ৯ বিটের চাকা, তাই নয়বার ঘোরালে শুরুর অবস্থা ফেরে। দুটি register জুড়ে ৩২ বিট সরাতে shl ax,1 তারপর rcl dx,1 ঠিক এই কারণে কাজ করে।

Count: 1, নয় CL — আর lab-এর একটি পার্থক্য

8086-এ shift/rotate-এর count দুই রকম: সংখ্যা 1, নয়তো CL register. shl ax,4-এর মতো সরাসরি বড় সংখ্যা 80186-এ যোগ হয়েছে। অংশ ২-এর NASM error (“no instruction for this cpu level”) সেটিই বলছিল। একই লাইন --cpu 186 দিয়ে assemble করলে সত্যিই নতুন opcode আসে:

$ python -B run8086.py shl186.asm --cpu 186 --trace
1000:0100  B89600   mov ax,0x96         AX=0096 ...
1000:0103  C1E004   shl ax,byte 0x4     AX=0960 ...
[exit code 0 via HLT, 3 instructions]

8086-এর জন্য লিখতে হয় mov cl,4 তারপর shl ax,cl. অনেক বই আর AI এই পার্থক্য ভুলে যায়, তাই NASM-এর cpu 8086 খুব কাজের পাহারাদার। আর একটি সূক্ষ্ম পার্থক্য: আসল 8086 CL-এর পুরো মান ধরে সরায়, কিন্তু 80286 থেকে Intel-এর CPU count-কে ৫ বিটে কেটে নেয়, অর্থাৎ ০ থেকে ৩১-এর মধ্যে রাখে। Unicorn 386-ধাঁচের, তাই lab-ও কেটে নেয় (Spec decision 15). CL = 33 (21H) দিয়ে সত্যিকারের run:

$ python -B run8086.py mask.asm --trace       (mov ax,96h · mov cl,33 · shl ax,cl)
1000:0103 B121       mov cl,0x21     AX=0096 CX=0021
1000:0105 D3E0       shl ax,cl       AX=012C CX=0021

Lab দেখাল 012CH, অর্থাৎ 33 mod 32 = 1 বার সরানো। আসল 8086-এ ৩৩ বার বাঁয়ে সরালে ১৬ বিটের সব বিট বেরিয়ে যেত, ফল 0000H. এজন্য এই কোর্সের কোনো উদাহরণ ১৫-এর বেশি count ব্যবহার করে না।

৫ · Control transfer — লাফ, ডাকা আর ফেরা

8085-এ লাফের ঠিকানা ছিল একটি ১৬ বিটের সংখ্যা। 8086-এ ঠিকানার দুই ভাগ, তাই লাফও তিন রকম। Short jump IP-র সঙ্গে একটি ৮ বিটের signed দূরত্ব যোগ করে, −128 থেকে +127 byte পর্যন্ত। Near jump যোগ করে ১৬ বিটের দূরত্ব, একই code segment-এর যেকোনো জায়গায় যায়। Far jump বা call নতুন CS আর IP দুটিই বসায়, অন্য segment-এ যায়। CALL near হলে শুধু IP stack-এ রাখে, far হলে আগে CS তারপর IP; ফেরার জন্য RET আর RETF ঠিক উল্টো কাজ করে। একটি ছোট program চারটিই দেখায়:

; ctl86.asm - short, near and far: JMP, CALL, RET, RETF
        org 100h
        jmp short a1        ; EB: IP + 8-bit displacement
a1:     jmp near b1         ; E9: IP + 16-bit displacement
b1:     call sub1           ; E8: push IP, near
        call 1000h:farsub   ; 9A: push CS, push IP, far
        hlt
sub1:   ret                 ; C3: pop IP
farsub: retf                ; CB: pop IP, pop CS
$ python -B run8086.py ctl86.asm --trace --mem 1000:FFFA,4     (শুধু SP আর IP)
1000:0100 EB00       jmp 0x102       SP=FFFE IP=0102
1000:0102 E90000     jmp 0x105       SP=FFFE IP=0105
1000:0105 E80600     call 0x10e      SP=FFFC IP=010E
1000:010E C3         ret             SP=FFFE IP=0108
1000:0108 9A0F010010 call word 0x1000:word 0x10f SP=FFFA IP=010F
1000:010F CB         retf            SP=FFFE IP=010D
1000:FFFA  0D 01 00 10
[exit code 0 via HLT, 7 instructions]

Short jump দুই byte (EB 00), near তিন byte (E9 00 00); দুটিতেই দূরত্ব 0, কারণ লক্ষ্য ঠিক পরের নির্দেশ। Near CALL SP-কে দুই কমায় (FFFCH), ফেরার ঠিকানা 0108H রাখে, আর RET সেটি তুলে IP = 0108H করে। Far CALL (9A, পাঁচ byte, ভেতরে offset 010FH আর segment 1000H) SP-কে চার কমায়: stack-এ রইল 0D 01 00 10, অর্থাৎ IP = 010DH নিচে আর CS = 1000H ওপরে। RETF দুটিই তুলে SP আবার FFFEH. Stack frame আর parameter-এর পুরো গল্প পর্ব ১৮-এ (8086-এর procedure, stack frame আর macro) পাবেন।

লক্ষ্য register বা মেমরিতে থাকলে লাফকে বলে indirect. jmp bx IP-তে BX-এর মান বসায়; jmp [jt+bx] একটি টেবিল থেকে ঠিকানা পড়ে। Smart scale-এর বোতাম সামলাতে এটি কাজে লাগে: বোতাম ০ শূন্য করা, বোতাম ১ tare. প্রতিটি ঠিকানা দুই byte, তাই বোতাম ১-এর জন্য BX = 2. সত্যিকারের run (jt.asm): NASM নির্দেশটিকে FF A7 18 01 করেছে, disassembly jmp word near [bx+0x118], আর program ছাপল T, ৮টি নির্দেশে। এমন টেবিলকে বলে jump table; C-র switch অনেক সময় compiler এভাবেই বানায়।

শর্তযুক্ত লাফ — signed আর unsigned আলাদা

শর্তযুক্ত লাফ (Jcc) কোনো তুলনা নিজে করে না; আগের নির্দেশ যে flag রেখে গেছে, শুধু সেটি দেখে। সাধারণত আগে থাকে CMP a, b. মূল কথা: একই CMP-এর পরে “a ছোট” প্রশ্নের দুটি আলাদা উত্তর হতে পারে, কারণ বিটগুলো unsigned না signed, CPU জানে না। তাই Intel দুই সেট নাম রেখেছে: unsigned-এর জন্য Above/Below, signed-এর জন্য Greater/Less.

CMP a, b-এর পরেunsignedশর্তsignedশর্ত
a > bJA = JNBECF = 0 আর ZF = 0JG = JNLEZF = 0 আর SF = OF
a ≥ bJAE = JNB = JNCCF = 0JGE = JNLSF = OF
a < bJB = JNAE = JCCF = 1JL = JNGESF ≠ OF
a ≤ bJBE = JNACF = 1 বা ZF = 1JLE = JNGZF = 1 বা SF ≠ OF
a = b / a ≠ bJE/JZ (ZF = 1), JNE/JNZ (ZF = 0): দুই অর্থেই একই
একটি flagJS/JNS, JO/JNO, JP/JPE, JNP/JPO, JC/JNC; আর JCXZ (CX = 0, কোনো flag নয়)

signed শর্তে SF আর OF দুটিই কেন? a − b-এর চিহ্ন (SF) সাধারণত বলে দেয় a ছোট কি না। কিন্তু বিয়োগ নিজেই signed সীমা পেরোলে (OF = 1) চিহ্নটি উল্টে যায়। তাই “a < b” মানে “SF আর OF আলাদা”। বাজারঘরের cold room-এ তাপমাত্রা রাখা হয় 0.01 °C এককে signed সংখ্যা হিসেবে: −1.50 °C মানে −150 = FF6AH. README অনুযায়ী 0.00 °C-এর নিচে low alarm. এখানে শুধু threshold-এর তুলনা দেখানো হচ্ছে; ০.৫০ °C hysteresis আর পরপর তিনটি মান মিলিয়ে নিশ্চিত হওয়ার নিয়ম পরের মডিউলগুলোর firmware-এ।

তুলনা আর লাফ
AX
অর্থ
CF ZF SF OF
JB (CF = 1)
JL (SF ≠ OF)
  1. মান। AX = FF6AH. unsigned ধরলে 65386, signed ধরলে −150, অর্থাৎ −1.50 °C. সঠিক অর্থ signed, কারণ তাপমাত্রা ঋণাত্মক হতে পারে।
  2. cmp ax,0. CPU FF6AH − 0000H করে, ফল ফেলে দেয়, flag রাখে: ধার নেই (CF = 0), ফল শূন্য নয় (ZF = 0), MSB 1 (SF = 1), signed সীমা পেরোয়নি (OF = 0). runner-এর ছাপেও শুধু S আর P.
  3. jb low. JB দেখে শুধু CF; CF = 0, তাই লাফ নেই। unsigned চোখে 65386 শূন্যের চেয়ে বড়। Low alarm বাজল না, অথচ cold room শূন্যের নিচে।
  4. jl low. JL দেখে SF ≠ OF: 1 ≠ 0, তাই লাফ নেওয়া হয়। signed চোখে −150 < 0. এটিই সঠিক নির্দেশ।
  5. উল্টো উদাহরণ। cmp ax,-1, AX = 7FFFH: বিয়োগে signed সীমা পেরোয়, OF = 1, SF = 1, আর CF = 1. JB নেয় (32767 < 65535), JL নেয় না (32767 > −1), বরং JG নেয়। দুই প্রশ্নের উত্তর দুই দিকে।

এবার পুরো program. পাঁচটি তাপমাত্রা (4.50, −1.50, 9.00, 8.00 আর 0.00 °C) দুবার পরীক্ষা: প্রথমবার JG/JL দিয়ে, দ্বিতীয়বার ভুল করে JA/JB দিয়ে। প্রতিটির জন্য ছাপে N (স্বাভাবিক), H (গরম) বা L (ঠান্ডা); INT 21h AH = 02h দিয়ে একটি অক্ষর ছাপা (Spec decision 14):

; cold86.asm (প্রথম অর্ধেক; দ্বিতীয় অর্ধেক হুবহু, শুধু ja/jb)
        org 100h
        mov si, temps       ; temperatures in 0.01 degC
        mov cx, 5
s_next: mov ax, [si]
        add si, 2
        mov dl, 'N'
        cmp ax, 800
        jg s_high           ; signed: above 8.00 degC
        cmp ax, 0
        jl s_low            ; signed: below 0.00 degC
        jmp s_show
s_high: mov dl, 'H'
        jmp s_show
s_low:  mov dl, 'L'
s_show: mov ah, 02h
        int 21h
        loop s_next
        ; ... same loop with ja / jb, then INT 21h AH=4Ch
temps   dw 450, -150, 900, 800, 0
$ python -B run8086.py cold86.asm
NLHNN NHHNN
[exit code 0 via INT 21h/4Ch, 115 instructions]

signed লাফে NLHNN: −1.50 °C ঠান্ডা (L), 9.00 °C গরম (H), আর ঠিক 8.00 °C “ওপরে নয়”, তাই N. unsigned লাফে NHHNN: −1.50 °C কে FF6AH = 65386 ধরে 800-এর চেয়ে বড় ভেবে “গরম” বলা হলো। Program কোনো error দেখায়নি, চলেছে নিখুঁতভাবে, শুধু উত্তর ভুল। এ ধরনের bug পরীক্ষা ছাড়া ধরা পড়ে না। নিচের মডেলে নিজের সংখ্যা দিয়ে flag আর লাফ পরখ করুন:

# CMP a, b-এর পরে flag, আর কোন শর্তযুক্ত লাফ নেওয়া হবে (১৬ বিট)
def cmp16(a, b):
    a &= 0xFFFF; b &= 0xFFFF
    r = (a - b) & 0xFFFF
    cf = int(a < b)                              # unsigned ধার
    zf = int(r == 0)
    sf = r >> 15
    of = ((a ^ b) & (a ^ r)) >> 15               # চিহ্ন আলাদা, আর ফলের চিহ্ন a-র উল্টো
    return cf, zf, sf, of

JUMPS = {                                         # Intel-এর শর্ত
    "JA":  lambda c, z, s, o: not c and not z,    # unsigned >
    "JB":  lambda c, z, s, o: c,                  # unsigned <
    "JG":  lambda c, z, s, o: not z and s == o,   # signed >
    "JL":  lambda c, z, s, o: s != o,             # signed <
    "JE":  lambda c, z, s, o: z,
}

def show(a, b):
    c, z, s, o = cmp16(a, b)
    taken = [j for j, f in JUMPS.items() if f(c, z, s, o)]
    print(f"cmp {a & 0xFFFF:04X}H,{b & 0xFFFF:04X}H ({a:>5} বনাম {b:>4}): "
          f"CF={c} ZF={z} SF={s} OF={o}  নেওয়া: {' '.join(taken) or '—'}")

for t in (450, -150, 900, 800, 0):               # cold room, 0.01 °C এককে
    show(t, 800)
show(-150, 0)
show(0x7FFF, -1)                                 # ধনাত্মক বনাম −1: OF-এর খেলা

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

cmp 01C2H,0320H (  450 বনাম  800): CF=1 ZF=0 SF=1 OF=0  নেওয়া: JB JL
cmp FF6AH,0320H ( -150 বনাম  800): CF=0 ZF=0 SF=1 OF=0  নেওয়া: JA JL
cmp 0384H,0320H (  900 বনাম  800): CF=0 ZF=0 SF=0 OF=0  নেওয়া: JA JG
cmp 0320H,0320H (  800 বনাম  800): CF=0 ZF=1 SF=0 OF=0  নেওয়া: JE
cmp 0000H,0320H (    0 বনাম  800): CF=1 ZF=0 SF=1 OF=0  নেওয়া: JB JL
cmp FF6AH,0000H ( -150 বনাম    0): CF=0 ZF=0 SF=1 OF=0  নেওয়া: JA JL
cmp 7FFFH,FFFFH (32767 বনাম   -1): CF=1 ZF=0 SF=1 OF=1  নেওয়া: JB JG

দ্বিতীয় লাইনটিই cold86.asm-এর bug: −150 বনাম 800-এ unsigned JA “বড়” বলে, signed JL “ছোট” বলে। শেষ তিনটি তুলনার flag কোর্সের runner-এ আলাদা run-এ মেলানো: cmp ax,0x320 (AX = FF6AH) দিল শুধু S, cmp ax,0 দিল S আর P, আর cmp ax,-1 (AX = 7FFFH) দিল O-I-S--PC. Python মডেল PF গোনে না, বাকি চারটি flag হুবহু মেলে।

8086-এর Jcc শুধু short — assembler কী করে

8086-এ প্রতিটি শর্তযুক্ত লাফ দুই byte: opcode আর ৮ বিটের দূরত্ব। লক্ষ্য 127 byte-এর বেশি দূরে হলে? 80386 near Jcc (0F 8x) এনেছে, 8086-এ তা নেই। NASM 3.02 cpu 8086-এ একটি কৌশল করে: শর্ত উল্টে ছোট লাফ, তার পরে একটি near JMP. মাঝে ২০০টি NOP রেখে je far_away লিখে সত্যিকারের assemble:

$ python -B run8086.py jfar.asm --bin        (cmp ax,0 · je far_away · times 200 nop · far_away: hlt)
bytes (209): 83 F8 00 75 03 E9 C8 00 90 90 90 ...
[exit code 0 via HLT, 4 instructions]

75 03 হলো JNE +3, যা পরের E9 C8 00 (near JMP +200) টপকে যায়। অর্থাৎ “সমান হলে দূরে যাওয়া” হয়ে গেল “সমান না হলে এই JMP টপকানো”। পুরোনো বা অন্য assembler-এ এমন লাফ error দিতে পারে, আর পরীক্ষায় হাতে লিখলে এই উল্টানো কৌশল নিজেকেই লিখতে হয়।

LOOP পরিবার আর INT

নির্দেশকাজলাফ দেয় যখন
LOOPCX = CX − 1CX ≠ 0
LOOPE = LOOPZCX = CX − 1CX ≠ 0 আর ZF = 1
LOOPNE = LOOPNZCX = CX − 1CX ≠ 0 আর ZF = 0
JCXZকিছু কমায় নাCX = 0; loop-এর আগে শূন্য গোনা আটকাতে

LOOP কোনো flag বদলায় না, আর CX কমানোর পরে পরীক্ষা করে: CX = 0 দিয়ে শুরু করলে প্রথম কমানোতেই FFFFH, অর্থাৎ 65536 বার ঘোরে। cold86.asm-এ CX = 5 দিয়ে loop counter পাঁচটি তাপমাত্রা গুনেছে। LOOP-ও short লাফ, দূরত্ব −128 থেকে +127. INT n, INTO (OF = 1 হলে type 4) আর IRET control transfer-এরই সদস্য, কিন্তু stack-এ FLAGS, CS, IP রাখে; এদের পুরো গল্প পর্ব ২০-এ (8086-এর interrupt — vector table, INT আর ISR) বলা হবে।

৬ · Flag আর processor control — এবং কত clock

নির্দেশকাজকোথায় লাগে
CLC, STC, CMCCF = 0, CF = 1, CF উল্টানোADC/RCL-এর আগে; subroutine থেকে সফল/ব্যর্থ ফেরত দিতে
CLD, STDDF = 0 বা 1string নির্দেশ SI/DI বাড়াবে না কমাবে (পর্ব ১৯)
CLI, STIIF = 0 বা 1INTR interrupt বন্ধ-চালু; NMI আটকায় না
HLTথামা, interrupt বা reset-এর অপেক্ষাlab-এ run শেষ করে (Spec decision 16)
NOPকিছু না (আসলে xchg ax,ax, opcode 90H)সময় নষ্ট বা জায়গা ভরাট
WAIT, ESC, LOCK8087 coprocessor-এর জন্য অপেক্ষা ও তাকে নির্দেশ দেওয়া; bus আটকে রাখাmaximum mode-এর ব্যবস্থা (পর্ব ২১)

শেষ প্রশ্ন: কোন নির্দেশ কত সময় নেয়? কোর্সের lab-এ 8086-এর জন্য কোনো clock গোনা নেই (Spec decision 16), তাই সময়ের সংখ্যা আসে শুধু Intel-এর 8086 manual-এর timing টেবিল থেকে। নিচের মানগুলো register operand-এর, datasheet-এর মান, মাপা নয়; মেমরি operand হলে effective address-এর clock যোগ হয়, আর queue ও wait state-এর কারণে বাস্তব সময় বেশি হতে পারে।

নির্দেশ (register)clock (Intel-এর টেবিল)নির্দেশ (register)clock
ADD reg,reg3XLAT11
MUL r8 / r1670–77 / 118–133IMUL r8 / r1680–98 / 128–154
DIV r8 / r1680–90 / 144–162IDIV r8 / r16101–112 / 165–184
shift, count 12shift, count CL8 + 4 × count
Jcc নেওয়া / না16 / 4LOOP নেওয়া / না17 / 5

একটি DIV r16 তাই প্রায় ৫০টি ADD-এর সমান। 5 MHz clock-এ (এক clock = 0.2 µs) 144–162 clock মানে 28.8–32.4 µs. Smart scale প্রতি 100 ms-এ মাপে, তাই এটুকু সময় কিছুই নয়; কিন্তু একটি দ্রুত interrupt-এর ভেতরে বারবার ভাগ করলে হিসাব বদলে যায়। ২-এর ঘাতে ভাগ হলে shift সস্তা, তবে signed সংখ্যায় SAR আর IDIV-এর ফল আলাদা হতে পারে (অনুশীলন ৩)।

আরও গভীরে: 8086-এর MUL, DIV-এর মতো জটিল নির্দেশ ভেতরে microcode-এ চলে: chip-এর ROM-এ রাখা ছোট ছোট ধাপ, যা shift-আর-যোগ করে গুণ এবং বিয়োগ-আর-shift করে ভাগ সারে। এজন্য clock সংখ্যা একটি পরিসর, কারণ operand-এর বিট অনুযায়ী ধাপ বদলায়। Opcode-এর নকশাতেও এর ছাপ আছে: MUL, IMUL, DIV, IDIV, NOT, NEG, TEST সবাই একই opcode F6H/F7H ভাগ করে, আর ModR/M byte-এর reg ঘর (/4, /5, /6, /7) বলে কোনটি; সত্যিকারের run-এর F6 E3 (mul bl) আর F6 F3 (div bl) দেখুন। এভাবে একটি ঘর opcode-এর কাজ করায় দ্বিতীয় operand লেখার জায়গাই থাকে না, আর AX/DX হয়ে যায় implicit. ModR/M-এর গঠন পর্ব ১৫-এ।

পরীক্ষা ও ইন্টারভিউতে: “MUL bx-এর ফল কোথায়?” → DX:AX, উঁচু word DX-এ। “DIV bl-এর পরে ভাগশেষ কোথায়?” → AH; ভাগফল AL-এ, না আঁটলে type 0. “JB আর JL-এর পার্থক্য” → JB unsigned, CF = 1; JL signed, SF ≠ OF. “LEA আর MOV” → LEA ঠিকানা দেয়, MOV সেই ঠিকানার data. “ROL আর RCL” → ROL ৮ বিটের চাকা, RCL CF-সহ ৯ বিটের। “8086-এ shl ax,4 চলে?” → না, 80186 থেকে; 8086-এ mov cl,4 তারপর shl ax,cl.

৭ · AI-এর যুগে 8086-এর নির্দেশ যাচাই

AI assistant 8086-এর program দ্রুত লিখে দেয়, আর বেশিরভাগ লাইন ঠিকও থাকে। ভুল লুকোয় implicit register, flag আর CPU-র প্রজন্মে। যা প্রায়ই দেখা যায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
shl ax,4, push 5, imul ax,bx,3-এর মতো 186/386-এর নির্দেশ লেখেNASM-এ cpu 8086: “no instruction for this cpu level” (Spec decision 13)
div bl দিয়ে বড় সংখ্যা ভাগ করে, বা div bx-এর আগে DX শূন্য করে নাভাগফল আঁটে কি না হাতে দেখা; runner-এ চালালে divide error ধরা পড়ে
signed ডেটায় JA/JB, unsigned-এ JG/JLপ্রতিটি তুলনার পাশে লিখুন সংখ্যাটি signed না unsigned; ঋণাত্মক মান দিয়ে পরীক্ষা
MUL-এর পরে ZF দেখে লাফ দেয়Intel-এর manual: শুধু CF আর OF নির্ধারিত
8085-এর JC/JM, RAL/RLC বা Z80-এর DJNZ মিশিয়ে ফেলেনির্দেশের নাম Intel-এর 8086 তালিকায় আছে কি না; assemble করে দেখা
clock সংখ্যা নিশ্চিত সুরে বলেIntel-এর টেবিলের সঙ্গে মেলানো; lab-এর ফলকে সময় বলে না ধরা (Spec decision 16)

AI-কে কাজে লাগাতে CPU, assembler আর যাচাইয়ের শর্ত শুরুতেই দিন:

আমি Intel 8086 (80186, 286 বা 386 নয়) শিখছি, NASM syntax-এ, .COM program (org 100h), cpu 8086. ১. smart scale-এর ওজন হিসাব করো: grams = (raw − 400) × 2000 / 1400, raw = 1380. কোন register-এ গুণফল আর ভাগফল থাকবে, প্রতিটি নির্দেশের পরে AX, DX লিখে দেখাও। ২. তাপমাত্রা signed, 0.01 °C এককে (যেমন −150). 0-এর নিচে হলে low, 800-এর ওপরে হলে high. কোন শর্তযুক্ত লাফ দেবে আর কেন, CF/SF/OF দিয়ে ব্যাখ্যা করো। ৩. শুধু 8086-এর নির্দেশ ব্যবহার করবে: shift-এর count 1 বা CL. MUL/DIV-এর পরে কোন flag নির্ধারিত, তা বলবে। ৪. clock সংখ্যা দিলে Intel-এর 8086 manual-এর টেবিল থেকে দাও, না জানলে বলো "নিশ্চিত নই"।

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

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

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

প্র ০১8086-এর ADD যেকোনো দুটি register নেয়, অথচ MUL আর DIV কেন AX আর DX-এ বাঁধা? এই নকশার পেছনে কী ছিল, আর আধুনিক ISA একই সমস্যা কীভাবে সমাধান করে?

প্রথম কারণ ঐতিহ্য। 8080 আর 8085 ছিল accumulator-কেন্দ্রিক: প্রায় সব হিসাব A দিয়ে। 8086-এর নকশাকারীরা চেয়েছিলেন 8080-এর assembly কোড যন্ত্র দিয়ে নতুন chip-এ অনুবাদ করা যাক, তাই A-র উত্তরসূরি হিসেবে AL/AX রাখা হলো, আর যে নির্দেশগুলো নতুন ও জটিল, সেগুলো এই “প্রধান” register-কে কেন্দ্র করেই সাজানো হলো। গুণের ফল operand-এর দ্বিগুণ চওড়া, তাই ফল রাখতে দুটি register লাগে; সবচেয়ে সহজ পছন্দ AX-এর সঙ্গে আরেকটি নির্দিষ্ট register, DX. নামেই তার ছাপ: D মানে data, আর I/O port-এর ঠিকানার জন্যও DX বাঁধা।

দ্বিতীয় কারণ নির্দেশের encoding. 8086-এর নির্দেশে ModR/M নামের একটি byte থাকে, যার একটি ঘর একটি operand বোঝায় আর আরেকটি ঘর দ্বিতীয় register. কিন্তু F6H/F7H opcode-এর নির্দেশগুলোতে সেই দ্বিতীয় ঘরটি opcode-এর বাকি অংশ হিসেবে খরচ হয়েছে: /4 মানে MUL, /6 মানে DIV ইত্যাদি। এই পর্বের সত্যিকারের run-এর F6 E3 (mul bl) আর F6 F3 (div bl) দেখলে বোঝা যায়, একটি বিটের দল বদলে নির্দেশটাই বদলেছে। ফলে নির্দেশে একটির বেশি operand লেখার জায়গা নেই; বাকিটা implicit হতেই হতো। এতে নির্দেশ ছোট হয় (দুই byte), যা ১৯৭৮ সালের দামি মেমরির যুগে গুরুত্বপূর্ণ ছিল।

দাম দিতে হয় programmer আর compiler-কে: গুণের আগে AX-এ মান আনতে হয়, DX-এ দরকারি কিছু থাকলে বাঁচিয়ে রাখতে হয়, আর ভাগের আগে DX শূন্য বা CWD করতে হয়। পরের x86 এই বাঁধন কিছুটা খুলেছে: 80186 তিন operand-এর IMUL (সরাসরি সংখ্যা দিয়ে) আনল, 386 যেকোনো দুটি register-এর IMUL. RISC-V-এর মতো আধুনিক ISA আরও সরল পথে গেছে: mul দেয় নিচের অর্ধেক, mulh আলাদা নির্দেশে উঁচু অর্ধেক, দুটিই যেকোনো register-এ (Computer Architecture পর্ব ২৬)। ARM Cortex-M3-এ UMULL দুই register-এ ৬৪ বিটের ফল দেয়, কোন দুটি তা programmer বলে দেন।

মূল উপলব্ধি: AX/DX-এর বাঁধন 8080-এর accumulator ঐতিহ্য আর ছোট encoding-এর ফল; পরের ISA register বেছে নেওয়ার স্বাধীনতা দিয়ে implicit operand-এর ফাঁদ কমিয়েছে।

প্র ০২CPU-র একটি মাত্র CMP আছে, অথচ লাফ দুই সেট। signed আর unsigned-এর এই ভাগ C ভাষা আর firmware-এর bug-এ কীভাবে ফিরে আসে?

CMP শুধু বিয়োগ করে ছয়টি flag রাখে; সংখ্যার অর্থ সে জানে না। Two's complement-এর সুবিধা হলো একই বিয়োগ দুই অর্থেই সঠিক বিট দেয়, আর flag-গুলো দুই অর্থের তথ্যই ধরে রাখে: CF বলে unsigned অর্থে ধার লেগেছে কি না, আর SF ও OF মিলে বলে signed অর্থে ফল ঋণাত্মক কি না। তাই একটি তুলনা যথেষ্ট, শুধু পড়ার নিয়ম দুটি। 8085-এ OF ছিল না; signed তুলনা করতে programmer-কে চিহ্নের বিট আলাদা করে দেখতে হতো। 8086 এটি hardware-এ দিল, আর দুই সেট নামে (Above/Below বনাম Greater/Less) পার্থক্যটি স্পষ্ট করল।

C ভাষায় এই সিদ্ধান্ত নেয় compiler, variable-এর type দেখে। int তুলনায় সে JL/JG বসায়, unsigned তুলনায় JB/JA. সমস্যা হয় যখন দুটি মিশে যায়। C-র নিয়মে int আর unsigned int তুলনায় signed মানটি unsigned-এ রূপান্তরিত হয়, তাই -1 < 1u মিথ্যা: −1 হয়ে যায় সবচেয়ে বড় unsigned সংখ্যা। compiler তখন সঠিকভাবেই unsigned লাফ বসায়, আর ফল হয় ঠিক এই পর্বের cold86.asm-এর NHHNN-এর মতো: −1.50 °C কে বিশাল সংখ্যা ধরে “গরম” বলা। বেশিরভাগ compiler এর জন্য একটি সতর্কবার্তা দিতে পারে (যেমন signed-unsigned তুলনার warning), যদি চালু করা থাকে।

Firmware-এ এমন bug বিশেষ বিপজ্জনক, কারণ program কোনো error দেখায় না, শুধু সীমার কাছের মানে ভুল করে, আর সাধারণ পরীক্ষায় সেসব মান প্রায়ই আসে না। বাজারঘরের cold room-এ ঠান্ডা কখনো শূন্যের নিচে না নামলে bug মাসের পর মাস লুকিয়ে থাকবে। প্রতিরোধের উপায়: ডেটার type শুরুতেই ঠিক করা (তাপমাত্রা int16_t, দাম uint32_t), সীমার দুই পাশের মান (−1, 0, 799, 800, 801) দিয়ে পরীক্ষা লেখা, আর assembly-তে প্রতিটি Jcc-এর পাশে মন্তব্যে signed না unsigned লেখা। ARM Cortex-M-এ একই ভাগ আছে: BLO/BHI unsigned, BLT/BGT signed (পর্ব ২৯)।

মূল উপলব্ধি: তুলনা একটি, পড়ার নিয়ম দুটি; ডেটার অর্থ জানেন programmer, তাই ভুল সেট বেছে নেওয়া এমন bug, যা চুপচাপ ভুল উত্তর দেয়।

প্র ০৩8086 shift-এর count CL-এর পুরো মান ধরে, অথচ 80286 থেকে Intel count-কে ৫ বিটে কেটে নেয়। কেন এই পরিবর্তন, আর কোর্সের lab-এর Unicorn কেন একই আচরণ করে?

Intel-এর টেবিল অনুযায়ী 8086-এ CL দিয়ে register shift নেয় 8 + 4 × count clock. CL ৮ বিটের, তাই count 255 হলে 8 + 1020 = 1028 clock, 5 MHz-এ প্রায় 206 µs. সমস্যা হলো 8086 একটি shift নির্দেশ মাঝপথে থামিয়ে interrupt নেয় না; interrupt আসে নির্দেশ শেষ হলে (REP-যুক্ত string নির্দেশ এর ব্যতিক্রম, পর্ব ১৯)। তাই একটি অর্থহীন বড় count (১৬ বিটের register-এ ১৬-র বেশি সরানোর ফল তো সবসময় 0) interrupt-এর সাড়া দেওয়ার সময় অকারণে বাড়িয়ে দিতে পারত। Real-time কাজে এমন অনিশ্চিত দেরি অগ্রহণযোগ্য।

Intel-এর পরের manual লিখেছে, 8086 count-কে mask করে না, কিন্তু 80286 থেকে পরের সব IA-32 processor count-কে ৫ বিটে (0–31) কেটে নেয়, যাতে সবচেয়ে খারাপ ক্ষেত্রেও সময় সীমিত থাকে। ৩২ বিটের register-এ ৩১ পর্যন্ত সরানোই যথেষ্ট, তাই ৫ বিট। 80186 আরেকটি উন্নতি আনে: সরাসরি সংখ্যা দিয়ে count (shl ax,4), যা এই পর্বে NASM cpu 8086-এ “no instruction for this cpu level” error দিয়েছে আর --cpu 186-এ C1 E0 04 হয়ে চলেছে।

কোর্সের lab-এ Unicorn একটি 386-শ্রেণির core, যা QEMU থেকে তৈরি; 16-bit real mode-এ চললেও এর ভেতরের নিয়ম 386-এর। তাই CL = 33 দিলে lab একবার সরিয়ে 012CH দিল, যেখানে আসল 8086 ৩৩ বার সরিয়ে 0000H দিত। Reference lab এটি গোপন করেনি: Spec decision 15-এ চারটি পার্থক্য লেখা আছে (PUSH SP, shift count, PUSHF-এর বিট ১২–১৫, divide error-এর ফেরার ঠিকানা), আর একটি test সেগুলো আটকে রাখে। শিক্ষাটি বড়: যেকোনো emulator বা simulator একটি মডেল, আসল silicon নয়। মডেলের সীমা জানা থাকলে তাকে বিশ্বাস করা যায়; না জানলে সে আত্মবিশ্বাসী ভুল দেখায়। Microcontroller firmware-এর ক্ষেত্রেও একই কথা: host-এ চলা test আর simulator যা দেখায়, chip-এর datasheet-এ তা মিলিয়ে নিতে হয় (পর্ব ৬৪)।

মূল উপলব্ধি: count-এর mask interrupt-এর দেরি সীমিত রাখার নকশা; আর lab-এর পার্থক্য মনে করিয়ে দেয়, simulator-এর ফল তার লেখা সীমার ভেতরেই সত্য।

প্র ০৪DAA, AAA, AAM-এর মতো দশমিক adjust নির্দেশ কেন রাখা হয়েছিল, আর আজকের 64 বিটের x86-এ এদের কী হয়েছে?

১৯৭০-এর দশকে microprocessor-এর বড় বাজার ছিল ক্যালকুলেটর, ক্যাশ রেজিস্টার, দাঁড়িপাল্লা আর ব্যবসার হিসাবের যন্ত্র। এসব যন্ত্রে সংখ্যা ঢোকে keypad থেকে দশমিক অঙ্কে, বের হয় seven-segment display-এ দশমিক অঙ্কে। প্রতিবার binary-তে রূপান্তর আর ফেরত আনা মানে ভাগের loop, যা 8080-এর মতো chip-এ ধীর। BCD-তে সরাসরি হিসাব করলে রূপান্তরই লাগে না, শুধু প্রতিটি যোগের পরে একটি সংশোধন। তাই 8080-এ DAA ছিল, আর 8086 সেটি রেখে ASCII অঙ্কের জন্য AAA, AAS, AAM, AAD যোগ করল, যাতে keyboard থেকে আসা '7' আর '5' সরাসরি যোগ করা যায়। Reference lab-এর bcd.asm ঠিক এটিই করে ছাপে 12. টাকার হিসাবের মতো জায়গায় দশমিক হিসাব binary-র ভগ্নাংশের গোলমালও এড়ায়।

সময়ের সঙ্গে ছবিটি বদলাল। CPU দ্রুত হলো, ভাগ hardware-এ এল, আর compiler binary-তে হিসাব করে শেষে একবার দশমিকে রূপান্তর করাই সহজ মনে করল। C-র মতো ভাষায় BCD-র কোনো type নেই, তাই compiler এই নির্দেশগুলো প্রায় কখনো বসায় না। Intel-এর 64 বিটের ISA-তে, 64-bit mode-এ, ছয়টি নির্দেশই (DAA, DAS, AAA, AAS, AAM, AAD) অবৈধ ঘোষিত হয়েছে, আর তাদের opcode অন্য কাজে খালি রাখা হয়েছে। পুরোনো 16 আর 32 বিটের mode-এ এরা এখনো চলে, সামঞ্জস্যের জন্য।

এমবেডেড জগতে প্রশ্নটি এখনো জীবিত, অন্য রূপে। বাজারঘরের smart scale-এর দাম firmware-এ পয়সায় একটি পূর্ণসংখ্যা (যেমন 8188), আর display-এ দেখাতে ভাগ করে অঙ্ক বের করতে হয়, তারপর প্রতিটি অঙ্কের seven-segment নকশা একটি lookup table থেকে আনতে হয়, যেমন এই পর্বের XLAT. Cortex-M0-এর মতো যে core-এ ভাগের নির্দেশ নেই, সেখানে প্রতি অঙ্কে ১০ দিয়ে ভাগ দামি, তাই কেউ কেউ “double dabble” নামের shift-আর-যোগের পদ্ধতিতে binary থেকে BCD বানান। আর RTC (real-time clock) chip-গুলো অনেক সময় সময়-তারিখ BCD-তেই রাখে, তাই firmware-এ BCD পড়ার দক্ষতা আজও লাগে।

মূল উপলব্ধি: দশমিক adjust নির্দেশ ছিল ক্যালকুলেটর-যুগের ধীর CPU-র শর্টকাট; দ্রুত binary হিসাব আর compiler-এর যুগে তা অপ্রয়োজনীয় হয়ে 64-bit mode থেকে বাদ পড়েছে, কিন্তু BCD ডেটা পড়া-লেখা এমবেডেড কাজে রয়ে গেছে।

প্র ০৫8086-এ একটি DIV r16 প্রায় ৫০টি ADD-এর সময় নেয়। আজকের microcontroller-এ ভাগ কতটা দামি, আর firmware লেখার সময় এটি কীভাবে নকশা বদলায়?

Intel-এর টেবিলে ADD reg,reg 3 clock, DIV r16 144–162 clock. কারণ ভাগ মূলত বিয়োগ-আর-shift-এর ধারাবাহিক কাজ, প্রতিটি ভাগফলের বিটের জন্য একটি ধাপ, আর 8086 সেটি microcode-এ একে একে চালায়। গুণও কম নয়, 118–133 clock. তাই সেই যুগের programmer-রা ২-এর ঘাতে গুণ-ভাগ shift দিয়ে করতেন, ছোট ধ্রুবকে গুণ shift আর যোগ মিলিয়ে (x × 10 = x × 8 + x × 2), আর সম্ভব হলে ভাগ এড়াতে হিসাব নতুন করে সাজাতেন।

আধুনিক microcontroller-এ ছবি নির্ভর করে core-এর ওপর। ARM-এর Cortex-M3 আর M4-এ hardware-এ UDIV আর SDIV আছে; ARM-এর Technical Reference Manual অনুযায়ী এদের সময় operand অনুযায়ী মোটামুটি 2 থেকে 12 cycle, কারণ ভাগফল ছোট হলে আগেই থামে। কিন্তু Cortex-M0 আর M0+ (ARMv6-M) core-এ ভাগের নির্দেশই নেই; সেখানে compiler একটি library function ডাকে, যা কয়েক ডজন থেকে শতাধিক cycle নিতে পারে। অনেক ৮ বিটের microcontroller-এও ভাগের hardware নেই। তাই কোন chip-এ firmware চলবে, তা না জেনে “ভাগ সস্তা” ধরে নেওয়া বিপজ্জনক।

Firmware-এর নকশায় এর প্রভাব স্পষ্ট। বাজারঘরের smart scale চারটি ADC মানের গড় নেয় (sum + 2) ÷ 4 সূত্রে: ভাজক 4 বেছে নেওয়া হয়েছে কারণ ÷ 4 মানে দুবার ডানে shift, প্রায় বিনা খরচে। ধ্রুবক দিয়ে ভাগ (যেমন ÷ 1400) compiler প্রায়ই “reciprocal দিয়ে গুণ আর shift”-এ বদলে দেয়, যা নিজের চোখে দেখা যায় compiler-এর assembly পড়ে (Compilers কোর্সের পর্ব ৭২-এ এমন কৌশলের আলোচনা)। আর সতর্কতা: signed সংখ্যায় shift আর ভাগ এক নয়। এই পর্বের অনুশীলন ৩-এ −7 ÷ 2 IDIV-এ −3, কিন্তু SAR-এ −4. ঋণাত্মক তাপমাত্রার গড় নিতে shift ব্যবহার করলে এই এক ঘরের পার্থক্য alarm-এর সীমায় ভুল আনতে পারে। নিয়ম: আগে সঠিক কোড, তারপর মেপে দেখা ভাগটি সত্যিই সময়ের বোঝা কি না।

মূল উপলব্ধি: ভাগ চিরকাল গুণ-যোগের চেয়ে দামি, আর কিছু core-এ hardware-ই নেই; firmware তাই ভাজক বেছে নেয় ২-এর ঘাতে, ধ্রুবক ভাগ compiler-কে দেয়, আর signed shift-এর ফাঁদ মনে রাখে।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — cold room-এর status subroutine: একটি NASM subroutine status লিখুন: AX-এ 0.01 °C এককে signed তাপমাত্রা; ফেরার সময় BL = 2 যদি তাপমাত্রা 8.00 °C-এর বেশি, 1 যদি 0.00 °C-এর কম, নইলে 0. চারটি মান 801, 800, 0, −1 দিয়ে পরীক্ষা করে অঙ্কগুলো ছাপুন। কোন লাফ ব্যবহার করবেন আর কেন?
    status: mov bl, 0           ; in: AX = temp in 0.01 degC
            cmp ax, 800
            jg st_hi            ; signed: above 8.00 degC
            cmp ax, 0
            jge st_ret          ; signed: 0.00 degC or more
            mov bl, 1
            ret
    st_hi:  mov bl, 2
    st_ret: ret

    তাপমাত্রা ঋণাত্মক হতে পারে, তাই signed লাফ JG আর JGE. পরীক্ষার loop (mov ax,[si], call status, add dl,'0', INT 21h AH = 02h, LOOP) সহ সত্যিকারের run ছাপে 2001: 801 → 2, ঠিক 800 → 0 (বেশি নয়), 0 → 0 (কম নয়), −1 → 1; ৬০টি নির্দেশ। সীমার ঠিক দুই পাশের মান দিয়েই পরীক্ষা করা হয়েছে, কারণ ভুল সাধারণত সেখানেই লুকোয়। jge-এর বদলে jae লিখলে −1 (FFFFH) “শূন্যের সমান বা বেশি” হয়ে যেত, আর শেষ অঙ্ক 1-এর বদলে 0.

  2. ভুল খুঁজুন — গড় করতে গিয়ে divide error: চারটি ADC মানের যোগফল 5520, README-র সূত্র (sum + 2) ÷ 4. কোড: mov ax,5520, add ax,2, mov bl,4, div bl. Runner থামে “divide error (INT 0)” বলে। ভুলটি কী, আর দুটি ঠিক সমাধান লিখুন।

    div bl ৮ বিটের ভাগ: AX ÷ BL, ভাগফল যায় AL-এ, যার সীমা 255. 5522 ÷ 4 = 1380 আঁটে না, তাই type 0. ভাজক ছোট হওয়া যথেষ্ট নয়, ভাগফল আঁটতে হবে। সমাধান ১ — ১৬ বিটের ভাগ: xor dx,dx, mov bx,4, div bx. সত্যিকারের run: AX=0564 (1380), DX=0002 (ভাগশেষ 2), ৬টি নির্দেশ। xor dx,dx না দিলে DX-এর আগের আবর্জনা ভাজ্যের উঁচু word হয়ে যেত। সমাধান ২ — ÷ 4 মানে দুবার ডানে shift: 8086-এ mov cl,2 তারপর shr ax,cl (shr ax,2 80186-এর নির্দেশ)। যোগফল unsigned, তাই SHR নিরাপদ।

  3. আগে বলুন, তারপর চালান — IDIV বনাম SAR: mov ax,-7, cwd, mov bx,2, idiv bx; তারপর mov ax,-7, sar ax,1. IDIV-এর পরে AX আর DX কত? SAR-এর পরে AX আর CF কত? দুটি “÷ 2” কেন আলাদা?

    CWD: AX = FFF9H ঋণাত্মক, তাই DX = FFFFH. IDIV শূন্যের দিকে কাটে: −7 ÷ 2 = −3, ভাগশেষ −1 (ভাজ্যের চিহ্ন): AX = FFFDH, DX = FFFFH. SAR নিচের দিকে কাটে (floor): FFF9H = 1111 1111 1111 1001b, ডানে সরিয়ে বাঁয়ে 1 ঢোকালে FFFCH = −4, আর বেরোনো বিট 1 যায় CF-এ, CF = 1. সত্যিকারের run: idiv bx → AX=FFFD DX=FFFF; sar ax,1 → AX=FFFC, ছাপ --I-S--PC; ৭টি নির্দেশ। ধনাত্মক সংখ্যায় দুটি একই, ঋণাত্মক বিজোড় সংখ্যায় এক ঘর পার্থক্য।

  4. হিসাব — গুণ-ভাগের register: (ক) AX = 1234H, BX = 0100H, mul bx-এর পরে DX আর AX? (খ) DX = 0001H, AX = 86A0H, CX = 1000, div cx-এর পরে AX আর DX? (গ) AL = 80H, BL = 02H, imul bl-এর পরে AX, CF আর OF? (ঘ) Intel-এর টেবিলে MUL r16 118–133 clock হলে 5 MHz-এ কত µs?

    (ক) 1234H × 0100H = 123400H (× 100H মানে hex-এ দুই অঙ্ক বাঁয়ে): DX = 0012H, AX = 3400H; DX শূন্য নয়, CF = OF = 1. (খ) DX:AX = 000186A0H = 100000; 100000 ÷ 1000 = 100, ভাগশেষ 0: AX = 0064H, DX = 0000H. (গ) −128 × 2 = −256 = FF00H; AL = 00H একা −256 বোঝায় না, তাই CF = OF = 1. তিনটিই সত্যিকারের run-এ এক program-এ: DX=0012 AX=3400, তারপর AX=0064 DX=0000, তারপর AX=FF00 ছাপ O-I--Z-PC (Z এখানে অনির্ধারিত flag, অর্থহীন)। (ঘ) 5 MHz-এ এক clock = 1 ÷ 5000000 s = 0.2 µs; 118 × 0.2 = 23.6 µs থেকে 133 × 0.2 = 26.6 µs. এটি datasheet-এর মান থেকে হিসাব, lab-এ মাপা নয় (Spec decision 16).

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

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

ক্রম8086-এ ১৬ বিটের একটি unsigned সংখ্যাকে আরেকটি ১৬ বিটের সংখ্যা দিয়ে ভাগ করার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. ভাজ্য AX-এ আনা
  2. xor dx,dx দিয়ে DX শূন্য করা, যাতে DX:AX = ভাজ্য
  3. ভাজক একটি register-এ (যেমন CX) আনা
  4. div cx চালানো
  5. ভাগফল AX থেকে আর ভাগশেষ DX থেকে নেওয়া

8086-এ AL = FEH, BL = 03H. imul bl-এর পরে AX কত?

  • 02FAH
  • FFFAH
  • AH আগের মতো, AL = FAH
  • DX:AX = FFFF:FFFAH

AX = 03E8H (1000), BL = 07H. 8086-এ div bl-এর পরে AX কত?

  • AX = 8E06H
  • AX = 008EH
  • AX = 068EH
  • divide error, কারণ ভাগফল আঁটে না

AX-এ signed তাপমাত্রা −150 (FF6AH). cmp ax,0-এর পরে কোন লাফ নেওয়া হবে?

  • শুধু JB
  • JB আর JL দুটিই
  • JE
  • শুধু JL

AL = 81H, CF = 0. 8086-এ rcl al,1-এর পরে AL আর CF কত?

  • AL = 02H, CF = 1
  • AL = 03H, CF = 1
  • AL = C0H, CF = 1
  • AL = 02H, CF = 0

BX = 0119H. 8086-এ lea si,[bx+4] আর mov di,[bx+4]-এর পার্থক্য কী?

  • দুটিই মেমরি থেকে একই word পড়ে
  • SI পায় ঠিকানা 011DH, DI পায় সেই ঠিকানার data
  • LEA ২০ বিটের physical address দেয়
  • SI পায় data, DI পায় ঠিকানা

নিচের কোন লাইন NASM cpu 8086-এ assemble হয় না?

  • mov ds, ax
  • shl ax, cl
  • mov [bx], [si]
  • xchg ax, bx

শব্দকোষ

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

মনে রাখুন

  1. ছয় দল: data transfer (flag ছোঁয় না), arithmetic, logic-shift-rotate, string, control transfer, flag/processor control.
  2. MOV-এর নিষেধ: মেমরি → মেমরি নেই, segment register-এ সরাসরি সংখ্যা নেই, CS-এ MOV নেই। XLAT = [DS:BX + AL]; LEA ঠিকানা, MOV data.
  3. গুণ-ভাগ: r/m8: AX = AL × src, AX ÷ src → AL ভাগফল, AH ভাগশেষ; r/m16: DX:AX. ভাগফল না আঁটলে type 0; গুণের পরে শুধু CF, OF নির্ধারিত।
  4. Shift/rotate: count 1 বা CL; rotate শুধু CF, OF বদলায়; RCL/RCR CF-সহ চাকা; SAR নিচের দিকে কাটে, IDIV শূন্যের দিকে।
  5. লাফ: unsigned JA/JB (CF, ZF), signed JG/JL (SF, OF, ZF); Jcc আর LOOP শুধু short; near CALL IP রাখে, far CALL CS আর IP.

পরের পর্বে: পর্ব ১৭ (8086 assembly program — NASM, flag আর loop দিয়ে আসল কোড). এই পর্বের নির্দেশ জুড়ে পুরো program: array-এর যোগ, সবচেয়ে বড় সংখ্যা, factorial, string-এর দৈর্ঘ্য আর বাজারঘরের অর্ডারের মোট দাম, NASM আর MASM পাশাপাশি।

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

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