Giáo trình Vi xử lý (Phần 1)

Tr−êng ®¹i häc s− ph¹m kü thuËt h−ng yªn 
Khoa C«ng nghÖ Th«ng tin 
W™X 
Gi¸o tr×nh häc phÇn 
Vi xö lý 
(HÖ §¹i häc) 
 Tµi liÖu l−u hµnh néi bé 
H−ng Yªn 2005 
Giáo trình VI XỬ LÝ  
Bộ môn Kỹ thuật máy tính – Khoa CNTT – ĐHSPKT_HY  
MỤC LỤC 
Chương 1. BỘ VI XỬ LÝ 8086/8088 ..2 
1.1. Tổng quan về các bộ vi xử lý của Intel ..................................................................... 2 
1.2. Cấu trúc bộ vi xử lý 8086 .......................................................................................... 3 
1.2.1. Sơ đồ khối ........................................................................................................... 3 
1.2.2. Giải thích các thành phần trong sơ đồ ................................................................ 3 
1.2.3. Một số khái niệm cơ bản ..................................................................................... 4 
1.3. Tập thanh ghi của bộ vi xử lý 8086........................................................................... 5 
1.3.1. Các thanh ghi dữ liệu .......................................................................................... 5 
1.3.2. Các thanh ghi đoạn: CS, DS, ES, SS .................................................................. 6 
1.3.3. Các thanh ghi con trỏ và chỉ số: SI, DI, SP, BP ................................................. 6 
1.3.4. Thanh ghi con trỏ lệnh: IP .................................................................................. 7 
1.3.5. Thanh ghi cờ ....................................................................................................... 7 
1.4. Tập lệnh của bộ vi xử lý ............................................................................................ 7 
1.4.1. Sơ lược về tập lệnh của bộ vi xử lý .................................................................... 7 
1.4.2. Tập lệnh của CPU ............................................................................................... 8 
1.4.3. Nhóm lệnh di chuyển dữ liệu .............................................................................. 8 
1.4.4. Nhóm lệnh số học ............................................................................................. 10 
1.4.5. Nhóm lệnh logic ............................................................................................... 11 
1.4.6. Nhóm lệnh dịch chuyển và quay ...................................................................... 12 
1.4.7. Nhóm lệnh điều khiển rẽ nhánh ........................................................................ 13 
1.4.8. Nhóm lệnh vào ra cổng ..................................................................................... 14 
1.4.9. Nhóm lệnh điều khiển ....................................................................................... 14 
1.5. Chế độ địa chỉ của bộ vi xử lý 8086........................................................................ 14 
1.5.1. Tổng quan ......................................................................................................... 14 
1.5.2. Các chế độ địa chỉ dữ liệu ................................................................................. 15 
1.5.3. Chế độ địa chỉ thanh ghi ................................................................................... 15 
1.5.4. Chế độ địa chỉ tức thì ........................................................................................ 15 
1.5.5. Chế độ địa chỉ trực tiếp ..................................................................................... 15 
1.5.6. Chế độ địa chỉ gián tiếp thanh ghi .................................................................... 16 
1.5.7. Chế độ địa chỉ tương đối cơ sở(Base Relative Addressing) ............................. 16 
1.5.8. Chế độ địa chỉ tương đối chỉ số(Indexed Relative Addressing) ....................... 17 
1.5.9. Chế độ địa chỉ tương đối chỉ số cơ sở(Base Indexed Relative) ........................ 17 
1.5.10. Bảng tóm tắt các chế độ địa chỉ ...................................................................... 18 
1.6. Phân tích mã lệnh mã máy ...................................................................................... 18 
1.6.1. Khuôn dạng lệnh ............................................................................................... 18 
1.6.2. Một số mã lệnh mã máy .................................................................................... 20 
1.6.3. Một số ví dụ minh họa ...................................................................................... 21 
1.7. Lập trình và gỡ rối bằng DEBUG ........................................................................... 22 
1.7.1. Giới thiệu về lệnh của DEBUG ........................................................................ 22 
1.7.2. Lập trình bằng DEBUG .................................................................................... 24 
1.7.3. Gỡ rối chương trình bằng DEBUG ................................................................... 25 
Chương 2. CÁC BỘ VI XỬ LÝ TIÊN TIẾN CỦA INTEL ........................................ 26 
2.1. Bộ vi xử lý 80286 .................................................................................................... 26 
2.1.1. Các thanh ghi .................................................................................................... 26 
2.1.2. Tập lệnh ............................................................................................................ 27 
Giáo trình VI XỬ LÝ  
Bộ môn Kỹ thuật máy tính – Khoa CNTT – ĐHSPKT_HY  
2.2. Bộ vi xử lý 80386 .................................................................................................... 28 
2.2.1. Sơ đồ khối của 80386 ....................................................................................... 28 
2.2.2. Các thanh ghi .................................................................................................... 28 
2.2.3. Quản lý bộ nhớ ................................................................................................. 30 
2.2.4. Tập lệnh ............................................................................................................ 32 
2.3. Bộ vi xử lý 80486 .................................................................................................... 32 
2.3.1. Các phần tử xử lý CISC và RISC ..................................................................... 32 
2.3.2. Vi xử lý 80486 .................................................................................................. 33 
2.4. Các bộ vi xử lý Intel Pentium ................................................................................. 35 
2.4.1. Đặc điểm chung ................................................................................................ 35 
2.4.2. Cấu trúc và tính năng ........................................................................................ 35 
2.5. Bộ đồng xử lý toán 80x87 ....................................................................................... 39 
2.5.1. Sơ lược về các số thực ...................................................................................... 39 
2.5.2. Cấu trúc của 8087 ............................................................................................. 39 
2.5.3. Tập lệnh của 8087 ............................................................................................. 39 
2.6. Cấu trúc và chức năng của 8087 ............................................................................. 39 
2.6.1. Sơ đồ khối bên trong của 8087 ......................................................................... 39 
2.6.2. Nối 8087 với CPU ............................................................................................ 42 
2.7. Đồng xử lý 80287 ................................................................................................ 42 
Chương 3. CẤU TRÚC LẬP TRÌNH ASSEMBLY ................................................... 43 
3.1. Tổng quan về ngôn ngữ lập trình ASSEMBLY ...................................................... 43 
3.1.1. Khái niệm .......................................................................................................... 43 
3.1.2. So sánh hợp ngữ với các ngôn ngữ bậc cao ...................................................... 43 
3.2. Các đoạn trong một chương trình ........................................................................... 44 
3.3. Cấu trúc chung của một lệnh ASSEMBLY ............................................................ 44 
3.4. Khai báo dữ liệu và kiểu dữ liệu ............................................................................. 45 
3.4.1. Biến byte ........................................................................................................... 45 
3.4.2. Biến Word ......................................................................................................... 46 
3.4.3. Biến mảng ......................................................................................................... 46 
3.4.4. Biến chuỗi ......................................................................................................... 47 
3.5. Khung của một chương trình ASSEMBLY ............................................................ 47 
3.5.1. Cấu trúc chương trình để dịch ra tệp *.EXE..................................................... 47 
3.5.2. Cấu trúc chương trình để dịch ra tệp *.COM ................................................... 50 
3.6. Cách tạo một chương trình hợp ngữ ....................................................................... 52 
Chương 4. CÁC CẤU TRÚC LẬP TRÌNH .............................................................. 55 
4.1. Tổng quan ................................................................................................................ 55 
4.1.1. Các lệnh chuyển điều khiển .............................................................................. 55 
4.2. Cấu trúc tuần tự ....................................................................................................... 56 
4.3. Cấu trúc rẽ nhánh .................................................................................................... 57 
4.3.1. Cấu trúc IFTHEN ..................................................................................... 57 
4.3.2. Cấu trúc IF..THENELSE .............................................................................. 58 
4.3.3. Cấu trúc rẽ nhánh CASEOF ..................................................................... 59 
4.3.4. Cấu trúc rẽ nhánh với điều kiện kép ................................................................. 60 
4.4. Cấu trúc lặp ............................................................................................................. 61 
4.4.1. Cấu trúc FORTODO ............................................................................. 61 
4.4.2. Cấu trúc WHILEDO ................................................................................. 62 
Giáo trình VI XỬ LÝ  
Bộ môn Kỹ thuật máy tính – Khoa CNTT – ĐHSPKT_HY  
4.4.3. Cấu trúc REPEATUNTIL ........................................................................ 63 
4.5. Cấu trúc chương trình con ....................................................................................... 63 
4.5.1. Cấu trúc của chương trình con .......................................................................... 64 
4.5.2. Cách gọi và thực hiện một chương trình con .................................................... 66 
4.6. MACRO .................................................................................................................. 67 
4.6.1. Định nghĩa MACRO ......................................................................................... 67 
4.6.2. Gọi MACRO trong chương trình ...................................................................... 68 
4.6.3. Gọi MACRO từ đoạn chương trình khác ......................................................... 70 
Chương 5. MỘT SỐ VẤN ĐỀ NÂNG CAO ............................................................. 72 
5.1. Lập trình xử lý số nguyên ....................................................................................... 72 
5.2. Cấu trúc dữ liệu mảng ............................................................................................. 72 
5.2.1. Khai báo mảng .................................................................................................. 72 
5.2.2. Sử dụng mảng ................................................................................................... 73 
5.3. Cấu trúc dữ liệu xâu ký tự ....................................................................................... 75 
5.3.1. Cờ định hướng .................................................................................................. 75 
5.3.2. Lệnh chuyển đổi một chuỗi .............................................................................. 76 
5.3.3. Lệnh lưu chuỗi .................................................................................................. 77 
5.3.4. Lệnh nạp chuỗi ................................................................................................. 77 
5.4. Lập trình xử lý số thực ............................................................................................ 80 
5.5. Lập trình cho các bộ vi xử lý tiên tiến .................................................................... 80 
Chương 6. LIÊN KẾT ASSEMBLY VỚI CÁC NGÔN NGỮ BẬC CAO .................. 80 
6.1. Lập trình mã lệnh mã máy ...................................................................................... 80 
6.1.1. Cú pháp ............................................................................................................. 81 
6.1.2. Thực hiện .......................................................................................................... 81 
6.1.3. Một số chú ý ..................................................................................................... 81 
6.1.4. Ví dụ ................................................................................................................. 81 
6.2. Lập trình mã lệnh gợi nhớ ....................................................................................... 83 
6.2.1. Chèn khối lệnh ASSEMBLY............................................................................ 83 
6.3. Ngắt và lập trình ngắt trong ngôn ngữ bậc cao ....................................................... 85 
6.3.1. Khái niệm về ngắt ............................................................................................. 85 
6.3.2. Phân loại ngắt ................................................................................................... 86 
6.3.3. Giới thiệu về một số ngắt .................................................................................. 86 
Giáo trình VI XỬ LÝ  
Bộ môn Kỹ thuật máy tính – Khoa CNTT – ĐHSPKT_HY Trang 2 
Phần I 
BỘ VI XỬ LÝ 
Chương 1. BỘ VI XỬ LÝ 8086/8088 
1.1. Tổng quan về các bộ vi xử lý của Intel 
Một hệ vi xử lý được gọi là một hệ thống trong đó ... a nội dung của biến khi thực hiện chương trình. 
 Trong lập trình với hợp ngữ, người ta có thể mô tả đoạn dữ liệu với việc khai báo 
