Calcolatori Elettronici Assemblatore, Linker e Loader

Slides:



Advertisements
Presentazioni simili
Linguaggio C e C++.
Advertisements

Introduzione al linguaggio C++
Informatica Generale Marzia Buscemi
Una applicazione complessa non può essere sviluppata in un unico file: sarebbe ingestibile! Deve necessariamente essere strutturata su più file sorgente.
Digital FX!32 Conte Davide Crivello Emanuele Ferrando Elisa.
Classe III A A.s – 2011 Sistemi di Elaborazione e Trasmissione dell’Informazione 4 ore settimanali (2 laboratorio) Docenti Prof. Alberto Ferrari.
Dalla scrittura all’esecuzione
Gestione della memoria
Evoluzione dei linguaggi di programmazione
I linguaggi di programmazione
Generazione di Codice Intermedio
Massa Laura Mela Enrica
1 Classi di memorizzazione. 2 Definiscono le regole di visibilità delle variabili e delle funzioni quando il programma è diviso su più file Stabiliscono.
Generalità Linguaggio e Macchina Astratta
1 Strutture dati nel supporto a run time. 2 Entità presenti quando un programma va in esecuzione §programmi dutente (compilati) §routines del supporto.
Dr. Francesco Fabozzi Corso di Informatica
Chiamate a Procedure. Per lesecuzione di una procedura, un programma deve eseguire i seguenti sei passi: mettere i parametri in un posto dove la procedura.
SPIM Esercizi. Esercizio 7 – load/store Il codice deve: Inserire in memoria la word 0x a Leggere questo dato e inserirlo in s0 Sommarci 5 Salvare.
Introduzione alla programmazione
TRADUZIONE DEL PROGRAMMA Una volta che un programma sia stato scritto in C, esso non può essere eseguito senza unulteriore traduzione. Ciò perché qualsiasi.
Laboratorio di informatica: ASSEMBLER
Università degli Studi di Roma La Sapienza Architettura degli elaboratori II Funzioni.
Informatica di base A.A. 2003/2004 Algoritmi e programmi
File.
Programmazione Un programma descrive al computer, in estremo dettaglio, la sequenza di passi necessari a svolgere un particolare compito L’attività di.
CALCOLATORI ELETTRONICI Gestione delle subroutine.
Criticità sul controllo
Corso di Informatica Applicata - Lezione 3 - © 2005 Saverio De Vito Corso di Informatica Applicata Lezione 3 Università degli studi di Cassino Corso di.
Unità Didattica 2 I Linguaggi di Programmazione
memoria gestita staticamente:
Il sistema operativo Vito Perrone
Fondamenti di Informatica1 Software di base Tra il linguaggio macchina (basso livello) e i linguaggi evoluti (alto livello) esiste uno strato di software.
Espressioni condizionali
Architettura degli Elaboratori II (canale P-Z) Linguaggi e moduli
PROGRAMMARE IN C Un ambiente di sviluppo `e un software che serve per scrivere ed eseguire programmi. Generalmente integra almeno 3 funzionalita’: Editor:
Introduzione al linguaggio assembly del microprocessore a parte
Architettura degli Elaboratori II (canale P-Z) Istruzioni di controllo Dott. Franco Liberati.
Sottoprogramma Un blocco di istruzioni, come ad esempio lanello di ritardo, può costituire un sottoprogramma (subroutine) a sé stante, richiamabile dal.
G. Amodeo, C. Gaibisso Programmazione di Calcolatori Lezione VII Il compilatore e le sue opzioni Programmazione di Calcolatori: il compilatore e le sue.
INTERFACCIAMENTO ASSEMBLY - C++
Architettura degli Elaboratori II (canale P-Z) Modi di Indirizzamento Dott. Franco Liberati.

Complessità di un algoritmo
Generalità Software1Luglio 2004 Generalità Software Luglio 2004.
1 Università di Pavia - corso di Calcolatori Elettronici C code: L1:g = g + A[i]; i = i + j; if (i != h) goto L1; MIPS code: L1:add $t1, $s3, $s3# $t1.
- prof. V. Riboldi - SOTTOPROGRAMMI IN TPASCAL METODO TOP DOWN.
1 Università di Pavia - corso di Calcolatori Elettronici PROGETTO DI UN SISTEMA BASATO SU  P PROBLEMA REALE SVILUPPO HARDWARESVILUPPO SOFTWARE INTEGRAZIONE.
Arch. Elab. - S. Orlando 1 Esercitazione su Instruction Level Parallelism Salvatore Orlando.
Calcolatori Elettronici Introduzione al Pipelining
Elettronica Digitale (II Parte) 10-11_5 1 ELETTRONICA DIGITALE II (5) 6/12 Il processo di assemblaggio.
Calcolatori Elettronici Il Processore
Programmazione Assembly
Introduzione Laboratorio di Calcolo Corso di Laurea in Fisica Università degli Studi di Roma “La Sapienza”
Scrivere e compilare programmi
Compilazione separata
Esercitazione 3 Introduzione allo SPIM Pseudo-Istruzioni
L’esecuzione dei programmi
SPIM Esercizi. Esercizio 1 – il comando ‘li’ Il codice deve eseguire una singola operazione: mettere il valore immediato 1023 nel registro s3.
Concetti Fondamentali sulla Programmazione
Esercitazione 4 Chiamate di procedure Claudia Raibulet
Il software Claudia Raibulet
1 1. Introduzione alla gestione della memoria 2. Swapping 3. Memoria virtuale 4. Implementazione 5. Algoritmi di sostituzione Gestione della Memoria.
Esercizi.
1 Laboratorio di Programmazione di Sistema - C Susanna Pelagatti Ricevimento: Me ,
1 System Call ancora Vediamo passo passo come funziona una SC.
Laboratorio di Linguaggi... altre D O M A N D E ! Marco Tarini Università dell’Insubria Facoltà di Scienze Matematiche, Fisiche e Naturali di Varese Corso.
Corso di Laurea in Informatica Architettura degli elaboratori a.a Programmazione Assembly: procedure (1) Supporto hardware alle procedure Passaggio.
 Ogni processo che deve essere eseguito da un sistema di elaborazione, deve essere caricato e risiedere almeno parzialmente nella memoria centrale 
Corso di Laurea in Informatica Architettura degli elaboratori a.a ISA e Asm: esempi e suggerimenti.
Transcript della presentazione:

Calcolatori Elettronici Assemblatore, Linker e Loader Francesco Lo Presti rielaborate da Salvatore Tucci Give qualifications of instructors: DAP teaching computer architecture at Berkeley since 1977 Co-athor of textbook used in class Best known for being one of pioneers of RISC currently author of article on future of microprocessors in SciAm Sept 1995 RY took 152 as student, TAed 152,instructor in 152 undergrad and grad work at Berkeley joined NextGen to design fact 80x86 microprocessors one of architects of UltraSPARC fastest SPARC mper shipping this Fall Assembler, Linker & Loader

Compilazione Nella prima fase, il programma ad alto livello viene tradotto nel linguaggio assembler utilizzando un apposito programma detto compilatore Dopo la fase di compilazione, il programma scritto il linguaggio assembler viene tradotto in linguaggio macchina utilizzando un apposito programma detto assemblatore (assembler) Spesso con il termine compilazione si indica l’intero processo di traduzione da linguaggio ad alto livello a linguaggio macchina (essendo l’assemblatore spesso integrato con il compilatore) Assembler, Linker & Loader

Il processo di compilazione Il programma sorgente è scritto in un linguaggio ad alto livello (ad es., C) Il codice oggetto, scritto in linguaggio macchina, viene memorizzato su disco Il caricatore (loader) carica il programma in memoria principale per l’esecuzione Programma sorgente hello.c compilatore hello.s Programma in linguaggio assembler assemblatore Programma in linguaggio macchina (codice oggetto) hello.out caricatore Programma in memoria Assembler, Linker & Loader

Il linker Il linker (link editor o collegatore) ha il compito di collegare tra loro vari moduli che compongono lo stesso programma Programma sorgente suddiviso in più file che vengono compilati separatamente creando diversi file oggetto Utilizzo di funzioni di libreria Il linker collega tra loro i file contenenti il codice oggetto dei vari moduli che costituiscono il programma, unendovi anche il codice delle funzioni di libreria utilizzate, producendo un file contenente il codice eseguibile, memorizzato su disco Assembler, Linker & Loader

Esempio ... Assembler, Linker & Loader .globl main main:... jal proc .globl proc proc: addi $sp, $sp, -20 ... beq $s0, $zero, ret addi $a0, $s0, -1 addi $a1, $s1, 0 addi $a2, $s2, 0 jal proc addi $s3, $v0, 0 addi $a0, $s0, 0 jal is_in beq $v0, $zero, else2 sll $s3, $s3, 1 addi $s3, $s3, 1 j ret else2: addi $s3, $s3, 2 ret: addi $v0, $s3, 0 addi $sp, $sp, 20 jr $ra .globl is_in is_in: addi $t0, $zero, 0 addi $t1, $zero, 0 while: slt $t2, $t0, $a2 beq $t2, $zero, end sll $t3, $t0, 2 add $t3, $a1, $t3 lw $t4, 0($t3) bne $t4, $a0, inc addi $t1, $zero, 1 j end inc: addi $t0, $t0, 1 j while end: addi $v0, $t1, 0 jr $ra Assembler, Linker & Loader

L’assemblatore Traduce un modulo in assembler in un file oggetto Una combinazione di Istruzioni in linguaggio macchina Dati Informazioni per la corretta collocazione del modulo in memoria: Rilocazione Esempio Per poter tradurre in linguaggio macchina le istruzioni di salto, l’assemblatore deve poter determinare gli indirizzi corrispondenti alle etichette usate nei salti (tabella dei simboli) Tabella dei simboli: contiene le corrispondenze tra nomi delle etichette (simboli) ed indirizzi di memoria Il file oggetto prodotto dall’assemblatore assume che il modulo parta dalla locazione di memoria 0 (indirizzi relativi) Sarà il linker a gestire la rilocazione Istruzioni dipendenti da un indirizzo assoluto Assembler, Linker & Loader

Il processo di assemblaggio Il processo di traduzione in linguaggio macchina è semplice, salvo per le istruzioni con riferimenti a etichette locali non ancora dichiarate (riferimenti in avanti: l’etichetta è usata prima di essere definita) Assemblatore a due passate Prima passata: calcola la lunghezza delle istruzioni e genera una tabella dei simboli, contenente l’associazione tra i nomi delle etichette ed i corrispondenti indirizzi di memoria Seconda passata: tutti i riferimenti locali sono noti: usando la tabella dei simboli, può generare il codice macchina Assemblatore ad una passata Traduce in codice binario tutte le istruzioni tranne quelle con riferimenti in avanti (tecnica del backpatching) Mette queste istruzioni in una tabella dei simboli irrisolti Alla fine traduce anche queste Maggiore velocità ma intera rappresentazione binaria in memoria Assembler, Linker & Loader

Struttura del file oggetto Nei sistemi Unix, il file oggetto è composto da 6 sezioni distinte Object file header (intestazione) Dimensione e posizione delle altre parti del file oggetto Segmento di testo Codice in linguaggio macchina per le procedure nel file sorgente; possono esserci riferimenti irrisolti (istruzioni contenenti riferimenti a simboli esterni) Segmento di dati Rappresentazione binaria dei dati Informazioni di rilocazione Identificazione di istruzioni e dati da aggiornare al momento della rilocazione, in quanto dipendenti da indirizzi di memoria assoluti Tabella dei simboli Simboli definiti nel modulo e riferibili dall’esterno (etichette globali) e lista dei riferimenti irrisolti (ad es. per uso di funzioni di libreria) Informazioni per il debugger Descrizione concisa del modo in cui il programma è stato compilato Assembler, Linker & Loader

Esempio: Primo Passata .globl proc proc: addi $sp, $sp, -20 ... beq $s0, $zero, ret addi $a0, $s0, -1 addi $a1, $s1, 0 addi $a2, $s2, 0 jal proc addi $s3, $v0, 0 addi $a0, $s0, 0 jal is_in beq $v0, $zero, else2 sll $s3, $s3, 1 addi $s3, $s3, 1 j ret else2: addi $s3, $s3, 2 ret: addi $v0, $s3, 0 addi $sp, $sp, 20 jr $ra Tabella dei Simboli Etichetta Indirizzo proc 0x00 else2 0x60 ret 0x64 Assembler, Linker & Loader

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

Il linker Ciascun modulo ha il suo spazio degli indirizzi Quando i moduli vengono collegati occorre traslare i loro spazi degli indirizzi Occorre risolvere tutti i riferimenti esterni – tramite etichette globali - ossia le chiamate tra moduli e riferimenti a variabili globali Compiti del linker (a partire dalla tabella dei simboli e dalle informazioni di rilocazione) Porre simbolicamente in memoria istruzioni e dati Determinare gli indirizzi dei dati e delle etichette dei salti Unire i riferimenti interni ed esterni alle procedure Il linker produce un file oggetto che può essere eseguito sulla macchina Stesso formato del file oggetto ma con tutti i riferimenti risolti e senza informazioni di rilocazione Assembler, Linker & Loader

Esempio Assembler, Linker & Loader 0x400000 ... jal ??? 0x4000AC 0x4000B0 addi $sp, $sp, -20 ... beq $s0, $zero, 14 addi $a0, $s0, -1 addi $a1, $s1, 0 addi $a2, $s2, 0 jal 0x00 addi $s3, $v0, 0 addi $a0, $s0, 0 jal ??? beq $v0, $zero, 3 sll $s3, $s3, 1 addi $s3, $s3, 1 j 0x64 addi $s3, $s3, 2 addi $v0, $s3, 0 addi $sp, $sp, 20 jr $ra 0x400124 addi $t0, $zero, 0 addi $t1, $zero, 0 slt $t2, $t0, $a2 beq $t2, $zero, 8 sll $t3, $t0, 2 add $t3, $a1, $t3 lw $t4, 0($t3) bne $t4, $a0, 2 addi $t1, $zero, 1 j 0x30 addi $t0, $t0, 1 j 0x08 addi $v0, $t1, 0 jr $ra 0x400158 0x400120 Assembler, Linker & Loader

Esempio Assembler, Linker & Loader 0x400000 ... jal 0x4000B0 0x4000AC addi $sp, $sp, -20 ... beq $s0, $zero, 14 addi $a0, $s0, -1 addi $a1, $s1, 0 addi $a2, $s2, 0 jal 0x4000B0 addi $s3, $v0, 0 addi $a0, $s0, 0 jal 0x400124 beq $v0, $zero, 3 sll $s3, $s3, 1 addi $s3, $s3, 1 j 0x400104 addi $s3, $s3, 2 addi $v0, $s3, 0 addi $sp, $sp, 20 jr $ra 0x400124 addi $t0, $zero, 0 addi $t1, $zero, 0 slt $t2, $t0, $a2 beq $t2, $zero, 8 sll $t3, $t0, 2 add $t3, $a1, $t3 lw $t4, 0($t3) bne $t4, $a0, 2 addi $t1, $zero, 1 j 0x400154 addi $t0, $t0, 1 j 0x40012B addi $v0, $t1, 0 jr $ra 0x400158 0x400120 Assembler, Linker & Loader

Istruzioni MIPS da Rilocare Indirizzi relativi al PC (istruzioni beq e bne): da non rilocare L’indirizzamento relativo al PC è preservato anche se il codice viene spostato Indirizzi assoluti (istruzioni j e jal): da rilocare sempre Da rilocare anche istruzioni lw e sw che utilizzano il registro $gp per indirizzare dati statici Riferimenti esterni (tipicamente istruzione jal): da rilocare sempre Assembler, Linker & Loader

Il loader Una volta che il linker ha creato il file eseguibile, esso viene di solito memorizzato su disco All’atto dell’esecuzione, il S.O. lo carica dal disco e ne avvia l’esecuzione Il loader si occupa di far partire il programma Legge l’intestazione per determinare la dimensione dei segmenti testo e dati Crea uno spazio di memoria sufficiente per testo e dati Copia istruzioni e dati in memoria Copia nello stack i parametri (se presenti) passati al main Inizializza i registri e lo stack pointer 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() in C) Assembler, Linker & Loader

Librerie collegate dinamicamente Svantaggi del collegamento statico (prima dell’esecuzione del programma) Le routine della libreria fanno parte del codice eseguibile Uso di vecchie versioni della libreria anche se disponibili nuove versioni Caricamento dell’intera libreria anche se usata parzialmente Librerie collegate dinamicamente (DLL) Le routine della libreria non sono collegate e caricate finché il programma non viene eseguito Ogni routine viene collegata solo dopo essere invocata (lazy procedure linkage) Assembler, Linker & Loader