bgktmt ch4 mức vi lập trình

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


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


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ờ)


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ý


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


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


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


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


9 /87

THANH GHI

Đỉnh Stack

Đáy Stack

SPCÊt

vµo

LÊy raChiÒu t¨ng cña

®Þa chØ


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


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


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)


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


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.


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


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.


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.


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.


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


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.


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.


22 /87

4.2.2 Vi chỉ thị: khuôn dạng gồm 13 trường


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)


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).


25 /87


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.

...


26 /87


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.


27 /87


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.


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.


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


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ị


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ị.


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ỏ.


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).


34 /87


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ộ.


35 /87


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.


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]


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


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)


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)


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


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 ---↑}


42 /87





3: tir :=lshift(ir+ir); if n then goto 19; {if opcode = 01xx.12x then goto 19 else

next line}



...

{↓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 ---↑}


43 /87





3: tir :=lshift(ir+ir); if n then goto 19; {if opcode = 01xx.12x then goto 19

else next line}


...

{↓opcode = 001x.12x ----------------------------------------------- ADDD or SUBD ---↓}


{↓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 ---↑}


44 /87







...

{↓opcode = 001x.12x ----------------------------------------------- ADDD or SUBD ---↓}


...

{↓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 ---↑}


45 /87






...

{↓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 ---↑}


46 /87


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--- ↓}


{↓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 ---↑}


47 /87


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 --------------------------------------------------------------------- ↓}


{↓opcode = 100x.12x --------------------------------------------------------------------- ↓}


{↓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 ---↑}


48 /87





...

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 = 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 ----↑}


49 /87


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 --------------------------------------------------------------------------- ↓}


{↓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 ----↑ }


50 /87


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 --------------------------------------------------------------------------- ↓}


...

{↓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}


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}...


{↓opcode = 110x.12x -------------------------------------------------------------------------- ↓}


{↓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 ---↑}


52 /87


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 ---↑}


53 /87


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 ---↑}


54 /87


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 ---↑}


55 /87


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}

...


{↓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 ---↑}


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}...


...

{↓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 ---↑}


57 /87


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 --- ↓}


{↓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 ---↑}


58 /87





...

{↓opcode = 1111.101x.xxxx.xxxx------------------------------------------------- SWAP --- ↓}

70: a := ac; {SWAP ac, sp}

71: ac := sp;

72: sp := a; goto 0;

{↑--------------------------------------------------------------------------------------- SWAP ---↑}


59 /87




...

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 ---↑}


60 /87


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;


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

bgktmt ch4 mức vi lập trình

Technology