Arm汇编学习总结

Posted 2020-09-17

 Arm汇编学习总结：

 

　　1. LDR/STR架构

 

　　　　1).ARM采用RISC架构，CPU本身不能直接读取内存，而需要先将内存中内容加载入CPU中通用寄存器中才能被CPU处理。
　　　　2).ldr（load register）指令将内存内容加载入通用寄存器。
　　　　3).str（store register）指令将寄存器内容存入内存空间中。
　　　　4).ldr/str组合用来实现 ARM CPU和内存数据交换。

 

• 3级流水线如图所示（PC为程序计数器），流水线使用3个阶段，因此指令分3个阶段执行。

  ⑴ 取指从存储器装载一条指令

  ⑵ 译码识别将要被执行的指令

  ⑶ 执行处理指令并将结果写会寄存器

• PC总是指向第3条指令，或者说PC总是指向当前正在执行的指令地址再加2条指令的地址。

• 寻址方式

• 寄存器寻址

1. 将R2寄存器中的值存放到R1寄存器中

• 寄存器移位寻址

1. 操作数2先进行移位操作，然后再与第一个操作数进行操作。
2. MOV   R0,R1,LSL #3

 

• 寄存器间接寻址

1. LDR   R1,[R2]

 

• 基址寻址

1. LDR  R2,[R3,#0X0C]

 

• 多寄存器寻址

1. LDMIA  R1! ,{R2-R4,R6}

 

• 堆栈寻址

1. 堆栈寻址是隐含的，它使用一个专门的寄存器（堆指针）指向一块存储区域（堆栈）。指针所指向的存储单元即是堆栈的栈顶
2. 存储器堆栈可分为两种:
3. 向上生长：向高地址方向生长，称为递增堆栈
4. 向下生长：向低地址方向生长，称为递减堆栈
5. 按堆栈指针的执行顺序分为:
6. 空堆栈： 堆栈指针指向下一个待压入数据的空位置  -->  即当有数据入堆栈时，数据先入栈，然后栈顶指针在加一
7. 满堆栈：堆栈指针指向最后压入堆栈的有效数据      -->  即当有数据入堆栈时，栈顶指针先加一，然后数据入栈

　　后缀的种类：

　　　　ia（increase after）先传输，再地址+4
　　　　ib（increase before）先地址+4，再传输
　　　　da（decrease after）先传输，再地址-4
　　　　db（decrease before）先地址-4，再传输
　　　　fd（full decrease）满递减堆栈
　　　　ed（empty decrease）空递减堆栈
　　　　fa（·······） 满递增堆栈
　　　　ea（·······）空递增堆栈

• 相对寻址

1. 相对寻址是基址寻址的另一种形式。由程序计数器PC提供基准地址，指令中的地址码字段作为偏移量，两者相加后得到的地址即操作数的有效地址

• 立即寻址

1. MOV  R0,#0XAA  立即数0XAA存放到寄存器R0中

 

 

 

ADC : 带进位的加法

(Addition with Carry)

ADC{条件}{S}  <dest>, <op 1>, <op 2>

 

                dest = op_1 + op_2 + carry

ADC将把两个操作数加起来，并把结果放置到目的寄存器中。它使用一个进位标志位，这样就可以做比 32 位大的加法。下列例子将加两个 128 位的数。
128 位结果: 寄存器 0、1、2、和 3
第一个 128 位数: 寄存器 4、5、6、和 7
第二个 128 位数: 寄存器 8、9、10、和 11。

ADDS    R0, R4, R8              ; 加低端的字

  ADCS    R1, R5, R9              ; 加下一个字，带进位

  ADCS    R2, R6, R10             ; 加第三个字，带进位

  ADCS    R3, R7, R11             ; 加高端的字，带进位

如果如果要做这样的加法，不要忘记设置 S 后缀来更改进位标志。

　

ADD : 加法

(Addition)

ADD{条件}{S}  <dest>, <op 1>, <op 2>

 

                dest = op_1 + op_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)

加法可以在有符号和无符号数上进行。

　

