2.1 Sinh viên tìm hiểu tài liệu “Một số lệnh assembly MIPS cơ bản” và mơ phỏng
Lệnh (code)
Giải thích
Chức năng
add $1, $2, $3
$1 = $2 + $3
Cộng 2 giá trị (kết quả có dấu)
addi $1, $2, 3
$1 = $2 + 3
Cộng 1 giá trị với 1 hằng số (kết
quả có dấu)
addu $1, $2, $3
$1 = $2 + $3
Cộng 2 giá trị (kết quả khơng có
dấu)
addiu $1, $2, $3
$1 = $2 + 3
Cộng 1 giá trị với 1 hằng số (kết
quả khơng có dấu)
sub $1, $2, $3
$1 = $2 - $3
Trừ 2 giá trị (kết quả có dấu)
subu $1, $2, $3
$1 = $2 - 3
Trừ 1 giá trị với 1 hằng số (kết
quả khơng có dấu)
and $1, $2, $3
$1 = $2 & $3
Phép toán logic và
andi $1, $2, 3
$1 = $2 & 3

Phép tốn logic và (có hằng số)
or $1, $2, $3
nor $1, $2, $3
lw $1, 20($2)

$1 = $2 | $3
$1 = ~($2 | $3)
$1 = Memory[$2+20]

sw $1, 20($2)

$1 = Memory[$2+20]

slt $1, $2, $3

if ($2 < $3) $1 = 1;
else $1 = 0
if ($2 < 3) $1 = 1;
else $1 = 0
if ($2 < $3) $1 = 1;
else $1 = 0
if ($2 < 3) $1 = 1;
else $1 = 0

slti $1, $2, $3
sltu $1, $2, $3
sltiu $1, $2, $3

Phép toán logic hoặc
Phép toán logic Not -> or

Chép 1 word (4 byte) tại vị trí
trong bộ nhớ RAM vào thanh
ghi
Lưu 1 word trong thanh ghi vào
vị trí trong bộ nhớ RAM
So sánh bé hơn
So sánh bé hơn hằng số
So sánh bé hơn không dấu
So sánh bé hơn hằng số không
dấu
Được gọi như 1 input và output

syscall
việc thực thi các lệnh và cho biết chức năng của các lệnh cơ bản sau:

add, addi, addu, addiu, sub, subu, and, andi, or, nor, lw, sw, slt, slti, sltu, sltiu, syscall

Code
.data
var1: .word
.text
__start:
lw
li
sw

23
$t0, var1
$t1,5
$t1,var1


Giải thích
# Khai báo vùng nhớ data
# gán var1 = 23 (kiểu int)
# Khai báo vùng nhớ chứa mã lệnh
#Code
# gán $t0 = var1 = 23
# gán $t1 = 5
# cho var1 = $t1 hay var1 = 5


.data
array1: .space 12
.text
__start:
la $t0,array1
li $t1,5
sw $t1,($t0)
li $t1,13
sw $t1, 4($t0)
li $t1, -7
sw $t1, 8($t0)
li $v0,5
syscall
.data
string1: .asciiz "Print this. \n"
.text
main: li $v0,4
la $a0,string1
syscall


# mảng arr1 có kích thước 12 byte liên tục
# Gán mảng arr1 là $t0
# Gán $t1=5
#lưu $t1 với 0 byte = 5 vào mảng $t0
# Gán $t1=13
#lưu $t1 có 4 byte = 13 vào mảng $t0
# Gán $t1= -7
#lưu $t1 có 8 byte = -7 vào mảng $t0
# Gán $v0=5
#sau khi kết thúc lệnh syscall thì ta nhập vào
#lại giá trị $v0
#lệnh cout trong c++
#$v0 = 4
#load địa chỉ của string1 vào thanh ghi $a0
#xuất ra thanh ghi $a0

Bài 3
A,

Code
.data
chuoi1: .asciiz "Chao ban! Ban la sinh
vien nam thu may? \n"
chuoi2: .asciiz "Hihi, minh la sinh vien
nam thu 1 ^-^"
.text
la $a0,chuoi1
li $v0,4
move $t1,$v0

syscall
la $a0,chuoi2
li $v0,4
move $t2,$v0
syscall

Giải thích
# Khai báo vùng nhớ data
# cout chuoi1
#
# cout chuoi2
#
# code
# load địa chỉ chuoi1 vào thanh ghi $a0
# lưu $v0 với địa chỉ $a0
# lưu $v0 vào $t1 tránh bị trùng $a0 sau
# in chuoi1
# load địa chỉ chuoi2 vào thanh ghi $a0
# lưu $v0 với địa chỉ $a0
# lưu $v0 vào $t2
# in chuoi2


B,Biểu diễn nhị phân của 2 chuỗi là

