ĐẠI HỌC QUỐC GIA TP.

HỒ CHÍ MINH
TRƯỜNG ĐẠI HỌC CÔNG NGHỆ THÔNG TIN

BÀI BÁO CÁO THỰC HÀNH LAB 3

MÔN: THỰC HÀNH KIẾN TRÚC

MÁY TÍNH

LỚP: CE119.O21.1
Giảng viên hướng dẫn: Nguyễn Thành Nhân

Sinh viên thực hiện: Lâm Xuân Phước

MSSV: 22521154

TP. HỒ CHÍ MINH

 CE119-Lab03
1. Thao tác với mảng
Đề bài như sau:

✓ In ra cửa sổ I/O của MARS tất cả các phần tử của mảng array1 và
array2
 PRINT1:
Dùng để in ra các giá trị của mảng
array1.

EXIT1:
Dùng để in ra kí tự ‘\n’ cho biết
xuống dòng.

Thực hiện tạo biến đếm $t0 = 0.

Thực hiện load địa chỉ mảng array2
vào thanh ghi $t2.

PRINT2:
Thực hiện so sánh $t0, 16. Để kiểm
tra đã duyệt hết mảng chưa.
Thực hiện in ra các giá trị trong
mảng array2.

✓ Gán các giá trị cho mảng array3 sao cho array3[i] = array2[i] +
array2[size2 - 1 - i]
 GAN:
+ Khởi tạo biến đếm $t0, $t1 = 0.
+ Load địa chỉ mảng array3, array2
vào thanh ghi $t6, $t5.

Loop:
Vì array3 chỉ được khai báo .space 8.
Do đó ta chỉ cần load 8 phần tử vào
mảng.
+ Thực hiện load giá trị array2[i] và
lưu vào $s1.
+ Thực hiện load giá trị array2[size2 –
1 – i] và lưu vào $t2.
+ Thực hiện cộng giá trị của 2 phần tử
và lưu vào thanh ghi $t4 (mảng
array3[i])
+ Thực hiện tăng chỉ số lên 1 và nhảy
về vòng lặp Loop.

PRINT3:
Thực hiện in ra giá trị của các phần
tử được lưu trong mảng array3.

✓ Người sử dụng nhập vào mảng thứ mấy và chỉ số phần tử cần lấy trong
mảng đó, chương trình xuất ra phần tử tương ứng.
 + Thực hiện load địa chỉ của các mảng
array1, array2, array3.
+ Thực hiện nhập giá trị mảng và chỉ số
của phần tử cần tìm.
Đặt điều kiện:
• Nếu mảng = 1 nhảy đến print_array1.
• Nếu mảng = 2 nhảy đến print_array2.
• Nếu mảng = 3 nhảy đến print_array3.
+ Nếu mảng > 3 hoặc mảng < 1 nhảy đến
input để nhập lại.

Print_array1:
+ Di chuyển đến vị trí của chỉ số cần tìm.
+ Thực hiện lw giá trị và in giá trị ra.
 Print_array2:
+ Di chuyển đến vị trí của chỉ số cần tìm.
+ Thực hiện lw giá trị và in giá trị ra.

Print_array3:
+ Di chuyển đến vị trí của chỉ số cần tìm.
+ Thực hiện lw giá trị và in giá trị ra.

EXIT:
Thực hiện lệnh kết thúc chương trình.

2. Bài tập (chỉ sử dụng con trỏ)

Nhập một mảng các số nguyên n phần tử (nhập vào số phần tử và giá trị của từng phần tử),
xuất ra cửa sổ I/O của MARS theo từng yêu cầu sau:

.data
 array: .space 1000 # Khai bao mang co do dai toi da 1000 phan tu
msg_prompt_int: .asciiz "Nhap so luong phan tu cho mang: "
msg_array_input: .asciiz "Nhap gia tri cho mang: " Nội dung phần khai báo
msg_max_value: .asciiz "Gia tri lon nhat cua mang: " cho các hàm sử dụng

msg_min_value: .asciiz "Gia tri nho nhat cua mang: "

