汇编-ARMv8架构指令集_汇编 blx

1 跳转指令

跳转指令用于实现程序流程的跳转，在ARM程序中有两种方法可以实现程序流程的跳转：

1.1 直接向程序计数器PC写入跳转地址值。

通过向程序计数器PC写入跳转地址值，可以实现在4GB的地址空间中的任意跳转，在跳转之前结合使用

MOV LR，PC  ;将下一条指令地址写到LR

等类似指令，可以保存将来的返回地址值，从而实现在4GB连续的线性地址空间的子程序调用。

1.2 使用专门的跳转指令

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

1.2.1、  B指令

B指令的格式为：

B{条件}  目标地址

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

B   Label         ；程序无条件跳转到标号Label处执行
 
 
CMP R1，＃0       ；当CPSR寄存器中的Z条件码置位时，程序跳转到标号Label处执行
 
BEQ Label      

1.2.2、  BL指令

BL指令的格式为：

BL{条件} 目标地址

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

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

1.2.3、  BLX指令

BLX指令的格式为：

BLX  目标地址

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

1.2.4、  BX指令

BX指令的格式为：

BX{条件}  目标地址

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

2、数据处理指令

数据处理指令数据处理指令可分为    数据传送指令、算术逻辑运算指令 、比较指令等。

• 数据传送指令用于在寄存器和存储器之间进行数据的双向传输。
• 算术逻辑运算指令完成常用的算术与逻辑的运算，该类指令不但将运算结果保存在目的寄存器中，同时更新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的标志位

CMPR1，＃100               ；将寄存器R1的值与立即数100相减，并根据结果

                              设置CPSR的标志位

4、  CMN指令

CMN指令的格式为：

CMN{条件} 操作数1，操作数2

CMN指令用于把一个寄存器的内容和另一个寄存器的内容或立即数取反后进行比较，同时更新CPSR中条件标志位的值。该指令实际完成操作数1和操作数2相加，并根据结果更改条件标志位。

指令示例：

CMN    R1，R0              ；将寄存器R1的值与寄存器R0的值相加，并根据结果

                                设置CPSR的标志位

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

                                CPSR的标志位

5、  TST指令

TST指令的格式为：

TST{条件} 操作数1，操作数2

TST指令用于把一个寄存器的内容和另一个寄存器的内容或立即数进行按位的与运算，并根据运算结果更新CPSR中条件标志位的值。操作数1是要测试的数据，而操作数2是一个位掩码，该指令一般用来检测是否设置了特定的位。

指令示例：

TST    R1，＃％1              ；用于测试在寄存器R1中是否设置了最低位（％表示二进制数）

TSTR1，＃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，其余的位保持不变。

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

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

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中的控制位域

5、加载/存储指令

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。