AND : 逻辑与

(logical AND)

AND{条件}{S}  <dest>, <op 1>, <op 2>

 

                dest = op_1 AND op_2

AND将在两个操作数上进行逻辑与，把结果放置到目的寄存器中；对屏蔽你要在上面工作的位很有用。操作数 1 是一个寄存器，操作数 2 可以是一个寄存器，被移位的寄存器，或一个立即值:

AND     R0, R0, #3              ; R0 = 保持 R0 的位 ０ 和 1，丢弃其余的位。

AND 的真值表(二者都是 1 则结果为 1):

Op_1   Op_2   结果

 

  0      0      0

  0      1      0

  1      0      0

  1      1      1

　

BIC : 位清除

(Bit Clear)

BIC{条件}{S}  <dest>, <op 1>, <op 2>

 

                dest = op_1 AND (!op_2)

BIC是在一个字中清除位的一种方法，与 OR 位设置是相反的操作。操作数 2 是一个 32 位位掩码(mask)。如果如果在掩码中设置了某一位，则清除这一位。未设置的掩码位指示此位保持不变。

BIC     R0, R0, #%1011          ; 清除 R0 中的位 0、1、和 3。保持其余的不变。

BIC 真值表 :

Op_1   Op_2   结果

 

  0      0      0

  0      1      0

  1      0      1

  1      1      0

译注：逻辑表达式为 Op_1 AND NOT Op_2

　

EOR : 逻辑异或

(logical Exclusive OR)

EOR{条件}{S}  <dest>, <op 1>, <op 2>

 

                dest = op_1 EOR op_2

EOR将在两个操作数上进行逻辑异或，把结果放置到目的寄存器中；对反转特定的位有用。操作数 1 是一个寄存器，操作数 2 可以是一个寄存器，被移位的寄存器，或一个立即值:

EOR     R0, R0, #3              ; 反转 R0 中的位 0 和 1

EOR 真值表(二者不同则结果为 1):

Op_1   Op_2   结果

 

  0      0      0

  0      1      1

  1      0      1

  1      1      0

　

MOV : 传送

(Move)

MOV{条件}{S}  <dest>, <op 1>

 

                dest = op_1

MOV从另一个寄存器、被移位的寄存器、或一个立即值装载一个值到目的寄存器。你可以指定相同的寄存器来实现NOP 指令的效果，你还可以专门移位一个寄存器:

MOV     R0, R0                  ; R0 = R0... NOP 指令

 

  MOV     R0, R0, LSL#3           ; R0 = R0 * 8

如果 R15 是目的寄存器，将修改程序计数器或标志。这用于返回到调用代码，方法是把连接寄存器的内容传送到R15:

MOV     PC, R14                 ; 退出到调用者

 

  MOVS    PC, R14                 ; 退出到调用者并恢复标志位

                                    (不遵从 32-bit 体系)

　

MVN : 传送取反的值

(MoveNegative)

MVN{条件}{S}  <dest>, <op 1>

 

                dest = !op_1

MVN从另一个寄存器、被移位的寄存器、或一个立即值装载一个值到目的寄存器。不同之处是在传送之前位被反转了，所以把一个被取反的值传送到一个寄存器中。这是逻辑非操作而不是算术操作，这个取反的值加 1 才是它的取负的值:

MVN     R0, #4                  ; R0 = -5

 

  MVN     R0, #0                  ; R0 = -1

　

ORR : 逻辑或

(logical OR)

ORR{条件}{S}  <dest>, <op 1>, <op 2>

 

                dest = op_1 OR op_2

OR将在两个操作数上进行逻辑或，把结果放置到目的寄存器中；对设置特定的位有用。操作数 1 是一个寄存器，操作数 2 可以是一个寄存器，被移位的寄存器，或一个立即值:

ORR     R0, R0, #3              ; 设置 R0 中位 0 和 1

OR 真值表(二者中存在 1 则结果为 1):

Op_1   Op_2   结果

 

  0      0      0

  0      1      1

  1      0      1

  1      1      1

　

