CSE P 501 Compilers. Instruc7on Selec7on Hal Perkins Winter UW CSE P 501 Winter 2016 N-1

Transcription

1 CSE P 501 Compilers Instruc7on Selec7on Hal Perkins Winter 2016 UW CSE P 501 Winter 2016 N-1

2 Agenda Compiler back- end organiza7on Instruc7on selec7on tree padern matching Credits: Slides by Keith Cooper (Rice); Appel ch. 9; burg/iburg slides by Preston Briggs, CSE 501 Sp09 Burg/iburg paper: Engineering a Simple, Efficient Code Generator, Fraser, Hanson, & Proebs7ng, ACM LOPLAS v1, n3 (Sept. 1992) UW CSE P 501 Winter 2016 N-2

3 Compiler Organiza7on scan parse semantics opt1 opt2 optn instr. select isntr. sched reg. alloc front end middle back end infrastructure symbol tables, trees, graphs, etc UW CSE P 501 Winter 2016 N-3

4 Big Picture Compiler consists of lots of fast stuff followed by hard problems Scanner: O(n) Parser: O(n) Analysis & Op7miza7on: ~ O(n log n) Instruc7on selec7on: fast or NP- Complete Instruc7on scheduling: NP- Complete Register alloca7on: NP- Complete UW CSE P 501 Winter 2016 N-4

5 IR for Code Genera7on Assume a low- level RISC- like IR 3 address, register- register instruc7ons + load/ store r1 <- r2 op r3 Could be tree structure or linear Expose as much detail as possible Assume enough (i.e., ) registers Invent new temporaries for intermediate results Map to actual registers later UW CSE P 501 Winter 2016 N-5

6 Overview: Instruc7on Selec7on Map IR into assembly code Assume known storage layout and code shape i.e., the op7miza7on phases have already done their thing Combine low- level IR opera7ons into machine instruc7ons (take advantage of addressing modes, etc.) UW CSE P 501 Winter 2016 N-6

7 Overview: Instruc7on Scheduling Reorder opera7ons to hide latencies processor func7on units; memory/cache Originally invented for supercomputers (1960s) Now important everywhere Even non- RISC machines, i.e., x86 Even if processor reorders on the fly Assume fixed program UW CSE P 501 Winter 2016 N-7

8 Overview: Register Alloca7on Map values to actual registers Previous phases change need for registers Add code to spill values to temporaries as needed, etc. Usually worth doing another instruc7on scheduling pass aierwards if spill code inserted UW CSE P 501 Winter 2016 N-8

9 How Hard? Instruc7on selec7on Can make locally op7mal choices Global is undoubtedly NP- Complete Instruc7on scheduling Single basic block quick heuris7cs General problem NP Complete Register alloca7on Single basic block, no spilling, interchangeable registers linear General NP Complete UW CSE P 501 Winter 2016 N-9

10 Conven7onal Wisdom We typically lose lidle by solving these independently But not always, of course (itera7ng phases on x86[- 64] can help because of limited registers, memory operands) Instruc7on selec7on Use some form of padern matching virtual registers create as needed Instruc7on scheduling Within a block, list scheduling is close to op7mal Across blocks: EBBs or trace scheduling if list scheduling not good enough Register alloca7on Start with unlimited virtual registers and map enough to K UW CSE P 501 Winter 2016 N-10

11 An Simple Low- Level IR (1) Details not important for our purposes; point is to get a feeling for the level of detail involved This example is from Appel Expressions CONST(i) integer constant i TEMP(t) temporary t (i.e., register) BINOP(op,e1,e2) applica7on of op to e1,e2 MEM(e) contents of memory at address e Means value when used in an expression Means address when used on lei side of assignment CALL(f,args) apply func7on f to argument list args UW CSE P 501 Winter 2016 N-11

