Übersicht

Der Abschitt Opcodes ist in zwei Teile gegliedert. Der erste Teil beschreibt die Opcodes, die mangels Unterlagen alle eigenständig ermittelt wurden.
Dank des IBM-Museums in Sindelfingen war es mir möglich, in den dortigen Unterlagen tatsächlich die offizielle Beschreibung des Maschinenbefehlssatzes zu finden. Diese ist im zweiten Teil aufgeführt.
Befehle oder Funktionen, die ich nicht oder nicht richtig ermittelt hatte, habe ich erkennbar durch (**) ergänzt bzw. korrigiert. Persönlich sind mir meine eigenen Mnemonics aber lieber, da sie doch die Befehle besser beschreiben.

Zusätzlich habe ich (ebenfalls durch das IBM-Museum) die detailierte Beschreibung der einzelnen Befehle gefunden. Es handelt sich dabei um einen Auszug aus einem "IBM CONFIDENTIAL"-Papier Kapitel 2.
Wer den Text wiedererkennt und die anderen Kapitel haben sollte, möge er sich unbedingt mit mir in Verbindung setzen!

Opcodes Teil 1

Alle Maschinenbefehle bzw. Mnemonics und deren Bedeutung wurden zu Fuß ermittelt, da überhaupt keine Unterlagen dazu aufzutreiben waren. Ich habe aber erfahren, daß die IBM intern Kurse hielt, in denen auch die Maschinensprache der IBM 5100/5110 inkl. Mnemonics behandelt wurde.

Übersicht der Maschinenbefehle für die IBM-Rechner 5100, 5110 und 5120

Hex    Binär                   Mnemonic           Beschreibung                                 
0xy0   0000xxxxyyyy0000   DEC2 Rx, Ry        Rx ¬ Ry - 2
0000   0000000000000000   HALT               Endlosschleife durch DEC2 R0, R0
0xy1   0000xxxxyyyy0001   DEC Rx, Ry         Rx ¬ Ry - 1
0xy2   0000xxxxyyyy0010   INC Rx, Ry         Rx ¬ Ry + 1
0xy3   0000xxxxyyyy0011   INC2 Rx, Ry        Rx ¬ Ry + 2
0xy4   0000xxxxyyyy0100   MOVE Rx, Ry        Rx ¬ Ry
0004   0000000000000100   NOP                führt ein MOVE R0, R0 aus
0xy5   0000xxxxyyyy0101   AND Rx, Ry         Rx ¬ Lo(Rx) AND Lo(Ry)
0xy6   0000xxxxyyyy0110   OR Rx, Ry          Rx ¬ Lo(Rx) OR Lo(Ry)
0xy7   0000xxxxyyyy0111   XOR Rx, Ry         Rx ¬ Lo(Rx) XOR Lo(Ry)
0xy8   0000xxxxyyyy1000   ADD Rx, Ry         Rx ¬ Rx + Lo(Ry)
0xy9   0000xxxxyyyy1001   SUB Rx, Ry         Rx ¬ Rx - Lo(Ry)
0xyA   0000xxxxyyyy1010   ADDH Rx, Ry        Lo(Rx) ¬ Hi(Rx) + Lo(Ry)
                                             Hi(Rx) ¬ Carry ($00 oder $01) (**)
0xyB   0000xxxxyyyy1011   ADDH2 Rx, Ry       (**)
                                             Lo(Rx) ¬ Hi(Rx) + Lo(Ry)
                                             Hi(Rx) ¬ Carry - 1 ($FF oder $00)
0xyC   0000xxxxyyyy1100   MHL Rx, Ry         Lo(Rx) ¬ Hi(Ry)
0xyD   0000xxxxyyyy1101   MLH Rx, Ry         Hi(Rx) ¬ Lo(Ry)
0iyE   0000iiiiyyyy1110   GETB Ry, i         Ry ¬ Datenbyte von Gerät i
0iyF   0000iiiiyyyy1111   GETADD Ry, i       Ry ¬ Ry + {0,2,4,6,8,A,C,E}
                                             je nach Datenbyte von Gerät i
                                             (eine Art Prioritätenkodierung) (**)

