Link asm in another language

CHƯƠNG 1: MӢ ĐҪU ............................................................................................................................. 3
1.1. NHҳC LҥI CÁC HӋ ĐӃM ......................................................................................................................... 3
1.1.1. Các h͏ đ͇m ............................................................................................................................... 3
1.1.2. Chuy͋n đ͝i s͙ giͷa các h͏ đ͇m ................................................................................................. 3
1.2. VI Xӱ LÝ 8086, TұP LӋNH VÀ CÁC MODE ĐӏA CHӍ .................................................................................. 6
1.2.1. Vi x͵ lý 8086 ............................................................................................................................ 6
1.2.2. Các thanh ghi và mode đ͓a ch͑ trong 8086 ................................................................................ 7
1.2.3. Các mode đ͓a ch͑ cͯa 8086 ..................................................................................................... 10
1.3. NGҳT .............................................................................................................................................. 14
1.4. GIӟI THIӋU VӅ HӧP NGӳ ..................................................................................................................... 16
1.4.1. L̵p trình b̹ng hͫp ngͷ .......................................................................................................... 16
1.4.2. Các bưͣc vi͇t chương trình hͫp ngͷ ....................................................................................... 17
1.4.3. C̭u trúc m͡t chương trình hͫp ngͷ d̩ng segment đơn gi̫n .................................................... 19
1.4.4. C̭u trúc cͯa m͡t chương trình segment d̩ng chu̱n ............................................................... 24
CHƯƠNG 2. LұP TRÌNH VӟI DEBUG ................................................................................................. 30
2.1. TәNG QUAN VӅ DEBUG .................................................................................................................... 30
2.1.1. Đ̿c đi͋m cͯa Debug............................................................................................................... 30
2.1.2. Khͧi đ͡ng và thoát kh͗i Debug ............................................................................................... 30
2.2. CÁC LӋNH CӫA DEBUG ..................................................................................................................... 30
2.2.1. Nhóm các l͏nh biên so̩n chương trình.................................................................................... 30
2.2.2. Nhóm các l͏nh d͓ch chuy͋n dͷ li͏u ......................................................................................... 32
2.2.3. Nhóm l͏nh quan sát ................................................................................................................ 34
2.2.4. Nhóm l͏nh thi hành chương trình ............................................................................................ 34
CHƯƠNG 3: CÁC LӋNH CӫA ASSEMBLY ......................................................................................... 36
3.1 CÁC LӋNH VұN CHUYӇN Dӳ LIӋU ......................................................................................................... 36
3.2 CAC LӋNH Sӕ HӑC .............................................................................................................................. 39
3.3 CAC LӋNH THAO TAC MӭC BIT ........................................................................................................... 43
3.4 CAC LӋNH THAO TAC VӟI DÃY (CHUӛI) ............................................................................................... 46
3.5 CAC LӋNH NHҧY ± CHUYӇN DIӅU KHIӇN .............................................................................................. 48
3.6 CAC LӋNH THAO TAC VӟI Cӡ VA DIӅU KHIӇN Bӝ.................................................................................... 50
CHƯƠNG 4 CHƯƠNG TRINH CON VA CHƯƠNG TRINH DA TӋP ................................................ 52
4.1 THӫ TөC ± CHƯƠNG TRINH CON ......................................................................................................... 52
4.1.1 Cơ ch͇ làm vi͏c cͯa chương trình con...................................................................................... 52
4.1.2 C̭u trúc cͯa chương trình con ................................................................................................. 52
4.1.3 V̭n đ͉ chuy͋n giao tham s͙ ..................................................................................................... 53
4.1.4 V̭n đ͉ b̫o v͏ các thanh ghi .................................................................................................... 54
4.1.5. M͡t s͙ ví dͭ ............................................................................................................................ 54
4.2 CHƯƠNG TRÌNH ĐA TӋP ..................................................................................................................... 58
4.2.1 L͏nh đi͉u khi͋n PUBLIC ......................................................................................................... 58
4.2.2 L͏nh đi͉u khi͋n EXTERN......................................................................................................... 59
4.2.3 L͏nh đi͉u khi͋n GLOBAL ....................................................................................................... 59
4.2.4. T͏p INCLUDE và cách dùng................................................................................................... 62
4.2.5 MACRO và v̭n đ͉ liên quan .................................................................................................... 65
4.2.5.1. Chͱc năng ........................................................................................................................... 65
CHƯƠNG 5: CÁC THAO TÁC VӟI TӋP ............................................................................................... 70
5.1 THҿ FILE (F ILE HANDLES) ................................................................................................................ 70
5.1.1 Kh͙i đi͉u khi͋n file ± FCB (File Control Blocks)...................................................................... 70
5.1.2 Th̓ file .................................................................................................................................... 70
5.2. CAC DӏCH Vө DUNG THҿ FILE CӫA DOS VA CAC MÃ LӛI ...................................................................... 71
5.2.1. Các d͓ch vͭ dùng th̓ file cͯa DOS .......................................................................................... 71
5.2.2 Các mã l͟i tr̫ v͉ ..................................................................................................................... 82
CHƯƠNG 6 LIÊN KӃT GIӳA NGÔN NGӳ ASSEMBLY VӟI CÁC NGÔN NGӳ BұC CAO .............. 84
6.1 Mӣ ĐҫU ............................................................................................................................................ 84
6.2. LIÊN KӃT ASSEMBLY VӟI NGÔN NGӳ C............................................................................................... 84

1

6.2.1. Inline assembly trong C .......................................................................................................... 84
6.2.2. Vi͇t tách bi͏t nhi͉u module trong C ........................................................................................ 85
Khai báo cͯa ASM: Gi͙ng như đa t͏p thu̯n tuý .................................... Error! Bookmark not defined.
VҩN ĐӅ 2 ...................................................................................... ERROR! BOOKMARK NOT DEFINED.
6.3 LIÊN KӃT ASSEMBLY VӟI NGÔN NGӳ PASCAL....................................................................................... 87
6.3.1. Inline assembly trong Pascal................................................................................................... 87
6.3.2. Inline assembly trong Pascal................................................................................................... 88

2

Chương 1: MӢ ĐҪU

1.1. Nhҳc lҥi các hӋ đӃm

1.1.1. Các hӋ đӃm
Trong cuӝc sӕng hàng ngày chúng ta thưӡng dùng hӋ cơ sӕ 10 ± hӋ đӃm
đưӧc hình thành tӯ 10 kí sӕ tӯ 0 đӃn 9 - đӇ biӇu diӉn các giá trӏ sӕ. ĐiӅu này rҩt
tӵ nhiên vì tӯ xa xưa con ngưӡi bình thưӡng đã biӃt dùng 10 ngón tay cӫa mình
đӇ như là mӝt công cө tính toán sơ đҷng.
Trong thӃ giӟi máy tính thì khác, do máy tính đưӧc cҩu tҥo nên tӯ các mҥch
điӋn tӱ và các mҥch này chӍ có hai trҥng thái có điӋn và không có điӋn. Do đó đӇ
biӉu diӉn mӝt giá trӏ sӕ trong máy tính ngưӡi ta sӱ dөng hӋ đӃm cơ sӕ hai hay hӋ
đӃm nhӏ phân (Binary number system). Trong hӋ đӃm này chӍ tӗn tҥi hai chӳ sӕ 0
và 1 tương ӭng vӟi hai trҥng thái có điӋn và không có điӋn cӫa các mҥch điӋn tӱ.
NӃu dùng hӋ cơ sӕ hai đӇ biӇu diӉn các sӕ có giá trӏ lӟn sӁ gһp bҩt tiӋn là sӕ
hӋ hai thu đưӧc quá dài, thí dө: 255 = 1111 1111
ĐӇ viӃt kӃt quҧ biӉu diӉn các sӕ cho gӑn lҥi ngưӡi ta sӱ dөng các các hӋ
đӃm khác như hӋ cơ sӕ 8(bát phân) và hӋ cơ sӕ 16 (thұp lөc, hexa). Bҧng sau đây
trình bày mӝt sӕ hӋ đӃm cơ bҧn:
HӋ đӃm Cơ sӕ Sӕ kí sӕ và kí tӵ Dҥng kí sӕ và kí tӵ
Nhӏ phân (Binary) 2 2 0,1
Bát phân (Octal) 8 8 0,1,2,3,4,5,6,7
Thұp phân (Decimal) 10 10 0,1,2,3,4,5,6,7,8,9
Thұp lөc phân 16 16 0,1,2,3,4,5,6,7,8,9,
(Hexadecimal) A,B,C,D,E,F
Bҧng 1.1. Các hӋ đӃm cơ bҧn
Ngoài ra, hӋ đӃm BCD còn đưӧc sӱ dөng đӇ biӇu diӉn các sӕ tӯ 0 đӃn 9 vӟi
4 bit (4 bit=1 nibble) nhӏ phân.

1.1.2. ChuyӇn đәi sӕ giӳa các hӋ đӃm
1.1.2.1. ChuyӇn đәi giӳa hӋ thұp phân và hӋ nhӏ phân
a. ChuyӇn tӯ hӋ thұp phân sang hӋ nhӏ phân
Quy tҳc: Lҩy phҫn nguyên chia cho 2 và ghi lҥi phҫn dư, tiӃp tөc lҩy
thương chia cho 2 và ghi lҥi phҫn dư. Lһp lҥi quá trình cho đӃn khi thương bҵng
0. Sau đó viӃt các sӕ dư theo chiӅu tӯ phép chia cuӕi cùng đӃn phép chia đҫu
tiên.

3

Thí dө:

(33)10 = (100001)2

33 2

1 16 2
0 8 2
0 4 2
0 2 2

0 1 2
1 0

Hình 1.1. Cách đәi mӝt sӕ hӋ mưӡi sang hӋ hai
Quy tҳc đәi sӕ thұp phân hӋ mưӡi sang hӋ hai: Lҩy sӕ cҫn đәi nhân vӟi 2,
tích gӗm phҫn nguyên và phҫn lҿ. Lҩy phҫn lҿ nhân tiӃp vӟi 2 cho đӃn khi nào
tích thu đưӧc bҵng 1 thì dӯng lҥi. Chӑn riêng phҫn nguyên cӫa các tích thu đưӧc
và viӃt theo thӭ tӵ tӯ phép nhân đҫu tiên đӃn phép nhân cuӕi cùng. Thí dө:

(0,125)10 = (0,001)2

0,125 x 2 = 0 ,250
0,250 x 2 = 0 ,50
0,50 x 2 = 1 ,0

Hình 1.2. Các đәi mӝt sӕ thұp phân hӋ mưӡi sang hӋ hai
b. ChuyӇn tӯ hӋ nhӏ phân sang hӋ thұp phân:
ĐӇ chuyӇn tӯ hӋ nhӏ phân sang thұp phân ta tính tәng các tích sӕ giӳa các
hӋ sӕ vӟi các trӑng sӕ 2i tҥi tӯng vӏ trí thӭ i.
Thí dө:
(1110,11)2 = 1.23 + 1.22 + 1.21 + 0.20 + 1.2-1 + 1.2-2
= 8 + 4 + 2 + 0,5 + 0,25 = (14,75)10
1.1.2.2. ChuyӇn đәi giӳa thұp lөc hoһc hӋ bát phân sang hӋ nhӏ phân

4

Quy tҳc: Nhóm 4 bit (hoһc 3 bit cho hӋ bát phân) bҳt đҫu tӯ bit ngoài cùng
bên phҧi, tính giá trӏ sӕ hӑc theo quy luұt giá trӏ riêng cho tӯng nhóm. ViӃt các
giá trӏ này liên tiӃp nhau.
Thí dө:
Cho sӕ nhӏ phân: 11110101 chuyӇn sang hӋ thұp lөc và hӋ bát phân như sau:
(11 110 101) 3 6 5 trong hӋ bát phân là sӕ 365
(1111 0101) 15 5 F5 trong hӋ thұp lөc là sӕ F5
Khi cҫn chuyӇn ngưӧc lҥi làm tương tӵ. Thí dө:
(120)8 = (001 010 000) 2
(120)16 = (0001 0010 0000)2
1.3. Các phép toán bit
1.3.1. Phép toán AND
Kí hiӋu: &
Ý nghĩa: Nhân logic trên các bit. Phép toán này thӵc hiӋn trên tӯng cһp bit
tương ӭng cӫa các toán hҥng theo quy tҳc trong bҧng sau:
A B A&B
0 0 0
0 1 0
1 0 0
1 1 1
Bҧng 1.3. Bҧng chân lý phép toán AND trên bit
1.1.3. Các phép toán logic
1.1.3.1. Phép toán OR
Kí hiӋu: |
Ý nghĩa: Cӝng logic trên các bit. Phép toán này thӵc hiӋn trên tӯng cһp bit
tương ӭng cӫa các toán hҥng theo quy tҳc trong bҧng sau:
A B A|B
0 0 0
0 1 1
1 0 1
1 1 1
Bҧng 1.4. Bҧng chân lý phép toán OR trên bit
1.1.3.2. Phép toán XOR
Kí hiӋu: ^

5

Ý nghĩa: Phép cӝng logic trên các bit. Thӵc hiӋn trên tӯng cһp bit tương
ӭng cӫa các toán hҥng theo quy tҳc trong bҧng sau.
A B A^B
0 0 0
0 1 1
1 0 1
1 1 0
Bҧng 1.5. Bҧng chân lý phép toán XOR trên bit
1.1.3.3. Phép toán NOT
Kí hiêu: ~
Ý nghĩa: phép đҧo bit, đәi các giá trӏ trong mӛi bit cӫa toán hҥng x tӯ 0->1,
1->0.
1.1.3.4. Phép toán dӏch trái/phҧi
- x SHR i: Phép dӏch phҧi, cho giá trӏ có đưӧc tӯ sӕ nguyên x sau khi dӏch
sang phҧi i bit; các sӕ 0 sӁ lҩp đҫy các kӃt quҧ bên trái nӃu là sӕ nguyên dương;
nӃu không phҧi là sӕ nguyên dương thì sӕ 1 sӁ lҩp đҫy các kӃt quҧ bên trái.
Thí dө:
5 >> 2 = 1 ( 0101 >> 2 = 0001)
- x SHL i: Phép dӏch trái, cho giá trӏ có đưӧc tӯ sӕ nguyên x sau khi dӏch
sang trái i bit; các sӕ 0 sӁ lҩp đҫy các kӃt quҧ ӣ bên phҧi.
5 << 2 = 20

1.2. Vi xӱ lý 8086, tұp lӋnh và các mode đӏa chӍ

1.2.1. Vi xӱ lý 8086
Vi xӱ lý (VXL) làm nhiӋm vө cӫa bӝ xӱ lý trung tâm CPU nên thưӡng
đươc gӑi là CPU và đưӧc đһt ӣ trung tâm bҧn mҥch chính. VXL đưӧc chӃ tҥo
trên cơ sӣ công nghӋ chӃ tҥo các mҥch vi điӋn tӱ tích hӧp rҩt lӟn vӟi các phҫn tӱ
cơ bҧn là các Transistor.
Các máy tính IBM tương thích vӟi VXL cӫa hãng Intel nên ta sӁ đi tìm hiӇu
vӅ VXL cӫa intel. Hӑ VXL cӫa Intel 80x86 vӟi x là 1,2,3,4, đӃn sӕ 5 thì đәi
thành Pentium. Ngoài ra còn có các VXL cӫa các hãng khác.
80x86 là VXL 16 bit, tӭc là nó có bus dӳ liӋu 16 bit. Do vұy nó có khҧ năng
truy xuҩt dӳ liӋu 2 byte mӝt lҫn. bus đӏa chӍ có đӝ rӝng 20 bit. Tӭc là nó có khҧ
năng xác đӏnh đӏa chӍ cӫa 220 ô nhӟ = 1MB đӏa chӍ byte nhӟ vұt lý.

