Lista rozkazów: Różnice pomiędzy wersjami

Z MERA 400 wiki
Przejdź do nawigacji Przejdź do wyszukiwania
Nie podano opisu zmian
 
(Nie pokazano 23 pośrednich wersji utworzonych przez tego samego użytkownika)
Linia 13: Linia 13:
|-
|-
| M || zawartość następnego słowa za słowem podstawowym rozkazu
| 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
| P || wskaźnik przeskoku. Gdy P=1 to IC := IC + długość rozkazu + 1
Linia 66: Linia 72:
Uwagi do listy 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]]):
# 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 D=0, C≠0
#* '''R''' dla C≠0, D=0
#* '''A''' dla D=1, C≠0
#* '''A''' dla C≠0, D=1
#* '''D''' dla D=0, C=0
#* '''D''' dla C=0, D=0
#* '''I''' dla D=1, C=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)
# 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
# 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.


{| class="wikitable"
{| class="wikitable"
! Lp. !! Mnemonik !! Źródłosłów !! Opis !! Treść !! Ustaw<br>wskaźniki
! Lp. !! Mnemonik !! Źródłosłów !! Opis !! Treść !! Ustaw<br>wskaźniki
|-
|-
| 1 || '''LWn, rA, rC, Rb''' || Load Word || Umieść w rejestrze || R/A/ := N
| 1 || '''LW'''n, 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
| 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/
| 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/]
| 4 || '''LD'''n, 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/]
| 5 || '''LF'''n, 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/]
| 6 || '''LA'''n, 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/]
| 7 || '''LL'''n, 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/&and;<span style="text-decoration:overline;">R7</span>] &or; [N&and;R7]
| 8 || '''LS'''n, rA, rC, rB || Load Selective || Umieść przez maskę w R7 || R/A/ := [R/A/&and;<span style="text-decoration:overline;">R7</span>] &or; [N&and;R7]
|-
|-
| 9 || '''TWn, rA, rC, rB''' || Take Word || Umieść według NB || R/A/ := S/N,NB/
| 9 || '''TW'''n, 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/]
| 10 || '''TD'''n 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/]
| 11 || '''TF'''n, 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/]
| 12 || '''TA'''n, 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/]
| 13 || '''TL'''n, 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/
| 14 || '''RW'''n, 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+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]
| 16 || '''RD'''n, 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]]
| 17 || '''RF'''n, 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]
| 18 || '''RA'''n, 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]
| 19 || '''RL'''n, 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/
| 20 || '''PW'''n, 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]
| 21 || '''PD'''n, 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]
| 22 || '''PF'''n, 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]
| 23 || '''PA'''n, 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]
| 24 || '''PL'''n, 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
| 25 || '''RZ'''n, 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 <br>R/A/ := R/A/ + 1
| 26 || '''RI'''n, rA, rC, rB || Remember and Increment || Umieść w pamięci i dodaj 1 || S/R/A// := N <br>R/A/ := R/A/ + 1
|-
|-
| 27 || '''AWn, rA, rC, rB''' || Add Word || Dodaj || R/A/ := R/A/ + N || Z, M, V, C
| 27 || '''AW'''n, 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
| 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
| 29 || '''AC'''n, 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
| 30 || '''SW'''n, 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
| 31 || '''CW'''n, 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
| 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/ := <span style="text-decoration:overline;">R/A/</span>+1 || Z, M, V, C
| 33 || '''NGA''', rA || NeGation Arithmetic || Neguj arytmetycznie || R/A/ := <span style="text-decoration:overline;">R/A/</span>+1 (-R/A/)|| Z, M, V, C
|-
|-
| 34 || '''NGC, rA''' || NeGation with Carry || Neguj z przeniesieniem || R/A/ := <span style="text-decoration:overline;">R/A/</span>+C || Z, M, V, C
| 34 || '''NGC''', rA || NeGation with Carry || Neguj z przeniesieniem || R/A/ := <span style="text-decoration:overline;">R/A/</span>+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
| 35 || '''AD'''n, 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
| 36 || '''SD'''n, 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 &times; S/N/ || Z, M, V
| 37 || '''MW'''n, rC, rB || Multiply Words || Mnóż || [R1, R2] := R2 &times; S/N/ || Z, M, V
|-
|-
| 38 || '''DWn, rC, rB''' || Divide Words || Dziel || R2 := [R1, R2] : S/N/ <br>R1 := reszta || Z, M
| 38 || '''DW'''n, rC, rB || Divide Words || Dziel || R2 := [R1, R2] : S/N/ <br>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
| 39 || '''AF'''n, 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
| 40 || '''SF'''n, 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] &times; [S/N/, S/N+1/, S/N+2/] || Z, M, C
| 41 || '''MF'''n, rC, rB || Multiply Floating point numbers || Pomnóż liczby zmennorzecinkowe || [R1, R2, R3] := [R1, R2, R3] &times; [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
| 42 || '''DF'''n, 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
| 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/ &or; N || Z
| 44 || '''OR'''n, rA, rC, rB || Or Register || Dodaj logicznie || R/A/ := R/A/ &or; N || Z
|-
|-
| 45 || '''OMn, rA, rC, rB''' || Or Memory || Dodaj logicznie do pamięci ||S/N;NB/ := S/N;NB/ &or; R/A/ || Z
| 45 || '''OM'''n, rA, rC, rB || Or Memory || Dodaj logicznie do pamięci ||S/N;NB/ := S/N;NB/ &or; R/A/ || Z
|-
|-
| 46 || '''NRn, rA, rC, rB''' || aNd in Register || Pomnóż logicznie || R/A/ := R/A/ &and; N || Z
| 46 || '''NR'''n, rA, rC, rB || aNd in Register || Pomnóż logicznie || R/A/ := R/A/ &and; N || Z
|-
|-
| 47 || '''NMn, rA, rC, rB''' || aNd in Memory || Pomnóż logicznie do pamięci || S/N;NB/ := S/N;NB/ &and; R/A/ || Z
| 47 || '''NM'''n, rA, rC, rB || aNd in Memory || Pomnóż logicznie do pamięci || S/N;NB/ := S/N;NB/ &and; R/A/ || Z
|-
|-
| 48 || '''XRn, rA, rC, rB''' || eXclusive or in Register || Różnica symetryczna || R/A/ := R/A/ <strike>&middot;</strike> N || Z
| 48 || '''XR'''n, rA, rC, rB || eXclusive or in Register || Różnica symetryczna || R/A/ := R/A/ <strike>&middot;</strike> N || Z
|-
|-
| 49 || '''XMn, rA, rC, rB''' || eXclusive or in Memory || Różnica symetryczna w pamięci || S/N;NB/ := S/N;NB/ <strike>&middot;</strike> R/A/ || Z
| 49 || '''XM'''n, rA, rC, rB || eXclusive or in Memory || Różnica symetryczna w pamięci || S/N;NB/ := S/N;NB/ <strike>&middot;</strike> R/A/ || Z
|-
|-
| 50 || '''ERn, rA, rC, rB''' || Erase bits in Register || Zeruj bity || R/A/ := R/A/ &and; <span style="text-decoration:overline;">N</span> || Z
| 50 || '''ER'''n, rA, rC, rB || Erase bits in Register || Zeruj bity || R/A/ := R/A/ &and; <span style="text-decoration:overline;">N</span> || Z
|-
|-
| 51 || '''EMn, rA, rC, rB''' || Erase bits in Memory || Zeruj bity w pamięci || S/N;NB/ := S/N;NB/ &and; <span style="text-decoration:overline;">R/A/</span> || Z
| 51 || '''EM'''n, rA, rC, rB || Erase bits in Memory || Zeruj bity w pamięci || S/N;NB/ := S/N;NB/ &and; <span style="text-decoration:overline;">R/A/</span> || Z
|-
|-
| 52 || '''CLn, rA, rC, rB''' || Compare Logically || Porównaj logicznie || R/A/ >=< N || L, E, G
| 52 || '''CL'''n, rA, rC, rB || Compare Logically || Porównaj logicznie || R/A/ >=< N || L, E, G
|-
|-
| 53 || '''NGL, rA''' || NeGate Logically || Neguj logicznie || R/A/ := <span style="text-decoration:overline;">R/A/</span> || Z
| 53 || '''NGL''', rA || NeGate Logically || Neguj logicznie || R/A/ := <span style="text-decoration:overline;">R/A/</span> || Z
|-
|-
| 54 || '''SXU, rA''' || Set X as Upper bit || Ustaw wskaźnik X według R/A/<sub>0</sub> || X := R/A/<sub>0</sub> || Z
| 54 || '''SXU''', rA || Set X as Upper bit || Ustaw wskaźnik X według R/A/<sub>0</sub> || X := R/A/<sub>0</sub> || X
|-
|-
| 55 || '''SXL, rA''' || Set X as Lower bit || Ustaw wskaźnik X według R/A/<sub>15</sub> || X := R/A/<sub>15</sub> || Z
| 55 || '''SXL''', rA || Set X as Lower bit || Ustaw wskaźnik X według R/A/<sub>15</sub> || X := R/A/<sub>15</sub> || X
|-
|-
| 56 || '''SLZ, rA''' || Shift Left add Zero || Przesuń w lewo || R/A/ &laquo; [R/A/,0]<br>Y := R/A/<sub>0</sub> || Y
| 56 || '''SLZ''', rA || Shift Left add Zero || Przesuń w lewo || R/A/ &laquo; [R/A/,0]<br>Y := R/A/<sub>0</sub> || Y
|-
|-
| 57 || '''SLY, rA''' || Shift Left add Y || Przesuń w lewo z Y || R/A/ &laquo; [R/A/,Y]<br>Y := R/A/<sub>0</sub> || Y
| 57 || '''SLY''', rA || Shift Left add Y || Przesuń w lewo z Y || R/A/ &laquo; [R/A/,Y]<br>Y := R/A/<sub>0</sub> || Y
|-
|-
| 58 || '''SLX, rA''' || Shift Left add X || Przesuń w lewo z X || R/A/ &laquo; [R/A/,X]<br>Y := R/A/<sub>0</sub> || Y
| 58 || '''SLX''', rA || Shift Left add X || Przesuń w lewo z X || R/A/ &laquo; [R/A/,X]<br>Y := R/A/<sub>0</sub> || Y
|-
|-
| 59 || '''SVZ''' || Shift left, check oVerflow, add Zero || Przesuń w lewo, ustaw V || R/A/ &laquo; [R/A/,0]<br>Y := R/A/<sub>0</sub> || Y, V
| 59 || '''SVZ''', rA || Shift left, check oVerflow, add Zero || Przesuń w lewo, ustaw V || R/A/ &laquo; [R/A/,0]<br>Y := R/A/<sub>0</sub> || Y, V
|-
|-
| 60 || '''SVY''' || Shift left, check oVerflow, add Y || Przesuń w lewo z Y, ustaw V || R/A/ &laquo; [R/A/,Y]<br>Y := R/A/<sub>0</sub> || Y, V
| 60 || '''SVY''', rA || Shift left, check oVerflow, add Y || Przesuń w lewo z Y, ustaw V || R/A/ &laquo; [R/A/,Y]<br>Y := R/A/<sub>0</sub> || Y, V
|-
|-
| 61 || '''SVX, rA''' || Shift left, check oVerflow, add X || Przesuń w lewo z X, ustaw V || R/A/ &laquo; [R/A/,X]<br>Y := R/A/<sub>0</sub> || Y, V
| 61 || '''SVX''', rA || Shift left, check oVerflow, add X || Przesuń w lewo z X, ustaw V || R/A/ &laquo; [R/A/,X]<br>Y := R/A/<sub>0</sub> || Y, V
|-
|-
| 62 || '''SRZ''' || Shift Right, add Zero || Przesuń w prawo || [0,R/A/] R/A/&raquo;<br>Y := R/A/<sub>15</sub> || Y
| 62 || '''SRZ''', rA || Shift Right, add Zero || Przesuń w prawo || [0,R/A/] R/A/&raquo;<br>Y := R/A/<sub>15</sub> || Y
|-
|-
| 63 || '''SRY''' || Shift Right, add Y || Przesuń w prawo z Y || [Y,R/A/] R/A/&raquo;<br>Y := R/A/<sub>15</sub> || Y
| 63 || '''SRY''', rA || Shift Right, add Y || Przesuń w prawo z Y || [Y,R/A/] R/A/&raquo;<br>Y := R/A/<sub>15</sub> || Y
|-
|-
| 64 || '''SRX''' || Shift Right, add X || Przesuń w prawo z X || [X,R/A/] R/A/&raquo;<br>Y := R/A/<sub>15</sub> || Y
| 64 || '''SRX''', rA || Shift Right, add X || Przesuń w prawo z X || [X,R/A/] R/A/&raquo;<br>Y := R/A/<sub>15</sub> || Y
|-
|-
| 65 || '''SHC, rA, T''' || SHift Cyclic || Przesuń cyklicznie || R/A/&raquo;T&raquo;R/A/<br>T - liczba przesunięć
| 65 || '''SHC''', rA, T || SHift Cyclic || Przesuń cyklicznie || R/A/&raquo;T&raquo;R/A/<br>T - liczba przesunięć (4-bitowa!)
|-
|-
| 66 || '''LBn, rA, rC, rB''' || Load Byte || Umieść bajt || R/A/<sub>8&divide;15</sub> := S/N;NB/
| 66 || '''LBn''', rA, rC, rB || Load Byte || Umieść bajt || R/A/<sub>8&divide;15</sub> := S/N*;NB/
|-
|-
| 67 || '''RBn, rA, rC, rB''' || Remember Byte || Pamiętaj bajt || S/N;NB/ := R/A/<sub>8&divide;15</sub>
| 67 || '''RB'''n, rA, rC, rB || Remember Byte || Pamiętaj bajt || S/N*;NB/ := R/A/<sub>8&divide;15</sub>
|-
|-
| 68 || '''ZLB, rA''' || Zero to Left Byte || Zeruj bajt lewy || R/A/<sub>0&divide;7</sub> := 0
| 68 || '''ZLB''', rA || Zero to Left Byte || Zeruj bajt lewy || R/A/<sub>0&divide;7</sub> := 0
|-
|-
| 69 || '''ZRB, rA''' || Zero to Right Byte || Zeruj bajt prawy || R/A/<sub>8&divide;15</sub> := 0
| 69 || '''ZRB''', rA || Zero to Right Byte || Zeruj bajt prawy || R/A/<sub>8&divide;15</sub> := 0
|-
|-
| 70 || '''CBn, rA, rB, rC''' || Compare Byte || Porównaj bajt || R/A/<sub>8&divide;15</sub> >=< S/N;NB/ || L, E, G
| 70 || '''CBn''', rA, rB, rC || Compare Byte || Porównaj bajt || R/A/<sub>8&divide;15</sub> >=< S/N*;NB/ || L, E, G
|-
|-
| 71 || '''UJn, rC, rB''' || Unconditional Jump || Skocz || IC := N
| 71 || '''UJ'''n, rC, rB || Unconditional Jump || Skocz || IC := N
|-
|-
| 72 || '''UJS, T''' || Unconditional Jump Short || Skocz względnie || IC := IC + T
| 72 || '''UJS''', T || Unconditional Jump Short || Skocz względnie || IC := IC + T
|-
|-
| 73 || '''LJn, rC, rB''' || Link Jump || Skocz ze śladem || S/N/ := IC<br>IC := N + 1
| 73 || '''LJ'''n, rC, rB || Link Jump || Skocz ze śladem || S/N/ := IC<br>IC := N + 1
|-
|-
| 74 || '''RJn, rA, rC, rB''' || Return Jump || Skocz ze śladem w rejestrze || R/A/ := IC<br>IC := N
| 74 || '''RJ'''n, rA, rC, rB || Return Jump || Skocz ze śladem w rejestrze || R/A/ := IC<br>IC := N
|-
|-
| 75 || '''JNn, rC, rB''' || Jump if Not equal || Skocz gdy <span style="text-decoration:overline;">E</span> || Jeśli E=0 to IC := N
| 75 || '''JN'''n, rC, rB || Jump if Not equal || Skocz gdy <span style="text-decoration:overline;">E</span> || Jeśli E=0 to IC := N
|-
|-
| 76 || '''JLn, rC, rB''' || Jump if Less || Skocz przy L || Jeśli L=1 to IC := N
| 76 || '''JL'''n, 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
| 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
| 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
| 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
| 80 || '''JG'''n, 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
| 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
| 82 || '''JZ'''n, 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
| 83 || '''JM'''n, 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<br>V := 0 || V
| 84 || '''JVS''', T || Jump if oVerflow Short || Skocz względnie przy V || Jeśli V=1 to IC := IC + T<br>V := 0 || V
|-
|-
| 85 || '''JCS, T''' || Jump if Carry Short || Skocz względnie przy C || Jeśli C=1 to IC := IC + T
| 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
| 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
| 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<br>Jeśli R/A/=0 to P := 1 || P
| 88 || '''TRB''', rA, T || parameTer to Register and Branch || Dodaj arg. krótki i przeskocz || R/A/ := R/A/ + T<br>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<br>Jeśli R/A/=0 to IC := IC + T
| 89 || '''IRB''', rA, T || Increment Register and Branch || Dodaj 1, skocz względnie || R/A/ := R/A/ + 1<br>Jeśli R/A/&ne;0 to IC := IC + T
|-
|-
| 90 || '''DRB, rA, T''' || Decrease Register and Branch || Odejmij 1, skocz względnie || R/A/ := R/A/ - 1<br>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<br>Jeśli R/A/&ne;0 to IC := IC + T
|-
|-
| 91 || '''BBn, rA, rC, rB''' || Branch on Bits || Porównaj logicznie iloczyn || Jeśli R/A/&and;N &equiv; N to P := 1 || P
| 91 || '''BB'''n, rA, rC, rB || Branch on Bits || Porównaj logicznie iloczyn || Jeśli R/A/&and;N &equiv; 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/ &and; R/A/ &equiv; R/A/ to P := 1 || P
| 92 || '''BM'''n, rA, rC, rB || Branch on bits in Memory || Porównaj logicznie iloczyn w pamięci || Jeśli S/N;NB/ &and; R/A/ &equiv; R/A/ to P := 1 || P
|-
|-
| 93 || '''BSn, rA, rC, rB''' || Branch Selective || Porównaj logicznie przez maskę || Jeśli R/A/ &and; R7 &equiv; N &and; R7 to P := 1 || P
| 93 || '''BS'''n, rA, rC, rB || Branch Selective || Porównaj logicznie przez maskę || Jeśli R/A/ &and; R7 &equiv; N &and; R7 to P := 1 || P
|-
|-
| 94 || '''BCn, rA, rC, rB''' || Branch if not all Conditions || Porównaj logicznie iloczyn || Jeśli R/A/ &and; N &equiv; N to P := 1 || P
| 94 || '''BC'''n, rA, rC, rB || Branch if not all Conditions || Porównaj logicznie iloczyn || Jeśli R/A/ &and; N &ne; N to P := 1 || P
|-
|-
| 95 || '''BNn, rA, rC, rB''' || Branch if No conditions || Przeskocz gdy iloczyn=0 || Jeśli R/A/ &and; N &equiv; 0 to P := 1 || P
| 95 || '''BN'''n, rA, rC, rB || Branch if No conditions || Przeskocz gdy iloczyn=0 || Jeśli R/A/ &and; N &equiv; 0 to P := 1 || P
|-
|-
| 96 || '''BRC, b''' || Branch if not Right Conditions || Badaj prawy bajt R0 || Jeśli R0<sub>8&divide;15</sub> &and; b &ne; b to P := 1 || P
| 96 || '''BRC''', b || Branch if not Right Conditions || Badaj prawy bajt R0 || Jeśli R0<sub>8&divide;15</sub> &and; b &ne; b to P := 1 || P
|-
|-
| 97 || '''BLC, b''' || Branch if not Left Conditions || Badaj lewy bajt R0 || Jeśli R0<sub>0&divide;7</sub> &and; b &ne; b to P := 1 || P
| 97 || '''BLC''', b || Branch if not Left Conditions || Badaj lewy bajt R0 || Jeśli R0<sub>0&divide;7</sub> &and; b &ne; b to P := 1 || P
|-
|-
| 98 || '''IBn, rC, rB''' || Increment and Branch || Następnik pamięci || S/N/ := S/N/ + 1<br>Jeśli S/N/=0 to P := 1 || P
| 98 || '''IB'''n, rC, rB || Increment and Branch || Następnik pamięci || S/N/ := S/N/ + 1<br>Jeśli S/N/=0 to P := 1 || P
|-
|-
| 99 || '''MDn, rC, rB''' || MoDify next instruction || Modyfikuj || MOD := N
| 99 || '''MD'''n, rC, rB || MoDify next instruction || Modyfikuj || MOD := N
|-
|-
| 100 || '''NOP''' || No OPeration || Nic nie rób || traktowany przez assembler jako UJS, 0
| 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
| 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
| 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/ &and; R/A/ &equiv; R/A/ to P := 1<br>Jeśli S/N;NB/ &and; R/A/ &ne; R/A/ to S/N;NB/ := S/N;NB/ &or; R/A/ || P
| 103 || '''IS'''n, rA, rC, rB || Install Semaphore || Ustaw semafor || Jeśli S/N;NB/ &and; R/A/ &equiv; R/A/ to P := 1<br>Jeśli S/N;NB/ &and; R/A/ &ne; R/A/ to S/N;NB/ := S/N;NB/ &or; R/A/ || P
|-
|-
| 104 || '''EXL, b''' || EXtra code Legal || Ekstrakod || S/S/97;0// := IC <br>S/S/97;0/+1/ := R0 <br>S/S/97;0/+2/ := SR <br>S/S/97;0/+3/ := b <br>R0 := 0 <br>IC := S/96;0/ <br>SR<sub>9,10</sub> := 0 <br>S/97;0/ := S/97;0/+4
| 104 || '''EXL''', b || EXtra code Legal || Ekstrakod || S/S/97;0// := IC <br>S/S/97;0/+1/ := R0 <br>S/S/97;0/+2/ := SR <br>S/S/97;0/+3/ := b <br>R0 := 0 <br>IC := S/96;0/ <br>SR<sub>9,10</sub> := 0 <br>S/97;0/ := S/97;0/+4
|-
|-
| 105 || '''RPC, rA''' || Remember Program Conditions || Prześlij rejestr R0 || R/A/ := R0
| 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/
| 106 || '''LPC''', rA || Load Program Conditions || Umieść w rejestrze R0 || R0 := R/A/
|-
|-
| 107 || '''MBn, rA, rC, rB''' || Modify Block ard. register (??) || Umieść w SR || SR<sub>10&divide;15</sub> := S/N/<sub>10&divide;15</sub>
| 107 || <span style="color:red">'''MB'''n, rC, rB</span> || Modify Block address register || Umieść w SR || SR<sub>10&divide;15</sub> := S/N/<sub>10&divide;15</sub>
|-
|-
| 108 || '''IMn, rA, rC, rB''' || load Interrupt Mask || Umieść w RM || SR<sub>0&divide;9</sub> := S/N/<sub>0&divide;9</sub>
| 108 || <span style="color:red">'''IM'''n, rC, rB</span> || load Interrupt Mask || Umieść w RM || SR<sub>0&divide;9</sub> := S/N/<sub>0&divide;9</sub>
|-
|-
| 109 || '''KIn, rA, rC, rB''' || Kill Interrupts || Pamiętaj RZ || S/N/ := RZ<sub>0&divide;11,28&divide;31</sub>
| 109 || <span style="color:red">'''KI'''n, rC, rB</span> || Kill Interrupts || Pamiętaj RZ || S/N/ := RZ<sub>0&divide;11,28&divide;31</sub>
|-
|-
| 110 || '''FIn, rA, rC, rB''' || Fetch Interrupts || Umieść w RZ || RZ<sub>0&divide;11,28&divide;31</sub> := S/N
| 110 || <span style="color:red">'''FI'''n, rC, rB</span> || Fetch Interrupts || Umieść w RZ || RZ<sub>0&divide;11,28&divide;31</sub> := S/N/
|-
|-
| 111 || '''SPn, rA, rC, rB''' || Start Program || Powróć do programu || IC := S/N;NB/ <br>R0 := S/N+1;NB/ <br> SR := S/N+2;NB/
| 111 || <span style="color:red">'''SP'''n, rC, rB</span> || Start Program || Powróć do programu || IC := S/N;NB/ <br>R0 := S/N+1;NB/ <br> SR := S/N+2;NB/
|-
|-
| 112 || '''HLT''' || HaLT || Czekaj || ||
| 112 || <span style="color:red">'''HLT'''</span> || HaLT || Czekaj (na przerwania) || [[Instrukcja HLT]] ||
|-
|-
| 113 || '''MCL''' || Master CLear || Zeruj || zeruj RZ, SR, R0, kanały, urządzenia, rejestry podziału PAO
| 113 || <span style="color:red">'''MCL'''</span> || Master CLear || Zeruj || zeruj RZ, SR, R0, kanały, urządzenia, rejestry podziału PAO
|-
|-
| 114 || '''SIU''' || Set Interrupt Upper || Ustaw przerwanie starsze || RZ<sub>30</sub> := 1
| 114 || <span style="color:red">'''SIU'''</span> || Set Interrupt Upper || Ustaw przerwanie starsze || RZ<sub>30</sub> := 1
|-
|-
| 115 || '''SIL''' || Set Interrupt Lower || Ustaw przerwanie młodsze || RZ<sub>31</sub> := 1
| 115 || <span style="color:red">'''SIL'''</span> || Set Interrupt Lower || Ustaw przerwanie młodsze || RZ<sub>31</sub> := 1
|-
|-
| 116 || '''CIT''' || Clear InTerrupts || Zeruj przerwania programowe || RZ<sub>30,31</sub> := 00
| 116 || <span style="color:red">'''CIT'''</span> || Clear InTerrupts || Zeruj przerwania programowe || RZ<sub>30,31</sub> := 00
|-
|-
| 117 || '''SIT''' || Set InTerrupts || Ustaw przerwania programowe || RZ<sub>30,31</sub> := 11
| 117 || <span style="color:red">'''SIT'''</span> || Set InTerrupts || Ustaw przerwania programowe || RZ<sub>30,31</sub> := 11
|-
|-
| 118 || '''GIU''' || Generate Interrupt Upper || Wyślij przerwanie typu U || RZ<sub>3</sub>/drugiego procesora/ := 1 <br>jeśli odpowiedź OK to P := 1 || P
| 118 || <span style="color:red">'''GIU'''</span> || Generate Interrupt Upper || Wyślij przerwanie typu U || RZ<sub>3</sub>/drugiego procesora/ := 1 <br>jeśli odpowiedź OK to P := 1 || P
|-
|-
| 119 || '''GIL''' || Generate Interrupt Lower || Wyślij przerwanie typu L || RZ<sub>29</sub>/drugiego procesora/ := 1 <br>jeśli odpowiedź OK to P := 1 || P
| 119 || <span style="color:red">'''GIL'''</span> || Generate Interrupt Lower || Wyślij przerwanie typu L || RZ<sub>29</sub>/drugiego procesora/ := 1 <br>jeśli odpowiedź OK to P := 1 || P
|-
|-
| 120 || '''LIP''' || Leave to Interrupted Program || Powróć z przerwania || IC := S/S/97;0/-4/ <br>R0 :=  S/S/97;0/-3/<br> SR := S/S/97;0/-2/ <br>S/97;0/ := S/97;0/-4
| 120 || <span style="color:red">'''LIP'''</span> || Leave to Interrupted Program || Powróć z przerwania || IC := S/S/97;0/-4/ <br>R0 :=  S/S/97;0/-3/<br> SR := S/S/97;0/-2/ <br>S/97;0/ := S/97;0/-4
|-
|-
| 121 || '''OUn, rA, rC, rB''' || OUtput data || Wyjście || ||
| 121 || <span style="color:red">'''OU'''n</span>, rA, rC, rB || OUtput data || Wyjście || [[Instrukcje wejścia-wyjścia]] ||
|-
|-
| 122 || '''INn, rA, rC, rB''' || INput data || Wejście || ||
| 122 || <span style="color:red">'''IN'''n</span>, rA, rC, rB || INput data || Wejście || [[Instrukcje wejścia-wyjścia]] ||
|}
|}

Aktualna wersja na dzień 10:52, 24 paź 2021

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:

  1. Rozkazy nielegalne (dozwolone tylko przy pracy systemu operacyjnego) oznaczono kolorem czerwonym
  2. 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
  3. Jeśli C=0, to zamiast rC występuje M (słowo następne za słowem rozkazowym)
  4. argument rB nie występuje w przypadku B=0 lub gdy rozkaz nie może ulegać B-modyfikacji
  5. 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.
  6. 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/ · N Z
49 XMn, rA, rC, rB eXclusive or in Memory Różnica symetryczna w pamięci S/N;NB/ := S/N;NB/ · R/A/ 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
Źródło: „http://mera400.pl/index.php?title=Lista_rozkazów&oldid=3144”