12 Simple Low- Level IR (2) Statements MOVE(TEMP t, e) evaluate e and store in temporary t MOVE(MEM(e1), e2) evaluate e1 to yield address a; evaluate e2 and store at a EXP(e) evaluate expressions e and discard result SEQ(s1,s2) execute s1 followed by s2 NAME(n) assembly language label n JUMP(e) jump to e, which can be a NAME label, or more complex (e.g., switch) CJUMP(op,e1,e2,t,f) evaluate e1 op e2; if true jump to label t, otherwise jump to f LABEL(n) defines loca7on of label n in the code UW CSE P 501 Winter 2016 N-12

13 Low- Level IR Example (1) Expr for a local variable at a known offset k from the frame pointer fp Linear MEM(BINOP(PLUS, TEMP fp, CONST k)) Tree MEM + TEMP fp CONST k UW CSE P 501 Winter 2016 N-13

14 Low- Level IR Example (2) For an array element e(k), where each element takes up w storage loca7ons MEM + MEM * e k CONST w UW CSE P 501 Winter 2016 N-14

15 Genera7ng Low- Level IR Assuming ini7al IR is an AST, a simple treewalk can be used to generate the low- level IR Can be done before, during, or aier op7miza7ons in the middle part of the compiler Typically AST is lowered to some lower- level IR, but maybe not final lowest- level one used in instruc7on selec7on Create registers (temporaries) for values and intermediate results Value can be safely allocated to a register when only 1 name can reference it Trouble: pointers, arrays, reference parameters Assign a virtual register to anything that can go into one Generate loads/stores for other values UW CSE P 501 Winter 2016 N-15

16 Instruc7on Selec7on Issues Given the low- level IR, there are many possible code sequences that implement it correctly e.g. to set %rax to 0 on x86, among others movq $0,%rax xorq %rax,%rax subq %rax,%rax imulq %rax,0 Many machine instruc7ons do several things at once e.g., register arithme7c and effec7ve address calcula7on leaq offset(%rbase,%rindex,scale),%rdst UW CSE P 501 Winter 2016 N-16

17 Instruc7on Selec7on Criteria Several possibili7es Fastest Smallest Minimize power consump7on (ex: don t use a func7on unit if leaving it powered- down is a win) Some7mes not obvious e.g., if one of the func7on units in the processor is idle and we can select an instruc7on that uses that unit, it effec7vely executes for free, even if that instruc7on wouldn t be chosen normally (Some interac7on with scheduling here ) UW CSE P 501 Winter 2016 N-17

18 Implementa7on Problem: We need some representa7on of the target machine instruc7on set that facilitates code genera7on Idea: Describe machine instruc7ons using same low- level IR used for program Use padern matching techniques to pick machine instruc7ons that match fragments of the program IR tree Want this to run quickly Would like to automate as much as possible UW CSE P 501 Winter 2016 N-18

19 Matching: How? Tree IR padern match on trees Tree paderns as input Each padern maps to target machine instruc7on (or sequence) and at least one simple target match for each kind of tree node so we can always generate something Various algorithms max. munch, dynamic programming, Linear IR some sort of string matching Strings as input Each string maps to target machine instruc7on sequence Use text matching or peephole matching (parsing!, but with a way, way ambiguous grammar for target machine) Both work well in prac7ce; algorithms are quite different UW CSE P 501 Winter 2016 N-19

20 An Example Target Machine (1) Arithme7c Instruc7ons result in reg. (unnamed) ri TEMP ADD ri <- rj + rk + MUL ri <- rj * rk * SUB and DIV are similar UW CSE P 501 Winter 2016 N-20

21 An Example Target Machine (2) Immediate Instruc7ons ADDI ri <- rj + c + + CONST CONST CONST SUBI ri <- rj - c - CONST UW CSE P 501 Winter 2016 N-21

22 An Example Target Machine (3) Load LOAD ri <- M[rj + c] MEM MEM MEM MEM + + CONST CONST CONST UW CSE P 501 Winter 2016 N-22