6

VӅ mһt cҩu trúc, CPU hay VXL có hai phҫn chӭc năng đӝc lұp đó là BIU
và EU:
BIU là đơn vӏ ghép nӕi, nó thӵc hiӋn tҩt cҧ các công viӋc vӅ BUS cho EU.
Nó thiӃt lұp khâu nӕi vӟi thӃ giӟi bên ngoài là các Bus đӏa chӍ, sӕ liӋu và điӅu
khiӇn. BIU bao gӗm các thanh ghi đoҥn nhӟ, thanh ghi con trӓ lӋnh và bӝ điӅu
khiӇn logic Bus.
EU là đơn vӏ thi hành lӋnh, EU gӗm hai khӕi: khӕi tính toán sӕ hӑc và logic
ALU và khӕi điӅu khiӇn CU. EU có trách nhiӋm xӱ lý dӳ liӋu, nó duy trì trҥng
thái cӫa VXL, kiӇm soát các thanh ghi đa năng và toán hҥng lӋnh. EU gӗm các
thanh ghi đa năng, thanh ghi cӡ.
Khi VXL hoҥt đӝng, dӳ liӋu đưӧc truyӅn giӳa VXL và thiӃt bӏ vào ra khi
có yêu cҫu cӫa EU. Chúng không đưӧc truyӅn trӵc tiӃp tӟi EU mà phҧi qua mӝt
vùng nhӟ RAM có dung lưӧng nhӓ hơn 6 byte gӑi là hàng nhұp lӋnh trưӟc PQ.
Rӗi sau đó mӟi đưӧc truyӅn vào đơn vӏ lӋnh IU. TiӃp đó IU sӁ điӅu khiӇn EU đӇ
cho lӋnh đưӧc thӵc hiӋn bӣi ALU.
Mӝt chu kì lӋnh cӫa 8086 có thӇ coi đơn giҧn gӗm hai thӡi khoҧng: lҩy lӋnh
tӯ bӝ nhӟ và thӵc hiӋn lӋnh. Khi EU đang thӵc hiӋn lӋnh trưӟc thì BIU đã tìm và
lҩy lӋnh tiӃp theo tӯ bӝ nhӟ, giҧi mã nó và nҥp vào PQ vào, khiӃn cho thӡi gian
lҩy lӋnh cӫa 8086 có thӇ coi là bҵng 0. Sau này chúng ta biӃt đӃn cơ chӃ này
trong các VXL vӅ sau cӫa Intel đó là cơ chӃ đưӡng ӕng.

1.2.2. Các thanh ghi và mode đӏa chӍ trong 8086
Thanh ghi là mӝt bӝ nhӟ dҥng RAM đưӧc tích hӧp ngay trong VXL. Vì tӕc
đӝ truy cұp các thanh ghi nhanh hơn RAM, nên thanh ghi đưӧc dùng đӇ lưu trӳ
các dӳ liӋu tҥm thӡi cho quá trình xӱ lý và tính toán bên trong máy tính.

1.2.2.1. Cách đӏnh đӏa chӍ byte nhӟ trong 8086
Bus đӏa chӍ cӫa 8086 có 20 bit, đӏnh đӏa chӍ cho 1 MB bӝ nhӟ, trong khi đó
các thanh ghi trong 8086 đӅu có đӝ rӝng là 16 bit, nên phҧi có cơ chӃ đӇ đánh đӏa
chӍ logic và vұt lý cho không gian nhӟ 1MB. Cách đánh đӏa chӍ như sau:
Chương trình sӁ chia không gian nhӟ vұt lý thành các đoҥn nhӟ logic, vӟi
kích thưӟc 64Kbyte mӛi đoҥn, các byte trong đoҥn là liên tiӃp nhau. Mӛi đoҥn
nhӟ đưӧc chương trình gҳn cho mӝt đӏa chӍ đoҥn, đó là đӏa chӍ byte nhӟ thҩp
nhҩt trong đoҥn nhӟ. Hai đoҥn nhӟ liӅn kӅ nhau nhҩt thiӃt phҧi cách nhau 16
byte, do đó các đoҥn có đӏa chӍ là bӝi sӕ 16 cӫa nhau. Như vұy chương trình có
thӇ chӭa các đoҥn tách rӡi, phӫ lҩp hoһc chӗng lên nhau. Bên trong đoҥn có đӏa

7

chӍ offset đӇ chӍ khoҧng cách tӯ đӏa chӍ thҩp nhҩt trong đoҥn tӟi ô nhӟ đó. Giá trӏ
offset cho phép xác đӏnh chính xác đӏa chӍ logic cӫa byte nhӟ trong đoҥn đó.
Như vұy, mӝt byte nhӟ đưӧc đӏnh đӏa chӍ logic bӣi mӝt cһp 2 thanh ghi 16
bit là chӭa đӏa chӍ đoҥn và đӏa chӍ đӝ lӋch (segment:offset). Ngưӡi lұp trình chӍ
quan tâm tӟi đӏa chӍ logic nhưng khi truy xuҩt bӝ nhӟ, đơn vӏ ghép nӕi Bus BIU
trong VXL sӁ tính tӯ đó ra đӏa chӍ vұt lý thұt sӵ cӫa byte nhӟ cҫn truy cұp theo
công thӭc:
Đ͓a ch͑ v̵t lý=đ͓a ch͑ đo̩n ×16 + đ͓a ch͑ đ͡ l͏ch (segment×16 + offset)
ĐiӅu này đưӧc BIU thӵc hiӋn dӉ dàng bҵng cách dӏch trái giá trӏ thanh ghi
chӭa đӏa chӍ đoҥn đi 4 bit rӗi cӝng vӟi giá trӏ offset trong thanh ghi chӭa đӝ lӋch
(vì khi mӝt sӕ nhӏ phân đưӧc dӏch trái đi 4 digit, tương đương vӟi viӋc nhân nó
vӟi 24 = 16).
Vì mӛi thanh ghi đoҥn dài 16 bit nên có thӇ đӏnh đӃn 64 k đoҥn nhӟ, và sӕ
đӏa chӍ offset (tương ӭng vӟi kích thưӟc mӛi đoҥn) sӁ là 64 kbyte. Do đó không
gian đӏa chӍ logic sӁ lӟn hơn và bҵng 64 kbyte × 64 kbyte đӏa chӍ = 4 Gbyte nhӟ.

1.2.2.2. Các thanh ghi trong 8086
8086 có 14 thanh ghi 16 bit.
Các thanh ghi đa năng AX, BX, CX, DX. Chúng đưӧc dùng đӇ lưu trӳ dӳ
liӋu tҥm thӡi trong khi thӵc hiӋn chương trình. Ưu điӇm cӫa viӋc sӱ dөng thanh
ghi bên trong cho viӋc lưu trӳ tҥm thӡi dӳ liӋu là cho phép VXL có thӇ truy cұp
dӳ liӋu nhanh hơn rҩt nhiӅu so vӟi viӋc phҧi truy cұp bӝ nhӟ ngoài. Các thanh
ghi này đưӧc tách thành hai phҫn, mӛi phҫn 8 bit, phҫn chӭa 8 bit cao là AH,
BH, CH, DH và phҫn chӭa 8 bit thҩp là AL, BL, CL , DL. Mӛi phҫn đӅu có thӇ
đưӧc đӏa chӍ hóa tách biӋt.
y Thanh ghi AX: Thanh ghi tích lũy (Accumulator Register) ± là thanh ghi
đóng vai trò trung tâm đӕi vӟi phép nhân và phép chia. Thanh ghi AH
thưӡng đưӧc sӱ dөng đӇ truy nhұp qua mӝt kênh vào/ra.
y Thanh ghi BX: Thanh ghi cơ sӣ (Base Register) ± đưӧc dùng cho các
loҥi đӏnh đӏa chӍ đһc biӋt đӇ tính toán đӏa chӍ, thưӡng đưӧc dùng đӇ chӭa
con trӓ trӓ tӟi bӝ nhӟ.
y Thanh ghi CX: Thanh ghi đӃm (Count Register) ± chӭa sӕ đӃm trong các
lӋnh lһp vòng.
y Thanh ghi DX: Thanh ghi dӳ liӋu (Data Register) ± là thanh ghi mӣ rӝng
cӫa thanh ghi AX trong các lӋnh nhân và chia. Thanh ghi này chӭa nӱa
cao cӫa mӝt tích 32 bit hoһc nӱa cao cӫa mӝt sӕ bӏ chia 32 bit. Trong

8

viӋc thӵc hiӋn các lӋnh đӑc/viӃt các cәng vào/ra, thanh ghi này đưӧc
dùng đӇ chӭa đӏa chӍ cӫa các cәng cҫn đӑc/viӃt có giá trӏ lӟn hơn FFh.
Các thanh ghi đoҥn CS, DS, SS, ES: có 4 thanh ghi đoҥn dùng đӇ lưu trӳ đӏa
chӍ 16 bit cӫa 4 loҥi đoҥn nhӟ logic: đoҥn mã lӋnh CS, đoҥn dӳ liӋu DS, đoҥn
ngăn xӃp SS, đoҥn phө ES. Ngăn xӃp (stack) là mӝt vùng nhӟ đưӧc đһt ra
ngoài đӇ lưu trӳ đӏa chӍ và dӳ liӋu trong khi thӵc hiӋn chương trình con.
y Thanh ghi đoҥn mã lӋnh CS: là thanh ghi chӭa đӏa chӍ đoҥn cӫa vùng
chӭa mã lӋnh cӫa chương trình đang thӵc hiӋn.
y Thanh ghi đoҥn dӳ liӋu DS: là thanh ghi đӏa chӭa đӏa chӍ đoҥn cӫa
vùng dӳ liӋu mà chương trình đang thӵc hiӋn sӱ dөng, vùng này
thưӡng chӭa các biӃn cӫa chương trình.
y Thanh ghi đoҥn ngăn xӃp SS: là thanh ghi chӭa đӏa chӍ đoҥn bӝ nhӟ
ngăn xӃp (stack) cӫa chương trình.
y Thanh ghi đoҥn phө (mӣ rӝng, bә xung): là thanh ghi chӭa đӏa chӍ
đoҥn cӫa vùng nhӟ bә xung mà chương trình đang sӱ dөng, vùng này
cũng thưӡng chӭa các biӃn cӫa chương trình.
Các thanh ghi con trӓ và chӍ sӕ: gӗm có các thanh ghi: BP, SP, SI, DI, IP.
y SP (Stack Pointer) ± thanh ghi con trӓ stack: nó luôn kӃt hӧp vӟi SS đӇ
chӍ ra đӍnh tӭc thӡi cӫa ngăn xӃp. Sau mӛi thao tác cҩt mӝt tӯ (word)
vào ngăn xӃp SP sӁ tӵ đӝng giҧm đi 2 đơn vӏ, và ngưӧc lҥi sau mӛi
thao tác lҩy mӝt tӯ ra khӓi ngăn xӃp SP sӁ tӵ đӝng tăng lên 2 đơn vӏ.
y BP (Base Stack Pointer) ± thanh ghi con trӓ cơ sӣ: là thanh ghi con trӓ
đӇ đánh dҩu ngăn xӃp, Trong nhiӅu thao tác vӟi stack cҫn sӱ dөng
thêm thanh ghi này, chҷng hҥn như truyӅn thông sӕ thông qua stack.
y SI (Source Index) và DI (Destination Index) ± thanh ghi con trӓ chӍ sӕ
nguӗn và thanh ghi con trӓ chӍ sӕ đích: đưӧc thiӃt kӃ đӇ chuyên sӱ
dөng trong các thao tác vұn chuyӇn dӳ liӋu. Trong mӝt sӕ lӋnh cӫa
8086 các thanh ghi này luôn đưӧc kӃt hӧp vӟi các thanh ghi đoҥn DS,
ES đӇ trӓ tӟi nguӗn và đích cӫa thao tác vұn chuyӇn dӳ liӋu. Đó là cҳp
DS: SI và ES:DI.
Thanh ghi con trӓ lӋnh IP (Intruction Pointer): Thanh ghi con trӓ lӋnh
luôn chӭa đӏa chӍ lӋch cӫa lӋnh tiӃp theo sӁ đưӧc thi hành trong đoҥn nhӟ CS.
Sau khi mӝt lӋnh đưӧc thi hành thì IP lҥi đưӧc bӝ VXL thay đәi giá trӏ đӇ trӓ tӟi
lӋnh tiӃp theo sӁ đưӧc thi hành.

9

Thanh ghi cӡ Flag (Flags Register): đây là thanh ghi 16 bit, trong đó mӛi
bit đưӧc sӱ dөng đӇ thӇ hiӋn mӝt trҥng thái cӫa bӝ VXL tҥi mӝt thӡi điӇm nhҩt
đӏnh trong quá trình thӵc hiӋn chương trình, trong VXL 8086 mӟi chӍ có 9 bit
đưӧc sӱ dөng, ngưӡi ta gӑi mӛi bit đó là mӝt cӡ, mӛi cӡ thưӡng đưӧc biӇu diӉn
bҵng mӝt kí hiӋu gӧi nhӟ, mӛi cӡ đӅu có hai trҥng thái khác nhau là 0 và 1.
Ngưӡi lұp trình ASM hay dùng trҥng thái các bit cӡ làm điӅu kiӋn cho các lӋnh
nhҧy có điӅu kiӋn.
x x x x O D I T S Z x A x P x C

x: không đưӧc đӏnh nghĩa.
y C hoһc CT (Carry flag): cӡ nhӟ. CF = 1 khi sӕ nhӟ tràn khӓi bit có
trӑng sӕ lӟn nhҩt.
y P hoһc PF (Parity flag): cӡ parity. PF phҧn ánh tính chҹn lҿ (parity)
cӫa tәng sӕ bit có trong kӃt quҧ. PF = 1 khi tәng sӕ bit 1 trong kӃt quҧ
là chҹn.
y A hoһc AF (Auxiliary carry flag): cӡ nhӟ phө, rҩt có ý nghĩa khi ta làm
viӋc vӟi các sӕ BCD. AF = 1 khi có nhӟ hoһc mưӧn tӯ mӝt sӕ BCD
thҩp (4 bit thҩp) sang mӝt sӕ BCD cao (4 bit cao).
y Z hoһc ZF ( Zero flag): cӡ rӛng, ZF = 1 khi kӃt quҧ bҵng 0.
y S hoһc SF (Sign flag): cӡ dҩu, SF = 1 khi kӃt quҧ âm.
y hoһc OF (Overflow flag): cӡ tràn, OF = 1 khi có hiӋn tưӧng tràn sӕ
hӑc, đó là trưӡng hӧp sӕ quá lӟn vưӧt ra khӓi dung lưӧng nơi gӱi đӃn.
y T hoһc TF (Trap flag): cӡ bүy, TF = 1 thì CPU làm viӋc ӣ chӃ đӝ chҥy
tӯng lӋnh( chӃ đӝ này cҫn dùng khi cҫn tìm lӛi trong mӝt chương
trình).
y I hoһc IF (Interrupt enable flag): cӡ cho phép ngҳt, IF = 1 thì CPU cho
phép các yêu cҫu ngҳt đưӧc tác đӝng.
y D hoһc DF (Direction flag): cӡ hưӟng, DF = 1 khi CPU làm viӋc vӟi
chuӛi kí tӵ theo thӭ tӵ tӯ trái sang phҧi (hay còn gӑi D là cӡ lùi).

