@C9Kodierungsschema der ARM-Kommandos (ARM250)

@C7

Und hier noch fr alle Bitbeier, die

 a) noch keine PRMs haben (oder ein sonstiges "schlaues" Buch besitzen) und
 b) zu faul sind, das selbst zu tun, aber
 c) es trotzdem wissen wollen,

 
 das Kodierungsschema der ARM-Kommandos (ARM250)


Alle Angaben wie immer ohne Gewhr und Pistole!
(Besitze nmlich auch noch keine Literatur dazu und habe es mir selber an
einen verregneten Sonntag ausgeknobelt)


Vorab die verwendeten Symbole und Erklrungen:

c = ConditionCode:: EQ,NE,CS (HS),CC (LO),MI,PL,VS,VC,HI,LS,GE,LT,GT,LE,AL,NV
S = S-Option:: nein, ja
P = P-Option:: nein, ja (0,15)
B = B-Option:: nein, ja
L = L-Option:: nein, ja
! = !-Option (Operationsadresse nach Operation in Basisadresse):: nein, ja
i = Offset VOR Speicherzugriff zur Basisadresse addieren:: nein, ja
^ = ^-Option:: nein, ja
+ = Vorzeichen:: minus, plus
p = Operation::  Register ( SHIFT Zahl ), Zahl
q = Operation::  Zahl, Register ( SHIFT Zahl )
a = Adressoffset | SWI-Nummer (24 Bit)
z = Zahl (12 Bit) 
b = Bitfolge (8 Bit)
> = Bitfolgen-ROR (4 Bit)
k = Stack-Mode:: DA, IA, DB, IB
d = Rd (4 Bit)
n = Rn (4 Bit)
m = Rm (4 Bit)
s = Rs (4 Bit)
l = Rlist (16 Bit: R<nr> = Bit<nr> )  
r = Barrel-Shift-Mode:: LSL (ASL),LSR,ASR,ROR (RRX => vvvv v = 0000 0)
v = Shift-Wert (5 Bit)
0 = 0
1 = 1
? = 0 (wird nicht ausgewertet)
u = 0 (undefiniert)


