Traduzione da C a Catena di compilazione

Transcript

1 Traduzione da C a Vittorio Zaccaria Dicembre 2009 Catena di compilazione utilizzo di linguaggi intermedi di(ir) Analisi sintattica e trattamento degli errori Generazione del codice macchina linguaggio di alto livello assembly Ottimizzazione del codice macchina Assemblaggio e collegamento facoltativa codice oggetto (sinonimi binario, eseguibile, linguaggio macchina) 1

2 Analisi sintattica Analisi sintattica e generazione del codice verifica se il programma è int a; sintatticamente corretto segnala errori e warnings Generazione di codice il programma viene tradotto in linguaggio macchina il codice macchina prodotto è in forma simbolica (.S) ling. sorgente di alto livello char c; a = c + 1; A: DS.L 1 // int a C: DS.B 1 // char c MOVE.B C, D0 ADDI.B #1, D0 MOVE.L D0, A ling. macchina simbolico Assemblaggio e collegamento Assemblaggio: risolve simboli assemblatore indirizzo di memoria etichetta d istruzione Spiazzamento L istruzione simbolica viene tradotta in codifica numerica Collegamento unisce più moduli eseguibili per esempio programma e librerie standard (IO ecc) A: DS.L 1 // int a C: DS.B 1 // char c MOVE.B C, D0 ADDI.B #1, D0 MOVE.L D0, A ling. macchina simbolico codici operativi MOVE.B 1010 ADDI.B 1100 tab. dei simboli A 1010 C ling. macchina numerico 2

3 Note aggiuntive su assemblaggio e linker Assemblaggio Genera per ogni modulo: la tabella bll dii dei simboli lidl del modulo, generando il codice oggetto I riferimenti simbolici esterni Funzioni (extern) Variabili globali Modulo assemblato da indirizzo 0; Direttiva ORG: serve a posizionare l area istruzioni e viene gestito dal loader e dal Sistema Operativo (modulo di gestione della memoria) 3

4 Assemblaggio Etichette di salto: causano il problema forward references (risolto in 2 passi) CMP.L #0, D0 BGE LABEL_POS NEG.L D0 LABEL_POS Assemblaggio Costruzione tabella simboli modulo: indirizzi numerici di tutti i simboli Contiene anche cosanti simboliche (EQU) Per etichette che definiscono variabili Variabili non inizializzate vengono allocate in.bss Variabili inizializzate messe in.data Etichette associate ai salti Viene calcolato l offset (se possibile) Indirizzo assoluto (se possibile) 4

5 Linker Collega piu di un modulo oggetto/libreria Genera un unico programma binario eseguibile (in formato rilocabile) Unico spazio di indirizzamento Tecniche di traduzione da C ad assembly Note generali 5

6 Schema di compilazione da C ad assembly 68K Ispirato a GCC Fa uso di: banco di registri classi d istruzioni modi d indirizzamento e organizzazione del sottoprogramma Consiste in Traduzione statement tt tcc Traduzione invocazioni funzioni C Traduzione delle strutture di controllo Application Binary Interface Specifica di: Dimensione dei tipi di dati Allineamento dati e istruzioni Convenzioni di chiamata delle funzioni (passaggio parametri) Chiamate al sistema operativo Struttura dell eseguibile 6

7 Ingombro in memoria delle variabili Unita minima indirizzabile: singolo byte In C (Linux): sizeof (char) = 1 byte sizeof (short int) = 2 byte sizeof (int) = 4 byte sizeof (long int) = 8 byte (non utilizzabile su M68k) sizeof (array) = somma ingombri elementi sizeof (struct) = somma ingombri campi Non considereremo floating point 13 Posizione in memoria delle variabili C Globali: allocate a indirizzo prefissato Locali: allocate sulla pila Dinamiche: allocate sullo heap (gestito a sua volta all interno dell area dati del processo) D/A Op D/A. Op MEM Utilizzo tipico dei registri da parte del compilatore nel calcolo di un espressione o statement. MEM 7

8 Convenzioni per uso dei registri D0 D7 per variabili di tipo carattere o intero A0 A7 per variabili di tipo indirizzo registri A0 A5: indici a vettori registro A6 (o FP) come puntatore all area di attivazione registro A7 (o SP) come puntatore alla pila (usp o ssp) Il registro SR contiene i bit di esito Aggiornato da (MOVE CMP ADD SUB NEG ecc AND OR NOT ecc) Usato da istruzioni Bcc e DBcc 15 Dimensionamento dati 8 bit per carattere 32bit per intero Le istruzioni assembly devono avere un suffisso: B per dato da 8 bit byte W per dato da 16 bit parola L per dato da 32 bit parola lunga o doppia Es: MOVE.B D1, D2 // D2 [D1] 8 bit meno signif. MOVE.W D1, D2 // D2 [D1] 16 bit meno signif. MOVE.L D1, D2 // D2 [D1] registro completo 16 8

