GENERAZIONE CODICE MACCHINA Daniela Briola Lorena Bellino

GENERAZIONE CODICE GENERAZIONE CODICE MACCHINAMACCHINA

Daniela BriolaDaniela Briola

Lorena BellinoLorena Bellino

Funzione getregFunzione getreg

• Restituisce la locazione L destinata a Restituisce la locazione L destinata a ospitare il valore di x nelle istruzioni del ospitare il valore di x nelle istruzioni del tipo tipo x := y op zx := y op z

• Locazioni restituite dalla funzione:Locazioni restituite dalla funzione:– L è il registro che contiene yL è il registro che contiene y– L è un registro vuotoL è un registro vuoto– L è un registro occupatoL è un registro occupato– L è la locazione di xL è la locazione di x

Esempio 1/2Esempio 1/2

• d := (a - b) + (a - c) +(a - c)d := (a - b) + (a - c) +(a - c)

t := a – bt := a – b

u := a – cu := a – c

v := t + uv := t + u

d := v + ud := v + u


StatementStatement CodeCode

generatedgenerated

RegisterRegister

descriptordescriptor

Address Address

descriptordescriptor

t := a - bt := a - b MOV a, R0MOV a, R0

SUB b, R0SUB b, R0

R0 contiene tR0 contiene t t in R0t in R0

u := a - cu := a - c MOV a, R1MOV a, R1

SUB c, R1SUB c, R1

R0 contiene tR0 contiene t

R1 contiene uR1 contiene u

t in R0t in R0

u in R1u in R1

v := t + uv := t + u ADD R1, R0ADD R1, R0 R0 contiene vR0 contiene v

R1 contiene uR1 contiene u

u in R1u in R1

v in R0v in R0

d := v + ud := v + u ADD R1, R0ADD R1, R0 R0 contiene dR0 contiene d d in R0d in R0

MOV R0, dMOV R0, d d in R0 e in d in R0 e in memoriamemoria

IndiciIndici

statementstatement

i in register Rii in register Ri i in memoria Mii in memoria Mi i nello stacki nello stack

codicecodice costocosto codicecodice costocosto codicecodice costocosto

a := b[i]a := b[i] MOV b(Ri), RMOV b(Ri), R 22MOV Mi, RMOV Mi, R

MOV b(R), RMOV b(R), R44

MOV Si(A), RMOV Si(A), R

MOV b(R), RMOV b(R), R44

a[i] := ba[i] := b MOV b, a(Ri)MOV b, a(Ri) 33MOV Mi, RMOV Mi, R

MOV b, a(R)MOV b, a(R)55

MOV Si(A), RMOV Si(A), R

MOV b, a(R)MOV b, a(R)55

Istruzioni condizionaliIstruzioni condizionali

• Branch conditionBranch condition• Condition code: che indicano se l’ultima quantità Condition code: che indicano se l’ultima quantità

calcolata è positiva, negativa o zerocalcolata è positiva, negativa o zero– Esempio:Esempio:

• If x < y goto z -----> CMP x, yIf x < y goto z -----> CMP x, y CJ< zCJ< z

• x := y + z MOV y, R0x := y + z MOV y, R0if x < 0 goto z ------> ADD z, R0if x < 0 goto z ------> ADD z, R0if x > 0 goto wif x > 0 goto w MOV R0, x MOV R0, x

CJ< zCJ< z CJ> wCJ> w

Allocazione e assegnazione registriAllocazione e assegnazione registri

• LocaleLocale– Assegnazione di specifici valori a determinati registriAssegnazione di specifici valori a determinati registri– Più semplice da implementare ma meno efficientePiù semplice da implementare ma meno efficiente

• GlobaleGlobale– Registri mantengono i valori per la durata del bloccoRegistri mantengono i valori per la durata del blocco– Registri riservati alle variabili più utilizzateRegistri riservati alle variabili più utilizzate– Più efficiente ma più complesso da implementarePiù efficiente ma più complesso da implementare

Allocazione e assegnazione registriAllocazione e assegnazione registri

• Risparmi– Utilizzo di x in loop L non preceduto da assegnazione -1– per ogni blocco di L in cui x è vivo all’uscita e gli viene

