Chuong 3 - Tap Lenh Arm

HỌC VIỆN CÔNG NGHỆ BƯU CHÍNH VIỄN THÔNG
BÀI GIẢNG MÔN
KỸ THUẬT VI XỬ LÝ
Giảng viên: TS. Trương Cao Dũng

Điện thoại/E-mail: 0936354555 / dungtc@ptit.edu.vn
Học kỳ/Năm biên soạn: Kỳ 1/2017
KỸ THUẬT VI XỬ LÝ
NỘI DUNG
 Chương 1 – Tổng quan về hệ vi xử lý
 Chương 2 – Bộ vi xử lý ARM
 Chương 3 – Lập trình hợp ngữ cho vi xử lý ARM
 Chương 4 – Lập trình Vi điều khiển STM32
 Chương 5 – Lập trình GPIO, ADC và Timer
 Chương 6 – Lập trình ngắt NVICE và DMAE
2
CHƯƠNG 3-LẬP TRÌNH HỢP NGỮ ARM
NỘI DUNG
1. Giới thiệu về lập trình Assembly
2. Tập lệnh của ARM
1. Lệnh xử lý dữ liệu (data processing)
2. Dịch chuyển dữ liệu (data movement)
3. Điều khiển chương trình (flow control)
4. Ngắt
3
 Lập trình cho VXL là lập trình bằng ngôn ngữ máy hay hợp ngữ
(Assembly). Công cụ hỗ trợ lập trình hợp ngữ: cú pháp, tập lệnh,
thư viện,…gọi là Assembler.
 Cấu trúc chung của một chương trình hợp ngữ cho ARM:
operands
label opcode comment 4
 Cấu trúc chung của một lệnh ARM

label <dấu cách> lệnh <dấu cách> ; chú giải
optional
opcode
Labe Operand Operand Operand

(optional) 1 2 3 5
NỘI DUNG
2. Di chuyển dữ liệu (data transfer)
6
 Đặc điểm của tập lệnh ARM:

• Kiến trúc Load – Store
• Lệnh 3 địa chỉ
• Tất cả đều là các lệnh có hoặc không điều kiện
• Có khả năng load/store nhiều thanh ghi đồng thời
• Khối dịch và khối ALU có thể hoạt động song song, do
đó phép tính dịch, quay bít và các phép tính tính toán có
thể được thực hiện đồng thời.
 Lệnh xử lý dữ liệu:
• Lệnh xử lý dữ liệu bao gồm lệnh di chuyển dữ liệu giữa
các thanh ghi (move:MOV), lệnh số học (arithmetic
instruction), lệnh logic (logical instruction), lệnh so sánh
(comparison) và lệnh nhân (multiply).
• Hầu hết các lệnh xử lý dữ liệu có thể dùng bộ dịch
(barrel shifter) để xử lý một trong những toán hạng của
lệnh  tăng tốc độ xử lý và tính toán dữ liệu.
 Lệnh xử lý dữ liệu
• Arithmetic: ADD ADC SUB SBC RSB RSC
• Logic: AND ORR EOR BIC
• Comparisons: CMP CMN TST TEQ
• Data movement: MOV MVN
 Lưu ý: các lệnh chỉ thực hiện trên thanh ghi, KHÔNG thực hiện trên
bộ nhớ. (RISC)
 Cú pháp:
<Operation>{<cond>}{S} Rd, Rn, Operand2
 Lệnh so sánh tác động đến cờ và thanh ghi Rd không bị tác
động
 Lệnh di chuyển dữ liệu không tác động đến thanh ghi Rn
 Toán hạng thứ 2 (operand2) được đưa đến ALU thông qua bộ dịch
chuyển barrel shifter
 Di chuyển dữ liệu giữa các thanh ghi

MOV<cond><S> Rd, Rn, <operands>
MOVCS R0, R1 ; Nếu cờ nhớ C = 1 thì R0:= R1 (đk CS)
MOVS R0, #0 ; R0 = 0
; Z = 1, N = 0
; C, V không bị tác động (điều kiện S không ảnh
hưởng đến C,V bits)
MOVS R0, #0 ; R0 = #0x00000001;
; Z = 0, N = 0
; C, V không bị tác động
MOVS R0, #0 ; R0 = #0xFFFFFFFFB; =-5;
; Z = 0, N = 1
; C, V không bị tác động
 Di chuyển dữ liệu giữa các thanh ghi:
• Lưu ý: Hầu hết các lệnh trong ARM có trường điều kiện.
Khi thỏa mãn điều kiện đó thì lệnh mới được thực hiện.
MOVCS R0, R1 ; R0 = R1 chỉ khi C = 1.
MOVCC R0, R1 ; R0 = R1 chỉ khi C = 0.
Có cả thảy 16 điều kiện (condition) theo bảng sau:

• Gồm có hai lệnh:
 MOV R0, R2 ; R0 = R2
 MVN R0, R2 ; move negative, R0 = - R2
• Ví dụ:
Trước: r5 = 5
r7 = 8
MOV r7, r5
Sau: r5 = 5
r7 = 5; vì giá trị thanh ghi là tạm thời
MVN r7, r5
Sau: r5 = 5, r7 = -5=0xFFFFFFFB (biểu diễn âm của -5 trong
hệ 32 bit)
MOV R1, #0x12 Syntax
; Lưu số 8 bit vào phần thấp của R1 MOV{S}{cond} Rd, Operand2
MOV{cond} Rd, #imm16
MOV R1,#0x1234 where:
S
; Lưu số 16 bit vào phần thấp của R1 is an optional suffix. If S is specified, the
condition flags are updated on the
MOVT R1,#0x1234 ; Lưu số 16 bit vào cond result of the operation.
phần cao của R1 is an optional condition code.
Rd
MOVT R1,#0xFF; is the destination register.
Operand2
lưu 8 bit vào phần cao của R1 is a flexible second operand.
imm16
MOV32 R1,#0x12345678 is any value in the range 0-65535=2^16-1.
; Lưu số 32 bit vào R1

 Cho 2 số như sau đây, hãy tìm kết quả của các thanh ghi của