vị trí bắt đầu của đoạn là: .DATA 
c/ Đoạn ngăn xếp 
 Đoạn này được sử dụng để chứa dữ liệu truy xuất theo phương thức "Vào trước 
Ra sau - First In Last Out - FILO" 
 Trong lập trình với hợp ngữ, người ta có thể mô tả đoạn ngăn xếp với việc khai 
báo bằng một tên: .Stack với độ dài đoạn ngăn xếp. Thường thì độ dài tối đa là 256 byte. 
3.3. Cấu trúc chung của một lệnh ASSEMBLY 
 Một lệnh của hợp ngữ dù đơn giản hay phức tạp đều phải có đầy đủ một trong 
các thành phần sau: 
[Tên] [Mã lệnh] [Các toán hạng] [;chú thích] 
Trong đó: 
Tên - có thể là tên một chương trình con, một macro, một nhãn hoặc một thành phần 
nào đó. 
Mã lệnh - Cơ bản trường này chứa mã lệnh dưới dạng mã gợi nhớ. Có thể là lệnh 
thật hoặc lệnh giả. 
Nếu là lệnh thật thì đây là các lệnh của bộ vi xử lý. 
Nếu là các lệnh giả thì đây là các dẫn hướng của chương trình dịch. Ví dụ PROC, 
MACRO, ENDP, ENDM, SEGMENT, ENDS... 
Các toán hạng - Là các thành phần mà các lệnh sử dụng để thực hiện lệnh. 
Giáo trình VI XỬ LÝ  
Bộ môn Kỹ thuật máy tính – Khoa CNTT – ĐHSPKT_HY Trang 45 
Nếu là các lệnh thật thì đây chính là các toán hạng của lệnh. Với bộ vi xử lý 
8086/8088, các toán hạng này có thể là 0,1 hoặc 2. 
Nếu là các lệnh giả thì đây là các tham số. Số lượng tham số tuỳ thuộc vào việc 
khai báo các dẫn hướng. 
Chú thích - là lời giải thích để người sử dụng hiểu rõ hơn về lệnh. Lời chú thích phải 
được bắt đầu bởi dấu (;) và chúng sẽ không được chương trình dịch xử lý. 
Ví dụ: 
Lap: ADD AL,[BX] ;Cộng giá trị trong thanh ghi AL với ô nhớ có địa chỉ là 
DS:BX. 
 ;Kết quả được đưa vào thanh ghi AL. 
