Sei sulla pagina 1di 4

Compilazione

Nella prima fase, il programma ad alto livello viene tradotto


nel linguaggio assembler utilizzando un apposito programma
Architetture dei Calcolatori detto compilatore
(Lettere A-I) Dopo la fase di compilazione, il programma scritto il
linguaggio assembler viene tradotto in linguaggio macchina
Assemblatore,
Assemblatore, Linker e Loader utilizzando un apposito programma detto assemblatore
(assembler)
Spesso con il termine compilazione si indica l lintero processo
Prof. Francesco Lo Presti di traduzione da linguaggio ad alto livello a linguaggio
macchina (essendo llassemblatore spesso integrato con il
compilatore)

Assembler, Linker & Loader 1 Assembler, Linker & Loader 2

Il processo di compilazione Il linker

Il programma sorgente Il linker (link editor o collegatore)


collegatore) ha il compito di collegare tra
Programma sorgente hello.c scritto in un linguaggio ad loro vari moduli che compongono lo stesso programma
alto livello (ad es., C) Programma sorgente suddiviso in pi
pi file che vengono compilati
compilatore separatamente creando diversi file oggetto
Utilizzo di funzioni di libreria
hello.s Il codice oggetto, scritto
Programma in linguaggio assembler in linguaggio macchina, Il linker collega tra loro i file contenenti il codice oggetto dei
viene memorizzato su vari moduli che costituiscono il programma, unendovi anche il
disco codice delle funzioni di libreria utilizzate, producendo un file
assemblatore
contenente il codice eseguibile, memorizzato su disco

Programma in linguaggio Il caricatore (loader)


macchina (codice oggetto) hello.out carica il programma in
memoria principale per
caricatore lesecuzione

Programma in memoria Assembler, Linker & Loader 3 Assembler, Linker & Loader 4
Esempio Lassemblatore
.globl main .globl proc .globl is_in
main:... proc: addi $sp, $sp, -20 is_in: addi $t0, $zero, 0
jal proc ... addi $t1, $zero, 0 Traduce un modulo in assembler in un file oggetto
... beq $s0, $zero, ret while: slt $t2, $t0, $a2 Una combinazione di
addi $a0, $s0, -1 beq $t2, $zero, end
9 Istruzioni in linguaggio macchina
addi $a1, $s1, 0
9 Dati
sll $t3, $t0, 2
addi $a2, $s2, 0 add $t3, $a1, $t3
jal proc
9 Informazioni per la corretta collocazione del modulo in memoria:
Rilocazione
lw $t4, 0($t3)
addi $s3, $v0, 0
Esempio
bne $t4, $a0, inc
addi $a0, $s0, 0

addi $t1, $zero, 1
addi $a1, $s1, 0 j end
9 Per poter tradurre in linguaggio macchina le istruzioni di salto,
salto,
addi $a2, $s2, 0
lassemblatore deve poter determinare gli indirizzi corrispondenti alle
etichette usate nei salti (tabella dei simboli)
inc: addi $t0, $t0, 1
jal is_in
9 Tabella dei simboli: contiene le corrispondenze tra nomi delle
j while
beq $v0, $zero, else2
etichette (simboli) ed indirizzi di memoria
end: addi $v0, $t1, 0
sll $s3, $s3, 1 jr $ra
addi $s3, $s3, 1 Il file oggetto prodotto dall
dallassemblatore assume che il
j ret modulo parta dalla locazione di memoria 0 (indirizzi relativi)
else2: addi $s3, $s3, 2 Sar
Sar il linker a gestire la rilocazione
ret: addi $v0, $s3, 0 9 Istruzioni dipendenti da un indirizzo assoluto
...
addi $sp, $sp, 20
Assembler, Linker & Loader 5 Assembler, Linker & Loader 6
jr $ra

Il processo di assemblaggio Struttura del file oggetto

Il processo di traduzione in linguaggio macchina semplice, Nei sistemi Unix,


