Linguaggio macchina e linguaggio assembly - diegm

FONDAMENTI DI INFORMATICA
Prof. PIER LUCA MONTESSORO
Università degli Studi di Udine
Linguaggio macchina e
linguaggio assembly
Formato delle istruzioni
15
8
gruppo
modo di indirizzamento
codice dell’istruzione
7
0
primo registro
(se presente)
secondo registro
(se presente)
In alternativa può contenere
un “offset” scritto su 8 bit
per le istruzioni di salto
Gruppi
• Trasferimento dati da e verso la memoria o tra registri
codice 0 (002)
• Istruzioni aritmetico-logiche
codice 1 (012)
• Input/output
codice 2 (102)
• Istruzioni di controllo
codice 3 (112)
Modi di indirizzamento
• Operando immediato
– codice 1 (012), mnemonico I: la parola che segue
l’istruzione contiene il dato
• Indirizzo assoluto
– codice 2 (102), mnemonico A: la parola che segue
l’istruzione contiene l’indirizzo del dato
• Indirizzo in registro
– codice 3 (112), mnemonico R: l’indirizzo del dato è
contenuto nel registro specificato
Gruppo “trasferimento dati”
LDWI d X load word
00010000dddd0000 DATA(16)
LDWA d A load word
00100000dddd0000 ADDR(16)
LDWR d a load word
00110000ddddaaaa
LDBI d X load byte
00010001dddd0000 DATA(8)
LDBA d A load byte
00100001dddd0000 ADDR(16)
LDBR d a load byte
00110001ddddaaaa
STWA s A store word 00100010ssss0000 ADDR(16)
STWR s a store word 00110010ssssaaaa
STBA s A store byte 00100011ssss0000 ADDR(16)
STBR s a store byte 00110011ssssaaaa
MV
s d move
00000100ssssdddd
PUSH s
push
00001000ssss0000
POP d
pop
00001001dddd0000
SPRD d
read SP
00001101dddd0000
SPWR s
write SP
00001110ssss0000
s, d, a: codice del registro interessato
(s = source, d = destination, a = address)
Esempio
LDWI R15 ABAC
indirizzo di
memoria
0000
0001
0002
0003
F0
10
AC
AB
registro 15
codice
operativo
operando
Gruppo “aritmetico-logiche”
ADD
SUB
NOT
AND
OR
XOR
INC
DEC
LSH
RSH
s
s
r
s
s
s
r
r
r
r
d
d
d
d
d
add
subtract
bitwise NOT
bitwise AND
bitwise OR
bitwise XOR
increment
decrement
left shift
right shift
01000000ssssdddd
01000001ssssdddd
01000010rrrr0000
01000011ssssdddd
01000100ssssdddd
01000101ssssdddd
01001000rrrr0000
01001001rrrr0000
01001010rrrr0000
01001011rrrr0000
s, d, r: codice del registro interessato
(s = source, d = destination)
Esempio
SUB R8 R10
registro R8
indirizzo di
memoria
0000
0001
8A
41
registro R10
codice
operativo
Gruppo “input/output”
INW
INB
OUTW
OUTB
TSTI
TSTO
d
d
s
s
A
A
A
A
A
A
input word
input byte
out word
out byte
test input
test output
10000000dddd0000
10000001dddd0000
10000010ssss0000
10000011ssss0000
1000010000000000
1000010100000000
IN_ADDR
IN_ADDR
OUT_ADDR
OUT_ADDR
IN_ADDR
OUT_ADDR
TSTI e TSTO settano il flag Z a 1 (vero) se
l’operazione di I/O è stata completata; se il
flag vale zero l’operazione di I/O va ripetuta
Gruppo “controllo”
BR
JMP
JMPZ
JMPNZ
JMPN
JMPNN
JMPC
JMPV
CALL
RET
HLT
A
f
f
f
f
f
f
f
A
branch
jump
jump if zero
jump if not zero
jump if negative
jump if not neg.
jump if carry
jump if overflow
subroutine call
return from sub.
halt
1100000000000000 ADDR
11000001ffffffff
11000010ffffffff
11000011ffffffff
11000100ffffffff
11000101ffffffff
11000110ffffffff
11000111ffffffff
1100100000000000 ADDR
1100100100000000
1100111100000000
ffffffff = valore dell’offset di salto
(8 bit in complemento a 2)
CALL e RET
• Fanno uso dello stack di sistema (tipo di dato
astratto LIFO: Last-In-First-Out implementato
mediante vettore)
• Analogia con una pila (“stack”) di piatti: si
inserisce in cima alla pila e si preleva in ordine
inverso a quello dell’inserimento
• Operazioni
– PUSH (inserisce)
– POP (preleva)
Stack di sistema
PUSH
stack pointer
punta sempre alla prima
posizione libera dello stack
POP
Esempio
POP  A75B
PUSH (A75B)
SP = 2
22
68
7
6
5
4
3
2
1
0
SP = 4
5B
A7
22
68
7
6
5
4
3
2
1
0
SP = 2
22
68
7
6
5
4
3
2
1
0
Riepilogo linguaggio
- In the following, uppercase symbols mean numbers, lowercase
symbols mean registers. For example, 'A' could be 0x32F5,
'a' could be R12
- 'r', 's', 'd', and 'a' represent the code (0 to 15) of the
register to be used:
r = register (the value in the register will be read and modified)
s = source (read only)
d = destination (the value in the register will overwritten)
a = (the value in the register will be used as a memory address)
- The ffffffff value represents a memory offset, positive (forward
branches) or negative (in 2's complement, for backword branches)
- Most of the instructions of the data trasfer group work on memory
data, addresses or registers:
xxxI = data is stored in memory in the location immediately
following the instruction code
xxxA = the instrucion code in memory is followed by the data
address
xxxR = two registers are used: one to sore the data, and another
one to store the memory address
Riepilogo linguaggio
Data transfer group:
____________________
assembly
inst. name
machine code
LDWI
LDWA
LDWR
LDBI
LDBA
LDBR
STWA
STWR
STBA
STBR
MV
PUSH
POP
SPRD
SPWR
load word
load word
load word
load byte
load byte
load byte
store word
store word
store byte
store byte
move
push
pop
read SP
write SP
00010000dddd0000
00100000dddd0000
00110000ddddaaaa
00010001dddd0000
00100001dddd0000
00110001ddddaaaa
00100010ssss0000
00110010ssssaaaa
00100011ssss0000
00110011ssssaaaa
00000100ssssdddd
00001000ssss0000
00001001dddd0000
00001101ssss0000
00001110ssss0000
d
d
d
d
d
d
s
s
s
s
s
s
d
d
s
X
A
a
X
A
a
A
a
A
a
d
action
DATA(16)
ADDR(16)
DATA(8)
ADDR(16)
ADDR(16)
ADDR(16)
d <- X
d <- mem[A]
d <- mem[a]
d <- X
d <- mem[A]
d <- mem[a]
mem[A] <- s
mem[a] <- s
mem[A] <- s
mem[a] <- s
d <- s
push (s)
d <- pop ()
d <- SP
SP <- s
Riepilogo linguaggio
Arithmetic-logic group:
_______________________
assembly inst. name
machine code
action (C operators)
ADD
SUB
NOT
AND
OR
XOR
INC
DEC
LSH
RSH
01000000ssssdddd
01000001ssssdddd
01000010rrrr0000
01000011ssssdddd
01000100ssssdddd
01000101ssssdddd
01001000rrrr0000
01001001rrrr0000
01001010rrrr0000
01001011rrrr0000
d
d
r
d
d
d
r
r
r
r
s
s
r
s
s
s
r
r
r
r
d
d
d
d
d
add
subtract
bitwise NOT
bitwise AND
bitwise OR
bitwise XOR
increment
decrement
left shift
right shift
<<<<<<<<<<-
d + s
d - s
~r
d & s
d | s
d ^ s
r + 1
r + 1
r << 1
r >> 1
Riepilogo linguaggio
Input/output group:
___________________
assembly inst. name
machine code
INW
INB
OUTW
OUTB
input word
input byte
out word
out byte
10000000dddd0000
10000001dddd0000
10000010ssss0000
10000011ssss0000
TSTI A
test input
1000010000000000 IN_ADDR(16)
TSTO A
test output 1000010100000000 OUT_ADDR(16)
d
d
s
s
A
A
A
A
action
IN_ADDR(16)
IN_ADDR(16)
OUT_ADDR(16)
OUT_ADDR(16)
d <- read[A]
d <- read[A]
out[A] <- s
out[A] <- s
if completed
Z <- 1
else
Z <- 0
if completed
Z <- 1
else
Z <- 0
Riepilogo linguaggio
Control group:
______________
assembly inst. name
machine code
action (C-like)
BR
JMP
JMPZ
JMPNZ
JMPN
JMPNN
JMPC
JMPV
CALL
RET
HLT
1100000000000000 ADDR(16)
11000001FFFFFFFF
11000010FFFFFFFF
11000011FFFFFFFF
11000100FFFFFFFF
11000101FFFFFFFF
11000110FFFFFFFF
11000111FFFFFFFF
1100100000000000 ADDR(16)
1100100100000000
1100111100000000
PC <- A
PC <- PC + F
if (z == 1) PC <- PC
if (z == 0) PC <- PC
if (N == 1) PC <- PC
if (N == 0) PC <- PC
if (C == 1) PC <- PC
if (V == 1) PC <- PC
push (PC); PC <- A
PC <- pop()
halt
A
F
F
F
F
F
F
F
A
branch
jump
jump if zero
jump if not zero
jump if negative
jump if not neg.
jump if carry
jump if overflow
subroutine call
return from sub.
halt
+
+
+
+
+
+
F
F
F
F
F
F
Istruzioni e flag
LDWI d X
LDWA d A
LDWR d a
LDBI d X
LDBA d A
LDBR d a
STWA s A
STWR s a
STBA s A
STBR s a
MV
s d
PUSH s
POP
d
SPRD d
SPWR s
ADD s d
SUB s d
NOT r
AND s d
OR s d
XOR s d
INC r
DEC r
load word
load word
load word
load byte
load byte
load byte
store word
store word
store byte
store byte
move
push
pop
read SP
write SP
add
subtract
bitwise NOT
bitwise AND
bitwise OR
bitwise XOR
increment
decrement
Z
D
D
D
D
D
D
D
D
D
D
D
D
D
D
D
D
D
N
D
D
D
D
D
D
D
D
D
D
D
D
D
D
C
D
D
0
0
0
0
D
D
V
D
D
0
0
0
0
D
D
LSH r
RSH r
INW d A
INB d A
OUTW s A
OUTB s A
TSTI A
TSTO A
BR
A
JMP
f
JMPZ f
JMPNZ f
JMPN f
JMPNN f
JMPC f
JMPV f
CALL A
RET
HLT
left shift
right shift
input word
input byte
out word
out byte
test input
test output
branch
jump
jump if zero
jump if not zero
jump if negative
jump if not neg.
jump if carry
jump if overflow
subroutine call
return from sub.
halt
Z
D
D
D
D
D
D
-
Legenda:
D = dipende dal risultato
- = non modificato
N
D
D
D
D
-
C
D
D
-
V
0
0
-
Assemblatore
• Programma che traduce il programma da linguaggio
assembly a linguaggio macchina
• Traduce le istruzioni
• Ignora gli eventuali commenti
• Calcola gli indirizzi di salto
• Riserva spazio in memoria per i dati
Fa uso di “ETICHETTE” e di speciali direttive
Esempio di programma in assembler
; somma N ( 3) numeri
N:
word 3
DATA: byte 5
byte 9
byte 0C
START: LDWA R1 N
LDWI R2 DATA
LDWI R10 0
LOOP: LDBR R11 R2
ADD R11 R10
INC R2
DEC R1
JMPNZ LOOP
HLT
(su 8 bit)
; variabile N iniz. a 3
; primo numero
; secondo numero
; terzo e ultimo numero
; inizio del programma
;
;
;
;
;
azzera R10
inizia il ciclo
somma al totale
passa al num. success.
decrem. il contatore
; in R10 c’e` la somma
Esempio di programma in assembler
; somma N ( 3) numeri (su 8 bit)
N:
word 3
; variabile N iniz. a 3
DATA: byte 5
; primo numero
byte 9
; secondo numero
byte 0C
; terzo e ultimo numero
START: LDWA R1 N
; inizio del programma
LDWI R2 DATA ETICHETTA: rappresenta un indirizzo di memoria il
LDWI R10 0
; azzera
cui valore
numerico R10
sarà calcolato dall’assemblatore
LOOP: LDBR R11 R2 durante
; la
inizia
ildelciclo
traduzione
programma in linguaggio
ADD R11 R10 macchina
; somma al totale
INC R2
; passa al num. success.
DEC R1
; decrem. il contatore
JMPNZ LOOP
HLT
; in R10 c’e` la somma
Esempio di programma in assembler
; somma N ( 3) numeri (su 8 bit)
N:
word 3
; variabile N iniz. a 3
DATA: byte 5
; primo numero
byte 9
; secondo numero
byte 0C
; terzo e ultimo numero
START: LDWA R1 N
; inizio del programma
LDWI R2 DATA
LDWI R10 0
; azzera R10
LOOP: LDBR R11 R2 Direttive;per
inizia
il ciclo
riservare spazio in memoria per le
ADD R11 R10 variabili;e inizializzarne
somma alil valore:
totale
INC R2
; BYTE:
passa
al num. success.
riserva un byte
DEC R1
; WORD:
decrem.
il contatore
riserva 2 byte
JMPNZ LOOP
HLT
; in R10 c’e` la somma
Esempio di programma in assembler
; somma N ( 3) numeri (su 8 bit)
N:
word 3
; variabile N iniz. a 3
DATA: byte 5
; primo numero
byte 9
; secondo numero
byte 0C
; terzo e ultimo numero
START: LDWA R1 N
; inizio del programma
LDWI R2 DATA
LDWI R10 0
; azzera R10
LOOP: LDBR R11 R2
; inizia il ciclo
ADD R11 R10
; somma al totale
COMMENTI: l’assemblatore
ignora il contenuto
dellaal num. success.
INC R2
; passa
riga a partire dal
DECpunto
R1 e virgola (compreso)
; decrem. il contatore
JMPNZ LOOP
HLT
; in R10 c’e` la somma
Programma in linguaggio macchina
assembly
N:
DATA:
indirizzo(h)
contenuto(h)
0000
0001
0002
0003
0004
0005
0006
0007
0008
0009
000A
000B
000C
000D
000E
000F
0010
0011
0012
03
00
05
09
0C
10
20
00
00
20
10
02
00
A0
10
00
00
B2
31
word 3
byte
byte
byte
START: LDWA
5
9
0C
R1 N
LDWI R2 DATA
LDWI R10 0
LOOP:
LDBR R11 R2
PRIMA IL
BYTE MENO
SIGNIFICATIVO!
}
}
}
}
}
}
}
0010000000010000
indirizzo di N
0001000000100000
indirizzo DATA
0001000010100000
valore zero
0011000110110010
segue
Programma in linguaggio macchina
assembly
ADD R11 R10
INC R2
DEC R1
JMPNZ LOOP
HALT
indirizzo(h)
contenuto(h)
0013
0014
0015
0016
0017
0018
0019
001A
001B
001C
BA
40
20
48
10
49
F6
C3
00
CF
}
}
}
}
}
0100000010111010
0100100000100000
0100100100010000
1100001111110110
1100111100000000
Indirizzo della prossima istruzione: 001Bh
Indirizzo di destinazione del salto (LOOP): 0011h
Offset del salto: 0011h - 001Bh = -000Ah
 F6h (in compl. a 2 su 8 bit)