msg_sum: .asciiz "Tong tat ca cac phan tu cua mang: "
msg_index_input: .asciiz "Nhap chi so cua phan tu can tim: "
msg_value_at_index: .asciiz "Gia tri cua phan tu tai chi so can tim: "
.text
main:
# Nhap so luong phan tu cua mang
li $v0, 4
la $a0, msg_prompt_int Thực hiện nhập số lượng
phần tử của mảng.
syscall
li $v0, 5
syscall
move $t0, $v0
Lấy địa chỉ ban đầu của mảng array lưu vào $t1, sau đó sao chép vào
$t4.
# Lay dia chi cua mang
+ Thực hiện tăng giá trị ( nhân 4) đối với số lượng phần tử.
la $t1, array + Sau đó thực hiện lệnh add để cộng địa chỉ đầu và đoạn địa chỉ cần
move $t4, $t1 nhập.

sll $t2, $t0, 2 + Cuối cùng ta thu được:

$t3: chứa địa chỉ cuối cùng của mảng sau khi thêm đủ các phần tử.
add $t3, $t2, $t1
$t1: chứa địa chỉ đầu tiên của mảng khi chưa thêm phần tử nào.
addi $t7, $zero, 0
$t7: Khởi tạo biến đếm 0.

# Nhap va luu mang tu nguoi dung

li $v0, 4
la $a0, msg_array_input
syscall
input_loop: Thực hiện nhập và lưu mảng:
+ Dùng lệnh slt để so sánh địa chỉ con trỏ đầu và cuối.
+ beq: Dùng để so sánh điều kiện. Nếu đúng thì nhảy
đến nhãn ‘Find_MaxMin’. Còn nếu không thỏa ĐK
thì tiến hành nhập và lưu giá trị vào $t1.
 slt $t5, $t1, $t3
beq $t5, $zero, Find_MaxMin

li $v0, 5
syscall
sw $v0, ($t1)

addi $t1, $t1, 4

j input_loop

# Tim gia tri nho nhat va lon nhat trong mang

Find_MaxMin:
Lệnh move: dùng để di chuyển con
move $t1, $t4
trỏ lên đầu mảng.
lw $t2, ($t1)
+ Load giá trị vào thanh ghi $t2.
li $t5, 0
+ Tạo biến đếm $t5 = 0
move $t6, $t2
+ Lệnh move $t6, $t2: dùng để gán
move $t7, $t2 giá trị min.
+ Lệnh move $t7,$t2: dùng để gán giá
trị max.
Loop:
slt $t5, $t1, $t3
Thực hiện so sánh vị trí con trỏ đầu và cuối bằng lệnh
beq $t5, $zero, Print_MaxMin slt.
lw $t2, ($t1) Dùng để beq để kiểm tra và thoát chương trình.
blt $t2, $t6, min Load giá trị vào $t2
bgt $t2, $t7, max + So sánh blt $t2, $t6, min. Sẽ nhảy đến hàm min nếu (
a < b).
j increase
Hàm min:blt $t2, $t7, max. Sẽ nhảy đến hàm max nếu (
+ So sánh
min:
a > b).
Gán giá trị $t2 vào $t6
move $t6, $t2
+ Nếuđế
Nhảy a =hàm
b thìincrease.
nhảy đến hàm increase.
j increase
max: Hàm max:
move $t7, $t2 Gán giá trị $t2 vào $t7
Nhảy đế hàm increase.
 j increase
increase: Hàm increase:
addi $t1, $t1, 4 Tăng $s1 lên 4 đơn vị
j Loop Nhảy đến hàm Loop.
# In ra gia tri nho nhat va lon nhat trong mang

Print_MaxMin:
li $v0, 4
la $a0, msg_min_value Hàm Print_MaxMin:

syscall + Dùng để in ra giá trị Max, Min của mảng.

li $v0, 1 + Nhảy đến hàm Sum_array

move $a0, $t6

syscall
li $v0, 11
li $a0, '\n'
syscall
li $v0, 4
la $a0, msg_max_value
syscall
li $v0, 1
move $a0, $t7
syscall
j Sum_array

# Tinh tong cac phan tu cua mang

Sum_array: Sum_array:
li $s0, 0 Khởi tạo biến sum $s0 = 0.
move $t1, $t4 Di chuyển con trỏ lên đầu mảng.
Loop_Sum:
slt $t5, $t1, $t3 Loop_Sum:
Lần lượt lặp qua các phần tử và cộng giá
trị của nó với biến $s0.
Khi lặp qua hết các phần tử của mảng, thì
 beq $t5, $zero, Print_Sum