Unix, il file oggetto composto da 6 sezioni distinte
salvo per le istruzioni con riferimenti a etichette locali non Object file header (intestazione)
ancora dichiarate (riferimenti in avanti: lletichetta usata 9 Dimensione e posizione delle altre parti del file oggetto
prima di essere definita)
Segmento di testo
9 Codice in linguaggio macchina per le procedure nel file sorgente;
sorgente;
Assemblatore a due passate possono esserci riferimenti irrisolti (istruzioni contenenti riferimenti
riferimenti a
Prima passata: calcola la lunghezza delle istruzioni e genera una simboli esterni)
tabella dei simboli, contenente llassociazione tra i nomi delle Segmento di dati
etichette ed i corrispondenti indirizzi di memoria
9 Rappresentazione binaria dei dati
Seconda passata: tutti i riferimenti locali sono noti: usando la
tabella dei simboli, pu generare il codice macchina Informazioni di rilocazione
9 Identificazione di istruzioni e dati da aggiornare al momento della
della
rilocazione,
rilocazione, in quanto dipendenti da indirizzi di memoria assoluti
Assemblatore ad una passata
Tabella dei simboli
Traduce in codice binario tutte le istruzioni tranne quelle con
riferimenti in avanti (tecnica del backpatching) 9 Simboli definiti nel modulo e riferibili dall
dallesterno (etichette globali) e
lista dei riferimenti irrisolti (ad es. per uso di funzioni di libreria)
Mette queste istruzioni in una tabella dei simboli irrisolti
Alla fine traduce anche queste Informazioni per il debugger
Maggiore velocit 9 Descrizione concisa del modo in cui il programma stato compilato
velocit ma intera rappresentazione binaria in memoria

Assembler, Linker & Loader 7 Assembler, Linker & Loader 8


Esempio: Primo Passata Esempio: Secondo Passata
.globl proc .globl proc
proc: addi $sp, $sp, -20 proc: addi $sp, $sp, -20 addi $sp, $sp, -20
... ... ...
beq $s0, $zero, ret
Tabella dei Simboli beq $s0, $zero, ret beq $s0, $zero, 14
Tabella dei Simboli
Etichetta Indirizzo
addi $a0, $s0, -1 Etichetta Indirizzo addi $a0, $s0, -1 addi $a0, $s0, -1
proc 0x00
addi $a1, $s1, 0
proc 0x00 addi $a1, $s1, 0 addi $a1, $s1, 0
else2 0x60
addi $a2, $s2, 0 addi $a2, $s2, 0 addi $a2, $s2, 0
ret 0x64
jal proc
else2 0x60 jal proc jal 0x0
addi $s3, $v0, 0 ret 0x64 addi $s3, $v0, 0 addi $s3, $v0, 0
Generazione
addi $a0, $s0, 0 addi $a0, $s0, 0 addi $a0, $s0, 0 Tabella dei Simboli
addi $a1, $s1, 0 addi $a1, $s1, 0 addi $a1, $s1, 0 Etichetta Indirizzo
addi $a2, $s2, 0 addi $a2, $s2, 0 Codice addi $a2, $s2, 0 proc 0x00
jal is_in jal is_in Macchina jal ??? is_in 0x4B
beq $v0, $zero, else2 beq $v0, $zero, else2 beq $v0, $zero, 3
Relocation Information
Istr.
Istr. Indirizzo
sll $s3, $s3, 1 sll $s3, $s3, 1 sll $s3, $s3, 1
addi $s3, $s3, 1 addi $s3, $s3, 1 addi $s3, $s3, 1 jal 0x38
j ret j ret j 0x64 jal 0x4B
else2: addi $s3, $s3, 2 else2: addi $s3, $s3, 2 addi $s3, $s3, 2 j 0x5B
ret: addi $v0, $s3, 0 ret: addi $v0, $s3, 0 addi $v0, $s3, 0
... ... ...
addi $sp, $sp, 20 addi $sp, $sp, 20 addi $sp, $sp, 20
Assembler, Linker & Loader 9 Assembler, Linker & Loader 10
jr $ra jr $ra jr $ra

Il linker Esempio
0x400000 ...
jal ???

0x4000AC ...

Ciascun modulo ha il suo spazio degli indirizzi 0x4000B0 addi $sp, $sp, -20

Quando i moduli vengono collegati occorre traslare i loro spazi degli


...

indirizzi
beq $s0, $zero, 14

Occorre risolvere tutti i riferimenti esterni tramite etichette


addi $a0, $s0, -1

globali - ossia le chiamate tra moduli e riferimenti a variabili


addi $a1, $s1, 0
0x400124 addi $t0, $zero, 0
addi $a2, $s2, 0
globali jal 0x00
addi $t1, $zero, 0

