Yleisesti SOP muoto saadaan totuustaulusta seuraavasti

• etsi rivit, joissa ulostulona on 1
• muodosta tulo rivin muuttujista, tai muuttujan negaatiosta, jos muuttuja on 0
• muodosta summa tulotermeistä

Muuttujien ja termien määrä voi olla mielivaltainen, eikä siis rajoitettu kahteen, kuten käsitellyissä esimerkeissä.

Summien tulomuoto (Product of Sums - POS)

Yleisesti POS-muoto totuustaulusta saadaan seuraavasti

• etsi rivit, joissa ulostulona on 0
• summaa rivin muuttujat, tai muuttujan negaatio, jos muuttujan arvo on 1
• muodosta tulo summatermeistä

Muuttujien ja termien määrä voi olla mielivaltainen, eikä siis rajoitettu kahteen, kuten käsitellyissä esimerkeissä.

Muunnos SOP-muodosta NAND-muotoon

Muunnos POS-muodosta NOR-muotoon

Boolen funktioiden sieventäminen

Algebrallinen sieventäminen

NAND muotoon sieventäminen

Karnaughin kartta

Karnaughin kartasta SOP-muotoinen sievennetty lauseke

Kuvan eri värisistä alueista saadaan siis sievennetyt SOP-termit

Väri	termi
oranssi
sininen
vihreä

sievennetty SOP-muotoinen lauseke saadaan summaamalla termit

Karnaughin kartasta POS-muotoinen sievennetty lauseke

Kuvan eri värisistä alueista saadaan siis sievennetyt POS-termit

Väri	termi
oranssi
sininen
vihreä

ja sievennetty POS-muotoinen lauseke saadaan kertomalla termit

Kombinaatiologiikka

Puolisummain

                       
1
      
c
             
   
0
      
0
      
1
      
1
      
a
 
+ 0
    
+ 1
    
+ 0
    
+ 1
    
+ b
  
0
0     
0
1     
0
1     
10
     
cs

Kokosummain

 
0
0
    
0
0
    
0
0
    
1
0
    
0
1
    
1
1
    
1
1
    
1
1
    
c[2]
c[1]
c[0]
  
0
0
    
0
0
    
1
0
    
1
0
    
0
1
    
0
1
    
1
1
    
1
1
       
a[1]
a[0]
+ 
0
0
  
+ 
1
0
  
+ 
0
0
  
+ 
1
0
  
+ 
0
1
  
+ 
1
1
  
+ 
0
1
  
+ 
1
1
   
+   
b[1]
b[0]
 
00
0
   
01
0
   
01
0
   
10
0
   
01
0
   
10
0
   
10
0
   
11
0
   
c[2]s[1]
s[0]

Tulovalitsin

Enemmän kuin kaksi sisäänmenoa tulovalitsimeen

Lähtövalitsin

Esimerkki lähtövalitsimesta

Enemmän kuin kaksi ulostuloa lähtövalitsimesta

Aritmeettislooginen yksikkö

ALU:n suunnittelu

• Ihan ensin päätetään arkkitehtuurin bittimäärä
  • eli sanan leveys
  • meidän tapauksessa 16-bittinen arkkitehtuuri
• Mietitään funktiot jotka ALUn halutaan toteuttavan
  • AND ja OR operaatio?
  • Yhteen- ja vähennyslasku?
• Rautatoteutus kaikille halutuille funktioille?
  • Mooren laki
  • Komponenttien toteuttaminen raudalle maksaa (transistoreita)
  • Voidaanko yksinkertaistaa?
  • Mitä toteutetaan laitteistolla, mitä ohjelmistolla?
• Mietitään miten ALU:lle annetaan käskyt funktioiden toteuttamiseksi
  • Määritellään sisääntulosignaalit
    • ohjaus- ja datasignaalit

HACK-tietokoneen prosessorin ALU:n suunnittelu

ALU:n ohjaussignaalit