lw $t2, ($t1)
add $s0, $s0, $t2
addi $t1, $t1, 4
j Loop_Sum

Print_Sum:
Print_Sum:
li $v0, 11
Thực hiện in giá trị tổng Sum ra màn
li $a0, '\n' hình.
syscall Nhảy đến hàm input2.
li $v0, 4
la $a0, msg_sum
syscall
li $v0, 1
move $a0, $s0
syscall
j input2

# Nhap chi so cua phan tu can tim va in gia tri cua phan tu tai chi so do
input2:
li $v0, 11 Input2:

li $a0, '\n' + Dùng để nhập chỉ số của phần tử cần in.

syscall + Thực hiện lệnh li $v0, 5: để nhập vào chỉ số của

phần tử cần tìm.
li $v0, 4
la $a0, msg_index_input
syscall
li $v0, 5
syscall
move $s0, $v0
Output2:
output2:
+ Thực hiện in ra giá trị của phần tử ở chỉ số cần
tìm.
+ Di chuyển vị trí con trỏ lên đầu mảng.
 move $t1, $t4
addi $s0, $s0, -1
sll $s0, $s0, 2
add $t1, $t1, $s0
lw $t2, ($t1)
li $v0, 4
la $a0, msg_value_at_index
syscall
li $v0, 1
move $a0, $t2
syscall
j exit
exit:
Exit:
li $v0, 10
Thực hiện kết thúc chương trình.
syscall

Nhập một mảng các số nguyên n phần tử (nhập vào số phần tử và giá trị của từng phần tử).
Mảng này gọi là A.

.data
array: .space 1000 # Khai bao mang co do dai toi da 1000 phan tu
 msg_prompt_int: .asciiz "Nhap so luong phan tu cho mang: "
msg_array_before: .asciiz "Mang truoc khi thay doi: " .data:
msg_array_after: .asciiz "Mang sau khi thay doi: " Nội dung phần khai báo
msg_array_input: .asciiz "Nhap gia tri cho mang: " cho các hàm sử dụng.

msg_input_i: .asciiz "Nhap gia tri cho bien nguyen i: "

msg_input_j: .asciiz "Nhap gia tri cho bien nguyen j: "

.text
main:
# Nhap so luong phan tu cho mang
Thực hiện nhập số lượng phần tử
li $v0, 4 cho mảng.
la $a0, msg_prompt_int + Sau đó thực hiện lưu giá trị vào
syscall $t0.

li $v0, 5
syscall
move $t0, $v0 # Luu so luong phan tu vao $t0

# Lay dia chi cua mang

Lấy địa chỉ của mảng lưu vào $t1.
la $t1, array
Sao chép địa chỉ con trỏ vào $t4.
move $t4, $t1
Thực hiện sll $t2, $t0, 2: để lấy giá trị của số phần tử nhân 4.
sll $t2, $t0, 2
Thực hiện add $t3, $t2, $t1: Thực hiện cộng địa chỉ của con trỏ
add $t3, $t2, $t1
đầu và đoạn cần dịch chuyển.
addi $t7, $zero, 0
Thực hiện tạo biến đém cho $t7 = 0.

# Nhap va luu mang tu nguoi dung

li $v0, 4
la $a0, msg_array_input
syscall Input_loop:

input_loop: + Thực hiện kiểm tra đã nhập đủ phần

tử chưa.
slt $t5, $t7, $t0 # Kiem tra xem da nhap du so phan tu chua
+ Thực hiện nhập giá trị vào mảng.
+ Lưu giá trị vào thanh ghi $t1.
+ Tăng biến đếm lên 1 đơn vị cho $t7.
 beq $t5, $zero, print_array
li $v0, 5
syscall
sw $v0, ($t1)
addi $t7, $t7, 1 # Tang bien dem
addi $t1, $t1, 4 # Tang dia chi cua mang
j input_loop

print_array:
Print_array:
# Thiet lap con tro ve dau mang
Dùng để thiết lập con trỏ về đầu
move $t1, $t4 mảng.
Gọi thông báo xuất chuỗi kí tự:
li $v0, 4 “Mang truoc khi thay doi”.

