An Optimizing Compiler

Transcription

1 An Optimizing Compier The big difference between interpreters and compiers is that compiers have the abiity to think about how to transate a source program into target code in the most effective way. Usuay that means trying to transate the program in such a way that it executes as fast as possibe on the target machine. This usuay impies either one or both of the foowing tasks: Rewrite the AST so that it represents a more efficient program Tree Rewriting Reorganize the generated instructions so that they represent the most efficient target program possibe This is referred to as Optimization. There are many optimization techniques avaiabe to compiers in addition to the two mentioned above: Register aocation, oop optimization, common subexpression eimination, dead code eimination, etc

2 An Optimizing Compier In our optimizing compier we study: Tree rewriting in the context of constant foding, and Target code optimization in the context of peephoe optimization.

3 Tree Rewriting So far our appications ony have ooked at the AST as an immutabe data structure Bytecode interpreter used it to execute instructions The Cuppa1 interpreter used it as an abstract representation of the origina program PrettyPrinter used it to regenerate programs But there are many cases where we actuay want to transform the AST Consider constant foding

4 Constant Foding Constant foding is an optimization that tries to find arithmetic operations in the source program that can be performed at compie time rather than runtime.

5 Constant Foding In constant foding we ook at the operations in arithmetic expressions and if the operands are constants then we perform the operation and repace the AST with a resut node. x = x = 15 = = x + x

6 Constant Foding One way to view constant foding is as a AST rewriting. Here the AST for the expression is repaced by an AST node for the constant 15. In order to accompish this we need to wak the AST for a Cuppa1 program and ook for patterns that aow us to rewrite the tree. This is very simiar to code generation tree waker where we waked the tree and ooked for AST patterns that we coud transate into Exp1bytecode. The big difference being that in the constant foder we wi be returning the rewritten tree from the tree waker rather than bytecode as in the code generator.

7 Constant Foding Consider: cuppa1_cc_fod.py

8 Constant Foding Consider: cuppa1_cc_fod.py

9 Constant Foding Consider: cuppa1_cc_fod.py

10 Constant Foding Let's try our waker on our assignment statement exampe to see if it does what we caim it does,

11 Compier Architecture As an exampe we insert a constant foding tree rewriting phase into our Cuppa1 compier as a tree waker. Constant Foding Waker Frontend CodeGen Waker Input buid AST write Output

12 Peephoe Code Optimization A peephoe optimizer improves the generated code by reorganizing the generated instructions. If you reca the code generator for our Cuppa1 compier transates Cuppa1 AST patterns into Exp1bytecode patterns and simpy composes the generated bytecode patterns into a ist of instructions. That can ead to very siy ooking code.

13 Peephoe Code Optimization Consider: Reay Siy!

14 Peephoe Code Optimization There is a rue for that:

15 Peephoe Code Optimization Consider: Even Siier!

16 Peephoe Code Optimization There is a rue for that:

17 Peephoe Code Optimization One way to think of a peephoe optimizer is as a window (the peephoe) which we side across the generated instructions repeatedy and appy rewrite rues ike the ones we deveoped above to the code within the window. The peephoe optimizer terminates once no onger any code is being rewritten. The repeated nature of the process is necessary because appying one rewrite rue to the instruction ist can expose opportunities to appy other rewrite rues. So we need to keep siding the window across the instructions unti no further rewrites are possibe.

18 Peephoe Code Optimization

19 Peephoe Code Optimization Rewrite Rues: cuppa1_cc_output.py

20 Peephoe Code Optimization ######################################################################### # appy peephoe optimization. The instruction tupe format is: # (instr_name_str, [param_str1, param_str2,...]) def peephoe_opt(instr_stream): ix = 0 change = Fase whie(true): curr_instr = instr_stream[ix] ### compute some usefu predicates on the current instruction is_first_instr = ix == 0 is_ast_instr = ix+1 == en(instr_stream) has_abe = True if not is_first_instr and abe_def(instr_stream[ix-1]) ese Fase <** rewrite rues here **> ### advance ix if is_ast_instr and not change: break eif is_ast_instr: ix = 0 change = Fase ese: ix += 1 cuppa1_cc_output.py

21 Optimizing Compier Architecture We insert our peephoe optimizer between the code generator and the output phase Constant Foding Waker Frontend CodeGen Waker Input buid AST Peephoe Opt Output

22 Optimizing Compier Top-eve Driver Function cuppa1_cc.py