• yksi negatoi ALU:n x-sisäänmenon (operandin),
• yksi nollaa ALU:n x-sisäänmenon (operandin),
• yksi negatoi ALU:n y-sisäänmenon (operandin),
• yksi nollaa ALU:n y-sisäänmenon (operandin),
• yksi negatoi ALU:n ulostulon,
• yksi valitsee suoritetaanko AND- vai ADD-operaatio, toisin sanoen ohjataanko ALU:n ulostuloksi yhteenlasku- vai AND-piirin ulostulo.

ALU:n OR-funktion toteutus

Tutkitaanpa ALU:n totuustaulun OR-funktiota vastaavaa riviä.

 zx nx zy ny  f no    out
  0  1  0  1  0  1    x|y

Rivin mukaan OR-funktio saadaan negatoimalla x-sisäänmeno (nx = 1), negatoimalla y-sisäänmeno (ny = 1), muodostamalla niiden AND-operaatio (f = 0) sekä negatoimalla ulostulo (no = 1). Kuvaus tuo varmaan mieleen De Morganin -teoreemat, De Morganin NOR -teoreeman oikeapuoli vastaa melkein kuvausta. Lisäämällä oikealle (ja vasemmalle) puolelle ulostulon negatoinnin, saadaan ja kaksoisnegaatiosäännön mukaan eli ALU:n OR-funktio toteutetaan soveltamalla De Morganin NOR -teoreemaa.

ALU:n vähennyslaskun toteutus

 zx nx zy ny  f no    out
  0  1  0  0  1  1    x-y

• Positiivisilla luvuilla
  • 7 – 5 = 2
  • -(-7 - -5) = -(-2)
  • -(-7 + 5) = -(-2) = 2
• Vastaavasti negatiivisella luvulla
  • −8 – 4 = −12
  • −(+8 + 4)= −(12) = −12

Tässä siis sulkujen ulkopuolella oleva miinusmerkki vastaa ALU:n ulostulon negatoimista, ja ensimmäisen luvun edessä olevan etumerkin vaihtaminen ALU:n x-sisäänmenon negatointia. Toisin sanoen

• Muutetaan ensimmäinen termin merkkiä (negatoidaan)
• Muutetaan vähennyslasku yhteenlaskuksi
• Muutetaan lopputuloksen merkkiä (negatoidaan)

Eli ALU:n pitää vähennyslaskun toteuttamiseksi

• muuttaa :n merkkiä
• käyttää yhteenlaskupiiriä
• muuttaa ulostulon merkkiä

Esim.

 
  negatoidaan ensimmäinen luku ja vaihdetaan vähennyslasku yhteenlaskuksi

                   input  _______________ output
   7     00000111  -----> |   11111000  |
-  5   - 00000101  -----> | + 00000101  |
----   ----------         | ----------  |
   2                      |   11111101  | ----->   00000010 (tämä on +2)
                          ---------------
                                   negatoidaan lopputulos

Esim.

 
  negatoidaan ensimmäinen luku ja vaihdetaan vähennyslasku yhteenlaskuksi

                   input  _______________ output
  -8     11111000  -----> |   00000111  |
-  4   - 00000100  -----> | + 00000100  |
----   ----------         | ----------  |
 -12                      |   00001011  | ----->   11110100 (tämä on -12)
                          ---------------
                                   negatoidaan lopputulos

ALU voidaan siis toteuttaa yhteenlaskupiirillä sekä AND -piirillä ja lisäksi pitää valita miten operandeja sekä ulostuloa käsitellään, eli

• zx ja nx ohjaa multiplekseriä
  • valitaan yhteenlasku ja AND-piirien toinen sisäänmeno
    • x, negatoitu x, 0 tai negatoitu 0
• zy ja ny ohjaa multiplekseriä
  • valitaan yhteenlasku ja AND-piirien toinen sisäänmeno
    • y, negatoitu y, 0 tai negatoitu 0
• f ohjaa multipekseriä,
  • jonka sisäänmenoina on yhteenlasku sekä AND -piirien ulostulot.