la $a0, msg_array_before
syscall
print_loop:
# Kiem tra xem da duyet het mang chua print_loop:
slt $t5, $t1, $t3 + Thực hiện và kiểm tra đã duyệt hết mảng chưa.
beq $t5, $zero, input_i_j Nếu duyệt hết thì nhảy đến hàm “input_i_j”
+ Load giá trị của mảng vào thanh ghi $a0.

# Load gia tri tu mang vao thanh ghi $a0 de in ra + Thực hiện in ra giá trị trong thanh ghi $a0.

lw $a0, ($t1) + Thực hiện tăng con trỏ lên 4 byte ( 1word)
bằng với kích thước của 1 phần tử của mảng.
li $v0, 1
+ Thực hiện nhảy đến nhãn j print_loop: Quay
syscall trở lại vòng lặp.
li $v0, 11
li $a0, ' '
syscall

# Tang con tro len 4 byte (kich thuoc cua mot phan tu trong mang)
addi $t1, $t1, 4
 # Lap lai cho den khi duyet het mang
j print_loop

input_i_j:
li $v0, 11 input_i_j:
li $a0, '\n' Thực hiện nhập giá trị của biến i.
syscall
# Nhap gia tri cua bien nguyen i tu nguoi dung
li $v0, 4
la $a0, msg_input_i
syscall
li $v0, 5
syscall
move $s0, $v0 # Luu gia tri cua i vao $s0

# Nhap gia tri cua bien nguyen j tu nguoi dung

li $v0, 4 input_i_j:
la $a0, msg_input_j Thực hiện nhập giá trị của biến j.
syscall
li $v0, 5
syscall
move $s1, $v0 # Luu gia tri cua j vao $s1

# Luu dia chi nen cua mang A vao $s3 Thực hiện lưu giá trị địa chỉ nền của mảng A
la $s3, array vào $s3.

# So sanh i va j Tiến hành so sánh giá trị của i và j.

Nếu i < j thì thực hiện A[i] = i.
+ Thực hiện sao chép giá trị của I vào $t6.
 slt $t5, $s0, $s1 # Neu i < j
beq $t5, $zero, else_case # Thi nhay den nhanh else
move $t6, $s0
addi $s0, $s0, -1
sll $s0, $s0, 2
add $s3, $s3, $s0 # Lay gia tri cua A[i]
sw $t6, 0($s3) # Luu gia tri moi vao A[i]
j print_loop2 # Ket thuc if-else
else_case:
addi $s0, $s0, -1 Else_case:
sll $s0, $s0, 2 Nếu i > = j thì thực hiện aA[i] = j.
add $s3, $s3, $s0 # Lay gia tri cua A[i] Cách làm tương tự như trên.
sw $s1, 0($s3) # Luu gia tri moi vao A[i]

print_loop2:
Print_loop2:
# Thiet lap con tro ve dau mang
Dùng để in ra giá trị mảng sau khi thay đổi.
move $t1, $t4
li $v0, 4
la $a0, msg_array_after
syscall
Loop2:
Loop2:
# Kiem tra xem da duyet het mang chua
+ Thực hiện kiểm tra đã duyệt hết mảng chưa.
slt $t5, $t1, $t3
Nếu duyệt hết thì nhảy đến hàm end_if.
beq $t5, $zero, end_if
+ Thực hiện load giá trị phần tử của mảng vào
thanh ghi $a0.
# Load gia tri tu mang vao thanh ghi $a0 de in ra
+ Thực hiện in ra giá trị của các phần tử mảng.
lw $a0, ($t1)
+ Thực hiện tăng con trỏ lên 4 byte.
li $v0, 1
+ Thực hiện j Loop2: Quay trở lại vòng lặp.
syscall
li $v0, 11
 li $a0, ' '
syscall

# Tang con tro len 4 byte (kich thuoc cua mot phan tu trong mang)
addi $t1, $t1, 4

# Lap lai cho den khi duyet het mang

j Loop2
end_if:
# Ket thuc chuong trinh
End_if:
li $v0, 10
Dùng để kết thúc chương trình.
syscall