23 An Example Target Machine (4) Store not an expression; no result STORE M[rj + c] <- ri MOVE MOVE MOVE MOVE MEM MEM MEM MEM + + CONST CONST CONST UW CSE P 501 Winter 2016 N-23

24 An Example Target Machine (5) mem- >mem copy also not an expression MOVEM M[rj] <- M[ri] MOVE MEM MEM UW CSE P 501 Winter 2016 N-24

25 Tree PaDern Matching (1) Goal: Tile the low- level tree with opera7on (instruc7on) trees A!ling is a collec7on of <node,op> pairs node is a node in the tree op is an opera7on tree <node,op> means that op could implement the subtree at node UW CSE P 501 Winter 2016 N-25

26 Tree PaDern Matching (2) A 7ling implements a tree if it covers every node in the tree and the overlap between any two 7les (trees) is limited to a single node If <node,op> is in the 7ling, then node is also covered by a leaf in another opera7on tree in the 7ling unless it is the root Where two opera7on trees meet, they must be compa7ble (i.e., expect the same value in the same loca7on) UW CSE P 501 Winter 2016 N-26

27 Example Tree for a[i]:=x MOVE MEM MEM + + MEM + TEMP i * CONST 4 FP CONST x FP CONST a UW CSE P 501 Winter 2016 N-27

28 Genera7ng Code Given a 7led tree, to generate code Postorder treewalk; node- dependant order for children Emit code sequences corresponding to 7les in order Connect 7les by using same register name to 7e boundaries together UW CSE P 501 Winter 2016 N-28

29 Tiling Algorithms (1) Maximal Munch Start at root of tree, find largest 7le that fits. Cover the root node and possibly other nearby nodes. Then repeat for each subtree Generate instruc7on as each 7le is placed Generates instruc7ons in reverse order Generates an op7mum 7ling 7les sum to lowest possible cost But not op7mal there may be another 7ling where two adjacent 7les can be combined into one of lower cost UW CSE P 501 Winter 2016 N-29

30 Tiling Algorithms (2) Dynamic Programming There may be many 7les that could match at a par7cular node Idea: Walk the tree and accumulate the set of all possible 7les that could match at that point Tiles(n) Then: Select minimal cost for subtrees (bodom up), and go top- down to select and emit lowest- cost instruc7ons UW CSE P 501 Winter 2016 N-30

31 Tile(Node n) Tiles(n) <- empty; if n has two children then Tile(lei child of n) Tile(right child of n) for each rule r that implements n if (lei(r) is in Tiles(lei(n)) and right(r) is in Tiles(right(n))) Tiles(n) <- Tiles(n) + r else if n has one child then Tile(child of n) for each rule r that implements n if(lei(r) is in Tiles(child(n))) Tiles(n) <- Tiles(n) + r else /* n is a leaf */ Tiles(n) <- { all rules that implement n } UW CSE P 501 Winter 2016 N-31

32 Tools iburg and burg and others use a combina7on of dynamic programming and tree padern matching to find op7mal transla7ons Product of years of research going back to peephole op7mizers Not really a research area now (like parsing), but s7ll room for newer/beder tools UW CSE P 501 Winter 2016 N-32

33 Peephole Op7miza7on Idea: Find pairs of instruc7ons (not necessarily adjacent) and replace them with something beder Instead of use t2 = &c t3 = *t2 t3 = c UW CSE P 501 Winter 2016 N-33

34 Which Pairs? Chris Fraser no7ced that useful pairs were connected by UD chains, so Plan: consider each instruc7on together with instruc7ons that feed it UD chains reach across blocks, so instruc7on selector can work globally Works great with SSA too UW CSE P 501 Winter 2016 N-34

35 PaDerns Reduce pairs of instruc7ons to schema7cs t5 = 4 t6 = t4 + t5 becomes %reg1 = %con %reg3 = %reg2 + %reg1 Find in hash table; if found, replace %reg3 = %reg2 + %con UW CSE P 501 Winter 2016 N-35