• no ohjaa multiplekseriä,
  • jonka sisäänmenoina on edellisen multiplekserin ulostulo ja sen negaatio
• edellisen multiplekserin ulostulo on ALU:n ulostulo
• zr ja ng ulostulot saadaan tutkimalla ALU:n ulostuloa

Sekvenssilogiikka

Set-Reset -Kiikku

D-Kiikku

T-kiikku

J-K -kiikku

Laskurit

Muistit

• Random Access Memory (RAM)
  • tarvitsevat virtaa säilyttääksen muistinsa
  • Static RAM
  • Dynamic RAM
    • pitää virkistää säännöllisesti virran saannin lisäksi
• Read Only Memery (ROM)
• Programmable PROM
• Erasable Programmable EPROM
• Electrically Erasable Programmable EEPROM
  • Flash muistit
    • Toteutus NAND- tai NOR-porteilla

Muistirekisteri

Muistikomponentit

• 8-sanainen 4-bitin muisti

• 64-sanainen 4-bitin muisti

Ohjelmalaskuri

• 4-bittinen PC

Tietokoneen arkkitehtuuri

• Tietokoneen arkkitehtuuri
  • ominaisuudet, jotka ovat ohjelmoijan nähtävissä
• Tietokoneen organisaatio
  • komponentit, jotka toteuttavat arkkitehtuurin ominaisuudet

Tietokoneen rakenne

Prosessorin yhteydet

Tietokoneen ja ohjelmiston yleinen rakenne

Tietokoneen ja ohjelmiston yleinen rakenne

• Loogisilla piireillä ja komponenteilla rakennetaan prosessori ja muistit
• Prosessorin rakenne määrää sen minkälaisia käskyjä sille voidaan antaa -> käskykanta (Instruction set)
• Konekieli on joukko binäärisiä ”sanoja” jotka vastaavat prosessorin käskyjä
• Assembly kieli antaa binäärisille bittijoukoille paremmin muistettavat vastineet, esimerkiksi HACK-assembly -kielessä:
  • 1111110111001000
  • M=M-1
• Jokaiselle prosessorityypille on oma konekieli ja siten myös assembly kieli

Tietokoneen toiminta

HACK-tietokoneen rakenne

HACK tietokoneen muisti

• ROM muisti, ladataan konekielinen ohjelma
• RAM muisti, käytetään ohjelman parametrien tallentamiseen
• I/O laitteet, näyttö ja näppis
  • Memory-mapped I/O
  • I/O laitteet kytketty samaan väylään kuin muisti
  • Laitteilla oma "muistiosoite"
  • HACK-tietokoneessa RAM muistin jatkeena

HACK-prosessori

HACK-tietokoneen toiminta

• HACK tietokone
  • Hae A-käsky
  • Suorita A-Käsky
  • Hae C-käsky
  • Suorita C-Käsky
  • Toista alusta
• ’Normaali’ –tietokone
  • Hae käsky
  • Suorita käsky
  • Toista alusta

Esimerkkiohjelma

// C# koodia
// Adds 1+...+5.
int i = 1;
int sum = 0;
while (i <= 5) {
    sum += i;
    Console.WriteLine(sum);
    i++;
}

// PSEUDO Assembly koodia
Alusta muuttujat i=1 ja sum=0 (varaa niille paikka muistista)
(LOOP)
  Laske i-5
  Jos ALU output > 0 
    niin indeksi liian suuri, hyppää LOPPU:un
  muuten (ALU output <= 0)
     kasvata summaa
     kasvata indeksiä
     hyppää LOOP:iin
 (LOPPU)
    Lopeta ohjelma

Esimerkin toteutus HACK-prosessorin assembly kielellä

