ARM 指令集

kenson

算术和逻辑指令
ADC : 带进位的加法
7 M/ C. |8 h8 V+ }3 y5 D; F- E; {(Addition with Carry)

3 \+ h. K$ z; |9 z4 ^ADC{条件}{S}  <dest>, <op 1>, <op 2>
5 r# q, ^, U4 D4 u
                dest = op_1 + op_2 + carry
% O3 x$ W: \5 M8 P$ I1 s' RADC 将把两个操作数加起来，并把结果放置到目的寄存器中。它使用一个进位标志位，这样就可以做比 32 位大的加法。下列例子将加两个 128 位的数。
128 位结果: 寄存器 0、1、2、和 3
第一个 128 位数: 寄存器 4、5、6、和 7
第二个 128 位数: 寄存器 8、9、10、和 11。
7 r6 ^" P# q! V
6 \6 \0 B7 a$ S3 z) C  ADDS    R0, R4, R8              ; 加低端的字
  ADCS    R1, R5, R9              ; 加下一个字，带进位
1 V* O+ i, ~; \) R% u' F' U+ }  ADCS    R2, R6, R10             ; 加第三个字，带进位
6 b& x( N  ]0 `6 E5 v  ADCS    R3, R7, R11             ; 加高端的字，带进位
如果如果要做这样的加法，不要忘记设置 S 后缀来更改进位标志。


0 n1 ^4 C6 m0 g
ADD : 加法
(Addition)
7 A/ B- d; A, u$ y. e4 Q- ?, m
  e( E/ x( n5 K  nADD{条件}{S}  <dest>, <op 1>, <op 2>
4 q) s7 n- ?0 ?; u9 y2 k- q9 G3 c
: e# W3 S! ^% S6 t9 H8 R                dest = op_1 + op_2
1 F( T: ^5 H- ?5 |8 ~ADD 将把两个操作数加起来，把结果放置到目的寄存器中。操作数 1 是一个寄存器，操作数 2 可以是一个寄存器，被移位的寄存器，或一个立即值:

+ z* g+ M& ], ]& ^0 ~  ADD     R0, R1, R2              ; R0 = R1 + R2
  ADD     R0, R1, #256            ; R0 = R1 + 256
/ T; ~; E" S' m  ADD     R0, R2, R3,LSL#1        ; R0 = R2 + (R3 << 1)
加法可以在有符号和无符号数上进行。

　
( w% x5 a$ j: P) S$ G3 S
2 e3 M/ ]: P3 Y8 uAND : 逻辑与
/ W) c. X8 J, c(logical AND)

AND{条件}{S}  <dest>, <op 1>, <op 2>
5 m4 I1 W( p% F) J% ^) q+ }
                dest = op_1 AND op_2
AND 将在两个操作数上进行逻辑与，把结果放置到目的寄存器中；对屏蔽你要在上面工作的位很有用。 操作数 1 是一个寄存器，操作数 2 可以是一个寄存器，被移位的寄存器，或一个立即值:
. ]+ J  K" i# a% m3 ^: N
AND     R0, R0, #3              ; R0 = 保持 R0 的位 ０ 和 1，丢弃其余的位。
AND 的真值表(二者都是 1 则结果为 1):
! N! F) O$ }8 G4 z0 B0 o
Op_1   Op_2   结果
' Q7 `$ R  `0 ?* A
  0      0      0
& Z) [! Y8 r* t- F  {2 q) h% M  0      1      0
/ _) d2 O; ]: I9 k0 V  1      0      0
  1      1      1
9 x# Q# m0 K* N) o. I- ^　
& o& [: `5 [- D. e" z% @" m* yBIC : 位清除
(Bit Clear)

& \9 T2 o, K+ NBIC{条件}{S}  <dest>, <op 1>, <op 2>

                dest = op_1 AND (!op_2)
& e. C2 N/ I8 ?8 N/ N4 K2 tBIC 是在一个字中清除位的一种方法，与 OR 位设置是相反的操作。操作数 2 是一个 32 位位掩码(mask)。如果如果在掩码中设置了某一位，则清除这一位。未设置的掩码位指示此位保持不变。
2 y7 @; {% A6 _0 z+ a1 Y, d9 o6 i
7 ?5 ?7 S8 N% dBIC     R0, R0, #%1011          ; 清除 R0 中的位 0、1、和 3。保持其余的不变。
+ Q7 Z7 y- V8 \& L; lBIC 真值表 :

1 h5 d6 ]! Q" `  m4 mOp_1   Op_2   结果

  0      0      0
: ?" E9 E- I  j; N. U  0      1      0
( I/ Z& S- v, I. p1 ]& [. [  1      0      1
8 F; M. L' s+ Y9 [! O  1      1      0
译注：逻辑表达式为 Op_1 AND NOT Op_2
　

# g9 N$ G2 B# `# {: REOR : 逻辑异或
(logical Exclusive OR)

- Y- o8 D6 n3 AEOR{条件}{S}  <dest>, <op 1>, <op 2>
  b+ s7 D& K7 u2 B8 |
                dest = op_1 EOR op_2
EOR 将在两个操作数上进行逻辑异或，把结果放置到目的寄存器中；对反转特定的位有用。操作数 1 是一个寄存器，操作数 2 可以是一个寄存器，被移位的寄存器，或一个立即值:
* {4 V$ e, }  D* J. }9 ^
" [; O$ D. ^) l( @* b" I. tEOR     R0, R0, #3              ; 反转 R0 中的位 0 和 1
EOR 真值表(二者不同则结果为 1):
; Q8 @; A" q! f& ~$ a
Op_1   Op_2   结果
# }* @. x% y$ \/ y2 f( V, `4 X" V
  0      0      0
  0      1      1
7 T# J0 I. k0 F* A  1      0      1
  1      1      0
　
5 Q% ~/ Q8 j3 D5 f7 k. R3 ]MOV : 传送
- t4 M# L4 W+ s' ?, z- E(Move)

5 X8 P/ D8 S* u7 g- hMOV{条件}{S}  <dest>, <op 1>
9 S6 d4 |1 R" ?! j2 g2 e) H+ K! ]
2 P. M2 q' \0 E9 ~7 p8 g                dest = op_1
MOV 从另一个寄存器、被移位的寄存器、或一个立即值装载一个值到目的寄存器。你可以指定相同的寄存器来实现 NOP 指令的效果，你还可以专门移位一个寄存器:

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

+ S7 @* c6 N4 G, T) m8 v8 C, j  MOV     R0, R0, LSL#3           ; R0 = R0 * 8
如果 R15 是目的寄存器，将修改程序计数器或标志。这用于返回到调用代码，方法是把连接寄存器的内容传送到 R15:
/ |- D& k) P# j" o
  MOV     PC, R14                 ; 退出到调用者

  MOVS    PC, R14                 ; 退出到调用者并恢复标志位
                                    (不遵从 32-bit 体系)
　