1.2.3. Các mode đӏa chӍ cӫa 8086
Hay còn gӑi là các chӃ đӝ đӏa chӍ, các phương pháp xác đӏnh đӏa chӍ cӫa
các toán hҥng có trong lӋnh. Lưu ý rҵng tұp các thanh ghi cӫa bӝ xӱ lý đưӧc sҳp
xӃp cũng tҥo nên mӝt bӝ nhӟ tӕc đӝ cao và cũng có mӝt không gian đӏa chӍ.

10

Đӏa chӍ hiӋu dөng EA ~ offset hay đӝ lӋch cӫa ô nhӟ chӭa toán hҥng mong
muӕn tính tӯ đӏa chӍ cơ sӣ đoҥn. Đӏa chӍ vұt lý cӫa ô nhӟ chӭa toán hҥng đưӧc
8086 xác đӏnh bҵng cách cӝng đӏa chӍ hiӋu dөng vӟi đӏa chӍ cơ sӣ đoҥn nҵm
trong các thanh ghi đoҥn. Thanh ghi đoҥn thông dөng nhҩt là thanh ghi DS.
8086 có các mode đӏa chӍ sau:
y Đӏnh đӏa chӍ tӭc thӡi: các đơn giҧn nhҩt đӇ xác đӏnh mӝt toán hҥng là
phҫn đӏa chӍ cӫa lӋnh chӭa chính toán hҥng đó chӭ không cҫn đӏa chӍ
hoһc thông tin khác mô tҧ toán hҥng đó ӣ đâu. Mӝt toán hҥng như vұy
gӑi là toán hҥng tӭc thӡi bӣi vì toán hҥng đưӧc tìm và nҥp tӵ đӝng tӯ
bӝ nhӟ cùng lúc vӟi lӋnh và đưӧc sӱ dөng ngay lұp tӭc. Đӏnh đӏa chӍ
tӭc thӡi có ưu điӇm là không cҫn mӝt truy xuҩt bӝ nhӟ nào. Tuy nhiên
nó có nhưӧc điӇm là toán hҥng bӏ giӟi hҥn bӣi mӝt sӕ chӍ đһt vӯa trong
trưӡng đӏa chӍ.
Thí dө: MOV CX, 437Bh
y Đӏnh đӏa chӍ trӵc tiӃp: phương pháp này xác đӏnh mӝt toán hҥng bҵng
cách cung cҩp đӏa chӍ cӫa tӯ nhӟ chӭa toán hҥng cho bӝ xӱ lý. Vӟi chӃ
đӝ đӏnh đӏa chӍ bӝ nhӟ đơn giҧn nhҩt, đӏa chӍ hiӋu dөng chӍ là sӕ 16 bit
đưӧc viӃt tiӃp trong câu lӋnh.
Thí dө: MOV BL, [437Ah], nҥp nӝi dung ô nhӟ có đӝ lӋch tính tӯ đӏa
chӍ cơ sӣ đoҥn là 437A vào thanh ghi BL. Khi đó VXL sӁ tính toán
đӏa chӍ cӫa ô nhӟ bҵng cách cӝng thêm đӏa chӍ hiӋu dөng 437A vào đӏa
chӍ cơ sӣ đoҥn dӳ liӋu.
ChӃ đӝ đӏnh đӏa chӍ này đưӧc gӑi là trӵc tiӃp vì đӝ dӏch chuyӇn cӫa
toán hҥng đưӧc chӍ ra trӵc tiӃp trong câu lӋnh.
Thí dө khác: MOV BX, [437Ah], copy mӝt tӯ 16 bit tӯ ô nhӟ vào
thanh ghi BX. Bӣi mӛi đӏa chӍ trong 8086 đҥi diӋn cho 1 byte, do đó
nӝi dung cӫa ô nhӟ có đӏa chӍ lӋch so vӟi đӏa chӍ đoҥn dӳ liӋu DS là
437A sӁ đưӧc copy vào thanh ghi BL, nӝi dung ô nhӟ có đӏa chӍ lӋch
437B sӁ đưӧc copy vào thanh ghi BH.
Ngoài ra đӏnh đӏa chӍ trӵc tiӃp còn đưӧc dùng đӇ xác đӏnh toán hҥng
đích trong bӝ nhӟ, ví dө: MOV [437Ah], BX sӁ copy vào ô nhӟ có đӏa
chӍ lӋch 437A nӝi dung thanh ghi BL, và copy nӝi dung thanh ghi BH
vào ô nhӟ có đӏa chӍ lӋch là 437B.
y Đӏnh đӏa chӍ thanh ghi: Trong chӃ đӝ này, thanh ghi sӁ là toán hҥng
nguӗn cӫa câu lӋnh. Thí dө: MOV CX, AX. Trong đó, toán hҥng
nguӗn là toán hҥng đӭng sau dҩu phҭy, toán hҥng đích là toán hҥng

11

đӭng trưӟc dҩu phҭy, lӋnh MOV CX, AX sӁ copy nӝi dung thanh ghi
AX vào thanh ghi CX. Ta có thӇ copy nӝi dung bҩt cӭ thanh ghi 16 bit
nào sang thanh ghi 16 bit khác, cũng có thӇ copy nӝi dung bҩt cӭ thanh
ghi 8 bit nào sang thanh ghi 8 bit khác, các trưӡng hӧp còn lҥi là không
thӇ.
y Đӏnh đӏa chӍ gián tiӃp: trong chӃ đӝ này, trưӡng đӏa chӍ cho biӃt tӯ
nhӟ nào hoһc thanh ghi nào chӭa đӏa chӍ cӫa toán hҥng. Trong nhóm
này có các loҥi như sau:
- Đӏnh vӏ gián tiӃp thanh ghi: lúc này đӏa chӍ hiӋu dөng nҵm ӣ mӝt
trong các thanh ghi BX, BP, SI hoһc DI.
Thí dө: MOV AX, [SI] ; chuyӇn nӝi dung cӫa ô nhӟ trong đoҥn hiӋn
tҥi có offset là nӝi dung cӫa thanh ghi SI và thanh ghi AX.
- Đӏnh vӏ cơ sӣ: EA là tәng cӫa đӝ dӏch chuyӇn và nӝi dung cӫa thanh
ghi BX hoһc BP.
-Thí dө: MOV [BX] + displacement, AL; chuyӇn nӝi dung cӫa thanh
ghi AL vào ô nhӟ có đӏa chӍ offset bҵng tәng nӝi dung cӫa BX vӟi đӝ
dӏch chuyӇn.
y Đӏnh vӏ chӍ sӕ (indexed addressing): EA là tәng cӫa đӝ dӏch chuyӇn
và nӝi dung cӫa thanh ghi SL hoһc DI.
Lý do có chӃ đӝ này như sau. NhiӅu thuұt toàn cҫn thӵc hiӋn mӝt thao
tác nào đó trên mӝt chuӛi cҩu trúc dӳ liӋu lưu giӳ trong nhӳng vӏ trí
nhӟ liên tiӃp. Thí dө xét mӝt khӕi gӗm n tӯ lӋnh máy chiӃm các vӏ trí
A, A + 1, A + 2, «, A + n-1. Các tӯ này cҫn đưӧc di chuyӇn đӃn các
vӏ trí B, B + 1, B + 2, « ,B + n-1. Trong trưӡng hӧp này có thӇ thӵc
hiӋn lӋnh MOV A, B rӗi thay đәi chính lӋnh đó thành MOVE A + 1, B
+ 1 và lһp lҥi cho tӟi khi cҧ n tӯ đưӧc sao chép hӃt. Bҵng cách đӏnh đӏa
chӍ gián tiӃp có thӇ thӵc hiӋn đưӧc điӅu này. Mӝt thanh ghi hoһc tӯ
nhӟ đưӧc nҥp đӏa chӍ A, mӝt thanh ghi hoһc tӯ nhӟ khác đưӧc nҥp đӏa
chӍ B. LӋnh MOV dùng 2 thanh ghi này làm các con trӓ và sau mӛi lҫn
sao chép mӝt tӯ con trӓ đưӧc tăng lên 1. Các con trӓ là mӝt phҫn cӫa
dӳ liӋu chӭ không phҧi là phҫn cӫa chương trình và nhӳng ngưӡi sӱ
dөng không đưӧc dùng chung đӗng thӡi. Mӝt giҧi pháp khác là có mӝt
sӕ thanh ghi gӑi là thanh ghi ch͑ s͙ hoҥt đӝng như sau. Đӏa chӍ có 2
phҫn: sӕ cӫa mӝt thanh ghi chӍ sӕ và mӝt hҵng sӕ. Đӏa chӍ cӫa toán
hҥng là tәng cӫa hҵng sӕ vӟi nӝi dung cӫa thanh ghi chӍ sӕ. Trong thí
dө này, nӃu cҧ hai đӏa chӍ đưӧc đӏnh chӍ sӕ bҵng cách dùng mӝt thanh

12

ghi chӍ sӕ chӭa sӕ nguyên k, lӋnh MOV A, B sӁ chuyӇn nӝi dung vө trí
nhӟ A + k tӟi B + k. Bҵng cách khӣi đӝng thanh ghi chӍ sӕ là 0 và tăng
nӝi dung thanh ghi này lên mӝt lưӧng bҵng kích thích cӫa tӯ sau khi
sao chép mӝt tӯ, chӍ cҫn mӝt thanh ghi cho vòng lһp sao chép. Hơn
nӳa viӋc tăng thanh ghi sӁ nhanh hơn viӋc tăng mӝt vӏ trí nhӟ. ViӋc
đánh chӍ sӕ đưӧc sӱ dөng rӝng rãi đӇ đӏnh đӏa chӍ mӝt trưӡng tҥi mӝt
khoҧng cách đã biӃt tính tӯ điӇm đҫu cӫa mӝt cҩu trúc dӳ liӋu đã cho.
Các biӃn cөc bӝ trong mӝt thӫ tөc đưӧc truy cұp theo cách này.
ViӋc tăng hoһc giҧm giá trӏ thanh ghi chӍ sӕ trưӟc hoһc sau khi nó
đưӧc sӱ dөng là viӋc làm thưӡng xuyên xҧy ra. Vì vұy ngưӡi ta thưӡng
đưa các lӋnh đӏnh đӏa chӍ đһc biӋt hoһc thұm chí có nhӳng thanh ghi
chӍ sӕ đһc biӋt mà tӵ chúng có thӇ tăng hoһc giҧm giá trӏ. ViӋc sӱa đәi
tӵ đӝng mӝt thanh ghi chӍ sӕ đưӧc gӑi là đánh ch͑ s͙ t͹ đ͡ng
(autoindexing).
Thí dө lӋnh: MOV AL, [SI] + displacement; chuyӇn nӝi dung ô
nhӟ có đӏa chӍ offset bҵng tәng cӫa nӝi dung SI vӟi đӝ dӏch chuyӇn
vào thanh ghi AL.
MOV AH,[BX] [SI] + displacement; chuyӇn
nӝi dung cӫa ô nhӟ có đӏa chӍ offset bҵng tәng cӫa đӝ dӏch chuyӇn vӟi
nӝi dung cӫa BX và SI vào thanh ghi AH.
Đây là kiӇu đ͓nh đ͓a ch͑ ch͑ s͙ và cơ sͧ, EA là tәng cӫa nӝi dung
thanh ghi cơ sӣ, thanh ghi chӍ sӕ và đӝ dӏch chuyӇn.
y Đӏnh đӏa chӍ ngăn xӃp (stack addressing): Ngăn xӃp gӗm các phҫn tӱ
dӳ liӋu (tӯ, kí tӵ, bit v.v«) đưӧc lưu trӳ theo mӝt trұt tӵ liên tiӃp trong
bӝ nhӟ. Phҫn tӱ đҫu tiên đưӧc cҩt vào ngăn xӃp sӁ ӣ đáy ngăn xӃp.
Phҫn tӱ mӟi nhҩt đưӧc cҩt vào sӁ ӣ đӍnh ngăn xӃp. KӃt hӧp vӟi mӛi
ngăn xӃp là mӝt thanh ghi hoһc tӯ nhӟ chӭa đӏa chӍ cӫa đӍnh ngăn xӃp
đưӧc gӑi là con tr͗ ngăn x͇p (stack pointer).
Máy tính có lӋnh PUSH cҩt các nӝi dung cӫa ô nhӟ hoһc thanh ghi vào
ngăn xӃp. LӋnh này phҧi thӵc hiӋn viӋc sao chép phҫn tӱ đó và tăng
con trӓ ngăn xӃp. Ngưӧc lҥi, lӋnh POP lҩy nӝi dung đӍnh ngăn xӃp đưa
trӣ lҥi thanh ghi hoһc ô nhӟ phҧi thӵc hiӋn sao chép mӟi vào nơi thích
hӧp và giҧm con trӓ ngăn xӃp.
Thí dө lӋnh: PUSH AX ;cҩt nӝi dung cӫa thanh ghi AX vào ngăn
xӃp

13

POP AX ;hӗi phөc giá trӏ thanh ghi AX tӯ nӝi dung
đӍnh ngăn xӃp.
Mӝt sӕ lӋnh không đӏa chӍ cũng có thӇ đưӧc sӱ dөng cùng vӟi ngăn
xӃp. Đӏnh dҥng lӋnh này chӍ ra rҵng 2 toán hҥng đưӧc lҩy ra khӓi ngăn
xӃp, toán hҥng này tiӃp sau toán hҥng kia, phép toán đưӧc thӵc hiӋn
(thí dө nhân hoһc AND) và kӃt quҧ đưӧc cҩt trӣ lҥi ngăn xӃp.

