Strojový kód, assembler, emulátor

počítača
● Návrh architektúry hypotetického procesora
● Strojový kód
● Assemblerový jazyk
● Programovanie v assemblerovom jazyku:
– Lineárny program
– Vetvenie
– Cyklus
● Emulátor počítača
Autor: Peter Tomcsányi, Niektoré práva vyhradené v zmysle licencie Creative Commons
http://creativecommons.org/licenses/by-nc-sa/3.0/
Návrh architektúry hypotetického procesora
Náš hypotetický procesor je 8-bitový.
Má päť 8-bitových registrov
Aj adresy do pamäte sú 8-bitové, pamäť môže mať teda maximálne 256 bajtov.

Najnižší bit registra F sa nazýva „bit Z“, určuje, že porovnávané čísla boli
rovnaké alebo že výsledok aritmetickej operácie bol nula.
Ďalší bit registra F sa nazýva „bit G“, určuje, prvé z porovnávaných čísiel
bolo väčšie než druhé.
Ostatné bity registra F nemajú žiadny význam
 Návrh strojového kódu
Prvý Druhý Assemblerový
bajt bajt zápis Význam
00 NOP Neurob nič
01 n LDA n Prenes bajt z adresy n do registra A
02 n STA n Prenes bajt z registra A na adresu n
Pripočiítaj k A hodnotu z adresy n
03 n ADD n Nastav bit Z: keď je výsledok nula tak 1, inak 0
Odčítaj od A hodnotu z adresy n,
04 n SUB n Nastav bit Z: keď je výsledok nula tak 1, inak 0
05 adr JMP adr Skoč na adresu adr
Nastav bit G: keď je A neznamienkovo väčšie než obsah adresy n tak 1, inak 0
06 n CMP n Nastav bit Z: keď je A rovné obsahu adresy n tak 1, inak 0
07 adr JNE adr Ak je bit Z v reg. F rovný 0, tak skoč na adresu adr
08 adr JG adr Ak je bit G v reg. F rovný 1, tak skoč na adresu adr
FF HALT Zastav procesor
x DATA x Pseudoinštrukcia - ulož do výsledného programu číslo x

Prvý program v strojovom kóde Symbolické vyjadrenie adries odbremení

Adresa Strojový kód Assemblerový zápis programátora od zisťovania ich číselnej hodnoty:
00 01 05 LDA 5 LDA X
02 03 06 ADD 6 ADD Y
04 FF HALT HALT
05 02 DATA 2 X: DATA 2
06 03 DATA 3 Y: DATA 3
Assemblerový jazyk sa nazýva aj
Čo bude v registri A keď procesor zastaví? Jazyk symbolických adries
 Vykonávanie inštrukcií riadiacou jednotkou
Konkretizácia pre navrhnutý procesor
1. Vyber inštrukciu z pamäti z adresy ktorá je v
registri PC a umiestni ju do registra I.
2. Zvýš obsah registra PC o 1.
3. Ak inštrukcia potrebuje operand z pamäti (ako
vstup alebo výstup), tak vyber jeho adresu z
adresy ktorá je v registri PC, umiestni ju do
registra Adr a zvýš register PC o 1.
4. Vykonaj inštrukciu.
5. Ak inštrukcia ukladá výsledok do pamäti, tak ho
ulož do pamäti na adresu, ktorá je v registri Adr.
6. Pokračuj znova krokom 1.
 Úloha 1
● Napíšte program v strojovom kóde, ktorý
vypočíta 2*X+4*Y, kde X a Y sú uložené v
bajtoch za programom.
● Program najprv zapíšte v assemblerovom
zápise, potom ho preveďte do strojového kódu.
LDA X 00 : 01 0D
ADD X 02 : 03 0D
ADD Y 04 : 03 0E Dá sa to naprogramovať
ADD Y 06 : 03 0E na menej inštrukcií?
ADD Y 08 : 03 0E
ADD Y 0A : 03 0E
HLT 0C : FF
X: DATA 1 0D : 01
Y: DATA 2 0E : 02
 Úloha 2
● Čo spraví tento program?
Čo bude na jeho konci v
X, Y a v registri A?
LDA X A = X A = X
CMP Y if A > Y: if A <= Y:
JG Koniec pass Pom = A
STA Pom else: X = Y
LDA Y Pom = A Y = Pom
STA X X = Y A = X
LDA Pom Y = Pom
STA Y A = X
LDA X
Koniec: HALT
X: DATA 3
Y: DATA 4
Pom: DATA 0
 Úloha 3
● Čo spraví tento program?
LDA X
STA N
Cyklus: LDA Y
ADD Vysl Pre niektorú hodnotu X
ale nebude fungovať
STA Vysl
„správne“.
LDA N Opravte program.
SUB Jedna
STA N
JNE Cyklus
LDA Vysl
HALT
X: DATA 3
Y: DATA 4
Vysl: DATA 0
N: DATA 0
Jedna: DATA 1
 Jednoduchý emulátor strojového kódu
Emulátor je program, ktorý vykonáva inštrukcie strojového kódu
konkrétneho (hypotetického alebo skutočného) procesora a
simuluje prácu celého počítača.
Náš jednoduchý emulátor slúži predovšetkým ako ukážka toho, čo
sa deje vo vnútri procesora, teda aké úlohy plní riadiaca jednotka.
Poslúži aj na vysvetlenie vzťahu strojového kódu a
assemblerového jazyka.

Naprogramoval som ho v Pythone.

Niektoré vlastnosti Pythonu, ktoré som využil:
● čísla možno zapisovať aj v dvojkovej alebo aj v šestnástkovej

sústave:
x = 0b0101
y = 0xFE
● Python pozná logické operácie s číslami rovnako, ako C:

print(x & y)
print(x | y)
 Jednoduchý emulátor strojového kódu (2)
Kompletný program nájdete na: http://edi.fmph.uniba.sk/~tomcsanyi/InterpreterPython.zip
def interpretuj(kod):
pam = kod+[0]*(256-len(kod)) # doplnenie pamäte do 256
pc = 0; a = 0; f = 0 # počiatočné nastavenie
while True:
i = pam[pc]; pc = (pc+1)%256
if i == 0: # NOP neurob nič skúste:
pass interpretuj([1,5,3,6,255,2,3])
elif i == 1: # LDA
adr = pam[pc]; pc = (pc+1)%256
a = pam[adr]
elif i == 2: # STA
adr = pam[pc]; pc = (pc+1)%256
pam[adr] = a
elif i == 3: # ADD elif i == 7: # JNE
adr = pam[pc]; pc = (pc+1)%256 if f & 1 == 0: pc = pam[pc]
a =(a+pam[adr]) % 256 else: pc = (pc+1)%256
if a == 0: f = f | 1 elif i == 8: # JG
else: f = f & 0b11111110 if f & 2 == 1: pc = pam[pc]
elif i == 4: # SUB else: pc = (pc+1)%256
adr = pam[pc]; pc = (pc+1)%256 elif i == 255:
a =(a-pam[adr]) % 256 break
if a == 0: f = f | 1 else:
else: f = f & 0b11111110 raise Exception('Neznáma inštrukcia'+
elif i == 5: # JMP str(i))
pc = pam[pc] return a
elif i == 6: # CMP
adr = pam[pc]; pc = (pc+1)%256
if a == pam[adr]: f = f | 1
else: f = f & 0b11111110
if a > pam[adr]: f = f | 2
else: f = f & 0b11111101