深入解析ARM汇编指令及输出段描述-CSDN博客

ARM汇编指令

ARM处理器的指令集可以分为跳转指令、数据处理指令、程序状态寄存器（PSR）处理指令、加载/存储指令、协处理器指令和异常产生指令6大指令。

一、跳转指令

跳转指令用于实现程序流程的跳转，在ARM程序中有以下两种方法可以实现程序流程的跳转。
Ⅰ.使用专门的跳转指令；

Ⅱ.直接向程序计数器PC写入跳转地址值，通过向程序计数器PC写入跳转地址值，可以实现在4GB的地址空间中的任意跳转，在跳转之前结合使用MOV LR，PC等类似指令，可以保存将来的返回地址值，从而实现在4GB连续的线性地址空间的子程序调用。

ARM指令集中的跳转指令可以完成从当前指令向前或向后的32MB的地址空间的跳转，包括以下4条指令：

1、B指令

B指令的格式为：

B{条件} 目标地址
B指令是最简单的跳转指令。一旦遇到一个B指令，ARM处理器将立即跳转到给定的目标地址，从那里继续执行。注意存储在跳转指令中的实际值是相对当前PC 值的一个偏移量，而不是一个绝对地址，它的值由汇编器来计算（参考寻址方式中的相对寻址）。它是24位有符号数，左移两位后有符号扩展为32 位，表示的有效偏移为26 位(前后32MB的地址空间)。以下指令：
B   Label             ；程序无条件跳转到标号Label处执行
CMP R1，＃0     ；当CPSR寄存器中的Z条件码置位时，程序跳转到标号Label处执行
BEQ Label

2、BL指令

BL指令的格式为：

BL{条件} 目标地址
BL是另一个跳转指令，但跳转之前，会在寄存器R14中保存PC的当前内容，因此，可以通过将R14的内容重新加载到PC中，来返回到跳转指令之后的那个指令处执行。该指令是实现子程序调用的一个基本但常用的手段。

以下指令：

BL Label ；当程序无条件跳转到标号Label处执行时，同时将当前的 PC值保存到

；R14（LR）中

3、BLX指令

BLX指令的格式为：

BLX 目标地址
BLX指令从ARM指令集跳转到指令中所指定的目标地址，并将处理器的工作状态有ARM状态切换到Thumb状态，该指令同时将PC的当前内容保存到寄存器R14中。因此，当子程序使用Thumb指令集，而调用者使用ARM指令集时，可以通过BLX指令实现子程序的调用和处理器工作状态的切换。同时，子程序的返回可以通过将寄存器R14值复制到PC中来完成。

4、BX指令

BX指令的格式为：

BX{条件} 目标地址
BX指令跳转到指令中所指定的目标地址，目标地址处的指令既可以是ARM指令，也可以是Thumb指令。

二、数据处理指令

数据处理指令可分为数据传送指令、算术逻辑运算指令和比较指令等。
数据传送指令用于在寄存器和存储器之间进行数据的双向传输；
算术逻辑运算指令完成常用的算术与逻辑的运算，该类指令不但将运算结果保存在目的寄存器中，同时更新CPSR中的相应条件标志位；
比较指令不保存运算结果，只更新CPSR中相应的条件标志位。
数据处理指令共以下16条。

1、MOV指令（传送）

MOV指令的格式为：

MOV{条件}{S} 目的寄存器，源操作数
MOV指令可完成从另一个寄存器、被移位的寄存器或将一个立即数加载到目的寄存器。其中S选项决定指令的操作是否影响CPSR中条件标志位的值，当没有S 时指令不更新CPSR中条件标志位的值。
指令示例：
MOV R1，R0                   ；将寄存器R0的值传送到寄存器R1
MOV PC，R14                 ；将寄存器R14的值传送到 PC，常用于子程序返回
MOV R1，R0，LSL＃3    ；将寄存器R0的值左移3位后传送到R1

2、MVN指令（求反）

MVN指令的格式为：

MVN{条件}{S} 目的寄存器，源操作数
MVN指令可完成从另一个寄存器、被移位的寄存器、或将一个立即数加载到目的寄存器。与MOV指令不同之处是在传送之前按位被取反了，即把一个被取反的值传送到目的寄存器中。其中S决定指令的操作是否影响CPSR中条件标志位的值，当没有S时指令不更新CPSR中条件标志位的值。
指令示例：
MVN R0，＃0 ；将立即数0取反传送到寄存器R0中，完成后R0=-1

3、CMP指令（比较）

CMP指令的格式为：

CMP{条件} 操作数1，操作数2
CMP指令用于把一个寄存器的内容和另一个寄存器的内容或立即数进行比较，同时更新CPSR中条件标志位的值。该指令进行一次减法运算，但不存储结果，只更改条件标志位。标志位表示的是操作数1与操作数2的关系(大、小、相等)，例如，当操作数1大于操作操作数2，则此后的有GT后缀的指令将可以执行。
指令示例：
CMP R1，R0 ；将寄存器R1的值与寄存器R0的值相减，并根据结果设置CPSR的标

；志位
CMP R1，＃100 ；将寄存器R1的值与立即数100相减，并根据结果设置CPSR的标志位

4、CMN指令（负数比较）

CMN指令的格式为：
CMN{条件} 操作数1，操作数2
CMN指令用于把一个寄存器的内容和另一个寄存器的内容或立即数取反后进行比较，同时更新CPSR中条件标志位的值。该指令实际完成操作数1和操作数2相加，并根据结果更改条件标志位。
指令示例：
CMN R1，R0 ；将寄存器R1的值与寄存器R0的值相加，并根据结果设置CPSR

；的标志位
CMN R1，＃100 ；将寄存器R1的值与立即数100相加，并根据结果设置CPSR的标志位

5、TST指令（测试）

TST指令的格式为：
    TST{条件} 操作数1，操作数2
TST指令用于把一个寄存器的内容和另一个寄存器的内容或立即数进行按位的与运算，并根据运算结果更新CPSR中条件标志位的值。操作数1是要测试的数据，而操作数2是一个位掩码，该指令一般用来检测是否设置了特定的位。
指令示例：
TST   R1，＃％1            ；用于测试在寄存器R1中是否设置了最低位（％表示二进制数）
TST R1，＃0xffe          ；将寄存器R1的值与立即数0xffe按位与，并根据结果设置CPSR

；的标志位

6、TEQ指令（测试相等）

TEQ指令的格式为：
TEQ{条件} 操作数1，操作数2
TEQ指令用于把一个寄存器的内容和另一个寄存器的内容或立即数进行按位的异或运算，并根据运算结果更新CPSR中条件标志位的值。该指令通常用于比较操作数1和操作数2是否相等。
指令示例：
TEQ R1，R2 ；将寄存器R1的值与寄存器R2的值按位异或，并根据结果设置CPSR

；的标志位

7、ADD指令（相加）

ADD指令的格式为：
     ADD{条件}{S} 目的寄存器，操作数1，操作数2
ADD指令用于把两个操作数相加，并将结果存放到目的寄存器中。操作数1应是一个寄存器，操作数2可以是一个寄存器，被移位的寄存器，或一个立即数。
指令示例：
ADD     R0，R1，R2                 ； R0 = R1 + R2
ADD     R0，R1，#256               ； R0 = R1 +256
ADD     R0，R2，R3，LSL#1      ； R0 = R2 +(R3 << 1)

8、ADC指令（带进位相加）

ADC指令的格式为：
ADC{条件}{S} 目的寄存器，操作数1，操作数2
ADC指令用于把两个操作数相加，再加上CPSR中的C条件标志位的值，并将结果存放到目的寄存器中。它使用一个进位标志位，这样就可以做比32位大的数的加法，注意不要忘记设置S后缀来更改进位标志。操作数1应是一个寄存器，操作数2可以是一个寄存器，被移位的寄存器，或一个立即数。
以下指令序列完成两个128位数的加法，第一个数由高到低存放在寄存器R7～R4，第二个数由高到低存放在寄存器R11～R8，运算结果由高到低存放在寄存器R3～R0：
ADDS    R0，R4，R8         ；加低端的字
ADCS    R1，R5，R9         ；加第二个字，带进位
ADCS    R2，R6，R10       ；加第三个字，带进位
ADC      R3，R7，R11       ；加第四个字，带进位

9、SUB指令（相减）

SUB指令的格式为：
SUB{条件}{S} 目的寄存器，操作数1，操作数2
SUB指令用于把操作数1减去操作数2，并将结果存放到目的寄存器中。操作数1应是一个寄存器，操作数2可以是一个寄存器，被移位的寄存器，或一个立即数。该指令可用于有符号数或无符号数的减法运算。
指令示例：
SUB     R0，R1，R2                ； R0 = R1 - R2
SUB     R0，R1，#256           ； R0 = R1 -256
SUB     R0，R2，R3，LSL#1     ； R0 = R2 -(R3 << 1)

10、~~~~C指令