Với ví dụ trên, thi lap la tên một nhãn và kết thúc bằng dấu (:); ADD là lệnh thực 
hiện phép cộng; AL và [BX] là hai toán hạng với qui định nếu tên thanh ghi hoặc một giá 
trị hằng nằm trong dấu [] thì đó là địa chỉ OFFSET của ô nhớ chứa dữ liệu cần thao tác; 
các thành phần sau dấu (;) chỉ là lời chú thích. 
3.4. Khai báo dữ liệu và kiểu dữ liệu 
 Như chúng ta đã thấy qua hai ví dụ trên, khi khai báo dữ liệu cho chương trình, 
người ta thường sử dụng toán tử DB. Nhưng, trên thực tế, các toán tử khác cũng có thể 
được dùng đến để khai báo cho các dữ liệu có kiểu khác nhau. 
DB - Define Byte - Định nghĩa biến kiểu Byte 
DW - Define Word - Định nghĩa biến kiểu Word 
DD - Define Double Word - Định nghĩa biến kiểu Double Word 
DT - Define Ten Byte - Định nghĩa biến kiểu 10 byte 
EQU - Equal (Bằng) - Khai báo một hằng, địa chỉ cổng xác định. 
 Vậy, chúng ta có thể sử dụng các toán tử trên để khai báo cho các biến và hằng ra 