RSB : 反向减法

(Reverse Subtraction)

RSB{条件}{S}  <dest>, <op 1>, <op 2>

 

                dest = op_2 - op_1

SUB用操作数two 减去操作数one，把结果放置到目的寄存器中。操作数 1 是一个寄存器，操作数 2 可以是一个寄存器，被移位的寄存器，或一个立即值:

RSB     R0, R1, R2              ; R0 = R2 - R1

  RSB     R0, R1, #256            ; R0 = 256 - R1

  RSB     R0, R2, R3,LSL#1        ; R0 = (R3 << 1) - R2

反向减法可以在有符号或无符号数上进行。

　

RSC : 带借位的反向减法

(Reverse Subtraction with Carry)

RSC{条件}{S}  <dest>, <op 1>, <op 2>

 

                dest = op_2 - op_1 - !carry

同于SBC，但倒换了两个操作数的前后位置。

　

SBC : 带借位的减法

(Subtraction with Carry)

SBC{条件}{S}  <dest>, <op 1>, <op 2>

 

                dest = op_1 - op_2 - !carry

SBC做两个操作数的减法，把结果放置到目的寄存器中。它使用进位标志来表示借位，这样就可以做大于 32 位的减法。SUB和SBC生成进位标志的方式不同于常规，如果需要借位则清除进位标志。所以，指令要对进位标志进行一个非操作 - 在指令执行期间自动的反转此位。

　

SUB : 减法

(Subtraction)

SUB{条件}{S}  <dest>, <op 1>, <op 2>

 

                dest = op_1 - op_2

SUB用操作数one 减去操作数 two，把结果放置到目的寄存器中。操作数 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)

减法可以在有符号和无符号数上进行。

移位指令

       ARM 处理器组建了可以与数据处理指令(ADC、ADD、AND、BIC、CMN、CMP、EOR、MOV、MVN、ORR、RSB、SBC、SUB、TEQ、TST)一起使用的桶式移位器(barrel shifter)。你还可以使用桶式移位器影响在 LDR/STR 操作中的变址值。

译注：移位操作在 ARM 指令集中不作为单独的指令使用，它是指令格式中是一个字段，在汇编语言中表示为指令中的选项。如果数据处理指令的第二个操作数或者单一数据传送指令中的变址是寄存器，则可以对它进行各种移位操作。如果数据处理指令的第二个操作数是立即值，在指令中用 8 位立即值和 4 位循环移位来表示它，所以对大于255 的立即值，汇编器尝试通过在指令中设置循环移位数量来表示它，如果不能表示则生成一个错误。在逻辑类指令中，逻辑运算指令由指令中 S 位的设置或清除来确定是否影响进位标志，而比较指令的 S 位总是设置的。在单一数据传送指令中指定移位的数量只能用立即值而不能用寄存器。

下面是给不同的移位类型的六个助记符:

LSL  逻辑左移

  ASL  算术左移

  LSR  逻辑右移

  ASR  算术右移

  ROR  循环右移

  RRX  带扩展的循环右移

ASL和LSL是等同的，可以自由互换。

你可以用一个立即值(从 0 到 31)指定移位数量，或用包含在 0 和 31 之间的一个值的寄存器指定移位数量。

逻辑或算术左移

(Logical or Arithmetic Shift Left)

Rx, LSL #n    or

  Rx, ASL #n    or

  Rx, LSL Rn    or

  Rx, ASL Rn

接受 Rx 的内容并按用‘n’或在寄存器 Rn 中指定的数量向高有效位方向移位。最低有效位用零来填充。除了概念上的第 33 位(就是被移出的最小的那位)之外丢弃移出最左端的高位，如果逻辑类指令中 S 位被设置了，则此位将成为从桶式移位器退出时进位标志的值。

考虑下列:

MOV    R1, #12

  MOV    R0, R1, LSL#2

在退出时，R0 是 48。这些指令形成的总和是R0 = #12, LSL#2等同于 BASIC 的R0 = 12 << 2