// Hack assembly koodi
@i // assembler -kääntäjää valitsee muistipaikan, jonne i tallennetaan
M=1 // i=1 (sijoitetaan indeksin aloitusarvo yo. muistipaikkaan)
@sum // assembler -kääntäjää valitsee muistipaikan, jonne sum tallennetaan 
M=0 // sum=0 (alustetaan summa nollaksi tallentamalla 0 sum -muuttujan muistipaikkaan)
(LOOP)  // määrittää hyppyosoitteen
@i  // Asetetaan A-rekisterin arvoksi i-muuttujan muistipaikan osoite
D=M // D=M[i] haetaan lukuarvo RAM muistin (M) osoitteesta i, tallennetaan D-rekisteriin
@5  // asetetaan A-rekisteriin arvo 5
D=D-A // D=i-5, vähennetään A-rekisterin arvo D-rekisterin arvosta, tallennetaan D-rekisteriin
@END // asetetaan A rekisteriin mahdollinen hyppy osoite eli (END):iä seuraavan rivin osoite
D;JGT // Jos D:narvo positiivinen, hypätään (END):iin muuten jatketaan seuraavalle riville
@i // Asetetaan A-rekisteriin i:n osoite
D=M // D=M[i] haetaan i:n arvo muistista osoitteesta M[i] ja tallennetaan D-rekisteriin
@sum   // asetetaan A-rekisterin arvoksi sum parametrin osoite
M=D+M // sum=i+sum, haetaan muistista M[sum] arvo, lisätään D-rekisterin arvoon, tallennetaan muistiin
@i  // Asetetaan A rekisteriin i:n osoite
M=M+1 // i=i+1, haetaan i:n arvo yo. osoitteesta, lisätään 1 ja tallennetaan samaan osoitteeseen
@LOOP  // asetetaan A-rekisteriin (LOOP):ia seuraavan rivin osoite (muistipaikka ROM muistissa)
0;JMP // Goto LOOP, lasketaan "nolla", ja riippumatta laskutoimituksen tuloksesta hypätään (LOOP):iin
(END)  // määrittää hyppyosoitteen
@END   // Kirjan tekijöiden tapa lopettaa ohjelman suoritus (menemällä ikuiseen silmukkaan lopuksi)
0;JMP // Infinite loop

HACK Assembly kielen käskyt

A-Instruction

• @value
• Missä value on ei-negatiivinen kokonaisluku
• Binäärisenä: 0vvv vvvv vvvv vvvv
• Käytetään lukuarvon tallentamiseen A-rekisteriin
• A-rekisterin arvoa voidaan käyttää kolmella eri tavalla
  • Tallennetaan vakio arvo (A = value)
  • Valitaan RAM muistipaikka (register = RAM[A])
  • Valitaan ROM muistin seuraava suoritettava käsky (muistipaikka) (PC = A)
• A-käskyä täytyy seurata C-käsky, joka määrää mitä A-rekisteriin tallennetulla lukuarvolla tehdään

HACK Assembly kielen käskyt

C-Instruction

• dest=comp;jump
  • comp
    • Kertoo ALU:lle mikä operaatio suoritetaan
    • Ja minkä rekisterin/muistipaikan arvoja käytetään operaatiossa
  • dest
    • Kertoo minne laskutoimituksen comp tulos tallennetaan
  • jump
    • Kertoo millä ehdolla hypätään (ladataan ohjelmalaskurille uusi arvo)

Vertaa ALU:n toimintaan

Comp(ute) -käsky

 (a=0) c1 c2 c3 c4 c5 c6  (a=1)
------ -- -- -- -- -- --  -----
    0   1  0  1  0  1  0    
    1   1  1  1  1  1  1
   -1   1  1  1  0  1  0
    D   0  0  1  1  0  0
    A   1  1  0  0  0  0     M
   !D   0  0  1  1  0  1
   !A   1  1  0  0  0  1    !M
   -D   0  0  1  1  1  1
   -A   1  1  0  0  1  1    -M
  D+1   0  1  1  1  1  1
  A+1   1  1  0  1  1  1   M+1
  D-1   0  0  1  1  1  0
  A-1   1  1  0  0  1  0   M-1
  D+A   0  0  0  0  1  0   D+M
  D-A   0  1  0  0  1  1   D-M
  A-D   0  0  0  1  1  1   M-D
  D&A   0  0  0  0  0  0   D&M
  D|A   0  1  0  1  0  1   D|M