sao? Thể hiện các dạng cấu trúc dữ liệu như thế nào? 
3.4.1. Biến byte 
Biến kiểu byte sẽ chiếm 1 byte trong bộ nhớ. Hướng dẫn chương trình dịch để định nghĩa 
biến kiểu byte có dạng tổng quát như sau: 
 Tên BD giá_trị_khởi_tạo 
Ví dụ: so1 DB 3Eh 
Trong ví dụ trên, so1 là một biến kiểu byte có giá trị khởi tạo là 3Eh. Song, đôi khi chúng 
ta không cần thiết phải khởi tạo giá trị cho biến, có thể sử dụng cách khai báo sau: 
 so2 DB ? 
Cũng như các ngôn ngữ lập trình khác, một biến kí tự cũng được coi là một biến kiểu 
byte với mỗi một kí tự được thể hiện bằng mã ASCII của chúng từ 0 - FFh 
Giả sử, muốn khai báo một biến kí tự và khởi tạo giá trị bằng ‘A’, ta có thể thực hiện 
bằng một trong hai cách sau: 
Giáo trình VI XỬ LÝ  
Bộ môn Kỹ thuật máy tính – Khoa CNTT – ĐHSPKT_HY Trang 46 
Ch DB ‘A’ ;khởi tạo trực tiếp giá trị ‘A’ 
Hoặc: Ch DB 41h ;khởi tạo thông qua mã ASCII của ‘A’ 
3.4.2. Biến Word 
Để khai báo biến kiểu từ (Word), chúng ta có thể sử dụng cú pháp sau: 
 tên DW giá_trị_khởi_tạo 
Cũng giống như việc khai báo biến kiểu byte, giá_trị_khởi_tạo có thể là dấu (?) để không 
khởi tạo giá trị cho biến. 
Ví dụ: 
 1/ w1 DW 3FB4h ;khai báo biến w1 với giá trị khởi tạo là 3FB4h 
 2/ w2 DW ? ;không khởi tạo giá trị cho biến w2 