1.3. Ngҳt
Ngҳt (interrupt) là khҧ năng dӯng chương trình chính đang chҥy đӇ thӵc
hiӋn mӝt chương trình khác rӗi sau đó lҥi quay vӅ thӵc hiӋn tiӃp chương trình
chính.
Mӝt trong nhӳng tình huӕng xҧy ra ngҳt như sau: trong khi vi xӱ lý đang
thӵc hiӋn chuӛi lӋnh cӫa chương trình chính nӃu mӝt thiӃt bӏ ngoҥi vi nào đó cҫn
trao đәi thông tin vơi vi xӱ lý, nó sӁ gӱi mӝt tín hiӋu yêu cҫu gӑi là yêu c̯u ng̷t
(thí dө INTR) tӟi vi xӱ lý. Vi xӱ lý sӁ thӵc hiӋn nӕt lӋnh hiӋn tҥi và trҧ lӡi bҵng
tín hiӋu ch̭p nh̵n ng̷t (thí dө INTA). Chương trình chính lúc này sӁ bӏ dӯng lҥi
(ngҳt) và vi xӱ lý cҩt giӳ nӝi dung cӫa các thanh ghi đang dùng bҵng lӋnh PUSH
vào mӝt vùng nhӟ đһc biӋt (gӑi là ngăn xӃp) rӗi chuyӇn sang chương trình con
phͭc vͭ ng̷t tӭc là chương trình trao đәi thông tin mà đơn vӏ yêu cҫu.
Sau khi xong viӋc, nhӡ lӋnh RET và các lӋnh POP hӗi phөc ngăn xӃp, vi
xӱ lý sӁ quay vӅ đúng chӛ bӏ ngҳt và tiӃp tөc thӵc hiӋn chương trình chính như
hình 2.10 chӍ ra.
Các ngҳt không chӍ có ý nghĩa quan trӑng đӕi vӟi phҫn mӅm mà cҧ vӟi
phҫn cӭng. Các ngҳt trong hӑ vi xӱ lý 80x86 có thӇ đưӧc phát ra tӯ mӝt trong ba
nguӗn sau:
Ng̷t cͱng: do tín hiӋu đưӧc sinh ra bӣi các chip điӋn tӱ hoһc thiӃt bӏ ngoҥi
vi bên ngoài vi xӱ lí gây nên. Đó là mӝt cơ cҩu đơn giҧn và hiӋu quҧ cho phép vi
xӱ lý phҧn ӭng mӝt cách kӏp thӡi vӟi các yêu cҫu ngҳt. Thí dө, ҩn hay nhҧ bàn
phím sӁ gây nên ngҳt cӭng sӕ 9 (ngҳt bàn phím), chương trình xӱ lí ngҳt sӁ phҧn
ӭng bҵng cách đưa kí tӵ đưӧc ҩn vào vùng đӋm cӫa bàn phím, vào vӏ trí ngay sau
kí tӵ đưӧc ҩn lҫn trưӟc.
Ng̷t có th͋ b͓ che (maskable) do tín hiӋu yêu cҫu ngҳt đưӧc đưa tӟi
chân INTR cӫa vi xӱ lý. Ngҳt này sӁ bӏ vô hiӋu hóa (bӏ che) bҵng lӋnh hӧp ngӳ
CLI (xóa cӡ ngҳt). NӃu bӏ che thì mһc dù đưӧc gӑi, chương trình xӱ lí ngҳt
tương ӭng cũng không đưӧc thӵc hiӋn. LӋnh STI (đһt cӡ ngҳt) cho phép các ngҳt
bӏ che trӣ lҥi hoҥt đӝng.

14

Ng̷t không th͋ b͓ che (non-maskable) do tín hiӋu yêu cҫu ngҳt đưӧc
đưa tӟi chân NMI cӫa vi xӱ lý. Ngҳt luôn đưӧc thӵc hiӋn kӇ cҧ khi đưӧc gӑi
ngay sau lӋnh CLI. Ngҳt này liên quan tӟi các hӓng hóc phҫn cӭng nghiêm trӑng
(thí dө, hӓng RAM).
Ng̷t m͉m: vӟi nguӗn gây ngҳt là các câu lӋnh gӑi ngҳt INT đưӧc sӱ dөng
cùng sӕ thӭ tӵ ngҳt. Thí dө, lӋnh gӑi ngҳt sӕ 5 (in trang màn hình) đưӧc viӃt là
INT 5. Các ngҳt mӅm cho phép gӑi các chương trình phө cӫa hӋ điӅu hành. Ngҳt
mӅm còn có thӇ đưӧc gӑi tӯ ngôn ngӳ bұc cao, lúc đó nó sӁ đưӧc dӏch ra thành
lӋnh hӧp ngӳ INT.
Ngo̩i l͏: là nguӗn ngҳt thӭ 3 do các lӛi phát sinh trong quá trình thӵc hiӋn
câu lӋnh (thí dө, ngҳt chia cho mӝt sӕ cho 0), vi xӱ lý sӁ tӵ đӝng ngҳt chương
trình đang chҥy bҵng ngҳt sӕ 0.
Vào cuӕi mӛi chu trình lӋnh, 8086 sӁ kiӇm tra xem có ngҳt nào đưӧc yêu
cҫu không. NӃu có yêu cҫu ngҳt, 8086 sӁ phҧn ӭng theo các bưӟc sau:
Giҧm con trӓ ngăn xӃp đi 2 và cҩt thanh ghi cӡ vào ngăn xӃp.
Không cho phép ngҳt cӭng tӯ chân INTR bҵng cách xóa cӡ ngҳt IF trong
thanh ghi cӡ.
Xóa cӡ bưӟc TF trong thanh ghi cӡ.
Giҧm con trӓ ngăn xӃp đi 2 và cҩt nӝi dung thanh ghi đoҥn mã vào ngăn
xӃp.
Giҧm con trӓ ngăn xӃp đi 2 mӝt lҫn nӳa và cҩt nӝi dung thanh ghi con trӓ
lӋnh hiӋn thӡi vào ngăn xӃp.
Thӵc hiӋn mӝt lӋnh nhҧy gián tiӃp far jump tӟi phҫn đҫu cӫa chương trình
con phөc vө ngҳt do ngưӡi dùng viӃt.
Vi xӱ lý 8086 có thӇ phөc vө đưӧc tӟi 256 ngҳt khác ngau, đưӧc đánh sӕ tӯ
0 đӃn 255. Mӛi ngҳt ӭng vӟi mӝt chương trình con phөc vө ngҳt và sӁ đưӧc thӵc
hiӋn khi đưӧc gӑi lҥi. Đӏa chӍ lôgic ô nhӟ bҳt đҫu cӫa mӛi chương trình này gӑi
là mӝt véctơ ng̷t dài 4 byte gӗm đӏa chӍ đoҥn và đӏa chӍ offset 16 bit, đӏa chӍ
offset đưӧc đһt trưӟc đӏa chӍ đoҥn. 256 đӏa chӍ này đưӧc lưu trӳ lҫn lưӧt trong
vùng nhӟ thҩp nhҩt cӫa bӝ nhӟ gӑi là b̫ng các vectơ ng̷t có đӝ dài là 4 x 256 =
1024 byte tӯ đӏa chӍ 0000: 0000 đӃn 0000: 03FF. Như vұy, đӏa chӍ cӫa chương
trình xӱ lí ngҳt sӕ 0 nҵm ӣ 4 ô nhӟ tӯ 0000: 0000 đӃn 0000: 0003, đӏa chӍ cӫa
chương trình ngҳt sӕ 1 tӯ 0000: 0004 đӃn 0000: 0007 v.v« Dó đó đӇ xác đӏnh ô nhӟ
chӭa đӏa chӍ bҳt đҫu cӫa chương trình con phөc vө ngҳt ta chӍ viӋc nhân sӕ ngҳt vӟi 4.

15

1.4. Giӟi thiӋu vӅ hӧp ngӳ

1.4.1. Lұp trình bҵng hӧp ngӳ
ViӋc lұp trình bҵng ngôn ngӳ máy đòi hӓi ta phҧi nhӟ các mã lӋnh bҵng sӕ
(dưӟi dҥng nhӏ phân), còn đưӧc gӑi là mã máy, phҧi sҳp đһt vӏ trí cӫa mã lӋnh và
các sӕ liӋu trong bӝ nhӟ cӫa máy tính, ngay cҧ sӕ liӋu cũng phҧi viӃt dưӟi dҥng
sӕ. Công viӋc này rҩt nһng nhӑc, tӕn công, dӉ nhҫm lүn và khó chӍnh sӱa.
Tuy nhiên viӋc viӃt chương trình bҵng ngôn ngӳ máy cũng có nhӳng ưu
điӇm cӫa nó như phát huy tӕi đa đưӧc khҧ năng cӫa tұp lӋnh cӫa bӝ vi xӱ lý,
cũng như sӱ dөng có hiӋu quҧ nhҩt bӝ nhӟ cӫa máy tính, tӕc đӝ thӵc hiӋn
chương trình là nhanh nhҩt và chương trình có kích thưӟc nhӓ nhҩt.
ĐӇ tránh các khó khăn cӫa viӋc viӃt chương trình bҵng ngô ngӳ máy nhưng
vүn đҥt đưӧc ưu điӇm cӫa viӋc lұp trình bҵng ngôn ngӳ máy ngưӡi ta sӱ dөng
hӧp ngӳ. Hӧp ngӳ là mӝt ngôn ngӳ lұp trình gӧi nhӟ, nó có các ưu nhưӧc điӇm
như sau:
y Ưu điӇm :
Vì ngôn ngӳ Assembler rҩt gҫn gũi vӟi ngôn ngӳ máy nên chương trình
+ Chҥy nhanh.
+ TiӃt kiӋm bӝ nhӟ.
+ Có thӇ lұp trình truy cұp qua các giao diӋn vào ra nhưng hiӋn nay các
ngôn ngӳ bұc cao cũng có thӇ làm đưӧc.
y Nhưӧc điӇm
+ Khó viӃt bӣi vì yêu cҫu ngưӡi lұp trình rҩt am hiӇu vӅ phҫn cӭng.
+ Khó tìm sai: bao gӗm sai vӅ cú pháp (syntax) và sai vӅ thuұt toán
(Algorithm). Chương trình dӏch sӁ thông báo sai ta sӁ dùng debug cӫa DOS đӇ
kiӇm tra.
+ Không chuyӇn chương trình Assembler cho các máy tính có cҩu trúc
khác nhau.
y Ӭng dөng
+ ViӃt lõi cӫa hӋ điӅu hành.
+ Các chương trình trò chơi ( ngày trưӟc).
+ Tҥo virus.
+ Các chương trình đo và điӅu khiӇn sӱ dөng trong công nghiӋp, ngày nay
các vi điӅu khiӇn đưӧc sӱ dөng mӝt cách rӝng rãi.
1.4.2. HӋ lӋnh Assembler
a) HӋ lӋnh assembler gӗm có:

16

y Tұp lӋnh MNEMONIC sinh mã máy đӇ chҥy chương trình.
y Các DIRECTIVE điӅu khiӇn khi dӏch chương trình.
b) Cú pháp cӫa mӝt dòng lӋnh ASM
y Mӛi mӝt dòng chӍ đưӧc viӃt mӝt lӋnh.
y [Label] [Directive/Mnemonic] [Operands] [;Commnet]
[Nhãn] [Loҥi lӋnh] [Toán hҥng][Ghi chú]
Tӯ ; cho đӃn hӃt dòng là ghi chú và nó có hiӋu lӵc chӍ trên 1 dòng.
ví dө:
L1:
mov ax,bx
c) Tұp lӋnh Mnemonic
- Tұp lӋnh Mnemonic là gì? Đó là lӋnh cӫa ASM đưӧc thӇ hiӋn bҵng viӃt tҳt
cӫa tiӃng Anh cho dӉ hiӇu.
Ví dө:
TiӃng Anh LӋnh dҥng Mnemonic
Move mov
Addition add
Multiplication mul
Các quy ưӟc vӅ toán hҥng:
y SRC: Toán hҥng nguӗn.
y DST: Toán hҥng đích.
y REG(reg8/reg16): Toán hҥng là thanh ghi
y Data: Toán hҥng là hҵng sӕ.
y Mem: Toán hҥng là biӃn nhӟ.
y Segreg: Toán hҥng là thanh ghi segment.
Tұp lӋnh MNEMONIC gӗm có 6 nhóm:
y Nhóm 1: Các lӋnh di chuyӇn dӳ liӋu
y Nhóm 2: Các lӋnh sӕ hӑc.
y Nhóm 3: Các lӋnh thao tác bit
y Nhóm 4: Các lӋnh thao tác xâu ký tӵ.
y Nhóm 5: Các lӋnh rӁ nhánh
y Nhóm 6: Các hӋ thӕng cӡ

1.4.2. Các bưӟc viӃt chương trình hӧp ngӳ
HiӋn nay có hai chương trình dӏch rҩt phә biӃn là MASM (cӫa hãng
Microsoft) và TASM (cӫa hãng Borland) vӅ cơ bҧn là hai chương dӏch này rҩt
giӕng nhau nhưng khác nhau ӣ chӛ: khi viӃt lӋnh push
NӃu viӃt :
push ax

17

push bx
push cx
thì cҧ hai chương trình đӅu biên dӏch đưӧc. ( cách viӃt này theo MASM).
Còn trong TASM thì cho phép viӃt
push ax bx cx

1.4.2.1. Cài đһt chương trình dӏch TASM:
y Cách 1:
Mua đĩa bҧn quyӅn nӃu là đĩa mӅm thì có 5 đĩa hoһc là 1 đĩa CD. Hoһc
download phҫn mӅm TASM hoһc MASM vӅ.
Run cmd
A: install

y Cách 2:
+ Tҥo thư mөc: C:TASM
+ Copy 4 tӋp lõi tӯ máy khác đã cài đһt theo cách 1 vӅ thư mөc đã tҥo
trưӟc.

1.4.2.2. Các bưӟc thӵc hiӋn mӝt chương trình Assember trên máy PC :
(soҥn thҧo chương trình, dӏch chương trình, liên kӃt, chҥy thӱ và
cách tìm sai bҵng DEBUG cӫa DOS và TD (Turbo Debug) cӫa Borland)
Bao gӗm 4 bưӟc:
+ Bưӟc 1: Dùng chương trình soҥn thҧo bҩt kì (Edit, NC, TC, «.) đӇ soҥn
thҧo chương trình. Sau khi soҥn thҧo xong phҧi cҩt tӋp có đuôi là .ASM.
+ Bưӟc 2: Dӏch chương trình gӕc có đuôi .ASM thành tӋp có đuôi là .OBJ
Cú pháp: C:BT> tasm ten tep[.ASM]
ten tep.OBJ

18

Chú ý: khi chương trình dӏch có lӛi thì không sinh ra tӋp có đuôi là .OBJ
Cách khai báo sai
** Error**ten tep.asm[10] Illegal Instruction
dòng thӭ bao nhiêu lӛi gì
+ Bưӟc 3: Liên kӃt đӇ chuyӇn tên tӋp có đuôi .OBJ sang tӋp .EXE hay
.COM
Cú pháp: C:BT> tlink ten tep[.OBJ]
ten tep.EXE hay ten tep.COM
+ Bưӟc 4: Chҥy thӱ chương trình
Khi chҥy nӃu có lӛi thì dùng debug đӇ kiӇm tra.
Ví dө:
.model small
.stack
.data
message db "Hello$"
.code
main proc
mov ax,seg message
mov ds,ax
mov ah,09
lea dx,message
int 21h
mov ax,4ch
int 21h
main endp
end main
1.4.3. Cҩu trúc mӝt chương trình hӧp ngӳ dҥng segment đơn giҧn
Cҩu trúc cӫa mӝt chương trình hӧp ngӳ có liên quan chһt chӁ vӟi cҩu trúc
phҫn cӭng cӫa bӝ vi xӱ lý. Ngưӡi ta đã tҥo dӵng bӕn đoҥn (segment) đưӧc dӵ
tính cho bӝ vi xӱ lý trong quá trình lұp trình: đoҥn mã lӋnh, đoҥn dӳ liӋu, đoҥn
ngăn xӃp và đoҥn mӣ rӝng. Trong đó, ít nhҩt mӝt chương trình hӧp ngӳ phҧi có
mӝt đoҥn mã lӋnh.
Do chương trình hӧp ngӳ có cҩu trúc như vұy mà ta có khái niӋm vӅ
chương trình hͫp ngͷ d̩ng segment. Mӝt chương trình segment dҥng chuҭn phҧi
đӏnh nghĩa đҫy đӫ bӕn đoҥn, mӛi đoҥn đưӧc bҳt đҫu bҵng chӍ dүn hưӟng