C,

Code
.data
chuoi: .asciiz

.text
li $v0,8
la $a0,chuoi
li $a1,30
syscall
li $v0,4
move $t1,$v0
syscall

Giải thích
# Khai báo vùng nhớ data
#
#
# viết chuỗi
# load địa chỉ chuoi vào thanh ghi $a0
# số kí tự tối đa có thể nhập là 29
# nhập
#
# lưu $v0 với địa chỉ $a0
# lưu $v0 vào $t1 tránh bị trùng $a0 sau
# in chuoi

d) Nhập vào 2 số nguyên sau đó xuất tổng của 2 số nguyên này

Code
.data
nhap1: .asciiz "Nhap So Thu 1: "
nhap2: .asciiz "Nhap So Thu 2: "
tong: .asciiz "Tong la: "
.text

main:
la $a0,nhap1
add $v0,$0,4
syscall
add $v0,$0,5
syscall
add $t0,$0,$v0
la $a0,nhap2
add $v0,$0,4
syscall
add $v0,$0,5
syscall

Giải thích
# Khai báo vùng nhớ data
# biến nhap1
# biến nhap2
# biến tổng
#
#
# load địa chỉ nhap1 vào thanh ghi $a0
# lưu $v0 với địa chỉ $a0
# nhập
#
# Gán $v0=5 -> in
# in biến
# lưu $t0 = $v0
#
# load địa chỉ nhap2 vào thanh ghi $a0
# lưu $v0 với địa chỉ $a0

#
#
# Gán $v0=5
# nhập


add $t1,$0,$v0
Tong:
add $t2,$t0,$t1
la $a0,tong
add $v0,$0,4
syscall
add $a0,$0,$t2
add $v0,$0,1
syscall

# Gán $t1 = $v0
#
#
# $t2 = $t0 + $t1
# load địa chỉ tong vào thanh ghi $a0
# lưu $v0 với địa chỉ $a0
#
#
# load địa chỉ $t2 vào thanh ghi $a0
# gán $v0 = 1 -> xuất
# Xuất

Bt thanm khảo
a,Assembly là gì? Assembly là một loại ngơn ngữ lập trình cấp thấp cho bộ vi xử lý và các thiết bị có thể

lập trình khác. Ngơn ngữ này có thể được tạo bằng cách biên dịch mã nguồn từ một ngôn ngữ lập trình
cấp cao, chẳng hạn như C, C++.
- Trình bày các q trình một chương trình viết bằng ngơn ngữ C/C++ được thực hiện trên máy tính?
Giai đồn tiền xử lý (Pre-processor) -> Giai đoạn dịch NNBC sang Asembly (Compiler) -> Giai đoạn dịch
asembly sang ngôn ngữ máy (Asember) -> Giai đoạn liên kết (Linker)
b. Trình bày các kiểu dữ liệu trong MIPS32 và kích thước của từng kiểu dữ liệu các kiểu dữ li êu:
+ .word 4 : biến nguyên có kích thước 1 word
+ .byte ‘a’, ‘c’: mảng có 2 phần tử, mỗi phần tử 1 byte
+ .space n : mảng có kích thước n byte liên tục
+ .asciiz “hello” : chuỗi có kết thúc bởi null
c. Trình bày cấu trúc bộ nhớ của một chương trình C++(layout memory).
- Memory layout của của một chương trình C/C++ gồm 5 phần chính: Text Segment, Initialized Data
Segment, Uninitialized Data Segment, Heap và Stack

d.Viết chương trình hợp ngữ nhập vào ba số a,b,c. Kiểm tra và in ra số lớn nhất, số bé
nhất(khơng dùng vịng lặp)


Code
.data
_a: .asciiz "a = "
_b: .asciiz "b = "
_c: .asciiz "c = "
_max:.asciiz "max = "
_min: .asciiz "\nmin = "
.text
main:
la $a0,_a
li $v0,4
syscall

li $v0,5
syscall
move $t0,$v0
la $a0,_b
li $v0,4
syscall
li $v0,5
syscall
move $t1,$v0
la $a0,_c
li $v0,4
syscall
li $v0,5
syscall
move $t2,$v0
#nhap xong
slt $s0,$t1,$t0
beq $s0,$0, L1
j L2
L1:

L2:
L3:

move $t4,$t0
move $t0,$t1
move $t1,$t4
slt $s0,$t2,$t0
beq $s0,$0, L3
j L4

move $t4,$t0
move $t0,$t2

