Laboratorio di informatica: ASSEMBLER

Download Report

Transcript Laboratorio di informatica: ASSEMBLER

Laboratorio di informatica:
ASSEMBLER
Dott. Alessio Malizia
[email protected]
Introduzione
Il linguaggio assemblatore (assembly language) o
assembler fornisce una rappresentazione simbolicamnemonica della codifica binaria delle istruzioni in
linguaggio macchina.
A tal fine l’assemblatore:


gestisce i nomi simbolici per le istruzioni e per le celle di
memoria,
gestisce un insieme di strumenti che agevolano la
programmazione e aumentano la chiarezza dei programmi
come etichette e macro.
Schema Linker
Modulo
sorgente
Assemblatore
Libreria
Modulo
sorgente
Assemblatore
Modulo
oggetto
Collegatore
Modulo
oggetto
Modulo
eseguibile
Vantaggi e Svantaggi
Risulta utile programmare utilizzando un linguaggio
assemblatore quando si ha la necessità di:


Raggiungere un’elevata velocità
Ridurre le dimensioni del programma
Lo svantaggio principale della programmazione in un
linguaggio assemblatore è che i programmi ottenuti
sono fortemente legati al calcolatore per cui sono
stati progettati e vanno riscritti se li si vuole
trasportare su un calcolatore differente, tale
inconveniente è aggravato dalla rapida evoluzione dei
calcolatori per cui un’architettura viene presto
soppiantata da architetture piu’ nuove e piu’ veloci.
Memoria del MIPS
SPIM
SPIM è un simulatore software che permette
l’esecuzione di programmi scritti nel linguaggio
macchina del processore MIPS 2000/3000.
L’architettura MIPS è un esempio classico (anche se
superata) di architettura RISC (Reduced Instruction
Set Computer) e per questo piu’ semplice da
programmare.
Indirizzi web:


