1

Bài tập lập trình assembly.

Lưu ý: Với những bài phức tạp, nên viết giải thuật sử dụng flowchat hoặc pseodocode.

For all exams, you should make use of the Beta documentation and you can use the Bsim (Beta simulator) to
verify the exams.

Cơ bản:
1. Đổi chỗ 2 phần từ mảng a[1] và a[3].
2. Viết chương trình thực hiện phép tính: a[0]=a[1]+a[2]
3. Chia a[0] cho a[1], phần nguyên lưu vào a[2], phần dư lưu vào a[3].
4. Cho a[0] lưu giá trị số phút. Chuyển đổi số phút trên thành giờ lưu vào a[1] và phần dư phút lưu vào a[2].
(Ví dụ: a[0] = 125 thì a[1]=2 và a[2]=5).
5. Cho a[0] lưu giá trị số giây. Chuyển đổi số phút trên thành giờ lưu vào a[1] và phần dư phút lưu vào a[2]
và phần dư giây lưu vào a[3]. (Ví dụ: a[0] = 3745 thì a[1]=1 và a[2]=2 và a[3]=25 = 0x19).
6. Đếm số digit ‘1’ trong giá trị a[0]. Kết quả lưu vào a[1].
7. Nếu a[1] > a[3] thì đổi chỗ
8. Tìm giá trị nhỏ nhất của a[0], a[1] và a[2], kết quả lưu vào a[3].
9. Tìm giá trị lớn nhất của a[0], a[1] và a[2], kết quả lưu vào a[3].
10. Kiếm tra xem a[0], a[1] và a[2] có phải là độ dài của 3 cạnh tam giác hay không. Nếu đúng lưu 1 vào a[3],
ngược lại lưu 0.
11. Sắp xếp a[0], a[1] và a[2] theo thứ tự tăng dần.
12. Sắp xếp a[0], a[1] và a[2] theo thứ tự giảm dần.

Nâng cao:
13. Tính tổng s = 1 + 2 + … + a[0] và lưu vào thanh ghi r0.
14. Tính tổng các phần tử mảng a[0] đến a[9] và lưu vào a[10].
15. Tìm số lớn nhất của các phần tử mảng a[0] đến a[9] và lưu vào a[10].
16. Tìm ước số chung lớn nhất của a[0] và a[1] lưu vào a[2].
17. Tìm bội số chung nhỏ nhất của a[0] và a[1] lưu vào a[2].
18. Xác định a[0] có phải là số nguyên tố không? Nếu có ghi 1 vào a[1], ngược lại ghi 0.
19. Tìm số nguyên tố nhỏ nhất lớn hơn a[0], kết quả lưu vào a[1]. (ví dụ a[0]=8 thì a[1]=11).
20. Xác định a[0] có phải là số chính phương không không? Nếu có ghi 1 vào a[1], ngược lại ghi 0.
21. Sắp xếp mảng a tăng dần dùng giải thuật nổi bọt (bubble sort).
22. Sắp xếp mảng a tăng dần dùng giải thuật chọn (selection sort).
 2

Problem 1:
/* Khai bao mảng
Load (LD): Giá trị trong ô nhớ tải vào thanh ghi
Store (ST): Giá trị trong thanh ghi lưu vào ô nhớ

Đề bài: Ghi giá trị 0x123 vào a[3]

Tải giá trị a[3] vao thanh ghi r10 */

.include "beta.uasm"
// Viết code vào đây

HALT()
a: LONG(9) // a[0] – Address a
LONG(2) // a[1] – Address a+4 = a+4*1
LONG(0) // a[2] – Address a+8 = a+4*2
LONG(4) // a[3] – Address a+12 = a+4*3
LONG(5) // …

Problem 2:

// Đề bài: Đổi chỗ 2 phần tử mảng a[3] và a[5]

.include "beta.uasm"
// Viết code vào đây

HALT()

a: LONG(9) // a[0] – Address a

LONG(2) // a[1] – Address a+4 = a+4*1
LONG(0) // a[2] – Address a+8 = a+4*2
LONG(4) // a[3] – Address a+12 = a+4*3
LONG(5) // …

Problem 3:
// Đề bài: Nếu a[1] > a[3] thì đổi chỗ

.include "beta.uasm"

HALT()
a: LONG(9) // a[0] – Address a
LONG(2) // a[1] – Address a+4 = a+4*1
LONG(0) // a[2] – Address a+8 = a+4*2
LONG(4) // a[3] – Address a+12 = a+4*3
LONG(5) // a[4] - …
 3

Program :

// Doi gia tri cua 2 thanh ghi r0 va r1

// su dung r2 lam trung gian

.include "beta.uasm"
ADDC(r31,5,r0) // r0=5
ADDC(r31,7,r1) // r1=7
ADD(R0, R31, R2) // R2=R0
ADD(R1, R31, R0) // R0=R1
ADD(R2, R31, R1) // R1=R2
HALT()

Program :