chương trình sau mỗi dòng lệnh khi thực hiện:
R1=0xFE00689A; R2=0xCD102E85;
MOV R3, R1, #0x12
; Lưu số 8 bit vào phần thấp của R1
MOV R4, R1, #0x1234
; Lưu số 16 bit vào phần thấp của R1
MOVT R5, R1, #0x1234
; Lưu số 16 bit vào phần cao của R1
MOV32 R6, R2, #0x12345678
; Lưu số 32 bit vào R1
Đáp số: R3, R4, R5, R6=0x0000009A, 0x0000689A, 0xFE000000,
0xCD102E85
 Barrel shiffter:
 Bộ dịch thùng (barrel shifter)
Operand Operand
dùng để chứa dữ liệu của toán hạng 1 2
Operand2 với kiểu dữ liệu là số tức thời
hoặc số hexa trước khi tính toán trong
Barrel
ALU. Shifter
 Việc sử dụng Barrel Shifter sẽ
làm tăng tốc độ tính toán và xử lý
ARM hỗ trợ có 4 phép toán liên quan
đến dịch và quay gồm:
ALU
Dịch trái logic (LSL), Dịch phải logic (LSR),
Dịch phải số học (ASR) và Quay phải mở rộng (RRX)
Result
 Dịch trái: LSL: Logical Shift Left
• MOV Rd, Rn, LSL #n ; Rd = Rn<<n

• MOV R0, R2, LSL #2 ; R0 = R2<<2
; R2 không đổi (Rn không
đổi)
Ví dụ: R2=0…0 0011 0000 (32 bits)
Trước: R2 = 0x00000030
Sau: R0 = 0x000000C0 0…0 1100.0000 (32 bits)
R2 = 0x00000030
 Dịch phải: LSR=Logical Shift Right

0 Register C
• MOV Rd, Rn, LSR #n ; Rd = Rn>>n

• MOV R0, R2, LSR #2 ; R0 = R2>>2
; R2 không đổi (Rn ko
đổi)
Ví dụ: 0…0 0011 0000
Trước: R2 = 0x00000030
Sau: R0 = 0x0000000C 0…0 .0000.1100
R2 = 0x00000030
 Dịch phải số học: ASR= Arithmetical Shift Right
• MOV Rd, Rn, ASR #n ; R0 = R2>>n (ASR)

• MOV R0, R2, ASR #2 ; R0 = R2>>2
; R2 không đổi
Quy tắc: ASR copy n bit MSB chèn vào từ trái qua phải và cắt đi
n bit thừa bên phải. Khi MSB=0 ASR=LSR
Ví dụ: 1010 0…0 0011 0000 (R2)
Trước: R2 = 0xA0000030
Sau: R0 = 0xE800000C 1110.1000…0000 1100 (MSB=1)
R2 = 0xA0000030
 Dịch phải số học: ASR= Arithmetic Shift Right
• MOV R0, R2, ASR #3 ; R0 = R2>>3

; R2 không đổi
Ví dụ: 0…0 0011 0000, MSB=0 nên ASR=LSR,
copy 3(n=3 bit) bit 0 chèn vào từ trái qua phải
Trước: R2 = 0x00000030
Sau: R0 = 0x00000006 0…0 .0000(29 số0 ).11 0
R2 = 0x00000030
 Quay phải mở rộng: RRX= Rotate Right Extension
• MOV Rd, Rn, RRX#n ; Rd = Rn sau khi quay vòng n

bits bằng cách tách ra từ ngoài cùng bên phải móc vào trái
• MOV R0, R2, RRX#3 ; R0 = R2 sau khi quay
; R2 không đổi, RRX#3
Ví dụ: R2=0…0 0011 0001
Trước: R2 = 0x00000031 ; C = 001 0000…0 00110
Sau: R0 = 0x20000006 ; C = 01
R2 = 0x00000031
Số mới R2=0010.0000…0 0.0110=0x20000006
 BTVN:Ví dụ: cho R1= 0x1F000068; R2=0x02E0000B;
 Hãy tìm kết quả của các phép toán sau đây:
MOV R3, R1, LSL#4;
MOV R7, R2, ASR#6;
MOV R4, R1, ASR#5;
MOV R5, R2, LSR#2;
MOV R6, R2, RRX#3;
• Hãy ghi kết quả thanh ghi nguồn và đích sau mỗi phép
Cho: R1=0xAE000079
MOV R4, R1, ASR#3;
MOV R6, R1, RRX#5;
Tìm kết quả R4,R6 ở ví dụ này
 Các lệnh số học: Cộng và trừ

instruction<cond><S> Rd, Rn, N
Cờ carry trong thanh ghi CPSR sẽ được thiết lập với

các lệnh có cờ
 Các chế độ địa chỉ:
• Chế độ địa chỉ thanh ghi:
 ADD R0, R1, R2 ; Các toán hạng là các thanh ghi
• Chế độ địa chỉ tức thời:
 ADD R3, R3, #1 ; R3 = R3 + 1
 ADC R3,R3, #1 ; R3=R3+1+C flag
 ADDCS R3, R3, #1 ; R3 = R3 + 1, cờ C được thiết lập=1
 SUB R3, R3, #1 ; R3 = R3 - 1
 ADD R8, R7, #0xff ; R8 = R7[7:0]: lấy có 8 bit cuối R7 đưa
; vào R8
 Dấu # được sử dụng để biểu diễn toán hạng tức thời
 Toán hạng có ký hiệu 0x đứng trước: biểu diễn số hexa
 3 loại địa chỉ của Operand2: reg, số tức thời (imm), hexa