逻辑右移

(Logical Shift Right)

Rx, LSR #n    or

  Rx, LSR Rn

它在概念上与左移相对。把所有位向更低有效位方向移动。如果逻辑类指令中 S 位被设置了，则把最后被移出最右端的那位放置到进位标志中。它同于 BASIC 的register = value >>> shift。

算术右移

(Arithmetic Shift Right)

Rx, ASR #n    or

  Rx, ASR Rn

类似于 LSR，但使用要被移位的寄存器(Rx)的第 31 位的值来填充高位，用来保护补码表示中的符号。如果逻辑类指令中 S 位被设置了，则把最后被移出最右端的那位放置到进位标志中。它同于 BASIC 的register = value >> shift。

循环右移

(Rotate Right)

Rx, ROR #n    or

  Rx, ROR Rn

循环右移类似于逻辑右移，但是把从右侧移出去的位放置到左侧，如果逻辑类指令中 S 位被设置了，则同时放置到进位标志中，这就是位的‘循环’。一个移位量为 32 的操作将导致输出与输入完全一致，因为所有位都被移位了 32个位置，又回到了开始时的位置!

带扩展的循环右移

(Rotate Right with extend)

Rx, RRX

这是一个 ROR#0 操作，它向右移动一个位置 - 不同之处是，它使用处理器的进位标志来提供一个要被移位的 33 位的数量。

 

乘法指令

 

指令格式

这两个指令与普通算术指令在对操作数的限制上有所不同:

1.  给出的所有操作数、和目的寄存器必须为简单的寄存器。

2.  你不能对操作数 2 使用立即值或被移位的寄存器。

3.  目的寄存器和操作数 1 必须是不同的寄存器。

4.  最后，你不能指定 R15 为目的寄存器。

MLA : 带累加的乘法

(Multiplication with Accumulate)

MLA{条件}{S}  <dest>, <op 1>, <op 2>, <op 3>

 

                dest = (op_1 * op_2) + op_3

MLA的行为同于MUL，但它把操作数 3 的值加到结果上。这在求总和时有用。

　

MUL : 乘法

(Multiplication)

MUL{条件}{S}  <dest>, <op 1>, <op 2>

 

                dest = op_1 * op_2

MUL提供 32 位整数乘法。如果操作数是有符号的，可以假定结果也是有符号的。

 

比较指令

 

指令格式

译注：CMP 和 CMP 是算术指令，TEQ 和 TST 是逻辑指令。把它们归入一类的原因是它们的 S 位总是设置的，就是说，它们总是影响标志位。

CMN : 比较取负的值

(Compare Negative)

CMN{条件}{P}  <op 1>, <op 2>

 

                status = op_1 - (- op_2)

CMN同于CMP，但它允许你与小负值(操作数 2 的取负的值)进行比较，比如难于用其他方法实现的用于结束列表的-1。这样与 -1 比较将使用:

CMN     R0, #1                  ; 把 R0 与 -1 进行比较

详情参照CMP指令。

　

CMP : 比较

(Compare)

CMP{条件}{P}  <op 1>, <op 2>

 

                status = op_1 - op_2

CMP允许把一个寄存器的内容如另一个寄存器的内容或立即值进行比较，更改状态标志来允许进行条件执行。它进行一次减法，但不存储结果，而是正确的更改标志。标志表示的是操作数 1 比操作数 2 如何(大小等)。如果操作数1 大于操作操作数 2，则此后的有 GT 后缀的指令将可以执行。
明显的，你不需要显式的指定S后缀来更改状态标志... 如果你指定了它则被忽略。

　

TEQ : 测试等价

(Test Equivalence)

TEQ{条件}{P}  <op 1>, <op 2>

 

                Status = op_1 EOR op_2

TEQ类似于TST。区别是这里的概念上的计算是 EOR 而不是 AND。这提供了一种查看两个操作数是否相同而又不影响进位标志(不象CMP那样)的方法。加上P后缀的TEQ还可用于改变 R15 中的标志(在 26-bit 模式中)。详情请参照 psr.html，在 32-bit 模式下如何做请参见这里。

　