36 Tree- Based Representa7on The tree makes the UD chains explicit Each defini7on in the tree is used once Typically a basic block would have a sequence of expression trees UW CSE P 501 Winter 2016 N-36

37 Example Code for i = c + 4 [c a char; i an int] t1 = &i t2 = &c t3 = *t2 t4 = cvci(t3) t5 = 4 t6 = t4+t5 *t1 = t6 = &i + c2i ld &c 4 UW CSE P 501 Winter 2016 N-37

38 Tree PaDerns An iburg spec is a set of rules. BNF: rule = nonterm : tree = integer (cost) tree = term (tree, tree) term (tree) term nonterm Terminals are IL opera7ons Nonterminals name sets of rules UW CSE P 501 Winter 2016 N-38

39 Rules Rules are numbered to the right of the = sign The cost of a rule is its cost (oien 0) plus the cost of any subtrees A rule may be nested to define a padern that matches more than one level in a tree UW CSE P 501 Winter 2016 N-39

40 Example stmt : ASSIGN(addr, reg) = 1 (1) stmt : reg = 2 (0) reg : ADD(reg, rc) = 3 (1) reg : ADD(rc, reg) = 4 (1) reg : LD(addr) = 5 (1) reg : C2I(LD(addr)) = 6 (1) reg : addr = 7 (1) reg : con = 8 (1) addr : ADD(reg, con) = 9 (0) addr : ADD(con, reg) = 10 (0) addr : ADDRLP = 11 (0) // addr of local var rc : con = 12 (0) rc : reg = 13 (0) con : CNST = 14 (0) UW CSE P 501 Winter 2016 N-40

41 Algorithm Pass I: bodom up Label each node with lowest cost rule to produce result from available operands (cost = cost of rule + cost of subtrees) Label is: (r, c) = best is rule r, cost is c Pass II: top down Find cheapest node that generates result needed by parent tree Emit instruc7ons in reverse order as choices are made UW CSE P 501 Winter 2016 N-41

42 BoDom- up (Labeling) op stmt reg addr rc con a a = stmt : ASSIGN(addr, reg) = 1 (1) stmt : reg = 2 (0) reg : ADD(reg, rc) = 3 (1) reg : ADD(rc, reg) = 4 (1) reg : LD(addr) = 5 (1) reg : C2I(LD(addr)) = 6 (1) reg : addr = 7 (1) reg : con = 8 (1) addr : ADD(reg, con) = 9 (0) addr : ADD(con, reg) = 10 (0) addr : ADDRLP = 11 (0) rc : con = 12 (0) rc : reg = 13 (0) con : CNST = 14 (0) b c b c &i + d e d c2i e 4 f g f ld g &c UW CSE P 501 Winter 2016 N-42

43 Top- Down (Reduc7on) op stmt reg addr rc con a a (1,3) = stmt : ASSIGN(addr, reg) = 1 (1) stmt : reg = 2 (0) reg : ADD(reg, rc) = 3 (1) reg : ADD(rc, reg) = 4 (1) reg : LD(addr) = 5 (1) reg : C2I(LD(addr)) = 6 (1) reg : addr = 7 (1) reg : con = 8 (1) addr : ADD(reg, con) = 9 (0) addr : ADD(con, reg) = 10 (0) addr : ADDRLP = 11 (0) rc : con = 12 (0) rc : reg = 13 (0) con : CNST = 14 (0) b (2,1) (7,1) (11,0) (13,1) c (2,2) (3,2) (9,1) (13,2) b c &i + d (2,1) (6,1) (13,1) e (2,1) (8,1) (12,0) (14,0) d c2i e 4 f (2,1) (5,1) (13,1) g (2,1) (7,1) (11,0) (13,1) f ld g &c UW CSE P 501 Winter 2016 N-43

44 Coming ADrac7ons Instruc7on Scheduling Register Alloca7on And more. UW CSE P 501 Winter 2016 N-44