9 Dimensionamento indirizzi Registri d indirizzo (A0 A5): a 16 bit per memoria fisica i max da 64 K byte a 32 bit per memoria fisica max da 4 G byte Suffissi: W per indirizzo da 16 bit indirizzo corto L per indirizzo da 32 bit indirizzo lungo Es.: MOVEA.W A1, A2 // A2 [A1] 16 bit meno signif. MOVEA.L A1, A2 // A2 [A1] registro completo 17 Variabili globali conversione char c; int a; int b = 5; int vet [10]; int punt; short int d; ORG 1000 // decimale C: DS.B 1 A: DS.L 1 // oppure DS.B 4 B: DC.L 5 // inizializzazione VET: DS.L 10 // oppure DS.B 40 PUNT: DS.L 1 // oppure DS.B 4 D: DS.W 1 // oppure DS.B 2 tab. dei simboli C 1000 A 1001 B 1005 VET 1009 PUNT 1039 D 1043 DS riserva solo spazio senza inizializzarlo DC riserva spazio e lo inizializza il puntatore (di ogni tipo) è equiparato all intero 18 9

10 Variabile globale struct struct s { char c; int a; } tab. dei sim. S 1000 S.C 0 S.A 1 ORG 1000 // decimale S: DS.B 5 // = somma ingombri di c e a S.C: EQU 0 // spiazzamento di c in s S.A: EQU 1 // spiazzamento di a in s Allocazione spazio per l intera struct Definizione dei simboli di spiazzamento per l accesso agli elementi tidll della struct t Utilizzo del. per differenziare gli spiazzamenti da altre struct 19 Tecniche di traduzione da C ad assembly Traduzione di: Semplici statement Strutture di controllo Invocazione delle funzioni Espressioni 10

11 Traduzione semplici statement Regola base per la traduzione dei semplici statement C Assumiamo che lo statement sia una semplice manipolazione della variabile Assumere che la variabile sia sempre collocata in memoria Come tradurre gli statement C Caricando le variabili nei registri all inizio dello statement (o non appena serve) Memorizzandole allafine dello statement Ogni variabile cambiata deve essere memorizzata il prima possibile

12 Esempio, variabile globale intera int a; a = a + 1; A: DS.L 1 // spazio per int MOVE.L A, D0 // D0 [A] ADDI.L #1, D0 // D0 [D0] + 1 MOVE.L D0, A // A [D0] oppure (ottimizza senza passare per il registro D0) ADDI.L #1, A // A [A] + 1 dato che ADDI può lavorare direttamente in memoria 23 Variabile globale per puntatore int a; int punt; punt = &a; punt = punt + 1; A: DS.L 1 // spazio per int PUNT: DS.W 1 // spazio per punt // punt = &a MOVEA.W #A, A0 // A0 A MOVE.W A0, PUNT // PUNT [A0] // punt = punt + 1 MOVEA.W PUNT, A0 // A0 [PUNT] MOVE.L (A0), D0 // D0 [[A0]] ADDI.L #1, D0 // D0 [D0] + 1 MOVE.L D0, (A0) // [A0] [D0] non confondere tra assegnamento a puntatore (che ne modifica la cella di memoria) e a oggetto puntato (che non modifica la cella di memoria del puntatore) 24 12

13 Variabili locali int f () { int a; a = a + 1; } // LINK e altre EQU A: EQU 8 // vedi area di attivazione MOVE.L A(FP), D0 // D0 [A + [FP]] ADDI.L #1, D0 // D0 [D0] + 1 MOVE.L D0, A(FP) // A + [FP] [D0] oppure (ottimizza senza passare per il registro D0) 1 ADDI.L #1, A(FP) // A + [FP] [A + [FP]] + dato che ADDI può lavorare direttamente in memoria 25 Tecniche di ottimizzazione int a; int b; int c; a = a + b; c = a + 2; codice C di alto livello sorgente A: DS.L 1 B: DS.L 1 C: DS.L 1 // a = a + b MOVE.L A, D0 MOVE.L B, D1 ADD.L D0, D1 MOVE.L D1, A // c = a + 2 MOVE.L A, D0 ADDI.L #2, D0 MOVE.L D0, C A: DS.L 1 B: DS.L 1 C: DS.L 1 // a = a + b MOVE.L A, D0 ADD.L B, D0 MOVE.L D0, A // c = a + 2 MOVE.L A, D0 ADDI.L #2, D0 MOVE.L D0, C unificate A: DS.L 1 B: DS.L 1 C: DS.L 1 // a = a + b MOVE.L A, D0 ADD.L B, D0 MOVE.L D0, A // c = a + 2 ADDI.L #2, D0 MOVE.L D0, C eliminata codice plain ossia non ottimizzato unifica tramite semiortogonalità di ADD elimina tenendo var in registro dato D