http://www.cs.wisc.edu/~larus/spim.html
ftp://ftp.cs.wisc.edu/pub/spim
I registri
I registri (2)
L’unità centrale di elaborazione MIPS è dotata di 32 registri a 32
bit di uso generale numerati da $0 a $31.
Il registro $0 contiene sempre il valore 0.
Il registro $at ($1) è riservato alle pseudoistruzioni
dell’assemblatore, i registri $k0 ($26) e $k1 ($27) sono riservati
al nucleo del sistema operativo; questi tre registri non
andrebbero mai usati da parte di altri programmi o da parte dei
compilatori.
I registri $a0, $a1, $a2 e $a3 ($4, $5, $6 e $7) sono usati per
passare fino a 4 argomenti al sottoprogramma (eventuali altri
argomenti possono essere passati tramite la pila).
I registri (3)
I registri $v0 e $v1 ($2 e $3) sono usati per restituire argomenti
al programma chiamante.
I registri da $t0 a $t9 (da $8 a $15 piu’ $24 e $25) vengono
chiamati registri di salvataggio temporaneo e vengono usati per
memorizzare temporaneamente valori che non interessa
conservare per tutta la durata dell’esecuzione del
sottoprogramma.
I registri da $s0 a $s7 (da $16 a $23) vengono chiamati
registri di salvataggio permanente e servono per memorizzare
valori che vanno conservati inalterati per tutta la durata del
sottoprogramma.
I registri (4)
Il registro $gp ($28) è un puntatore globale che fa riferimento
al punto medio di un blocco di memoria da 64K appartenente al
segmento dei dati dinamici.
Il registro $sp ($29) è il puntatore alla pila (stack pointer) e
fa riferimento alla prima cella di memoria libera sulla cima della
pila.
Il registro $fp ($30) è il puntatore di attivazione di procedura
(frame pointer).
Il registro $ra - return address - ($31) viene aggiornato
dall’istruzione jal in modo che contenga l’indirizzo di rientro da
una chiamata a procedura eseguita con istruzione jal.
La finestra Text
La finestra Data
Comandi di SPIM
QUIET terminazione del simulatore e ritorno al sistema operativo
LOAD caricamento di un modulo contenente codice assemblatore o codice
eseguibile
RUN lancio della simuzione dell’esecuzione del programma caricato
STEP simulazione dell’esecuzione passo−passo del programma caricato
CLEAR cancellazione dei registri e della memoria
SET VALUE inserimento del valore specificato in un registro o in una cella di
memoria
PRINT visualizzazione del contenuto di un registro o di una cella di memoria
BREAKPOINT inserimento o cancellazione di un’istruzione di sospensione o
elenco di tutte le istruzioni di ssospensione inserite nel programma
HELP visualizzazione di messaggi di assistenza
TERMINAL apertura o chiusura della finestra console
MODE impostazione della modalità operativa di SPIM
Sintassi assemblatore SPIM
In linguaggio assemblatore i commenti iniziano con il carattere #: tutti i caratteri
fino alla fine della linea vengono ignorati dall’assemblatore.
Gli identificatori, cioè etichette e codici operativi mnemonici, sono sequenze
alfanumeriche che includono i caratteri "_ " e ". " e non possono cominciare con
un numero.
I codici operativi mnemonici sono considerate parole chiave e non possono
essere usati come etichette.
Qualsiasi identificatore che cominci in prima colonna e termini con il carattere
due punti ":“ viene considerato etichetta.
I numeri interi vengono automaticamente considerati in base 10; il prefisso 0x
serve ad indicare numeri espressi in base 16; per esempio 256 e 0x100 hanno lo
stesso valore.
Le stringe vanno racchiuse tra doppi apici (").
Caratteri speciali seguono le convenzioni C:



\n carattere di ritorno (newline)
\t carattere di tabulazione (tab)
\" doppio apice (quote).
Esempio di programma
Chiamate di Sistema
Codice di “la risposta è 5”
Rappresentazione delle istruzioni
Modalità di indirizzamento
Modalità di indirizzamento (2)
Esercizi (1)
Soluzioni (1a)
Soluzioni (1b)
Esercizi (2)
Soluzioni (2a)
Soluzioni (2b)
Esempi (1)
Alcuni esempi su come inizializzare e
leggere variabili globali e su come
eseguire operazioni di Input/Output
usando la Console
Esempi (2)
Esempi (3)
Esempi (4)
Esempi (5)
Esempi (6)
Esempi (7)
Esempi (8)
Progetti
Riempimento degli elementi di una
matrice
Fattoriale di un numero intero
(ricorsivo)
Numeri di Fibonacci, vers. Ricorsiva di
complessità esponenziale
Numeri di Fibonacci, vers. Ricorsiva di
complessità lineare
Riempimento degli elementi di
una matrice
Programma che definisce una matrice 10x10 in cui ogni elemento assume
come valore la somma dell'indice di riga e dell'indice di colonna, cioè
matrice(i,j)=i+j con i,j=0,...,9.
.data
nrig: .word 10
# definizione del valore del numero di righe della
matrice
ncol: .word 10
# definizione del valore del numero di colonne della
matrice
matrice: .word 0:100 # definizione dell'area di memoria che conterrà la
matrice
# (100 words inizializzate col valore 0)
.text
.globl main
Riempimento degli elementi di
una matrice
main:
li $t0,0
li $t1,0
a9
li $t2,0
# in $t0 viene posto l'indice di riga i che assume valori da 0 a 9
# in $t1 viene posto l'indice di colonna j che assume valori da 0
# in $t2 viene posto l'indice k utilizzato per lo scorrimento delle
# locazioni di memoria
lw $t3,nrig
lw $t4,ncol
ciclo:
add $t5, $t0, $t1
sw $t5, matrice($t2)
addi $t2, $t2, 4
addi $t1, $t1, 1
blt $t1, $t4, ciclo
Riempimento degli elementi di
una matrice
li $t1, 0
addi $t0,$t0,1
blt $t0, $t3, ciclo
li $v0, 10
syscall
# Quando si carica il programma si può osservare che nell'area Data
Segments si ha:
# a partire dall'indirizzo 0x10010000
# - i dati 0x0000000a 0x0000000a 0x00000000 0x0000000
# - a partire dall'indirizzo 0x10010010 lo spazio riservato alla matrice
Fattoriale di un numero intero
(ricorsivo)
Programma che calcola il fattoriale di un numero in modo ricorsivo: dato il valore n
di cui si vuole calcolare il fattoriale si ha che n!= n x (n-1)! = n x (n-1) x (n-2)!
= ... Si procede quindi chiamando fatt (etichetta della parte ricorsiva di
programma) sul valore n, si decrementa n e si chiama fatt su n-1 e cosi' via.
Ogni volta che si procede ad una nuova chiamata bisogna memorizzare nella pila
il valore su cui si va a fare la nuova chiamata e l'indirizzo a cui si vuole tornare
alla chiusura di tale chiamata. Osservate che venono usati rispettivamente i
registri $a0 per passare il valore e $v0 per riportare il risultato come indicato
nelle convenzioni dell'uso dei registri per le chiamate a procedura.
.data
elemento: .word 4 # definizione del valore di cui si vuole calcolare il fattoriale
.text
.globl main
Fattoriale di un numero intero
(ricorsivo)
main:
lw $a0,elemento # si carica nel registro $a0 elemento (cioè il valore 4)
jal fatt
# salto all'etichetta fatt e memorizzazione dell'indirizzo dell'istruzione
# successiva nel registro $31 cioè $ra (ove la sigla ra sta proprio per
# return address)
move $t0, $v0
# pone il contenuto del registro $v0 nel registro $t0
li $v0,10
# pone nel registro $v0 il valore 10 (codice numerico per la chiamata a
# sistema operativo che esegue la terminazione del programma)
syscall
# chiamata a sistema operativo
fatt:
beq $a0, $0, esci # salto all'etichetta esci se il valore attuale di elemento (contenuto nel
# registro $a0) è zero
subu $sp, $sp, 8 # il valore del puntatore alla pila (registro $sp - stack pointer) viene
# decrementato di 8 (8 byte corrispondono a due parole di memoria ognuna
# di 32 bit
Fattoriale di un numero intero
(ricorsivo)
sw $ra,4($sp)
# si pone il valore presente nel registro $ra nella pila, precisamente nella
# locazione precedente a quella indicata dal puntatore alla pila: 4($sp)
sw $a0,8($sp)
# si pone il valore presente nel registro $a0 nella pila, precisamente nella
# locazione precedente di due posizioni rispetto a quella indicata dal
# puntatore alla pila: 8($sp)
sub $a0,$a0,1
# si decrementa elemento di uno
jal fatt
# salto all'etichetta fatt
lw $a0,8($sp)
# recupero del valore presente nella pila da porre nel registro $a0
lw $ra,4($sp)
# recupero del valore presente nella pila da porre nel registro $ra
mul $v0, $a0,$v0 # si moltiplica il valore attuale contenuto in $v0 con il valore in $a0
# appena recuperato dalla pila e si pone in $v0
add $sp, $sp,8
# si aggiorna il valore del puntatore alla pila poichè i dati dono stati
# recuperati
jr $ra
# salto all'indirizzo contenuto nel registro $ra (ultimo valore recuperato
# dalla pila)
Fattoriale di un numero intero
(ricorsivo)
esci:
li $v0,1
jr $ra
# si arriva a questa etichetta se il valore attuale di $a0 è zero cioè se
#l'ultimo valore di $a0 posto nella pila è uno
# inizializzazione del valore di $v0, cioè del fattoriale, con il valore di
# $a0 che è uno
# salto all'indirizzo contenuto nel registro $ra