19

(directive) segment và kӃt thúc bҵng chӍ dүn hưӟng ENDS, mӛi đoҥn đӅu đưӧc
ngưӡi lұp trình cho trưӟc mӝt tên đӝc lұp vӟi kiӇu cӫa nó.
Ӣ cuӕi mӛi chương trình hӧp ngӳ có chӍ dүn hưӟng END đӇ hưӟng dүn cho
bӝ dӏch hӧp ngӳ biӃt rҵng chương trình đã kӃt thúc.
Tuy nhiên, viӋc viӃt mӝt chương trình hӧp ngӳ dҥng segment chuҭn quá
phӭc tҥp, nên chúng ta thưӡng dùng dҥng giҧn lưӧc cӫa nó hay chương trình hͫp
ngͷ d̩ng segment đơn gi̫n.
1.4.3.1. Dҥng thưӡng thҩy 1 chương trình ASM đơn giҧn
(Khai báo theo directive điӅu khiӇn segment dҥng đơn giҧn)
.MODEL
.STACK
.DATA
Khai báo biӃn
.CODE
Nhãn chương trình:
Thân chương trình
END Nhãn chương trình
Mӝt chương trình asm đưӧc biên dӏch thành công sӁ trӣ thành mӝt file chҥy
có phҫn mӣ rӝng là .com hoһc .exe. Sӵ khác nhau cӫa chương trình dҥng .com và
chương trình dҥng .exe là:
y Chương trình dҥng .com có tҩt cҧ các phҫn mã lӋnh, dӳ liӋu và ngăn
xӃp đӅu cùng nҵm trong mӝt segment
y Chương trình dҥng .exe có phҫn mã lӋnh, dӳ liӋu và ngăn xӃp nҵm trên
các segment khác nhau.
a) Cҩu trúc chương trình dҥng .Com
Cҩu trúc:
.MODEL SMALL
.CODE org 0100h
[JMP nhãn khác
khai báo biӃn
nhãn khác:]
int 20h
[các chương trình con]

20

Ví dө: ViӃt chương trình hiӋn mӝt xâu lên màn hình:
.model small
.code
org 100h
begin:
jmp var
str db "hello world!$"
var:
lea dx,str
mov ah,9
int 21h

mov ah,1
int 21h

mov ah,4ch
int 21h
end begin
a) Cҩu trúc chương trình dҥng .exe
Cҩu trúc:
.MODEL SMALL
.STACK 100h
.DATA
Khai báo biӃn
.CODE
mov ax,@data
mov ds,ax
mov ah,4ch
int 21h
Ví dө: Chương trình hiӋn mӝt xâu lên màn hình
.model small

21

.stack 100h
.data
.code
begin:
mov ax,@data
mov ds,ax
lea dx,str
mov ah,9
int 21h

mov ah,1
int 21h

mov ah,4ch
int 21h
end begin

1.4.3.2. Các Directve (.MODEL, .STACK, .DATA, .CODE, ...)
a) Directive .MODEL
Chͱc năng: Cho phép ngưӡi lұp trình xác lұp vùng nhӟ RAM thích hӧp cho
chương trình.
Cú pháp
. Model KiӇu
Tiny Code + data ” 64k
Small Code ” 64k; data ” 64k
Compact Code ” 64k; data • 64k
Medium Code • 64k; data ” 64k
Large Code • 64k; data • 64k
1 array ” 64k
Huge Code • 64k; data • 64k
1 array • 64k

b) Directive .STACK

22

Chͱc năng: Báo cho chương trình dӏch cӫa ASM biӃt xác lұp mӝt vùng nhӟ
RAM cho Stack. Vӟi lӋnh điӅu khiӇn này thì DOS sӁ xác lұp đӏa chӍ đҫu cӫa
ngăn xӃp và giá trӏ đó đưӧc đưa vào thanh ghi segment SS.
Cú pháp: . stack đӝ dài (tính theo byte)
Ví dө: . stack 100h
NӃu không có khai báo . stack thì lҩy đӝ dài mһc đӏnh default.
c) Directive . DATA
Chͱc năng: Báo cho chương trình dӏch cӫa ASM biӃt đӇ xác lұp mӝt vùng
nhӟ RAM cho dӳ liӋu chương trình.
Cú pháp:
.DATA
Khai báo biӃn
BiӃn trong ASM có ba loҥi: biӃn sӕ, biӃn xâu kí tӵ và biӃn trưӡng sӕ
y Khai báo biӃn sӕ
. DATA
Tên_biӃn KiӇu Giá_trӏ_ban_đҫu/?
Các kiӇu dӳ liӋu:
db ( 1 byte)
dw (2 byte)
dd ( 4 byte)
dp ( 6 byte)
dq ( 8 byte)
dt ( 10 byte)
trong đó 2 biӃn db và dw hay dùng.
Ví dө:
.DATA Value dw ?
Value db 10
y Khai báo biӃn xâu kí tӵ
. DATA
Tên_biӃn db Các_kí_tӵ_cách_nhau_bӣi_dҩu_phҭy đӝ_lӟn dup (1 kí tӵ/
?)
Ví dө:
.DATA
xau1 db µH¶,¶e¶,¶l¶,¶l¶,¶l,¶o¶
xau2 db 100h dup(µA¶)
xau2 db 100 dup(?)

23

y Khai báo biӃn trưӡng sӕ
.DATA
Tên_trưӡng_sӕ kiӇu_cӫa_thành_phҫn (Các sӕ cách nhau bӣi dҩu ',')
Đӝ_lӟn dup( 1 sӕ/?)
Ví dө:
.DATA
array1 db 100,2,21,31
array2 dw 100h dup(-100)
Chú ý: NӃu chương trình có khai báo biӃn (tӭc là có .DATA) thì ngưӡi lұp
trình ASM phҧi đưa phҫn đӏa chӍ segment cӫa vùng nhӟ dӳ liӋu vào trong DS
nhӡ 2 lӋnh sau:
mov reg16, @data
mov ds,reg16
Ví dө:
mov ax, @data
mov ds,ax
d) Directive .CODE
Chͱc năng: Báo cho chương trình dӏch ASM biӃt đӇ xác lұp 1 vùng nhӟ
RAM cho phҫn tӱ mã máy cӫa chương trình.
Cú pháp: .CODE

1.4.4. Cҩu trúc cӫa mӝt chương trình segment dҥng chuҭn
Ta có thӇ hình dung dҥng thưӡng thҩy cӫa mӝt chương trình segment như
sau:
Segment_Name SEGMENT
....
....
....
Segment_Name ENDS
END
1.4.4.1. Chương trình segment đơn giҧn dҥng chuҭn
Stack segment
db 100h dup (?)
Stack ends
Data segment
Khai báo biӃn

24

Data ends
Code segment
Assume cs:code, ds:data, ss:stack
Nhan CT:
mov ax, data
mov ds,ax
mov ah, 4ch
int 21h
code ends
END Nhan CT
1.4.4.2. Các directive điӅu khiӇn segment: dҥng chuҭn
(SEGMENT, GROUP và ASSUME)
a) Directive SEGMENT
Chͱc năng: báo cho chương trình dӏch ASM xác lұp các segment cho
chương trình.
Cú pháp:
Khuân mүu đҫy đӫ cӫa chӍ dүn hưӟng SEGMENT là:
Segment_Name SEGMENT Align Combine Use Class
PARA(16 byte) PUBLIC USER16 Class
BYTE (1 byte) COMMON USER32
WORD(2 byte) STACK
DWORD(4 byte) AT
PAGE(128 byte)
-Segment_Name: bҩt kǤ mӝt đӏnh danh nào. Tên segment chӍ đưӧc phép
bao gӗm mӝt tӯ, nӃu gӗm nhiӅu tӯ thì phҧi có dҩu gҥch dưӟi đӇ nӕi các tӯ vӟi
nhau. Các phҫn tӱ đӭng sau SEGMENT đӅu là tùy chӑn.
- Align
Cú pháp:
Align
PARA (16 byte)
BYTE (1 byte)
WORD (2 byte)
DWORD (4 byte)
PAGE (128 byte)

25

Chͱc năng: xác lұp khoҧng trӕng giӳa segment đang khai báo vӟi segment
trưӟc nó. NӃu là BYTE thì khoҧng trӕng giӳa hai segment là 1 byte, PARA là 16
byte...

hình:
Xác lұp khoҧng trӕng giӳa hai segment là 1 byte (BYTE)
NӃu như Align không đưӧc đӏnh nghĩa thì chӍ thӏ mһc đӏnh PARA sӁ đưӧc
sӱ dөng.
- Combine
Chӭc năng 1: cho phép đһt segment khai báo vào mӝt vùng nhӟ RAM theo
yêu cҫu.
Cú pháp:
tên segment SEGMENT đӏa chӍ
....
....
....
Tên segment ENDS
Chӭc năng 2: phөc vө chương trình đa tӋp thuҫn tuý ASM, cách gӝp các
segment có cùng tên nҵm ӣ các tӋp khác nhau khi liên kӃt.
Cú pháp:
COMMON Tҩt cҧ các đoҥn cùng tên đưӧc nҥp chӗng lên nhau, sao
cho tҩt cҧ đӅu bҳt đҫu ӣ cùng mӝt đӏa chӍ. Khi đó đoҥn
tәng cӝng sӁ lӟn bҵng đoҥn riêng lҿ lӟn nhҩt
PUBLIC Các đoҥn cùng tên sӁ đưӧc kӃt nӕi vӟi nhau thành mӝt
đoҥn duy nhҩt.
PRIVATE Mӛi đoҥn nҵm trong mӝt đoҥn vұt lý riêng.
(Default)
- USE : chӍ có tӯ thӃ hӋ 80386 và chӍ đưӧc dùng vӟi chӍ dүn hưӟng 386.

26

use16 ASM 16 bit (default): Đӝ dài đoҥn cӵc đҥi là 64Kbyte
use32 ASM 32 bit : Đӝ dài đoҥn cӵc đҥi là 4Gbyte.
- µCLASS¶
Chӭc năng: cho phép gӝp các segment có cùng lӟp lҥi gҫn nhau khi liên kӃt.
Tên lӟp phҧi đưӧc đһt trong dҩu nháy đơn '', có thӇ dùng mӝt tên bҩt kǤ. Tҩt cҧ
các segment có cùng tên nhưng có tên lӟp khác nhau sӁ đưӧc nҥp kӃ tiӃp nhau
vào trong bӝ nhӟ. Thông thưӡng thì ta chӍ cҫn có mӝt tên lӟp khi ta muӕn kӃt nӕi
các chương trình hӧp ngӳ vӟi các chương trình ngôn ngӳ bұc cao.

Cách khai báo 3 segment cӫa chương trình:
Dҥng chuҭn Dҥng đơn giҧn
Stack segment
db 100h dup (?) .Stack 100h
Stack ends
Data segment .DATA
Khai báo biӃn Khai báo biӃn
Data ends
Chú ý: mov ax, data Chú ý: mov ax,@data
mov ds, ax mov ds, ax
Code segment .CODE
Nhan CT: Nhan CT:
Code ends ENDS Nhan CT
ENDS Nhan CT
b) Drective GROUP

27

Chͱc năng: gӝp các segment cùng loҥi cho dӉ dàng qui chiӃu.
Cú pháp:
tên nhóm GROUP tên các segment
Khai báo các segment
Gi̫i thích:
Data1 segment
M1 db ?
Data1 ends
Data2 segment
M2 dw ?
Data2 ends
Code segment
PS:
mov ax, data1
mov ds,ax
mov cl, M1
mov ax, data2
mov ds,ax
mov cl, M2
Ta làm group như sau:
Nhom_DL GROUP data1,data2
Data1 segment
M1 db ?
Data1 ends
Data2 segment
M2 dw ?
Data2 ends
Code segment
PS:
mov ax, nhom_DL
mov cl, M1
mov dx,M2
c) Directive ASSUME
Chͱc năng: cho biӃt segment khai báo thuӝc loҥi segment nào
Cú pháp:
assume tên thanh ghi segment : tên segment

28

Gi̫i thích:

assume cs:x3, ds:x2,ss:x1
Chú ý: assume thưӡng là dòng đҫu cӫa code segment
Ví dө: HiӋn xâu kí tӵ "hello world !$"
stack segment
db 100h dup(?)
ends stack
data segment
ends data
code segment
assume ss:stack,cs:code,ds:data
begin:
mov ax,data
mov ds,ax
lea dx,str
mov ah,9
int 21h
mov ah,1
int 21h
mov ah,4ch
int 21h
ends code
end begin

29

Chương 2. Lұp trình vӟi Debug

2.1. Tәng quan vӅ Debug
2.1.1. Đһc điӇm cӫa Debug
Debug là mӝt chương trình chҥy trong môi trưӡng DOS. Nó dùng đӇ cho
ngưӡi lұp trình có thӇ:
y nhұp và dӏch các lӋnh dҥng hӧp ngӳ sang mã máy và ngưӧc lҥi
y nҥp, xem và thay đәi nӝi dung cӫa tӋp ӣ trong khӕi nhӟ
y chҥy chương trình theo tӯng lӋnh, nhóm lӋnh hay cҧ chương trình
y sӱa tӯng byte, nhiӅu byte hay cҧ chương trình
y xem và thay đәi nӝi dung các thanh ghi
Các lӋnh cӫa debug đӅu bҳt đҫu bҵng mӝt hay hai chӳ cái, trong đó có mӝt
dҩu ?
2.1.2. Khӣi đӝng và thoát khӓi Debug
Khӣi đӝng Debug tҥi dҩu nhҳc cӫa DOS ta gõ lӋnh:
Debug [ә đĩa][đưӡng dүn][tên tӋp]
Trong đó các tham sӕ đi đҵng sau lӋnh Debug dùng đӇ chӍ ra tên tӋp .EXE
hay .COM đӇ kiӇm tra.
Sau khi khӣi đӝng Debug thì màn hình lúc này còn mӝt dҩu nhҳc là dҩu
gҥch ngang nhӓ "_". Tҥi đây ta gõ các lӋnh cӫa Debug đӇ thӵc hiӋn kӃt thúc lӋnh
là ENTER và muӕn thoát khӓi Delbug ta gõ lӋnh q (quit).