% s6 o' v4 C, f3 X  A0 CMVN : 传送取反的值
  x3 Y8 t2 W5 i  A% M+ l(MoveNegative)

5 w# H( U! e0 S) f) Y' tMVN{条件}{S}  <dest>, <op 1>
4 z; s1 d, O% Z) z9 T
9 y8 l" c$ m7 q2 \# w( g                dest = !op_1
* t6 W5 ^  @7 M) `! VMVN 从另一个寄存器、被移位的寄存器、或一个立即值装载一个值到目的寄存器。不同之处是在传送之前位被反转了，所以把一个被取反的值传送到一个寄存器中。这是逻辑非操作而不是算术操作，这个取反的值加 1 才是它的取负的值:

  MVN     R0, #4                  ; R0 = -5
, Z0 A7 j# Q/ [% |# @$ j5 H8 Y
8 E; ~2 E+ F) C& m  y1 x  MVN     R0, #0                  ; R0 = -1
, d6 y+ ~7 i$ R5 S5 P9 I　
ORR : 逻辑或
(logical OR)

, J2 d8 p5 m2 {7 ^' A5 M2 sORR{条件}{S}  <dest>, <op 1>, <op 2>

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

ORR     R0, R0, #3              ; 设置 R0 中位 0 和 1
% y2 q# g- C7 ^& ]/ L: m( m) b% C  C- ]OR 真值表(二者中存在 1 则结果为 1):

Op_1   Op_2   结果
7 [' }3 p2 p, o  W3 c5 V$ G
  0      0      0
4 }5 F: j* c% ^: e$ z, L  0      1      1
( ~$ j, |# o1 ^  X, m  1      0      1
! M+ y( I) b( C" H  1      1      1
# D0 }( U, Q6 a* M' G, y" R　
RSB : 反向减法
  \) L/ {9 ^) s9 |* r' ~7 J(Reverse Subtraction)

8 g9 q: }3 B3 k# j9 }RSB{条件}{S}  <dest>, <op 1>, <op 2>
6 S6 G0 q& n. k
* H. g2 j6 \3 q$ h! |2 A- v                dest = op_2 - op_1
SUB 用操作数 two 减去操作数 one，把结果放置到目的寄存器中。操作数 1 是一个寄存器，操作数 2 可以是一个寄存器，被移位的寄存器，或一个立即值:
* [, g6 X# e/ G+ @9 `2 F5 B4 q
  RSB     R0, R1, R2              ; R0 = R2 - R1
  RSB     R0, R1, #256            ; R0 = 256 - R1
$ T9 h! |2 ^2 S, G, p9 O' N+ |  RSB     R0, R2, R3,LSL#1        ; R0 = (R3 << 1) - R2
反向减法可以在有符号或无符号数上进行。

　
# h2 c$ N  {. ~/ U' S
' I' }! d* s' H6 \$ A% MRSC : 带借位的反向减法
(Reverse Subtraction with Carry)
. C! ]- A2 J9 V3 w. a- v
" U- k+ V4 \  @RSC{条件}{S}  <dest>, <op 1>, <op 2>

                dest = op_2 - op_1 - !carry
9 A( J$ Y* p/ g% l9 v$ {同于 SBC，但倒换了两个操作数的前后位置。
- D  k3 U  k  p& n) Y, ]
0 w* j0 N/ I+ r5 y　

" z' V( P# F, u0 U) \) bSBC : 带借位的减法
3 V% [2 a& N+ N; o7 C(Subtraction with Carry)

SBC{条件}{S}  <dest>, <op 1>, <op 2>
" ~+ T6 D7 w* X& V7 f
% ~0 [. C7 [# |2 o                dest = op_1 - op_2 - !carry
+ W7 P3 i& B+ e! T$ P5 OSBC 做两个操作数的减法，把结果放置到目的寄存器中。它使用进位标志来表示借位，这样就可以做大于 32 位的减法。SUB 和 SBC 生成进位标志的方式不同于常规，如果需要借位则清除进位标志。所以，指令要对进位标志进行一个非操作 - 在指令执行期间自动的反转此位。
. z; `, \0 B6 x9 J5 I4 G
( I; y# P5 w: Z8 D( b+ C　

SUB : 减法
0 ]2 F5 y8 j3 Z0 R1 P6 R(Subtraction)
  p. w* o7 B1 U
+ j/ L' t3 w! G1 t9 w+ F  Z0 @SUB{条件}{S}  <dest>, <op 1>, <op 2>

' D' D' Z0 w. @* p1 l                dest = op_1 - op_2
) p" e+ k9 I: X6 y( d5 Q( zSUB 用操作数 one 减去操作数 two，把结果放置到目的寄存器中。操作数 1 是一个寄存器，操作数 2 可以是一个寄存器，被移位的寄存器，或一个立即值:
) ~/ t) |4 x: ~# M$ `8 V* O
  SUB     R0, R1, R2              ; R0 = R1 - R2
  SUB     R0, R1, #256            ; R0 = R1 - 256
) f4 J1 m+ V3 k  SUB     R0, R2, R3,LSL#1        ; R0 = R2 - (R3 << 1)
减法可以在有符号和无符号数上进行。
- j, b, K) j  l$ V/ N  d
5 H" m% W6 I. ?: u; {移位指令
& I( ]' B: O: F, |% _       ARM 处理器组建了可以与数据处理指令(ADC、ADD、AND、BIC、CMN、CMP、EOR、MOV、MVN、ORR、RSB、SBC、SUB、TEQ、TST)一起使用的桶式移位器(barrel shifter)。你还可以使用桶式移位器影响在 LDR/STR 操作中的变址值。

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

1 S  b6 t* |  T) J) B: R" j下面是给不同的移位类型的六个助记符:

  LSL  逻辑左移
  ASL  算术左移