~~~~C指令的格式为：
~~~~C{条件}{S} 目的寄存器，操作数1，操作数2
~~~~C指令用于把操作数1减去操作数2，再减去CPSR中的C条件标志位的反码，并将结果存放到目的寄存器中。操作数1应是一个寄存器，操作数2可以是一个寄存器，被移位的寄存器，或一个立即数。该指令使用进位标志来表示借位，这样就可以做大于32位的减法，注意不要忘记设置S后缀来更改进位标志。该指令可用于有符号数或无符号数的减法运算。
指令示例：
SUBS R0，R1，R2 ；R0 = R1 - R2- ！C，并根据结果设置CPSR的进位标志位

11、R~~~~指令

R~~~~指令的格式为：
R~~~~{条件}{S} 目的寄存器，操作数1，操作数2
R~~~~指令称为逆向减法指令，用于把操作数2减去操作数1，并将结果存放到目的寄存器中。操作数1应是一个寄存器，操作数2可以是一个寄存器，被移位的寄存器，或一个立即数。该指令可用于有符号数或无符号数的减法运算。
指令示例：
R~~~~     R0，R1，R2                        ； R0 = R2 – R1
R~~~~     R0，R1，#256                    ； R0 = 256 –R1
R~~~~     R0，R2，R3，LSL#1          ； R0 = (R3<< 1) - R2

12、RSC指令（反向带进位减）

RSC指令的格式为：
RSC{条件}{S} 目的寄存器，操作数1，操作数2
RSC指令用于把操作数2减去操作数1，再减去CPSR中的C条件标志位的反码，并将结果存放到目的寄存器中。操作数1应是一个寄存器，操作数2可以是一个寄存器，被移位的寄存器，或一个立即数。该指令使用进位标志来表示借位，这样就可以做大于32位的减法，注意不要忘记设置S后缀来更改进位标志。该指令可用于有符号数或无符号数的减法运算。
指令示例：
RSC R0，R1，R2 ；R0 = R2 – R1- ！C

13、AND指令（逻辑位与）

AND指令的格式为：
AND{条件}{S} 目的寄存器，操作数1，操作数2
AND指令用于在两个操作数上进行逻辑与运算，并把结果放置到目的寄存器中。操作数1应是一个寄存器，操作数2可以是一个寄存器，被移位的寄存器，或一个立即数。该指令常用于屏蔽操作数1的某些位。
指令示例：
AND R0，R0，＃3 ；该指令保持R0的0、1位，其余位清零。

14、ORR指令（逻辑位或）

ORR指令的格式为：
ORR{条件}{S} 目的寄存器，操作数1，操作数2
ORR指令用于在两个操作数上进行逻辑或运算，并把结果放置到目的寄存器中。操作数1应是一个寄存器，操作数2可以是一个寄存器，被移位的寄存器，或一个立即数。该指令常用于设置操作数1的某些位。
指令示例：
ORR R0，R0，＃3 ；该指令设置R0的0、1位，其余位保持不变。

15、EOR指令（逻辑位异或）

EOR指令的格式为：
EOR{条件}{S} 目的寄存器，操作数1，操作数2
EOR指令用于在两个操作数上进行逻辑异或运算，并把结果放置到目的寄存器中。操作数1应是一个寄存器，操作数2可以是一个寄存器，被移位的寄存器，或一个立即数。该指令常用于反转操作数1的某些位。
指令示例：
EOR R0，R0，＃3 ；该指令反转R0的0、1位，其余位保持不变。

16、BIC指令（位清零）

BIC指令的格式为：
BIC{条件}{S} 目的寄存器，操作数1，操作数2
BIC指令用于清除操作数1的某些位，并把结果放置到目的寄存器中。操作数1应是一个寄存器，操作数2可以是一个寄存器，被移位的寄存器，或一个立即数。操作数2为32位的掩码，如果在掩码中设置了某一位，则清除这一位。未设置的掩码位保持不变。
指令示例：
BIC R0，R0，＃％1011 ；该指令清除R0中的位 0、1、和 3，其余的位保持不变。

三、乘法指令与乘加指令

ARM 微处理器支持的乘法指令与乘加指令共有6条，可分为运算结果为32位和运算结果为64位两类，与前面的数据处理指令不同，指令中的所有操作数、目的寄存器必须为通用寄存器，不能对操作数使用立即数或被移位的寄存器，同时，目的寄存器和操作数1必须是不同的寄存器。
乘法指令与乘加指令共有以下6条：

1、MUL指令（相乘）

MUL指令的格式为：
     MUL{条件}{S} 目的寄存器，操作数1，操作数2
MUL指令完成将操作数1与操作数2的乘法运算，并把结果放置到目的寄存器中，同时可以根据运算结果设置CPSR中相应的条件标志位。其中，操作数1和操作数2均为32位的有符号数或无符号数。
指令示例：
MUL R0，R1，R2           ；R0 = R1 × R2
MULS R0，R1，R2           ；R0 = R1 × R2，同时设置CPSR中的相关条件标志位

2、MLA指令（带累加的相乘）

MLA指令的格式为：
     MLA{条件}{S} 目的寄存器，操作数1，操作数2，操作数3
MLA指令完成将操作数1与操作数2的乘法运算，再将乘积加上操作数3，并把结果放置到目的寄存器中，同时可以根据运算结果设置CPSR中相应的条件标志位。其中，操作数1和操作数2均为32位的有符号数或无符号数。
指令示例：
MLA   R0，R1，R2，R3           ；R0 = R1 × R2+ R3
MLAS R0，R1，R2，R3           ；R0 = R1 × R2+ R3，同时设置CPSR中的相关条件标志位

3、SMULL指令

SMULL指令的格式为：
     SMULL{条件}{S}   目的寄存器Low，目的寄存器High，操作数1，操作数2
SMULL指令完成将操作数1与操作数2的乘法运算，并把结果的低32位放置到目的寄存器Low中，结果的高32位放置到目的寄存器High中，同时可以根据运算结果设置CPSR中相应的条件标志位。其中，操作数1和操作数2均为32位的有符号数。
指令示例：
SMULL   R0，R1，R2，R3     ；R0 = （R2 × R3）的低32位
                                                  ；R1 = （R2 × R3）的高32位

4、SMLAL指令

SMLAL指令的格式为：
    SMLAL{条件}{S}   目的寄存器Low，目的寄存器High，操作数1，操作数2
SMLAL指令完成将操作数1与操作数2的乘法运算，并把结果的低32位同目的寄存器Low中的值相加后又放置到目的寄存器Low中，结果的高32位同目的寄存器High中的值相加后又放置到目的寄存器High中，同时可以根据运算结果设置CPSR中相应的条件标志位。其中，操作数1和操作数2均为32位的有符号数。
对于目的寄存器Low，在指令执行前存放64位加数的低32位，指令执行后存放结果的低32位；对于目的寄存器High，在指令执行前存放64位加数的高32位，指令执行后存放结果的高32位。
指令示例：
SMLAL   R0，R1，R2，R3      ；R0 = （R2 × R3）的低32位＋ R0
                                                   ；R1 = （R2 × R3）的高32位＋ R1

5、UMULL指令

UMULL指令的格式为：
    UMULL{条件}{S}   目的寄存器Low，目的寄存器High，操作数1，操作数2
UMULL指令完成将操作数1与操作数2的乘法运算，并把结果的低32位放置到目的寄存器Low中，结果的高32位放置到目的寄存器High中，同时可以根据运算结果设置CPSR中相应的条件标志位。其中，操作数1和操作数2均为32位的无符号数。
指令示例：
UMULL   R0，R1，R2，R3      ；R0 = （R2 × R3）的低32位
                                                    ；R1 = （R2 × R3）的高32位

6、UMLAL指令

UMLAL指令的格式为：
    UMLAL{条件}{S}   目的寄存器Low，目的寄存器High，操作数1，操作数2
UMLAL指令完成将操作数1与操作数2的乘法运算，并把结果的低32位同目的寄存器Low中的值相加后又放置到目的寄存器Low中，结果的高32位同目的寄存器High中的值相加后又放置到目的寄存器High 中，同时可以根据运算结果设置CPSR中相应的条件标志位。其中，操作数1和操作数2均为32位的无符号数。
对于目的寄存器Low，在指令执行前存放64位加数的低32位，指令执行后存放结果的低32位；对于目的寄存器High，在指令执行前存放64位加数的高32位，指令执行后存放结果的高32位。
指令示例：
UMLAL   R0，R1，R2，R3           ；R0 = （R2 × R3）的低32位＋ R0
                                                          ；R1 = （R2 × R3）的高32位＋ R1

四、程序状态寄存器访问指令

1、MRS指令

MRS指令的格式为：
    MRS{条件}    通用寄存器程序状态寄存器（CPSR或SPSR）