Dest(ination)

d1 d2 d3   Mnemonic Destination (minne tallennetaan)
 0  0  0    null    Operaation tulosta ei tallenneta
 0  0  1    M       Memory[A] (RAM muistipaikka A)
 0  1  0    D       D register
 0  1  1    MD      Memory[A] and D register
 1  0  0    A       A register
 1  0  1    AM      A register and Memory[A]
 1  1  0    AD      A register and D register
 1  1  1    AMD     A register, Memory[A], and D register

Hyppykäskyt

   j1        j2        j3
(out < 0) (out = 0) (out > 0) Mnemonic 	Effect
   0         0	       0        null 	No jump
   0         0	       1         JGT 	If out > 0 jump
   0         1	       0         JEQ 	If out = 0 jump
   0         1	       1         JGE 	If out ≥ 0 jump
   1         0	       0         JLT 	If out < 0 jump
   1         0	       1         JNE 	If out ≠ 0 jump
   1         1	       0         JLE 	If out ≤ 0 jump
   1         1         1         JMP 	Jump

Mnemonic ≈ muistisääntö (assembly kielinen toteutus) 

HACK Assembly kielen käskyt

Esimerkki A-käskyn jälkeisistä C-käskyistä

• @47 // A=47

• D=A // D=47

• @47 // A=47

• D=M // D=RAM[47]

• @47 // A=47

• 0;JMP // Ladataan PC:lle uusi arvo (ROM muistin muistipaikka, josta ohjelman suoritusta jatketaan)

HACK Assembly kielen käskyt

Esimerkki A-käskyn jälkeisistä C-käskyistä

@47     // 0000000000101111 
D=A     // 111accccccdddjjj

@47     // 0000000000101111
D=M     // 111accccccdddjjj

@47     // 0000000000101111 
0;JMP   // 111accccccdddjjj

HACK tietokoneen näppäimistö ja näyttö

• Normaalia RAM muistia 16K, osoitteet väliltä 0 - 16383
  • 14-bittinen osoite, 2¹⁴ osoitetta
  • yhteen osoitteeseen voidaan tallentaa 16-bittinen sana
• Näyttö, osoitteet väliltä 16384 - 24575
  • Mustavalkoinen näyttö, väri tallennetaan yhteen bittiin
  • yksi muistipaikka 16-bittinen = 16 pikseliä
  • 256 riviä, 512 pikseliä per rivi
  • 256 * 512 * 1 = 131072 bittiä
  • 131072/16 = 8192 (8k) muistipaikkaa
  • Ei voida lukea, muistipaikkaan kirjoittamalla valitaan väri
• Näppäimistön muistiosoite 24576
  • Voidaan lukea mitä näppäintä on painettu, ei voi kirjoittaa

Esimerkkiohjelmia näppäimistön ja näytön käytöstä

• nappain.asm
• nappain2.asm
• nappain3.asm

WHILE logiikka

// while condition 
// while (10 - y < 0) {
while (y < 10) {
	code block 1
	// esim. y++
}
code block 2

(LOOP)
  // D = 10 - y tai D = y - 10
  D // not condition
  // tallennetaan D:hen False 
  // ehto, jolla hypätään
  @END
  D;JEQ
  // D ≠ 0
  code block 1 //y++ etc.
  @LOOP
  0;JMP
(END) // D = 0 eli false
  code block 2

IF logiikka

// if condition
if (x != 0) {
	code block 1
}
else { // x == 0
	code block 2
}
code block 3

  D // negatoitu ehto (not x)
  // D = !x
  // jos x == 0 -> D == !x == -1 (bin)
  // jos x == -1 -> D == !x == 0 (bin)
  @IF_TRUE
  D;JEQ // if D == 0 then jmp
  // else x == 0 (D ≠ 0)
  code block 2
  @END
  0;JMP
(IF_TRUE) // (x != 0)
  code block 1
(END)
  code block 3