- N& T3 n% m2 Q6 ^4 A; N2 A  LSR  逻辑右移
  ASR  算术右移
: f) F# n5 B. U8 ~; p0 X+ @& u" M  ROR  循环右移
  RRX  带扩展的循环右移
ASL 和 LSL 是等同的，可以自由互换。
: j1 z' ^1 q" q3 C7 r/ M- Q
你可以用一个立即值(从 0 到 31)指定移位数量，或用包含在 0 和 31 之间的一个值的寄存器指定移位数量。

逻辑或算术左移
3 R+ J& ~6 o$ x; U4 F(Logical or Arithmetic Shift Left)
% t1 g/ A/ G5 m# v
/ O5 s/ q2 P0 Y" S8 f; ^8 `) l$ t$ ^  Rx, LSL #n    or
  Rx, ASL #n    or
  Rx, LSL Rn    or
  Rx, ASL Rn
接受 Rx 的内容并按用‘n’或在寄存器 Rn 中指定的数量向高有效位方向移位。最低有效位用零来填充。除了概念上的第 33 位(就是被移出的最小的那位)之外丢弃移出最左端的高位，如果逻辑类指令中 S 位被设置了，则此位将成为从桶式移位器退出时进位标志的值。
+ z) r3 r# b4 `* R
+ v/ c9 [! x4 y考虑下列:
$ f# c# l) J0 |. f9 z8 N% r
. ]2 f6 a: l% ~0 v+ m  MOV    R1, #12
5 }, S: K5 a9 D' V! H  MOV    R0, R1, LSL#2
在退出时，R0 是 48。 这些指令形成的总和是 R0 = #12, LSL#2 等同于 BASIC 的 R0 = 12 << 2
* \( H: m% o$ k/ a7 p) _
逻辑右移
( N5 v1 R, Y4 V  f; a3 M(Logical Shift Right)

. B9 `+ O- ^# t# e7 ^  Rx, LSR #n    or
  Rx, LSR Rn
它在概念上与左移相对。把所有位向更低有效位方向移动。如果逻辑类指令中 S 位被设置了，则把最后被移出最右端的那位放置到进位标志中。它同于 BASIC 的 register = value >>> shift。

算术右移
; D+ H# g9 k# H7 v(Arithmetic Shift Right)

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

$ V' K: w" Q) s# [, d8 o$ z2 b循环右移
" x/ V& r" L2 g  n8 z(Rotate Right)
/ o/ J" q# r- F5 \# W0 l
  Rx, ROR #n    or
0 w8 @' E, T$ |. Y- q  Rx, ROR Rn
循环右移类似于逻辑右移，但是把从右侧移出去的位放置到左侧，如果逻辑类指令中 S 位被设置了，则同时放置到进位标志中，这就是位的‘循环’。一个移位量为 32 的操作将导致输出与输入完全一致，因为所有位都被移位了 32 个位置，又回到了开始时的位置!
3 d6 K* A$ c3 g
带扩展的循环右移
5 _  f9 P* F4 m( {+ ?3 P& o0 r(Rotate Right with extend)
0 J1 P' ~) f& D8 B+ D* X
Rx, RRX
" q5 U# H. r) F0 w1 }1 U这是一个 ROR#0 操作，它向右移动一个位置 - 不同之处是，它使用处理器的进位标志来提供一个要被移位的 33 位的数量。

, ^, k8 p6 |- X" D* n* N- l  d乘法指令
1 d8 m1 H0 J! y指令格式
( X2 ^) T% C5 x2 a. T& S
这两个指令与普通算术指令在对操作数的限制上有所不同:
4 m( z* N/ M/ k" t3 p4 n& U4 c
/ v  G# R( n9 ~8 D4 U, h给出的所有操作数、和目的寄存器必须为简单的寄存器。
你不能对操作数 2 使用立即值或被移位的寄存器。
目的寄存器和操作数 1 必须是不同的寄存器。
最后，你不能指定 R15 为目的寄存器。
MLA : 带累加的乘法
: D6 W9 I# b: H9 Q) V(Multiplication with Accumulate)

MLA{条件}{S}  <dest>, <op 1>, <op 2>, <op 3>
) V; K$ Q; V1 p1 z3 g
+ \. l6 u! k- l( g* f% Y7 `                dest = (op_1 * op_2) + op_3
" o% V6 E7 s/ X9 iMLA 的行为同于 MUL，但它把操作数 3 的值加到结果上。这在求总和时有用。

　
8 t: f' ~; r) {+ I0 e
MUL : 乘法
(Multiplication)
% T$ M3 ]* u5 K: ^9 e' k
' g% A  y3 F$ J. L& _0 y9 z: GMUL{条件}{S}  <dest>, <op 1>, <op 2>
& g8 q5 F9 E3 I2 W) P
                dest = op_1 * op_2
& }3 B5 L$ Y" b5 E0 O% vMUL 提供 32 位整数乘法。如果操作数是有符号的，可以假定结果也是有符号的。
9 ?1 E8 U4 s9 T; e0 R% F
比较指令
5 L3 n  _/ S+ b1 q3 v& U指令格式