3.4.3. Biến mảng 
Mảng là một danh sách (dãy) các phần tử có cùng một kiểu với các giá trị (có thể) khác 
nhau. Vì vậy, để khai báo một mảng, chúng ta có thể thực hiện theo cú pháp sau: 
 Tên DB danh_sách_giá_trị_khởi_tạo ;khai báo mảng các phần tử kiểu byte 
 Tên DW danh_sách_giá_trị_khởi_tạo ;khai báo mảng các phần tử kiểu word 
Ví dụ 1: mang1 DB 30,55,73,88,33 
Giả thiết, mang1 được nạp vào bộ nhớ tại địa chỉ offset 23E5h. Khi đó, mảng này sẽ có 
các phần tử được khởi tạo và hình ảnh của chúng trong bộ nhớ như sau: 
Tên phần tử Giá trị khởi tạo địa chỉ bộ nhớ 
Mang10 
Mang11 
Mang12 
Mang13 
Mang14 
30 
55 
73 
88 
33 
23E5h 
23E6h 
23E7h 
23E8h 
23E9h 
Ví dụ 2: mang2 DW 2BA3h,2748h,9843h,1F3Bh 
Cũng với giả thiết mang2 được nạp vào bộ nhớ tại địa chỉ offset 23E5h. Khi đó hình ảnh 
của mảng này sẽ là: 
Tên phần tử Giá trị khởi tạo địa chỉ bộ nhớ 
Mang20 
Mang22 
Mang24 
Mang26 
2BA3h 
2748h 
9843h 
1F3Bh 
23E5h 
23E7h 
23E9h 
23EBh 
Chúng ta cũng có thể khởi tạo các giá trị liên tiếp giống nhau. Khi đó, ta cũng có thể sử 
dụng toán tử DUP. Ví dụ: 
 Mang3 DB 100 DUP(5Ch) 
Giáo trình VI XỬ LÝ  
Bộ môn Kỹ thuật máy tính – Khoa CNTT – ĐHSPKT_HY Trang 47 
Mang3 là một mảng có 100 phần tử với các giá trị khởi tạo của các phần tử đều là 5Ch 
 Mang4 DB 3,4,2,10 DUP(0) 
Mang4 có 13 phần tử với 3 phần tử đầu lần lượt là 3,4,2; các phần tử còn lại có giá trị 0. 
Với mảng hai chiều, việc định nghĩa chúng có thể thực hiện theo cú pháp sau: 
Tên DB (DW) giá_trị_khởi_tạo_hàng_1 
 giá_trị_khởi_tạo_hàng_2 
 ....................................... 
 giá_trị_khởi_tạo_hàng_n 
Ví dụ: 
 Mang_2_chieu DB 10 DUP(0) 
 10 DUP(50) 
 10 DUP(100) 
 10 DUP(150) 
Khai báo một mảng hai chiều có 4 hàng 10 cột với giá trị khởi tạo của hàng 0 là 0, hàng 1 
là 50, hàng 2 là 100, hàng 3 là 150. 
3.4.4. Biến chuỗi 
Biến chuỗi hay xâu kí tự thực chất chỉ là một mảng (1 chiều) các phần tử là các kí tự 
trong đó mỗi kí tự có thể được biểu diễn bằng một số là mã ASCII hoặc là kí tự nằm 
trong dấu ' ' hoặc " ". Vì vậy, ta có thể khai báo bằng một trong các cách sau: 
Xau1 DB 'Chao' 
Xau2 DB 'C','h','a','o' 
Xau3 DB 43h,68h,61h,6Fh 
3.5. Khung của một chương trình ASSEMBLY 
 Một chương trình hợp ngữ thể hiện các đoạn dành cho chúng rõ ràng với việc sử 
dụng kích thước bộ nhớ phù hợp và cú pháp của các lệnh rõ ràng tuân theo một cú pháp 
chung, mặc dù, đó là lệnh thật hoặc lệnh giả. Để thể hiện một chương trình đó, người ta 
đưa ra 2 dạng cấu trúc. Bao gồm: 
3.5.1. Cấu trúc chương trình để dịch ra tệp *.EXE 
 Một chương trình *.EXE thường thể hiện rõ ràng 3 đoạn: mã, dữ liệu, ngăn xếp. 