Esercizio
• Si scriva un programma in linguaggio macchina (in binario)
per la lettura di una sequenza di caratteri da tastiera
• Si assuma che:
– la tastiera abbia indirizzo 0001h
– la sequenza di caratteri venga terminata dall’utente dal
carattere “carriage return”, codice ASCII 0Dh, e in memoria
dal valore zero
– i caratteri letti vadano memorizzati in memoria a partire
dall’indirizzo 0100h
– in 0000h ci sia il puntatore alla sequenza in memoria (0100h)
Soluzione (assembler)
D_ADDR:
word 0100
START:
LDWA R0 D_ADDR
LDBI R2 0D
INB R1 0001
TSTI 0001
JMPNZ LOOP
MV R1 R3
SUB R2 R1
JMPZ END
STBR R3 R0
INC R0
JMP LOOP
LDBI R3 0
STBR R3 R0
HALT
LOOP:
END:
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
indirizzo di memoria dove iniziare
a salvare i caratteri letti
carica l’indirizzo (0100) in R0
carica il codice ASCII di CR in R2
legge un carattere da tastiera
la lettura e` stata eseguita?
no: ripeti l’istruzione di input
salva in R3 il carattere letto
confronta con il codice ASCII di CR
se Z=1 fine della sequenza di input
salva il carattere letto
incrementa il puntatore
passa al carattere successivo
carica il valore 0 in R3
scrive 0 al termine della sequenza
Soluzione (linguaggio macchina)
assembly
D_ADDR:
word 0100
START:
LDWA R0 D_ADDR
LDBI R2 0D
LOOP:
INB R1 0001
TSTI 0001
JMPNZ LOOP
indirizzo(h)
0000
0001
0002
0003
0004
0005
0006
0007
0008
0009
000A
000B
000C
000D
000E
000F
0010
0011
0012
contenuto(h)
00
01
00
20
00
00
20
11
0D
10
81
01
00
00
84
01
00
F6
C3
}
}
}
}
D_ADDR
}
}
}
}
1: ind. tastiera
0010000000000000
ind. di D_ADDR
0001000100100000
CR (ASCII 1310)
} 1000000100010000
1000010000000000
1: ind. tastiera
1100001111110110
segue
Soluzione (linguaggio macchina)
assembly
MV R1 R3
SUB R2 R1
JMPZ END
STBR R3 R0
INC R0
JMP LOOP
END:
LDBI R3 0
STBR R3 R0
HALT
indirizzo(h)
0013
0014
0015
0016
0017
0018
0019
001A
001B
001C
001D
001E
001F
0020
0021
0022
0023
0024
0025
contenuto(h)
13
04
21
41
06
C2
30
33
00
48
EA
C1
30
11
00
30
33
00
CF
}
}
}
}
}
}
}
0000010000010011
}
}
0011001100110000
0100000100100001
1100001000000110
0011001100110000
0100100000000000
1100000111101010
0001000100110000
valore zero
1100111100000000