Upload
toa-cao
View
253
Download
7
Embed Size (px)
Citation preview
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
1 /87
CHƯƠNG 4
MỨC VI LẬP TRÌNH
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
2 /87
THANH GHI
Chức năng và đặc điểm: Tập hợp các thanh ghi nằm trong BXL Chứa các thông tin tạm thời phục vụ cho hoạt động ở thời điểm hiện
tại của BXL Như là mức đầu tiên của hệ thống nhớ Tùy thuộc vào BXL cụ thể Số lượng thanh ghi nhiều → tăng hiệu năng của BXL Có hai loại thanh ghi
Các thanh ghi lập trình được Các thanh ghi không lập trình được
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
3 /87
THANH GHI
Một số thanh ghi điển hìnhCác thanh ghi địa chỉ
Bộ đếm chương trình (Program Counter) Con trỏ dữ liệu (Data Pointer) Con trỏ ngăn xếp (Stack Pointer) Thanh ghi cơ sở và thanh ghi chỉ số (Base Register &
Index Register)
Các thanh ghi dữ liệuThanh ghi trạng thái (thanh ghi cờ)
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
4 /87
THANH GHI
Thanh ghi địa chỉChương trình mã máy đang thực hiện chiếm 3
vùng nhớ khác nhau trong bộ nhớ: vùng lệnh, vùng dữ liệu, vùng ngăn xếp
Vùng lệnh: chứa các lệnh của chương trình, do Thanh ghi bộ đếm chương trình quản lý.
Vùng dữ liệu: chứa dữ liệu, do thanh ghi con trỏ dữ liệu quản lý
Vùng ngăn xếp: chứa địa chỉ CTC, ngắt, phục vụ thực hiện rẽ nhánh, do thanh ghi con trỏ ngăn xếp quản lý
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
5 /87
THANH GHI
Bộ đếm chương trìnhCòn gọi là con trỏ lệnh IP (Instruction Pointer),
quản lý địa chỉ vùng lệnh Giữ địa chỉ của lệnh tiếp theo sẽ được nhận vàoSau khi lệnh được nhận vào, nội dung PC tự động
tăng để trỏ sang lệnh kế tiếp
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
6 /87
THANH GHI
Minh họa bộ đếm chương trình. . .
Lệnh
Lệnh
Lệnh
Lệnh sẽ được nhận vào
Lệnh kế tiếp
Lệnh
Lệnh
. . .
PC
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
7 /87
THANH GHI
Thanh ghi con trỏ dữ liệuChứa địa chỉ của ngăn nhớ dữ liệu mà BXL cần
truy nhập . . .
Dữ liệu
Dữ liệu
Dữ liệu
DL cần đọc/ghi
Dữ liệu
Dữ liệu
. . .
DP
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
8 /87
THANH GHI
Con trỏ ngăn xếpNgăn xếp (Stack):
Là vùng nhớ có cấu trúc LIFO Đáy ngăn xếp là một ngăn nhớ xác định Đỉnh ngăn xếp có thể bị thay đổi
Con trỏ ngăn xếp SP: SP trỏ vào ngăn nhớ đỉnh ngăn xếp Cất thêm thông tin vào ngăn xếp → SP giảm Lấy thông tin từ ngăn xếp → SP tăng Khi ngăn xếp rỗng → SP trỏ vào đáy
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
9 /87
THANH GHI
Đỉnh Stack
Đáy Stack
SPCÊt
vµo
LÊy raChiÒu t¨ng cña
®Þa chØ
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
10 /87
THANH GHI
Thanh ghi cơ sở và thanh ghi chỉ sốThanh ghi cơ sở: chứa địa chỉ của ngăn nhớ cơ
sở (ngăn nhớ gốc tương đối), còn gọi: địa chỉ đoạn (segment)
Thanh ghi chỉ số: chứa độ lệch của địa chỉ giữa ngăn nhớ mà BXL cần truy nhập so với ngăn nhớ cơ sở, còn gọi: địa chỉ offset
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
11 /87
. . .
Gốc tương đối
Ng/nhớ cần truy nhập
. . .
Ngăn nhớ cơ sởThanh ghi cơ sở
Thanh ghi chỉ số
Khoảng lệch
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
12 /87
Các thanh ghi dữ liệuChứa các dữ liệu tạm thời hoặc kết quả trung gianCần có nhiều thanh ghi dữ liệuCác thanh ghi số nguyên: 8, 16, 32, 64, ... BitCác thanh ghi số thực (dấu phẩy động)
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
13 /87
Thanh ghi trạng tháiCòn gọi là thanh ghi cờ (Flag Register)Chứa các thông tin trạng thái của BXL
Các cờ phép toán: báo hiệu trạng thái của phép toán Các cờ điều khiển: biểu thị trạng thái điều khiển của
BXL
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
14 /87
Minh họa thanh ghi trạng thái
x x x x OF DF IF TF SF ZF X AF X PF X CF
Cờ trạng thái
Cờ điều khiển
• OF (Overflow - tràn): OF = 1 xác định tràn số học, xảy ra khi kết quả vượt ra ngoài phạm vi biểu diễn.• DF (Direction- hướng): xác định hướng chuyển chuỗi, DF = 1 khi CPU làm việc với chuỗi theo thứ tự từ phải sang trái và ngược lại.• IF (Interrupt - ngắt): cho phép hay cấm các ngắt có mặt nạ.• TF (Trap - bẫy): đặt CPU vào chế độ từng bước, dùng cho các chương trình gỡ rối (debugger).• SF (Sign - dấu): dùng để chỉ các kết quả số học là số dương (SF = 0) hay âm (SF = 1).• ZF (Zero): = 1 nếu kết quả của phép toán trước là 0.• AF (Auxiliary – nhớ phụ): dùng trong các số thập phân để chỉ nhớ từ nửa byte thấp hay mượn từ nửa byte cao.• PF (Parity): PF = 1 nếu kết quả của phép toán là có tổng số bit 1 là chẵn (dùng để kiểm tra lỗi truyền dữ liệu)•CF (Carry): CF = 1 nếu có nhớ hay mượn từ bit cao nhất của kết quả. Cờ này cũng dùng cho các lệnh quay.
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
15 /87
4.2.1 Đường dữ liệu
Đường dữ liệu là một phần của CPU, nó có chứa ALU, các đầu vào và đầu ra.
Thí dụ trên hình vẽ:
16 thanh ghi 16 bit giống nhau tạo nên một bộ nhớ tạm chỉ truy cập được ở mức vi chương trình.
Thanh ghi đưa nội dung ra: bus A, bus B hoặc đồng thời cả 2 bus.
Nạp vào thanh ghi: từ bus C.
ALU (16 bit) có thể thực hiện 4 chức năng: A+B, A AND B, A và not A
F0 và F1 định chức năng sẽ được ALU thực hiện.
ALU sinh ra hai bit trạng thái dựa trên kết quả ra hiện thời của nó:
N có giá trị 1 khi kết quả ra là âm Z có giá trị 1 khi kết quả ra bằng 0 (Zê-rô).
A
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
16 /87
4.2.1 Đường dữ liệu (Data path)
Shifter có thể dịch: trái, phải, không dịch.
Có thể thực hiện dịch trái hai bit một giá
trị ghi trong thanh ghi R, bằng cách tính
R+R trong ALU, sau đó dịch kết quả
(tổng) một bit nữa sang trái bằng thanh
ghi dịch.
A latch và B latch: được nạp từ bus A và
bus B để cho phép có thể thay đổi nội
dung các thanh ghi đã nạp giá trị vào
ALU.
Các tín hiệu L0 và L1 điều khiển việc nạp
giá trị trên bus A và bus B vào các thanh
ghi chốt.
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
17 /87
4.2.1 Đường dữ liệu (Data path)
MAR: thanh ghi địa chỉ ô nhớ cần thao tác
Có thể được nạp từ thanh ghi chốt B song
song với một thao tác của ALU.
M0 điều khiển việc nạp của MAR.
MBR: thanh ghi đệm (dữ liệu) đọc/ghi bộ nhớ.
Được nạp giá trị từ đầu ra của thanh ghi
dịch, giá trị này cũng có thể đồng thời được
chứa vào một trong các thanh ghi của bộ
nhớ tạm.
M1 điều khiển việc nạp của MBR từ đầu ra
của thanh ghi dịch
M2 và M3 điều khiển việc đọc và ghi bộ nhớ.
AMUX: bộ dồn kênh để chọn dữ liệu đưa vào
ALU từ A latch hay từ MBR
A0 điều khiển AMUX.
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
18 /87
4.4.2 Thí dụ về một vi chương trình
Các thanh ghi:
PC, AC và SP
IR: Thanh ghi lệnh.
TIR (Temporary IR): chứa tạm thời bản sao của
IR dùng để giải mã vĩ chỉ thị.
0, 1, -1: các hằng số được chỉ ra trên thanh ghi
AMASK ( 0000.1111.1111.1111b): làm mặt nạ để
tách các bit của trường địa chỉ khỏi các bit của
trường opcode trong chỉ thị MAC-1.
SMASK ( 0000.0000.1111.1111b): làm mặt nạ để
tách địa chỉ offset 8 bit trong các chỉ thị INSP và
DESP.
Sáu thanh ghi còn lại (A, B, C, D, E, F) không
được gán trước các chức năng, có thể được sử
dụng theo ý của người lập vi chương trình.
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
19 /87
4.2.2 Vi chỉ thị - microinstruction
Các tín hiệu để điều khiển đường dữ liệu gồm 9 nhóm: 16 tín hiệu để điều khiển việc nạp cho bus A
từ bộ nhớ tạm (có 16 thanh ghi). 16 tín hiệu để điều khiển việc nạp cho bus B
từ bộ nhớ tạm. 16 tín hiệu để điều khiển việc nạp cho bộ
nhớ tạm từ bus C. 2 tín hiệu để điều khiển 2 thanh ghi chốt A
và B. 2 tín hiệu để điều khiển chức năng ALU. 2 tín hiệu để điều khiển bộ dịch. 4 tín hiệu để điều khiển MAR và MBR. 2 tín hiệu để chỉ rõ thao tác đối với bộ nhớ
(R/W). 1 tín hiệu để điều khiển Amux.
Tổng số tín hiệu: 61
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
20 /87
... 4.2.2 Vi chỉ thị - microinstruction
Có thể điều khiển đường dl bằng 61 tín hiệu
Thực hiện một chu kỳ của đường dữ liệu:
Một chu kỳ bao gồm việc mở cổng cho
các giá trị trong bộ nhớ tạm đi vào bus A
và bus B, chốt chúng lại trong hai thanh
ghi chốt bus A latch và B latch
Cho các giá trị từ các thanh ghi chốt chạy
qua ALU và shifter
Cuối cùng là việc chứa các kết quả vào
trong bộ nhớ tạm hoặc vào MBR. Ngoài
ra MAR cũng có thể được nạp, sau đó
một chu kỳ bộ nhớ sẽ bắt đầu.
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
21 /87
... 4.2.2 Vi chỉ thị - microinstruction
Giảm số bít để điều khiển đường dữ liệu:
Sử dụng bộ giải mã 4 -16: giảm số bit điều khiển mỗi bus A, B và C từ 16 xuống còn 4.
Chấp nhận chỉ nạp dữ liệu trên bus C vào 1 trong 16 thanh ghi. 61 – 3*(16 – 4) = 61 – 36 = 25.
Bỏ 2 bit điều khiển A latch và B latch: vì luôn cần chúng tích cực ở các thời điểm xác định nên có thể dùng luôn tín hiệu đồng hồ:
25 – 2 = 23.
Nếu bộ nhớ đã dùng tín hiệu RD và WR thay cho M2 và M3:
23 – 2 = 21.
Tuy nhiên nên bổ sung 1 tín hiệu là ENC: cho / không cho phép chứa giá trị trên bus C vào bộ nhớ tạm.
ENC=1: Có cất giá trị trên bus C ENC=0: Không cất
Tổng số bit tín hiệu = 22 bit.
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
22 /87
4.2.2 Vi chỉ thị: khuôn dạng gồm 13 trường
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
23 /87
4.2.3 Việc định thời vi chỉ thị
Là việc định trình tự xảy ra các sự kiện trong quá
trình thực hiện một vi chỉ thị.
Một chu kỳ ALU cơ sở bao gồm việc:
1. Nạp vi chỉ thị tiếp theo sẽ được thi hành vào
MIR .
2. Mở cổng các thanh ghi tạm đi vào bus A và
bus B và giữ chúng trong A latch và B latch.
3. Khi các giá trị đưa vào ALU ổn định, dành
thời gian cho ALU và shifter để chúng sinh ra
giá trị ra ổn định; nạp MAR nếu cần thiết.
4. Khi giá trị ra của shifter ổn định, chứa giá trị
trên bus C vào bộ nhớ tạm và nạp cho MBR
nếu việc này cũng được yêu cầu.
sử dụng một đồng hồ 4 pha (có 4 chu kỳ con)
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
24 /87
... 4.2.3 Việc định thời vi chỉ thị
Bộ nhớ điều khiển (Control Store): Chứa vi chương trình
Dung lượng 256x32
Chu kỳ con thứ nhất: nạp vi chỉ thị trỏ bởi MPC cho MIR (và chốt lại).
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
25 /87
... 4.2.3 Việc định thời vi chỉ thị
Chu kỳ con thứ hai: Đơn vị Increment tính MPC+1; Các trường của MIR bắt đầu điều khiển đường dữ liệu: A decoder và B decoder
thực hiện giải mã
2/16 thanh ghi được chọn mở cổng đổ dữ liệu vào bus A và bus B
A latch và B latch chốt dữ liệu ở đầu vào và đưa dữ liệu ra.
...
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
26 /87
... 4.2.3 Việc định thời vi chỉ thị
Chu kỳ con thứ ba:
dành cho ALU và
shifter; Amux: Xác định giá trị vào
nhánh trái của ALU
Trong khi ALU và
shifter đang tính toán
thì MAR được nạp từ
bus B nếu trường
MAR =1.
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
27 /87
... 4.2.3 Việc định thời vi chỉ thị
Chu kỳ con thứ tư: Giá trị trên bus C có thể được
chứa vào: Bộ nhớ tạm, nếu ENC=1 Hoặc MBR, nếu MBR và
WR=1. MBR được nạp từ bộ nhớ ngoài
nếu trường MBR và RD=1. "C decoder“: Nhận ở đầu vào:
ENC Đường tín hiệu đồng hồ thứ tư Trường C của vi chỉ thị Nếu 2 tín hiệu đầu tiên đồng
thời =1, C decoder sẽ giải mã chọn 1/16 thanh ghi.
Hai tín hiệu điều khiển bộ nhớ RD và WR được nối với các bit tương ứng của MIR.
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
28 /87
4.2.4 Sự định trình tự các vi chỉ thị
Đó là việc chọn vi chỉ thị tiếp theo: tuần tự hay nhảy (Jump)
Trường COND sẽ xác định thực hiện: Tuần tự: MPC+1 Rẽ nhánh: ADDR
Có 4 cách lựa chọn vi chỉ thị tiếp theo, chỉ ra bằng trường COND như sau:
0 = Không nhảy
1 = Nhảy tới ADDR nếu N =1
2 = Nhảy tới ADDR nếu Z =1
3 = Nhảy tới ADDR vô điều kiện.
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
29 /87
... 4.2.4 Sự định trình tự các vi chỉ thị
Đơn vị Micro sequencing logic kết hợp 2 bit N và Z của ALU và 2 bit L (Left - trái) và bit R (Right - phải) của trường COND để sinh ra tín hiệu điều khiển Mmux.
Mmux= LRN LRZ LR RN LZ LR+ + = + +
COND LR N Z Mmux
00 x X 0
01 1 X 1
10 X 1 1
11 LR x X 1
LR
RL
RL
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
30 /87
4.3 Thí dụ về một kiến trúc mức máy thông thường
Để nghiên cứu tiếp thí dụ về mức vi chương trình, chúng ta
cần nghiên cứu kiến trúc của mức máy thông thường, mức
này sẽ được hỗ trợ bởi một trình thông dịch chạy trên máy
mức 1 - Mức Vi chương trình.
4.3.1 Kiến trúc mức máy thông thường - Vĩ kiến trúc
4.3.2 Vấn đề đánh địa chỉ bộ nhớ chính và bộ nhớ
ngăn xếp
4.3.3 Tập vĩ chỉ thị
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
31 /87
4.3.1 Kiến trúc mức máy thông thường - Vĩ kiến trúc
Trình thông dịch chạy trên máy mức 1 (Gọi là Mic-1)- Mức
Vi chương trình.
Gọi kiến trúc của các máy ở mức 2 và 3 là vĩ kiến trúc
(macroarchitecture) cho tương phản với kiến trúc ở mức 1
đã được gọi là vi kiến trúc (microarchitecture). Gọi máy
mức 2 là Mac-1.
Trong chương này các chỉ thị bình thường như ADD,
MOVE và các chỉ thị khác của mức máy thông thường (máy
mức 2) sẽ được gọi là vĩ chỉ thị.
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
32 /87
4.3.2 Vấn đề đánh địa chỉ bộ nhớ chính và bộ nhớ ngăn xếp
Sự cần thiết phải có stack: Sử dụng cho các biến cục bộ của các chương trình con
Cần tổ chức theo kiểu LIFO (Last In First Out).
Cần một con trỏ đỉnh stack - SP (Stack Pointer).
2 thao tác quan trọng nhất là PUSH và POP PUSH X: dịch con trỏ stack rồi đặt X vào bộ nhớ tại vị trí
lúc này được trỏ bởi SP.
POP Y: chứa phần tử ở trên cùng của stack vào Y rồi
dịch con trỏ.
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
33 /87
... 4.3.2 Vấn đề đánh địa chỉ bộ nhớ chính và bộ nhớ ngăn xếp
Vấn đề đánh địa chỉ bộ nhớ chính:
Giả sử:
1. Bộ nhớ chính có 212 = 4096 từ
2. Tại mức máy thông thường chúng ta sử dụng 3 thanh ghi là:
PC (Program Counter): con trỏ lệnh, trỏ tới lệnh sắp được thực hiện
SP (Stack Pointer): được sử dụng cho các thao tác với bộ nhớ stack
AC (ACcumulator): cho các thao tác với bộ nhớ (vận chuyển dữ liệu,
để tính toán số học ...)
Phương thức đánh địa chỉ (mode địa chỉ) là cách thức chỉ ra
vị trí của dữ liệu (toán hạng, chỉ thị của chương trình).
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
34 /87
... 4.3.2 Vấn đề đánh địa chỉ bộ nhớ chính và bộ nhớ ngăn xếp
Các mode địa chỉ:
Các chỉ thị mode địa chỉ trực tiếp: có chứa một địa chỉ bộ nhớ
12 bit, đánh được địa chỉ của toàn bộ 4096 từ trong bộ nhớ.
Những chỉ thị như vậy cần phải có để truy cập các biến toàn cục.
Các chỉ thị mode gián tiếp: (12 bit) cho phép người lập trình tính
địa chỉ nhớ, đặt nó vào trong thanh ghi AC, sau đó đọc hoặc ghi
word đã được đánh địa chỉ. Dạng đánh địa chỉ này rất phổ biến và
thường được dùng để truy cập các phần tử của mảng.
Các chỉ thị mode cục bộ: (có thể <= 12 bit) chỉ ra một vị trí tương
đối (độ dịch hay offset) so với SP và được dùng để truy cập các
biến cục bộ.
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
35 /87
... 4.3.2 Vấn đề đánh địa chỉ bộ nhớ chính và bộ nhớ ngăn xếp
LODD, STOD, ADDD, SUBD: sd mode địa chỉ trực tiếp
LODL, STOL, AD, DL, SUBL sd mode địa chỉ cục bộ
JUMP: chỉ thị nhảy không điều kiện
JPOS, JZER, JNEG, JNZE: nhảy có điều kiện
LOCO: nạp 1 hằng số 12 bit vào AC
PSHI: đẩy word có địa chỉ nằm trong AC lên stack
POPI: Lấy 1 word ra khỏi stack và chứa nó vào một word của bộ nhớ có
địa chỉ nằm trong AC
SWAP: hoán vị nội dung AC và SP
INSP, DESP: thay đổi SP một lượng đã biết trong lúc biên dịch
Call: gọi thủ tục sau khi đã cất địa chỉ trở về vào stack.
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
36 /87
4.3.3 Tập vĩ chỉ thị
Mã nhị phân (Binary)Ký hiệu
(Mnemonic) Thực hiện Giải thích
0000xxxxxxxxxxxx LODD Load direct ac:=m[x]
0001xxxxxxxxxxxx STOD Store direct m[x]:=ac
0010xxxxxxxxxxxx ADDD Add direct ac:=ac+m[x]
0011xxxxxxxxxxxx SUBD Subtract direct ac:=ac-m[x]
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
37 /87
... 4.3.3 Tập vĩ chỉ thị
Mã nhị phân (Binary) Ký hiệu (Mnemonic)
Thực hiện Giải thích
0100xxxxxxxxxxxx JPOS Jump positive if ac ≥ 0 then pc:=x
0101xxxxxxxxxxxx JZER Jump zero if ac=0 then pc:=x
0110xxxxxxxxxxxx JUMP Jump pc:=x
0111xxxxxxxxxxxx LOCO Load constant ac:=x (0 ≤ x ≤ 4095)
1000xxxxxxxxxxxx LODL Load local ac:=m[sp+x]
1001xxxxxxxxxxxx STOL Store local m[x+sp]:=ac
1010xxxxxxxxxxxx ADDL Add local ac:=ac+m[sp+x]
1011xxxxxxxxxxxx SUBL Subtract local ac:=ac-m[sp+x]
1100xxxxxxxxxxxx JNEG Jump negative if ac < 0 then pc:=x
1101xxxxxxxxxxxx JNZE Jump nonzero if ac <> 0 then pc:=x
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
38 /87
... 4.3.3 Tập vĩ chỉ thị
Mã nhị phân (Binary)Ký hiệu
(Mnemonic)
Thực hiện Giải thích
1110xxxxxxxxxxxx CALL Call procedure sp:=sp-1; m[sp]:=pc; pc:=x
1111000000000000 PSHI Push indirect sp:=sp-1; m[sp]:=m[ac]
1111001000000000 POPI Pop indirect m[ac]:=m[sp]; sp:=sp+1
1111010000000000 PUSH Push onto stack sp:=sp-1; m[sp]:=ac
1111011000000000 POP Pop from stack ac:=m[sp]; sp:=sp+1
1111100000000000 RETN Return pc:=m[sp]; sp:=sp+1
1111101000000000 SWAP Swap ac, sp tmp:=ac; ac:= sp; sp:=tmp
11111100YYYYYYYY INSP Increment sp sp:=sp+y (0 ≤ y ≤ 255)
11111110YYYYYYYY DESP Decrement sp sp:=sp-y (0 ≤ y ≤ 255)
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
39 /87
4.4.1 Ngôn ngữ Vi assembly
Để chỉ rõ việc sử dụng các chức năng 0, 1, 2 và 3
của ALU, chúng ta viết:
ac:=a+ac
a:=band(ir,smask) ;# band = "Boolean and“
ac:=a
a:=inv(a) ;# inv = “invert”
Các thao tác dịch trái và dịch phải có thể được ký
hiệu là lshift và rshift, như:
tir:=lshift(tir+tir)
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
40 /87
... 4.4.1 Ngôn ngữ Vi assembly
Statement(Chỉ thị ngôn ngữ MAL)
AMUX
COND
ALU
SH
MBR
MAR
RD
WR
ENC
C B A
ADDR
Mar := pc; rd 0 0 2 0 0 1 1 0 0 0 0 0 00
Rd 0 0 2 0 0 0 1 0 0 0 0 0 00
ir := mbr 1 0 2 0 0 0 0 0 1 3 0 0 00
pc := pc+1 0 0 0 0 0 0 0 0 1 0 6 0 00
Mar := ir; mbr := ac; wr 0 0 2 0 1 1 0 1 0 0 3 1 00
alu := tir; if n then goto 15 0 1 2 0 0 0 0 0 0 0 0 4 15
ac := inv (mbr) 1 0 3 0 0 0 0 0 1 1 0 0 00
tir := lshift (tir); if n then goto 25 0 1 2 2 0 0 0 0 1 4 0 4 25
alu := ac; if z then goto 22 0 2 2 0 0 0 0 0 0 0 0 1 22
ac :=band(ir, amask); goto 0 0 3 1 0 0 0 0 0 1 1 8 3 00
sp := sp + (-1); rd 0 0 0 0 0 0 1 0 1 2 2 7 00
tir := lshift(ir+ir); if n then goto 69 0 1 0 2 0 0 0 0 1 4 3 3 69
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
41 /87
... 4.4.2 Thí dụ về một vi chương trình
Giống mọi chương trình thông dịch, vi chương trình của chúng ta có một vòng lặp chính:
Lấy chỉ thị về (fetch): bắt đầu từ dòng 0
Giải mã (decode): dòng 2-5 (đây là một trong các nhánh)
Thi hành (execute): dòng 6-8 (đây là một trong các nhánh, thực hiện LODD)
0: mar := pc; rd; {main loop. Fetch an Instruction}
1: pc := pc+1; rd; {increment pc, and keep on reading}
2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}
3: tir :=lshift(ir+ir); if n then goto 19; {if opcode = 01xx.12x then goto 19 else next line}
4: tir := lshift(tir); if n then goto 11; {000x or 001x?}
5: alu := tir; if n then goto 9; {0000 or 0001?}
{opcode = 0000.12x ----------------------------------------------------------- LODD ---↓}
6: mar := ir; rd; {LODD: mar := operand add, and read}
7: rd; {keep on reading}
8: ac := mbr; goto 0 {ac := Operand}
{↑-------------------------------------------------------------------------------- LODD ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
42 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}
1: pc := pc+1; rd; {increment pc, and keep on reading}
2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}
3: tir :=lshift(ir+ir); if n then goto 19; {if opcode = 01xx.12x then goto 19 else
next line}
4: tir := lshift(tir); if n then goto 11; {000x or 001x?}
5: alu := tir; if n then goto 9; {0000 or 0001?}
...
{↓opcode = 0001.12x ----------------------------------------------------------- STOD ---↓}
9: mar := ir; mbr := ac; wr; {STOD: mar := operand add, and write}
10: wr; goto 0; {keep on writing, going to fetch a next instruction}
{↑------------------------------------------------------------------------------------ STOD ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
43 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}
1: pc := pc+1; rd; {increment pc, and keep on reading}
2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}
3: tir :=lshift(ir+ir); if n then goto 19; {if opcode = 01xx.12x then goto 19
else next line}
4: tir := lshift(tir); if n then goto 11; {000x or 001x?}
...
{↓opcode = 001x.12x ----------------------------------------------- ADDD or SUBD ---↓}
11: alu := tir; if n then goto 15; {0010 or 0011?}
{↓opcode = 0010.12x ----------------------------------------------------------- ADDD ---↓}
12: mar := ir; rd; {ADDD: mar := operand add, and read}
13: rd; {keep on reading}
14: ac := mbr + ac; goto 0{ac := m[x]+ac; going to fetch a next instruction}
{↑------------------------------------------------------------------------------------ ADDD ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
44 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}
1: pc := pc+1; rd; {increment pc, and keep on reading}
2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}
3: tir :=lshift(ir+ir); if n then goto 19; {if opcode = 01xx.12x then goto 19 else next line}
4: tir := lshift(tir); if n then goto 11; {000x or 001x?}
...
{↓opcode = 001x.12x ----------------------------------------------- ADDD or SUBD ---↓}
11: alu := tir; if n then goto 15; {0010 or 0011?}
...
{↓opcode = 0011.12x ------------------------------------------------------------- SUBD ---↓}
15: mar := ir; rd; {SUBD: mar := operand add, and read}
16: ac := ac + 1; rd; {keep on reading while executing ac := ac+1}
17: a := inv(mbr); {Note: x - y = x + 1 + not y}
18: ac := ac + a; goto 0; {ac := ac+not.m[x] + 1; going to fetch a next instruction}
{↑------------------------------------------------------------------------------------ SUBD ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
45 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}
1: pc := pc+1; rd; {increment pc, and keep on reading}
2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}
3: tir :=lshift(ir+ir); if n then goto 19; {if opcode = 01xx.12x then goto 19 else next line}
...
{↓opcode = 01xx.12x ------------------------------------------------------------------------ ↓}
19: tir := lshift(tir); if n then goto 25; {if opcode = 011x.12x then goto 25 else next line}
20: alu := tir; if n then goto 23; {if opcode = 0101.12x then goto 23 else next line}
{↓opcode = 0100.12x ------------------------------------------------------------ JPOS --- ↓}
21: alu := ac; if n then goto 0 {JPOS: if ac < 0 then going to jump}
22: pc := band(ir, amask); goto 0; {calc. add to jump, and perform the jump}
{↑------------------------------------------------------------------------------------ JPOS ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
46 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}1: pc := pc+1; rd; {increment pc, and keep on reading}2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}3: tir :=lshift(ir+ir); if n then goto 19; {if opcode = 01xx.12x then goto 19 else next line}...19: tir := lshift(tir); if n then goto 25; {if opcode = 011x.12x then goto 25 else next line}20: alu := tir; if n then goto 23; {if opcode = 0101.12x then goto 23 else next line}...
{↓opcode = 0101.12x ----------------------------------------------------------- JZER --- ↓}
23: alu := ac; if z then goto 22; {JZER: if ac = 0 then goto 22 to do smth to jump}
24: goto 0; {ac <> 0, so no jump: going to fetch next instruction}--- JZER ---↑}
{↓opcode = 011x.12x go from line 19 ------------------------------JMP or LOCO--- ↓}
25: alu := tir; if n then goto 27; {0110 or 0111?}
{↓opcode = 0110.12x -------------------------------------------------------------JMP--- ↓}
26: pc := band(ir, amask); goto 0; {JUMP: pc := x}---------------- JMP ---↑}
{↓opcode = 0111.12x go from line 25 -------------------------------------- LOCO--- ↓}
27: ac := band(ir, amask); goto 0; {LOCO ac := x}------------------- LOCO ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
47 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}1: pc := pc+1; rd; {increment pc, and keep on reading}2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}...7: rd; {keep on reading}8: ac := mbr; goto 0 {ac := Operand}...
28: tir := lshift(ir+ir); if n then goto 40; {if opcode = 11xx.12x then goto 40 else next line}
{↓opcode = 10xx.12x --------------------------------------------------------------------- ↓}
29: tir := lshift(tir); if n then goto 35; {if opcode = 101x.12x then goto 35 else next line}
{↓opcode = 100x.12x --------------------------------------------------------------------- ↓}
30: alu := tir; if n then goto 33; {if opcode = 1001.12x then goto 33 else next line}
{↓opcode = 1000.12x = ----------------------------------------------------------- LODL ---- ↓}
31: a := ir + sp; {LODL: ac := m[sp+x]; performed by lines 31, 32, 7, 8}
32: mar := a; rd; goto 7; {attention: mar = 12-bit reg., other regs = 16-bit}
{↑--------------------------------------------------------------------------------------- LODL ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
48 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}
1: pc := pc+1; rd; {increment pc, and keep on reading}
2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}
...
28: tir := lshift(ir+ir); if n then goto 40; {if opcode = 11xx.12x then goto 40 else next line}
29: tir := lshift(tir); if n then goto 35; {if opcode = 101x.12x then goto 35 else next
line}
30: alu := tir; if n then goto 33; {if opcode = 1001.12x then goto 33 else next line}
...
{↓ opcode = 1001.12x = ----------------------------------------------------------- STOL ---- ↓}
33: a := ir + sp; {STOL: m[x+sp] := ac; performed by lines 33, 34, 10}
34: mar := a; mbr := ac; wr; goto 10;
{↑ ---------------------------------------------------------------------------------------- STOL ----↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
49 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}1: pc := pc+1; rd; {increment pc, and keep on reading}2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}...13: rd; {keep on reading}14: ac := mbr + ac; goto 0 {ac := m[x]+ac; going to fetch a next instruction}...28: tir := lshift(ir+ir); if n then goto 40; {if opcode = 11xx.12x then goto 40 else next line}29: tir := lshift(tir); if n then goto 35; {if opcode = 101x.12x then goto 35 else next line}...
{↓opcode = 101x.12x --------------------------------------------------------------------------- ↓}
35: alu := tir; if n then goto 38; {if opcode = 1011.12x then goto 38 else next line}
{↓opcode = 1010.12x -------------------------------------------------------------- ADDL --- ↓}
36: a := ir + sp;
37: mar := a; rd; goto 13; {ADDL: ac := ac + m[sp+x]; performed by lines 36, 13, 14}
{↑ ---------------------------------------------------------------------------------------- ADDL ----↑ }
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
50 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}1: pc := pc+1; rd; {increment pc, and keep on reading}2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}...16: ac := ac + 1; rd; {keep on reading while executing ac := ac+1}17: a := inv(mbr); {Note: x - y = x + 1 + not y}18: ac := ac + a; goto 0; {ac := ac+not.m[x] + 1; going to fetch a next instruction}...28: tir := lshift(ir+ir); if n then goto 40; {if opcode = 11xx.12x then goto 40 else next line}29: tir := lshift(tir); if n then goto 35; {if opcode = 101x.12x then goto 35 else next line}...
{↓opcode = 101x.12x --------------------------------------------------------------------------- ↓}
35: alu := tir; if n then goto 38; {if opcode = 1011.12x then goto 38 else next line}
...
{↓opcode = 1011.12x --------------------------------------------------------------- SUBL ---↓}
38: a := ir + sp; {SUBL: ac := ac – m[sp+x]}
39: mar := a; rd; goto 16; {SUBL performed by lines 38, 39, 16, 17, 18}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
51 /87
... 4.4.2 Thí dụ về một vi chương trình0: mar := pc; rd; {main loop. Fetch an Instruction}1: pc := pc+1; rd; {increment pc, and keep on reading}2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}...28: tir := lshift(ir+ir); if n then goto 40; {if opcode = 11xx.12x then goto 40 else next line}...
40: tir := lshift(tir); if n then goto 46; {if opcode = 111x.12x then goto 46 else next line}
{↓opcode = 110x.12x -------------------------------------------------------------------------- ↓}
41: alu := tir; if n then goto 44; {if opcode = 1101.12x then goto 44 else next line}
{↓opcode = 1100.12x -------------------------------------------------------------- JNEG --- ↓}
42: alu := ac; if n then goto 22; {JNEG: if ac< 0 then pc := x; performed by lines 42, 43/22}
43: goto 0; {ac > 0, so no jump: going to fetch next instruction}
{↑--------------------------------------------------------------------------------------- JNEG ---↑}
{↓opcode = 1101.12x -------------------------------------------------------------- JNZE --- ↓}
44: alu := ac; if z then goto 0; {JNZE: if ac<> 0 then pc := x}
45: pc := band(ir, amask); goto 0;
{↑--------------------------------------------------------------------------------------- JNZE ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
52 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}1: pc := pc+1; rd; {increment pc, and keep on reading}2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}...28: tir := lshift(ir+ir); if n then goto 40; {if opcode = 11xx.12x then goto 40 else next line}...40: tir := lshift(tir); if n then goto 46; {if opcode = 111x.12x then goto 46 else next line}...
{↓opcode = 111x.12x go from line 40 ------------------------------------------------------ ↓}
46: tir := lshift(tir); if n then goto 50; {if opcode = 1111.12x then goto 50 else next line}
{↓opcode = 1110.12x -------------------------------------------------------------- CALL --- ↓}
47: sp := sp + (-1); {CALL: sp := sp-1; m[sp] := pc; pc := x}
48: mar := sp; mbr := pc; wr;
49: pc := band(ir, amask); wr; goto 0;
{↑--------------------------------------------------------------------------------------- CALL ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
53 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}1: pc := pc+1; rd; {increment pc, and keep on reading}2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}...10: wr; goto 0; {keep on writing, going to fetch a next instruction}...28: tir := lshift(ir+ir); if n then goto 40; {if opcode = 11xx.12x then goto 40 else next line}...40: tir := lshift(tir); if n then goto 46; {if opcode = 111x.12x then goto 46 else next line}...46: tir := lshift(tir); if n then goto 50; {if opcode = 1111.12x then goto 50 else next line}...
50: tir := lshift(tir); if n then goto 65; {if opcode=1111.1xxx.xxxx.xxxx then goto 65 else next line}
51: tir := lshift(tir); if n then goto 59; {if opcode=1111.01xx.xxxx.xxxx then goto 59 else next line}
52: alu := tir; if n then goto 56; {if opcode=1111.001x.xxxx.xxxx then goto 56 else next line}
{↓opcode = 1111.000x.xxxx.xxxx--------------------------------------------------- PSHI --- ↓}
53: mar := ac; rd; {PSHI: sp := sp-1; m[sp] := m[ac]}
54: sp := sp + (-1); rd;
55: mar := sp; wr; goto 10;
{↑--------------------------------------------------------------------------------------- PSHI ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
54 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}1: pc := pc+1; rd; {increment pc, and keep on reading}2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}...10: wr; goto 0; {keep on writing, going to fetch a next instruction}...28: tir := lshift(ir+ir); if n then goto 40; {if opcode = 11xx.12x then goto 40 else next line}...40: tir := lshift(tir); if n then goto 46; {if opcode = 111x.12x then goto 46 else next line}...46: tir := lshift(tir); if n then goto 50; {if opcode = 1111.12x then goto 50 else next line}...50: tir := lshift(tir); if n then goto 65; {if opcode=1111.1xxx.xxxx.xxxx then goto 65 else next line}51: tir := lshift(tir); if n then goto 59; {if opcode=1111.01xx.xxxx.xxxx then goto 59 else next line}52: alu := tir; if n then goto 56; {if opcode=1111.001x.xxxx.xxxx then goto 56 else next line}...{↓opcode = 1111.001x.xxxx.xxxx------------------------------------------------- POPI --- ↓}56: mar := sp; sp := sp + 1; rd; {POPI: m[ac] := m[sp]; sp := sp+1}57: rd; {keep on reading}58: mar := ac; wr; goto 10;{↑--------------------------------------------------------------------------------------- POPI ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
55 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}1: pc := pc+1; rd; {increment pc, and keep on reading}2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}...10: wr; goto 0; {keep on writing, going to fetch a next instruction}...28: tir := lshift(ir+ir); if n then goto 40; {if opcode = 11xx.12x then goto 40 else next line}...40: tir := lshift(tir); if n then goto 46; {if opcode = 111x.12x then goto 46 else next line}...46: tir := lshift(tir); if n then goto 50; {if opcode = 1111.12x then goto 50 else next line}...50: tir := lshift(tir); if n then goto 65; {if opcode=1111.1xxx.xxxx.xxxx then goto 65 else next line}
51: tir := lshift(tir); if n then goto 59; {if opcode=1111.01xx.xxxx.xxxx then goto 59 else next line}
...
59: alu := tir; if n then goto 62; {if opcode=1111.011x.xxxx.xxxx then goto 62 else next line}
{↓opcode = 1111.010x.xxxx.xxxx------------------------------------------------- PUSH --- ↓}
60: sp := sp + (-1); {PUSH: sp := sp-1; m[sp] := ac}
61: mar := sp; mbr := ac; wr; goto 10; {10: wr; goto 0}
{↑--------------------------------------------------------------------------------------- PUSH ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
56 /87
... 4.4.2 Thí dụ về một vi chương trình0: mar := pc; rd; {main loop. Fetch an Instruction}1: pc := pc+1; rd; {increment pc, and keep on reading}2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}...28: tir := lshift(ir+ir); if n then goto 40; {if opcode = 11xx.12x then goto 40 else next line}...40: tir := lshift(tir); if n then goto 46; {if opcode = 111x.12x then goto 46 else next line}...46: tir := lshift(tir); if n then goto 50; {if opcode = 1111.12x then goto 50 else next line}...50: tir := lshift(tir); if n then goto 65; {if opcode=1111.1xxx.xxxx.xxxx then goto 65 else next line}51: tir := lshift(tir); if n then goto 59; {if opcode=1111.01xx.xxxx.xxxx then goto 59 else next line}...
59: alu := tir; if n then goto 62; {if opcode=1111.011x.xxxx.xxxx then goto 62 else next line}
...
{↓opcode = 1111.011x.xxxx.xxxx--------------------------------------------------- POP --- ↓}
62: mar := sp; sp := sp + 1; rd; {POP: ac := m[sp]; sp := sp+1}
63: rd;
64: ac := mbr; goto 0;
{↑----------------------------------------------------------------------------------------- POP ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
57 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}1: pc := pc+1; rd; {increment pc, and keep on reading}2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}...28: tir := lshift(ir+ir); if n then goto 40; {if opcode = 11xx.12x then goto 40 else next line}...40: tir := lshift(tir); if n then goto 46; {if opcode = 111x.12x then goto 46 else next line}...46: tir := lshift(tir); if n then goto 50; {if opcode = 1111.12x then goto 50 else next line}...50: tir := lshift(tir); if n then goto 65; {if opcode=1111.1xxx.xxxx.xxxx then goto 65 else next line}...
65: tir := lshift(tir); if n then goto 73; {if opcode=1111.11xx.xxxx.xxxx (INSP| DESP) then goto 73 else next line}
{↓opcode = 1111.10xx.xxxx.xxxx-------------------------------------------------- RETN or SAWP --- ↓}
66: alu := tir; if n then goto 70; {if opcode=1111.101x.xxxx.xxxx then goto 70 else next line}
{↓opcode = 1111.100x.xxxx.xxxx---------------------------------------------------RETN --- ↓}
67: mar := sp; sp := sp + 1; rd; {RETN: pc := m[sp]; sp := sp+1}
68: rd;
69: pc := mbr; goto 0;
{↑---------------------------------------------------------------------------------------- RETN ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
58 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}1: pc := pc+1; rd; {increment pc, and keep on reading}2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}...28: tir := lshift(ir+ir); if n then goto 40; {if opcode = 11xx.12x then goto 40 else next line}...40: tir := lshift(tir); if n then goto 46; {if opcode = 111x.12x then goto 46 else next line}...46: tir := lshift(tir); if n then goto 50; {if opcode = 1111.12x then goto 50 else next line}...50: tir := lshift(tir); if n then goto 65; {if opcode=1111.1xxx.xxxx.xxxx then goto 65 else next line}...
65: tir := lshift(tir); if n then goto 73; {if opcode=1111.11xx.xxxx.xxxx (INSP| DESP) then goto 73 else next line}
66: alu := tir; if n then goto 70; {if opcode=1111.101x.xxxx.xxxx then goto 70 else next line}
...
{↓opcode = 1111.101x.xxxx.xxxx------------------------------------------------- SWAP --- ↓}
70: a := ac; {SWAP ac, sp}
71: ac := sp;
72: sp := a; goto 0;
{↑--------------------------------------------------------------------------------------- SWAP ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
59 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}1: pc := pc+1; rd; {increment pc, and keep on reading}2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}...28: tir := lshift(ir+ir); if n then goto 40; {if opcode = 11xx.12x then goto 40 else next line}...40: tir := lshift(tir); if n then goto 46; {if opcode = 111x.12x then goto 46 else next line}...46: tir := lshift(tir); if n then goto 50; {if opcode = 1111.12x then goto 50 else next line}...50: tir := lshift(tir); if n then goto 65; {if opcode=1111.1xxx.xxxx.xxxx then goto 65 else next line}...
65: tir := lshift(tir); if n then goto 73; {if opcode=1111.11xx.xxxx.xxxx (INSP| DESP) then goto 73 else next line}
...
73: alu := tir; if n then goto 76; {if opcode=1111.111x.xxxx.xxxx (DESP) then goto 76 else next
line}
{↓opcode = 1111.110x.xxxx.xxxx-------------------------------------------------- INSP --- ↓}
74: a := band(ir, smask); {INSP: sp := sp+y, (y = 8-bit)}
75: sp := sp + a; goto 0;
{↑--------------------------------------------------------------------------------------- INSP ---↑}
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
60 /87
... 4.4.2 Thí dụ về một vi chương trình
0: mar := pc; rd; {main loop. Fetch an Instruction}1: pc := pc+1; rd; {increment pc, and keep on reading}2: ir := mbr; if n then goto 28; {save, if opcode = 1xxx.12x then goto 28}...28: tir := lshift(ir+ir); if n then goto 40; {if opcode = 11xx.12x then goto 40 else next line}...40: tir := lshift(tir); if n then goto 46; {if opcode = 111x.12x then goto 46 else next line}...46: tir := lshift(tir); if n then goto 50; {if opcode = 1111.12x then goto 50 else next line}...50: tir := lshift(tir); if n then goto 65; {if opcode=1111.1xxx.xxxx.xxxx then goto 65 else next line}...65: tir := lshift(tir); if n then goto 73; {if opcode=1111.11xx.xxxx.xxxx (INSP| DESP) then goto 73 else
next line}...
73: alu := tir; if n then goto 76; {if opcode=1111.111x.xxxx.xxxx (DESP) then goto 76 else next line}
...
75: sp := sp + a; goto 0;
{↓opcode = 1111.111x.xxxx.xxxx------------------------------------------------ DESP --- ↓}
76: a := band(ir, smask); {DESP: sp := sp-y, (y = 8-bit)}
77: a := inv(a);
78: a := a + 1; goto 75;
BỘ MÔN KỸ THUẬT MÁY TÍNH – KHOA ĐIỆN TỬ
61 /87
4.5 Những vấn đề cần cân nhắc, lựa chọn khi
thiết kế mức vi chương trình
4.5.1 Vi chỉ thị theo chiều đứng và theo chiều ngang
(SV tự đọc)
4.5.2 Lập siêu vi chương trình – Nanoprogramming
(SV tự đọc)
4.5.3 Đường ống dẫn chỉ thị và các chỉ thị nhảy: SV tự
đọc