// r0 chứa tổng số phút

// đổi ra giờ (lưu vào r1) và số phút còn lại (lưu vào r2)
// Ví dụ:
// r0=125 thì r1=2 và r2=5
// r0=75 thì r1=1 và r2=15

.include "beta.uasm"
ADDC(r31,125,r0) // r0=125 phút
DIVC(r0,60,r1) // r1=r0/60
MULC(r1,60,r3) // r3=r1*60
SUB(r0,r3,r2) // r2=r0-r3

HALT()

Program :
// tìm giá trị nhỏ nhất của r1, r2 và r3 - lưu kết quả vào r0

.include "beta.uasm"
ADDC(r31,5,r1) // r1=5
ADDC(r31,3,r2) // r2=3
ADDC(r31,8,r3) // r3=8

ADDC(r1,0,r0) // r0=r1 / MULC(r1,1,r0) / ADD(r31,r1,r0)

SS1:
CMPLT(r2,r0,r10) // r2<r0 thi r10 = 1 , nguoc lai r10=0
BNE(r10,TH1,r20) // Nếu r10 khác 0 thì nhảy đến TH1, r20=PC
// (r20 chứa PC - địa chỉ câu lệnh hiện tại)
SS2:
 4

CMPLT(r3,r0,r10)
BNE(r10,TH2,r20)
BR(ket_thuc) // Nhay den ket_thuc

TH1:
ADDC(r2,0,r0)
BR(SS2)

TH2:
ADDC(r3,0,r0)

ket_thuc:
HALT()

Program :

// Bài 5: Sắp xếp r0, r1, r2 theo thứ tự tăng dần

.include "beta.uasm"
ADDC(r31,8,r0)
ADDC(r31,7,r1)
ADDC(r31,5,r2)

SS1:
CMPLT(r1,r0,r10) // nếu r1<r0 thì r10=1.
BNE(r10,swap1,r31) // nếu r10 khác 0 thì nhảy đến swap1
// BR(SS2)

SS2:
CMPLT(r2,r0,r10)
BNE(r10,swap2,r31)
// BR(SS3)

SS3:
CMPLT(r2,r1,r10)
BNE(r10,swap3,r31)
BR(ket_thuc)

swap1:
ADDC(r0,0,r3)
ADDC(r1,0,r0)
ADDC(r3,0,r1)
BR(SS2)

swap2:
ADDC(r0,0,r3)
ADDC(r2,0,r0)
ADDC(r3,0,r2)
BR(SS3)

swap3:
ADDC(r2,0,r3)
ADDC(r1,0,r2)
ADDC(r3,0,r1)
 5

// BR(ket_thuc)

ket_thuc:
HALT()

Program :

// Bài 6: Đọc / ghi vào bộ nhớ (CPU <--> Memory)

.include "beta.uasm"
ADDC(r31,12,r0)
ST(r0,a+8,r31) // r0 --> M(4)
LD(r31,a+12,r5) // a[3] --> R5

HALT()

a: LONG(5) // a[0] - địa chỉ a

LONG(7) // a[1] - địa chỉ a+4
LONG(9) // a[2] - địa chỉ a+8
LONG(2) // a[3] - địa chỉ a+12
LONG(0) // ...
LONG(6) // a[n] - địa chỉ a+4*n

----------------------------------------------------------------------
// Bài 7: Sắp xếp a[0], a[1] và a[2] theo thứ tự tăng dần.

.include "beta.uasm"
LD(r31,a,r0) // r0=a0
LD(r31,a+4,r1) // r1=a1
LD(r31,a+8,r2) // r2=a2
// Sắp xếp 3 thanh ghi r0, r1, r2 theo thứ tự tăng dần
SS1:
CMPLT(r1,r0,r10) // nếu r1<r0 thì r10=1.
BNE(r10,swap1,r31) // nếu r10 khác 0 thì nhảy đến swap1
SS2:
CMPLT(r2,r0,r10)
BNE(r10,swap2,r31)
SS3:
CMPLT(r2,r1,r10)
BNE(r10,swap3,r31)
BR(luu_kq)

swap1:
ADDC(r0,0,r3)
ADDC(r1,0,r0)
ADDC(r3,0,r1)
BR(SS2)

swap2:
ADDC(r0,0,r3)
ADDC(r2,0,r0)
 6

ADDC(r3,0,r2)
BR(SS3)

swap3:
ADDC(r2,0,r3)
ADDC(r1,0,r2)
ADDC(r3,0,r1)

luu_kq:
ST(r0,a,r31) // r0 --> a0
ST(r1,a+4,r31) // r1 --> a1
ST(r2,a+8,r31) // r2 --> a2

HALT()

a: LONG(9) // a[0] - địa chỉ a

LONG(7) // a[1] - địa chỉ a+4
LONG(8) // a[2] - địa chỉ a+8

----------------------------------------------------------------------

// Bài 8: Đổi giá trị a[0] và a[3].