assegnato un valore nel blocco -2

• Allocazione di un registro ad una variabile x in un loop L:

∑B L use(x, B) + 2 * live(x, B) (*)

Dove:• Use(x, B): n° volte in cui x è usato in B prima di ogni

definizione di x• Live(x, B): 1 se x è viva all’uscita di B e gli viene assegnato

un valore in B, 0 altrimenti


∑B L use(x, B) + 2 * live(x, B)

R0, R1, R2


• Valutazione di (*) per x = a:Valutazione di (*) per x = a:

– ∑∑B B L L 2*live(a, B) = 22*live(a, B) = 2

– ∑ ∑B B L L use(a, B) = 0 + 1 + 1 + 0 = 2use(a, B) = 0 + 1 + 1 + 0 = 2

– ∑∑B B L L use(a, B) + 2 * live(a, B) = 4use(a, B) + 2 * live(a, B) = 4

– Per b, c, d, e, f i valori sono rispettivamente 6, 3, 6, 4, Per b, c, d, e, f i valori sono rispettivamente 6, 3, 6, 4, 44

– È ragionevole pensare che R0, R1ed R2 mantengano È ragionevole pensare che R0, R1ed R2 mantengano i valori di a, b, di valori di a, b, d

Rappresentazione di BB tramite dagsRappresentazione di BB tramite dags

• I dag sono utili strutture per rappresentare I dag sono utili strutture per rappresentare i BBi BB

• Etichette sui nodi:Etichette sui nodi:– Foglie etichettate da identificatori unici: nomi Foglie etichettate da identificatori unici: nomi

di variabili o costantidi variabili o costanti– Nodi interni etichettati da operatoriNodi interni etichettati da operatori– I nodi possono avere opzionalmente una I nodi possono avere opzionalmente una

sequenza di identificatori che rappresentano i sequenza di identificatori che rappresentano i corrispondenti valori calcolaticorrispondenti valori calcolati

EsempioEsempio

1.1. t1 := 4 * it1 := 4 * i2.2. t2 := a[t1]t2 := a[t1]3.3. t3 := 4 * it3 := 4 * i4.4. t4 := b[t3]t4 := b[t3]5.5. t5 := t2 * t4t5 := t2 * t46.6. t6 := prod + t5t6 := prod + t57.7. prod := t6prod := t68.8. t7 := i + 1t7 := i + 19.9. i := t7i := t710.10. if i <= 20 goto 1.if i <= 20 goto 1.

Costruzione dag – Algoritmo 1/3Costruzione dag – Algoritmo 1/3

• Input: basic block (BB)Input: basic block (BB)• Output: dag rappresentante il BB che contiene le Output: dag rappresentante il BB che contiene le

seguenti informazioni: seguenti informazioni: – Un’etichetta per ogni nodoUn’etichetta per ogni nodo– Ad ogni nodo si associa una lista di identificatoriAd ogni nodo si associa una lista di identificatori

• Metodo:Metodo:– Struttura dati per rappresentare dagStruttura dati per rappresentare dag– Lista contenente tutti gli identificatori cui è associato un nodoLista contenente tutti gli identificatori cui è associato un nodo– Node(y): restituisce nodo con identificatore yNode(y): restituisce nodo con identificatore y– Statement della formaStatement della forma

i.i. x := y op zx := y op zii.ii. x := op zx := op ziii.iii. x := zx := z

Costruzione dag – algoritmo 3/3 Costruzione dag – algoritmo 3/3

1.1. Se node(y) non è definito, creare una foglia etichettata Se node(y) non è definito, creare una foglia etichettata y, e sia node(y) tale nodoy, e sia node(y) tale nodo