Aliohjelmakutsu

Code block 1
Draw_letter(A);
Code block 2
Draw_letter(A);
Code block 4
...
void Draw_letter(Char x) {
  Code block 3
} // minne? miten palataan?

    Code block 1 Assemblynä
// paluuosoite aliohjelmasta, joka tallennetaan takaisin –muuttujaan
    @PALUUOSOITE
    D=A
    @takaisin
    M=D
    @DRAW_LETTER
    0;JMP
(PALUUOSOITE)  // tänne
    Code block 2 Assemblynä
    @PALUUOSOITE2
    D=A
    @takaisin
    M=D
    @DRAW_LETTER
    0;JMP
(PALUUOSOITE2)  // vai tänne
    Code block 4 Assemblynä

// jossain ROM muistissa
(DRAW_LETTER)
   Code block 3 Assemblynä
   @takaisin // paluuosoite
   A=M // RAM muistista
   0;JMP

HACK-tietokoneen ja -prosessorin toteutus

HACK-prosessorin toimintalogiikka

• Tulkitaan käsky instruction[16]
  • Jos A-käsky, niin
    • Viedään instruction[16] A-rekisteriin
  • Jos C-käsky, niin selvitetään biteistä
    • ALU:lle komento
    • Rekisterien/muistin sisällön vienti ALU:lle
    • ALU:n ulostulon tulkinta ja tallennus (rekisteriin/muistiin)
    • Hyppyehdon täyttyminen?
      • Asetetaan A-rekisterin arvo PC:n uudeksi arvoksi
      • Jos ei hypätä niin PC = PC + 1
• Käskyn suorituksen jälkeen noudetaan PC:n osoittama seuraava käsky

C-käsky binäärisenä

PC-Tietokone vs. HACK-tietokone

Välimuisti

Moniydinprosessorit

Keskeytykset

x86 Assembly

x86 arkkitehtuuri

• Assembly kieli, josta on kehittynyt nykyisten ’Intel-arkkitehtuuri’ –prosessorien assembly kielet
• Kehitetty alkujaan 16-bittisen Intel 8086 prosessorin kanssa
• Add5.c nykyisellä x86-64 assemblyllä
  • https://godbolt.org/g/I2sUcS

Ollaan tietokoneena

Muistien toteutus

SRAM

DRAM

Flash muisti NAND tekniikalla

• SSD-levyt, muistitikut, ...
• muistisolu vie vähemmän tilaa
  • suurempi tallennuskapasiteetti
  • vähemmän virtaa per bitti
• ei voida lukea tavu kerrallaan
• Nopeampi kirjoittaa
• vähemmän virtaa aktiivisena

Flash muisti NOR tekniikalla

• Ohjelmoitavat ROM-muistit
• Prosessorien ja mikrokontrollereiden käyttöön
• Nopeampi lukea
• Vähemmän virtaa stand-by tilassa

Esimerkki kertolaskun toteutuksesta

Kertolaskun säännöt

                       
   
0
      
0
      
1
      
1
 
x 0
    
x 1
    
x 0
    
x 1
          
   
0
      
0
      
0
      
1
	 
  Esim.
	
    10            
ab
       
  
x 11
          
x cd
           
    10         
ad bd
               (a AND d) (b AND d)
 
+ 10 
    
+ ac bc   
     (a AND c) (b AND c)  
   110	

  Esim.
	
    010                 
abc
       
  
x 111
               
x def
           
    010            
af bf cf
                     (a AND f) (b AND f) (c AND f)
   010          
ae be ce
              (a AND e) (b AND e) (c AND e)
+ 010  
    
+ ad bd cd      
 (a AND d) (b AND d) (c AND d)  
  01110	

Kertolasku omalla komponentilla

Assembler

• Assembler on ohjelma, joka kääntää Assembly kielisen ohjelman konekielelle
• Konekieli on joukko binäärisiä ”sanoja” jotka vastaavat prosessorin käskyjä
• Assembly kieli antaa binäärisille bittijoukoille paremmin muistettavat vastineet, esim.
  • 1111110111001000
  • M=M-1
