Bài giảng Kiến trúc máy tính - Chương 5: Kiến trúc tập lệnh - Nguyễn Kim Khánh

 và 3)
n $t0 – $t9: các giá trị tạm thời
n Có thể được ghi lại bởi thủ tục được gọi
n $s0 – $s7: cất giữ các biến
n Cần phải cất/khôi phục bởi thủ tục được gọi
n $gp: global pointer - con trỏ toàn cục cho dữ liệu 
tĩnh (thanh ghi 28)
n $sp: stack pointer - con trỏ ngăn xếp (thanh ghi 29)
n $fp: frame pointer - con trỏ khung (thanh ghi 30)
n $ra: return address - địa chỉ trở về (thanh ghi 31)
2017 Kiến trúc máy tính 276
NKK-HUST
Các lệnh gọi thủ tục
n Gọi thủ tục: jump and link
jal ProcedureAddress
n Địa chỉ của lệnh kế tiếp (địa chỉ trở về) được cất ở 
thanh ghi $ra
n Nhảy đến địa chỉ của thủ tục
n Trở về từ thủ tục: jump register
jr $ra
n Copy nội dung thanh ghi $ra (đang chứa địa chỉ trở về) 
trả lại cho bộ đếm chương trình PC
2017 Kiến trúc máy tính 277
NKK-HUST
Minh họa gọi Thủ tục
jal proc 
jr $ra 
proc 
Save, etc. 
Restore 
PC 
Prepare 
to continue 
Prepare 
to call 
main 
2017 Kiến trúc máy tính 278
NKK-HUST
Gọi thủ tục lồng nhau
jal abc 
jr $ra 
abc 
Save 
Restore 
PC 
Prepare 
to continue 
Prepare 
to call 
main 
jal xyz 
jr $ra 
xyz 
Procedure 
abc 
Procedure 
xyz 
2017 Kiến trúc máy tính 279
NKK-HUST
Ví dụ Thủ tục lá
n Thủ tục lá là thủ tục không có lời gọi thủ tục khác
n Mã C:
int leaf_example (int g, h, i, j)
{ 
int f;
f = (g + h) - (i + j);
return f;
}
n Các tham số g, h, i, j ở $a0, $a1, $a2, $a3
n f ở $s0 (do đó, cần cất $s0 ra ngăn xếp)
n $t0 và $t1 được thủ tục dùng để chứa các giá trị tạm 
thời, cũng cần cất trước khi sử dụng
n Kết quả ở $v0
2017 Kiến trúc máy tính 280
NKK-HUST
Mã hợp ngữ MIPS
2017 Kiến trúc máy tính 281
leaf_example:
addi $sp, $sp, -12
sw $t1, 8($sp)
sw $t0, 4($sp)
sw $s0, 0($sp)
add $t0, $a0, $a1
add $t1, $a2, $a3
sub $s0, $t0, $t1
add $v0, $s0, $zero
lw $s0, 0($sp)
lw $t0, 4($sp) 
lw $t1, 8($sp)
addi $sp, $sp, 12 
jr $ra
# tạo 3 vị trí ở stack
# cất nội dung $t1
# cất nội dung $t0
# cất nội dung $s0
# $t0 = g+h
# $t1 = i+j
# $s0 = (g+h)-(i+j)
# trả kết quả sang $v0
# khôi phục $s0
# khôi phục $t0 
# khôi phục $t1 
# xóa 3 mục ở stack 
# trở về nơi đã gọi
NKK-HUST
Ví dụ Thủ tục cành
n Là thủ tục có gọi thủ tục khác
n Mã C:
int fact (int n)
{ 
if (n < 1) return (1);
else return n * fact(n - 1);
}
n Tham số n ở $a0
n Kết quả ở $v0
2017 Kiến trúc máy tính 282
NKK-HUST
Mã hợp ngữ MIPS
2017 Kiến trúc máy tính 283
fact:
addi $sp, $sp, -8
sw $ra, 4($sp) 
sw $a0, 0($sp) 
slti $t0, $a0, 1 
beq $t0, $zero, L1
addi $v0, $zero, 1 
addi $sp, $sp, 8 
jr $ra 
L1: addi $a0, $a0, -1
jal fact 
lw $a0, 0($sp)
lw $ra, 4($sp)
addi $sp, $sp, 8
mul $v0, $a0, $v0 
jr $ra 
# dành stack cho 2 mục 
# cất địa chỉ trở về
# cất tham số n
# kiểm tra n < 1
# nếu đúng, kết quả là 1
# lấy 2 mục từ stack 
# và trở về
# nếu không, giảm n 
# gọi đệ qui
# khôi phục n ban đầu
# và địa chỉ trở về
# lấy 2 mục từ stack
# nhân để nhận kết quả
# và trở về
NKK-HUST
Sử dụng Stack khi gọi thủ tục
b 
a 
$sp c 
Frame for 
current 
procedure 
$fp 
. . . 
Before calling 
b 
a 
$sp 
c 
Frame for 
previous 
procedure 
$fp 
. . . 
After calling 
Frame for 
current 
procedure 
Old ($fp) 
Saved 
registers 
y 
z 
. . . 
Local 
variables 
2017 Kiến trúc máy tính 284
NKK-HUST
6. Dữ liệu ký tự
n Các tập ký tự được mã hóa theo byte
n ASCII: 128 ký tự
n 95 ký thị hiển thị , 33 mã điều khiển
n Latin-1: 256 ký tự
n ASCII và các ký tự mở rộng
n Unicode: Tập ký tự 32-bit
n Được sử dụng trong Java, C++, 
n Hầu hết các ký tự của các ngôn ngữ trên thế 
giới và các ký hiệu
2017 Kiến trúc máy tính 285
NKK-HUST
Các thao tác với Byte/Halfword
n Có thể sử dụng các phép toán logic
n Nạp/Lưu byte/halfword trong MIPS
n lb rt, offset(rs) lh rt, offset(rs)
n Mở rộng theo số có dấu thành 32 bits trong rt 
n lbu rt, offset(rs) lhu rt, offset(rs)
n Mở rộng theo số không dấu thành 32 bits trong rt
n sb rt, offset(rs) sh rt, offset(rs)
n Chỉ lưu byte/halfword bên phải
2017 Kiến trúc máy tính 286
NKK-HUST
Ví dụ copy String
n Mã C:
void strcpy (char x[], char y[])
{ int i;
i = 0;
while ((x[i]=y[i])!='\0')
i += 1;
}
n Các địa chỉ của x, y ở $a0, $a1
n i ở $s0
2017 Kiến trúc máy tính 287
NKK-HUST
Ví dụ Copy String
n Mã hợp ngữ MIPS
strcpy:
addi $sp, $sp, -4 # adjust stack for 1 item
sw $s0, 0($sp) # save $s0
add $s0, $zero, $zero # i = 0
L1: add $t1, $s0, $a1 # addr of y[i] in $t1
lbu $t2, 0($t1) # $t2 = y[i]
add $t3, $s0, $a0 # addr of x[i] in $t3
sb $t2, 0($t3) # x[i] = y[i]
beq $t2, $zero, L2 # exit loop if y[i] == 0 
addi $s0, $s0, 1 # i = i + 1
j L1 # next iteration of loop
L2: lw $s0, 0($sp) # restore saved $s0
addi $sp, $sp, 4 # pop 1 item from stack
jr $ra # and return
2017 Kiến trúc máy tính 288
NKK-HUST
7. Các lệnh nhân và chia số nguyên
2017 Kiến trúc máy tính 289
n MIPS có hai thanh ghi 32-bit: HI (high) và LO (low)
n Các lệnh liên quan:
n mult rs, rt # nhân số nguyên có dấu
n multu rs, rt # nhân số nguyên không dấu
n Tích 64-bit nằm trong cặp thanh ghi HI/LO
n div rs, rt # chia số nguyên có dấu
n divu rs, rt # chia số nguyên không dấu
n HI: chứa phần dư, LO: chứa thương
n mfhi rd # Move from Hi to rd
n mflo rd # Move from LO to rd
NKK-HUST
8. Các lệnh với số dấu phẩy động (FP)
n Các thanh ghi số dấu phẩy động
n 32 thanh ghi 32-bit (single-precision): $f0, $f1,  $f31
n Cặp đôi để chứa dữ liệu dạng 64-bit (double-precision): 
$f0/$f1, $f2/$f3, 
n Các lệnh số dấu phẩy động chỉ thực hiện trên các 
thanh ghi số dấu phẩy động
n Lệnh load và store với FP
n lwc1, ldc1, swc1, sdc1
n Ví dụ: ldc1 $f8, 32($s2)
2017 Kiến trúc máy tính 290
NKK-HUST
Các lệnh với số dấu phẩy động
n Các lệnh số học với số FP 32-bit (single-precision)
n add.s, sub.s, mul.s, div.s
n VD: add.s $f0, $f1, $f6
n Các lệnh số học với số FP 64-bit (double-precision)
n add.d, sub.d, mul.d, div.d
n VD: mul.d $f4, $f4, $f6
n Các lệnh so sánh
n c.xx.s, c.xx.d (trong đó xx là eq, lt, le, )
n Thiết lập hoặc xóa các bit mã điều kiện
n VD: c.lt.s $f3, $f4
n Các lệnh rẽ nhánh dựa trên mã điều kiện
n bc1t, bc1f
n VD: bc1t TargetLabel
2017 Kiến trúc máy tính 291
NKK-HUST
5.5. Các phương pháp định địa chỉ của MIPS
n Các lệnh Branch chỉ ra:
n Mã thao tác, hai thanh ghi, hằng số
n Hầu hết các đích rẽ nhánh là rẽ nhánh gần
n Rẽ xuôi hoặc rẽ ngược
op rs rt imm 
6 bits 5 bits 5 bits 16 bits
n Định địa chỉ tương đối với PC 
n PC-relative addressing
n Địa chỉ đích = PC + hằng số imm × 4
n Chú ý: trước đó PC đã được tăng lên
n Hằng số imm 16-bit có giá trị trong dải [-215 , +215 - 1]
2017 Kiến trúc máy tính 292
NKK-HUST
Lệnh beq, bne
2017 Kiến trúc máy tính 293
beq $s0, $s1, Exit
bne $s0, $s1, Exit
4 or 5 16 17 Exit
000100 10000 10001 0000 0000 0000 0110
op rs rt imm 
6 bits 5 bits 5 bits 16 bits
Lệnh mã máy
beq
000101 10000 10001 0000 0000 0000 0110bne
khoảng cách tương đối tính theo word
NKK-HUST
Địa chỉ hóa cho lệnh Jump 
n Đích của lệnh Jump (j và jal) có thể là bất 
kỳ chỗ nào trong chương trình
n Cần mã hóa đầy đủ địa chỉ trong lệnh
op address
6 bits 26 bits
n Định địa chỉ nhảy (giả) trực tiếp 
(Pseudo)Direct jump addressing
n Địa chỉ đích = PC3128 : (address × 4)
2017 Kiến trúc máy tính 294
NKK-HUST
Ví dụ mã lệnh j và jr
j L1 # nhảy đến vị trí có nhãn L1
jr $ra # nhảy đến vị trí có địa chỉ ở $ra;
# $ra chứa địa chỉ trở về
0 
0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 
31 0 
j = 2 
op jump target address 
J 
Effective target address (32 bits) 
25 
 From PC 