2.2. Các lӋnh cӫa Debug
2.2.1. Nhóm các lӋnh biên soҥn chương trình
1) LӋnh A
Cú pháp: A [address]
Thông sӕ address: là mӝt sӕ hexa gӗm 4 chӳ sӕ đӇ chӍ đӏa chӍ bҳt đҫu các
lӋnh dҥng hӧp ngӳ cӫa chương trình. Đӏa chӍ có thӇ là CS:Offset hay chӍ có đӏa
chӍ Offset vì ngҫm đӏnh là CS hiӋn hành. NӃu không có tham sӕ address thì lҩy
đӏa chӍ CS:Offset hiӋn hành mà lӋnh trưӟc dùng tҥi đó.
Công dөng: LӋnh cho ta nhұp các lӋnh cӫa chương trình dҥng hӧp ngӳ vào
mӝt đӏa chӍ ô nhӟ.
Ví dө: A 200 hay A 0200
Khi đó màn hình sӁ hiӋn ra đӏa chӍ ô nhӟ xxxx:0200 đӇ ta gõ lӋnh vào đӏa
chӍ trên, ví dө ta gõ lӋnh MOV AX, 09 (các giá trӏ trong Debug đӅu ӣ dҥng hexa

30

nên ta không cҫn đưa thêm ký tӵ h đҵng sau giá trӏ đó. NӃu có nó sӁ báo lӛi). Sau
khi nhҩn Enter thì dòng lӋnh đưӧc:
y dӏch ra mã máy
y ghi vào ô nhӟ có đӏa chӍ trên
y màn hình hiӋn ra đӏa chӍ tiӃp theo đӇ chӡ nhұp lӋnh tiӃp theo
Cӭ tiӃp tөc như vұy ta có thӇ nhұp đưӧc cҧ chương trình
2) LӋnh E
Cú pháp: E <address> [list]
Thông sӕ address là mӝt sӕ hexa gӗm bӕn chӳ sӕ đӇ chӍ đӏa chӍ bҳt đҫu đӇ
xem hay sӱa đәi dӳ liӋu. Đӏa chӍ có thӇ là CS:Offset hay chӍ là Offset vì ngҫm
đӏnh là CS hiӋn hành.
Thông sӕ list là danh sách các dӳ liӋu mà ta muӕn nhұp vào các ô nhӟ liên
tiӃp. NӃu là mӝt xâu ký tӵ thì tâ phҧi đһt trong hai dҩu nháy kép "" hay hai dҩu
nháy đơn ''.
Công dөng: Dùng đӇ xem và sӱa nӝi dung cӫa tӯng ô nhӟ. Ta chӍ cҫn chӍ
ra đӏa chӍ đҫu tiên cӫa ô nhӟ và khi đó nó sӁ hiӋn ra nӝi dung cӫa ô nhӟ đҫu tiên,
nӃu ta muӕn sӱa dӳ liӋu cӫa ô nhӟ thì ta cӭ viӋc nhұp dӳ liӋu mӟi bên cҥnh dӳ
liӋu cũ, sau đó nhҩn dҩu cách đӇ xem nӝi dung cӫa ô nhӟ tiӃp theo. KӃt thúc lӋnh
này là dҩu Enter.
3) LӋnh F
Cú pháp: F range list
Thông sӕ range xác đӏnh mӝt vùng nhӟ, có thӇ là đӏa chӍ bҳt đҫu và đӏa chӍ
kӃt thúc hay đӏa chӍ bҳt đҫu và chiӅu dài cӫa vùng nhӟ.
thông sӕ list chӍ danh sách các dӳ liӋu muӕn lҩp đҫy vùng nhӟ range
Công dөng: Lҩp đҫy các ô nhӟ bҵng mӝt danh sách các dӳ liӋu. LӋnh này
có thӇ thay cho lӋnh E đӇ nhұp đӗng thӡi nhiӅu dӳ liӋu cùng mӝt lúc.
Ví dө: F 0100 L 100 41 42 43
LӋnh này sӁ ghi đҫy các ô nhӟ tӯ 0100 đӃn 01FF (100 đӏa chӍ) bҵng các con
sӕ 41, 42, 43. Ba giá trӏ này sӁ lһp lҥi cho đӃn khi toàn bӝ các ô nhӟ đưӧc lҩp
đҫy giá trӏ.
Ví dө 2: F 0100 0120 41 42
LӋnh này sӁ lҩp đҫy các ô nhӟ trong vùng tӯ 0100 đӃn 0120 (21 ô nhӟ) bӣi
các giá trӏ 41, 42.
4) LӋnh U
Cú pháp: U [range]

31

Thông sӕ range xác đӏnh đӏa chӍ đҫu và đӏa chӍ cuӕi hay đӏa chӍ đҫu và chiӅu
dài ô nhӟ.
Công dөng: Có thӇ nói lӋnh này trái ngưӧc vӟi lӋnh A, nó dӏch ngưӧc các
lӋnh tӯ mã máy sang lӋnh dҥng assembly trong các ô nhӟ đưӧc chӍ ra vùng range
hay đӏa chӍ IP hiӋn hành.
Ví dө:
U 0100 : Dӏch ngưӧc 32 byte đҫu tiên tӯ đӏa chӍ 0100
U CS:0100 110 : Dӏch ngưӧc dӳ liӋu tӯ đӏa chӍ CS:0100 tӟi CS: 110
U 0100 L 20 : Dӏch ngưӧc 20 dòng lӋnh bҳt đҫu tӯ đӏa chӍ 0100
2.2.2. Nhóm các lӋnh dӏch chuyӇn dӳ liӋu
1) LӋnh I
Cú pháp: I <đӏa chӍ cәng>
Thông sӕ đӏa chӍ cәng vào có thӇ mã hóa thành 16 bit
Công dөng: Đӑc giá trӏ cӫa cәng có đӏa chӍ đưӧc chӍ ra
Ví dө: I 2F8 : Đӑc giá trӏ cӫa cәng có đӏa chӍ là 2F8 và in giá trӏ lên màn
hình
2) LӋnh O
Cú pháp: O <Đӏa chӍ cӗng> <giá trӏ>
Thông sӕ đӏa chӍ cәng giӕng lӋnh I
Thông sӕ giá trӏ là byte sӕ liӋu đưa ra cәng
Công dөng: LӋnh này đưa mӝt byte dӳ liӋu ra cәng
Ví dө: O 61 3A : Đưa giá trӏ 3A ra cәng 61
3) LӋnh L
Cú pháp:
Dҥng 1: L [address] ghi nӝi dung cӫa mӝt sӕ byte đã đưӧc chӍ đӏnh trong
thanh ghi BX:CX cӫa mӝt tӋp lên đĩa.
Dҥng 2: L address driver firstsector numer nҥp trӵc tiӃp các cung đưӧc
chӍ đӏnh
Thông sӕ address là đӏa chӍ mà ӣ đó ta muӕn nҥp tӋp hay nӝi dung cӫa
cung. NӃu không chӍ đӏnh đӏa chӍ thì Debug sӁ lҩy đӏa chӍ mһc đӏnh trong CS.
Thông sӕ Driver chӍ đӏnh ә đĩa trên đó các cung chӍ đӏnh sӁ đưӧc đӑc. Có
các giá trӏ 0=ә A, 1=ә B, 2=ә C,...
Thông sӕ Fistsector là mӝt sӕ hexa chӍ sӕ cung đӇ nҥp
Thông sӕ number là mӝt sӕ hexa chӍ sӕ các cung liên tiӃp sӁ đưӧc đӑc.

32

Công dөng: Dҥng 1 nҥp nӝi dung cӫa tӋp tin có tên N vào bӝ nhӟ cӫa máy
tính có đӏa chӍ là address. NӃu không có đӏa chӍ thì máy sӁ lҩy đӏa chӍ CS:0100.
Cһp thanh ghi BX:CX sӁ chӭa kích thưӟc tӋp.
Dҥng 2: Nҥp nӝi dung các cung trên đĩa vào bӝ nhӟ bҳt đҫu tӯ đӏa chӍ
address. Sector đҫu tiên trên đĩa cҫn đưӧc xác đӏnh trong firstsector và sӕ sector
cҫn đӑc đưӧc cho vào trong number.
Ví dө: Nҥp tӋp a.txt vào đӏa chӍ bҳt đҫu là CS:0000h
y N a.txt
y L0
Ví dө: Nҥp 5 sector đҫu tiên cӫa đĩa A vào bӝ nhӟ có đӏa chӍ là DS:0000h:
L DS:0000 0 1 5
4) LӋnh N
Cú pháp: N [driver][đưӡng dүn]<tên tӋp>
Công dөng: LӋnh này đһt tên cho tӋp sҳp ghi hay tӋp đã tӗn tҥi đӇ đӑc vào
bӝ nhӟ.
Ví dө:
N C:test.txt
R CX
100
W 0100
Hai lӋnh này sӁ ghi 100 byte bҳt đҫu tҥi đӏa chӍ 0100 vào tӋp test.txt trong ә
đĩa C.
5) LӋnh W
Cú pháp:
Dҥng 1: W[address]
Ghi nӝi dung cӫa sӕ byte đưӧc chӍ trong BX:CX bҳt đҫu tҥi address vào tӋp
có tên đưӧc đһt bӣi lӋnh N
Dҥng 2: W address driver firstsector number
Các tham sӕ giӕng lӋnh L
Ví dө: W 0000 0 200 10 : Ghi 10 sector trong bӝ nhӟ bҳt đҫu tҥi đӏa chӍ
CS:0000 vào sector thӭ 200 cӫa đĩa A.
6) LӋnh M
Cú pháp: M range address
Thông sӕ range chӍ đӏnh các đӏa chӍ bҳt đҫu hoһc kӃt thúc hay đӏa chӍ bҳt
đҫu và chiӅu dài vùng nhӟ mà ta muӕn chép nӝi dung.

33

Thông sӕ address là đӏa chӍ bҳt đҫu mà ta muӕn chép nӝi dung cӫa vùng
nhӟ range đӃn
Công dөng: Chép nӝi dung cӫa vùng nhӟ range sang vùng khác có đӏa chӍ
bҳt đҫu là address.
Ví dө: M 0100 2FE 3000:0000 : ChuyӇn vùng dӳ liӋu tӯ DS:0100 đӃn
DS:02FE sang vùng nhӟ bҳt đҫu là 3000:0000
2.2.3. Nhóm lӋnh quan sát
1) LӋnh ?
LӋnh này hiӋn nӝi dung cӫa các lӋnh cӫa Debug và chӍ dүn (lӋnh HELP)
2) LӋnh R
Cú pháp: R [register]
LӋnh này nӃu không có tham sӕ register thì nó sӁ cho hiӋn nӝi dung tҩt cҧ
các thanh ghi cӫa vi xӱ lý kӇ cҧ thanh ghi cӡ.
NӃu có tham sӕ register thì lӋnh này cho hiӋn nӝi dung cӫa thanh ghi đó và
cho phép thay đәi nӝi dung cӫa thanh ghi đó.
4) LӋnh D
Cú pháp: D [address] hay D[range]
Thông sӕ address là đӏa chӍ bҳt đҫu cӫa mӝt vùng nhӟ 128 byte đӇ hiӇn thӏ
Thông sӕ range là đҥi chӍ đҫu và đӏa chӍ cuӕi hay đӏa chӍ đҫu và đӝ dài cӫa
vùng nhӟ đӇ hiӇn thӏ.
5) LӋnh C
Cú pháp: C range address
Thông sӕ range chӍ đӏnh đӏa chӍ bҳt đҫu và kӃt thúc hay đӏa chӍ bҳt đҫu và
chiӅu dài cӫa vùng nhӟ thӭ nhҩt đӇ so sánh.
Thông sӕ address chӍ đӏnh đӏa chӍ bҳt đҫu cӫa vùng nhӟ thӭ hai cӫa khӕi
nhӟ đӇ so sánh.
Công dөng: LӋnh này sӁ so sánh hai vùng nhӟ trên nӃu giӕng nhau toàn bӝ
thì Debug không hiӋn thông báo gì cҧ. Còn nӃu không đӗng nhҩt thì Debug sӁ
hiӇn thӏ nӝi dung cӫa các ô nhӟ khác nhau.
2.2.4. Nhóm lӋnh thi hành chương trình
1) LӋnh T
Cú pháp: T [=address][value]
Thông sӕ =address chӍ đӏnh đӏa chӍ mà Debug phҧi bҳt đҫu thӵc hiӋn. NӃu
không có tham sӕ này thì Debug thӵc hiӋn tӯ đӏa chӍ trong cһp CS:IP.

34

Thông sӕ value chӍ sӕ lӋnh cҫn thӵc hiӋn, giá trӏ ngҫm đӏnh là 1
Công dөng: Thӵc hiӋn tӯng lӋnh mӝt hay mӝt sӕ các lӋnh. Sau mӛi lӋnh thì
nӝi dung các thanh ghi cӡ và thanh ghi chӭc năng đưӧc hiӋn lên màn hình cùng
vӟi câu lӋnh tiӃp theo.
2) LӋnh P
Cú pháp: P [=address][range]
Thông sӕ: Các thông sӕ giӕng lӋnh T
Công dөng: LӋnh này cũng thӵc hiӋn tӯng lӋnh mӝt giӕng lӋnh T chӍ có
mӝt điӇm khác là khi gһp lӋnh gӑi chương trình con, lӋnh lһp hay lӋnh ngҳt thì
nó thӵc hiӋn cҧ nhóm lӋnh trên.
3) LӋnh G
Cú pháp: G [=address][điӇm dӯng]
Thông sӕ address giӕng lӋnh T
Thông sӕ điӇm dӯng chӍ đӏnh điӇm dӯng cho lӋnh G
Công dөng: LӋnh này thӵc hiӋn toàn bӝ chương trình hay thӵc hiӋn tӯ đҫu
đӃn điӇm dӯng. Mӝt điӅu khác biӋt so vӟi lӋnh P và T là con trӓ lӋnh IP không
tăng.
Ví dө: G=0100 hay G : Thӵc hiӋn toàn bӝ chương trình bҳt đҫu tҥi đӏa chӍ
CS:0100
G =0100 200 : Thӵc hiӋn chương trình tӯ cs:0100 đӃn cs:0200

35

Chương 3: Các lӋnh cӫa Assembly

3.1 Các lӋnh vұn chuyӇn dӳ liӋu
Tҩt cҧ lӋnh trong nhóm này khi thӵc hiӋn không làm thay đәi trҥng thái cӫa
các bit cӡ.
1) LӋnh mov
Chͱc năng: Đưa nӝi dung tӯ SRC đӃn DST
Cú pháp: mov DST, SRC
reg1 reg2 mov ax, bx
reg data mov cx,100
reg mem mov dx,value
mem reg mov value,dx
mem data mov value,100
segreg reg16 mov ds,ax
reg16 segreg mov bx,cs
segreg mem 16 mov cs,value
mem16 segreg mov value,cs
Chú ý:
y Không đưӧc di chuyӇn giӳa hai biӃn nhӟ (mov mem1,mem2).
Thӵc hiӋn gián tiӃp:
mov reg,mem2
mov mem1,reg
y Không đưa trӵc tiӃp dӳ liӋu vào thanh ghi segment (mov seg,data).
Thӵc hiӋn gián tiӃp:
mov reg16,data
mov segreg,reg16
y Sӵ khác nhau khi sӱ dөng các chӃ đӝ đӏa chӍ
( mov ax,bx khác vӟi mov ax,[bx] ; đưa nӝi dung mà bx trӓ đӃn vào ax)
mov ax,[bx] tương đương vӟi
mov ax, ds:[bx] (SI,DI hay BP)
2) LӋnh push
Chͱc năng: cҩt 2 byte cӫa SRC vào đӍnh ngăn xӃp(stack).
Cú pháp:
PUSH SRC
Reg16

36