• Jokaiselle prosessorityypille on oma konekieli ja siten myös assembly kieli

Toimintalogiikka

• Toista, kunnes .asm tiedoston EOF
  • Lue seuraava Assembly kielinen komento
  • Paloittele komento osiin
  • Hae osia vastaava binäärikoodi
  • Yhdistä koodit yhdeksi 16-bittiseksi konekieliseksi käskyksi
  • Anna ulostulona konekielinen koodi
    • kirjoita .hack tiedostoon uusi rivi

Toiminta ilman symboleita

• Jos tyhjä rivi tai kommentti → ei tehdä mitään
• Jos alkaa @ -merkillä, niin A-käsky
  • Esim. String @9 → pitää muuttaa String:iksi 0000000000001001
• Jos ei, niin tutkitaan löytyykö riviltä = -merkkiä ja ; -merkkiä,
  • jotta saadaan selville mitkä dest=comp;jump -osat käskyssä on
  • Selvitetään dest osaa vastaava binääriluku
  • Selvitetään comp osaa vastaava binääriluku
  • Selvitetään jump osaa vastaava binääriluku
  • Kasataan 16-bittinen konekielinen C-käsky yhdistämällä osat
• Voidaan olettaa että kommentit alkavat aina rivin alusta ja rivien lopussa ei ole kommentteja

HACK assembly -kielen symbolit

• Käydään koodi läpi etsimällä symbolit, esim. @sum tai @LOOP tai (LOOP)
  • Lisäksi riveiltä poistetaan kaikki kommentit ja kommenttien jälkeiset merkit, jos niitä on, esim.
  • D=M // D = first number
• Kahdenlaisia symboleita
  • Muuttujia, joille pitää varata muistiosoite, esimerkiksi @sum
  • Osoitteita joihin pitää hypätä, eli jossain on sama symboli kaarisuluissa
    • Esimerkiksi @LOOP ja (LOOP)
    • rivinumero tulee selvittää, jotta saadaan hyppypaikka

Toiminta symboleiden kanssa

• Ensin käydään läpi se, löytyykö symbolia vastaava hyppypaikka eli symboli suluissa, esim. (LOOP)
  • Löytyykö sulkuja? Jos löytyy, lisää suluissa oleva symbolitaulukkoon ja tallenna sulku-rivin alapuolisen rivin numero vastaamaan symbolia
• Sen jälkeen käydään koodi uudestaan läpi, etsien symboleita, esim. @sum tai @LOOP
  • Jos symbolitaulukossa, niin se on hyppy-symboli
  • Jos symbolia ei taulukossa, kyseessä on muuttuja, jolle pitää varata paikka RAM muistista (aloitetaan muistipaikasta 16)
• Symbolitaulukon toteutus esim. Javan hashtable:lla
• Lisäksi taulussa pitää olla muutama etukäteen määritelty symboli, jotka pitää muuttaa RAM osoitteiksi, esim. SCREEN
• Kun taulu valmis korvataan Assembly koodin symbolit niitä vastaavilla osoitteilla

Assemblerin toteutus

• Millä tahansa ohjelmointikielellä
• Suositeltava arkkitehtuuri
  • Parser moduuli: purkaa käskyt osiin
  • Code moduuli: kääntää osat binääriseksi
  • SymbolTable moduuli: hallinnoi symbolitaulua
  • Main moduuli: tiedoston luku/kirjoitus, käyttää yo. moduuleja ulostulon rakentamiseen
• Testaa Assembleriasi testiohjelmilla (add.asm etc.)
  • Versiot ilman symboleita tai symboleiden kanssa
• Lopuksi voit verrata Assembler-simulaattorilla simulaattorin kääntämää koodia sinun Assemblerin kääntämään koodiin

Kurssin luennot loppui

• Tehkää ahkerasti tehtäviä!
• Labraohjauksia tulee tarpeen mukaan myös ensi vuonna!
• Hyvää joulua kaikille!