Lista rozkazów
Przejdź do nawigacji
Przejdź do wyszukiwania
Objaśnienia symboli użytych w liście rozkazów
| Oznaczenie | Znaczenie |
|---|---|
| A, B, C | numer rejestru uniwersalnego wskazany w polach A, B lub C rozkazu |
| b | argument bajtowy rozkazu (bity 8÷15 rozkazu) |
| D | bit pośredniego adresowania |
| IC | licznik rozkazów |
| M | zawartość następnego słowa za słowem podstawowym rozkazu |
| N | argument efektywny rozkazu. W zależności od rozkazu może oznaczać liczbę stałoprzecinkową, informację logiczną, lub adres. |
| N* | argument efektywny rozkazu bajtowego. Adres bajtu. |
| MOD | modyfikator, ustawiany przez rozkazy MD |
| P | wskaźnik przeskoku. Gdy P=1 to IC := IC + długość rozkazu + 1 |
| R0 ÷ R7 | zawartość rejestrów uniwersalnych |
| rA, rB, rC | argumenty rozkazu związane z odpowiednimi polami rozkazu |
| R/A/, R/B/, R/C/ | rejestr uniwersalny o numerze wskazanym wartością odpowiedniego pola rozkazu |
| R/A/i | i-ty bit rejestru uniwersalnego wskazanego wartością pola rozkazu |
| R/A/i÷j | bity i...j rejestru uniwersalnego wskazanego wartością pola rozkazu |
| RZ | rejestr zgłoszeń przerwań |
| RS | rejestr stanu systemu |
| RM | rejestr masek przerwań |
| Q | wzkaźnik pracy systemu: Q=0 oznacza pracę systemu operacyjnego, Q=1 pracę programu użytkowego |
| := | przypisanie wartości |
| S/x/ | zawartość komórki pamięci o adresie x |
| S/x;NB/ | zawartość komórki pamięci o adresie x w bloku NB |
| ∧ | operator logiczny AND (iloczyn) |
| ∨ | operator logiczny OR (suma) |
| operator logiczny XOR (różnica symetryczna) | |
| x | operator logiczny NOT (negacja) |
| >=< | porównanie (w rezultacie ustawia odpowiednio wskaźniki) |
| ≡ | tożsamość |
| ≠ | różne |
| « | przesunięcie o jeden bit w lewo |
| » | przesunięcie o jeden bit w prawo |
| »n» | przesunięcie cykliczne o n bitów w prawo |
Lista Rozkazów
Uwagi do listy rozkazów:
- Rozkazy nielegalne (dozwolone tylko przy pracy systemu operacyjnego) oznaczono kolorem czerwonym
- W poniższej tabeli za n w nazwie rozkazu należy podstawić przyrostek zależny od lokalizacji argumentu normalnego i bitu D-modyfikacji (patrz: Wykonanie rozkazu):
- R dla C≠0, D=0
- A dla C≠0, D=1
- D dla C=0, D=0
- I dla C=0, D=1
- Jeśli C=0, to zamiast rC występuje M (słowo następne za słowem rozkazowym)
- argument rB nie występuje w przypadku B=0 lub gdy rozkaz nie może ulegać B-modyfikacji
- Jeżeli w opisie rozkazu nie jest wymieniony licznik rozkazów IC, to przyjmujemy zawsze, że rozkaz ten powoduje zwiększenie IC o długość rozkazu.
- Jeżeli w wykonaniu operacji używana jest zawartość IC, to przyjmuje się, że jest ona równa pierwszemu adresowi następnego rozkazu.
| Lp. | Mnemonik | Źródłosłów | Opis | Treść | Ustaw wskaźniki |
|---|---|---|---|---|---|
| 1 | LWn, rA, rC, rB | Load Word | Umieść w rejestrze | R/A/ := N | |
| 2 | LWT, rA, T | Load to Word paremeTer | Umieść krótki argument | R/A/ := T | |
| 3 | LWS, rA, T | Load to Word Short | Pobierz względnie | R/A/ := S/IC+T/ | |
| 4 | LDn, rC, rB | Load Double word | Umieść w R1 i R2 | [R1, R2] := [S/N/, S/N+1/] | |
| 5 | LFn, rC, rB | Load Floating point number | Umieść w R1, R2 i R3 | [R1, R2, R3] := [S/N/, S/N+1/, S/N+2/] | |
| 6 | LAn, rC, rB | Load All registers | Umieść w R1, R2, ..., R7 | [R1, R2, ..., R7] := [S/N/, S/N+1/, ..., S/N+6/] | |
| 7 | LLn, rC, rB | Load Last three registers | Umieść w R5, R6 i R7 | [R5, R6, R7] := [S/N/, S/N+1/, S/N+2/] | |
| 8 | LSn, rA, rC, rB | Load Selective | Umieść przez maskę w R7 | R/A/ := [R/A/∧R7] ∨ [N∧R7] | |
| 9 | TWn, rA, rC, rB | Take Word | Umieść według NB | R/A/ := S/N,NB/ | |
| 10 | TDn rC, rB | Take Double word | Pobierz do R1 i R2 | [R1, R2] := [S/N;NB/, S/N+1;NB/] | |
| 11 | TFn, rC, rB | Take Floating point number | Pobierz do R1, R2, R3 | [R1, R2, R3] := [S/N;NB/, S/N+1;NB/, S/N+2;NB/] | |
| 12 | TAn, rC, rB | Take to All registers | Pobierz do R1, R2, ..., R7 | [R1, R2, ..., R7] := [S/N;NB/, S/N+1;NB/, ..., S/N+6;NB/] | |
| 13 | TLn, rC, rB | Take to Last three registers | Pobierz do R5, R6, R7 | [R5, R6, R7] := [S/N;NB/, S/N+1;NB/, S/N+2;NB/] | |
| 14 | RWn, rA, rC, rB | Remember Word | Pamiętaj rejestr | S/N/ := R/A/ | |
| 15 | RWS, rA, T | Remember Word Short | Pamiętaj względnie | S/IC+T/ := R/A/ | |
| 16 | RDn, rC, rB | Remember Double word | Pamiętaj R1 i R2 | [S/N/, S/N+1/] := [R1, R2] | |
| 17 | RFn, rC, rB | Remember Floating point number | Pamiętaj R1, R2, R3 | [S/N/, S/N+1/, S/N+2/] := [R1, R2, R3]] | |
| 18 | RAn, rC, rB | Remember All registers | Pamiętaj R1, R2, ..., R7 | [S/N/, S/N+1/, ..., S/N+6/] := [R1, R2, ..., R7] | |
| 19 | RLn, rC, rB | Remember Last three registers | Pamiętaj R5, R6, R7 | [S/N/, S/N+1/, S/N+2/] := [R5, R6, R7] | |
| 20 | PWn, rA, rC, rB | Put Word | Pamiętaj według NB | S/N;NB/ := R/A/ | |
| 21 | PDn, rC, rB | Put Double word | Prześlij R1 i R2 | [S/N;NB/, S/N+1;NB/] := [R1, R2] | |
| 22 | PFn, rC, rB | Put Floating point number | Prześlij R1, R2 i R3 | [S/N;NB/, S/N+1;NB/, S/N+2;NB/] := [R1, R2, R3] | |
| 23 | PAn, rC, rB | Put All registers | Prześlij R1, R2, ..., R7 | [S/N;NB/, S/N+1;NB/, ..., S/N+6;NB/] := [R1, R2, ..., R7] | |
| 24 | PLn, rC, rB | Put Last three registers | Prześlij R5, R6, R7 | [S/N;NB/, S/N+1;NB/, S/N+2;NB/] := [R5, R6, R7] | |
| 25 | RZn, rC, rB | Remember Zero | Zeruj słowo w pamięci | S/N/ := 0 | |
| 26 | RIn, rA, rC, rB | Remember and Increment | Umieść w pamięci i dodaj 1 | S/R/A// := N R/A/ := R/A/ + 1 | |
| 27 | AWn, rA, rC, rB | Add Word | Dodaj | R/A/ := R/A/ + N | Z, M, V, C |
| 28 | AWT, rA, T | Add to Word parameTer | Dodaj krótki argument | R/A/ := R/A/ + T | Z, M, V, C |
| 29 | ACn, rA, rC, rB | Add word with Carry | Dodaj z przeniesieniem | R/A/ := R/A/ + N + C | Z, M, V, C |
| 30 | SWn, rA, rC, rB | Subtract Word | Odejmij | R/A/ := R/A/ - N | Z, M, V, C |
| 31 | CWn, rA, rC, rB | Compare Word | Porównaj | R/A/ >=< N | L, E, G |
| 32 | CWT, rA, T | Compare Word to parameTer | Porównaj z krótkim arg. | R/A/ >=< T | L, E, G |
| 33 | NGA, rA | NeGation Arithmetic | Neguj arytmetycznie | R/A/ := R/A/+1 (-R/A/) | Z, M, V, C |
| 34 | NGC, rA | NeGation with Carry | Neguj z przeniesieniem | R/A/ := R/A/+C | Z, M, V, C |
| 35 | ADn, rC, rB | Add Double word | Dodaj liczby długie | [R1, R2] := [R1, R2] + [S/N/, S/N+1/] | Z, M, V, C |
| 36 | SDn, rC, rB | Subtract Double word | Odejmij liczby długie | [R1, R2] := [R1, R2] - [S/N/, S/N+1/] | Z, M, V, C |
| 37 | MWn, rC, rB | Multiply Words | Mnóż | [R1, R2] := R2 × S/N/ | Z, M, V |
| 38 | DWn, rC, rB | Divide Words | Dziel | R2 := [R1, R2] : S/N/ R1 := reszta |
Z, M |
| 39 | AFn, rC, rB | Add Floating point numbers | Dodaj liczby zmiennoprzecinkowe | [R1, R2, R3] := [R1, R2, R3] + [S/N/, S/N+1/, S/N+2/] | Z, M, C |
| 40 | SFn, rC, rB | Subtract Floating point numbers | Odejmij liczby zmennorzecinkowe | [R1, R2, R3] := [R1, R2, R3] - [S/N/, S/N+1/, S/N+2/] | Z, M, C |
| 41 | MFn, rC, rB | Multiply Floating point numbers | Pomnóż liczby zmennorzecinkowe | [R1, R2, R3] := [R1, R2, R3] × [S/N/, S/N+1/, S/N+2/] | Z, M, C |
| 42 | DFn, rC, rB | Divide Floating point numbers | Podziel liczby zmennorzecinkowe | [R1, R2, R3] := [R1, R2, R3] : [S/N/, S/N+1/, S/N+2/] | Z, M, C |
| 43 | NRF | NoRmalize Floating point number | Normalizuj | [R1, R2, R3] := znormalizowana liczba zmiennoprzecinkowa | |
| 44 | ORn, rA, rC, rB | Or Register | Dodaj logicznie | R/A/ := R/A/ ∨ N | Z |
| 45 | OMn, rA, rC, rB | Or Memory | Dodaj logicznie do pamięci | S/N;NB/ := S/N;NB/ ∨ R/A/ | Z |
| 46 | NRn, rA, rC, rB | aNd in Register | Pomnóż logicznie | R/A/ := R/A/ ∧ N | Z |
| 47 | NMn, rA, rC, rB | aNd in Memory | Pomnóż logicznie do pamięci | S/N;NB/ := S/N;NB/ ∧ R/A/ | Z |
| 48 | XRn, rA, rC, rB | eXclusive or in Register | Różnica symetryczna | R/A/ := R/A/ |
Z |
| 49 | XMn, rA, rC, rB | eXclusive or in Memory | Różnica symetryczna w pamięci | S/N;NB/ := S/N;NB/ |
Z |
| 50 | ERn, rA, rC, rB | Erase bits in Register | Zeruj bity | R/A/ := R/A/ ∧ N | Z |
| 51 | EMn, rA, rC, rB | Erase bits in Memory | Zeruj bity w pamięci | S/N;NB/ := S/N;NB/ ∧ R/A/ | Z |
| 52 | CLn, rA, rC, rB | Compare Logically | Porównaj logicznie | R/A/ >=< N | L, E, G |
| 53 | NGL, rA | NeGate Logically | Neguj logicznie | R/A/ := R/A/ | Z |
| 54 | SXU, rA | Set X as Upper bit | Ustaw wskaźnik X według R/A/0 | X := R/A/0 | X |
| 55 | SXL, rA | Set X as Lower bit | Ustaw wskaźnik X według R/A/15 | X := R/A/15 | X |
| 56 | SLZ, rA | Shift Left add Zero | Przesuń w lewo | R/A/ « [R/A/,0] Y := R/A/0 |
Y |
| 57 | SLY, rA | Shift Left add Y | Przesuń w lewo z Y | R/A/ « [R/A/,Y] Y := R/A/0 |
Y |
| 58 | SLX, rA | Shift Left add X | Przesuń w lewo z X | R/A/ « [R/A/,X] Y := R/A/0 |
Y |
| 59 | SVZ, rA | Shift left, check oVerflow, add Zero | Przesuń w lewo, ustaw V | R/A/ « [R/A/,0] Y := R/A/0 |
Y, V |
| 60 | SVY, rA | Shift left, check oVerflow, add Y | Przesuń w lewo z Y, ustaw V | R/A/ « [R/A/,Y] Y := R/A/0 |
Y, V |
| 61 | SVX, rA | Shift left, check oVerflow, add X | Przesuń w lewo z X, ustaw V | R/A/ « [R/A/,X] Y := R/A/0 |
Y, V |
| 62 | SRZ, rA | Shift Right, add Zero | Przesuń w prawo | [0,R/A/] R/A/» Y := R/A/15 |
Y |
| 63 | SRY, rA | Shift Right, add Y | Przesuń w prawo z Y | [Y,R/A/] R/A/» Y := R/A/15 |
Y |
| 64 | SRX, rA | Shift Right, add X | Przesuń w prawo z X | [X,R/A/] R/A/» Y := R/A/15 |
Y |
| 65 | SHC, rA, T | SHift Cyclic | Przesuń cyklicznie | R/A/»T»R/A/ T - liczba przesunięć (4-bitowa!) | |
| 66 | LBn, rA, rC, rB | Load Byte | Umieść bajt | R/A/8÷15 := S/N*;NB/ | |
| 67 | RBn, rA, rC, rB | Remember Byte | Pamiętaj bajt | S/N*;NB/ := R/A/8÷15 | |
| 68 | ZLB, rA | Zero to Left Byte | Zeruj bajt lewy | R/A/0÷7 := 0 | |
| 69 | ZRB, rA | Zero to Right Byte | Zeruj bajt prawy | R/A/8÷15 := 0 | |
| 70 | CBn, rA, rB, rC | Compare Byte | Porównaj bajt | R/A/8÷15 >=< S/N*;NB/ | L, E, G |
| 71 | UJn, rC, rB | Unconditional Jump | Skocz | IC := N | |
| 72 | UJS, T | Unconditional Jump Short | Skocz względnie | IC := IC + T | |
| 73 | LJn, rC, rB | Link Jump | Skocz ze śladem | S/N/ := IC IC := N + 1 | |
| 74 | RJn, rA, rC, rB | Return Jump | Skocz ze śladem w rejestrze | R/A/ := IC IC := N | |
| 75 | JNn, rC, rB | Jump if Not equal | Skocz gdy E | Jeśli E=0 to IC := N | |
| 76 | JLn, rC, rB | Jump if Less | Skocz przy L | Jeśli L=1 to IC := N | |
| 77 | JLS, T | Jump if Less Short | Skocz względnie przy L | Jeśli L=1 to IC := IC + T | |
| 78 | JEn, rC, rB | Jump if Equal | Skocz przy E | Jeśli E=1 to IC := N | |
| 79 | JES, T | Jump if Equal Short | Skocz względnie przy E | Jeśli E=1 to IC := IC + T | |
| 80 | JGn, rC, rB | Jump if Greater | Skocz przy G | Jeśli G=1 to IC := N | |
| 81 | JGS, T | Jump if Greater Short | Skocz względnie przy G | Jeśli G=1 to IC := IC + T | |
| 82 | JZn, rC, rB | Jump if Zero | Skocz przy Z | Jeśli Z=1 to IC := N | |
| 83 | JMn, rC, rB | Jump if Minus | Skocz przy M | Jeśli M=1 to IC := N | |
| 84 | JVS, T | Jump if oVerflow Short | Skocz względnie przy V | Jeśli V=1 to IC := IC + T V := 0 |
V |
| 85 | JCS, T | Jump if Carry Short | Skocz względnie przy C | Jeśli C=1 to IC := IC + T | |
| 86 | JYS, T | Jump if Y Short | Skocz względnie przy Y | Jeśli Y=1 to IC := IC + T | |
| 87 | JXS, T | Jump if X Short | Skocz względnie przy X | Jeśli X=1 to IC := IC + T | |
| 88 | TRB, rA, T | parameTer to Register and Branch | Dodaj arg. krótki i przeskocz | R/A/ := R/A/ + T Jeśli R/A/=0 to P := 1 |
P |
| 89 | IRB, rA, T | Increment Register and Branch | Dodaj 1, skocz względnie | R/A/ := R/A/ + 1 Jeśli R/A/≠0 to IC := IC + T | |
| 90 | DRB, rA, T | Decrease Register and Branch | Odejmij 1, skocz względnie | R/A/ := R/A/ - 1 Jeśli R/A/≠0 to IC := IC + T | |
| 91 | BBn, rA, rC, rB | Branch on Bits | Porównaj logicznie iloczyn | Jeśli R/A/∧N ≡ N to P := 1 | P |
| 92 | BMn, rA, rC, rB | Branch on bits in Memory | Porównaj logicznie iloczyn w pamięci | Jeśli S/N;NB/ ∧ R/A/ ≡ R/A/ to P := 1 | P |
| 93 | BSn, rA, rC, rB | Branch Selective | Porównaj logicznie przez maskę | Jeśli R/A/ ∧ R7 ≡ N ∧ R7 to P := 1 | P |
| 94 | BCn, rA, rC, rB | Branch if not all Conditions | Porównaj logicznie iloczyn | Jeśli R/A/ ∧ N ≠ N to P := 1 | P |
| 95 | BNn, rA, rC, rB | Branch if No conditions | Przeskocz gdy iloczyn=0 | Jeśli R/A/ ∧ N ≡ 0 to P := 1 | P |
| 96 | BRC, b | Branch if not Right Conditions | Badaj prawy bajt R0 | Jeśli R08÷15 ∧ b ≠ b to P := 1 | P |
| 97 | BLC, b | Branch if not Left Conditions | Badaj lewy bajt R0 | Jeśli R00÷7 ∧ b ≠ b to P := 1 | P |
| 98 | IBn, rC, rB | Increment and Branch | Następnik pamięci | S/N/ := S/N/ + 1 Jeśli S/N/=0 to P := 1 |
P |
| 99 | MDn, rC, rB | MoDify next instruction | Modyfikuj | MOD := N | |
| 100 | NOP | No OPeration | Nic nie rób | traktowany przez assembler jako UJS, 0 | |
| 101 | RKY, rA | Read KeYboard | Czytaj klucze | R/A/ := klucze KB pulpitu technicznego | |
| 102 | RIC, rA | Read Instruction Counter | Czytaj licznik rozkazów | R/A/ := IC | |
| 103 | ISn, rA, rC, rB | Install Semaphore | Ustaw semafor | Jeśli S/N;NB/ ∧ R/A/ ≡ R/A/ to P := 1 Jeśli S/N;NB/ ∧ R/A/ ≠ R/A/ to S/N;NB/ := S/N;NB/ ∨ R/A/ |
P |
| 104 | EXL, b | EXtra code Legal | Ekstrakod | S/S/97;0// := IC S/S/97;0/+1/ := R0 S/S/97;0/+2/ := SR S/S/97;0/+3/ := b R0 := 0 IC := S/96;0/ SR9,10 := 0 S/97;0/ := S/97;0/+4 | |
| 105 | RPC, rA | Remember Program Conditions | Prześlij rejestr R0 | R/A/ := R0 | |
| 106 | LPC, rA | Load Program Conditions | Umieść w rejestrze R0 | R0 := R/A/ | |
| 107 | MBn, rC, rB | Modify Block address register | Umieść w SR | SR10÷15 := S/N/10÷15 | |
| 108 | IMn, rC, rB | load Interrupt Mask | Umieść w RM | SR0÷9 := S/N/0÷9 | |
| 109 | KIn, rC, rB | Kill Interrupts | Pamiętaj RZ | S/N/ := RZ0÷11,28÷31 | |
| 110 | FIn, rC, rB | Fetch Interrupts | Umieść w RZ | RZ0÷11,28÷31 := S/N/ | |
| 111 | SPn, rC, rB | Start Program | Powróć do programu | IC := S/N;NB/ R0 := S/N+1;NB/ SR := S/N+2;NB/ | |
| 112 | HLT | HaLT | Czekaj (na przerwania) | Instrukcja HLT | |
| 113 | MCL | Master CLear | Zeruj | zeruj RZ, SR, R0, kanały, urządzenia, rejestry podziału PAO | |
| 114 | SIU | Set Interrupt Upper | Ustaw przerwanie starsze | RZ30 := 1 | |
| 115 | SIL | Set Interrupt Lower | Ustaw przerwanie młodsze | RZ31 := 1 | |
| 116 | CIT | Clear InTerrupts | Zeruj przerwania programowe | RZ30,31 := 00 | |
| 117 | SIT | Set InTerrupts | Ustaw przerwania programowe | RZ30,31 := 11 | |
| 118 | GIU | Generate Interrupt Upper | Wyślij przerwanie typu U | RZ3/drugiego procesora/ := 1 jeśli odpowiedź OK to P := 1 |
P |
| 119 | GIL | Generate Interrupt Lower | Wyślij przerwanie typu L | RZ29/drugiego procesora/ := 1 jeśli odpowiedź OK to P := 1 |
P |
| 120 | LIP | Leave to Interrupted Program | Powróć z przerwania | IC := S/S/97;0/-4/ R0 := S/S/97;0/-3/ SR := S/S/97;0/-2/ S/97;0/ := S/97;0/-4 | |
| 121 | OUn, rA, rC, rB | OUtput data | Wyjście | Instrukcje wejścia-wyjścia | |
| 122 | INn, rA, rC, rB | INput data | Wejście | Instrukcje wejścia-wyjścia |