Compiti del linker (a partire dalla tabella dei simboli e dalle


slt $t2, $t0, $a2
addi $s3, $v0, 0

informazioni di rilocazione)
rilocazione)
beq $t2, $zero, 8
addi $a0, $s0, 0
sll $t3, $t0, 2
Porre simbolicamente in memoria istruzioni e dati
addi $a1, $s1, 0
add $t3, $a1, $t3
addi $a2, $s2, 0
Determinare gli indirizzi dei dati e delle etichette dei salti jal ???
lw $t4, 0($t3)

Unire i riferimenti interni ed esterni alle procedure beq $v0, $zero, 3


bne $t4, $a0, 2

Il linker produce un file oggetto che pu essere eseguito sulla


addi $t1, $zero, 1
sll $s3, $s3, 1

macchina
j 0x30
addi $s3, $s3, 1
addi $t0, $t0, 1
Stesso formato del file oggetto ma con tutti i riferimenti risolti
risolti e
j 0x64
j 0x08
senza informazioni di rilocazione
addi $s3, $s3, 2
addi $v0, $t1, 0
addi $v0, $s3, 0
... 0x400158 jr $ra

addi $sp, $sp, 20

0x400120 jr $ra

Assembler, Linker & Loader 11 Assembler, Linker & Loader 12


Esempio Istruzioni MIPS da Rilocare
0x400000 ...
jal 0x4000B0

0x4000AC ...

Indirizzi relativi al PC (istruzioni beq e bne):


bne): da
0x4000B0 addi $sp, $sp, -20
...
beq $s0, $zero, 14
non rilocare
addi $a0, $s0, -1
addi $a1, $s1, 0 Lindirizzamento relativo al PC preservato anche se il
0x400124
codice viene spostato
addi $t0, $zero, 0
addi $a2, $s2, 0
addi $t1, $zero, 0
jal 0x4000B0
addi $s3, $v0, 0
slt $t2, $t0, $a2
Indirizzi assoluti (istruzioni j e jal):
jal): da rilocare
sempre
beq $t2, $zero, 8
addi $a0, $s0, 0
sll $t3, $t0, 2
addi $a1, $s1, 0

Da rilocare anche istruzioni lw e sw che utilizzano


add $t3, $a1, $t3
addi $a2, $s2, 0
lw $t4, 0($t3)
jal 0x400124
beq $v0, $zero, 3
bne $t4, $a0, 2
addi $t1, $zero, 1
il registro $gp per indirizzare dati statici
sll $s3, $s3, 1
addi $s3, $s3, 1
j 0x400154
addi $t0, $t0, 1
Riferimenti esterni (tipicamente istruzione jal):jal): da
rilocare sempre
j 0x400104
j 0x40012B
addi $s3, $s3, 2
addi $v0, $t1, 0
addi $v0, $s3, 0
... 0x400158 jr $ra

addi $sp, $sp, 20

0x400120 jr $ra

Assembler, Linker & Loader 13 Assembler, Linker & Loader 14

Il loader Librerie collegate dinamicamente

Una volta che il linker ha creato il file eseguibile, Svantaggi del collegamento statico (prima
esso viene di solito memorizzato su disco dell
dellesecuzione del programma)
All
Allatto dell
dellesecuzione, il S.O. lo carica dal disco e Le routine della libreria fanno parte del codice eseguibile
ne avvia llesecuzione 9 Uso di vecchie versioni della libreria anche se disponibili
nuove versioni
Il loader si occupa di far partire il programma Caricamento dell
dellintera libreria anche se usata
Legge llintestazione per determinare la dimensione dei parzialmente
segmenti testo e dati
Librerie collegate dinamicamente (DLL)
Crea uno spazio di memoria sufficiente per testo e dati
Le routine della libreria non sono collegate e caricate
Copia istruzioni e dati in memoria finch
finch il programma non viene eseguito
Copia nello stack i parametri (se presenti) passati al main Ogni routine viene collegata solo dopo essere invocata
Inizializza i registri e lo stack pointer (lazy procedure linkage)
Salta ad una procedura di inizializzazione che copia i
parametri nei registri appositi dallo stack e poi invoca la
procedura di inizio del programma (main
(main()
() in C)
Assembler, Linker & Loader 15 Assembler, Linker & Loader 16