14 Traduzione strutture di controllo If then if(cond) { Body } Test!COND Body vero Resto del programma 14

15 If then // var. globale int a; // condizione if (a == 5) { // ramo then } / end if / // seguito A: DS.L 1 // riserva mem per a MOVE.L A, D0 // D0 [A] CMPI.L #5, D0 // esiti [D0] 5 BNE FINE // se!= 0 va a FINE // ramo then FINE: // seguito va modificato com è ovvio per >, <, <=, == e!= idem se a è variabile locale od oggetto puntato 29 If then else if(cond) { b_then } else { b_else } Test!COND b_then BRA belse b_else Resto del programma vero 15

16 If then else // var. globale int a; // condizione if (a >= 5) { // ramo then } else { // ramo else } / end if / // seguito A: DS.L 1 // riserva mem per a MOVE.L A, D0 // D0 [A] CMPI.L #5, D0 // esiti [D0] 5 BLT ELSE // se < 0 va a ELSE // ramo then BRA FINE // va a FINE ELSE: // ramo else FINE: // seguito va modificato com è ovvio per >, <, <=, == e!= idem se a è variabile locale od oggetto puntato 31 While while(cond) { Body... } Test!COND Body BRA Resto del programma vero 16

17 While // var. globale int a; // condizione while (a >= 5) { // corpo } / end while / // seguito A: DS.L 1 // riserva mem per a CICLO: MOVE.L A, D0 // D0 [A] CMPI.L #5, D0 // esiti [D0] 5 BLT FINE // se < 0 va a FINE // corpo del ciclo BRA CICLO // torna a CICLO FINE: // seguito del ciclo va modificato com è ovvio per >, <, <=, == e!= idem se a è variabile locale od oggetto puntato 33 For INIZ for(iniz; COND; INCR) { Body } Test!COND Body INCR BRA Resto del programma vero 17

18 For // variabile globale int a; // testata del ciclo for (a = 1; a <= 5; a++) { // corpo del ciclo } / end for / // seguito del ciclo la variabile di conteggio a viene aggiornata in fondo al corpo del ciclo ( a++ è post-incremento) A: DS.L 1 // riserva mem per a MOVE.L #1, D0 // D0 1 a = 1 MOVE.L D0, A // A [D0] CICLO: MOVE.L A, D0 // D0 [A] a <= 5 5 CMPI.L #5, D0 // esiti [D0] BGT FINE // se > 0 va a FINE // corpo del ciclo a++ MOVE.L A, D0 // D0 [A] ADDI.L #1, D0 // D0 [D0] + 1 MOVE.L D0, A // A [D0] BRA CICLO // torna a CICLO FINE: // seguito del ciclo 35 va modificato per > < <= e a ++a a Invocazione di funzioni Passaggio parametri Creazione record diattivazione Creazione record di attivazione (anche chiamato stack frame o area di attivazione) 18