; x# f1 @: |9 ?译注：CMP 和 CMP 是算术指令，TEQ 和 TST 是逻辑指令。把它们归入一类的原因是它们的 S 位总是设置的，就是说，它们总是影响标志位。
5 ]+ U! J; t! J2 i
CMN : 比较取负的值
(Compare Negative)
0 C1 E9 S3 S" D# R* n
" X7 W3 {  H* j/ SCMN{条件}{P}  <op 1>, <op 2>
3 [; m- ]8 y8 A  |+ s( o
4 E5 z7 k' V3 Q6 G& J$ v                status = op_1 - (- op_2)
CMN 同于 CMP，但它允许你与小负值(操作数 2 的取负的值)进行比较，比如难于用其他方法实现的用于结束列表的 -1。这样与 -1 比较将使用:
6 s1 C/ W4 k. |0 K
* {1 @0 n( H0 y9 E. X4 ^$ R4 X9 _CMN     R0, #1                  ; 把 R0 与 -1 进行比较
详情参照 CMP 指令。
0 ]" V5 ]2 f& z  [" O3 B
$ m8 B7 w! W, g1 d; w3 s( C　
! n5 t1 O3 J$ Z6 I% n
/ x% b. F1 i' j  a* mCMP : 比较
* Y& j* e. D' R% t$ S2 O(Compare)

( J6 D7 @$ ]0 x; F  T) qCMP{条件}{P}  <op 1>, <op 2>

9 L( `# C  M* N, `% F& Y                status = op_1 - op_2
CMP 允许把一个寄存器的内容如另一个寄存器的内容或立即值进行比较，更改状态标志来允许进行条件执行。它进行一次减法，但不存储结果，而是正确的更改标志。标志表示的是操作数 1 比操作数 2 如何(大小等)。如果操作数 1 大于操作操作数 2，则此后的有 GT 后缀的指令将可以执行。
明显的，你不需要显式的指定 S 后缀来更改状态标志... 如果你指定了它则被忽略。
* l/ r6 y8 c$ r, g
1 d) ]9 z! G) r& Y( V$ i. R. h8 R　

TEQ : 测试等价
+ z- V. z& [# S; F' F(Test Equivalence)
$ A1 ^0 v* u7 p$ l5 @
! Z; [( q1 i2 L; l7 d" T9 aTEQ{条件}{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 模式下如何做请参见这里。

. H- v6 x5 e' _0 w3 f1 p* y% U8 l　
5 ]1 N  \  C9 e* K  {
& S- D* z: M! K0 J/ w  gTST : 测试位
) R) j7 e. Z" E3 L/ J3 F7 t1 a0 f7 {1 k(Test bits)
) X5 Q& Y! B; x6 H5 F
TST{条件}{P}  <op 1>, <op 2>
$ s; y/ m- S2 N" d) l* j: r0 n9 Y
' X4 n  r. q6 E1 |8 c  Q                Status = op_1 AND op_2
7 p; K7 I: |3 I; b9 ~TST 类似于 CMP，不产生放置到目的寄存器中的结果。而是在给出的两个操作数上进行操作并把结果反映到状态标志上。使用 TST 来检查是否设置了特定的位。操作数 1 是要测试的数据字而操作数 2 是一个位掩码。经过测试后，如果匹配则设置 Zero 标志，否则清除它。象 CMP 那样，你不需要指定 S 后缀。

TST     R0, #%1                 ; 测试在 R0 中是否设置了位 0。
- O6 G, c0 z$ M( K1 t5 W
, @" _& g! E2 t9 C9 a- |/ t5 A分支指令
5 S4 R" i- p1 h6 nB : 分支
$ h% g* @3 A0 \1 D6 B(Branch)
: t# ?, j" c% y. WB{条件}  <地址>
B 是最简单的分支。一旦遇到一个 B 指令，ARM 处理器将立即跳转到给定的地址，从那里继续执行。
注意存储在分支指令中的实际的值是相对当前的 R15 的值的一个偏移量；而不是一个绝对地址。
. Z% |% a4 W! f2 e它的值由汇编器来计算，它是 24 位有符号数，左移两位后有符号扩展为 32 位，表示的有效偏移为 26 位(+/- 32 M)。
' v2 t  Z: {5 ]在其他处理器上，你可能经常见到这样的指令:
+ L4 L( J9 ?) w; i/ d6 j# }% ]OPT 1
  LDA &70
! T3 X) l1 k- r& H, V! [6 P! T# h6 Y: W  CMP #0
8 _; P$ ?4 C1 E2 G' J  BEQ Zero
  STA &72
2 e2 k" W. Y# i( V .Zero RTS
(取自 Acorn Electron User Guide issue 1 page 213)
在 ARM 处理器上，它们将变成下面这些东西:
OPT     1
  ADR     R1, #&70
! ]% d  c# o) D, X& c& q9 n  LDR     R0, [R1]
; c$ ~, _3 d* n  CMP     #0
2 m3 _! I* G; S! ]( E4 a  BEQ     Zero
1 `* U# C) e8 Z; z( A- \  STR     R0, [R1, #2]
.Zero
+ W: B/ p& c) K, n  MOV     PC, R14
这不是一个很好的例子，但你可以构想如何更好的去条件执行而不是分支。另一方面，如果你有大段的代码或者你的代码使用状态标志，那么你可以使用条件执行来实现各类分支: 这样一个单一的简单条件执行指令可以替代在其他处理器中存在的所有这些分支和跳转指令。
OPT     1
  ADR     R1, #&70
6 L, y2 a5 P. P) C3 ]0 V. c  LDR     R0, [R1]
% _, _( u& r* T0 P. R0 h% u- y  CMP     R0, #0
+ o. {% c  G: I; T) V9 j: [4 ^  STRNE   R0, [R1, #2]
  MOV     PC, R14
8 I$ U( @3 i  V  w+ F# EBL : 带连接的分支
& X! m6 Z$ q% k$ t) U/ d
& V' u5 i& U7 ^0 \. C(Branch with Link)
$ d& U* F& m) A3 [9 P% s
BL{条件}  <地址>

BL 是另一个分支指令。就在分支之前，在寄存器 14 中装载上 R15 的内容。你可以重新装载 R14 到 R15 中来返回到在这个分支之后的那个指令，
+ I/ j' n$ P$ Z
* m' G4 S' `6 ?% A% `3 p, j它是子例程的一个基本但强力的实现。它的作用在屏幕装载器 2 (例子 4)中得以很好的展现...
9 o3 R) S3 W# H! a1 O  v; b
6 n! V3 z8 e. e* @+ O2 ~.load_new_format
! G4 `7 Q+ T- M9 l      BL     switch_screen_mode
3 Q# \9 k! m) s0 `) C0 g: {6 x      BL     get_screen_info
      BL     load_palette

    .new_loop
5 {# T$ ~. ^% d5 ^, I5 j      MOV    R1, R5
      BL     read_byte
      CMP    R0, #255
  O* ^: q( f* e; z4 V% E( P      BLEQ   read_loop
      STRB   R0, [R2, #1]!

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

条件执行
" z7 w$ l3 ?# l! u
　

3 x7 ~  r6 N- ?( e& [8 y
: i: D1 \7 F/ [8 zARM 处理器的一个非常特殊的特征是它的条件执行。我们指的不是基本的如果进位则分支，ARM 使这个逻辑阶段进一步深化为如果进位则 XXX- 这里的 XXX 是任何东西。
为了举例，下面是 Intel 8086 处理器分支指令的一个列表:
JA    Jump if Above
  JAE   Jump if Above or Equal
+ D2 M2 d8 V& E" H4 C( I  JB    Jump if Below
% s; O$ t6 p: |! b# f/ r0 E- \  JBE   Jump if Below or Equal
  JC    Jump if Carry
" M8 K& `8 E- l9 b' V& L- }7 m  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
/ g' z9 \6 j* s! e# t  JL    Jump if Less than
/ p8 o+ V7 ~' W$ s5 O  JLE   Jump if Less Than or Equal
  JMP   JuMP
  JNA   Jump if Not Above
' Q5 }5 A+ H! Q- b  JNAE  Jump if Not Above or Equal
7 ^* G$ a6 q6 o5 _$ ?3 b  JNB   Jump if Not Below
: k  D7 `  G* }, [2 F  JNBE  Jump if Not Below or Equal
3 A% ~1 S4 |! |# @! W  JNC   Jump if No Carry
/ B, M0 h. k& n$ Y5 x7 t  JNE   Jump if Not Equal
! n5 K; X; z2 J  _  JNG   Jump if Not Greater than
0 C' q7 ^" L% A: C. [  JNGE  Jump if Not Greater than or Equal
$ I- N  P, N8 F/ v. {  JNL   Jump if Not Less than
" E6 U* [, Z+ F* N  JNLE  Jump if Not Less than or Equal
$ Y( \- Z1 P8 R5 [, ^  JNO   Jump if Not Overflow
  JNP   Jump if Not Parity
7 p1 O/ p5 ~: ?0 h; Z2 f  JNS   Jump if Not Sign
  JNZ   Jump if Not Zero
  p: e7 L/ \# _+ e& p1 ^0 |  JO    Jump if Overflow
& u0 j- X  W4 y% i' n" u, D5 x  JP    Jump if Parity
+ g/ B: l; w$ h- p% z$ {, B/ J  JPE   Jump if Parity Even
  JPO   Jump if Parity Odd
  JS    Jump if Sign
  JZ    Jump if Zero

80386 添加了:
  JECXZ Jump if ECX Zero

7 u& d: x; T! n+ R; L' \/ F5 `作为对比，ARM 处理器只提供了:
" w: r+ b( W" z, p/ lB     分支
  BL    带连接的分支

5 u+ p, J5 D+ h3 N但 ARM 提供了条件执行，你可以不受这个表面上不灵活的方式的限制:
BEQ   Branch if EQual
' J5 p/ \$ y2 m5 Z; [5 x1 z  BNE   Branch if Not Equal
* l* w7 e8 ~0 i1 v, {  g  BVS   Branch if oVerflow Set
9 I2 ?! K  |& D. f( O  BVC   Branch if oVerflow Clear
  BHI   Branch if HIgher
  BLS   Branch if Lower or the Same
1 m8 C2 E8 S" r3 H" B  BPL   Branch if PLus
  BMI   Branch if MInus
  BCS   Branch if Carry Set
  BCC   Branch if Carry Clear
# C1 M7 Z0 d6 c9 b) w0 D  BGE   Branch if Greater than or Equal
8 O" l. y+ Q% P6 x) U1 F  BGT   Branch if Greater Than
* Y1 |3 D* d2 M, p: a  BLE   Branch if Less than or Equal
, Q3 ]! |; W1 G$ k3 M  BLT   Branch if Less Than

$ b3 s3 D* x9 w: Q8 M, s  BLEQ  Branch with Link if EQual
  ....
  BLLT  Branch with Link if Less Than
  @4 k% k) e1 D" d6 `2 p
9 h6 G* w1 `5 o# q4 y, p( D还有两个代码，
' I1 F# W* e* v" S. v4 r$ _/ ?) eAL - ALways，缺省条件所以不须指定
6 |5 T: `4 I9 `) |
+ }, A3 b9 l9 u8 m) \   
! q) b4 X3 }/ s5 `4 f: t; P) oNV - NeVer，不是非常有用。你无论如何不要使用这个代码...
% Y9 C8 u! _- [; P4 Y/ f, |" Q  F

( x" u( q4 Z0 A0 [1 s当你发现所有 Bxx 指令实际上是同一个指令的时候，紧要关头就到了。
6 }6 m" |" L* J6 ?+ ~8 L接着你会想，如果你可以在一个分支指令上加上所有这些条件，那么对一个寄存器装载指令能否加上它们? 答案是可以。
下面是可获得的条件代码的列表:
EQ : 等于
如果一次比较之后设置了 Z 标志。
% p) U% v8 L0 P; ~　
8 K( v9 r& X0 }1 O' G$ `8 K0 uNE : 不等于
" k9 F& F" v6 J; J如果一次比较之后清除了 Z 标志。
　
VS : 溢出设置
如果在一次算术操作之后设置了 V 标志，计算的结果不适合放入一个 32bit 目标寄存器中。
　
2 c+ i  [. I$ B% h* IVC : 溢出清除
如果清除了 V 标志，与 VS 相反。
　
4 q! W* @6 H# Z5 O6 V5 sHI : 高于(无符号)
2 j$ G6 i9 U+ H, ~# }如果一次比较之后设置了 C 标志并清除了 Z 标志。
0 |) E. _6 G% _- \　
+ W' ^8 X  F' A* O' XLS : 低于或同于(无符号)
* Z: m6 x! J/ u1 W2 z5 W  J+ |" C. v如果一次比较操作之后清除了 C 标志或设置了 Z 标志。
　
' N4 A& Y' w9 r( `PL : 正号
. n, H& [4 ]% ?, q如果一次算术操作之后清除了 N。出于定义‘正号’的目的，零是正数的原因是它不是负数...
　
MI : 负号
5 D, P6 y' u) k* R' H; a如果一次算术操作之后设置了 N 标志。
" v, m/ l& N9 m, B1 w  ?: X　
2 E% {/ g% P+ I9 r; eCS : 进位设置
如果一次算术操作或移位操作之后设置了 C 标志，操作的结果不能表示为 32bit。你可以把 C 标志当作结果的第 33 位。
　
( o' X) v$ X: U2 }3 x: S  o7 _CC : 进位清除
" p  y0 C: K: I; X与 CS 相反。
6 _# W6 a" ^& m. e, N　
, r' m4 r. M: V9 Z& N' C1 J. J" B7 i6 KGE : 大于或等于(有符号)
如果一次比较之后...
设置了 N 标志并设置了 V 标志
或者...
清除了 N 标志并清除了 V 标志。
4 S$ Q5 _, y8 W2 P" H0 K. X5 n　
* w. f0 r6 j/ @9 g" hGT : 大于(有符号)
. H# D! U& w5 u如果一次比较之后...
设置了 N 标志并设置了 V 标志
或者...
清除了 N 标志并清除了 V 标志
2 k0 g& @8 p) A2 J6 @; D. X: b并且...
( j1 T/ g$ n& q! ^- A1 R5 Z9 P清除了 Z 标志。
　
, m' j# e% q) m+ GLE : 小于或等于(有符号)
如果一次比较之后...
设置了 N 标志并清除了 V 标志
或者...
清除了 N 标志并设置了 V 标志
并且...
设置了 Z 标志。
% N2 X8 M0 v3 n  o% S　
, q, M, ^! O% n9 rLT : 小于(有符号)
如果一次比较之后...
设置了 N 标志并清除了 V 标志。
  A! J- v2 `" g; S4 k$ \: P或者...
清除了 N 标志并设置了 V 标志。
& t. u+ B. c. R( v0 }0 Q　
0 M# \0 J  g! r3 L; [; u, m$ hAL : 总是
缺省条件，所以不用明显声明。
　
NV : 从不
- _% f% ]" d# B* t2 x5 S- h3 m不是特别有用，它表示应当永远不执行这个指令。是穷人的 NOP。
. a& ^+ k4 b9 K/ O# O包含 NV 是为了完整性(与 AL 相对)，你不应该在你的代码中使用它。
9 p2 }2 s' U- R" L& K8 S有一个在最后的条件代码 S，它以相反的方式工作。当用于一个指令的时候，导致更改状态标志。这不是自动发生的 - 除非这些指令的目的是设置状态。例如:
) o- b: T$ w8 W  r  ADD     R0, R0, R1

2 ]1 a+ p1 B/ W1 Q$ `9 O  ADDS    R0, R0, R1

  ADDEQS  R0, R0, R1
6 O5 x- d" k$ F  c! T9 v
第一个例子是一个基本的加法(把 R1 的值增加到 R0)，它不影响状态寄存器。
第二个例子是同一个加法，只不过它导致更改状态寄存器。
* O+ W9 F8 u1 O9 @; J, P
4 @8 [4 h5 V8 t3 [  ~最后一个例子是同一个加法，更改状态寄存器。不同在于它是一个有条件的指令。只有前一个操作的结果是 EQ (如果设置了 Z 标志)的时候它才执行。

; Z1 c2 Q' H( A' m下面是条件执行的一个工作中的例子。你把寄存器 0 与存储在寄存器 10 中内容相比较。
+ C8 x9 x7 k  y
2 p! a  W3 A# I8 U% ?) L8 {如果不等于 R10，则调用一个软件中断，增加它并分支回来再次做这些。否则清除 R10 并返回到调用它的那部分代码(它的地址存储在 R14)。
, ]) p% A& `  U, D
! y2 |, J9 H5 f; |$ a\ 条件执行的一个例子

$ p7 ^. f0 d3 s3 h6 u) K( G  .loop                           ; 标记循环开始位置
  CMP     R0, R10                 ; 把 R0 与 R10 相比较
$ G  a$ z/ m4 F! c. [: M5 S  SWINE   &40017                  ; 不等于: 调用 SWI &40017
0 i! S: J2 T: z6 Q5 \  ADDNE   R0, R0, #1              ;         向 R0 加 1
3 |" b2 r9 e" z2 m" _  BNE     loop                    ;         分支到 'loop'
/ }* y3 M8 l9 u0 s. E  MOV     R10, #0                 ; 等于  : 设置 R10 为零
/ E$ z3 K* f, B5 `  LDMFD   R13!, {R0-R12,PC}       ;         返回到调用者
8 i8 X* n  {0 @5 ^$ o! D  y* a
5 C  _7 e8 s! C  R- M, k注解:
SWI 编号就象我写的这样。在 RISC OS 下，它是给 Econet_DoImmediate 的编号。不要字面的接受它，这只是一个例子!

- {1 O  V' A4 [9 `' M   
你可能以前没见过 LDMFD，它从栈中装载多个寄存器。在这个例子中，我们从一个完全正式的栈中装载 R0 至 R12 和 R14。关于寄存器装载和存储的更多信息请参阅 str.html。
) X8 _$ b5 `8 k4 S4 M6 h
   
. X2 J3 ~! G: }( Z% O我说要装载 R14。那么为什么要把它放入 PC 中? 原因是此时 R14 存储的值包含返回地址。我们也可以采用:
4 R7 x- `- r3 v" h, I$ e* u. KLDMFD      R13!, {R0-R12,R14}
" s9 |7 E2 @3 m3 y
+ A/ c  ?7 j8 F: D/ x9 x& w6 Z% U    MOV        PC, R14
但是直接恢复到 PC 中可以省略这个 MOV 语句。
1 ]' c5 Z& E% D
   
- a1 ]. a2 l2 ~& D6 k2 ^! Q: w' B+ f最后，这些寄存器很有可能被一个 SWI 调用所占用(依赖于在调用期间执行的代码)，所以你最好把你的重要的寄存器压入栈中，以后在恢复它们。
5 `2 e2 \& q" N! [  B. {( ]6 }

9 m6 O0 _: s3 D, h            
. S8 M5 X- V) T+ m& a- RSWI 指令

$ I9 L5 `9 p- y  ~, U                     
: h$ m" J1 h! W. dSWI : 软件中断

: Y9 _& y+ k; P$ H0 L* `(Software Interrupt)

SWI{条件}  <24 位编号>

指令格式
这是一个简单的设施，但可能是最常用的。多数操作系统设施是用 SWI 提供的。没有 SWI 的 RISC OS 是不可想象的。
$ U( f8 E, _' Z
# j% Q& L7 ~& `! \4 |$ m6 R, MNava Whiteford 解释了 SWI 是如何工作的(最初在 Frobnicate issue 12?)...

+ y7 n8 x! @& K　

SWI 是什么?
5 l$ }& E; G: R2 |) L- D- n) U
6 x& u- {* k1 D- q0 P" Q0 H  zSWI 表示 Software Interrupt。在 RISC OS  中使用 SWI 来访问操作系统例程或第三方生产的模块。许多应用使用模块来给其他应用提供低层外部访问。
SWI 的例子有:

5 m0 N6 g, {" m
7 ^& m: b) @; b3 _9 H文件器 SWI，它辅助读写磁盘、设置属性等。
0 K  E$ d7 ]# U
+ |5 |+ L0 C% g9 ~# ^$ M5 [& X   
打印机驱动器 SWI，用来辅助使用打印并行端口。
' _( {) D" y9 X: u# K; X3 k' f
/ U, \8 D/ L$ J; c3 F& C   
, G' U+ l: |3 \FreeNet/Acorn TCP/IP 协议栈 SWI，用 TCP/IP 协议在 Internet 上发送和接收数据。