0 0 
x x x x 
0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 
31 25 20 15 0 
ALU 
instruction 
Source 
register 
Unused 
op rs rt 
R 
rd sh 
10 5 
fn 
Unused Unused jr = 8 
2017 Kiến trúc máy tính 295
NKK-HUST
Ví dụ mã hóa lệnh 
Loop: sll $t1, $s3, 2 0x8000 0 0 19 9 2 0
add $t1, $t1, $s6 0x8004 0 9 22 9 0 32
lw $t0, 0($t1) 0x8008 35 9 8 0
bne $t0, $s5, Exit 0x800C 5 8 21 2
addi $s3, $s3, 1 0x8010 8 19 19 1
j Loop 0x8014 2 0x2000
Exit:  0x8018
2017 Kiến trúc máy tính 296
NKK-HUST
Rẽ nhánh xa
n Nếu đích rẽ nhánh là quá xa để mã hóa với 
offset 16-bit, assembler sẽ viết lại code
n Ví dụ
beq $s0, $s1, L1
(lệnh kế tiếp)
...
L1:
sẽ được thay bằng đoạn lệnh sau:
bne $s0, $s1, L2
j L1
L2: (lệnh kế tiếp)
...
L1:
2017 Kiến trúc máy tính 297
NKK-HUST
Tóm tắt về các phương pháp định địa chỉ
1. Định địa chỉ tức thì
2. Định địa chỉ thanh ghi
3. Định địa chỉ cơ sở
4. Định địa chỉ tương đối với PC
5. Định địa chỉ giả trực tiếp
2017 Kiến trúc máy tính 298
Although we show MIPS as having 32-bit addresses, nearly all microprocessors 
(including MIPS) have 64-bit address extensions (see Appendix E and Section 
2.18). ! ese extensions were in response to the needs of so" ware for larger 
programs. ! e process of instruction set extension allows architectures to expand in 
such a way that is able to move so" ware compatibly upward to the next generation 
of architecture.
Hardware/
Software 
Interface
1. Immediate addressing
2. Register addressing
3. Base addressing
4. PC-relative addressing
5. Pseudodirect addressing
Immediateop rs rt
op rs rt . . . functrd
Register
Registers
op rs rt Address
Word
Memory
+Register HalfwordByte
op rs rt Address
Word
Memory
+PC
op
Word
Memory
PC
Address
FIGURE 2.18 Illustration of the fi ve MIPS addressing modes. ! e operands are shaded in color. 
! e operand of mode 3 is in memory, whereas the operand for mode 2 is a register. Note that versions of 
load and store access bytes, halfwords, or words. For mode 1, the operand is 16 bits of the instruction itself. 
Modes 4 and 5 address instructions in memory, with mode 4 adding a 16-bit address shi" ed le" 2 bits to the 
PC and mode 5 concatenating a 26-bit address shi" ed le" 2 bits with the 4 upper bits of the PC. Note that a 
single operation can use more than one addressing mode. Add, for example, uses both immediate (addi) 
and register (add) addressing.
 2.10 MIPS Addressing for 32-bit Immediates and Addresses 117