MRS指令用于将程序状态寄存器的内容传送到通用寄存器中。该指令一般用在以下两种情况：
Ⅰ.当需要改变程序状态寄存器的内容时，可用MRS将程序状态寄存器的内容读入通用寄存器，修改后再写回程序状态寄存器。
Ⅱ.当在异常处理或进程切换时，需要保存程序状态寄存器的值，可先用该指令读出程序状态寄存器的值，然后保存。
指令示例：
MRS R0，CPSR                        ；传送CPSR的内容到R0
MRS R0，SPSR                        ；传送 SPSR的内容到R0

2、MSR指令

MSR指令的格式为：
     MSR{条件}    程序状态寄存器（CPSR或SPSR）_<域>，操作数
MSR指令用于将操作数的内容传送到程序状态寄存器的特定域中。其中，操作数可以为通用寄存器或立即数。<域>用于设置程序状态寄存器中需要操作的位，32位的程序状态寄存器可分为4个域：
位[31：24]为条件位域，用f表示；
位[23：16]为状态位域，用s表示；
位[15：8] 为扩展位域，用x表示；
位[7：0]    为控制位域，用c表示；
该指令通常用于恢复或改变程序状态寄存器的内容，在使用时，一般要在MSR指令中指明将要操作的域。
指令示例：
MSR CPSR，R0       ；传送R0的内容到CPSR
MSR SPSR，R0       ；传送R0的内容到SPSR
MSR CPSR_c，R0    ；传送R0的内容到SPSR，但仅仅修改CPSR中的控制位域

五、加载/存储指令。

ARM微处理器支持加载/存储指令用于在寄存器和存储器之间传送数据，加载指令用于将存储器中的数据传送到寄存器，存储指令则完成相反的操作。常用的加载存储指令如下：

1、LDR指令

LDR指令的格式为：
    LDR{条件} 目的寄存器，<存储器地址>
LDR指令用于从存储器中将一个32位的字数据传送到目的寄存器中。该指令通常用于从存储器中读取32位的字数据到通用寄存器，然后对数据进行处理。当程序计数器PC作为目的寄存器时，指令从存储器中读取的字数据被当作目的地址，从而可以实现程序流程的跳转。该指令在程序设计中比较常用，且寻址方式灵活多样，请读者认真掌握。
指令示例：
LDR R0，[R1]               ；将存储器地址为R1的字数据读入寄存器R0。
LDR R0，[R1，R2]      ；将存储器地址为R1+R2的字数据读入寄存器R0。