2.2. Nel caso (i) determinare se esiste nodo etichettato op Nel caso (i) determinare se esiste nodo etichettato op con figlio sinistro = node(y) e figlio destro = node(z). con figlio sinistro = node(y) e figlio destro = node(z). Se non esiste creare così un nuovo nodo. Nel caso (ii) Se non esiste creare così un nuovo nodo. Nel caso (ii) determinare se esiste un nodo etichettato op il quale determinare se esiste un nodo etichettato op il quale ha come figlio node(y), se non esiste creare così un ha come figlio node(y), se non esiste creare così un nuovo nodo. In entrambi i casi, il nodo trovato o creato nuovo nodo. In entrambi i casi, il nodo trovato o creato lo indichiamo con n. Nel caso (iii) n = node(y).lo indichiamo con n. Nel caso (iii) n = node(y).

3.3. Eliminare x dalla lista degli identificatori associati a Eliminare x dalla lista degli identificatori associati a node(x); appendere x alla lista degli identificatori node(x); appendere x alla lista degli identificatori associati al nodo n e settare node(x) a n.associati al nodo n e settare node(x) a n.

Applicazioni dell’uso di DAGApplicazioni dell’uso di DAG

• Individuazione di sottoespressioni comuniIndividuazione di sottoespressioni comuni

• Stabilire quali identificatori hanno valori Stabilire quali identificatori hanno valori usati nel bloccousati nel blocco

• Determinare gli statement che calcolano Determinare gli statement che calcolano valori che possono essere usati al di fuori valori che possono essere usati al di fuori del bloccodel blocco

Ristrutturazione dell’ordine di Ristrutturazione dell’ordine di esecuzioneesecuzione

• (a + b) – (e – (c + d))(a + b) – (e – (c + d))

• BBBB– t1 := a + bt1 := a + b– t2 := c + dt2 := c + d– t3 := e – t2t3 := e – t2– t4 := t1 – t3t4 := t1 – t3

MOV a, R0MOV a, R0

ADD b, R0ADD b, R0

MOV c, R1MOV c, R1

ADD d, R1ADD d, R1

MOV R0, t1MOV R0, t1

MOV e, R0MOV e, R0

SUB R1, R0SUB R1, R0

MOV t1, R1MOV t1, R1

SUB R0, R1SUB R0, R1

MOV R1, t4MOV R1, t4

Ristrutturazione dell’ordine di Ristrutturazione dell’ordine di esecuzioneesecuzione

• Modificando l’ordine Modificando l’ordine delle istruzioni nel BBdelle istruzioni nel BB– t2 := c + dt2 := c + d– t3 := e – t2t3 := e – t2– t1 := a + bt1 := a + b– t4 := t1 – t3t4 := t1 – t3

vengono risparmiate vengono risparmiate due istruzionidue istruzioni

MOV c, R0MOV c, R0ADD d, R0ADD d, R0MOV e, R1MOV e, R1SUB R0, R1SUB R0, R1MOV a, R0MOV a, R0ADD b, R0ADD b, R0SUB R1, R0SUB R1, R0MOV R0, t4MOV R0, t4

Generazione codice ottimaleGenerazione codice ottimale

• Algoritmo consiste di 2 partiAlgoritmo consiste di 2 parti1.1. Etichetta ogni nodo con un intero che Etichetta ogni nodo con un intero che

denota il più piccolo numero di registri denota il più piccolo numero di registri richiesti per valutare l’alberorichiesti per valutare l’albero

2.2. Visita dell’albero il cui ordine è dato dal Visita dell’albero il cui ordine è dato dal valore delle etichette calcolato nel passo 1.valore delle etichette calcolato nel passo 1.

• Il codice di output viene generato Il codice di output viene generato durante la visita dell’albero.durante la visita dell’albero.

Algoritmo di etichettatura Algoritmo di etichettatura

• Foglia sinistra = è un nodo foglia il quale è Foglia sinistra = è un nodo foglia il quale è il discendente più a sinistra del proprio il discendente più a sinistra del proprio padre. Le altre foglie sono dette foglie padre. Le altre foglie sono dette foglie destredestre

• L’etichettatura viene effettuata in una visita L’etichettatura viene effettuata in una visita bottom-upbottom-up

Algoritmo di etichettaturaAlgoritmo di etichettatura

(1)(1) If n is leaf thenIf n is leaf then(2)(2) if n is the leftmost child of its parent thenif n is the leftmost child of its parent then(3)(3) label(n) := 1label(n) := 1(4)(4) else label(n) := 0else label(n) := 0(5)(5) Else beginElse begin