NKK-HUST
5.6. Dịch và chạy chương trình hợp ngữ
n Các phần mềm lập trình hợp ngữ MIPS: 
n MARS 
n MipsIt
n QtSpim
n MIPS Reference Data
2017 Kiến trúc máy tính 299
NKK-HUST
Dịch và chạy ứng dụng
Assembly Code
High Level Code
Compiler
Object File
Assembler
Executable
Linker
Memory
Loader
Object Files
Library Files
2017 Kiến trúc máy tính 300
NKK-HUST
Chương trình trong bộ nhớ
n Các lệnh (instructions)
n Dữ liệu
n Toàn cục/tĩnh: được cấp phát trước khi chương trình 
bắt đầu thực hiện
n Động: được cấp phát trong khi chương trình thực 
hiện
n Bộ nhớ:
n 232 bytes = 4 GiB
n Địa chỉ từ 0x00000000 đến 0xFFFFFFFF
2017 Kiến trúc máy tính 301
NKK-HUST
Bản đồ bộ nhớ của MIPS
SegmentAddress
0xFFFFFFFC
0x80000000
0x7FFFFFFC
0x10010000
0x1000FFFC
0x10000000
0x0FFFFFFC
0x00400000
0x003FFFFC
0x00000000
Reserved
Stack
Heap
Static Data
Text
Reserved
Dynamic Data
2017 Kiến trúc máy tính 302
NKK-HUST
Ví dụ: Mã C 
int f, g, y; // global 
variables
int main(void) 
{
f = 2;
g = 3;
y = sum(f, g);
return y;
}
int sum(int a, int b) {
return (a + b);
}
2017 Kiến trúc máy tính 303
NKK-HUST
Ví dụ chương trình hợp ngữ MIPS
.data
f:
g:
y:
.text
main:
addi $sp, $sp, -4 # stack frame
sw $ra, 0($sp) # store $ra
addi $a0, $0, 2 # $a0 = 2
sw $a0, f # f = 2
addi $a1, $0, 3 # $a1 = 3
sw $a1, g # g = 3
jal sum # call sum
sw $v0, y # y = sum()
lw $ra, 0($sp) # restore $ra
addi $sp, $sp, 4 # restore $sp
jr $ra # return to OS
sum:
add $v0, $a0, $a1 # $v0 = a + b
jr $ra # return
2017 Kiến trúc máy tính 304
NKK-HUST
Bảng ký hiệu
Ký hiệu Địa chỉ
f 0x10000000
g 0x10000004
y 0x10000008
main 0x00400000
sum 0x0040002C
2017 Kiến trúc máy tính 305
NKK-HUST
Chương trình thực thi
2017 Kiến trúc máy tính 306
Step 3: Linking
Most large programs contain more than one file. If the programmer
changes only one of the files, it would be wasteful to recompile and reas-
semble the other files. In particular, programs often call functions in
library files; these library files almost never change. If a file of high-level
code is not changed, the associated object file need not be updated.
The job of the linker is to combine all of the object files into one
machine language file called the executable. The linker relocates the data
and instructions in the object files so that they are not all on top of each
other. It uses the information in the symbol tables to adjust the addresses
of global variables and of labels that are relocated.
In our example, there is only one object file, so no relocation is
necessary. Figure 6.33 shows the executable file. It has three sections:
the executable file header, the text segment, and the data segment.
The executable file header reports the text size (code size) and data size
(amount of globally declared data). Both are given in units of bytes. The
text segment gives the instructions in the order that they are stored in
memory.
The figure shows the instructions in human-readable format next to
the machine code for ease of interpretation, but the executable file
includes only machine instructions. The data segment gives the address
of each global variable. The global variables are addressed with respect
to the base address given by the global pointer, $gp. For example, the first
Executable file header Text Size Data Size 
Text segment 
Data segment 
Address 
Address 
0x00400000 
0x00400004 
0x00400008 
0x0040000C 
0x00400010 
0x00400014 
0x00400018 
0x0040001C 
0x00400020 
0x00400024 
0x00400028 
0x0040002C 
0x00400030 
addi $sp, $sp, –4 
sw $ra, 0($sp)
addi $a0, $0, 2 
sw $a0, 0x8000($gp)
addi $a1, $0, 3 
sw $a1, 0x8004($gp)
jal 0x0040002C 
sw $v0, 0x8008($gp)
lw $ra, 0($sp)
addi $sp, $sp, –4 
jr $ra 
add $v0, $a0, $a1 
jr $ra 
0x10000000 
0x10000004 
0x10000008 
f 
g 
y 
0xC (12 bytes) 0x34 (52 bytes) 
0x23BDFFFC 
0xAFBF0000 
0x20040002
0xAF848000 
0x20050003 
0xAF858004 
0x0C10000B 
0xAF828008 
0x8FBF0000 
0x23BD0004 
0x03E00008 
0x00851020 
0x03E00008
Instruction 
Data
Figure 6.33 Executable
340 CHAPTER SIX Architecture
NKK-HUST
Chương trình trong bộ nhớ
y
g
f
0x03E00008
0x00851020
0x03E00008
0x23BD0004
0x8FBF0000
0xAF828008
0x0C10000B
0xAF858004
0x20050003
0xAF848000
0x20040002
0xAFBF0000
0x23BDFFFC
MemoryAddress
$sp = 0x7FFFFFFC0x7FFFFFFC
0x10010000
0x00400000
Stack
Heap
$gp = 0x10008000
PC = 0x00400000
0x10000000
Reserved
Reserved
2017 Kiến trúc máy tính 307
NKK-HUST
Ví dụ lệnh giả (Pseudoinstruction)
Pseudoinstruction MIPS Instructions
li $s0, 0x1234AA77 lui $s0, 0x1234
ori $s0, 0xAA77
mul $s0, $s1, $s2 mult $s1, $s2
mflo $s0
clear $t0 add $t0, $0, $0
move $s1, $s2 add $s2, $s1, $0
nop sll $0, $0, 0
2017 Kiến trúc máy tính 308
NKK-HUST
Hết chương 5
2017 Kiến trúc máy tính 309