1ijj   0001iiiijjjjjjjj   CTRL i, #j         Schickt Steuerbyte j an Gerät i

2xii   0010xxxxiiiiiiii   MOVE Rx, i'        Rx ¬ (i')        i' = 2*i
3xii   0011xxxxiiiiiiii   MOVE i', Rx        (i') ¬ Rx        i' = 2*i

4ix0   0100iiiixxxx0000   PUTB i, (Rx)+      Schickt Datenbyte adressiert über Rx an Gerät i;
                                                  Rx ¬ Rx + 1
4ix1   0100iiiixxxx0001   PUTB i, (Rx)++     dto; Rx ¬ Rx + 2
4ix2   0100iiiixxxx0010   PUTB i, (Rx)+++    dto; Rx ¬ Rx + 3
4ix3   0100iiiixxxx0011   PUTB i, (Rx)++++   dto; Rx ¬ Rx + 4
4ix4   0100iiiixxxx0100   PUTB i, (Rx)-      dto; Rx ¬ Rx - 1
4ix5   0100iiiixxxx0101   PUTB i, (Rx)--     dto; Rx ¬ Rx - 2
4ix6   0100iiiixxxx0110   PUTB i, (Rx)---    dto; Rx ¬ Rx - 3
4ix7   0100iiiixxxx0111   PUTB i, (Rx)----   dto; Rx ¬ Rx - 4
4ix8   0100iiiixxxx1000   PUTB i, (Rx)       dto; Rx bleibt unverändert

5xy0   0101xxxxyyyy0000   MOVE (Ry)', Rx     (Ry) ¬ Rx; Ry ¬ Ry + 1
5xy1   0101xxxxyyyy0001   MOVE (Ry)+, Rx     (Ry) ¬ Rx; Ry ¬ Ry + 2
                          MOVE (Ry)+', Rx
                          MOVE (Ry)++, Rx
                          MOVE (Ry)~, Rx     (Ry) ¬ Rx; Ry ¬ Ry - 1
                          MOVE (Ry)-, Rx
                          MOVE (Ry)-~, Rx
                          MOVE (Ry)--, Rx
5xy8   0101xxxxyyyy1000   MOVE (Ry), Rx      (Ry) ¬ Rx

6xy0   0110xxxxyyyy0000   MOVB Rx, (Ry)+     Rx ¬ Lo((Ry)); Ry ¬ Ry + 1
...    ...                ...
6xy8   0110xxxxyyyy1000   MOVB Rx, (Ry)      Rx ¬ Lo((Ry))

7xy0   0111xxxxyyyy0000   MOVB (Ry)+, Rx     (Ry) ¬ Lo(Rx); Ry ¬ Ry + 1
...    ...                ...
7xy8   0111xxxxyyyy1000   MOVB (Ry), Rx      (Ry) ¬ Lo(Rx)

8xii   1000xxxxiiiiiiii   LBI Rx, #i         Rx ¬ i

9xii   1001xxxxiiiiiiii   CLR Rx, #i         Rx ¬ Rx AND NOT i;
                                             Löscht Bits in Rx, die in i gesetzt sind

Axii   1010xxxxiiiiiiii   ADD Rx, #(i+1)     Rx ¬ Rx + (i + 1)

Bxii   1011xxxxiiiiiiii   SET Rx, #i         Rx ¬ Rx OR i;
                                             Setzt Bits in Rx, die in i gesetzt sind