.include "beta.uasm"
LD(r31,a,r0)
LD(r31,a+12,r1)
ST(r1,a,r31)
ST(r0,a+12,r31)
HALT()

a: LONG(0xa87) // a[0] - địa chỉ a

LONG(0x5a3) // a[1] - địa chỉ a+4
LONG(0b1101) // a[2] - địa chỉ a+8
LONG(0x123) // a[3] - địa chỉ a+12

----------------------------------------------------------------------
// Bài 9: Nếu a[3] < a[0] thì đổi giá trị a[0] và a[3].

.include "beta.uasm"
LD(r31,a,r0)
LD(r31,a+12,r1)

CMPLT(r1,r0,r10)
BNE(r10,SWAP,r31)
BR(ket_thuc)
SWAP:
ST(r1,a,r31)
ST(r0,a+12,r31)
ket_thuc:
 7

HALT()

a: LONG(0xa87) // a[0] - địa chỉ a

LONG(0x5a3) // a[1] - địa chỉ a+4
LONG(0b1101) // a[2] - địa chỉ a+8
LONG(0x123) // a[3] - địa chỉ a+12

----------------------------------------------------------------------
// Bài 10: Tìm giá trị MAX của a[1], a[2] và a[3], kết quả lưu vào a[0].

.include "beta.uasm"
LD(r31,a+4,r1) // a1 --> r1
LD(r31,a+8,r2) // a2 --> r2
LD(r31,a+12,r3) // a3 --> r3

// Tìm MAX của r1, r2, r3 lưu vào r0

ADDC(r1,0,r0) // r0=r1
SS1:
CMPLT(r0,r2,r10) // neu r0<r2 thi r10=1
BNE(r10,true1,r31) // neu r10 khác 0 thì nhảy đến true1
SS2:
CMPLT(r0,r3,r10)
BNE(r10,true2,r31)
BR(luu_kq)

true1:
ADDC(r2,0,r0) // r0=r2
BR(SS2)

true2:
ADDC(r3,0,r0) // r0=r3
BR(luu_kq)

luu_kq:
ST(r0,a,r31) // r0 --> a0

HALT()

a: LONG(0) // a[0] - địa chỉ a

LONG(0x123) // a[1] - địa chỉ a+4
LONG(0x789) // a[2] - địa chỉ a+8
LONG(0x555) // a[3] - địa chỉ a+12

----------------------------------------------------------------------

// 16. Tìm ước số chung lớn nhất của a[0] và a[1] lưu vào a[2].

.include "beta.uasm"
 8

LD(r31,a+4,r1) // a1 --> r1
LD(r31,a,r0) // a0 --> r0

// tìm ước số chung của r0 và r1, lưu vào r2

SS1:
CMPEQ(r0,r1,r10) // nếu r0=r1 thì r10=1
BNE(r10,luu_kq,r31) // nếu r10 khác 0 thì nhảy đến luu_kq
BR(SS2)
SS2:
CMPLT(r0,r1,r10)
BNE(r10,true,r31)

false:
SUB(r0,r1,r0)
BR(SS1)

true:
SUB(r1,r0,r1)
BR(SS1)

luu_kq:
ADDC(r0,0,r2) // r2=r0
ST(r2,a+8,r31) // r2 --> a[2]

HALT()

a: LONG(50) // a[0] - địa chỉ a

LONG(20) // a[1] - địa chỉ a+4
LONG(0) // a[2] - địa chỉ a+8

----------------------------------------------------------------------

// 13. Tính tổng s = 1 + 2 + … + a[0] và lưu vào a[1].

.include "beta.uasm"
LD(r31,a,r0) // r0=a[0]
ADDC(r31,0,r1) // r1=0
ADDC(r31,1,r2) // r2=1
SS:
CMPLE(r2,r0,r10) // neu r2<=r0 thi r10=1
BNE(r10,true,r31) // neu r10 khac 0 thi nhay den true
BR(luu_kq)

true:
ADD(r1,r2,r1) // r1=r1+r2
ADDC(r2,1,r2)
BR(SS)

luu_kq:
ST(r1,a+4,r31) // r1 --> a[1]
HALT()

//-------------------
a: LONG(0x123) // a[0] - địa chỉ a
 9

LONG(0) // a[1] - địa chỉ a+4

----------------------------------------------------------------------
// 20. Xác định a[0] có phải là số chính phương không không? Nếu có ghi 1 vào a[1],
ngược lại ghi 0.

.include "beta.uasm"
LD(r31,a,r0) // r0=a[0]
ADDC(r31,0,r1) // r1=0
ST(r1,a+4,r31) // a[1]=0

ADDC(r31,1,r1) // r1=1
loop:

ket_thuc:
HALT()

//-------------------
a: LONG(25) // a[0] - địa chỉ a
LONG(0) // a[1] - địa chỉ a+4

----------------------------------------------------------------------

HOMEWORK:
Làm các bài tập còn lại.

----------------------------------------------------------------------

----------------------------------------------------------------------