% T( H; ^. l6 p% X% }/ k在以这种方式使用的时候，SWI 允许操作系统拥有一个模块结构，这意味着用来建立完整的操作系统的所需的代码可以被分割成许多小的部分(模块)和一个模块处理程序(handler)。


当 SWI 处理程序得到对特定的例程编号的一个请求的时候，它找到这个例程的位置并执行它，并传递(有关的)任何数据。
6 l, T' g$ K  f( H. V& @: a
% u3 U0 o3 n) h, U9 ?
% I7 x4 e6 Z6 B/ t$ }, I1 c% J它是如何工作的?
# y2 o; t+ X8 t8 e' q: b5 I8 g
首先查看一下如何使用它。一个 SWI 指令(汇编语言)看起来如下:
SWI &02
8 [' z2 [! r, h# y
4 {8 P( b3 P  T/ y+ d或
4 C4 G$ C5 d- S! ~3 SSWI "OS_Write0"
8 {$ i  L7 p! v1 j( B# F
这些指令实际上是相同的，将被汇编成相同的指令。唯一的不同是第二个指令使用一个字符串来表示 SWI 编号 &02。
在使用采用了字符串编号的程序的时候，在执行之前首先查找这个字符串。
在这里我们不想处理字符串，因为它不能给出它要进行什么的一个真实表示。它们通常用于增进一个程序的清晰程度，但不是实际执行的指令。
/ H/ [( Q. Q: W* s
让我们再次看一下第一个指令:

) o( {  q! O8 C+ p' {  e3 V7 {SWI &02

- X7 D8 U* {* N' a, m+ c$ t这是什么意思? 字面的意思是进入 SWI 处理程序并传递值 &02。在 RISC OS 中这意味着执行编号是 &02 的例程。
它是如何这么作的? 它如何传递 SWI 编号和进入 SWI 处理程序?


如果你查看内存的开始 32 字节(位于 0-&1C)并反汇编它们(查开实际的 ARM 指令)你将见到如下:


　
2 f9 N9 {5 V$ ~# v6 v' G

0 q& B7 Y9 N+ W2 @# `0 E& k地址       内容               反汇编
00000000 : 0..? : E5000030 : STR     R0,[R0,#-48]
00000004 : .ó?? : E59FF31C : LDR     PC,&00000328
00000008 : .ó?? : E59FF31C : LDR     PC,&0000032C
  D: J) A% U; W0000000C : .ó?? : E59FF31C : LDR     PC,&00000330
00000010 : .ó?? : E59FF31C : LDR     PC,&00000334
' d7 R* a6 W4 Q$ X. K4 b00000014 : .ó?? : E59FF31C : LDR     PC,&00000338
+ L1 s; i* s7 Q3 ~6 {. N- ]! G00000018 : .ó?? : E59FF31C : LDR     PC,&0000033C
0000001C :  2?? : E3A0A632 : MOV     R10,#&3200000

1 z4 G+ p0 R( z" h3 g让我们仔细看一下。
除了第一个和最后一个指令之外(它们是特殊情况)你见到的都是把一个新值装载到 PC (程序计数器)的指令，它们告诉计算机到哪里去执行下一个指令。
, {' n: a6 a! S

还展示了这个值是从内存中的一个地址接受来的。(你可以在 !Zap 主菜单上使用“Read Memory”选项去自己查看一下。)
+ |+ R" y% R$ k5 j; w
( ^0 c& G0 U7 Q6 K5 m+ ~$ S
' K; T. Z9 P/ Z  X# G0 y5 W( B这看起来好象与 SWI 没多少关系，下面做进一步的说明。

$ U0 x, D/ x5 U2 J$ l
一个 SWI 所做的一切就是把模式改变成超级用户并设置 PC 来执行在地址 &08 处的下一个指令!
- E! Z2 `# l  W. I. i. W

把处理器转换到超级用户模式会切换掉两个寄存器 r13 和 r14 并用 r13_svc 和 r14_svc 替换它们。

8 R- _; ^# X; c% @+ S" h! h
% A9 H9 K8 C0 I在进入超级用户模式的时候，还把 r14_svc 设置为在这个 SWI 指令之后的地址。
( `2 O5 T0 Y1 h7 A
4 E/ _/ _0 B4 H# {
这个实际上就象一个连接到地址 &08 的分支指令(BL &08)，但带有用于一些数据(SWI 编号)的空间。


* h  o$ B! ]& @9 [象我说过的那样，地址 &08 包含跳转到另一个地址的一个指令，就是实际的 SWI 程序的地址!

/ r. }* U* I1 \+ Y$ p/ F- W
$ l$ a2 E$ ^, Q6 ^9 ^3 B此时你可能会想“稍等一会! 还有 SWI 编号呢?”。实际上处理器忽略这个值本身。SWI 处理程序使用传递来的 r14_svc 的值来获取它。

9 u8 }$ X: L. y3 S0 X
下面是完成它的步骤(在存储寄存器 r0-r12 之后):

% Q9 C# n1 p  \" f8 b& ?
它从 r14 中减去 4 来获得 SWI 指令的地址。

   
! l$ Y- H' B: ?" X* _把这个指令装载到一个寄存器。

8 f6 X  H6 w0 q   
清除这个指令的高端 8 位，去掉了 OpCode 而只剩下的 SWI 编号。
& i0 Z/ I# R& B- {9 x8 X
$ `, p- \8 N; k   
8 S. X& e/ ^. \$ c2 y5 V/ p# b使用这个值来找到要被执行的代码的例程的地址(使用查找表等)。
! Q1 |; z/ w, o" n# o/ Y" ^) d
5 f" @) o$ N) c   
恢复寄存器 r0-r12。
, S4 k' J) s/ m9 K0 p: e" y
1 y8 i, o1 X# s   
' [8 ~; n) a( Q5 Q; A- o4 v使处理器离开超级用户模式。

* j5 i+ Y7 p, G   
" o8 ~) Q: Y7 i; A8 f4 T; t跳转到这个例程的地址。

* p# V6 q7 g6 u9 t5 A
容易吧! ;)
下面是一个例子，来自 ARM610 datasheet:

* l9 \! E" |! K; q. k( M0 d4 [  Q
0x08 B Supervisor
& w- M% p3 g2 s4 G8 M7 Z- {
EntryTable
3 B" ?+ I# }8 }2 P) D/ ] DCD ZeroRtn
; G5 \% {+ S3 v  E. n DCD ReadCRtn
DCD WriteIRtn

: f/ @0 d7 ?/ \: D( X2 ^0 Q7 U ...

/ A( w" l* U0 }2 c8 b8 eZero   EQU 0
; |! W: L% i. ~0 o/ SReadC  EQU 256
' q0 Q4 V: S1 h3 q' gWriteI EQU 512
+ K7 F! }# F1 q+ R
; SWI 包含需要的例程在位 8-23 中和数据(如果有的话)在位 0-7 中。
; 假定 R13_svc 指向了一个合适的栈

STMFD R13, {r0-r2 , R14}
; 保存工作寄存器和返回地址。
LDR R0,[R14,#-4]
! d2 f5 b+ u& I6 J" a5 t1 r7 Q ; 得到 SWI 指令。
5 ^1 O, ?5 x. K" m6 FBIC R0,R0, #0xFF000000
8 t) m1 I0 t0 A" b9 P, H ; 清除高端的 8 位。
$ G$ l0 W! H8 f4 b# _; o# O( xMOV R1, R0, LSR #8
9 H/ c: Z$ \2 X- s/ b  k, c& ? ; 得到例程偏移量。
ADR R2, EntryTable
; 得到入口表(EntryTable)的开始地址。
LDR R15,[R2,R1,LSL #2]
; 分支到正确的例程
7 _  d- \" t! N$ ~& B/ Y) y3 A
' p$ C7 s/ `; W: `5 o8 x1 t( SWriteIRtn
; 写 R0 中的位 0 - 7 中的字符。
5 y5 p2 C1 Z4 T# V8 |3 n1 K* n
.............
( k4 T% O2 w. q- \: z( a+ `8 } LDMFD R13, {r0-r2 , R15}^
; 恢复工作空间，并返回、恢复处理器模式和标志。
# M) T) i! p2 U: K$ x$ o
这就是 SWI 指令的基本处理步骤。

kenson

ARM指令集不必要会编但一定要懂，如果你要学UBOOT的话那一定要看了。

kenson

其实ARM指令集不是好难，基本上都是这些变化。

hotdll

楼上大神，看这些指令，感觉都是汇编指令？

kenson

hotdll 发表于 2016-12-5 08:49
4 }4 R  J! S, V8 a楼上大神，看这些指令，感觉都是汇编指令？

就是汇编啊