Sau khi được biên dịch (Assembled) và liên kết (Linked), chúng có thể được thực thi trực 
tiếp từ dòng lệnh của DOS như các chương trình khác. Cấu trúc cơ bản của một chương 
trình dạng này như sau: 
TITLE ten_chuong_trinh 
.MODEL 
.STACK 
.DATA 
Giáo trình VI XỬ LÝ  
Bộ môn Kỹ thuật máy tính – Khoa CNTT – ĐHSPKT_HY Trang 48 
.CODE 
 Main PROC 
 ;Khởi tạo cho DS hoặc/và ES 
 MOV AX,@data 
 MOV DS,AX 
 ;MOV ES,AX 
 ;Các lệnh của chương trình chính 
 ;Trở về DOS bằng việc sử dụng chức năng 4Ch của ngắt 21h 
 MOV AH,4Ch 
 INT 21h 
 Main ENDP 
 ;Các chương trình con (nếu có) 
 END Main 
 Trong cấu trúc trên, tại dòng cuối cùng xuất hiện dẫn hướng chương trình dịch 
END và MAIN để kết thúc toàn bộ chương trình. Main chính là nơi bắt đầu các lệnh của 
chương trình trong đoạn mã. 
 Khi một chương trình *.EXE được nạp vào bộ nhớ, DOS sẽ tạo ra một mảng 
gồm 256 byte cho PSP (Program Segment Prefix - Tiền tố chương trình). PSP được sử 
dụng để chứa các thông tin liên quan đến chương trình và đặt ngay vào trước phần chứa 
mã lệnh của chương trình. 
 Tại dòng .MODEL chúng ta có thể khai báo qui mô sử dụng bộ nhớ phù hợp cho 
từng chương trình. Có thể là một trong các thành phần sau: 
Kiểu kích thước Mô tả 
Tiny (Hẹp) mã lệnh và dữ liệu gói gọn trong một đoạn 
Small (nhỏ) mã lệnh gói gọn trong một đoạn, dữ liệu nằm 
trong một đoạn 
Medium (Trung bình) mã lệnh không gói gọn trong một đoạn, dữ 
liệu nằm trong một đoạn 
Compact (Gọn) mã lệnh gói gọn trong một đoạn, dữ liệu 
không gói gọn trong một đoạn 
Large (rộng) mã lệnh không gói gọn trong một đoạn, 
dữ liệu không gói gọn trong một đoạn, 
không có mảng nào lớn hơn 64K 
Huge (Đồ sộ) mã lệnh không gói gọn trong một đoạn, 
Giáo trình VI XỬ LÝ  
Bộ môn Kỹ thuật máy tính – Khoa CNTT – ĐHSPKT_HY Trang 49 
dữ liệu không gói gọn trong một đoạn, 
các mảng có thể lớn hơn 64K 
 Chương trình dịch sẽ dịch tên @data thành các giá trị số của đoạn dữ liệu và đưa 
các thông số của dữ liệu vào thanh ghi DS và ES. 
 Để hiểu rõ hơn về cấu trúc chương trình này, chúng ta lấy một ví dụ minh hoạ 
như sau: 
Ví dụ: Viết một chương trình hợp ngữ thực hiện in hai chuỗi kí tự trên hai dòng màn 
hình. 
title ct 
.MODEL Small 
.STACK 100h 
.DATA 
 chao DB 'Chao cac ban sinh vien lop TK1$' 
 hoi DB 'Cac ban co muon hoc mon Vi xu ly khong? $' 
.CODE 
main PROC 
;Nap du lieu cho DS 
 MOV AX,@DATA 
 MOV DS,AX 
;Xoa man hinh bang chuc nang 0 cua ngat 10h 
 MOV AH,0 
 MOV AL,3 ;che do text 80x25 
 INT 10h 
;In chuoi thu nhat ra man hinh 
 MOV AH,9 
 MOV DX,offset chao ;tro toi dia chi offset cua chuoi 
 INT 21h 
;Dua con tro xuong dong tiep theo va ve dau dong 
 MOV AH,2 
 MOV DL,13 ;xuong dong 
 INT 21h 
 MOV DL,10 ;ve dau dong 
 INT 21h 
;In chuoi thu hai ra man hinh 
 MOV AH,9 
Giáo trình VI XỬ LÝ  
Bộ môn Kỹ thuật máy tính – Khoa CNTT – ĐHSPKT_HY Trang 50 
 MOV DX,offset hoi 
 INT 21h 
