二、寻址方式
每种寻址方式可能还有其他的变形，但是在这一章中不做过多说明，会在下面对应的章节中给出。
寄存器寻址
MOV R1,R2 ;R2 -> R1
立即寻址
MOV R0,#0x123 ;0x123 -> R0
寄存器偏移寻址
MOV R0,R1,LSL #2 ;R1 的值左移 2 位，结果送给R0，即 R2 * 4 -> R0
可采用的移位操作如下：
- LSL：逻辑左移（Logical Shift Left），寄存器中字的低端空出的位补 0
- LSR：逻辑右移（Logical Shift Right），寄存器中字的高端空出的位补 0
- ASR：算术右移（Arithmetic Shift Right），移位过程中保持符号位不变，即如 果源操作数为正数，则字的高端空出的位补 0，否则补 1
- ROR：循环右移（Rotate Right），由字的低端移出的位填入字的高端空出的位
- RRX：带扩展的循环右移（Rotate Right eXtended by 1place）,操作数右移一位， 高端空出的位用原 C 标志值填充。
寄存器间接寻址
LDR R0,[R1] ;将 R1 中的数值作为地址，将这个地址的值取出给R0
基址寻址
LDR R2,[R3,#0x0F] ;将 R3 中的数值加 0x0F 作为地址，取出此地址的数值保存在 R2 中
多寄存器寻址
堆栈寻址
二、数据处理指令
快速查阅表
| 编号 | 助记符号 | 说明 | 操作 | | :--: | :-------------------: | :-----------------: | :---------------------------: | | 0 | MOV Rd ,operand2 | 数据转送 | Rd←operand2 | | 1 | MVN Rd ,operand2 | 数据非转送 | Rd←(~operand2) | | 2 | ADD Rd,Rn operand2 | 加法运算指令 | Rd←Rn+operand2 | | 3 | SUB Rd,Rn operand2 | 减法运算指令 | Rd←Rn-operand2 | | 4 | RSB Rd,Rn operand2 | 逆向减法指令 | Rd←operand2-Rn | | 5 | ADC Rd,Rn operand2 | 带进位加法 | Rd←Rn+operand2+carry | | 6 | SBC Rd,Rn operand2 | 带进位减法指令 | Rd←Rn-operand2-(NOT)Carry | | 7 | RSC Rd,Rn operand2 | 带进位逆向减法指令 | Rd←operand2-Rn-(NOT)Carry | | 8 | AND Rd,Rn operand2 | 逻辑与操作指令 | Rd←Rn&operand2 | | 9 | ORR Rd,Rn operand2 | 逻辑或操作指令 | Rd←Rn|operand2 | | 10 | EOR Rd,Rn operand2 | 逻辑异或操作指令 | Rd←Rn＾operand2 | | 11 | BIC Rd,Rn operand2 | 位清除指令 | Rd←Rn&(～operand2) | | 12 | CMP Rn,operand2 | 比较指令 | 标志 N、Z、C、V←Rn-operand2 C | | 13 | CMN Rn,operand2 | 负数比较指令 | N、Z、C、V←Rn＋operand2 | | 14 | TST Rn,operand2 | 位测试指令 | 标志 N、Z、C、V←Rn＆operand2 | | 15 | TEQ Rn,operand2 | 相等测试指令 | 标志 N、Z、C、V←Rn＾operand2 | | 16 | MUL Rd,Rm,Rs | 32 位乘法指令 | Rd←RmRs (Rd≠Rm) | | 17 | MLA Rd,Rm,Rs,Rn | 32 位乘加指令 | Rd←RmRs+Rn (Rd≠Rm) | | 18 | UMULL RdLo,RdHi,Rm,Rs | 64 位无符号乘法指令 | (RdLo,RdHi)←RmRs | | 19 | UMLAL RdLo,RdHi,Rm,Rs | 64 位无符号乘加指令 | (RdLo,RdHi)←RmRs+(RdLo,RdHi) | | 20 | SMULL RdLo,RdHi,Rm,Rs | 64 位有符号乘法指令 | (RdLo,RdHi)←RmRs | | 21 | SMLAL RdLo,RdHi,Rm,Rs | 64 位有符号乘加指令 | (RdLo,RdHi)←RmRs+(RdLo,RdHi) |
在介绍指令之前，我们首先先来介绍影响CPSR中的一些标志位
-
V 溢出标志位
-
C 进位或借位标志位
- 对于加法指令（ADDS 和 CMN）如果产生进位，则C = 1
- 对于减法指令 （SUBS 和 CMP ）如果产生借位，则C = 0
-
Z 结果为0标志位
- Z = 1 表示运算结果是 0
- 同理
-
N 符号标志位
- N=1 表示运算结果为负数
- 同理
[0] MOV 数据转送指令
MOV{cond}{S} Rd,operand2
MOV R1,#0x12 ;R1=0x12
MOV R2,R1,LSL #2 ;R2=R1 << 2
MOVS R3,R2,LSL #4 ;R3=R2 << 4,并影响标志位
[1] MVN 数据非转送指令
这个命令和MOV很像，只不过在传送之前，把操作数先取反了。
在使用这个命令的时候，请不要忘记 ARM 的寄存器是 32位的
MVN{cond}{S} Rd,operand2
MVN R1,#0xFF ;R1=0xFFFFFF00,这里的 0xFF 实际上是 0x000000FF
[2] ADD 加法运算指令
ADD R1,R1,#0x13 ;R1 = R1 + 0x13
ADDS R2,R1,#0x1 ;影响标志位
[3] SUB 减法运算指令指令
SUB R0,R1,#0x12 ;R0=R1-0x12
[4] RSB 逆向减法指令
RSB R3,R1,#0x12 ;R3=0x12-R1
[5] ADC 带进位加法
带进位加法指令.将 operand2 的数据与 Rn 的值相加,再加上 CPSR 中的 C 条件标志位.结果保存到 Rd 寄存器.
由于寄存器是32位的，所以这个指令常用于计算64位加法。
这里需要注意的是，在进行 ADDS 运算的时候，如果出现了进位，CPSR中的 C=1，否则 C=0
例如有这样的两个64位数：
假设R0和R1构成一个64位数，R0存放低32位，R1存放高32位；R2，R3构成一个64位数，R2存放低32位，R3存放高32位.
计算的方法就是，先让两个低32位寄存器相加，为了得到可能的进位，需要用到ADDS，它能影响标志位
接着使用ADC，两个高32位相加，再加上标志位中的C 进位
LDR R0, =0XFFFFFFFF
LDR R1, =0X12
LDR R2, =0X1
LDR R3, =0X2
ADDS R0,R0,R2 ;R0 = R0 + R1 也就是0xFFFFFFFF + 0x1 这得到的是 0x00000000 ，因为溢出了，但是有进位 C = 1
ADC R1,R1,R3 ; R1 = R1 + R3 也就是 0x12 + 0x2 + 1 得到 0x15
[6] SBC 带进位减法指令
带进位减法指令。用寄存器 Rn 减去 operand2，再减去 CPSR 中的 C 条件标志位的反码
这里需要注意的是，在进行 SUBS 运算的时候，如果出现了借位，CPSR中的 C=0，否则 C=1
SBC与ADC指令类似，常用于计算64位的减法。
例如有这样的两个64位数：
假设R0和R1构成一个64位数，R0存放低32位，R1存放高32位；R2，R3构成一个64位数，R2存放低32位，R3存放高32位.
LDR R0, =0X12
LDR R1, =0X9
LDR R2, =0X32
LDR R3, =0X2
SUBS R0,R0,R2 ;R0 = R0 - R2 也就是 0x12 - 0x32 这将得到 0xFFFFFFE0 ,因为不够减，CPSR 中的 N=1，C=0
SBC R1,R1,R3 ;R1 = R1 - R3 - !C 也就是 0x9 - 0x2 - !0 ，得到0x6
[7] RSC 带进位逆向减法指令
用寄存器 operand2 减去 Rn,再减去 CPSR 中的 C 条件标志位的反码
例如有这样的两个64位数：
假设R0和R1构成一个64位数，R0存放低32位，R1存放高32位；R2，R3构成一个64位数，R2存放低32位，R3存放高32位.
LDR R0, =0X12
LDR R1, =0X9
LDR R2, =0X32
LDR R3, =0X2
RSBS R0,R0,R2 ;R0 = R2-R0 也就是 0x32 - 0X12 这将得到 0x20 ,没有借位 ，CPSR 中的 N=1，C=1
RBC R1,R1,R3 ;R1 = R3 - R2 - !C 也就是 0x2 - 0x9 - !1 ，得到0xFFFFFFF9
这里值得注意一下，在计算机中负数是用补码保存的。
2 - 9 = -7
这个 -7 的原码在八位寄存器中是 10000111 , 反码是 11111000,补码是 11111001 ，也就是0xF9 ，同理，在32位寄存器中就是 0xFFFFFFFF9
所以，在了解了SUBS 和 SBC 之后，我们同样可以求出 64 位的负数，和上面的例子是一样的
假设R0和R1构成一个64位数，R0存放低32位，R1存放高32位 ，求它的负数
LDR R0, =0X12
LDR R1, =0X9
RSBS R0,R0,#0 ;R0 = 0-R0 也就是 0 - 0X12 这将得到 0xFFFFFFEE ,有借位 ，CPSR 中的 N=1，C=0
RBC R1,R1,#0 ;R1 = 0- R1 - !C 也就是 0 - 0x9 - !0 ，得到0xFFFFFFF6
这里还是算一下，-10 的 补码
在八位寄存器中，-10 的原码表示是 1000 1010 ,反码表示是 1111 0101,补码表示是 1111 0110 ,也就是0xF6
在32位寄存器中的表示就是,0xFFFF FFF6
[8] AND 逻辑与操作指令
AND R0,R1,R2 ;R0=R1&R2
[9] ORR 逻辑或操作指令
ORR R0,R1,R2 ;R0=R1|R2
[10] EOR 逻辑异或操作指令
[11] BIC 位清除指令
位清除指令.将寄存器Rn的值与operand2的值的反码按位作逻辑与操作,结果保存 到 Rd 中
[12] CMP 比较指令
本质是 做减法 ,结果一定影响标志位
CMP R1,R2 ;R1-R2
[13] CMN 负数比较指令
本质是 做加法 ,结果一定影响标志位
CMN R1,R2 ;R1+R2
[14] TST 位测试指令
指令将寄存器Rn的值与operand2的值按位作逻辑与操作,根据操作的 结果理新 CPSR 中相应的条件标志位
TST R0,#0x1 ;判断 R0 的最低位是否为 0
[15] TEQ 位相等测试指令
指令寄存器Rn的值与operand2的值按位作逻辑异或操作,根据操作 的结果理新 CPSR 中相应条件标志位
TEQ R0,R1 ;比较 R0 与 R1 是否相等 ,与用cmp命令对比，它不影响(不影响 V 位和 C 位）
[16] MUL 32 位乘法指令
指令将 Rm 和 Rs 中的值相乘,结果的低 32 位保存到 Rd 中
MUL{cond}{S} Rd,Rm,Rs
MUL R1,R2,R3 ;R1=R2×R3
MULS R1,R2,R3 ;R0=R2×R3,同时设置 CPSR 中的 N 位和 Z 位
[17] MLA 32 位乘加指令
指令将 Rm 和 Rs 中的值相乘,再将乘积加上第 3 个操作数,结果的低 32 位保存到 Rd 中
MLA{cond}{S} Rd,Rm,Rs,Rn
MLA R1,R2,R3,R4 ;R1=R2×R3+R4
[18] UMULL 64 位无符号乘法指令
U即 Unsigned 无符号
指令将 Rm 和 Rs 中的值作无符号数相乘,结果的低 32 位保存 到 RsLo 中,而高 32 位保存到 RdHi 中
UMULL{cond}{S} RdLo,RdHi,Rm,Rs
UMULL R0,R1,R2,R3 ;(R1:R0)=R2×R3 ;相当于 R0 = (R2*R3) 的低32位,R1 = (R2*R3) 的高32位
[19] UMLAL 64 位无符号乘加指令
U即 Unsigned 无符号
指令将 Rm 和 Rs 中的值作无符号数相乘,64 位乘积与 RdHi,RdLo 相加,结果的低 32 位保存到 RdLo 中,而高 32 位保存到 RdHi 中.
UMLAL{cond}{S} RdLo,RdHi,Rm,Rs
UMLAL R0,R1,R2,R3 ;(R1,R0)=R2×R3+(R1,R0) ;相当于 R0 = (R2*R3) 的低32位 + R0,R1 = (R2*R3) 的高32位+ R1
[20] SMULL 64 位有符号乘法指令
S即 Signed 有符号
指令将 Rm 和 Rs 中的值作有符号数相乘,结果的低 32 位保存 到 RdLo 中,而高 32 位保存到 RdHi 中
SMULL R0,R1,R2,R3 ;(R1:R0)=R2×R3 ;相当于 R0 = (R2*R3) 的低32位,R1 = (R2*R3) 的高32位
[21] SMLAL 64 位有符号乘加指令
指令将 Rm 和 Rs 中的值作有符号数相乘,64 位乘积与RdHi,RdLo,相加,结果的低 32 位保存到 RdLo 中,而高 32 位保存到 RdHi 中.
SMLAL R0,R1,R2,R3 ;(R1,R0)=R2×R3+(R1,R0) ;相当于 R0 = (R2*R3) 的低32位 + R0,R1 = (R2*R3) 的高32位+ R1
三、ARM分支指令
在了解分支指令之前，我们首先得去了解一下条件码，否则我们就会没办法正确使用分支指令
在此给出条件码表格
| 条件码助记符 | 英文含义，助记符来源 | 查看的标志 | 中文含义 | | :----------: | :--------------------------------------------------------: | :--------: | :------------------------: | | EQ | Equal | Z＝1 | 相等 | | NE | Not equal. | Z＝0 | 不相等 | | CS/HS | Unsigned higher or same (or carry set). | C=1 | 无符号数大于或等于/C位设置 | | CC/LO | Unsigned lower (or carry clear). | C=0 | 无符号数小于/C位清除 | | MI | Negative. The mnemonic stands for "minus". | N=1 | 负数 | | PL | Positive or zero. The mnemonic stands for "plus". | N=0 | 正数或零 | | VS | Signed overflow. The mnemonic stands for "V set". | V=1 | 溢出/V位设置 | | VC | No signed overflow. The mnemonic stands for "V clear". | V=0 | 没有溢出 /V位清除 | | HI | Unsigned higher. | C=1，Z=0 | 无符号数大于 | | LS | Unsigned lower or same. | C=0，Z=1 | 无符号数小于或等于 | | GE | Signed greater than or equal. | N=V | 带符号数大于或等于 | | LT | Signed less than. | N!=V | 带符号数小于 | | GT | Signed greater than. | Z=0，N=V | 带符号数大于 | | LE | Signed less than or equal. | Z=1，N！=V | 带符号数小于或等于 | | AL | Always executed. | 任何 | 无条件执行（指令默认条件） |
快速记忆方法：
我们必须得结合英文才能快速地记住这些**“助记符”**
尤其是无符号和有符号之间的比较。
无符号一般会使用 Lower 和 Higher和 Same，有符号一般会使用 Greater than 和 Less than 和 Equal，
所以，无符号的大于等于 HS = Higher + Same ，无符号小于等于 LS = Lower + Same ，无符号大于 HI = Higher（前两个字母）,无符号小于 LO = Lower
同理的，有符号大于等于 GE = Greater + Equal ,有符号小于等于 LE = Less + Equal, 有符号大于就是 GT = Greater + Than ，有符号小于就是 LT = Less + Than
所以，通过这个英文可以很快速地就记住。
跳转分支指令
接下来，我们来说一下跳转指令，同样的，给出跳转指令快速查阅表：
| 助记符 | 说明 | 操作 | | :------: | :------------------: | :-------------------: | | B label | 跳转指令 | PC←label | | BL label | 带链接的跳转指令 | LR←PC-4, PC←label | | BX Rm | 带状态切换的跳转指令 | PC←label,切换处理状态 |
[1] B 跳转指令
B{cond} label
B LOOP_Y1 ;跳转到 LOOP_Y1 标号处
[2] BL 带链接的跳转指令
BL{cond} label
这个跳转的操作是：LR←PC-4, PC←label，由于将PC地址保持到了LR寄存器里面，所以之后还能跳转回来
[3] BX 带状态切换的跳转指令
略
四、加载和存储指令
Load and Store with register offset.
他们最基础的指令是 LDR 和 STR，以下先给出这两个基础指令的用法：
| 助记符 | 说明 | 操作 | | ------------------ | ---------- | --------------- | | LDR Rd, addressing | 加载字数据 | Rd←[addressing] | | STR Rd, addressing | 存储字数据 | [addressing]←Rd | | | | |
寄存器间接寻址
LDR R0,[R1] ;R0 <- [R1]
STR R0,[R1] ;[R1] <- R0
基址加变址寻址
这里有几种方式，前变址法、后变址法、自动变址
-
前变址法，也就是先变化地址，再根据这个地址 存取。
LDR R0,[R1,#4] ;R0 <- [R1 + 4] -
后变址，也就是先存取，再变化地址
LDR R0,[R1],#4 ;R0 <- [R1] 然后 R1<-R1+4 -
自动变址，综合上面两种，加一个 感叹号 ！
LDR R0,[R1,#4]! ;R0 <- [R1 + 4] 然后 R1<-R1+4
STR 指令也是同理的，这里不再赘述。
在理解了基础指令之后，我们可以尝试去看看这两个指令的更多用法：
以下依旧给出速查表：
| 助记符 | 说明 | 操作 | | -------------------- | -------------------------- | --------------- | | LDR Rd, addressing | 加载字数据 | Rd←[addressing] | | LDRB Rd,addressing | 加载无符字节数据 | Rd←[addressing] | | LDRT Rd，addressing | 以用户模式加载字数据 | Rd←[addressing] | | LDRBT Rd，addressing | 以用户模式加载无符号字数据 | Rd←[addressing] | | LDRH Rd，addressing | 加载无符半字数据 | Rd←[addressing] | | LDRSB Rd，addressing | 加载有符字节数据 | Rd←[addressing] | | LDRSH Rd，addressing | 加载有符半字数据 | Rd←[addressing] | | | | | | STR Rd，addressing | 存储字数据 | [addressing]←Rd | | STRB Rd，addressing | 存储字节数据 | [addressing]←Rd | | STRT Rd，addressing | 以用户模式存储字数据 | [addressing]←Rd | | SRTBT Rd，addressing | 以用户模式存储字节数据 | [addressing]←Rd | | STRH Rd，addressing | 存储半字数据 | [addressing]←Rd |
虽然看起来蛮多的，但主要就是
- 后缀带有B的，是无符字节数据
- 后缀带有H的，是无符半字数据
- 后缀带有SB的，是有符号字节数据
- 后缀带有SH的，是有符号半字数据
因为 字节是Byte ，半字是Half Word，有符号是 Signed
五、加载和存储指令LDM 和 STM 批量加载和批量存储分析
这一段内容来自 http://blog.chinaunix.net/uid-29401328-id-5059312.html
这里是简单地进行搬运。
普通用法和堆栈用法
当LDM/STM没有被用于堆栈，而只是简单地表示地址前向增加，后向增加，前向减少，后向减少时，由IA,IB,DA,DB控制。
- IA ----> Increment After 每次传送后地址加4
- IB ----> Increment Before 每次传送前地址加4
- DA ----> Decrement After 每次传送后地址减4
- DB ----> Decrement Before 每次传送前地址减4
堆栈请求格式，FD,ED,FA,EA定义了前/后向索引和上/下位
F,E表示堆栈满或者空。 A 和 D 定义堆栈是递增还是递减，如果递增，STM将向上，LDM向下，如果递减，则相反。
- FA ----> Full Ascending 满递增堆栈
- FD ----> Full Descending 满递减堆栈
- EA ----> Empty Ascending 空递增堆栈
- ED ----> Empty Descending 空递减堆栈
普通用法
STMIA R0!,{R1,R3,R5}
LDMDB R0!,{R1-R3}
保存的时候使用了 IA 后增加的方式，取的时候就得用 DB 先减少 的方式
这个例子的R0指向一段基地址
堆栈用法
-
Full descending 满递减堆栈——FD 堆栈首部是高地址，堆栈向低地址增长。栈指针总是指向堆栈最后一个元素（最后 一个元素是最后压入的数据）。ARM-Thumb过程调用标准和ARM、Thumb C/C++ 编译器总是使用Full descending 类型堆栈。
-
Full ascending 满递增堆栈——FA 堆栈首部是低地址，堆栈向高地址增长。栈指针总是指向堆栈最后一个元素（最后 一个元素是最后压入的数据）。
-
Empty descending 空递减堆栈——ED 堆栈首部是高地址，堆栈向低地址增长。栈指针总是指向下一个将要放入数据的空位置。
-
Empty ascending 空递增堆栈——EA 堆栈首部是低地址，堆栈向高地址增长。栈指针总是指向下一个将要放入数据的空位置。
A 和D 定义堆栈是递增还是递减，如果递增，STM将向上，LDM向下，如果递减，则相反。
所以，LDMFD和STMFD是成对使用，因为堆栈方式和出栈方式要是相同的
六、ARM 伪指令
| 伪指令助记符 | 说明 | 操作 | | ----------------------------------- | ------------------------ | ------------------------------------------ | | ADR{cond} register,exper | 小范围的地址读取伪指令 | register<-expr 指向的地址 | | ADRL {cond} register,exper | 中等范围的地址读取伪指令 | register<-expr 指向的地址 | | LDR{cond} register,=expr/label_expr | 大范围的地址读取伪指令 | register<-expr/label-expr 指定 的数据/地址 | | NOP | 空操作伪指令 | |
七、简单介绍数据定义伪指令
1、DCB 分配一段字节的内存单元
{label} DCB expr{,expr}{,expr}…
A
DCB 0x11,0x22,0x33,0x44
DCB 0x55,0x66,0x77,0x88
DCB "Hello World"
DCB "ABCDEFGHIJKLMN",0
2 、DCW 和 DCWU 分配一段半字的内存单元
DCWU 需要半字对齐
B
DCW 0x1122,0x3344,0x5566,0x7788
3、 DCD 和 DCDU 分配一段字内存单元
DCD 需要字对齐
C
DCW 0x11223344,0x55667788,0x99aabbcc,0xddeeff00
4、SPACE 分配一片连续的字节内存单元，并初始化为0
{label} SPACE expr
D
Space 500 ;分配 500 字节空间,并初始化为0
八、汇编程序设计
程序 1 、使用跳转完成函数功能
首先，我们先来一个简单的跳转指令：
... ;之前的一些操作
BL ADD_FUNCTION ;带连接的跳转，LR <- PC -4 ,PC <- ADD_FUNCTION
... ;完成ADD_FUNCTION 这个函数的操作
...
ADD_FUNCTION
... ;一些操作
MOV PC,LR ;函数返回，相当于RET、Return，总之就是 PC <- LR
下面这个例子是老师给的：
设计一个函数，计算R0 和 R1 的值
AREA Example1,CODE,READONLY
ENTRY
start
LDR R0,=0X66
LDR R1,=0X88
BL ADD_FUNCTION ;带链接跳转
B RETURN ;跳到结束位置
ADD_FUNCTION
ADD R0,R0,R1
MOV PC,LR
RETURN
END
程序 2 、计算数组第1项和第5项之和，并将结果保存在第9项中
AREA Example1,CODE,READONLY
ENTRY
start
LDR R0,=ARRAY
LDR R1,[R0]
LDR R2,[R0,#16]
ADD R1,R1,R2
STR R1,[R0,#32]
ARRAY
DCD 0X11,0X22,0X33,0X44
DCD 0X55,0X66,0X77,0X88
DCD 0X00,0X00,0X00,0X00
END
程序 3、编写一个分支程序段，如果R5中的值等于10，就把R5中的数据存入R1，否则就把R5中的数据分别存入寄存器R0和R1
AREA Example1,CODE,READONLY
ENTRY
start
MOV R5,#9
CMP R5,#10
MOVNE R0,R5
MOV R1,R5
END
程序 4、编写一个程序段，当R1中的数据大于R2中的数据时，将R2中的数据加10存入R1中，否则将R2中的数据加5存入R1中
AREA Example1,CODE,READONLY
ENTRY
start
MOV R1,#10
MOV R2,#5
CMP R1,R2
ADDHI R1,R2,#10
ADDLS R1,R2,#5
END
还记得吗？
无符号一般会使用 Lower 和 Higher和 Same，有符号一般会使用 Greater than 和 Less than 和 Equal，
所以，无符号的大于等于 HS = Higher + Same ，无符号小于等于 LS = Lower + Same ，无符号大于 HI = Higher（前两个字母）,无符号小于 LO = Lower
同理的，有符号大于等于 GE = Greater + Equal ,有符号小于等于 LE = Less + Equal, 有符号大于就是 GT = Greater + Than ，有符号小于就是 LT = Less + Than
程序 5、循环，将 src 中的10个字节的数据，传送到 dst 开始的区域
AREA init,CODE,READONLY
ENTRY
start
LDR R0,=src
LDR R1,=dst
MOV R2,#0
LOOP
LDRB R3,[R0,R2]
STRB R3,[R1,R2]
ADD R2,R2,#1
CMP R2,#10
BLO LOOP
src
DCB "0123456789"
dst
DCB "aaaaaaaaaa"
END
程序 6、循环，将src中的所有小写字母变成大写字母，其他的ASCII码不变
我们需要知道 ascii 码中，
A的十六进制是41，能够推出Z的十六进制是5A
a的十六进制是61，能够推出z的十六进制是7A
AREA init,CODE,READONLY
ENTRY
start
LDR R0,=src
MOV R1,#0
LOOP
LDRB R2,[R0,R1]
CMP R2,#0X61
BLO NEXT
CMP R2,#0X7A
SUBLS R2,R2,#0X20
STRBLS R2,[R0,R1]
NEXT
ADD R1,R1,#1
CMP R1,#10
BNE LOOP
src
DCB "AabCdEfghI"
END
程序 7、循环，将src中的所有大写字母变成小写字母，其他的ASCII码不变
和上一题同理
AREA init,CODE,READONLY
ENTRY
start
LDR R0,=src
MOV R1,#0
LOOP
LDRB R2,[R0,R1]
CMP R2,#0X41
BLO NEXT
CMP R2,#0X5A
ADDLS R2,R2,#0X20
STRBLS R2,[R0,R1]
NEXT
ADD R1,R1,#1
CMP R1,#10
BNE LOOP
src
DCB "AabCdEfghI"
END