TST : 测试位

(Test bits)

TST{条件}{P}  <op 1>, <op 2>

 

                Status = op_1 AND op_2

TST类似于CMP，不产生放置到目的寄存器中的结果。而是在给出的两个操作数上进行操作并把结果反映到状态标志上。使用TST来检查是否设置了特定的位。操作数 1 是要测试的数据字而操作数 2 是一个位掩码。经过测试后，如果匹配则设置 Zero 标志，否则清除它。象CMP 那样，你不需要指定S后缀。

TST     R0, #%1                 ; 测试在 R0 中是否设置了位 0。

 

分支指令

B : 分支

(Branch)

B{条件}  <地址>

B是最简单的分支。一旦遇到一个 B指令，ARM 处理器将立即跳转到给定的地址，从那里继续执行。

注意存储在分支指令中的实际的值是相对当前的 R15 的值的一个偏移量；而不是一个绝对地址。

它的值由汇编器来计算，它是 24 位有符号数，左移两位后有符号扩展为 32 位，表示的有效偏移为 26 位(+/- 32 M)。

在其他处理器上，你可能经常见到这样的指令:

OPT 1

  LDA &70

  CMP #0

  BEQ Zero

  STA &72

 .Zero RTS

(取自 Acorn Electron User Guide issue 1 page 213)

在 ARM 处理器上，它们将变成下面这些东西:

OPT     1

  ADR     R1, #&70

  LDR     R0, [R1]

  CMP     #0

  BEQ     Zero

  STR     R0, [R1, #2]

 .Zero

  MOV     PC, R14

这不是一个很好的例子，但你可以构想如何更好的去条件执行而不是分支。另一方面，如果你有大段的代码或者你的代码使用状态标志，那么你可以使用条件执行来实现各类分支: 这样一个单一的简单条件执行指令可以替代在其他处理器中存在的所有这些分支和跳转指令。

OPT     1

  ADR     R1, #&70

  LDR     R0, [R1]

  CMP     R0, #0

  STRNE   R0, [R1, #2]

  MOV     PC, R14

BL : 带连接的分支

 

(Branch with Link)

 

BL{条件}  <地址>

 

BL是另一个分支指令。就在分支之前，在寄存器 14 中装载上 R15 的内容。你可以重新装载 R14 到 R15 中来返回到在这个分支之后的那个指令，

 

它是子例程的一个基本但强力的实现。它的作用在屏幕装载器 2 (例子 4)中得以很好的展现...

 

.load_new_format

      BL     switch_screen_mode

      BL     get_screen_info

      BL     load_palette

 

    .new_loop

      MOV    R1, R5

      BL     read_byte

      CMP    R0, #255

      BLEQ   read_loop

      STRB   R0, [R2, #1]!

 

...在这里我们见到在装载器循环之前调用了三个子例程。接着，一旦满足了条件执行就在循环中调用了 read_byte子例程。

 

 

条件执行

 

　

 

ARM 处理器的一个非常特殊的特征是它的条件执行。我们指的不是基本的如果进位则分支，ARM 使这个逻辑阶段进一步深化为如果进位则 XXX- 这里的 XXX 是任何东西。

为了举例，下面是 Intel 8086 处理器分支指令的一个列表:

JA    Jump if Above

  JAE   Jump if Above or Equal

  JB    Jump if Below

  JBE   Jump if Below or Equal

  JC    Jump if Carry

  JCXZ  Jump if CX Zero (CX is a register that can be used for loop counts)

  JE    Jump if Equal

  JG    Jump if Greater than

  JGE   Jump if Greater than or Equal

  JL    Jump if Less than

  JLE   Jump if Less Than or Equal

  JMP   JuMP

  JNA   Jump if Not Above

  JNAE  Jump if Not Above or Equal

  JNB   Jump if Not Below

  JNBE  Jump if Not Below or Equal

  JNC   Jump if No Carry

  JNE   Jump if Not Equal

  JNG   Jump if Not Greater than

  JNGE  Jump if Not Greater than or Equal

  JNL   Jump if Not Less than

  JNLE  Jump if Not Less than or Equal

  JNO   Jump if Not Overflow

  JNP   Jump if Not Parity

  JNS   Jump if Not Sign

  JNZ   Jump if Not Zero

  JO    Jump if Overflow

  JP    Jump if Parity

  JPE   Jump if Parity Even

  JPO   Jump if Parity Odd

  JS    Jump if Sign

  JZ    Jump if Zero

 

条件码	助记符后缀	标志	含义
0000	EQ	Z置位	相等
0001	NE	Z清零	不相等
0010	CS	C置位	无符号数大于或等于
0011	CC	C清零	无符号数小于
0100	MI	N置位	负数
0101	PL	N清零	正数或零
0110	VS	V置位	溢出
0111	VC	V清零	未溢出
1000	HI	C置位Z清零	无符号数大于
1001	LS	C清零Z置位	无符号数小于或等于
1010	GE	N等于V	带符号数大于或等于
1011	LT	N不等于V	带符号数小于
1100	GT	Z清零且（N等于V）	带符号数大于
1101	LE	Z置位或（N不等于V）	带符号数小于或等于
1110	AL	忽略	无条件执行

 

 

• ldm/stm与栈的处理

 

1. 为什么需要多寄存器访问指令

 

1. ldr/str每周期只能访问4字节内存，如果需要批量读取、写入内存时太慢，解决方案是stm/ldm
2. ldm(load register mutiple)
3. stm（store register mutiple）

 

1. 举例（uboot start.S 537行）

 

1. stmia sp, {r0 - r12}
2. 将r0存入sp指向的内存处（假设为0x30001000）；然后地址+4（即指向0x30001004），将r1存入该地址；然后地址再+4（指向0x30001008），将r2存入该地址······直到r12内容放入（0x3001030），指令完成。

　　　一个访存周期同时完成13个寄存器的读写

 

!的作用:

 

ldmia r0, {r2 - r3}
ldmia r0！, {r2 - r3}

感叹号的作用就是r0的值在ldm过程中发生的增加或者减少最后写回到r0去，也就是说ldm时会改变r0的值。

 

^的作用:

ldmfd sp!, {r0 - r6, pc}
ldmfd sp!, {r0 - r6, pc}^

^的作用：在目标寄存器中有pc时，会同时将spsr写入到cpsr，一般用于从异常模式返回。

 

总结：批量读取或写入内存时要用ldm/stm指令。
各种后缀以理解为主，不需记忆，最常见的是stmia和stmfd。
谨记：操作栈时使用相同的后缀就不会出错，不管是满栈还是空栈、增栈还是减栈。

 

操作码	条件码助记符	标志	含义
0000	EQ	Z=1	相等
0001	NE(Not Equal)	Z=0	不相等
0010	CS/HS(Carry Set/High or Same)	C=1	无符号数大于或等于
0011	CC/LO(Carry Clear/LOwer)	C=0	无符号数小于
0100	MI(MInus)	N=1	负数
0101	PL(PLus)	N=0	正数或零
0110	VS(oVerflow set)	V=1	溢出
0111	VC(oVerflow clear)	V=0	没有溢出
1000	HI(HIgh)	C=1,Z=0	无符号数大于
1001	LS(Lower or Same)	C=0,Z=1	无符号数小于或等于
1010	GE(Greater or Equal)	N=V	有符号数大于或等于
1011	LT(Less Than)	N!=V	有符号数小于
1100	GT(Greater Than)	Z=0,N=V	有符号数大于
1101	LE(Less or Equal)	Z=1,N!=V	有符号数小于或等于
1110	AL	任何	无条件执行(默认)
1111	NV	任何	从不执行

 

参考： 

http://blog.csdn.net/tigerjibo/article/details/6186553

http://www.cnblogs.com/wxb20/p/6249580.html

http://blog.csdn.net/zqixiao_09/article/details/50726544