Cxy0   1100xxxxyyyy0000   SLE Rx, Ry         Skip, wenn Lo(Rx) £ Lo(Ry)
Cxy1   1100xxxxyyyy0001   SLT Rx, Ry         Skip, wenn Lo(Rx) < Lo(Ry)
Cxy2   1100xxxxyyyy0010   SE Rx, Ry          Skip, wenn Lo(Rx) = Lo(Ry)
Cx03   1100xxxx00000011   SZ Rx              Skip, wenn Lo(Rx) = 0
Cx04   1100xxxx00000100   SS Rx              Skip, wenn Lo(Rx) = $FF
Cxy5   1100xxxxyyyy0101   SBS Rx, Ry         Skip, wenn alle in Ry gesetzten Bits auch in Rx gesetzt sind
Cxy6   1100xxxxyyyy0110   SBC Rx, Ry         Skip, wenn alle in Ry gesetzten Bits in Rx gelöscht sind
Cxy7   1100xxxxyyyy0111   SBSH Rx, Ry        Skip, wenn alle in Ry gesetzten Bits in Hi(Rx) gesetzt sind
Cxy8   1100xxxxyyyy1000   SGT Rx, Ry         Skip, wenn Lo(Rx) > Lo(Ry)
Cxy9   1100xxxxyyyy1001   SGE Rx, Ry         Skip, wenn Lo(Rx) ³ Lo(Ry)
CxyA   1100xxxxyyyy1010   SNE Rx, Ry         Skip, wenn Lo(Rx) ¹ Lo(Ry)
Cx0B   1100xxxx00001011   SNZ Rx             Skip, wenn Lo(Rx) ¹ 0
Cx0C   1100xxxx00001100   SNS Rx             Skip, wenn Lo(Rx) ¹ $FF
CxyD   1100xxxxyyyy1101   SNBS Rx, Ry        Skip, wenn nicht alle in Ry gesetzten Bits auch in Rx gesetzt sind
CxyE   1100xxxxyyyy1110   SNBC Rx, Ry        Skip, wenn nicht alle in Ry gesetzten Bits in Rx gelöscht sind
CxyF   1100xxxxyyyy1111   SNBSH Rx, Ry       Skip, wenn nicht alle in Ry gesetzten Bits in Hi(Rx) gesetzt sind

Dx01   1101xxxx00000001   LWI Rx, #i         Rx ¬ i; entspricht MOVE Rx, (R0)+
iiii   iiiiiiiiiiiiiiii

Dxy0   1101xxxxyyyy0000   MOVE Rx, (Ry)'     Rx ¬ (Ry); Ry ¬ Ry + 1
...    ...                ...
Dxy8   1101xxxxyyyy1000   MOVE Rx, (Ry)      Rx ¬ (Ry)

E0xC   11100000xxxx1100   SHR Rx             Shiftet Lo(Rx) um 1 Bit nach rechts
                                             (**) Das niederwertigste Bit von Hi(Rx) wird zum höchstwertigen
                                             von Lo(Rx) (arithmetisches Schieben)
E0xD   11100000xxxx1101   ROR Rx             Rotiert Lo(Rx) um 1 Bit nach rechts
E0xE   11100000xxxx1110   ROR3 Rx            (**) Rotiert Lo(Rx) um 3 Bits nach rechts
E0xF   11100000xxxx1111   SWAP Rx            Vertauscht die Nibbles von Lo(Rx)
                                             (**) Rotiert Lo(Rx) um 4 Bits nach rechts

Eix0   1110iiiixxxx0000   GETB (Rx)+, i      Liest Datenbyte von Gerät i nach (Rx); Rx ¬ Rx + 1
...    ...                ...
Eix8   1110iiiixxxx1000   GETB (Rx), i       dto.

EixF   1110iiiixxxx1111   STAT Rx, i         Liest Status von Gerät i nach Rx

Fxii   1111xxxxiiiiiiii   SUB Rx, #(i+1)     Rx ¬ Rx - (i + 1)

Opcodes Teil 2

Die Maschinenbefehle bestehen stets aus einem 16-Bit Wort (bei der IBM ist das ein Halbwort). Die ersten vier Bits geben den Opcode an, die restlichen 12 hängen vom Opcode ab.

Übersicht

Opcode    2. Hexziffer   3. Hexziffer   4.Hexziffer     Befehle                            
  0            Rx            Ry            AM           ADD, ADDS1, ADDS2, AND, GETA, GETR,
                                                        HTL, LTH, MOVE, MVM1, MVM2, MVP1,
                                                        ORB, SUB, XOR
  1            DA                  Befehl               CTL
  2            Rx                  Adresse              LDHD
  3            Rx                  Adresse              STHD
  4            DA            Ry            M            PUTB
  5            Rx            Ry            M            STHI
  6            Rx            Ry            M            LDBI
  7            Rx            Ry            M            STBI
  8            Rx                  Datum                EMIT
  9            Rx                  Bitmaske             CLRI
  A            Rx                  Datum                ADDI
  B            Rx                  Bitmaske             SETI
  C            Rx            Ry            JM           Alle Sprungbefehle
  D            Rx            Ry            M            LDHI
  E            DA            Ry            SM           ROTR, SHFTR, GETB, GETRB
  F            Rx                  Datum                SUBI