Mem16
Ví dө: push ax
Toán hҥng gӕc có thӇ tìm đưӧc theo các chӃ đӝ đӏa chӍ khác nhau: có thӇ là
thanh ghi đa năng, thanh ghi đoҥn hay là ô nhӟ. LӋnh này thưӡng đưӧc dùng vӟi
lӋnh POP như là mӝt cһp đӛi ngүu đӇ xӱ lý các dӳ liӋu và trҥng thái cӫa chương
trình chính(CTC) khi vào ra chương trình con(ctc).
3) LӋnh POP
Chͱc năng: lҩy 2 byte (1 tӯ) ӣ đӍnh ngăn xӃp (stack) vào toán hҥng đích.
Cú pháp:
POP DST
Reg16
Mem16
Ví dө:
push ax
push bx
push cx
Đoҥn chương trình:
Pop cx
Pop bx
Pop ax
Chú ý:
- Cơ chӃ PUSH/POP là LIPO( last in first out)
- Cách viӃt trên chӍ đưӧc sӱ dөng trong MASM còn trong TASM đưӧc viӃt
như sau:
push ax bx cx
4) LӋnh PUSHF
Chͱc năng: cҩt giá trӏ thanh ghi cӡ vào đӍnh ngăn xӃp
Cú pháp: PUSHF
Dӳ liӋu tҥi ngăn xӃp không thay đәi, SS không thay đәi.
5) LӋnh POPF
Chͱc năng: Lҩy 2 byte tӯ đӍnh ngăn xӃp rӗi đưa vào thanh ghi cӡ.
Cú pháp: POPF
Sau lӋnh này dӳ liӋu tҥi ngăn xӃp không thay đәi, SS không thay đәi.
6) LӋnh XCHG (Exchange 2 Operands) Tráo nӝi dung 2 toán hҥng
Chͱc năng: Tráo nӝi dung 2 toán hҥng DST và SRC
Cú pháp:

37

XCHG DST SRC
Reg1 Reg2
Reg Mem
Trong toán hҥng đích có thӇ tìm theo chӃ đӝ đӏa chӍ khác nhau nhưng phҧi
chӭa dӳ liӋu có cùng đӝ dài và không đưӧc phép đӗng thӡi là 2 ô nhӟ và cũng
không đưӧc là thanh ghi đoҥn. Sau lӋnh XCHG toán hҥng chӭa nӝi dung cũ cӫa
toán hҥng kia và ngưӧc lҥi.
LӋnh này không tác đӝng đӃn cӡ.
7) LӋnh IN
Chͱc năng: đӑc dӳ liӋu tӯ cәng vào thanh ghi AL/AX
Cú pháp: IN AL/AX, đӏa chӍ cәng
Chú ý:
+ NӃu đӏa chӍ cәng <256 thì sӕ đӏa chӍ đӭng trӵc tiӃp trong lӋnh IN
Ví dө: đӏa chӍ cәng là 1fh
IN AL,1fh ; nӝi dung cәng 1fh đưa vào AL.
+ NӃu đӏa chӍ cәng • 256 thì phҧi nhӡ đӃn thanh ghi DX
Ví dө: đӏa chӍ COM1 = 378h
mov dx,378h
in al,dx
8) LӋnh OUT
Chͱc năng: đưa dӳ liӋu tӯ thanh ghi AL/AX ra cәng
Cú pháp: OUT đӏa chӍ cәng,AL/AX
Chú ý:
y NӃu đӏa chӍ cәng <256 thì sӕ đӏa chӍ đӭng trӵc tiӃp trong lӋnh OUT
Ví dө: đӏa chӍ cәng là 1fh
OUT 1fh,AL ; nӝi dung cәng 1fh đưa vào AL.
y NӃu đӏa chӍ cәng • 256 thì phҧi nhӡ đӃn thanh ghi DX
Ví dө: đӏa chӍ COM1 = 378h
mov dx,378h
out dx,al
9) LӋnh LEA (load Efective address)
Chͱc năng: lҩy phҫn đӏa chӍ offset cӫa biӃn đưa vào thanh ghi 16 bit
Cú pháp: lea reg16, mem
Ví dө: lea bx, Value hay mov bx, OFFSET Value
Đích thưӡng là các thanh ghi: BX, CX, DX, BP, SI, DI.

38

Nguӗn là tên biӃn trong đoҥn DS đưӧc chӍ rõ trong lӋnh hay ô nhӟ cө thӇ.
Ví dө: lea dx, msg; Nҥp đӏa chӍ offset cӫa bҧn tin msg vào dx.

10) LӋnh LES (Load register and ES with words from memory)
Chӭc năng: chuyӇn giá trӏ cӫa 1 tӯ tӯ mӝt vùng nhӟ vào thanh ghi đích và
giá trӏ cӫa tӯ tiӃp theo sau cӫa vùng nhӟ vào thanh ghi ES.
Cú pháp: les reg, mem
Trong đó: Đích là mӝt trong các thanh ghi AX, BX,CX, DX, SP, BP, SI, DI.
Gӕc là ô nhӟ trong đoҥn DS đưӧc chӍ rõ trong lӋnh

11) LӋnh LDS (Load resgister and DS with words from memory)
Chӭc năng: Nҥp mӝt tӯ tӯ bӝ nhӟ vào thanh ghi cho trong lӋnh và 1 tӯ tiӃp
theo vào DS.
Cú pháp: lds reg, mem

3.2 Các lӋnh sӕ hӑc
1) LӋnh ADD(addition)
Chӭc năng: DST ĸDST + SRC
Cӝng hai toán hҥng: lҩy toán hҥng đích cӝng vӟi toán hҥng nguӗn rӗi đưa
vào toán hҥng đích.
Cú pháp:

39

Tác đӝng đӃn cӡ: C, P, A, Z, S, O.
2) LӋnh ADC(Add with carry)
Chӭc năng: cӝng có nhӟ, DSTĸ DST + SRC + CF
Cú pháp: adc DST, SRC
Ví dө: adc ax, bx

3) LӋnh INC(Increment Destination Register or Memory)
Chӭc năng: Tăng toán hҥng đích thêm 1. DSTĸ DST + 1
Cú pháp: inc DST
Tác đӝng đӃn cӡ: C, P, Z, S, O.
Ví dө: regĺ inc ax
memĺ inc value
4) LӋnh INC(Increment Destination Register or Memory)
Chӭc năng: Tăng toán hҥng đích thêm 1. DST ĸDST + 1
Cú pháp: inc DST
Ví dө: regĺ inc ax
memĺ inc value
5) LӋnh SUB (Substraction)
Chӭc năng: Trӯ hai toán hҥng, DSTĸ DST ± SRC
Cú pháp: sub DST, SRC
Ví dө: sub ax, bx
Chú ý: chӃ đӝ đӏa chӍ không đưӧc đӗng thӡi là 2 ô nhӟ hay là thanh ghi
đoҥn.
6) LӋnh SBB (Substraction with borrow)
Chӭc năng: Trӯ có mưӧn, DST ĸDST ± SRC ± CF
Cú pháp: sbb DST, SRC
Ví dө: sbb ax, bx

40

7) LӋnh MUL/ IMUL (Multiply Unsigned Byte or Word/ Integer
Multiplication )
Chӭc năng: Nhân 2 toán hҥng vӟi sӕ không dҩu (MUL), sӕ có dҩu (IMUL)
Cú pháp:

Có hai trưӡng hӧp tә chӭc phép nhân
y 8 bits * 8 bits
Sӕ bӏ nhân phҧi là sӕ 8 bit đӇ trong AL
Sau khi nhân: al*SRC AX
y 16 bits * 16 bits
Sӕ bӏ nhân phҧi là sӕ 16 bit đӇ trong AX
Sau khi nhân: ax*SRC dx:ax
Tác đӝng đӃn cӡ: C, O.
Chú ý:
al = 1111 1111
bl = 0000 0010
mul bl ax = al*bl (255*2 = 510)
imul bl ax = al*bl (- 1*2 = -2 )
Trong phép chia thì ax, bx, dx (al,bl,dx) là ҭn
8) LӋnh DIV/IDIV(Unsigned Divide/Integer Division)
Chӭc năng: Chia hai toán hҥng vӟi sӕ không dҩu/ sӕ có dҩu
Cú pháp:

Hai trưӡng hӧp tә chӭc phép chia
y NӃu sӕ 16 bits chia cho sӕ 8 bits

y NӃu sӕ 32 bits chia cho sӕ 16 bits

41

Trong phép chia thì ax, bx, dx (al,bl,dx) là ҭn
Ví dө:

9) LӋnh DEC (Decrement Destination Register or Memory)
Chӭc năng: Giҧm toán hҥng đích đi 1, DSTĸ DST ± 1
Cú pháp: dec DST
regĺ dec ax
mem ĺdec value
10) LӋnh NEG (Negate a Operand)
Chӭc năng: lҩy bù hai cӫa mӝt toán hҥng, đҧo dҩu cӫa mӝt toán hҥng
DST ĸ - DST
Cú pháp: neg DST
regĺ neg ax
mem ĺneg value
11) LӋnh CMP (Compare Byte or Word)
Chӭc năng: So sánh nӝi dung cӫa hai toán hҥng và dӵng cӡ. Sau khi thӵc
hiӋn lӋnh này nӝi dung cӫa hai toán hҥng không thay đәi.
Cú pháp: cmp DST, SRC
Cách dӵng cӡ:
cmp DST, SRC
y NӃu DST < SRC thì CF = 1.
y NӃu DST • SRC thì CF = 0.
y NӃu DST = SRC thì ZF = 1.
y NӃu DST SRC thì ZF = 0.

42

3.3 Các lӋnh thao tác mӭc bit
Chú ý: tҩt cҧ các lӋnh trong nhóm này khi thӵc hiӋn có thӇ làm thay đәi
trҥng thái các bit cӡ.
1) LӋnh AND
Chӭc năng: Thӵc hiӋn phép ³và logic´, bit cӫa kӃt quҧ bҵng 1 khi 2 bit
tương ӭng đӅu bҵng 1. DSTĸ DST ȁ SRC
Ví dө:
al = 1010 1010
bl = 1100 1100
and al,bl = 1000 1000
Cú pháp: and DST, SRC
Cách hay dùng:
y Tách bit:
al = xxxx xxxx
0001 0000
and al, 10h = 000x 0000
Khi dùng phép AND đӇ che đi/ giӳ lҥi mӝt vài bit nào đó cӫa mӝt toán hҥng
thì bҵng cách nhân logic toán hҥng đó vӟi toán hҥng tӭc thì có các bit0/1 ӣ các
chӛ cҫn che/ giӳ nguyên tương ӭng.
y Dӵng cӡ and DST,DST
Ví dө: and ax, ax
NӃu ax < 0 thì SF = 1.
NӃu ax • 0 thì SF = 0.
NӃu ax = 0 thì ZF = 1.
NӃu ax 0 thì ZF = 0.
2) LӋnh OR
Chӭc năng: thӵc hiӋn phép hoһc logic, Bit cӫa kӃt quҧ = 1 khi 1 trong 2 bit
là 1.
DST ĸDST V SRC
Ví dө:
al = 1010 1010
bl = 1100 1100
or al,bl = 1110 1110
Cú pháp: or DST, SRC
Tác đӝng đӃn cӡ: C = O = 0, P, Z, S.
3) LӋnh XOR

43

Chӭc năng: Thӵc hiӋn phép ³hoһc loҥi trӯ´ 2 toán hҥng, bit cӫa kӃt quҧ
bҵng 1 khi 2 bit tương ӭng khác nhau.
Ví dө:
al = 1010 1010
bl = 1100 1100
xor al,bl = 0110 0110
Cú pháp: xor DST, SRC
Cách hay dùng:
y Tách bit:
al = xxxx xxxx
0001 0000
and al, 10h = 000x 0000
Tác đӝng đӃn cӡ: C = O = 0, P, Z, S.
Ví dө: Thӵc hiӋn ax = 0
1. mov ax,0 ; 3 byte
2. and ax,0
3. sub ax,ax ; 2 byte
4. xor ax,ax
4) LӋnh SHL (Shift Left)
Chӭc năng: dӏch trái các bit cӫa toán hҥng đích đi mӝt sӕ lҫn nào đó (sӕ lҫn
dӏch đưӧc cҩt trong thanh ghi CL).
Cú pháp: SHL DST, CL
(reg, mem)

Mӛi mӝt lҫn dӏch MSB sӁ đưa qua cӡ CF và đưa 0 vào LSB. CL chӭa sӕ lҫn
dӏch mong muӕn.
NӃu dӏch mӝt lҫn thì ta có thӇ viӃt trӵc tiӃp.
VD: shl ax,1
NӃu sӕ lҫn dӏch • 2 thì phҧi nhӡ đӃn CL/CX
shl ax, 4 Ł mov cl/cx, 4
shl ax, cl/cx
Ý nghĩa: Dӏch trái 1 lҫn là nhân 2 vӟi sӕ nguyên dương.
5) LӋnh SHR (Shift Right)

44

Chӭc năng: dӏch phҧi logic các bit cӫa toán hҥng đích đi mӝt sӕ lҫn nào đó
(sӕ lҫn dӏch đưӧc cҩt trong thanh ghi CL).
Cú pháp: SHR DST, CL
(reg, mem)

Mӛi mӝt lҫn dӏch LSB sӁ đưa qua cӡ CF và đưa 0 vào MSB. CL chӭa sӕ lҫn
dӏch mong muӕn.
VD: shr ax,1
NӃu sӕ lҫn dӏch • 2thì phҧi nhӡ đӃn CL/CX
shr ax, 4 Ł mov cl/cx, 4
shr ax, cl/cx
Ý nghĩa: Dӏch phҧi 1 lҫn là chia đôi và làm tròn dưӟi vӟi sӕ nguyên dương
6) LӋnh SAR ( Shift Arithmetically Right)
Chӭc năng: dӏch phҧi sӕ hӑc các bit cӫa toán hҥng đích đi mӝt sӕ lҫn nào đó
(sӕ lҫn dӏch đưӧc cҩt trong thanh ghi CL).
Cú pháp: SAR DST, CL
(reg, mem)

Mӛi mӝt lҫn MSB đưӧc giӳ lҥi ( nӃu ta hiӇu đây là bit dҩu cӫa mӝt sӕ nào
đó thì dҩu luôn không đәi sau phép dӏch phҧi sӕ hӑc) còn LSB đưӧc đưa vào cӡ
CF. CL chӭa sҹn sӕ lҫn dӏch mong muӕn.
VD:sar ax,1
NӃu sӕ lҫn dӏch • 2thì phҧi nhӡ đӃn CL/CX
sar ax, 4 Ł mov cl/cx, 4
sar ax, cl/cx
Ý nghĩa: Dӏch phҧi 1 lҫn là chia đôi và làm tròn dưӟi vӟi sӕ có dҩu.
7) LӋnh ROL( Rotate All Bits to the Left)

45

Chӭc năng: quay vòng sang trái các bit cӫa toán hҥng đích đi mӝt sӕ lҫn nào
đó (sӕ lҫn dӏch đưӧc cҩt trong thanh ghi CL). Trong mӛi lҫn quay giá trӏ bit cao
nhҩt vӯa chuyӇn vào thanh ghi cӡ CF đӗng thӡi chuyӇn vào bit thҩp nhҩt
Cú pháp: ROL DST, CL
(reg, mem)