;Ket thuc chuong trinh va tro ve DOS 
MOV AH,4Ch 
 INT 21h 
main ENDP 
 END main 
 Như vậy, ta thấy chương trình trên là một chương trình nhỏ nên sử dụng qui mô 
bộ nhớ nhỏ (Small). Kích thước ngăn xếp là 256 byte. Dữ liệu cho chương trình có hai 
chuỗi là chao và hoi. Các chuỗi này đều được khai báo với toán tử DB. 
 Đặc biệt, các lệnh hoặc nhóm lệnh của chương trình trên có giải thích để người 
đọc và chính bản thân người lập trình (khi đọc lại) cũng sẽ dễ hiểu hơn. 
3.5.2. Cấu trúc chương trình để dịch ra tệp *.COM 
Một chương trình *.COM thường có đặc điểm khác biệt với các chương trình *.EXE là 
chúng chỉ có thể sử dụng một đoạn duy nhất của bộ nhớ để chứa mã, dữ liệu và ngăn xếp. 
Vì vậy, qui mô sử dụng bộ nhớ của các chương trình dạng này thường là Tiny. 
Cấu trúc cơ bản của dạng chương trình này như sau: 
Title Cautruc_COM 
.Model Tiny 
.Code 
 org 100h 
 Start: JMP Continue 
 ;Dinh nghia cac bien, hang 
 Continue: 
 Main PROC 
 ;Cac lenh cua chuong trinh chinh 
 INT 20h 
 Main ENDP 
 ;Cac chuong trinh con (neu co) 
 End Start 
Với dạng cấu trúc này, khi dịch chương trình, chương trình dịch sẽ đưa ra thông báo "No 
Stack Segment". 
Trong cấu trúc trên, ta thấy, ở ngay đầu chương trình đoạn mã là lệnh giả ORG (Origin: 
điểm xuất phát) và lệnh JMP (nhảy). Lệnh giả ORG 100h dùng để gán địa chỉ bắt đầu cho 
chương trình tại địa chỉ 100h (256) trong đoạn mã, chừa lại đoạn bộ nhớ 256byte cho 
PSP. 
Giáo trình VI XỬ LÝ  
Bộ môn Kỹ thuật máy tính – Khoa CNTT – ĐHSPKT_HY Trang 51 
Lệnh JMP sau nhãn START dùng để nhảy qua phần bộ nhớ dành cho việc định nghĩa và 
khai báo dữ liệu. Đích của lệnh nhảy là phần đầu của chương trình chính. 
Hình ảnh của chương trình được thể hiện trong bộ nhớ được thể hiện như trong hình vẽ 
sau: 
Địa chỉ lệch 
0000h Đoạn đầu chương trình 
(PSP) 
0100h JMP Continue IP 
 Dữ liệu cho chương trình 
FFFEh 
Continue: 
(Chiều tiến của mã&dữ liệu) 
*** 
(Chiều tiến của ngăn xếp) 
SP 
Như vậy, một chương trình *.COM có một số hạn chế sau: 
- Dung lượng cực đại của chương trình chỉ giới hạn trong một đoạn 64K. 
- Chương trình chỉ được phép sử dụng ngăn xếp với kích thước nhỏ. Nếu không, nó 
sẽ chiếm nhiều phần trong đoạn mã lệnh. 
Chương trình *.COM thường được kết thúc bởi lệnh INT 20h. 
Sau đây chúng ta xét một ví dụ để hiểu rõ hơn về việc sử dụng cấu trúc trên trong lập 
trình hợp ngữ. 
Chương trình được viết như sau: 
Title Cautruc_COM 
.Model Tiny 
.Code 
 org 100h 
 Start: JMP Continue 
 chao DB 'Chao cac ban sinh vien lop TK1$' 
 hoi DB 'Cac ban co muon hoc mon Vi xu ly khong? $' 
Continue: 
 Main PROC 
;Xoa man hinh bang chuc nang 0 cua ngat 10h 
 MOV AH,0 
 MOV AL,3 ;che do text 80x25 
Giáo trình VI XỬ LÝ  
Bộ môn Kỹ thuật máy tính – Khoa CNTT – ĐHSPKT_HY Trang 52 
 INT 10h 
