6. Jämförelseinstruktioner

Dessa utför en aritmetisk eller logisk instruktion på två argument, kastar bort resultatet men sätter villkorsflaggorna. Vanligtvis används de för att testa datavärden utan att ändra dem innan en villkorlig förgrening exekveras.

6.1. Dokumentkonventioner

Notation: Rd, Rm, Rn betecknar ARM-register R0-R7. imm8 betecknar ett omedelbart värde med en bredd av 8 bitar.

6.2. Application Program Status Register (APSR)

Detta innehåller fyra bitar som testas av instruktionerna för villkorlig förgrening. Vanligtvis testar en villkorlig förgrening flera bitar, till exempel bge(LABEL). Betydelsen av villkorskoderna kan bero på om operanderna i en aritmetisk instruktion betraktas som signerade eller osignerade heltal. Sålunda antar bhi(LABEL) att osignerade tal bearbetades medan bgt(LABEL) antar signerade operander.

6.3. APSR-bitar

  • Z (noll)

Denna sätts om resultatet av en operation är noll eller om operanderna i en jämförelse är lika.

  • N (negativ)

Sätts om resultatet är negativt.

  • C (carry)

En addition sätter carry-flaggan när resultatet svämmar över ut ur MSB, till exempel vid addition av 0x80000000 och 0x80000000. På grund av tvåkomplementsaritmetikens natur är detta beteende omvänt vid subtraktion, där ett lån indikeras av att carry-biten är nollställd. Sålunda exekveras 0x10 - 0x01 som 0x10 + 0xffffffff vilket kommer att sätta carry-biten.

  • V (overflow)

Overflow-flaggan sätts om resultatet, betraktat som ett tvåkomplementstal, har ”fel” tecken i förhållande till operanderna. Att till exempel addera 1 till 0x7fffffff kommer att sätta overflow-biten eftersom resultatet (0x80000000), betraktat som ett tvåkomplementsheltal, är negativt. Observera att carry-biten i detta fall inte sätts.

6.4. Jämförelseinstruktioner

Dessa sätter APSR-flaggorna (Application Program Status Register) N (negativ), Z (noll), C (carry) och V (overflow).

  • cmp(Rn, imm8) Rn - imm8

  • cmp(Rn, Rm) Rn - Rm

  • cmn(Rn, Rm) Rn + Rm

  • tst(Rn, Rm) Rn & Rm

6.5. Villkorlig exekvering

Instruktionerna it och ite ger ett sätt att villkorligt exekvera från en till fyra efterföljande instruktioner utan behov av en etikett.

  • it(<condition>) If then

Exekvera nästa instruktion om <condition> är sant:

cmp(r0, r1)
it(eq)
mov(r0, 100) # runs if r0 == r1
# execution continues here

  • ite(<condition>) If then else

Om <condition> är sant, exekvera nästa instruktion, annars exekvera den efterföljande. Sålunda:

cmp(r0, r1)
ite(eq)
mov(r0, 100) # runs if r0 == r1
mov(r0, 200) # runs if r0 != r1
# execution continues here

Detta kan utökas till att styra exekveringen av upp till fyra efterföljande instruktioner: it[x[y[z]]] där x,y,z=t/e; t.ex. itt, itee, itete, ittte, itttt, iteee, osv.