Modifier

Name   Wert    Beschreibung                                                            
Normal modifier
 M     0 - 3   1 - 4 wird zum Inhalt von Ry addiert
       4 - 7   1 - 4 wird vom Inhalt in Ry subtrahiert
       > 7     Ry bleibt unverändert

ALU modifier
 AM    0 - F   wählt eine von 16 ALU-Funktionen aus

Jump modifier
 JM    0 - F   wählt eine von 16 bedingten Sprüngen aus

Special modifier
 SM    0 - B   nur GETB-Befehl: wie Modifier M
       C - F   wählt GETRB-Befehl aus (im Teil 1 STAT genannt)
               Bei Geräteadresse 0 werden die Rotier- und Schiebebefehle ausgewählt.

Alphabetische Auflistung

Mnemonic       Name                            Opcode   Kategorie               
ADD            Add                              0xy8    Arithmetisch Register
ADDI           Add immediate                    Axii    Arithmetisch Register
ADDS1          Add special 1                    0xyA    Arithmetisch Register
ADDS2          Add special 2                    0xyB    Arithmetisch Register
AND            And                              0xy5    Logisch Register
CLRI           Clear immediate                  9xii    Logisch Register
CTL            Control                          1ijj    I/O
EMIT           Emit byte                        8xii    Logisch Register
GETA           Get add                          0xyF    I/O
GETB           Get byte                         Eix?    I/O
GETR           Get to register                  0iyE    I/O
GETRB          Get byte to register             EixF    I/O
HTL            High to low                      0xyC    Register
JALL           Jump all ones                    Cx04    Jump
JALLM          Jump all masked                  Cxy5    Jump
JEQ            Jump equal                       Cxy2    Jump
JHAM           Jump high all masked             Cxy7    Jump
JHE            Jump high or equal               Cxy9    Jump
JHI            Jump high                        Cxy8    Jump
JHL            Jump high or low (not equal)     CxyA    Jump
JHSNM          Jump high some bit not masked    CxyF    Jump
JLE            Jump low or equal                Cxy0    Jump
JLO            Jump low                         Cxy1    Jump
JNO            Jump no ones                     Cx03    Jump
JNOM           Jump no ones masked              Cxy6    Jump
JSB            Jump some bits                   Cx0B    Jump
JSM            Jump some masked                 CxyE    Jump
JSN            Jump some not ones               Cx0C    Jump
JSNM           Jump some not masked             CxyD    Jump
LDBI           Load byte indirect               6xy?    Fetch&Store
LDHD           Load halfword direct             2xii    Fetch&Store
LDHI           Load halfword indirect           Dxy?    Fetch&Store
LTH            Low to high                      0xyD    Register
MOVE           Move register                    0xy4    Register
MVM1           Move minus 1                     0xy1    Register
MVM2           Move minus 2                     0xy0    Register
MVP1           Move plus 1                      0xy2    Register
MVP2           Move plus 2                      0xy3    Register
ORB            Or byte                          0xy6    Logisch Register
PUTB           Put byte                         4ix?    I/O
ROTR           Rotate register                  E0x?    Logisch Register
SETI           Set immediate                    Bxii    Logisch Register
SHFTR          Shift right                      E0xC    Logisch Register
STBI           Store byte indirect              7xy?    Fetch&Store
STHD           Store halfword direct            3xii    Fetch&Store
STHI           Store halfword indirect          5xy?    Fetch&Store
SUB            Subtract                         0xy9    Arithmetisch Register
SUBI           Subtract immediate               Fxii    Arithmetisch Register
XOR            Exclusive or                     0xy7    Logisch Register