;In chuoi thu nhat ra man hinh 
 MOV AH,9 
 MOV DX,offset chao ;tro toi dia chi offset cua chuoi 
 INT 21h 
;Dua con tro xuong dong tiep theo va ve dau dong 
 MOV AH,2 
 MOV DL,13 ;xuong dong 
 INT 21h 
 MOV DL,10 ;ve dau dong 
 INT 21h 
;In chuoi thu hai ra man hinh 
 MOV AH,9 
 MOV DX,offset hoi 
 INT 21h 
 INT 20h 
 Main ENDP 
 End Start 
Chúng ta có thể nhận xét rằng một chương trình *.COM không cần phải nạp dữ liệu vào 
DS vì chương trình dạng này có mã, dữ liệu và ngăn xếp trong cùng một đoạn. 
3.6. Cách tạo một chương trình hợp ngữ 
 Một chương trình viết bằng ngôn ngữ bậc cao có thể chạy trực tiếp trong môi 
trường của chúng. Song, với ngôn ngữ lập trình bậc thấp (hợp ngữ) thì việc chạy chương 
trình cần phải thông qua việc hợp dịch (Assembled), liên kết (Linked). Người ta đã đưa ra 
các bước để soạn thảo, dịch và chạy chương trình như sau: 
Bước 1: Soạn thảo văn bản chương trình 
Trong bước này, ta có thể thực hiện bằng một trình soạn thảo văn bản bất kỳ nào như 
EDIT, NCEDIT, TURBO PASCAL, C, NOTEPAD, hoặc WINWORD... nhưng, cần phải 
ghi lại với phần mở rộng là *.ASM. 
Bước 2: Hợp dịch chương trình nguồn ra các tệp đối tượng *.OBJ 
Trong bước này, ta có thể sử dụng trình MASM (MicroSoft Assembler) hoặc TASM 
(Turbo Assembler) theo cú pháp sau: 
MASM 9 tên_tệp[.phần_mở_rộng] ↵ 
Hoặc: TASM 9 tên_tệp[.phần_mở_rộng] ↵ 
Sau khi dịch, nếu có lỗi cú pháp, máy sẽ báo dòng gây lỗi và mã lỗi. Khi đó ta có thể 
quay lại bước 1 để sửa tệp nguồn và dịch lại cho đến khi không có lỗi. 
Giáo trình VI XỬ LÝ  
Bộ môn Kỹ thuật máy tính – Khoa CNTT – ĐHSPKT_HY Trang 53 
Bước 3: Liên kết các tệp đối tượng thành tệp chương trình *.EXE 
Có thể sử dụng trình liên kết LINK hoặc TLINK (Turbo) theo cú pháp sau: 
LINK 9 tệp_đt1[+tệp_đt2+...+tệp_đtn] ↵ 
Hoặc: TLINK 9 tệp_đt1[+tệp_đt2+...+tệp_đtn] ↵ 
Bước 4: Nếu chương trình viết dưới dạng cấu trúc *.COM thì thực hiện dịch sang dạng 
*.COM bằng cú pháp sau: 
 EXE2BIN 9 tên_tệp_exe 9 tên_tệp_com.COM ↵ 
Nếu tệp viết để dịch ra chương trình *.EXE thì bỏ qua bước này 
Bước 5: Chạy tệp chương trình vừa dịch 
 Tên_tệp_chương_trình ↵ 
Với các bước thực hiện như trên, chúng ta có thể mô phỏng bằng lưu đồ sau: 
Ví dụ: Soạn thảo một chương trình đơn giản, sau đó dịch và chạy chương trình này 
Bước 1: Soạn thảo văn bản chương trình 
Soạn thảo văn bản chương trình 
Dịch ra các tệp .OBJ bằng MASM 
Liên kết các tệp .OBJ thành tệp .EXE 
Lỗi cú pháp? 
Dịch ra tệp .COM? 
Dịch từ tệp .EXE sang tệp .COM 
Không 
Có 
Chạy chương trình 
Không 
Có 
Giáo trình VI XỬ LÝ  
Bộ môn Kỹ thuật máy tính – Khoa CNTT – ĐHSPKT_HY Trang 54 
Bước 2: Dịch ra tệp .OBJ 
Nếu có lỗi như hình trên, quay lại bước 1. Cứ như vậy cho đến khi không còn lỗi 
Bước 3: Liên kết các tệp *.OBJ thành tệp chương trình.