let l1, l2 be the children of nlet l1, l2 be the children of n(6)(6) label(n) = max(l1, l2) se l1 != l2 label(n) = max(l1, l2) se l1 != l2

l1 + 1 l1 == l2l1 + 1 l1 == l2 endend

• Nel caso generico, (6) viene sostituita con:Nel caso generico, (6) viene sostituita con:let nlet n11, … n, … nkk be the children on n ordered by be the children on n ordered by

“ “label”, so label(nlabel”, so label(n11) >= … >= label(n) >= … >= label(nkk)) label(n) := max label(n) := max 1<=i<=k1<=i<=k (label(n (label(nii) + i - 1)) + i - 1)

Algoritmo di etichettaturaAlgoritmo di etichettatura

• Ordine: a, b, t1, e, c, d, t2, t3, t4Ordine: a, b, t1, e, c, d, t2, t3, t4

Generazione codice da albero Generazione codice da albero etichettatoetichettato

• Procedura gencode(n): produce codice Procedura gencode(n): produce codice macchina valutando i sottoalberi di T con macchina valutando i sottoalberi di T con radice n. radice n.

• rstack: stack utilizzato per allocare i rstack: stack utilizzato per allocare i registriregistri

• tstack: stack utilizzato per allocare tstack: stack utilizzato per allocare locazioni di memoria temporanealocazioni di memoria temporanea

• swap: procedura che scambia i primi 2 swap: procedura che scambia i primi 2 registri sul top di rstackregistri sul top di rstack


Procedure gencode(n);Procedure gencode(n);BeginBegin/* case 0 *//* case 0 */IfIf n is a left leaf representing operand “name” n is a left leaf representing operand “name” andand n is the leftmost child of its parent n is the leftmost child of its parent thenthen printprint ‘MOV’ || name || top(rstack) ‘MOV’ || name || top(rstack)else if n is an interior node with operator “op”, left child n1 and right child n2 thenelse if n is an interior node with operator “op”, left child n1 and right child n2 then /* case 1*//* case 1*/ if label(n2) = 0 if label(n2) = 0 then then beginbegin

let name be the operand represented by n2;let name be the operand represented by n2; gencode(n1);gencode(n1); printprint op || name || ‘,’ || top(rstack) op || name || ‘,’ || top(rstack) endend /*case 2*//*case 2*/ else if 1<=label(n1) < label(n2) and label(n1) < r thenelse if 1<=label(n1) < label(n2) and label(n1) < r then beginbegin swap(rstack); gencode(n2);swap(rstack); gencode(n2); R := pop(rstack); /* n2 was evaluated into register R */R := pop(rstack); /* n2 was evaluated into register R */ gencode(n1);gencode(n1); printprint op || R || ‘,’ || top(rstack); op || R || ‘,’ || top(rstack); push(rstack, R);push(rstack, R); swap(rstack);swap(rstack); endend


/* case 3*//* case 3*/ else if 1 <= label(n2) <= label(n1) and label(n2) < r thenelse if 1 <= label(n2) <= label(n1) and label(n2) < r then beginbegin gencode(n1);gencode(n1); R := pop(rstack); /*n1 was evaluated into register R*/R := pop(rstack); /*n1 was evaluated into register R*/ gencode(n2);gencode(n2); printprint op || top(rstack) || ‘,’ || R; op || top(rstack) || ‘,’ || R; push(rstack, R);push(rstack, R); endend /* case 4 both labels >= r the total number of register *//* case 4 both labels >= r the total number of register */ elseelse beginbegin gencode(n2);gencode(n2); T := pop(tstack);T := pop(tstack); print ‘MOV’ || top(rstack) || ‘,’ || T;print ‘MOV’ || top(rstack) || ‘,’ || T; gencode(n1);gencode(n1); push(tstack, T);push(tstack, T); printprint op || T || ‘,’ || top(rstack); op || T || ‘,’ || top(rstack); endend

Documents

GENERAZIONE CODICE MACCHINA Daniela Briola Lorena Bellino