LDRR0，[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位清零。

LDRHR0，[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为地址的存储器中。

---

STRB指令

STRB指令的格式为：

STR{条件}B 源寄存器，<存储器地址>

STRB指令用于从源寄存器中将一个8位的字节数据传送到存储器中。该字节数据为源寄存器中的低8位。

指令示例：

STRB    R0，[R1]             ；将寄存器R0中的字节数据写入以R1为地址的存储

                                  器中。

STRB    R0，[R1，＃8]        ；将寄存器R0中的字节数据写入以R1＋8为地址的

                                  存储器中。

---

STRH指令

STRH指令的格式为：

STR{条件}H 源寄存器，<存储器地址>

STRH指令用于从源寄存器中将一个16位的半字数据传送到存储器中。该半字数据为源寄存器中的低16位。

指令示例：

    STRH   R0，[R1]             ；将寄存器R0中的半字数据写入以R1为地址的存储器中。

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

---

STUR 指令
stur 寄存器,[内存地址]

与STR的区别：

        用于：右边立即数是负数的情况

例如下面汇编代码

str w11, [x10, #0xa0]
stur w12, [x29, #-0x18]

局部变量:

int a = 3;

mov    w12, #0x3
stur   w12, [x29, #-0x18]

mov 先把3 赋值给寄存器w12,然后 stur存储指令把w12 寄存器里的内容写入内存地址 x29, #-0x18 里.

再看全局变量 int g_a = 0;

g_a = 10;

mov    w11, #0xa
str    w11, [x10, #0xa0]

mov 先把10=16进制0xa赋值给了 w11
str存储指令把w11里的内容写入 内存地址 x10, #0xa0 里面.

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

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）。

7、数据交换指令

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位数据交换。

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中。

9、协处理器指令

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处理器寄存器中。 

10、异常产生指令

1、SWI指令

SWI指令的格式为：

SWI{条件} 24位的立即数

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

指令示例：

   SWI   0x02                         ；该指令调用操作系统编号位02的系统例程。

2、BKPT指令

BKPT指令的格式为：

BKPT   16位的立即数

BKPT指令产生软件断点中断，可用于程序的调试。

11  ARM汇编器所支持的伪指令

在ARM汇编语言程序里，有一些特殊指令助记符，这些助记符与指令系统的助记符不同，没有相对应的操作码，通常称这些特殊指令助记符为伪指令，他们所完成的操作称为伪操作。伪指令在源程序中的作用是为完成汇编程序作各种准备工作的，这些伪指令仅在汇编过程中起作用，一旦汇编结束，伪指令的使命就完成。

在ARM的汇编程序中，有如下4种伪指令：符号定义伪指令、数据定义伪指令、汇编控制伪指令、宏指令以及其他伪指令。

11.1   符号定义（Symbol Definition）伪指令

符号定义伪指令用于定义ARM汇编程序中的变量、对变量赋值以及定义寄存器的别名等操作。常见的符号定义伪指令有如下4种：

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中通过该名称访

问寄存器列表。

11.2、数据定义（Data Definition）伪指令

数据定义伪指令一般用于为特定的数据分配存储单元，同时可完成已分配存储单元的初始化。常见的数据定义伪指令有如下9种：

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

11.3、 汇编控制（Assembly Control）伪指令

汇编控制伪指令用于控制汇编程序的执行流程，常用的汇编控制伪指令包括以下4条：

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用于从宏定义中跳转出去。

11.4、其他常用的伪指令

还有一些其他的伪指令，在汇编程序中经常会被使用，包括以下13条：

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

GE  T   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之间。

********************************************************************************                                                                             *

*                                                                             *

*******************************************************************************

4 ARM GNU常用汇编语言介绍

4.1 ARM GNU常用汇编伪指令介绍

1.   abort

.abort    ;停止汇编

.align ab***pr1,ab***pr2   ;

以某种对齐方式,在未使用的存储区域填充值. 第一个值表示对齐方式,4, 8,16或32. 第二个表达式值表示填充的值.

2.    if...else...endif

.if
 
.else
 
.endif

 支持条件预编译

3. include

.include "file": 包含指定的头文件, 可以把一个汇编常量定义放在头文件中.

4. comm

.comm  symbol, length:在bss段申请一段命名空间,该段空间的名称叫symbol, 长度为length. Ld连接器在连接会

为它留出空间.

5. data

.data subsection: 说明接下来的定义归属于subsection数据段.

6. equ

.equ symbol, expression: 把某一个符号(symbol)定义成某一个值(expression).该指令并不分配空间.

7. global

.global symbol: 定义一个全局符号, 通常是为ld使用.

8. ascii

.ascii "string": 定义一个字符串并为之分配空间.

9. byte

.byte expressions: 定义一个字节, 并为之分配空间.

10. short

.short expressions: 定义一个短整型, 并为之分配空间.

11. int

.int expressions: 定义一个整型,并为之分配空间.

12 long

.long expressions: 定义一个长整型, 并为之分配空间.

13 word

.word expressions: 定义一个字,并为之分配空间, 4bytes.

14. macro/endm

.macro: 定义一段宏代码, .macro表示代码的开始, .endm表示代码的结束.

15. req

name .req register name: 为寄存器定义一个别名.

16. code

.code [16|32]: 指定指令代码产生的长度, 16表示Thumb指令, 32表示ARM指令.

17. ltorg

.ltorg: 表示当前往下的定义在归于当前段,并为之分配空间.

4.2 ARM GNU专有符号

1. @

表示注释从当前位置到行尾的字符.

2. #

注释掉一整行.

3. ;

新行分隔符.

4.3 操作码

1. NOP

nop

空操作, 相当于MOV r0, r0

---

ADR LDR 伪指令的区别

LDR

ldr <register> , = <expression>

相当于PC寄存器或其它寄存器的长转移.

ADR

adr <register> <label>

相于PC寄存器或其它寄存器的小范围转移.

ADRL

adrl <register> <label>

相于PC寄存器或其寄存器的中范围转移.

在学习ARM汇编指令的时候，经常会使用到ldr与adr两条指令，相信大部分初学的人曾经都对这两个命令产生过疑惑。

其实这两条指令都是伪指令：

ldr指令是大范围的地址读取伪指令，相对于PC寄存器或其他寄存器的大范围跳转；
adr指令是小范围的地址读取伪指令，相对于PC寄存器或其他寄存器的小范围跳转。
要想清楚的说明这两条指令的区别，还是得从实际的例子中来解释，空谈泛泛，难以实际掌握。

    ldr r0, _start
    nop
    nop
    adr r0, _start
    nop
    nop
    ldr r0, =_start         ;绝对地址
    nop
    nop
_start:
    nop

反汇编后的结果如下：

1   0x00000000: e59f001c ... LDR r0, [pc, #28]; [0x24]=e1a00000
2   0x00000004: e1a00000 ... MOV r0, r0
3   0x00000008: e1a00000 ... MOV r0, r0
4   0x0000000c: e28f0010 ... ADD r0, pc, 0x10; r0=x00000024
5   0x00000010: e1a00000 ... MOV r0, r0 
6   0x00000014: e1a00000 ... MOV r0, r0
7   0x00000018: e59f0008 ... LDR r0, [pc, #8]; [0x28]=00000024
8   0x0000001c: e1a00000 ... MOV r0, r0
9   0x00000020: e1a00000 ... MOV r0, r0
_start:
10  0x00000024: e1a00000 ... MOV r0, r0
    $d  存放_start地址值
11  0x00000028: 00000024 ... DCD 36

• 第一行，寄存器间接寻址，获取_start的地址，此时，r0=0xe1a00000.
• 第四行，此时，r0=0x00000024.
• 第七行，取得标号_start的绝对地址，这个绝对地址是在link的时候确定的，看上去这只是一条指令，但是它要占用2个32bit的空间，一条是指令，另一条是_start的数据。因为在编译的时候不能够确定_start的值，而且也不能够用mov指令来给r0赋一个32bit的常量，所以需要多出一个空间来存放_start的真正数据，在这里就是0x00000024，由此可以看出，这个是绝对寻址，不管代码在什么地方运行，它的结果都是r0=0x00000024.
   

 adrp、adr、adr_l

adrp x0 , 1 ;注释下面

1. 将1的值,左移12位 1 0000 0000 0000 == 0x1000

2.将PC寄存器的低12位清零0x104bee870 ==> 0x104bee000，

        这里的PC寄存器的值:是到adrp x0 1的那里的PC寄存器里面的值

3.将1 和 2 的结果相加给X0 寄存器   

在Linux内核启动代码primary_entry中，使用adrp指令获取Linux内核在内存中的起始页地址，页大小为4KB，由于内核启动的时候MMU还未打开，此时获取的Linux内核在内存中的起始页地址为物理地址。adrp通过当前PC地址的偏移地址计算目标地址，和实际的物理无关，因此属于位置无关码。对于具体的计算过程，下面慢慢分析。

[arch/arm64/kernel/head.S]
SYM_CODE_START(primary_entry)
    ......
    adrp    x23, __PHYS_OFFSET
    and    x23, x23, MIN_KIMG_ALIGN - 1  // KASLR offset, defaults to 0
    ......
SYM_CODE_END(primary_entry)

[arch/arm64/kernel/head.S]
#define __PHYS_OFFSET    KERNEL_START  // 内核的物理地址
[arch/arm64/include/asm/memory.h]
// 内核的起始地址和结束地址在vmlinux.lds链接脚本中定义
#define KERNEL_START    _text         // 内核代码段的起始地址，也即内核的起始地址
#define KERNEL_END        _end          // 内核的结束地址

2.1.定义
adrp指令根据PC的偏移地址计算目标页地址。首先adrp将一个21位有符号立即数左移12位，得到一个33位的有符号数（最高位为符号位），接着将PC地址的低12位清零，这样就得到了当前PC地址所在页的地址，然后将当前PC地址所在页的地址加上33位的有符号数，就得到了目标页地址，最后将目标页地址写入通用寄存器。此处页大小为4KB，只是为了得到更大的地址范围，和虚拟内存的页大小没有关系。

通过adrp指令，可以获取当前PC地址±4GB范围内的地址。

通常的使用场景是先通过adrp获取一个基地址，然后再通过基地址的偏移地址获取具体变量的地址。

下面是adrp指令的编码格式。立即数占用21位，在运行的时候，会将21位立即数扩展为33位有符号数。最高位为1，表示这是一个aarch64指令。

 测试

Linux内核启动代码不好测试，需要写一个简单的测试代码。下面是本次adrp的测试代码，使用adrp指令获取g_val1和g_val2数组所在页的基地址，同时会打印数组的地址和调用函数的地址，由于是应用层的程序，这些地址都是虚拟地址，但是计算过程都是一样的。

#define PAGE_4KB    (4096) 
#define __stringify_1(x...)    #x
#define __stringify(x...)    __stringify_1(x)
uint64_t g_val1[PAGE_4KB / sizeof(uint64_t)];
uint64_t g_val2[PAGE_4KB / sizeof(uint64_t)];
 
#define ADRP(label)   ({          \
    uint64_t __adrp_val__ = 0;    \
    asm volatile("adrp %0," __stringify(label) :"=r"(__adrp_val__)); \
    __adrp_val__;                 \
})
 
static void adrp_test()
{
    printf("g_val1 addr 0x%lx, adrp_val1 0x%lx, adrp_test addr 0x%lx\n",
        (uint64_t)g_val1, ADRP(g_val1), (uint64_t)adrp_test);
    printf("g_val2 addr 0x%lx, adrp_val2 0x%lx, adrp_test addr 0x%lx\n",
        (uint64_t)g_val2, ADRP(g_val2), (uint64_t)adrp_test);
}

上面程序运行的输出结果如下，g_val1和g_val2的地址分别为0x5583e25028和0x5583e26028，g_val1的页基地址为0x5583e25000，g_val2页的基地址为0x5583e26000，adrp_test函数的地址为0x5583e1479c。

g_val1 addr 0x5583e25028, adrp_val1 0x5583e25000, adrp_test addr 0x5583e1479c
g_val2 addr 0x5583e26028, adrp_val2 0x5583e26000, adrp_test addr 0x5583e1479c
 

 反汇编代码如下所示。下面分析一下g_val1页基地址的计算过程，包括编译时和运行时，g_val2页基地址的计算过程类似，这里不再赘述。

• 将g_val1地址（0x11028）低12位清零，得到0x11000，将当前adrp指令所在地址（0x7b0）的低12清零，得到0x0（编译时完成）
• 0x1100减去0x0得到偏移地址0x11000，偏移地址右移12位得到偏移页数量0x11，将立即数0x11保存到指令编码中（编译时完成）
• 取出立即数0x11，左移12位转换成偏移的字节数，即0x11000（运行时完成）
• 将PC地址的低12位清零得到0x5583e14000（运行时完成）
• 将0x5583e14000加上0x1100得到g_val1运行时页基地址0x5583e25000（运行时完成）

000000000000079c <adrp_test>:  // 运行时的地址为0x5583e1479c
......
 7b0:    b0000080     adrp    x0, 11000 <__data_start>    // 获取g_val1页基地址
......
 7e0:    d0000080     adrp    x0, 12000 <g_val1+0xfd8>    // 获取g_val2页基地址
 
Disassembly of section .data:       // 数据段定义
0000000000011000 <__data_start>:    // 运行时的地址为0x5583e25000
    ...
......
Disassembly of section .bss:        // bss段定义
0000000000011028 <g_val1>:    // 运行时地址为0x5583e25028
    ...
0000000000012028 <g_val2>:    // 运行时地址为0x5583e26028
    ...

从上面可以看出，编译时和运行时的地址不一样，但通过adrp指令都能正确获取g_val1页基地址和g_val2页基地址。说明adrp获取的地址是位置无关的，不管运行时的地址怎么变，都可以正确获取对应变量页基地址。当然我们也可以使用专业的反汇编工具，直接将机器码转换为汇编代码。上面两条adrp指令转换的汇编代码如下，和上面一样，这里的偏移地址都已经做了左移12位的处理。

3.adr

3.1.定义

adr指令根据PC的偏移地址计算目标地址。偏移地址是一个21位的有符号数，加上当前的PC地址得到目标地址。adr可以获取当前PC地址±1MB范围内的地址。下面是adr指令的编码格式。立即数占用21位。

 

3.2.测试
下面是测试代码，使用adr指令获取变量g_val3和g_val4的地址，并与通过&获取的地址进行对比。

uint64_t g_val3 = 0;
uint64_t g_val4 = 0;
 
#define ADR(label)   ({          \
    uint64_t __adr_val__ = 0;    \
    asm volatile("adr %0," __stringify(label) :"=r"(__adr_val__)); \
    __adr_val__;                 \
})
 
static void adr_test()
{
    printf("g_val3 addr 0x%lx, adr_val1 0x%lx, adr_test addr 0x%lx\n",
        (uint64_t)&g_val3, ADR(g_val3), (uint64_t)adr_test);
    printf("g_val4 addr 0x%lx, adr_val2 0x%lx, adr_test addr 0x%lx\n",
        (uint64_t)&g_val4, ADR(g_val4), (uint64_t)adr_test);
}

下面是测试结果，使用&获取的地址和通过adr获取的地址相同。

g_val3 addr 0x5583e25018, adr_val1 0x5583e25018, adr_test addr 0x5583e14810
g_val4 addr 0x5583e25020, adr_val2 0x5583e25020, adr_test addr 0x5583e14810

下面是反汇编的代码。可以看出，adr汇编代码中的偏移地址被objdump使用符号地址代替了，没有使用真正的偏移地址。g_val3真正的偏移地址为0x107f4，g_val4真正的偏移地址为0x107cc。执行第一条adr指令的PC地址为0x5583e14824，则0x5583e14824+0x107f4=0x5583e25018为g_val3的地址。g_val4的计算过程类似，不再赘述。
 

0000000000000810 <adr_test>:    // 运行地址为0x5583e14810
......
 824:    10083fa0     adr    x0, 11018 <g_val3>  // 偏移地址为0x11018-0x824=0x107f4
......
 854:    10083e60     adr    x0, 11020 <g_val4>  // 偏移地址为0x11020-0x854=0x107cc
......
 
isassembly of section .data:
 
0000000000011000 <__data_start>:
    ...
......
Disassembly of section .bss:
......
0000000000011018 <g_val3>:      // 运行地址为0x5583e25018
    ...
 
0000000000011020 <g_val4>:      // 运行地址为0x5583e25020
    ...

4. adr_l
adr_l是Linux内核定义的一个宏，用于获取基于PC相对偏移+/- 4 GB内的符号地址。在内核上下文中，使用adrp和add指令获取符号地址，而在内核模块上下文中，使用mov指令获取符号地址。

    [arch/arm64/include/asm/assembler.h]
    .macro    adr_l, dst, sym
#ifndef MODULE  /* 内核上下文中 */
    adrp    \dst, \sym  /* 获取符号所在页的基地址 */
    /* :lo12:\sym - 获取符号sym的低12位地址。
       符号所在页的基地址加上低12位地址就得到符号的完整地址 */
    add    \dst, \dst, :lo12:\sym
#else  /* 内核模块上下中 */
    /* 将符号的bit[64:48]地址加载到dst寄存器中，同时做
       overflow check，其他位清零 */
    movz    \dst, #:abs_g3:\sym
    /* 将符号的bit[47:32]地址加载到dst寄存器中，不做
       overflow check，其他位保持不变 */
    movk    \dst, #:abs_g2_nc:\sym
    /* 将符号的bit[31:16]地址加载到dst寄存器中，不做
       overflow check，其他位保持不变 */
    movk    \dst, #:abs_g1_nc:\sym
    /* 将符号的bit[15:0]地址加载到dst寄存器中，不做
       overflow check，其他位保持不变 */
    movk    \dst, #:abs_g0_nc:\sym
#endif
    .endm

mov指令获取地址的操作如下图所示。

MOVZ将16位立即数移至寄存器，并且除该立即数之外的所有其他位均设置为零，同时也可以将立即数向左移0、16、32或48位。

   instruction                       value of x0
movz  x0, #0x1f88           |        0x1f88
movz  x0, #0x1f88, lsl #16  |        0x1f880000

MOVK移动16位立即数并将其保存到寄存器中，但寄存器中其他位保持不变。

       instruction                    value of x0
movk   x0, #0xb7fb, lsl #16  |        0xb7fb1f88
movk   x0, #0x7f, lsl #32    |        0x7fb7fb1f88 
 

5.1 lds文件说明

5.1.1 主要符号说明

    1. OUTPUT_FORMAT(bfdname)

    指定输出可执行文件格式.

   

    2. OUTPUT_ARCH(bfdname)

   

    指定输出可执行文件所运行CPU平台

   

    3. ENTRY(symbol)

    指定可执行文件的入口段

   

    5.1.2 段定义说明

    1. 段定义格式

    SECTIONS

    { ...

        段名 :

        {

            内容

        }

    ...

    }

1. ARMv8寄存器体系

1.1 概述

ARMv8架构继承了ARMv7与之前处理器技术的基础，除了对现有的16/32bit的Thumb2指令支持外，也向前兼容了现有的A32(ARM 32bit)指令集，基于64bit的AArch64架构，除了新增A64(ARM 64bit)指令集外，也扩充了现有的A32(ARM 32bit)和T32(Thumb2 32bit）指令集，另外还新增加了CRYPTO(加密)模块支持。

1.2 特性

1. ARMv8提供了AArch32 state和AArch64 state两种Execution State

 

2 Exception Level

​ 2.1 ARMv8定义EL0-EL3共 4个Exception Level来控制PE的行为

 Exception Level

• ELx(x<4)，x越大等级越高，执行特权越高
• 执行在EL0称为非特权执行
• EL2 没有Secure state，只有Non-secure state
• EL3 只有Secure state，实现EL0/EL1的Secure和Non-secure之间的切换
• EL0 & EL1 必须要实现，EL2/EL3则是可选实现

2.2 Exception Level & Security

1.3 寄存器

​ 在ARM64架构下，CPU提供了33个寄存器, 其中前31个（0~30）是通用寄存器 (general-purpose integer registers)，最后2个(31,32)是专用寄存器（sp寄存器和 pc 寄存器)。

2. Armv8指令集

2.1 汇编指令

​ ARM指令使用的是 三地址码 , 它的格式如下:

​ <opcode> {<cond>} {S} <Rd> , <Rn> , <shifter_operand>

• opcode：操作码，也就是助记符，操作码，也就是助记符，说明指令需要执行的操作类型
• cond：指令执行条件码，在编码中占4bit，0b0000 -0b1110
• S：条件码设置项,决定本次指令执行是否影响PSTATE寄存器响应状态位值
• Rd：目标寄存器，A64指令可以选择X0-X30 or W0-W30
• Rn：第一个操作数的寄存器，和Rd一样，不同指令有不同要求
• shifter_operand：第二个操作数，可以是立即数，寄存器Rm和寄存器移位方式（Rm，#shit）

Cond项表明了指令的执行的条件，每一条ARM指令都可以在规定的条件下执行，每条ARM指令包含4位的条件码，位于指令的最高4位[31：28]。
    条件码共有16种，每种条件码用2个字符表示，这两个字符可以添加至指令助记符的后面，与指令同时使用。
    当指令的执行条件满足时，指令才被执行，否则指令被忽略。如果在指令后不写条件码，则使用默认条件AL（无条件执行）。
    
                        指令的条件码
    
    条 件 码      助记符后缀            标    志                含    义
    0000            EQ                    Z置位                相等equal
    0001            NE                    Z清零                不相等not equal
    0010            CS                    C置位                无符号数大于或等于Carry Set
    0011            CC                    C清零                无符号数小于
    0100            MI                    N置位                负数minus
    0101            PL                    N清零                正数或零plus
    0110            VS                    V置位                溢出
    0111            VC                    V清零                没有溢出
    1000            HI                    C置位Z清零           无符号数大于high
    1001            LS                    Z置位C清零           无符号数小于或等于less
    1010            GE                    N等于V               带符号数大于或等于
    1011            LT                    N不等于V             带符号数小于least
    1100            GT                    Z清零且（N等于V）    带符号数大于great
    1101            LE                    Z清零或（N不等于V）  带符号数小于或等于
    1110            AL                    忽略                 无条件执行all
    1111

 2.2 指令分类

2.3 寻址方式

2.4 A64指令集

 
常用A64指令：

add

将某一寄存器的值和另一寄存器的值 相加 并将结果保存在另一寄存器中，如：

add x0, x0, #1    ; 将寄存器 x0 的值和常量 1 相加后保存在寄存器 x0 中
add x0, x1, x2    ; 将寄存器 x1 和 x2 的值相加后保存到寄存器 x0 中
add x0, x1, [x2]  ; 将寄存器 x1 的值加上寄存器 x2 的值作为地址，再取该内存地址的内容放入寄

sub

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)

and

and指令用于在两个操作数上进行逻辑与运算，并把结果放置到目的寄存器中。操作数1应是一个寄存器，操作数2可以是一个寄存器，被移位的寄存器，或一个立即数。该指令常用于屏蔽操作数1的某些位。如：

 AND  R0, R0, #3               ;3(0011) 该指令保持R0的0、1位，其余位清零。  

STP 指令 

p是pair的意思把一对寄存器写入到右边内存；
stp w0,w1,[x2] //把w0和 w1里面的值,写入到右边内存,[x2]中,w0在左边,w1在右边
在oc中的调用
fn2的声明

int fn2(int a,int b,int *c);//fn2的声明

调用

int c = 1;
int d = 2;
int e = 0;
result = fn2(c, d,&e);
NSLog(@"result=%d",result);

汇编函数定义

_fn2:
//w0 存储参数1,w1存储参数2.因为w0和w1共同组成x0,第三个参数向后延续一个寄存器,所以参数3存入x1中
stp w0,w1,[x2] //把w0和 w1里面的值,写入到右边内存,[x2]中,w0在左边,w1在右边
mov x0,x2//把x2的值存入返回值x0中
ret

调试结果

(lldb) re read x2
      x2 = 0x000000016fd9540c
(lldb) x 0x000000016fd9540c
0x16fd9540c: 00 00 00 00 02 00 00 00 01 00 00 00 0a 00 00 00  ................
0x16fd9541c: 01 00 00 00 c0 e4 6d 83 02 00 00 00 00 88 3e 80  ......m.......>.
(lldb) re read w0
      w0 = 0x00000001
(lldb) re read w1
      w1 = 0x00000002
(lldb) si
(lldb) x 0x000000016fd9540c
0x16fd9540c: 01 00 00 00 02 00 00 00 01 00 00 00 0a 00 00 00  ................
0x16fd9541c: 01 00 00 00 c0 e4 6d 83 02 00 00 00 00 88 3e 80  ......m.......>.
(lldb) si
(lldb) re read x0
      x0 = 0x000000016fd9540c

这个x0就是返回值,赋值给int类型是取走后8位,就是 0x6fd9540c,转换成10进制就是1876513804

打印结果:

result=1876513804

ldp

出栈指令（ldr 的变种指令，可以同时操作两个寄存器)，如：

 ldp x29, x30, [sp, #0x10]    ; 将 sp 偏移 16 个字节的值取出来，存入寄存器 x29 和寄存器 x30

blr

跳转到 某寄存器 (的值)指向的地址（有返回），先将下一指令地址（即函数返回地址）保存到寄存器 lr (x30)中，再进行跳转，如：

blr x20       ; 先将下一指令地址（x20 指向的函数调用后的返回地址）保存到寄存器 lr 中，然后再调用 x20 指向的函数

ARM64 指令集

ARM指令集是指计算机ARM操作指令系统。在ARM中有两种方式可以实现程序的跳转：一种是跳转指令；另一种是直接向PC寄存器(R15)中写入目标地址值。

ARM指令集可以分为数据处理指令，数据加载指令和存储指令，分支指令，程序状态寄存器(PSR)处理指令，协处理器指令和异常产生指令六大类。

arm指令

指令

作用

ADC

带进位的32位数加法

ADD

32位数相加

SUB

32位减法

AND

32位数的逻辑与

B

在32M空间内的相对跳转指令

BKPT

断点指令

BL

带链接的相对跳转指令-(1) 将下一条指令的地址放入lr(x30)寄存器，(2)转到标号出执行指令

BLX

带链接的切换跳转

BX

切换跳转

BEQ

相等则跳转(Branch if EQual)

BNE

不相等则跳转(Branch if Not Equal)

BGE

大于或等于跳转(Branch if Greater than or Equa)

BGT

大于跳转(Branch if Greater Than)

BIC

32位数的逻辑位清零

RET

默认使用lr(x30)寄存器的值通过底层指令提示CPU此处作为下条指令地址(ARM64平台的特色指令，面向硬件做了优化处理)

BLE

小于或等于跳转(Branch if Less than or Equal)

BLEQ

带链接等于跳转(Branch with Link if EQual)

BLLT

带链接小于跳转(Branch with Link if Less Than)

BLTt

小于跳转(Branch if Less Than)

CDP CDP2

协处理器数据处理操作

CLZ

零计数

CMN

比较两个数的相反数

CMP

32位数比较

EOR

32位逻辑异或

LDC LDC2

从协处理器取一个或多个32位值

LDM

从内存送多个32位字到ARM寄存器

LDR(load register)

从内存地址取一个单个的32位值加载入通用寄存器

STD

ldr的变种，可以同时操作两个寄存器

DLP(load register)

从内存地址取一个单个的64位值加载入通用寄存器

MCR MCR2 MCRR

从寄存器送数据到协处理器

MLA

32位乘累加

MOV

传送一个32位数到寄存器

MRC MRC2 MRRC

从协处理器传送数据到寄存器

MRS

把状态寄存器的值送到通用寄存器

MSR

把通用寄存器的值传送到状态寄存器

MUL

32位乘

MVN

把一个32位数的逻辑“非”送到寄存器

ORR

32位逻辑或

PLD

预装载提示指令

QADD

有符号32位饱和加

QDADD

有符号双32位饱和加

QSUB

有符号32位饱和减

QDSUB

有符号双32位饱和减

RSB

逆向32位减法

RSC

带进位的逆向32法减法

SBC

带进位的32位减法

SMLAxy

有符号乘累加(16位*16位)+32位=32位

SMLAL

64位有符号乘累加((32位*32位)+64位=64位)

SMALxy

64位有符号乘累加((32位*32位)+64位=64位)

SMLAWy

号乘累加((32位*16位)>>16位)+32位=32位

SMULL

64位有符号乘累加(32位*32位)=64位

SMULxy

有符号乘(16位*16位=32位)

SMULWy

有符号乘(32位*16位>>16位=32位)

STC STC2

从协处理器中把一个或多个32位值存到内存

STM

把多个32位的寄存器值存放到内存

SWI

软中断

SWP

把一个字或者一个字节和一个寄存器值交换

TEQ

等值测试

TST

位测试

UMLAL

64位无符号乘累加((32位*32位)+64位=64位)

UMULL

64位无符号乘累加(32位*32位)=64位

B.LE

标号：小于等于(if判断)

B.LT

标号：小于等于(do while)

B.GT

标号：小于等于(while do)

B.GE

标号：大于等于(for)

B.EQ

标号：比较结果是等于，执行标号，否则不跳转

B.HI

标号：比较结果是无符号大于，执行标号，否则不跳转

跳转指令

通过直接向PC寄存器中写入目标地址值可以实现在4GB地址空间中任意跳转，这种跳转指令又称为长跳转。如果在长跳转指令之前使用MOV LR，PC等指令，则可以保存将来返回的地址值，这样就实现了在4GB地址空间中的子程序调用。

在ARM版本5及以上的体系中，实现了ARM指令集和Thumb指令集的混合使用。指令使用目标地址值的bit[0]来确定目标程序的类型。bit[0]的值为1时，目标程序为Thumb指令；bit[0]值为0时，目标程序为ARM指令。

在ARM版本5以前的体系中，传送到PC寄存器中的目标地址值的低两位bits[1∶0]被忽略，跳转指令只能在ARM指令集中执行，即程序不能从ARM状态切换到Thumb状态。非T系列ARM版本5体系不含Thumb指令，当程序试图切换到Thumb状态时，将产生未定义指令异常中断。

ARM跳转指令可以从当前指令向前或向后的32MB地址空间跳转。这类跳转指令有以下4种。

(1)B 跳转指令

B〔条件) (地址)

B指令属于ARM指令集，是最简单的分支指令。一旦遇到一个B指令，ARM处理器将立即跳转到给定的地址，从那里继续执行。注意：存储在分支指令中的实际值是相对当前R15的值的一个偏移量，而不是一个绝对地址。它的值由汇编器来计算，是24位有符号数，左移两位后有符号扩展为32位，表示的有效偏移位为26位(+/－ 32 MB)。

(2)BL 带返回的跳转指令

BI，〔条件) (地址)

BL指令也属于ARM指令集，是另一个分支指令。就在分支之前，在寄存器R14中装载上R15的内容，因此可以重新装载R14到R15中来返回到这个分支之后的那个指令处执行，它是子例程的一个基本但强力的实现。

(3)BLX 带返回和状态切换的跳转指令

BLX

BLX指令有两种格式

第1种格式的BLX指令记作BLX(1)。BLX(1)从ARM指令集跳转到指令中指定的目标地址，并将程序状态切换到Thumb状态，该指令同时将PC寄存器的内容复制到LR寄存器中。

BLX(1)指令属于无条件执行的指令。

第2种格式的BLX指令记作BLX(2)。BLX(2)指令从ARM指令集跳转到指令中指定的目标地址，目标地址的指令可以是ARM指令，也可以是Thumb指令。目标地址放在指令中的寄存器中，该地址的bit[0]值为0，目标地址处的指令类型由CPSR中的T位决定。该指令同时将PC寄存器的内容复制到LR寄存器中。

(4)BX 带状态切换的跳转指令

BX(条件) (dest)

BX指令跳转到指令中指定的目标地址，目标地址处的指令可以是ARM指令，也可以是Thumb指令。目标地址值为指令的值和0xFFFFFFFE做“与”操作的结果，目标地址处的指令类型由寄存器决定。

常见汇编代码解读

add w0, #0xa ;w0中的值加0xa(10)

CMP W0, W1 ;比较大小 == SUB W0,W0,W1 不同CMP指令不改变w0的值

str w10 [sp] ; 注: 其中[]表示取sp地址;整句的意思是将读取w10中数据并存放到栈内

std x29, x30,[sp, #-0x10] == ( sub sp, sp,#0x10 std x29,x30, [sp] )

ldp x29,x30,[sp],#0x10 == ldp x29,x30,[sp] add sp,sp,#0x10

orr

adrp x0 , 1 ;注释下面

寄存器作用

w0 - w7 存储函数传入的参数 如果参数超过8个会对超出的参数做入栈操作

w0 一般会保存返回值

x29 没有什么特殊作用

x30 作用：保护回家的路 - ret 指令 返回x30中保存的指令地址

CPSR 寄存器

寄存器图示

N：负数标志位。如果目标寄存器中的有符号数为负数，则N=1，否则N=0。

Z：零标志位。如果目标寄存器中的数为0，则N=1，否则N=1。

C：进位标志位。有以下3种情况

1、无符号加法运算和CMN指令，如果产生进位，则C=1，否则C=0；

2、无符号减法运算和CMP指令，如果产生借位，则C=0，否则C=1；

3、进行移位操作的时候，C中保存最后一位移出的值。

说明：当一条指令中同时含有算术运算指令和移位指令时，影响C的值是算术运算而不是移位操作。

V：溢出标志位。进行有符号运算时如果发生错误，则V=1，否则V=0。

一些指令如CMN、TEQ等会无条件的刷新CPSR中的条件标志位，其他指令必须要在指令后面加上S后缀才会改变CPSR中的条件标志位。

I：IRQ中断禁止位。I=1代表禁止IRQ中断，I=0代表允许IRQ中断。

F：FIQ中断禁止位。F=1代表禁止FIQ中断，F=0代表允许FIQ中断。

这里和51单片机中的中断使能位有点小差别，51中的是中断使能位，所以为1的时候应该是中断使能，即允许中断。而这里是中断禁止位，为1的时候应该是禁止中断。

T：这一位只在ARMv4T指令集版本及以上才有效。因为ARMv4版本及以下都不支持Thumb指令集。在支持Thumb指令集的处理器中，T=0表示处于ARM状态，T=1表示处于Thumb状态。

M[4:0]：用于控制7种模式位(用户模式(usr)、系统模式(sys)、快速中断模式(fiq)、中断模式(irq)、中止模式(abt)、未定义指令模式(und)、管理模式(svc))。

模式图示

上述的7中处理器模式中，还可分类为特权模式，异常模式。

特权模式：除了用户模式之外的所有模式都是特权模式。在其他模式下都可以修改模式位来切换至不同的模式，而用户模式下不允许修改模式位。特权模式下可以比用户模式访问到更多的系统资源。

异常模式：除了用户模式和系统模式之外的所有模式都是异常模式。