LDR R0，[R1，#8] ；将存储器地址为R1+8的字数据读入寄存器R0。
LDR R0，[R1，R2] ！；将存储器地址为R1+R2的字数据读入寄存器R0，并将新地址

；R1＋R2写入R1。
LDR R0，[R1，＃8] ！；将存储器地址为R1+8的字数据读入寄存器R0，并将新地址 R1

；＋8写入R1。
LDR R0，[R1]，R2 ；将存储器地址为R1的字数据读入寄存器R0，并将新地址 R1＋

；R2写入R1。
LDR R0，[R1，R2，LSL＃2]！；将存储器地址为R1＋R2×4的字数据读入寄存器R0，并

；将新地址R1＋R2×4写入R1。
LDR R0，[R1]，R2，LSL＃2 ；将存储器地址为R1的字数据读入寄存器R0，并将新地

；址R1＋R2×4写入R1。

2、LDRB指令

LDRB指令的格式为：
LDR{条件}B 目的寄存器，<存储器地址>
LDRB指令用于从存储器中将一个8位的字节数据传送到目的寄存器中，同时将寄存器的高24位清零。该指令通常用于从存储器中读取8位的字节数据到通用寄存器，然后对数据进行处理。当程序计数器PC作为目的寄存器时，指令从存储器中读取的字数据被当作目的地址，从而可以实现程序流程的跳转。
指令示例：
LDRB R0，[R1] ；将存储器地址为R1的字节数据读入寄存器 R0，并将R0的高24

；位清零。
LDRB R0，[R1，＃8] ；将存储器地址为R1＋8的字节数据读入寄存器R0，并将 R0的

；高24位清零。

3、LDRH指令

LDRH指令的格式为：
LDR{条件}H 目的寄存器，<存储器地址>
LDRH指令用于从存储器中将一个16位的半字数据传送到目的寄存器中，同时将寄存器的高16位清零。该指令通常用于从存储器中读取16位的半字数据到通用寄存器，然后对数据进行处理。当程序计数器PC作为目的寄存器时，指令从存储器中读取的字数据被当作目的地址，从而可以实现程序流程的跳转。
指令示例：
LDRH R0，[R1] ；将存储器地址为R1的半字数据读入寄存器 R0，并将R0的高

；16位清零。
LDRH R0，[R1，＃8] ；将存储器地址为R1＋8的半字数据读入寄存器R0，并将R0 的

；高16位清零。
LDRH R0，[R1，R2] ；将存储器地址为R1＋R2的半字数据读入寄存器R0，并将 R0的

；高16位清零。

4、STR指令

STR指令的格式为：
STR{条件} 源寄存器，<存储器地址>
STR指令用于从源寄存器中将一个32位的字数据传送到存储器中。该指令在程序设计中比较常用，且寻址方式灵活多样，使用方式可参考指令LDR。
指令示例：
STR R0，[R1]，＃8 ；将R0中的字数据写入以R1为地址的存储器中，并将新地址

；R1＋8写入R1。
STR R0，[R1，＃8] ；将R0中的字数据写入以R1＋8为地址的存储器中。

5、STRB指令

STRB指令的格式为：
     STR{条件}B 源寄存器，<存储器地址>
STRB指令用于从源寄存器中将一个8位的字节数据传送到存储器中。该字节数据为源寄存器中的低8位。
指令示例：
STRB    R0，[R1]            ；将寄存器R0中的字节数据写入以R1为地址的存储器中。
STRB    R0，[R1，＃8]    ；将寄存器R0中的字节数据写入以R1＋8为地址的存储器中。

6、STRH指令

STRH指令的格式为：
      STR{条件}H 源寄存器，<存储器地址>
STRH指令用于从源寄存器中将一个16位的半字数据传送到存储器中。该半字数据为源寄存器中的低16位。
指令示例：
STRH   R0，[R1]           ；将寄存器R0中的半字数据写入以R1为地址的存储器中。
STRH   R0，[R1，＃8]   ；将寄存器R0中的半字数据写入以R1＋8 为地址的存储器中。

六、批量数据加载/存储指令。

ARM微处理器所支持批量数据加载/存储指令可以一次在一片连续的存储器单元和多个寄存器之间传送数据，批量加载指令用于将一片连续的存储器中的数据传送到多个寄存器，批量数据存储指令则完成相反的操作。常用的加载存储指令如下：LDM（或STM）指令
LDM（或STM）指令的格式为：

LDM（或STM）{条件}{类型} 基址寄存器{！}，寄存器列表{∧}
LDM（或STM）指令用于从由基址寄存器所指示的一片连续存储器到寄存器列表所指示的多个寄存器之间传送数据，该指令的常见用途是将多个寄存器的内容入栈或出栈。其中，{类型}为以下几种情况：
IA    每次传送后地址加1；
IB      每次传送前地址加1；
DA   每次传送后地址减1；
DB   每次传送前地址减1；
FD   满递减堆栈；
ED   空递减堆栈；
FA   满递增堆栈；
EA   空递增堆栈；
{！}为可选后缀，若选用该后缀，则当数据传送完毕之后，将最后的地址写入基址寄存器，否则基址寄存器的内容不改变。
基址寄存器不允许为R15，寄存器列表可以为R0～R15的任意组合。
{∧}为可选后缀，当指令为LDM且寄存器列表中包含R15，选用该后缀时表示：除了正常的数据传送之外，还将SPSR复制到CPSR。同时，该后缀还表示传入或传出的是用户模式下的寄存器，而不是当前模式下的寄存器。
指令示例：
STMFD R13!，{R0，R4-R12，LR}       ；将寄存器列表中的寄存器（R0，R4到R12，LR）存入堆栈。
LDMFD R13!， {R0，R4-R12，PC}      ；将堆栈内容恢复到寄存器（R0，R4到R12，LR）。

七、数据交换指令

1、SWP指令

SWP指令的格式为：
SWP{条件} 目的寄存器，源寄存器1，[源寄存器2]
SWP指令用于将源寄存器2所指向的存储器中的字数据传送到目的寄存器中，同时将源寄存器1中的字数据传送到源寄存器2所指向的存储器中。显然，当源寄存器1和目的寄存器为同一个寄存器时，指令交换该寄存器和存储器的内容。
指令示例：
SWP R0，R1，[R2] ；将R2所指向的存储器中的字数据传送到R0，同时将R1 中的字数据传送到R2所指向的存储单元。
SWP R0，R0，[R1] ；该指令完成将R1所指向的存储器中的字数据与R0中的数据交换。

2、SWPB指令

SWPB指令的格式为：
SWP{条件}B 目的寄存器，源寄存器1，[源寄存器2]
SWPB指令用于将源寄存器2所指向的存储器中的字节数据传送到目的寄存器中，目的寄存器的高24清零，同时将源寄存器1中的字节数据传送到源寄存器2所指向的存储器中。显然，当源寄存器1和目的寄存器为同一个寄存器时，指令交换该寄存器和存储器的内容。
指令示例：
SWPB R0，R1，[R2] ；将R2所指向的存储器中的字节数据传送到 R0，R0的高24位清零，同时将R1中的低8位数据传送到R2所指向的存储单元。
SWPB R0，R0，[R1] ；该指令完成将R1所指向的存储器中的字节数据与R0中的低8位数据交换。

八、移位指令

1、LSL（或ASL）

LSL（或ASL）的格式为：
通用寄存器，LSL（或ASL）操作数
LSL（或ASL）可完成对通用寄存器中的内容进行逻辑（或算术）的左移操作，按操作数所指定的数量向左移位，低位用零来填充。其中，操作数可以是通用寄存器，也可以是立即数（0～31）。
操作示例
MOV R0, R1, LSL#2 ；将R1中的内容左移两位后传送到R0 中。

2、LSR

LSR的格式为：
通用寄存器，LSR 操作数
LSR可完成对通用寄存器中的内容进行右移的操作，按操作数所指定的数量向右移位，左端用零来填充。其中，操作数可以是通用寄存器，也可以是立即数（0～31）。
操作示例：
MOV R0, R1, LSR #2 ；将R1中的内容右移两位后传送到R0 中，左端用零来填充。

3、ASR

ASR的格式为：
通用寄存器，ASR 操作数
ASR可完成对通用寄存器中的内容进行右移的操作，按操作数所指定的数量向右移位，左端用第31位的值来填充。其中，操作数可以是通用寄存器，也可以是立即数（0～31）。
操作示例：
MOV R0, R1, ASR #2 ；将R1中的内容右移两位后传送到R0 中，左端用第31位的值来填充。

4、ROR

ROR的格式为：
通用寄存器，ROR 操作数
ROR可完成对通用寄存器中的内容进行循环右移的操作，按操作数所指定的数量向右循环移位，左端用右端移出的位来填充。其中，操作数可以是通用寄存器，也可以是立即数（0～31）。显然，当进行32位的循环右移操作时，通用寄存器中的值不改变。
操作示例：
MOV R0, R1, ROR #2 ；将R1中的内容循环右移两位后传送到R0 中。

5、RRX

RRX的格式为：
通用寄存器，RRX 操作数
RRX可完成对通用寄存器中的内容进行带扩展的循环右移的操作，按操作数所指定的数量向右循环移位，左端用进位标志位C来填充。其中，操作数可以是通用寄存器，也可以是立即数（0～31）。
操作示例：
MOV R0, R1, RRX #2 ；将R1中的内容进行带扩展的循环右移两位后传送到R0中。

九、协处理器指令

1、CDP指令

CDP指令的格式为：
CDP{条件} 协处理器编码，协处理器操作码1，目的寄存器，源寄存器1，源寄存器2，协处理器操作码2。
CDP指令用于ARM处理器通知ARM协处理器执行特定的操作，若协处理器不能成功完成特定的操作，则产生未定义指令异常。其中协处理器操作码1和协处理器操作码2为协处理器将要执行的操作，目的寄存器和源寄存器均为协处理器的寄存器，指令不涉及ARM处理器的寄存器和存储器。
指令示例：
CDP P3，2，C12，C10，C3，4 ；该指令完成协处理器P3的初始化

2、LDC指令

LDC指令的格式为：
LDC{条件}{L} 协处理器编码，目的寄存器，[源寄存器]
LDC指令用于将源寄存器所指向的存储器中的字数据传送到目的寄存器中，若协处理器不能成功完成传送操作，则产生未定义指令异常。其中，{L}选项表示指令为长读取操作，如用于双精度数据的传输。
指令示例：
LDC P3，C4，[R0] ；将ARM处理器的寄存器R0所指向的存储器中的字数据传送到协处理器P3的寄存器C4中。

3、STC指令

STC指令的格式为：
STC{条件}{L} 协处理器编码，源寄存器，[目的寄存器]
STC指令用于将源寄存器中的字数据传送到目的寄存器所指向的存储器中，若协处理器不能成功完成传送操作，则产生未定义指令异常。其中，{L}选项表示指令为长读取操作，如用于双精度数据的传输。
指令示例：
STC P3，C4，[R0] ；将协处理器P3的寄存器C4中的字数据传送到ARM处理器的寄存器R0所指向的存储器中。

4、MCR指令

MCR指令的格式为：
MCR{条件} 协处理器编码，协处理器操作码1，源寄存器，目的寄存器1，目的寄存器2，协处理器操作码2。
MCR指令用于将ARM处理器寄存器中的数据传送到协处理器寄存器中,若协处理器不能成功完成操作，则产生未定义指令异常。其中协处理器操作码1和协处理器操作码2为协处理器将要执行的操作，源寄存器为ARM处理器的寄存器，目的寄存器1和目的寄存器2均为协处理器的寄存器。
指令示例：
MCR P3，3，R0，C4，C5，6 ；将ARM处理器寄存器R0中的数据传送到协处理器P3的寄存器C4和C5中。

5、MRC指令

MRC指令的格式为：
MRC{条件} 协处理器编码，协处理器操作码1，目的寄存器，源寄存器1，源寄存器2，协处理器操作码2。
MRC指令用于将协处理器寄存器中的数据传送到ARM处理器寄存器中,若协处理器不能成功完成操作，则产生未定义指令异常。其中协处理器操作码1和协处理器操作码2为协处理器将要执行的操作，目的寄存器为ARM处理器的寄存器，源寄存器1和源寄存器2均为协处理器的寄存器。
指令示例：
MRC P3，3，R0，C4，C5，6 ；该指令将协处理器P3的寄存器中的数据传送到 ARM处理器寄存器中。

十、异常产生指令

1、SWI指令

SWI指令的格式为：
SWI{条件} 24位的立即数
SWI指令用于产生软件中断，以便用户程序能调用操作系统的系统例程。操作系统在SWI的异常处理程序中提供相应的系统服务，指令中24位的立即数指定用户程序调用系统例程的类型，相关参数通过通用寄存器传递，当指令中24位的立即数被忽略时，用户程序调用系统例程的类型由通用寄存器R0的内容决定，同时，参数通过其他通用寄存器传递。
指令示例：
SWI 0x02 ；该指令调用操作系统编号位02的系统例程。

2、BKPT指令

BKPT指令的格式为：
BKPT 16位的立即数
BKPT指令产生软件断点中断，可用于程序的调试。

ARM汇编伪指令

在ARM汇编语言程序里，有一些特殊指令助记符，这些助记符与指令系统的助记符不同，没有相对应的操作码，通常称这些特殊指令助记符为伪指令，他们所完成的操作称为伪操作。伪指令在源程序中的作用是为完成汇编程序作各种准备工作的，这些伪指令仅在汇编过程中起作用，一旦汇编结束，伪指令的使命就完成。
在ARM 的汇编程序中，有如下几种伪指令：符号定义伪指令、数据定义伪指令、汇编控制伪指令、宏指令以及其他伪指令。

一、符号定义（SymbolDefinition）伪指令

符号定义伪指令用于定义ARM汇编程序中的变量、对变量赋值以及定义寄存器的别名等操作。
常见的符号定义伪指令有如下几种：
    — 用于定义全局变量的GBLA 、GBLL 和GBLS 。
    — 用于定义局部变量的LCLA 、LCLL 和LCLS 。
    — 用于对变量赋值的SETA 、SETL 、SETS 。
    — 为通用寄存器列表定义名称的RLIST 。

1、GBLA、GBLL 和GBLS

    语法格式：
    GBLA （GBLL 或GBLS ）全局变量名
    GBLA 、GBLL 和GBLS 伪指令用于定义一个ARM 程序中的全局变量，并将其初始化。其中：
    GBLA 伪指令用于定义一个全局的数字变量，并初始化为0 ；
    GBLL 伪指令用于定义一个全局的逻辑变量，并初始化为F（假）；
    GBLS 伪指令用于定义一个全局的字符串变量，并初始化为空；
    由于以上三条伪指令用于定义全局变量，因此在整个程序范围内变量名必须唯一。
    使用示例：
    GBLA Test1 ；           定义一个全局的数字变量，变量名为 Test1。
    Test1 SETA 0xaa ；   将该变量赋值为0xaa。
    GBLL Test2 ；            定义一个全局的逻辑变量，变量名为 Test2。
    Test2 SETL {TRUE} ；将该变量赋值为真。
    GBLS Test3 ；            定义一个全局的字符串变量，变量名为 Test3。
    Test3 SETS “Testing” ；将该变量赋值为"Testing”。

2、LCLA、LCLL 和LCLS

    语法格式：
    LCLA （LCLL 或 LCLS ）局部变量名
    LCLA 、LCLL 和LCLS 伪指令用于定义一个ARM 程序中的局部变量，并将其初始化。其中：
    LCLA伪指令用于定义一个局部的数字变量，并初始化为0 ；
    LCLL伪指令用于定义一个局部的逻辑变量，并初始化为F（假）；
    LCLS伪指令用于定义一个局部的字符串变量，并初始化为空；
    以上三条伪指令用于声明局部变量，在其作用范围内变量名必须唯一。
    使用示例：
    LCLA Test4 ；            声明一个局部的数字变量，变量名为Test4。
    Test3 SETA 0xaa ；   将该变量赋值为0xaa。

   LCLL Test5 ；            声明一个局部的逻辑变量，变量名为Test5。
    Test4 SETL {TRUE} ；将该变量赋值为真。
    LCLS Test6 ；            定义一个局部的字符串变量，变量名为Test6。
    Test6 SETS “Testing” ；将该变量赋值为 "Testing”。

3、SETA、SETL 和SETS

    语法格式：
    变量名 SETA （SETL 或 SETS ）表达式
    伪指令 SETA 、SETL 、SETS 用于给一个已经定义的全局变量或局部变量赋值。
    SETA伪指令用于给一个数学变量赋值；
    SETL伪指令用于给一个逻辑变量赋值；
    SETS伪指令用于给一个字符串变量赋值；
    其中，变量名为已经定义过的全局变量或局部变量，表达式为将要赋给变量的值。
    使用示例：
    LCLA Test3 ；            声明一个局部的数字变量，变量名为 Test3。
    Test3 SETA 0xaa ；    将该变量赋值为0xaa。
    LCLL Test4 ；            声明一个局部的逻辑变量，变量名为 Test4。
    Test4 SETL {TRUE} ；将该变量赋值为真。

4 、RLIST

    语法格式：
    名称 RLIST { 寄存器列表 }
    RLIST伪指令可用于对一个通用寄存器列表定义名称，使用该伪指令定义的名称可在ARM 指令 LDM/STM中使用。在LDM/STM指令中，列表中的寄存器访问次序为根据寄存器的编号由低到高，而与列表中的寄存器排列次序无关。
    使用示例：
    RegList RLIST {R0-R5 ，R8 ，R10} ；将寄存器列表名称定义为 RegList ，可在ARM指令LDM/STM中通过该名称访问寄存器列表。

二、数据定义（DataDefinition）伪指令

数据定义伪指令一般用于为特定的数据分配存储单元，同时可完成已分配存储单元的初始化。
常见的数据定义伪指令有如下几种：
    — DCB 用于分配一片连续的字节存储单元并用指定的数据初始化。
    — DCW（DCWU）用于分配一片连续的半字存储单元并用指定的数据初始化。
    — DCD （DCDU）用于分配一片连续的字存储单元并用指定的数据初始化。
    — DCFD（DCFDU）用于为双精度的浮点数分配一片连续的字存储单元并用指定的数据初始化。
    — DCFS（DCFSU）用于为单精度的浮点数分配一片连续的字存储单元并用指定的数据初始化。
    — DCQ（DCQU）用于分配一片以8字节为单位的连续的存储单元并用指定的数据初始化。
    — SPACE 用于分配一片连续的存储单元。
    — MAP 用于定义一个结构化的内存表首地址。
    — FIELD 用于定义一个结构化的内存表的数据域。

1、DCB

    语法格式：
    标号 DCB 表达式
    DCB伪指令用于分配一片连续的字节存储单元并用伪指令中指定的表达式初始化。其中，表达式可以为0～255的数字或字符串。DCB 也可用“=”代替。
    使用示例：
    Str DCB “This is a test” ；分配一片连续的字节存储单元并初始化。

2、DCW（或DCWU）

    语法格式：
    标号 DCW (或DCWU) 表达式
    DCW(或DCWU)伪指令用于分配一片连续的半字存储单元并用伪指令中指定的表达式初始化。
    其中，表达式可以为程序标号或数字表达式。
    用DCW分配的字存储单元是半字对齐的，而用DCWU分配的字存储单元并不严格半字对齐。
    使用示例：
    DataTest DCW 1 ，2 ，3 ；分配一片连续的半字存储单元并初始化。

3、DCD（或DCDU）

    语法格式：
    标号 DCD（或DCDU）表达式
    DCD（或DCDU）伪指令用于分配一片连续的字存储单元并用伪指令中指定的表达式初始化。其中，表达式可以为程序标号或数字表达式。DCD也可用"&” 代替。
    用DCD分配的字存储单元是字对齐的，而用DCDU分配的字存储单元并不严格字对齐。
    使用示例：
    DataTest DCD 4 ，5 ，6 ；分配一片连续的字存储单元并初始化。

4、DCFD（或DCFDU）

    语法格式：
    标号 DCFD（或DCFDU）表达式
    DCFD（或DCFDU）伪指令用于为双精度的浮点数分配一片连续的字存储单元并用伪指令中指定的表达式初始化。每个双精度的浮点数占据两个字单元。用 DCFD分配的字存储单元是字对齐的，而用DCFDU分配的字存储单元并不严格字对齐。
    使用示例：       FDataTest DCFD 2E115 ，-5E7 ；分配一片连续的字存储单元并初始化为指定的双精度数。

5、DCFS（或DCFSU）

    语法格式：
    标号 DCFS（或DCFSU）表达式
    DCFS（或DCFSU）伪指令用于为单精度的浮点数分配一片连续的字存储单元并用伪指令中指定的表达式初始化。每个单精度的浮点数占据一个字单元。用 DCFS分配的字存储单元是字对齐的，而用DCFSU分配的字存储单元并不严格字对齐。
    使用示例：
    FDataTest DCFS 2E5 ，-5E －7 ；分配一片连续的字存储单元并初始化为指定的单精度数。

6、DCQ(或DCQU）

    语法格式：
    标号 DCQ（或DCQU）表达式
    DCQ（或DCQU）伪指令用于分配一片以8个字节(双字)为单位的连续存储区域并用伪指令中指定的表达式初始化。用DCQ分配的存储单元是字对齐的，而用DCQU 分配的存储单元并不严格字对齐。
    使用示例：
    DataTest DCQ 100 ；分配一片连续的存储单元并初始化为指定的值。

7、SPACE

    语法格式：
    标号 SPACE 表达式
    SPACE伪指令用于分配一片连续的存储区域并初始化为0 。其中，表达式为要分配的字节数。
    SPACE也可用“ ％ ”代替。
    使用示例：
    DataSpace SPACE 100 ；分配连续100字节的存储单元并初始化为0 。

8、MAP

    语法格式：
    MAP 表达式 { ，基址寄存器}
    MAP伪指令用于定义一个结构化的内存表的首地址。MAP也可用“＾” 代替。
    表达式可以为程序中的标号或数学表达式，基址寄存器为可选项，当基址寄存器选项不存在时，表达式的值即为内存表的首地址，当该选项存在时，内存表的首地址为表达式的值与基址寄存器的和。
    MAP伪指令通常与FIELD伪指令配合使用来定义结构化的内存表。
    使用示例：
    MAP 0x100 ，R0 ；定义结构化内存表首地址的值为0x100＋R0 。

9、FILED

    语法格式：
    标号 FIELD 表达式
    FIELD伪指令用于定义一个结构化内存表中的数据域。FILED 也可用“#” 代替。
    表达式的值为当前数据域在内存表中所占的字节数。
    FIELD伪指令常与MAP伪指令配合使用来定义结构化的内存表。MAP伪指令定义内存表的首地址，FIELD伪指令定义内存表中的各个数据域，并可以为每个数据域指定一个标号供其他的指令引用。
    注意MAP和FIELD伪指令仅用于定义数据结构，并不实际分配存储单元。
    使用示例：
    MAP 0x100 ；定义结构化内存表首地址的值为0x100。
    A FIELD 16 ；定义A的长度为16字节，位置为0x100。
    B FIELD 32 ；定义B的长度为32字节，位置为0x110。
    S FIELD 256 ；定义S的长度为256字节，位置为0x130。

三、汇编控制（AssemblyControl）伪指令

汇编控制伪指令用于控制汇编程序的执行流程，常用的汇编控制伪指令包括以下几条：
    — IF 、ELSE 、ENDIF
    — WHILE 、WEND
    — MACRO 、MEND
    — MEXIT

1、IF、ELSE、ENDIF

    语法格式：
    IF 逻辑表达式
    指令序列 1
    ELSE
    指令序列 2
    ENDIF
    IF 、ELSE 、ENDIF伪指令能根据条件的成立与否决定是否执行某个指令序列。当IF后面的逻辑表达式为真，则执行指令序列1 ，否则执行指令序列2 。其中，ELSE及指令序列2可以没有，此时，当IF后面的逻辑表达式为真，则执行指令序列1 ，否则继续执行后面的指令。
    IF 、ELSE 、ENDIF伪指令可以嵌套使用。
    使用示例：
    GBLL Test ；声明一个全局的逻辑变量，变量名为Test
    IF Test = TRUE
    指令序列 1
    ELSE
    指令序列 2
    ENDIF

2、WHILE、WEND

    语法格式：
    WHILE 逻辑表达式
    指令序列
    WEND
    WHILE 、WEND伪指令能根据条件的成立与否决定是否循环执行某个指令序列。当WHILE后面的逻辑表达式为真，则执行指令序列，该指令序列执行完毕后，再判断逻辑表达式的值，若为真则继续执行，一直到逻辑表达式的值为假。
    WHILE 、WEND伪指令可以嵌套使用。
    使用示例：
    GBLA Counter ；   声明一个全局的数学变量，变量名为Counter
    Counter SETA 3 ；由变量Counter 控制循环次数
    ……
    WHILE Counter < 10
    指令序列
    WEND

3、MACRO、MEND

    语法格式：
    $ 标号宏名 $ 参数 1 ，$ 参数 2 ，……
    指令序列
    MEND
    MACRO 、MEND伪指令可以将一段代码定义为一个整体，称为宏指令，然后就可以在程序中通过宏指令多次调用该段代码。其中，$标号在宏指令被展开时，标号会被替换为用户定义的符号，宏指令可以使用一个或多个参数，当宏指令被展开时，这些参数被相应的值替换。
    宏指令的使用方式和功能与子程序有些相似，子程序可以提供模块化的程序设计、节省存储空间并提高运行速度。但在使用子程序结构时需要保护现场，从而增加了系统的开销，因此，在代码较短且需要传递的参数较多时，可以使用宏指令代替子程序。
    包含在MACRO和MEND之间的指令序列称为宏定义体，在宏定义体的第一行应声明宏的原型（包含宏名、所需的参数），然后就可以在汇编程序中通过宏名来调用该指令序列。在源程序被编译时，汇编器将宏调用展开，用宏定义中的指令序列代替程序中的宏调用，并将实际参数的值传递给宏定义中的形式参数。
    MACRO、MEND伪指令可以嵌套使用。

4、MEXIT

    语法格式：
    MEXIT
    MEXIT用于从宏定义中跳转出去。

四、其他常用的伪指令

还有一些其他的伪指令，在汇编程序中经常会被使用，包括以下几条：
    — AREA
    — ALIGN
    — CODE16 、CODE32
    — ENTRY
    — END
    — EQU
    — EXPORT（或GLOBAL ）
    — IMPORT
    — EXTERN
    — GET（或INCLUDE ）
    — INCBIN
    — RN
    — ROUT

1、AREA

    语法格式：
    AREA 段名属性1 ，属性2 ，……
    AREA伪指令用于定义一个代码段或数据段。其中，段名若以数字开头，则该段名需用“|”括起来，如：|1_test|。
    属性字段表示该代码段（或数据段）的相关属性，多个属性用逗号分隔。常用的属性如下：
    — CODE 属性：用于定义代码段，默认为READONLY 。
    — DATA 属性：用于定义数据段，默认为READWRITE 。
    — READONLY 属性：指定本段为只读，代码段默认为READONLY 。
    — READWRITE 属性：指定本段为可读可写，数据段的默认属性为READWRITE 。
    — ALIGN 属性：使用方式为ALIGN表达式。在默认时，ELF（可执行连接文件）的代码段和数据段是按字对齐的，表达式的取值范围为0～31，相应的对齐方式为2 表达式次方。
    — COMMON 属性：该属性定义一个通用的段，不包含任何的用户代码和数据。各源文件中同名的COMMON段共享同一段存储单元。
    一个汇编语言程序至少要包含一个段，当程序太长时，也可以将程序分为多个代码段和数据段。
    使用示例：

AREA Init ，CODE ，READONLY; 该伪指令定义了一个代码段，段名为Init ，属性为只读。

2、ALIGN

    语法格式：
    ALIGN { 表达式 { ，偏移量}}
    ALIGN伪指令可通过添加填充字节的方式，使当前位置满足一定的对齐方式。其中，表达式的值用于指定对齐方式，可能的取值为2的幂，如1 、2 、4 、8 、16 等。若未指定表达式，则将当前位置对齐到下一个字的位置。偏移量也为一个数字表达式，若使用该字段，则当前位置的对齐方式为：2的表达式次幂＋偏移量。
    使用示例：
    AREA Init ，CODE ，READONLY ，ALIEN＝3 ；指定后面的指令为8 字节对齐。
    指令序列
    END

3、CODE16、CODE32

    语法格式：
    CODE16（或CODE32）
    CODE16伪指令通知编译器，其后的指令序列为16位的Thumb指令。
    CODE32伪指令通知编译器，其后的指令序列为32位的ARM指令。
    若在汇编源程序中同时包含ARM指令和Thumb指令时，可用CODE16伪指令通知编译器其后的指令序列为16位的Thumb指令，CODE32伪指令通知编译器其后的指令序列为32位的ARM指令。因此，在使用ARM指令和Thumb指令混合编程的代码里，可用这两条伪指令进行切换，但注意他们只通知编译器其后指令的类型，并不能对处理器进行状态的切换。
    使用示例：
    AREA Init ，CODE ，READONLY      ……
    CODE32 ；                   通知编译器其后的指令为32位的 ARM指令
    LDR R0 ，＝NEXT＋1 ；将跳转地址放入寄存器R0
    BX R0 ；                        程序跳转到新的位置执行，并将处理器切换到Thumb工作状态
    ……
    CODE16 ；                    通知编译器其后的指令为16位的 Thumb指令
    NEXT LDR R3，＝0x3FF
    ……
    END ；

4、ENTRY

    语法格式：
    ENTRY
    ENTRY伪指令用于指定汇编程序的入口点。在一个完整的汇编程序中至少要有一个ENTRY（也可以有多个，当有多个ENTRY时，程序的真正入口点由链接器指定），但在一个源文件里最多只能有一个ENTRY（可以没有）。
    使用示例：
    AREA Init ，CODE ，READONLY
    ENTRY ；指定应用程序的入口点
    ……

5、END

    语法格式：
    END
    END伪指令用于通知编译器已经到了源程序的结尾。
    使用示例：
    AREA Init ，CODE ，READONLY
    ……
    END ；指定应用程序的结尾

6、EQU

    语法格式：
    名称 EQU 表达式 { ，类型 }
    EQU伪指令用于为程序中的常量、标号等定义一个等效的字符名称，类似于C语言中的＃define 。其中EQU可用“*”代替。名称为EQU伪指令定义的字符名称，当表达式为32位的常量时，可以指定表达式的数据类型，可以有以下三种类型：
    CODE16 、CODE32 和DATA
    使用示例：
    Test EQU 50 ；                      定义标号Test 的值为50。
    Addr EQU 0x55 ，CODE32 ；定义Addr的值为0x55 ，且该处为32位的ARM指令。

7、EXPORT（或GLOBAL）

    语法格式：
    EXPORT 标号 {[WEAK]}
    EXPORT伪指令用于在程序中声明一个全局的标号，该标号可在其他的文件中引用。EXPORT 可用GLOBAL代替。标号在程序中区分大小写，[WEAK] 选项声明其他的同名标号优先于该标号被引用。
    使用示例：
    AREA Init ，CODE ，READONLY
    EXPORT Stest ；声明一个可全局引用的标号Stest
    END

8、IMPORT

    语法格式：
    IMPORT 标号 {[WEAK]}
    IMPORT伪指令用于通知编译器要使用的标号在其他的源文件中定义，但要在当前源文件中引用，而且无论当前源文件是否引用该标号，该标号均会被加入到当前源文件的符号表中。标号在程序中区分大小写，[WEAK] 选项表示当所有的源文件都没有定义这样一个标号时，编译器也不给出错误信息，在多数情况下将该标号置为0 ，若该标号为B或BL指令引用，则将B或BL指令置为NOP操作。
    使用示例：
    AREA Init ，CODE ，READONLY
    IMPORT Main ；通知编译器当前文件要引用标号Main，但Main在其他源文件中定义。
    END

9、EXTERN

    语法格式：
    EXTERN 标号 {[WEAK]}
    EXTERN伪指令用于通知编译器要使用的标号在其他的源文件中定义，但要在当前源文件中引用，如果当前源文件实际并未引用该标号，该标号就不会被加入到当前源文件的符号表中。标号在程序中区分大小写，[WEAK] 选项表示当所有的源文件都没有定义这样一个标号时，编译器也不给出错误信息，在多数情况下将该标号置为0 ，若该标号为B或BL指令引用，则将B或BL指令置为NOP操作。
    使用示例：
    AREA Init ，CODE ，READONLY
    EXTERN Main ；通知编译器当前文件要引用标号Main，但Main在其他源文件中定义。
    END

10、GET（或INCLUDE）

    语法格式：
    GET 文件名
    GET伪指令用于将一个源文件包含到当前的源文件中，并将被包含的源文件在当前位置进行汇编处理。可以使用INCLUDE代替GET。
    汇编程序中常用的方法是在某源文件中定义一些宏指令，用EQU定义常量的符号名称，用MAP和FIELD定义结构化的数据类型，然后用GET伪指令将这个源文件包含到其他的源文件中。使用方法与C 语言中的"include”相似。
    GET伪指令只能用于包含源文件，包含目标文件需要使用INCBIN伪指令
    使用示例：
    AREA Init ，CODE ，READONLY
    GET a1.s ；        通知编译器当前源文件包含源文件a1.s
    GET C：\a2.s ；通知编译器当前源文件包含源文件C：\a2.s
    END

11、INCBIN

    语法格式：
    INCBIN 文件名
    INCBIN伪指令用于将一个目标文件或数据文件包含到当前的源文件中，被包含的文件不作任何变动的存放在当前文件中，编译器从其后开始继续处理。
    使用示例：
    AREA Init ，CODE ，READONLY
    INCBIN a1.dat ；     通知编译器当前源文件包含文件a1.dat
    INCBIN C：\a2.txt ；通知编译器当前源文件包含文件C：\a2.txt
    END

12、RN

    语法格式：
    名称 RN 表达式
    RN伪指令用于给一个寄存器定义一个别名。采用这种方式可以方便程序员记忆该寄存器的功能。其中，名称为给寄存器定义的别名，表达式为寄存器的编码。
    使用示例：
    Temp RN R0 ；将R0定义一个别名Temp

13、ROUT

    语法格式：
    {名称} ROUT
    ROUT伪指令用于给一个局部变量定义作用范围。在程序中未使用该伪指令时，局部变量的作用范围为所在的AREA，而使用ROUT后，局部变量的作为范围为当前ROUT和下一个ROUT之间。

3. BNE 与 BEQ

TST R0, #0X8
BNE SuspendUp ；BNE指令是“不相等（或不为0）跳转指令”：

LDR R1,#0x00000000

先进行and运算，如果R0的第四位不为1，则结果为零，则设置zero=1（继续下面的LDR指令）；

否则，如果R0的第四位为1，zero=0（跳到SuspendUp处执行）。

tst 和bne连用: 先是用tst进行位与运算，然后将位与的结果与0比较，如果不为0，则跳到bne紧跟着的标记（如bne sleep，则跳到sleep处）。

tst 和beq连用: 先是用tst进行位与运算，然后将位与的结果与0比较，如果为0，则跳到beq紧跟着的标记（如bne AAAA，则跳到AAAA处）。

from:http://blog.chinaunix.net/uid-25067956-id-398205.html

{

最近突然觉得这个arm-linux-ld这个指令特别重要，弄懂了这个，很多问题就明白了，特别是看uboot那些，所以找点资料来看看：

这是我conceptcon 的学习体会啊

}

一.首先熟悉几个arm地址相关的概念：

首先arm地址有三个地址概念：编译地址、期望运行物理地址、实际运行物理地址、相对地址、绝对地址、位置无关

编译地址：编译阶段的生成地址，其是相对地址，有些地址还没确定，如调用其他.O文件中的函数或库函数
期望运行物理地址：链接阶段生成的地址（期望绝对地址），会确定编译阶段没有确定的地址，并会根据链接器假设期望的程序烧录运行物理启始地址，来分配期望运行物理地址
实际运行物理地址：当程序被烧写到系统（实际绝对地址），实际加载运行时，又有一个实际的程序烧录运行物理启始地址，这个时候进行相应的转换得到实际运行物理地址
位置无关 :和实际烧写运行的地址无关

二.根据以上的地址概念，来分析ldr和adr/adrl 伪指令的区别

1. ldr
ldr r1, =_start
实际上会被编译器改成两条语句：
0x00 ldr r1,[pc, #0x0c]
//编译器知道DCD的地址，相对于ldr的地址偏移量，所以用ldr指令从此地址中取出0x64
....
0x0c DCD 0x64

_start:
0x64 MOVE r0,r0

2. adr
adr r1, _start
实际上会被编译器改成一条语句：
0x00 add r1, pc, #0x64

_start:
0x64 MOVE r0,r0

3. adrl //转化成两个ADD，寻址空间是8KB

4.综述

所以综上所述，ldr和adr的区别主要就是地址的位置无关性的差别。ldr伪指令操作，一旦实际运行物理地址和期望运行物理地址存在差别，那就会造成程序运行错误。虽然adr有这么多优点，但是adr的寻址空间只有前后4kb，而且必须在同一个代码段中，ldr就没有这些要求。

4.6.3 #pragma arm section [section_sort_list]

此编译指示指定要用于后续函数或对象的节名称。这包括编译器为进行初始化而创建的匿名对象的定义。注意可以将 __attribute__((section(..))) 用于函数或变量以替代 #pragma arm section。

【语法】
#pragma arm section [ section_sort_list]
其中：
section_sort_list 指定要用于后续函数或对象的节名称的可选列表。
section_sort_list 的语法为：section_type[[=]"name"] [,section_type="name"]*

有效的节类型是：• code 、• rodata、• rwdata、• zidata 。

【用法】

可以将分散加载描述文件与 ARM 链接器配合使用，以控制将已命名的节放在特定内存地址的方式。

【限制】

此选项对以下内容无效：
• 内联函数及其局部静态变量。
• 模板实例化及其局部静态变量。
• 删除未使用的变量和函数。但是，可通过使用 #pragma arm section，使链接
器能够删除本来可能会保留的函数或变量，因为它与使用的函数或变量位
于相同的节中。
• 将定义写入对象文件的顺序。

【示例】

int x1 = 5;                     // in .data (default)
int y1[100];                    // in .bss (default)
int const z1[3] = {1,2,3};      // in .constdata (default)
#pragma arm section rwdata = "foo", rodata = "bar"
int x2 = 5;                     // in foo (data part of region)
int y2[100];                    // in .bss
int const z2[3] = {1,2,3};      // in bar
char *s2 = "abc";               // s2 in foo, "abc" in .conststring
#pragma arm section rodata
int x3 = 5;                     // in foo
int y3[100];                    // in .bss
int const z3[3] = {1,2,3};      // in .constdata
char *s3 = "abc";               // s3 in foo, "abc" in .conststring
#pragma arm section code = "foo"
int add1(int x)                   // in foo (code part of region)
{
return x+1;
}
#pragma arm section code

其实就是增加额外的name段，将这个段放在code、rodata、rwdata或zidata的起始位置，至于具体是哪个段，就是由section_type[[=]"name"]中的section_type指定了。

我们对每个c或者汇编文件进行单独编译，但是不去连接，生成很多.o 的文件，这些.o文件首先是分散的，我们首先要考虑的如何组合起来；其次，这些.o文件存在相互调用的关系；再者，我们最后生成的bin文件是要在硬件中运行的，每一部分放在什么地址都要有仔细的说明。我觉得在写makefile的时候，最为重要的就是ld的理解，下面说说我的经验：

首先，要确定我们的程序用没有用到标准的c库，或者一些系统的库文件，这些一般是在操作系统之上开发要注意的问题，这里并不多说，熟悉在Linux编程的人，基本上都会用ld命令；这里，我们从头开始,直接进行汇编语言的连接。

我们写一个汇编程序，控制GPIO，从而控制外接的LED，代码如下;

   .text

.global _start

_start:

    LDR R0,=0x56000010 @GPBCON寄存器

    MOV R1,# 0x00000400
    str R1,[R0]

    LDR R0,=0x56000014
    MOV R1,#0x00000000

    STR R1,[R0]

    MAIN_LOOP:
            B MAIN_LOOP

代码很简单，就是一个对io口进行设置然后写数据。我们看它是如何编译的，注意我们这里使用的不是arm-linux-gcc而是arm-elf-gcc，二者之间没有什么比较大的区别，arm-linux-gcc可能包含更多的库文件，在命令行的编译上面是没有区别。我们来看是如何编译的：

arm-elf-gcc -g -c -o led_On.o led_On.s 首先纯编译不连接

arm-elf-ld -Ttext 0x00000000 -g led_On.o -o led_on_elf

用Ttext指明我们程序存储的地方，这里生成的是elf文件，还不是我们真正的bin，但是可以借助一些工具可以进行调试。然后：

arm-elf-objcopy -O binary -S led_on_elf led_on.bin

生成bin文件。

-T选项是ld命令中比较重要的一个选项，可以用它直接指明代码的代码段、数据段、博士生、

段，对于复杂的连接，可以专门写一个脚本来告诉编译器如何连接。

-Ttext addr

-Tdata addr

-Tbss addr

arm-elf-ld -Ttext 0x00000000 -g led_On.o -o led_on_elf ，运行地址为0x00000000，由于没有指明数据段和bss，他们会默认的依次放在后面。相同的代码不同的Ttext，你可以对比一下他们之间会变的差异，ld会自动调整跳转的地址。

第二个概念：section，section可以理解成一块，例如像c里面的一个子函数，就是一个section，链接器ld把object文件中的每个section都作为一个整体，为其分配运行的地址(memory layout)，这个过程就是重定位(relocation)；最后把所有目标文件合并为一个目标文件。

链接通过一个linker script来控制，这个脚本描述了输入文件的sections到输出文件的映射，以及输出文件的memory layout。

因此，linker总会使用一个linker script，如果不特别指定，则使用默认的script；可以使用‘-T’命令行选项来指定一个linker script。

＊映像文件的输入段与输出段

linker把多个输入文件合并为一个输出文件。输出文件和输入文件都是目标文件(object file)，输出文件通常被称为可执行文件(executable)。

每个目标文件都有一系列section，输入文件的section称为input section，输出文件的section则称为output section。

一个section可以是loadable的，即输出文件运行时需要将这样的section加载到memory(类似于RO&RW段)；也可以是allocatable的，这样的section没有任何内容，某些时候用0对相应的memory区域进行初始化(类似于ZI段)；如果一个section既非loadable也非allocatable，则它通常包含的是调试信息。

每个loadable或allocatable的output section都有两个地址，一是VMA(virtual memoryaddress)，是该section的运行时域地址；二是LMA(load memory address)，是该section的加载时域地址。

可以通过objdump工具附加'-h'选项来查看目标文件中的sections。

＊简单的Linker script

(1) SECTIONS命令：

The SECTIONS commandtells the linker how to map input sections into output sections, andhow to place the output sections in memory.

命令格式如下：

SECTIONS

{

sections-command

......

}

其中sections-command可以是ENTRY命令，符号赋值，输出段描述，也可以是overlay描述。

(2) 地址计数器‘.’(location counter)：

该符号只能用于SECTIONS命令内部，初始值为‘0’，可以对该符号进行赋值，也可以使用该符号进行计算或赋值给其他符号。它会自动根据SECTIONS命令内部所描述的输出段的大小来计算当前的地址。

(3) 输出段描述(output section description)：

前面提到在SECTIONS命令中可以作输出段描述，描述的格式如下：

section [address] [(type)] : [AT(lma)]

{

output-section-command

...

} [>region] [AT>lma_region] [:phdr :phdr ...] [=fillexp]

很多附加选项是用不到的。其中的output-section-command又可以是符号赋值，输入段描述，要直接包含的数据值，或者某一特定的输出段关键字。

＊linker script 实例

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

OUTPUT_ARCH(arm)

ENTRY(_start)

SECTIONS {

. = 0xa3f00000;

__boot_start = .;

.start ALIGN(4) : {

*(.text.start)

}

.setup ALIGN(4) : {

setup_block = .;

*(.setup)

setup_block_end = .;

}

.text ALIGN(4) : {

*(.text)

}

.rodata ALIGN(4) : {

*(.rodata)

}

.data ALIGN(4) : {

*(.data)

}

.got ALIGN(4) : {

*(.got)

}

__boot_end = .;

.bss ALIGN(16) : {

bss_start = .;

*(.bss)

*(COMMON)

bss_end = .;

}

.comment ALIGN(16) : {

*(.comment)

}

stack_point = __boot_start + 0x00100000;

loader_size = __boot_end - __boot_start;

setup_size = setup_block_end - setup_block;

}

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

在SECTIONS命令中的类似于下面的描述结构就是输出段描述：

.start ALIGN(4) : {

*(.text.start)

}

.start为output section name，ALIGN(4)返回一个基于locationcounter(.)的4字节对齐的地址值。*(.text.start)是输入段描述，*为通配符，意思是把所有被链接的object文件中的.text.start段都链接进这个名为.start的输出段。

源文件中所标识的section及其属性实际上就是对输入段的描述，例如.text.start输入段在源文件start.S中的代码如下：

.section .text.start

.global _start

_start :

b start

arm-elf-ld -Ttimer.lds -o timer_elf header .o

这里就必须存在一个timer.lds的文件。

对于.lds文件，它定义了整个程序编译之后的连接过程，决定了一个可执行程序的各个段的存储位置。虽然现在我还没怎么用它，但感觉还是挺重要的，有必要了解一下。

先看一下GNU官方网站上对.lds文件形式的完整描述：

SECTIONS {
...
secname start BLOCK(align) (NOLOAD) : AT ( ldadr )
{ contents } >region :phdr =fill
...
}

secname和contents是必须的，其他的都是可选的。下面挑几个常用的看看：

1、secname：段名

2、contents：决定哪些内容放在本段，可以是整个目标文件，也可以是目标文件中的某段（代码段、数据段等）

3、start：本段连接（运行）的地址，如果没有使用AT（ldadr），本段存储的地址也是start。GNU网站上说start可以用任意一种描述地址的符号来描述。

4、AT（ldadr）：定义本段存储（加载）的地址。

/* nand.lds */
SECTIONS {
firtst 0x00000000 : { head.o init.o }
second 0x30000000 : AT(4096) { main.o }
}

以上，head.o放在0x00000000地址开始处，init.o放在head.o后面，他们的运行地址也是0x00000000，即连接和存储地址相同（没有AT指定）；main.o放在4096（0x1000，是AT指定的，存储地址）开始处，但是它的运行地址在0x30000000，运行之前需要从0x1000（加载处）复制到0x30000000（运行处），此过程也就用到了读取Nand flash。

这就是存储地址和连接（运行）地址的不同，称为加载时域和运行时域，可以在.lds连接脚本文件中分别指定。

编写好的.lds文件，在用arm-linux-ld连接命令时带-Tfilename来调用执行，如
arm-linux-ld –Tnand.lds x.o y.o –o xy.o。也用-Ttext参数直接指定连接地址，如
arm-linux-ld –Ttext 0x30000000 x.o y.o –o xy.o。

既然程序有了两种地址，就涉及到一些跳转指令的区别，这里正好写下来，以后万一忘记了也可查看，以前不少东西没记下来现在忘得差不多了。

ARM汇编中，常有两种跳转方法：b跳转指令、ldr指令向PC赋值。

我自己经过归纳如下：

b step1 ：b跳转指令是相对跳转，依赖当前PC的值，偏移量是通过该指令本身的bit[23:0]算出来的，这使得使用b指令的程序不依赖于要跳到的代码的位置，只看指令本身。

ldr pc, =step1 ：该指令是从内存中的某个位置（step1）读出数据并赋给PC，同样依赖当前PC的值，但是偏移量是那个位置（step1）的连接地址（运行时的地址），所以可以用它实现从Flash到RAM的程序跳转。

此外，有必要回味一下adr伪指令，U-boot中那段relocate代码就是通过adr实现当前程序是在RAM中还是flash中。仍然用我当时的注释

adr r0, _start /* r0是代码的当前位置 */
/* adr伪指令，汇编器自动通过当前PC的值算出如果执行到_start时PC的值，放到r0中：
当此段在flash中执行时r0 = _start = 0；当此段在RAM中执行时_start = _TEXT_BASE(在board/smdk2410/config.mk中指定的值为0x33F80000，即u-boot在把代码拷贝到RAM中去执行的代码段的开始) */

ldr r1, _TEXT_BASE /*测试判断是从Flash启动，还是RAM */
/* 此句执行的结果r1始终是0x33FF80000，因为此值是又编译器指定的(ads中设置，或-D设置编译器参数) */
cmp r0, r1 /* 比较r0和r1，调试的时候不要执行重定位 */

下面，结合u-boot.lds看看一个正式的连接脚本文件。这个文件的基本功能还能看明白，虽然上面分析了好多，但其中那些GNU风格的符号还是着实让我感到迷惑。

OUTPUT_FORMAT("elf32littlearm", "elf32littlearm", "elf32littlearm")
  ;指定输出可执行文件是elf格式,32位ARM指令,小端
OUTPUT_ARCH(arm)
  ;指定输出可执行文件的平台为ARM
ENTRY(_start)
  ;指定输出可执行文件的起始代码段为_start.
SECTIONS
{
        . = 0x00000000 ; 从0x0位置开始
        . = ALIGN(4) ; 代码以4字节对齐
        .text : ;指定代码段
        {
          cpu/arm920t/start.o (.text) ; 代码的第一个代码部分
          *(.text) ;其它代码部分
        }
        . = ALIGN(4)
        .rodata : { *(.rodata) } ;指定只读数据段
        . = ALIGN(4);
        .data : { *(.data) } ;指定读/写数据段
        . = ALIGN(4);
        .got : { *(.got) } ;指定got段, got段式是uboot自定义的一个段,非标准段
        __u_boot_cmd_start = . ;把__u_boot_cmd_start赋值为当前位置,即起始位置
        .u_boot_cmd : { *(.u_boot_cmd) } ;指定u_boot_cmd段, uboot把所有的uboot命令放在该段.
        __u_boot_cmd_end = .;把__u_boot_cmd_end赋值为当前位置,即结束位置
        . = ALIGN(4);
        __bss_start = .; 把__bss_start赋值为当前位置,即bss段的开始位置
        .bss : { *(.bss) }; 指定bss段
        _end = .; 把_end赋值为当前位置,即bss段的结束位置
}