算术和逻辑指令

指令格式

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 的位 0 和 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 : 传送取反的值

(Move Negative)

  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 位的减法。SUBSBC 生成进位标志的方式不同于常规,如果需要借位则清除进位标志。所以,指令要对进位标志进行一个操作 - 在指令执行期间自动的反转此位。

  

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)
减法可以在有符号和无符号数上进行。

 


Return to assembler index
Copyright © 2001 Richard Murray