Register Allocation. Consider the following assignment statement: x = (a*b)+((c*d)+(e*f)); In posfix notation: ab*cd*ef*++x

Transcription

1 Register Aocation Consider the foowing assignment statement: x = (a*b)+((c*d)+(e*f)); In posfix notation: ab*cd*ef*++x Assume that two registers are avaiabe. Starting from the eft a compier woud generate the foowing sequence: R1,a mpy R1,b R2,c mpy R2,d For the next operation (e*f) no register is avaiabe and spi is needed. There are two possibiities for the rest of the code: st R2,temp R2,e mpy R2,f add R2,temp add R2,R1 st R1,x 1

2 or st mpy R1,f add R1,R2 R1,temp R1,e add R1,temp st R1,x However, the spi can be avoided if the expression is evauated in a different order: R1,c mpy R1,d R2,e mpy R2,f add R1,R2 R2,a mpy R2,b add R2,R1 st R2,x 2

3 Three address representation Source-to-source transformations may be appied to the AST. The next step is to generate three address code. In many cases, the compound statements (e.g. for or do oops and if statements) are transformed into sequences of instructions which incude three-address operations as we as cmp and jump instructions. The origina structure of the program (e.g. oops ) is recovered by anayzing the program fow graph. In some cases (e.g. SUIF) information on the high-eve constructs is kept as annotations to the three address representation of the program. 3

4 Program Fow Graph A program fow graph is aso necessary for compiation. the nodes are the basic bocks. There is an arc from bock B 1 to bock B 2 if B 2 can foow B 1 in some execution sequence. A basic bock is a sequence of consecutive statements in which fow of contro enters at the beginning and eaves at the end without hats or possibiity of branching except at the end. Agorithm BB: Basic Bock Partition Input: A program PROG in which instructions are numbered in sequence from 1 to PROG. INST(i) denotes the ith instruction. Output 1.the set of LEADERS of initia bock instructions. 2.for a x in LEADERS, the set BLOCK(x) of a intructions in the bock beginning at x 3. Method: 4

5 begin LEADERS:={1} for j := 1 to PROG do if INST(j) is a branch then add the index of each potentia target to LEADERS fi od TODO := LEADERS whie TODO do x := eement of TODO with smaest index TODO := TODO - {x} BLOCK(x) := {x} for i := x+1 to PROG whie i LEADERS do BLOCK(x) := BLOCK(x) + {i} od od end 5

6 A Simpe Code Generator Our objective is to make a reasonabe use of the registers when generating code for a basic bock. Consider for exampe: t=a-b u=a-c v=t+u d=v+u Each instruction coud be treated ike a macro which expand into something ike: R1,a sub R1,b st R1,t R1,a sub R1,c st R1,u R1,t add R1,u st R1,v R1,v add R1,u st R1,d The resuting code is not very good. Ony one register is used and there is much redundat code. A more sophisticated agorithm is needed. 6

7 Target Machine Language We use the foowing target machine anguage: The machine has two address instructions of the form op destination,source The destination has to be a register. The machine has severa opcodes incuding add sub (move source to destination) (add source to destination) (subtract source from destination) There is aso a store (st) instruction. The source (destination in the case of the store instruction) can be 1.an absoute memory address (a variabe name is used), 2.a register, 3.indexed (written c(r), where c is a constant and R a register), 4.indirect (written *R where R is a register), and 5.immediate (denoted #c where c is a constant) 7

8 Agorithm SCG: A Simpe Code Generator Input: 1.A basic bock of three address statements. 2.A symbo tabe SYMTAB Output: 1.Machine code Intermediate: 1.A register descriptor RD(R).The set variabes whose vaues are in register R 2.An address descriptor AD(variabe). The set of ocations (register, stack, memory) where the vaue of variabe can be found. R Var 1 x y RD(R) AD Ri....Mem Stack x r1,r2 AD(var) Assumption: save a ive variabes at the end of the BB (conservative) 8

9 begin for each instruction I in basic bock do if I is of form (x := y op z) then L := getreg(y,i); if L not in AD(y) then y := seect ( y ) generate( L,y ) z := seect (z) generate(op L,z ) AD(y) := AD(y) - {L} for a R in REGISTERS do RD(R) := RD(R) - {x} endfor RD(L) := {x} AD(x) := {L} if NEXTUSE(y,I) empty and LIVEONEXIT(y) is fase then fora R in REGISTERS do RD(R) := RD(R) - {y} endfora...same as above for z... eseif I is of form ( x := op y) then... simiar code as above... eseif I is of form (x := y) then if there is register R in AD(y) then RD(R) := RD(R) + {x} AD(x) := {R} 9

10 end ese L := getreg(y,i) generate( L,y) RD(L) := {x,y} AD(x) = {L} AD(y) = AD(y) + {L} enddo fora R in REGISTERS do fora v in RD(R) do if LIVEONEXIT(v) and SYMTAB.oc(v) not in AD(v) then (ony once for each v) generate(st R,v) endfora endfora The seect routine returns a register R if the vaue of the parameter is in R otherwise it returns thememory ocation containing the vaue of the parameter. 10

11 NEXTUSE and LIVEONEXIT The LIVEONEXIT(v) booean vaue is true if v may be used after the basic bock competes. It is computed using goba fow anaysis techniques to be discussed ater in the course. The NEXTUSE(v,I) is the statement number where v is used next in the basic bock. It is empty if v is not used again. NEXTUSE(v,I) can be computed as foows: fora variabes v in basicbock do USE(v) := {} od fora instructions I in basic bock in reverse order do if I is of form (x := y op z) then NEXTUSE(x,I) = USE(x) NEXTUSE(y,I) = USE(y) NEXTUSE(z,I) = USE(z) USE(x) = {} USE(y) := {I} USE(z) := {I} eseif... fi od 11

12 getreg(y,i) if there is register R such that RD(R) = {y} and both LIVEONEXIT(y) and NEXTUSE(y,I) are empty then return (R) ese if there is R in REGISTERS such that RD(R) emptythen return(r) ese R:= getanyregister() fora v in RD(R) do AD(v) := AD(v) - {R} if SYMTAC.oc(v) is not in AD(v) then generate(str,v) AD(v) := AD(v) + {SYMTAB.oc(v)} endfora 12

13 Two specia operators The [ ] operator is used to index a (one dimensiona) array a:=b[i] can be transated as (1) R,b(R) if i is in register R (2) R,M R,b(R) if i is memory ocation M (3) R,S(A) R,b(R) if i is in stack offset S. The * operator is simiar. For exampe, (2) abore is repaced by R,M R,*R 13