Ví dụ 1:
R0 = 0x00000000
R1 = 0x00000002
R2 = 0x00000001
SUB R0, R1, R2 R0=0x00000001
Ví dụ 2:
R0 = 0x0000
R1 = 0x0077
RSB R0, R1, #0 ; R0=0-R1
Biểu diễn kết quả dưới dạng 16bit có dấu: ,kq: R0=FFFFFF89
Ví dụ 3:
R1 = 0x00000001
SUBS R1, R1, #1
CPSR = ?, R1=?; R1=0, N=0,Z=1,C,V=ko bị t/đ, I,F=0,mode=user
Ví dụ 4:
MOV R0, #0x00000000
MOV R2, #0x00000001
MOV R1, #0x00000005; R1,LSL#2=00…010100=0x00000014
ADD R0, R1, R1, LSL #2; a) R0=0x00000019
,R1=0x00000005
ADD R0, R2, R1, RRX #2, R1=0x00000ABE; b)
R0=0x800002B0; R1=0x00000ABE;
R1,RRX#2=1000..01010101111=800002AF;R2= như cũ,

Ví dụ 5: Thực hiện phép cộng (lệnh ADC, ADDS) 3
số sau:
Số thứ nhất = 2ABC3458
Số thứ hai = E8934D47
Số thứ ba = 134DC378
Kết quả lưu vào thanh ghi R4 và kiểm tra các bit N,Z,C,V
BTVN: Thực hiện code đoạn trên vào Keil C (lệnh ADC,
ADD, SUB, SBC, RSC, RSB và xem chương trình tính ra R4
bằng bao nhiêu, kiểm tra lại bằng máy tính Casio Fx500;
26
Ví dụ: MOVS, SUBS,
ADDSN,Z,(C,V:
not affected)
16 trạng
thái đk:
CS,CC, I=0, operand2 là thanh ghi
EQ,NE I=1, operand2 là số nguyên
hexa, tức thời
…
 Cấu trúc lệnh
được mã hóa: ghi
vào SPSR (R13)
Operand2=Imm, 12
bit=>8 bit cho Imm,
4 bit để quay
quay được 16 bit.
 Cấu trúc lệnh: Condition

 Cấu trúc lệnh: Condition

 Cấu trúc lệnh: Opcode: từ bit 21-24: 2^4=16
 Cấu trúc lệnh: Operand2 (register)
Operand2=Reg và phần dịch/quay Operand2=Reg và phần dịch/quay thanh ghi,

số tức thời, 03 là mã số hiệu thanh 03 là mã số hiệu thanh ghi Rm (16 thanh ghi)
ghi Rm (16 thanh ghi)
Bit4 =1
Bit4 =0
Bit 65=00,01,10,11: ứng với 4 phép dịch,quay
Bit 65=00,01,10,11: ứng với 4 phép
dịch,quay Bit 7 được thiết lập mặc định là 0 (always=0)
Bit 7 đến 11 là 5 bit để dịch/quay Bit 8 đến 11 là 4 bit để chỉ số liệu thanh ghi
không dấu (031) dịch/quay (015)
I bit
MOV R4, #0x000000FE

MOV R5, R4, LSL#32
Chương trình sẽ báo
lỗi vì 32 vượt quá 2^5-1
 Ví dụ về lệnh xử lý dữ liệu
Bit I
• 1110.0000.1000(S).0001(Rn).0101.
(Rd).0000.0000.0011=0xE08
• 0001.000(I)0.100(opt)1(S).0000(Rn).0000.(Rd).0001.0.(#shift)000.0000=0x10900100
 Cấu trúc lệnh:
Lệnh:
MOV R4,#0x00
MOV R5,#0x05
MOV R7,#0x02
ADDEQ R4, R5, R7, ASR#7
BTVN: Hãy phân tích trạng thái thanh ghi SPSR sau khi
thực hiện chương trình trên (xem 32 bit của SPSR lần lượt
như thế nào?)
Kq: R4=#0x00;SPSR=00000000100001010100001111000111(2)=0x008543C7
Sau lệnh: ADDEQS R4,R5,R7,RRX #5 thì SPSR là thế nào?

 Cấu trúc lệnh:
Lệnh:
MOV R4,#0x00
MOV R5,#0x05
MOV R7,#0x28
ADDEQ R4, R5, R7, ASR#3
BTVN: Hãy phân tích trạng thái thanh ghi SPSR sau
khi thực hiện chương trình trên (xem 32 bit của SPSR
lần lượt như thế nào?)
Kq: R4=#0x0A;SPSR=00000000100001010100001111000111(2)=0x008543C7
Sau lệnh: RSBEQS R4,R5,R7,LSR #5 thì SPSR là thế nào?
Exercise 2 Current Program Status Register (CPSR)
Fill in the shaded areas.

Program counter PC =R15, #value = intermediate constant
value
Address (H) Comments After instruction is run
PC PC (Hex) C R0(Hex) R1(Hex) R2 (Hex)
All registers R0-R2 are rest to 0 here 0 0 0
0000 1000 Mov r1,#15 ;r1=15 0000 1004 0 0000 0000 0000 000f ffff ffff
Mov r2,#0xffffffff ;r2=#0xffffffff ? ? ? ? ?

;i.e. r2= -1
ADDs r0,r1,r2 ;r0=r1+r2 ? ?
ADCs r0,r1,r2 ;r0=r1+r2+C ? ?
SUBs r0,r1,r2 ;r0=r1-r2 ? ?
SBCs r0,r1,r2 ;r0=r1-r2+C-1 ? ?
Điền giá trị dòng tô màu vàng trong 20 phút (CPSR)

&: AND, ^: XOR,
 Lệnh logic OR |, ~: NOT
instruction<cond><S> Rd, Rn, N
MOV32 R1,#0xFE000086; MOV32 R2,#0x00C5A123; MOV32 R3,#0x28B845CD

Hãy tìm kết quả của các phép tính sau:
ANDNE R5, R1, R2;  Ví dụ: cho Rd=0x00A80072;Rn=1CD9ABF2
ORRCC R6, R1,R3;
Tính AND, ORR, EOR và BIC của Rd với Rn theo quy
EOR R7, R2, R3;
tắc trên
MOV R4, R2, ASR#2
BIC R0, R4, R2; Đáp số:
(BTVN)
 Lệnh logic
• AND R0, R1, R2 ; R0 = R1 and R2
• ORR R0, R1, R2 ; R0 = R1 or R2
• EOR R0, R1, R2 ; R0 = R1 xor R2
• BIC R0, R1, R2 ; R0 = R1 and (~R2) and not
Lệnh BIC là lệnh xóa bit: Các bit trong R1 sẽ bị xóa bởi các bit được
đánh dấu trong R2 (ở cùng vị trí nếu cùng giá trị thì xóa về 0 và ngược lại
R1 = 0x11111111 R2 = 0x01100101
BIC R0, R1, R2
R0 = 0x10011010
Exercise 3 Current Program Status Register (CPSR)

Program counter PC =R15, #value = intermediate constant
value
PC  R0(Hex) R1(Hex) R2(Hex) NZ
At the beginning 0000 0000H 0000 0055H 0000 0061H 00
0000 7000 ANDs r0,r1,r2 ;r0=r1 and r2 (bit

by bit )
ORRs r0,r1,r2 ;r0=r1 or r2
EORs r0,r1,r2 ;r0=r1 xor r2
BICs r0,r1,r2 ;r0=r1 and (not r2)
R1=55H=0101 0101 B
R2=61H=0110 0001 B
9EH=1001 1110 B
 Lệnh so sánh (comparison) &: AND, ^: XOR, | OR
• Các lệnh so sánh không tạo ra kết quả nhưng nó tác động đến
các bit cờ (N, Z, C, V) trong thanh ghi CPSR.
• Cú pháp: instruction<cond> Rn, N
 Lệnh so sánh
• CMP R1, R2 ; Thiết lập cờ dựa trên kết quả R1 – R2
• CMN R1, R2 ; Thiết lập cờ dựa trên kết quả R1 + R2
• TST R1, R2 ; bit test: Thiết lập cờ dựa trên kq R1 and R2
• TEQ R1, R2 ; test equality: Thiết lập cờ dựa trên kq R1 xor R2
BTVN: GV sẽ hỏi sau một tuần.

MOV32 R1,#0xFE000086; MOV32 R2,#0x00C5A123; MOV32 R3,#0x28B845CD
Hãy tìm kết quả các trạng thái flags NZCV của CPSR sau các phép tính sau:
CMP R5, R1, R2; R5=?
CMN R6, R1,R3; R6=?
TEQ R7, R2, R3;
TST R4, R2, R7;
 Lệnh so sánh
CMP
CMP r1,
r1,r2
r2 ;;set
setcc
ccon
onr1
r1--r2
r2(compare)
(compare)
 Same as SUB (subtract) except result of subtraction is not stored.

 Only the condition code bits (cc) {N,Z,C,V} in CPSR are changed
• N = 1 if MSB of (r1 - r2) is '1‘ (MSB of result is sign bit, 1 = negative)

• Z=1 when the result is zero
• C=1 when the result of an addition is greater than or equal to 232, if the
result of a subtraction is positive.
• V=1 (when result of add, subtract, or compare is >= 231, or < –231.). I.e.
• if two -ve numbers are added, the result is +ve (underflow).
• if two +ve numbers are added, the result is -ve (overflow).
(0x7FFFFFFF+1=0x80000000)
 Lệnh so sánh
Ví dụ:
R1 = a, R2 = b
if (R1<R2)
R1=a
else
R1=b
TST updates the N and Z flags
Exercise 6 according to the result, It
does not affect the C or V flags.

PC NZCV (binary) R1 (Hex) R2 (Hex)

All registers R0-R2=0 and NZCV=0000, here
0000 1000 Mov r1,#15 ;r1=15 decimal
Mov ;r2=0xF0 (0xf is

r2,#0x240 240 in decimal)
TST r1,r2 ; set cc on r1
0000
AND r2 (logical
1111 0000 1111
And
AND operation 0001 1000 Xor 0001 1000
test bits)
--------------------------------- ---------------------------------
Result 0000 1000 Result 0001 0111
TEQ r1,r2 ; set cc on r1 xor
r2 (test
equivalent)
Convert hex to decimal :http://easycalculation.com/hex-converter.php
Lệnh nhân (multification, multiply)
 Lệnh nhân: ARM7 hỗ trợ nhân có tích lũy và không
dạng y=a.x+b và y=a.x
MLA<cond><S> Rd, Rm, Rs, Rn
MUL<cond><S> Rd, Rm, Rs
-Tấtcả các toán hạng phải là thanh ghi (operand2=reg)

-Thanh ghi Rm, Rs phải là hai thanh ghi khác nhau
Lệnh nhân dài (long multification) 64 bit
 Lệnh nhân 64 bit (là kết quả phép nhân 2 số 32 bit)
instruction<cond><S> RdLo, RdHi, Rm, Rs
BTVN: Nhập hai số tùy ý cho vào thanh ghi R0, R1. Thực hiện phép nhân tích
lũy với phần tích lũy ở R2 và ghi vào R3.
Nhập 2 số tùy ý (không dấu hoặc có dấu) và di chuyển MOV32 vào R0, R1.
Lập trình nhân 64 bit dùng R5, R6 cho số 64 bit.
Mã optcode và SPSR ở chế độ lệnh nhân
Ví dụ: Cho chương trình như sau:

MOV R5,#5
MOV R4,#0xA0
Tìm kết quả SPSR của lệnh nhân và CPSR sau khi
thực hiện các lệnh:
1) MULEQ R0, R5, R4
2) UMLAL R1, R2, R4, R5
ARM has a number of multiply instructions
❖ Produce product of two 32-bit binary numbers held in registers.
❖ Results of 32-bit*32-bit is 64 bits. Some ARM processors stores the
entire 64-bit results in registers. Other ARM processors only stores the
LOWER 32-bit products.
❖ Multiply-Accumulate instruction also add product to accumulator value
to form a running total.
NỘI DUNG
4. Ngắt
49
 Lệnh rẽ nhánh: Branch (verb) branching
Thanh ghi CP (R15) sẽ lưu giá trị vào LR(R14) khi nhảy vào chương trình
con có nhãn label
• Lệnh rẽ nhánh không điều kiện
B label
….
label: ….
• Lệnh rẽ nhánh có điều kiện
MOV R0, #0
;{BL loop} optional
loop: ADD R0, R0, #1
CMP R0, #10
BNE loop
 Lệnh rẽ nhánh: có nhiều kiểu rẽ nhánh khác nhau
 Lệnh rẽ nhánh
 Lệnh rẽ nhánh
 Lệnh gọi hàm

• Lệnh BL (Branch to a Label) copy địa chỉ quay trở về
chương trình chính vào thanh ghi R14 (lr)
BL subfunc ; gọi hàm subfunc
CMP R1, #5 ; vị trí quay trở lại
…..
Subfunc: ….. ; hàm con
…..
MOV PC, LR ; quay lại chương trình
chính
 Lệnh gọi hàm
• B Label: Rẽ nhánh đến Label
• BL Label: Rẽ nhánh đến Label và lệnh tiếp theo trong LR
• BX R0: Rẽ nhánh đến địa chỉ (Addr) lưu trong R0 (số
tạm thời-Hexa #0x….)
• BLX R0: Rẽ nhánh đến địa chỉ ô nhớ lưu trong thanh ghi
R0
 Ví dụ: Tìm số lớn nhất trong 3 số sau và lưu trong

R3:
R0 = 0x342454AB
R1 = 0x4345CD21
R2 = 0x34CD2345
R3 =?
BTVN: Hãy viết chương trình hợp ngữ ARM thực hiện nhiệm
vụ nói trên.
Tuần kế tiếp sẽ giải và chữa bài này!
NỘI DUNG
4. Ngắt
57
 Lệnh di chuyển dữ liệu (data transfer # data movement)

• Di chuyển dữ liệu giữa các thanh ghi và bộ nhớ
• Có 3 dạng chính:
 Load/store một thanh ghi
 Load/store nhiều thanh ghi
 Hoán chuyển (swap, permutate) dữ liệu giữa ô nhớ và thanh ghi
(bản chất là một thư viện chương trình con code sẵn)
Lệnh hoán chuyển dữ liệu (SWP-swap) giữa hai thanh ghi sẽ tương đương
chương trình hoán đổi nội dung của hai thanh ghi R1 và R2 như sau:
MOV R0,R1;
MOV R1,R2;
MOV R2,R0;
 Lệnh di chuyển dữ liệu (data transfer # data movement)
• Cấu trúc khi mã hóa ở SPSR của lệnh di chuyển dữ liệu
 Load/Store một thanh ghi

• Cú pháp:
 <LDR|STR>{cond}{B\SB\H\SH} Rd, [Rn] : Nạp dữ liệu từ ô
nhớ có địa chỉ lưu trong Rn vào thanh ghi Rd
• Độ dài dữ liệu có thể là 1 byte (8 bit), 1 byte có dấu, nửa
từ (16 bit), nửa từ có dấu, 1 từ (32 bit)
SPSR của lệnh chuyển đổi dữ liệu Load/Store mức thanh ghi đơn


 Ví dụ:
addr Addr + 1 Giá trị thanh ghi
LDRB 11001101 00000000 00000000 00000000 00000000 11001101
LDRH 11001101 10100101 00000000 00000000 10100101 11001101

LDRSB 11001101 111111111 111111111 111111111 111111111 11001101
LDRSH 11001101 10100101 111111111 111111111 10100101 11001101
LDRSB 01001101 00000000 00000000 00000000 00000000 01001101
LDRSH 11001101 00100101 00000000 00000000 00100101 11001101

 Ví dụ:
LDRB 11001101 00000000 00000000 00000000 11001101
LDRH 11001101 10100101 00000000 00000000 10100101 11001101

LDRSB 11001101 111111111 111111111 111111111 11001101
LDRSH 11001101 10100101 111111111 111111111 10100101 11001101
LDRB 01001101 00000000 00000000 00000000 01001101
LDRH 11001101 00100101 00000000 00000000 00100101 11001101

• Chế độ địa chỉ Pre-indexed
 Địa chỉ bao gồm địa chỉ cơ sở (lưu trong thanh ghi) và các địa
chỉ đoạn (offset)
 Mục đích: cho phép truy cập tới các vị trí ô nhớ trong một vùng
nhớ.
LDR R0, [R1, #4] ; R0 = mem[R1+4]

; R1 không đổi
• Chế độ địa chỉ Auto-indexing (Preindex with writeback)
LDR R0, [R1,#4]! ; R0 = mem[R1+4]

; R1 = R1 + 4
Dấu ! biểu thị rằng thanh ghi R1 (chứa địa chỉ lưu ở thanh ghi này) sẽ cập
nhật luôn vị trí địa chỉ đoạn (offset)

• Chế độ địa chỉ Post-indexed
 Không sử dụng dấu chấm than (!)
LDR R0, [R1], #4 ; R0 = mem[R1]

; R1 = R1 + 4

• Lưu ý: Để nạp một số lớn hơn 255 vào thanh ghi:
LDR R1, = 0x12345678
Nếu dùng lệnh MOV R1, #0x12345678, chương trình sẽ
báo lỗi:
A1510E: Immediate 0x12345678 cannot be responded
Đó là khác biệt giữa LDR và MOV bởi vì MOV chỉ cho
phép thao tác với số 32 bit không lớn hơn 255!

• Ví dụ: R0 = 0x00000000
R1 = 0x00000009
mem32[R1] = 0x01010101
mem32[R1+4] = 0x02020202
Tìm giá trị của R0, R1 trong các trường hợp sau:
a. LDR R0, [R1,#4], ;R0=0x02020202, R1=0x00000009
b. LDR R0, [R1,#4]! ;R0=0x02020202,R1=0x0000000D
c. LDR R0, [R1],#4 ; R0=0x01010101, R1=0x0000000D
BT(ở lớp, về nhà): Hãy cho biết giá trị của R0,R1 trong
trường hợp trên.

• Ví dụ: Tìm giá trị của R0, R1 trong các trường hợp
sau:
a. STR R0,[R1,#20]
b. STR R0,[R1,R0,LSL #2]
c. STR R0,[R1,#16]!
d. STR R0,[R1],#20

• Ví dụ: Tính giá trị biểu thức
S= a1*b1 + a2*b2 + ... + a10*b10
trong đó địa chỉ ô nhớ chứa a1 lưu trong R8, b1 lưu trong
R9.

• Ví dụ: Tính giá trị biểu thức
MOV r11,#10
MOV r10,#0
LOOP
LDR r0,[r8],#4
LDR r1,[r9],#4
MLA r10,r0,r1,r10 ; r10 = r0*r1 + r10
SUBS r11,r11,#1
BNE LOOP
 Load/Store nhiều thanh ghi

• Cú pháp:
LDM|STM{cond}<mode> Rn{!},<register>
• M=Multi-register
• Các chế độ địa chỉ
Chế độ Mô tả Địa chỉ bắt đầu Địa chỉ kết thúc Rn!
IA Increment after Rn Rn + 4*N – 4 Rn + 4*N
IB Increment before Rn + 4 Rn + 4*N Rn + 4*N
DA Decrement after Rn – 4*N + 4 Rn Rn-4*N
DB Decrement before Rn – 4*N Rn – 4 Rn – 4*N

• LDMIA Rn, {<register>}
• Ví dụ:

• LDMIA Rn!, {<register>}
• Ví dụ:

• LDMIB Rn!, {<register>}
• Ví dụ:

• LDMDA Rn!, {<register>}
• Ví dụ:

• LDMDB Rn!, {<register>}
• Ví dụ:
 SPSR khi Load/Store nhiều thanh ghi
R0-R2, R14: cứ vị trí mã thanh ghi nào dùng

thì set nó =1: 4007;
R13=Rn bít 16-19: =13 (decimal)=D (hexa)
L=0 vì Load=1, store=0 mà lệnh là STM nghĩa
là store
W=1 vì R13! Nghĩa là auto-indexing
S=0 vì không có điều kiện force user bit
U=1 vì STMIA nghĩa là tăng sau (tăng thì là
up)
P=0 vì ko dùng pre/post index
25-27: 100
Cond=always =1110=E(ko có rõ điều kiện khác
thì default là always,
Vậy kết quả điền vào ta được E8AD4007
 Cho lệnh LDMDB r14!, {r1-5, r8-r10, r13,r15)

Hãy điền kết quả SPSR (BTVN):
 Định nghĩa hằng số trong lập trình ARM
 DCB: Lệnh chỉ dẫn sử dụng một hoặc nhiều byte
trong bộ nhớ để lưu dữ liệu
• Cú pháp: Label DCB exp,{offset}
 Ví dụ:
•Message1 DCB “Hello”
•Value1 DCB 0x12 ; Phân bổ 1 byte cho ô nhớ Value1 = 12
•Value2 DCW 0x1234 ; Phân bổ 2 byte cho Value2 = 1234
•Value3 DCD 0x12345678 ; Phân bổ 4 byte cho Value3
•SQR DCB 1,4,9,16; Phân bổ 4 byte cho 4 ô nhớ có giá trị lần
lượt là 1, 4, 9 và 16
 Trong tập lệnh ARM32
 DCW: Lệnh chỉ dẫn sử dụng từ 32 bit trong bộ nhớ để lưu dữ
liệu

 Ví dụ: Tìm giá trị đảo của C123 và lưu vào ô nhớ
ngoài (C123 là hằng số)
 Ví dụ: Tìm giá trị đảo của C123 và lưu vào ô nhớ ngoài
(địa chỉ bất kỳ hoặc lấy ngay địa chỉ đầu tiên là 0x0000)
AREA vidu, CODE, READONLY
ENTRY
Main
Value DCD 0xC123
Result DCD 0x0000
LDR R1, Value
LDR R0, Result
MVN R1, R1
STR R1, [R0]
 Ví dụ: Tìm giá trị đảo của DA68 và lưu vào ô nhớ ngoài
ở địa chỉ 0xAB0000000;
ENTRY
Main
Value DCD 0xDA68
Result DCD 0xAB000000
LDR R1, Value
LDR R0, Result
MVN R1, R1
STR R1, [R0]
 Ví dụ: Cộng hai số
• Value1 = 12345678
• Value2 = 23456789
• Result = ?
Dùng cách lập trình hằng số để thực hiện cộng hai số và nhân hai số (lệnh
nhân 64) như trên ở trên nền tảng KeilC bằng code Assembly
BTVN: Gợi ý: sử dụng hai thanh ghi để chứa kết quả: 1 thanh ghi 32 bit
để chứa 32 bit thấp của nó, thanh ghi thứ hai chứa kết quả phần nhớ được
tràn ra các bít thứ 33…
BT: khai báo hai hằng số 4 bytes (dùng lệnh DCW) , tìm số lớn nhất lưu
vào ô nhớ có địa chỉ là 0x00AB và hoán vị số nhỏ nhất với ô nhớ có địa
chỉ là 0x00FE (sử dụng lệnh SWP)

Khai báo hai hằng số 4 bytes (dùng lệnh DCW) , tìm số lớn nhất lưu vào ô
nhớ có địa chỉ là 0x00AB và hoán vị số nhỏ nhất với ô nhớ có địa chỉ là
0x00FE (sử dụng lệnh SWP)
ENTRY
Main
Address1 DCD 0x00AB
Address2 DCD 0x00FE
Value1 DCW 0x00000AB
Value2 DCW 0x00000009
LDR R0, Value1
LDR R1, Value2
CMP R0, R1
BGE Store
BLT Swap
Store
LDR R2, Addres1
STRGE R0, [R2]
B BAL Mode1
Swap
 Giải thích các lệnh sau đây:

MOV R0, R1,ROR #26
CMP R0,#256
MVNLT R0,#255
STR R0,[R1,R2,LSL#2]
STR R0,[R1,# -16]!
STRB R0,[R1,#1]!
STRB R0,[R1],R2
 Căn chỉnh ô nhớ trong ARM

Sử dụng lênh Align theo cú pháp:
 Align {expr,{offset}} : Căn chỉnh ô nhớ hiện tại
theo một kích thước nhất định.
• Nếu expr không được chỉ ra, Align sẽ căn chỉnh vị trí
lệnh ở từ nhớ tiếp theo.
Lệnh ADR: (Aligned-load data register)
Syntax
Cú pháp của ADR là:
ADR{condition} register,expression
Ở đây:
register là một thanh ghi để tải (load).
expression là một biểu thức thanh ghi hoặc chương trình tương đối để đánh giá:
- Một địa chỉ được căn chỉnh không theo từ (word) giữa 255 bytes
- Một địa chỉ được căn chỉnh trong 1020 bytes
Một địa chỉ có thể là trước hoặc sau một địa chỉ của lệnh hoặc thanh ghi cơ sở
Ví dụ:
start MOV r0,#10
ADR r4,start ; => SUB r4,pc,#0xc
The ADR instruction loads an address within a certain range, without performing a data load.
ADR accepts a PC-relative expression, that is, a label with an optional offset where the address of the label is relative to the PC.
AREA Jump, CODE, READONLY ; Name this block of code
ARM ; Following code is ARM code
num EQU 2 ; Number of entries in jump table
ENTRY ; Mark first instruction to execute
start ; First instruction to call
MOV r0, #0 ; Set up the three arguments
MOV r1, #3
MOV r2, #2
BL arithfunc ; Call the function
stop
MOV r0, #0x18 ; angel_SWIreason_ReportException
LDR r1, =0x20026 ; ADP_Stopped_ApplicationExit
SVC #0x123456 ; ARM semihosting (formerly SWI)
arithfunc ; Label the function
CMP r0, #num ; Treat function code as unsigned
; integer
BXHS lr ; If code is >= num then return
ADR r3, JumpTable ; Load address of jump table
LDR pc, [r3,r0,LSL#2] ; Jump to the appropriate routine
JumpTable
DCD DoAdd
DCD DoSub
DoAdd
ADD r0, r1, r2 ; Operation 0
BX lr ; Return
DoSub
SUB r0, r1, r2 ; Operation 1
BX lr ; Return
END ; Mark the end of this file
 Hoán chuyển dữ liệu giữa ô nhớ và thanh ghi
 Sử dụng lênh SWP (swap:hoán vị, hoán chuyển) để
exchange (chuyển đổi, tráo đổi) giữa bộ nhớ và thanh
ghi
 Cú pháp:
 Bài tập 1: Tính x = (mem[a] + mem[b]) – mem[c]
 Bài tập 2: Tính x= (mem[a] + mem[b])* mem[c]
 Bài tập 3: Tính R1=(R2<<2)|(R3&15)

Bài tập 4: Giải thích chương trình sau

AREA Program, CODE, READONLY
ENTRY AREA Data1, DATA
Main Table DCW &0B1A
LDR R0, = Data1 ALIGN
EOR R1, R1, R1 DCW &23C4
LDR R2, Length ALIGN
Loop DCW &15E7
LDR R3, [R0] ALIGN
ADD R1, R1, R3 TablEnd DCD 0
ADD R0, R0, #4
SUBS R2, R2, #0x1 AREA Data2, DATA
BNE Loop Length DCW (TablEnd - Table) / 4
STR R1, Result ALIGN
SWI &11 Result DCW 0
END
 Bài tập 5: Viết chương trình thực hiện:
Sao chép chuỗi “Hello world” từ một địa chỉ trong ô
nhớ Srcstr sang một địa chỉ ô nhớ có tên Dststr.
Chương trình có sử dụng hàm con Funccopy để copy.

So sánh hai chuỗi đã cho được lưu tại hai địa chỉ
trong ô nhớ có tên là “String1” và “String2”. Lưu
thông báo “Khác nhau” hoặc “Giống nhau” vào ô
nhớ có tên Result
AREA MYCODE, CODE, READONLY
ENTRY
main
ADR r1,srcstr Sao chép chuỗi “Hello world” từ một địa chỉ
ADR r0,dststr trong ô nhớ Srcstr sang một địa chỉ ô nhớ có
BL Funccopy tên Dststr. Chương trình có sử dụng hàm con
srcstr DCB "Hello world",0
Funccopy để copy.
dststr DCB "Destination",0
Funccopy
LDRB r2,[r1],#1
STRB r2,[r0],#1
CMP r2,#0
BNE Funccopy
MOV pc,lr
END ;End of the program
94
NỘI DUNG
4. Biệt lệ/Ngắt (Exception/Interrupt)
95
 Thanh ghi CPSR (Current Program Status Register)

 Thứ tự ưu tiên các biệt lệ (trường hợp đặc biệt, ngắt)

 Thứ tự ưu tiên các biệt lệ

 Quá trình xử lý của CPU khi có biệt lệ:

• Lưu giá trị CPSR vào SPSR tương ứng của chế độ
tương ứng (5 chế độ tương ứng Undef, FIQ, IRQ,
Abort, SVC)
• Lưu PC (R15) vào LR (R14) của chế độ tương ứng
• Thiết lập giá trị cho CPSR của chế độ tương ứng
• Thiết lập giá trị cho PC để trỏ tới địa chỉ của trình xử lý
biệt lệ (exception handler)
 Ngắt mềm:
• Ngắt mềm (software interrupt) tạo ra một biệt lệ cho phép
ứng dụng gọi một số tác vụ của hệ điều hành.
• Cú pháp: SWI{cond} SWI_number
 Ngắt mềm:
Số hiệu ngắt Mô tả chức năng Đầu vào Đầu ra
SWI 0x00 Hiển thị một ký tự R0 lưu ký tự Hiển thị trên màn hình ký tự
 Ngắt mềm:
SWI 0x02 Hiển thị một chuỗi ký tự ra màn hình R0 lưu địa chỉ của chuỗi Hiển thị trên màn hình chuỗi
ký tự ký tự
SWI 0x11 Dừng chương trình
SWI 0x12 Đăng ký sử dụng vùng nhớ trên Heap R0 lưu kích thước (đơn R0: địa chỉ của vùng nhớ
vị là byte)
SWI 0x13 Giải phóng vùng nhớ trên Heap
SWI 0x66 Mở một file dữ liệu. Chế độ mở được lưu R0: lưu tên file R0: Kết quả quá trình mở
trên R1: R1: lưu chế độ mở file file. Nếu file không mở
- 0: Mở để đọc được, R0 = -1.
- 1: Mở để ghi
- 2: Mở để ghi tiếp
SWI 0x68 Đóng file R0: lưu tên file
SWI 0x69 Viết ghi chuỗi ký ra file hoặc ra màn hình R0: tên file hoặc Stdout
R1: Địa chỉ chuỗi ký tự
SWI 0x6a Đọc một chuỗi ký tự từ một file R0: tên file R0: số byte được lưu trữ
R1: địa chỉ đích
R2: số byte lớn nhất cần
đọc ra
SWI 0x6b Viết số nguyên ra file R0: tên file
R1: số nguyên
SWI 0x6c Đọc số nguyên từ file R0: tên file R0: lưu số nguyên
SWI 0x6d Lấy thời gian của hệ thống R0: thời gian (tính theo
milligiây)
 Ngắt mềm:
Ví dụ 1: Viết chương trình hiển thị chuỗi ký tự “Hello
world” ra màn hình.
.equ swi_stdout,0x02 ; gán số hiệu ngắt với tên ngắt (ngắt

02 để xuất ký tự ra màn hình)
ldr r0,=TextString ; nạp địa chỉ chuỗi ký tự vào thanh ghi
swi swi_stdout ; gọi ngắt
TextString: .asciz "Hello world\n"
 Ngắt mềm:
Ví dụ 2: Mở file và ghi chuỗi ký tự vào file.
InFileName: .asciz "Infile1.txt"

Message: .asciz "Hello there \n"
.equ SWI_Open,0x66
ldr r0,=InFileName
mov r1,#2 @ input mode
swi SWI_Open
ldr r1,=Message
swi 0x69
swi 0x68
Sao chép chuỗi “Hello world” từ một địa chỉ trong ô
nhớ Srcstr sang một địa chỉ ô nhớ có tên Dststr. Sau đó
hiển thị chuỗi ký tự từ ô nhớ Dststr ra màn hình (sử
dụng ngắt mềm SWI với véc tơ ngắt thích hợp.
 Dành cho kiểm tra giữa kỳ!

Chuong 3 - Tap Lenh Arm

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Chuong 3 - Tap Lenh Arm

Uploaded by

Copyright:

Available Formats

HỌC VIỆN CÔNG NGHỆ BƯU CHÍNH VIỄN THÔNG

BÀI GIẢNG MÔN

Giảng viên: TS. Trương Cao Dũng

 Cấu trúc chung của một lệnh ARM

Labe Operand Operand Operand

 Đặc điểm của tập lệnh ARM:

 Di chuyển dữ liệu giữa các thanh ghi

 Di chuyển dữ liệu giữa các thanh ghi:

; Lưu số 32 bit vào R1

 Dịch trái: LSL: Logical Shift Left

• MOV Rd, Rn, LSL #n ; Rd = Rn<<n

 Dịch phải: LSR=Logical Shift Right

• MOV Rd, Rn, LSR #n ; Rd = Rn>>n

• MOV Rd, Rn, ASR #n ; R0 = R2>>n (ASR)

 Dịch phải số học: ASR= Arithmetic Shift Right

• MOV R0, R2, ASR #3 ; R0 = R2>>3

• MOV Rd, Rn, RRX#n ; Rd = Rn sau khi quay vòng n

 Các lệnh số học: Cộng và trừ

Cờ carry trong thanh ghi CPSR sẽ được thiết lập với

 Các lệnh số học: Cộng và trừ

 Cấu trúc lệnh: Condition

 Cấu trúc lệnh: Condition

Operand2=Reg và phần dịch/quay Operand2=Reg và phần dịch/quay thanh ghi,

MOV R4, #0x000000FE

Sau lệnh: ADDEQS R4,R5,R7,RRX #5 thì SPSR là thế nào?

Fill in the shaded areas.

Mov r2,#0xffffffff ;r2=#0xffffffff ? ? ? ? ?

ADDs r0,r1,r2 ;r0=r1+r2 ? ?

ADCs r0,r1,r2 ;r0=r1+r2+C ? ?

SUBs r0,r1,r2 ;r0=r1-r2 ? ?

SBCs r0,r1,r2 ;r0=r1-r2+C-1 ? ?

Điền giá trị dòng tô màu vàng trong 20 phút (CPSR)

MOV32 R1,#0xFE000086; MOV32 R2,#0x00C5A123; MOV32 R3,#0x28B845CD

Fill in the shaded areas.

0000 7000 ANDs r0,r1,r2 ;r0=r1 and r2 (bit

EORs r0,r1,r2 ;r0=r1 xor r2

BICs r0,r1,r2 ;r0=r1 and (not r2)

BTVN: GV sẽ hỏi sau một tuần.

 Same as SUB (subtract) except result of subtraction is not stored.

• N = 1 if MSB of (r1 - r2) is '1‘ (MSB of result is sign bit, 1 = negative)

Address (H) Comments After instruction is run

0000 1000 Mov r1,#15 ;r1=15 decimal

Mov ;r2=0xF0 (0xf is

-Tấtcả các toán hạng phải là thanh ghi (operand2=reg)

Ví dụ: Cho chương trình như sau:

 Lệnh gọi hàm

 Ví dụ: Tìm số lớn nhất trong 3 số sau và lưu trong

 Lệnh di chuyển dữ liệu (data transfer # data movement)

 Load/Store một thanh ghi

 Load/Store một thanh ghi

 Load/Store một thanh ghi

addr Addr + 1 Giá trị thanh ghi

 Load/Store một thanh ghi

addr Addr + 1 Giá trị thanh ghi

 Load/Store một thanh ghi

LDR R0, [R1, #4] ; R0 = mem[R1+4]

LDR R0, [R1,#4]! ; R0 = mem[R1+4]

 Load/Store một thanh ghi

LDR R0, [R1], #4 ; R0 = mem[R1]

 Load/Store một thanh ghi

 Load/Store một thanh ghi

 Load/Store một thanh ghi

 Load/Store một thanh ghi