Giải thích
# Khai báo vùng nhớ data
# biến a
# biến b
# biến c
# biến max
# biến min
#
#
# load địa chỉ a vào thanh ghi $a0
# Gán $v0=4 -> in
#
# Gán $v0=5 -> nhập
#
# lưu $t0 = $v0
#
# load địa chỉ b vào thanh ghi $a0
# Gán $v0=4 -> in
#
# Gán $v0=5 -> nhập
#
# lưu $t1 = $v0
#
# load địa chỉ c vào thanh ghi $a0
# Gán $v0=4 -> in
#
# Gán $v0=5 -> nhập

#
# lưu $t2 = $v0
#
#so sánh $t1 <= $t0 (b<=a) nếu bằng thì
#$s0=0
#so sánh nếu $s0=0 thì nhảy đến L1
#nhảy đến L2
#
# $t4 = $t0
# $t0 = $t1
# $t1 = $t4
#so sánh $t2 <= $t0 (c<=a)
#so sánh nếu $s0=0 thì nhảy đến L3
#nhảy đến L4
# $t4 = $t0
# $t0 = $t2


move $t2,$t4
L4:
L5:

L6:

slt $s0,$t2,$t1
beq $s0,$0, L5
j L6
move $t4,$t1
move $t1,$t2
move $t2,$t4

la $a0, _max
li $v0, 4
syscall
move $a0, $t0
li $v0, 1
syscall

# $t2 = $t4
#
#so sánh $t2 <= $t1 (c<=b)
#so sánh nếu $s0=0 thì nhảy đến L5
#nhảy đến L6
# $t4 = $t1
# $t1 = $t2
# $t2 = $t4
#
# load địa chỉ max vào thanh ghi $a0
# Gán $v0=4 -> in
#
# $a0 = $t0
# print interger
#
#

la $a0, _min
li $v0, 4
syscall
move $a0, $t2
li $v0, 1
syscall


# load địa chỉ min vào thanh ghi $a0
# Gán $v0=4 -> in
#
# $a0 = $t2
# print interger
#

E, tính cộng trừ nhân chia với mips

Code
.data
nhap1: .asciiz "a = "
nhap2: .asciiz "b = "
tong: .asciiz "a + b = "
hieu: .asciiz "\na - b = "
nhan: .asciiz "\na * b = "
chia: .asciiz "\na / b = "
.text
main:
la $a0,nhap1
add $v0,$0,4
syscall
add $v0,$0,5
syscall
add $t0,$0,$v0

Giải thích
# Khai báo vùng nhớ data
# biến nhap1

# biến nhap2
# bien tong
# biến hieu
# biến nhan
# bien chia
#
#
# load địa chỉ nhap1 vào thanh ghi $a0
# lưu $v0 với địa chỉ $a0
# nhập
#
# Gán $v0=5 -> in
# in biến
# lưu $t0 = $v0


la $a0,nhap2
add $v0,$0,4
syscall
add $v0,$0,5
syscall
add $t1,$0,$v0
Tong:
add $t2,$t0,$t1
la $a0,tong
add $v0,$0,4
syscall
add $a0,$0,$t2
add $v0,$0,1
syscall

Hieu:
sub $t3,$t0,$t1
la $a0,hieu
add $v0,$0,4
syscall
add $a0,$0,$t3
add $v0,$0,1
syscall
Nhan:
mul $t4,$t0,$t1
la $a0,nhan
add $v0,$0,4
syscall
add $a0,$0,$t4
add $v0,$0,1
syscall
Chia:
sub $t5,$t0,$t1
la $a0,chia
add $v0,$0,4
syscall
add $a0,$0,$t5
add $v0,$0,1

#
# load địa chỉ nhap2 vào thanh ghi $a0
# lưu $v0 với địa chỉ $a0
#
#
# Gán $v0=5

# nhập
# Gán $t1 = $v0
#
#
# $t2 = $t0 + $t1
# load địa chỉ tong vào thanh ghi $a0
# lưu $v0 với địa chỉ $a0
#
# load địa chỉ $t2 vào thanh ghi $a0
# gán $v0 = 1 -> xuất
# Xuất
#
#
# $t3 = $t0 - $t1
# load địa chỉ tong vào thanh ghi $a0
# lưu $v0 với địa chỉ $a0
#
# load địa chỉ $t3 vào thanh ghi $a0
# gán $v0 = 1 -> xuất
# Xuất
#
#
# $t4 = $t0 * $t1
# load địa chỉ tong vào thanh ghi $a0
# lưu $v0 với địa chỉ $a0
#
# load địa chỉ $t4 vào thanh ghi $a0
# gán $v0 = 1 -> xuất
# Xuất
#

#
# $t5 = $t0 / $t1
# load địa chỉ tong vào thanh ghi $a0
# lưu $v0 với địa chỉ $a0
#
# load địa chỉ $t5 vào thanh ghi $a0
# gán $v0 = 1 -> xuất


syscall

G, thầy đã hướng dẫn

# Xuất