19 Passaggio parametri F(a,b,c) { registri Z = g(x, y, z) } Record di attivazione o Record di attivazione o registri Usare registri iin input puo implicare il salvataggio di tali registri se si invocano altre funzioni innestate. Usare registri in output puo implicare un salvataggio da parte di chi chiama (caller) Passaggio parametri In questa lezione tratteremo il passaggio parametri tivia record di attivazione i (i (sia in ingresso che in uscita) Riserveremo un opportuno spazio nel record di attivazione per tali parametri 19

20 Record di attivazione Altre variabili Variabili blocchi innestati C (FP) Salvataggio registri usati Record di attivazione (stack frame) composto da: Variabili locali Prev. stack frame pointer Ind. Rit. Par. in ingresso g(r,s,t) chiama FP Prev. FP Record di attivazione g SP SP f(a,b,c) FP Record di attivazione f Records funzioni precedenti SP Struttura di una chiamata a funzione (M68K) Main() Posiziona mento { parametri abcnel a,b,c record di attivazione di f r=f(a,b,c) } Salto ad f Main f(a,b,c) { int x,y; return d; } d viene salvato al posto di c (nel record di attivazione di f) al ritorno dalla funzione Creazione spazio per x, y sul record di attivazione Salvataggio altre info temporane sul record di attivazione f 20

21 Chiamata/ritorno da sottoprog. Chiamata BSR (branch to subroutine) salto vicino JSR (jump to subroutine) salto lontano Ritorno SP [SP] 4 [SP] [PC] PC i.e. dest. RFS (return from subroutine) PC [[SP]] SP [SP] Record di attivazione int f (int p, int q) { int a; int b; return } A7 (o SP) A6 (o FP) = i i - area della funzione f idem eventuali altri registri i - 12 eventuale registro it salvato i -8 i -4 i i + 4 i + 8 i + 12 variabile locale b variabile locale a puntatore al record del chiamante indirizzo dirientro al chiamante parametro p parametro q area del chiamante 42 21

22 Gestione record di attivazione // chiamante // impila parametri // funzione int f (int p, int q) ) { int a; // dich. int b; // dich. // elabora return // uscita } tab. dei sim. p 8 Q 12 A -4 B -8 F: LINK FP, # 8 P: EQU 8 // spi. par. p Q: EQU 12 // spi. par. q A: EQU -4 // spi. var. a B: EQU -8 // spi. var. b // elabora // sovrascrive Q UNLK FP RFS EQU dichiara il simbolo senza riservare spazio di memoria; lo spazio viene riservato dal chiamante (impilando i parametri) e da LINK (nella funzione) 43 Riassumendo I record di attivazione formano una lista concatenata Creazione del record: LINK A6, # N (N è la dimensione delle variabili locali) Deallocazione del record: UNLK A6 I parametri sono allocati in ordine inverso hanno spiazzamento positivo rispetto a FP le variabili locali hanno spiazzamento negativo rispetto a FP 22

23 Schema di sottoprogramma SUB1: LINK A6, #-N // riservo spazio per le var locali di SUB1 MOVEM.L D1-,-(SP) // salvo i registri che uso // preparazione a chiamata di un altra funzione con due parametri MOVE.L, -(SP) // push secondo parametro MOVE.L, -(SP) // push primo parametro BRS SUB2 // chiamata ADDA.L #4, SP // pop (n-1)parametri * dim parametri MOVE.L (SP)+, // spilo e uso il valore in uscita di SUB2 // sovrascritto al primo parametro MOVE.L, spiaz.(a6) // salvo in stack il valore restituito da SUB1 in posizione (+4 per ind.rit. + 4(n), n numero di parametri, 4 dim parametri) rispetto a FP MOVEM.L (SP)+,D1- // ripristino i registri UNLK A6 // elimino var. locali RTS // ritorno al chiamante 45 Conversione espressioni 23

24 Albero sintattico Esempio di statement C: Z=(A+B)*(C-D)+5 ALBERO SINTATTICO Z * = A B C D Albero intermedio annotato con loads e stores Z stor e legenda Risultato temporaneo Contenuto in un registro Valore di una variabile In memoria * load load load load Ipotesi variabili globali A B C D 24

25 Tile Ogni istruzione e rappresentabile come un tile, il quale ha una forma ad albero. E un pattern MOVE Da, indirizzo_ var indirizzo_var (globale) store tile Da Altro esempio di tile Da MOVE indirizzo_var, Da load tile indirizzo_var 25

26 Altro esempio di tile Operazioni binarie aritmetiche (ADD, MUL, SUB etc.) SUB Da, Db Db (Db-Da) Db Da SUB #cost, Da ATTENZIONE ALL ORDINE OPERANDI Da Da cost Instruction selection Copertura totale dell albero lb con i tile delle istruzioni a disposizione Z stor e + 5 * + load load load load A B C D 26

27 Allocazione dei registri Z Allocare i registri stor associati itialle e load D2 I registri D2 associati ai D1 * D2 trasferimenti + temporanei sono bloccati + 5 D0 D1 D2 D3 load load load load A B C D Generazione del codice Visitare l albero in post ordine stor Scegliere sempre e strada a sinistra Ultima volta che si + 5 esce dal nodo * numerarlo e generare istruzione + Z load load load load A B C D 27

28 Codice generato MOVE.L A, D0 MOVE.L B, D1 ADD.L D0, D1 MOVE.L C, D2 MOVE.L D, D3 SUB.L D3, D2 MULS D1, D2. #5, MOVE.L D2, Z Z stor e D2 + 5 D1 * D2 ADD.L #5, D2 + D2 D0 D1 D2 D3 load load load load A B C D Chiamate di funzioni Il tile associato ad una chiamata di funzione (passaggio via record di attivazione) Dc funzione(x,y,z) Da Db Dc MOVE.L Dc, -(A7) MOVE.L Db, -(A7) MOVE.L Da, -(A7) BSR Funzione ADDA #8, A7 MOVE.L (A7)+, Dc 28