VD:rol ax,1
8) LӋnh ROR
Chӭc năng: quay vòng sang phҧi các bit cӫa toán hҥng đích đi mӝt sӕ lҫn
nào đó (sӕ lҫn dӏch đưӧc cҩt trong thanh ghi CL). Trong mӛi lҫn quay giá trӏ bit
thҩp LSB nhҩt vӯa chuyӇn vào thanh ghi cӡ CF đӗng thӡi chuyӇn vào bit cao
nhҩt MSB.
Cú pháp: ROR DST, CL
(reg, mem)

VD:ror ax,1

3.4 Các lӋnh thao tác vӟi dãy (chuӛi)
Chú ý: ChӍ có 2 lӋnh trong nhóm này khi thӵc hiӋn làm thay đәi các bit cӡ.
1) LӋnh MOVSB/MOVSW (Move String Byte or String Word)
Chӭc năng: ChuyӇn mӝt xâu ký tӵ theo tӯng byte(MOVSB) hay theo tӯng
tӯ (MOVSW) tӯ vùng nhӟ trӓ bӣi DS:SI sang vùng nhӟ trӓ bӣi ES:DI. Sau mӛi
lҫn dӏch chuyӇn thì giá trӏ cӫa SI, DI tӵ đӝng tăng lên 1 hoһc 2 khi cӡ hưӟng DF
= 0 hoһc giҧm đi 1 hoһc 2 khi DF = 1.
Phҫn tӱ cӫa Chuӛi đíchĸ Phҫn tӱ cӫa Chuӛi gӕc
Cú pháp: MOVSB hoһc MOVSW

46

Chuҭn bӏ trưӟc ds:si con trӓ đӃn đҫu xâu SRC, es:di con trӓ đӃn đҫu xâu
DST
2) LӋnh LODSB/LODSW (Load String Byte or Word into AL/AX)
Chӭc năng: ChuyӇn các kí tӵ theo tӯng byte (LODSB) hay theo tӯng tӯ
(LODSW) tӯ vùng nhӟ trӓ bӣi DS:SI vào AL/AX.
Cú pháp: LODSB hoһc LODSW
Chuҭn bӏ trưӟc ds:si con trӓ ӣ đҫu xâu, df = 0 hay df = 1.
3) LӋnh STOSB/STOSW (Store AL/AX in String Byte/Word)
Chӭc năng: ChuyӇn các kí tӵ nҵm ӣ AL(STOSB) /AX (STOSW) vào vùng
nhӟ trӓ bӣi ES:DI.
Cú pháp: STOSB hoһc STOSW hoһc STOS Chuӛi đích.
Xác lұp trưӟc ES:DI trӓ đӃn đҫu vùng nhӟ, df = 0 hay df = 1.
Nhұn xét
1. movsb = lodsb + stosb
2. movsw = lodsw + stosw
4) LӋnh CMPSB/CMPSW
Chӭc năng: So sánh hai xâu kí tӵ theo tӯng byte (CMPSB) / theo tӯng tӯ
(CMPSW) giӳa hai vùng nhӟ trӓ bӣi DS:SI và ES:DI. LӋnh này chӍ tҥo cӡ,
không lưu lҥi kӃt quҧ so sánh, sau khi so sánh các toán hҥng không bӏ thay đәi.
Cú pháp: CMPSB hoһc CMPSW hoһc STOS Chuӛi đích.
Xác lұp trưӟc DS:SI trӓ đӃn đҫu xâu 1, ES:DI trӓ đӃn đҫu xâu 2, df = 0 hay
df = 1.
Tác đӝng đӃn cӡ: ZF = 1 khi hai xâu bҵng nhau, ZF = 0 khi hai xâu khác
nhau.
5) TiӅn tӕ REP (Repeat String Instruction until CX = 0).
Chӭc năng: Lһp đi lһp lai lӋnh làm viӋc vӟi xâu kí tӵ đҵng sau nó cho đӃn
khi cx = 0. Sau mӛi lҫn thӵc hiӋn cx tӵ đӝng giҧm đi 1
Cú pháp: mov cx, sӕ lҫn

47

rep lӋnh làm viӋc vӟi xâu ; rep movsb

Thuұt toán
1. DS:SI
2. ES:DI
3. D = 0
4. CX = 5
5. rep movsb; sau mӛi lҫn cx = cx ± 1 cho đӃn khi cx = 0.

3.5 Các lӋnh nhҧy ± ChuyӇn điӅu khiӇn
1) LӋnh Call
Chӭc năng: Gӑi chương trình con
Cú pháp

2) LӋnh RET
Chӭc năng: quay vӅ chương trình đã gӑi chương trình con
Cú pháp: RET (nҵm ӣ cuӕi chương trình con)
3) LӋnh INT
Chӭc năng: Kích hoҥt mӝt ngҳt (chuyӇn sang chҥy chương trình con phөc
vө ngҳt) (Ngҳt mӅm).
Cú pháp: int n (sӕ ngҳt viӃt theo sӕ hexa)
Ví du: int 21h = int 33
Các ngҳt hay dùng hӛ trӧ cho lұp trình Assembler
y Hàm 1: Chӡ 1 kí tӵ
mov ah,1 ; gán ah = 1 al chӭa mã ASCII
; al = 0 khi kí tӵ gõ vào là các phím chӭc năng.
int 21h
y Hàm 2: HiӋn 1 ký tӵ lên màn hình tӯ vӏ trí con trӓ đang đӭng.

48

Cách 1:
mov al, mã ASCII
mov ah,0eh
int 10h
Cách 2:
mov dl, mã ASCII
; dl = mã ASCII cӫa kí tӵ cҫn hiӇn thӏ
mov ah,2
int 21h
y Hàm 3: HiӋn xâu kí tӵ kӃt thúc µ$¶ lên màn hình.
lea dx, tên biӃn xâu
; mov dx,offset tên biӃn xâu
mov ah,9
int 21h
y Hàm 4: Trӣ vӅ DOS
mov ah,4ch
int 21h
4) LӋnh IRET
Chӭc năng: quay vӅ chương trình đã kích hoҥt nó tӯ chương trình con phөc
ngҳt.
Cú pháp: IRET
- LӋnh JMP (go to)
Chӭc năng: nhҧy không điӅu kiӋn
Cú pháp:

Chú ý: Bưӟc nhҧy cӫa lӋnh jump < 64k
5) LӋnh nhҧy có điӅu kiӋn
Vӟi sӕ không có dҩu Vӟi sӕ có dҩu Nhҧy theo trҥng thái các
(Below/above) (Less/ greater) bit cӡ
Cmp DST, SRC Cmp DST, SRC
Jb/jnae Nhãn KhiDST dưӟi Jl/jnge Nhãn Khi jc Nhãn Khi
Đӏa chӍ SRC Đӏa chӍ DST<SRC Đӏa chӍ CF=1
Jbe/jna Nhãn Khi DST Jle/jng Nhãn Khi jnc Nhãn Khi
Đӏa chӍ dưӟi SRC Đӏa chӍ DST”SRC Đӏa chӍ CF=0
hoһc =
Je Nhãn Khi Je Nhãn Khi jz Nhãn Khi

49

Đӏa chӍ DST= SRC Đӏa chӍ DST= SRC Đӏa chӍ ZF=1
Jne Nhãn Khi Jne Nhãn Khi jnz Nhãn Khi
Đӏa chӍ DST SRC Đӏa chӍ DST SRC Đӏa chӍ ZF=0
Ja/jnbe Nhãn Khi DST trên Jg/jnle Nhãn Khi js Nhãn Khi
Đӏa chӍ SRC Đӏa chӍ DST > SRC Đӏa chӍ SF=1
Jae/jnb Nhãn Khi DST trên Jge/jnl Nhãn Khi jns Nhãn Khi
Đӏa chӍ /=SRC Đӏa chӍ DST •SRC Đӏa chӍ SF=0
Chú ý: Bưӟc nhҧy các lӋnh nhҧy có điӅu kiӋn phҧi nhӓ hơn hoһc bҵng 128
byte
6) LӋnh LOOP (for cӫa ASM)
Chӭc năng: lһp đi lһp lҥi khӕi lӋnh ASM nҵm giӳa nhãn và loop cho đӃn khi
cx = 0. Mӛi khi thӵc hiӋn mӝt vòng lһp giá trӏ cӫa CX giҧm đi 1.
Cú pháp:
mov cx, sӕ lҫn lһp; sӕ lҫn lһp • 1
Nhan:
Khӕi lӋnh ASM
Loop Nhan

3.6 Các lӋnh thao tác vӟi cӡ và điӅu khiӇn bӝ
1) LӋnh CLC (Clear CF)
Chӭc năng: Xoá giá trӏ cӡ CF vӅ 0, CF = 0
Cú pháp: CLC
Cӡ C = 0
2) LӋnh STC
Chӭc năng: Đưa giá trӏ cӡ CF lên 1, CF = 1
Cú pháp: STC
Cӡ C = 1
3) LӋnh CMC
Chӭc năng: Đҧo giá trӏ hiӋn thӡi cӫa cӡ CF.
Cú pháp: CMC
Tác đӝng đӅn cӡ C.
4) LӋnh CLI
Chӭc năng: Xoá giá trӏ cӫa cӡ IF vӅ 0(IF = 0). Cҩm toán bӝ các ngҳt cӭng
trӯ ngҳt MNI.
Cú pháp: CLI
Cӡ IF = 0.
5) LӋnh STI
Chӭc năng: Đưa giá trӏ cӫa cӡ IF lên1 (IF = 1). Cho phép ngҳt cӭng.
Cú pháp: STI

50

Cӡ IF = 1.
6) LӋnh CLD
Chӭc năng: Xoá giá trӏ cӫa cӡ DF vӅ 0 (DF = 0).
Cú pháp: CLD
Cӡ DF = 0, dӵng cӡ.
7) LӋnh STD
Chӭc năng: Đưa giá trӏ cӫa cӡ DF lên1 (DF = 1).
Cú pháp: STD
Cӡ DF = 1.
8) LӋnh HLT
Chӭc năng: dӯng máy
Cú pháp: HLT
9) LӋnh NOP
Chӭc năng: lӋnh này không thӵc hiӋn gì cҧ
Cú pháp: NOP (4ȝs)
Ý nghĩa:
Tҥo trӉ (delay)

Tҥo vòng chӡ vô tұn đӇ chӡ ngҳt.
L1: nop
jmp L1

51

Chương 4 Chương trình con và chương trình đa tӋp
4.1 Thӫ tөc ± Chương trình con
Trong các chương trình cӥ lӟn, viӋc module hóa đӇ cho chương trình có cҩu
trúc sáng sӫa, dӉ debug và tiӃt kiӋm thӡi gian viӃt mã là mӝt viӋc hӃt sӭc quan
trӑng. ĐӇ có thӇ module hóa đưӧc chương trình chúng ta cҫn phҧi sӱ dөng mӝt
trong các công cө rҩt hӳu hiӋu đó là thӫ tөc ± chương trình con. Chương trình
con là mӝt đoҥn các mã lӋnh đưӧc gӝp lҥi và đưӧc đһt tên, thông qua tên (bҵng
cách gӑi tên), chúng ta có thӇ sӱ dөng lҥi mӝt đoҥn mã lӋnh ӣ bҩt cӭ nơi nào ta
cҫn trong chương trình thay vì phҧi viӃt lҥi hoàn toàn đoҥn mã lӋnh đó.

4.1.1 Cơ chӃ làm viӋc cӫa chương trình con
Nói chung cơ chӃ làm viӋc cӫa chương trình con trong ASM không khác gì
nhiӅu so vӟi các ngôn ngӳ bұc cao khác.
Cơ chӃ có 5 bưӟc :
- Bưӟc 1: Tham sӕ thӵc đưa vào stack
- Bưӟc 2: Đӏa chӍ lӋnh tiӃp theo đưa vào stack
- Bưӟc 3: HӋ điӅu hành biӃt đưӧc đӏa chӍ đҫu cӫa chương trình con. Do vұy
hӋ điӅu hành đưa đӏa chӍ đҫu cӫa chương trình con vào CS:IP rӁ nhánh vào
chương trình con.
- Bưӟc 4: Thӵc hiӋn chương trình con cho đӃn khi gһp return thì vào stack
lҩy đӏa chӍ lӋnh tiӃp theo (đã cҩt ӣ bưӟc 2 đӇ đưa vào CS:IP) và quay vӅ chương
trình đã gӑi nó.
- Bưӟc 5: tiӃp tөc chương trình đang thӵc hiӋn dӣ.

4.1.2 Cҩu trúc cӫa chương trình con
Tên chương trình con PROC [near/far]
Bҧo vӋ các thanh ghi mà thân chương trình con phá vӥ.
Các lӋnh ASM cӫa thân chương trình con.
Hӗi phөc các thanh ghi mà thân chương trình con đã phá vӥ.
RET

52

Tên chương trình con ENDP
Nhұn xét:
1. Chương trình con thuҫn tuý ASM không có tham sӕ.
2. Vҩn đӅ near/ far
- Chương trình con là near khi mã máy cӫa chương trình con và mã máy cӫa
chương trình chính là cùng nҵm trong 1 segment, đӏa chӍ cӫa chương trình con và
chương trình chính chӍ khác nhau phҫn đӏa chӍ offset. Cho nên đӏa chӍ lӋnh tiӃp
theo cҩt váo stack chӍ cҫn 2 byte offset.
- Chương trình con là far khi mã máy cӫa chương trình con và mã máy cӫa
chương trình chính nҵm trên các segment khác nhau, đӏa chӍ cӫa chương trình
con và chương trình chính khác nhau cҧ vӅ phҫn đӏa chӍ segment. Cho nên đӏachӍ
lӋnh tiӃp theo cҩt vào stack phҧi cҫn 4 byte offset.
Default:
- Vӟi chương trình đưӧc khai báo directive dҥng đơn giҧn thì directive
MODEL sӁ cho biӃt chương trình con là near hay far
NӃu .MODEL tiny/small/compact thì chương trình con là NEAR(mã máy<
64k)
NӃu .MODEL medium/large/huge thì chương trình con là FAR(mã
máy>64k
- Vӟi chương trình con đưӧc viӃt theo directive dҥng chuҭn thì mһc đӏnh là
near. Còn muӕn chương trình con là far thì phҧi viӃt far khi viӃt chương trình
con.

4.1.3 Vҩn đӅ chuyӇn giao tham sӕ
Trong chương trình con cӫa hӧp ngӳ không có tham sӕ hình thӭc vì vұy mà
viӋc trao đәi dӳ liӋu giӳa chương trình con và chương trình chính gӑi nó đưӧc
thӵc hiӋn thông qua 3 cách sau:
y ChuyӇn tham sӕ thông qua các thanh ghi: Cách này đơn giҧn và dӉ viӃt
thưӡng đưӧc sӱ dөng trong các chương trình thuҫn túy ASM. Vӟi cách
này ta chӍ cҫn đһt mӝt giá trӏ vào thanh ghi nào đó trong chương trình
chính sau đó gӑi chương trình con và chương trình con sӁ sӱ dөng đưӧc
giá trӏ trong thanh ghi đó. Nó giӕng như ta đưa các chӭc năng con vào
thanh ghi AH trưӟc khi gӑi ngҳt cӫa hӋ thӕng, đó cũng là mӝt cách
truyӅn tham sӕ cho chương trình con thông qua thanh ghi.

53

Link asm in another language

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (18)

Destaque

Destaque (20)

Semelhante a Link asm in another language

Semelhante a Link asm in another language (20)

Link asm in another language