ANMERKUNGEN:

  ASL ist dasselbe wie LSL
  RRX wird codiert durch ROR #0
  OP2 = <reg> wird codiert durch <reg>,LSL #0
  OP2 weglassen wird codiert durch [Rn,#0] (nur in Gruppe 1 erlaubt)
  P wird codiert durch Rd=15 (dddd = Bit12-15)


GRUPPE 0

      flag   Command   Rn    Rd       Op2
      ====    ======  ====  ==== ===============
      
AND:: cccc 00p0  000S nnnn  dddd
             1                   >>>>  bbbb bbbb :Rd=Rn AND Konstante:
             0                   vvvv  vrr0 mmmm :Rd=Rn AND (Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Rd=Rn AND (Rm SHIFT Rs):

EOR:: cccc 00p0  001S nnnn  dddd
             1                   >>>>  bbbb bbbb :Rd=Rn EOR Konstante:
             0                   vvvv  vrr0 mmmm :Rd=Rn EOR (Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Rd=Rn EOR (Rm SHIFT Rs):

SUB:: cccc 00p0  010S nnnn  dddd
             1                   >>>>  bbbb bbbb :Rd=Rn SUB Konstante:
             0                   vvvv  vrr0 mmmm :Rd=Rn SUB (Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Rd=Rn SUB (Rm SHIFT Rs):

RSB:: cccc 00p0  011S nnnn  dddd
             1                   >>>>  bbbb bbbb :Rd=Rn RSB Konstante:
             0                   vvvv  vrr0 mmmm :Rd=Rn RSB (Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Rd=Rn RSB (Rm SHIFT Rs):

ADD:: cccc 00p0  100S nnnn  dddd
             1                   >>>>  bbbb bbbb :Rd=Rn ADD Konstante:
             0                   vvvv  vrr0 mmmm :Rd=Rn ADD (Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Rd=Rn ADD (Rm SHIFT Rs):

ADC:: cccc 00p0  101S nnnn  dddd
             1                   >>>>  bbbb bbbb :Rd=Rn ADC Konstante:
             0                   vvvv  vrr0 mmmm :Rd=Rn ADC (Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Rd=Rn ADC (Rm SHIFT Rs):

SBC:: cccc 00p0  110S nnnn  dddd
             1                   >>>>  bbbb bbbb :Rd=Rn SBC Konstante:
             0                   vvvv  vrr0 mmmm :Rd=Rn SBC (Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Rd=Rn SBC (Rm SHIFT Rs):

RSC:: cccc 00p0  111S nnnn  dddd
             1                   >>>>  bbbb bbbb :Rd=Rn RSC Konstante:
             0                   vvvv  vrr0 mmmm :Rd=Rn RSC (Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Rd=Rn RSC (Rm SHIFT Rs):

TST:: cccc 00p1  0001 nnnn  PPPP
             1                   >>>>  bbbb bbbb :Flags=Rn AND Konstante:
             0                   vvvv  vrr0 mmmm :Flags=Rn AND (Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Flags=Rn AND (Rm SHIFT Rs):

TEQ:: cccc 00p1  0011 nnnn  PPPP
             1                   >>>>  bbbb bbbb :Flags=Rn EOR Konstante:
             0                   vvvv  vrr0 mmmm :Flags=Rn EOR (Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Flags=Rn EOR (Rm SHIFT Rs):

CMP:: cccc 00p1  0101 nnnn  PPPP
             1                   >>>>  bbbb bbbb :Flags=Rn SUB Konstante:
             0                   vvvv  vrr0 mmmm :Flags=Rn SUB (Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Flags=Rn SUB (Rm SHIFT Rs):

CMN:: cccc 00p1  0111 nnnn  PPPP
             1                   >>>>  bbbb bbbb :Flags=Rn SUB-Konstante:
             0                   vvvv  vrr0 mmmm :Flags=Rn SUB-(Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Flags=Rn SUB-(Rm SHIFT Rs):

ORR:: cccc 00p1  100S nnnn  dddd
             1                   >>>>  bbbb bbbb :Rd=Rn ORR Konstante:
             0                   vvvv  vrr0 mmmm :Rd=Rn ORR (Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Rd=Rn ORR (Rm SHIFT Rs):

MOV:: cccc 00p1  101S ????  dddd
             1                   >>>>  bbbb bbbb :Rd=Konstante:
             0                   vvvv  vrr0 mmmm :Rd=Rm SHIFT v:
             0                   ssss  0rr1 mmmm :Rd=Rm SHIFT Rs:

BIC:: cccc 00p1  110S nnnn  dddd
             1                   >>>>  bbbb bbbb :Rd=Rn BIC Konstante:
             0                   vvvv  vrr0 mmmm :Rd=Rn BIC (Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Rd=Rn BIC (Rm SHIFT Rs):
                                 
MVN:: cccc 00p1  111S ????  dddd
             1                   >>>>  bbbb bbbb :Rd=NOT Konstante:
             0                   vvvv  vrr0 mmmm :Rd=NOT(Rm SHIFT v):
             0                   ssss  0rr1 mmmm :Rd=NOT(Rm SHIFT Rs):


GRUPPE 0a

      flag             Rd    Rn   Rs   Com.  Rm
      ====            ====  ==== ====  ==== ====

MUL:: cccc 000u  uu0S dddd  ???? ssss  1??1 mmmm :Rd=Rm*Rs:

MLA:: cccc 000u  uu1S dddd  nnnn ssss  1??1 mmmm :Rd=Rm*Rs+Rn:


GRUPPE 1

      flag Co-------m  Rn    Rd       Op2
      ==== ==       = ====  ==== ===============

STR:: cccc 01qi  +B!0 nnnn  dddd
             0                   zzzz  zzzz zzzz :Rd=>>Rn(+(-)z);Rn(+):
             1                   vvvv  vrru mmmm :Rd=>>Rn(+(-)Op2shft);Rn(+):

LDR:: cccc 01qi  +B!1 nnnn  dddd
             0                   zzzz  zzzz zzzz :Rd<<=Rn(+(-)z);Rn(+):
             1                   vvvv  vrru mmmm :Rd<<=Rn(+(-)Op2shft);Rn(+):


GRUPPE 2

      flag Com------m  Rn          Rlist
      ==== ===      = ====  ====================

STM:: cccc 100k  k^!0 nnnn  llll llll  llll llll :Rlist=>>Rn;Rn(+):

LDM:: cccc 100k  k^!1 nnnn  llll llll  llll llll :Rlist<<=Rn;Rn(+):


GRUPPE 2a

      flag Com             Adressoffset
      ==== ===   ===============================
      
B  :: cccc 101L  aaaa aaaa  aaaa aaaa  aaaa aaaa :PC+=a << 2:


GRUPPE 3

      flag Com             SWI-Nummer
      ==== ===   ===============================
      
SWI:: cccc 1111  aaaa aaaa  aaaa aaaa  aaaa aaaa :PC -->> SWI-Adr.:


GRUPPE 3a :11yy: (Koprozessorkommandos: yy <> 11 )


Das war's!

Wie man sieht, sind die 32 Bits fr die Kommandokodierung auf dem ARM
schon ganz schn ausgelastet.
 
Wer macht Vorschlge fr (kompatible) Weiterentwicklungen
des ARM-Prozessors: Branch-Pipeline, 64 Bit-Code, noch mehr Register,
oder wie oder was?

(Natrlich unter Nichtbercksichtigung konomischer Sachzwnge - allenfalls
solcher von technischer Natur.)

                                                                       R.Lorenz

