10. Intermediate Code Generation Compiler Structures 242-437, Semester 2, 2018-2019 10. Intermediate Code Generation Objectives describe intermediate code generation explain a stack-based intermediate code for the expression language

Overview 1. Intermediate Code (IC) Generation 2. IC Examples 3. Expression Translation in SPIM 4. The Expressions Language

In this lecture Front End Back End Source Program Lexical Analyzer Syntax Analyzer Semantic Analyzer In this lecture Int. Code Generator Intermediate Code Code Optimizer Back End As I said earlier, there will be 5 homeworks, each of which will contribute to 5% of your final grade. You will have at least 2 weeks to complete each of the homeworks. Talking about algorithms really helps you learn about them, so I encourage you all to work in small groups. If you don’t have anyone to work with please either e-mail me or stop by my office and I will be sure to match you up with others. PLEASE make sure you all work on each problem; you will only be hurting yourself if you leach off of your partners. Problems are HARD! I will take into account the size of your group when grading your homework. Later in the course I will even have a contest for best algorithm and give prizes out for those who are most clever in their construct. I will allow you one late homework. You *must* write on the top that you are taking your late. Homework 1 comes out next class. Target Code Generator Target Lang. Prog.

1. Intermediate Code (IC) Generation Helps with retargeting e.g. can easily attach a back end for a new machine to an existing front end Enables machine-independent code optimization. Target machine code Front end Back end Intermediate code

Graphical IC Representations Abstract Syntax Trees (AST) retains basic parse tree structure, but with unneeded nodes removed Directed Acyclic Graphs (DAG) compacted AST to avoid duplication smaller memory needs Control Flow Graphs (CFG) used to model control flow

Linear (text-based) ICs Stack-based (postfix) e.g. the JVM Three-address code x := y op z Two-address code: x := op y (the same as x := x op y)

2. IC Examples ASTs and DAGs Stack-based (postfix) Three-address Code SPIM

2.1. ASTs and DAGs a := b *-c + b * -c assign assign a + a + * * * AST Pros: easy restructuring of code and/or expressions for intermediate code optimization Cons: memory intensive

2.2. Stack-based (postfix) a := b * -c + b * -c b c uminus * b c uminus * + a assign (e.g. JVM stack instrs) iload 2 // push b iload 3 // push c ineg // uminus imul // * iload 2 // push b iload 3 // push c ineg // uminus imul // * iadd // + istore 1 // store a Postfix notation represents operations on a stack Pro: easy to generate Cons: stack operations are more difficult to optimize

Translated from the AST 2.3. Three-Address Code a := b * -c + b * -c t1 := - c t2 := b * t1 t3 := - c t4 := b * t3 t5 := t2 + t4 a := t5 t1 := - c t2 := b * t1 t5 := t2 + t2 a := t5 Translated from the AST Translated from the DAG

2.4. SPIM Three address code for a simulator that runs MIPS32 assembly language programs http://www.cs.wisc.edu/~larus/spim.html Loading/Storing lw register,var - loads value into register sw register,var - stores value from register many, many others continued

Binary math ops (reg1 = reg2 op reg3): 8 registers: $t0 - $t7 Binary math ops (reg1 = reg2 op reg3): add reg1,reg2,reg3 sub reg1,reg2,reg3 mul reg1,reg2,reg3 div reg1,reg2,reg3 Unary minus (reg1 = - reg2) neg reg1, reg2

"a := b * -c + b * -c" in SPIM assign a + * * b - b - c c lw $t0,c neg $t1,$t0 lw $t0,b mul $t2, $t1,$t0 mul $t1, $t1,$t0 add $t1,$t2,$t1 sw $t1,a assign a + t1 AST * * t1 t2 b - b - t0 t1 t0 t1 c c t0 t0

a := b * -c + b * -c assign a + * - b c lw $t0,c neg $t1,$t0 lw $t0,b mul $t1, $t1,$t0 add $t2,$t1,$t1 sw $t2,a a + t2 DAG * t1 - b t1 t0 c t0

3. Expression Translation in SPIM Generate: lw $t1,b Grammar: S => id := E E => E + E E => id S E E E E E As we parse, use attributes to pass information about the temporary variables up the tree. E 1 E a := b + c + d + e parse tree --> code using bottom-up evaluation

Each number corresponds to a temporary variable. Generate: lw $t1,b lw $t2,c S E E E E E E 1 E 2 a := b + c + d + e Each number corresponds to a temporary variable.

Each number corresponds to a temporary variable. Generate: lw $t1,b lw $t2,c add $t3,$t1,$t2 S E E E 3 E E E 1 E 2 a := b + c + d + e Each number corresponds to a temporary variable.

S E E E 3 E 4 E E 1 E 2 a := b + c + d + e Generate: lw $t1,b lw $t2,c add $t3,$t1,$t2 lw $t4,d S E E E 3 E 4 E E 1 E 2 a := b + c + d + e

S E 5 E E 3 E 4 E E 1 E 2 a := b + c + d + e Generate: lw t1,b lw t2,c add $t3,$t1,$t2 lw t4,d add $t5,$t3,$t4 S E 5 E E 3 E 4 E E 1 E 2 a := b + c + d + e

S E 5 6 E E 3 E 4 E E 1 E 2 a := b + c + d + e Generate: lw $t1,b lw $t2,c add $t3,$t1,$t2 lw $t4,d add $t5,$t3,$t4 lw $t6,e S E 5 6 E E 3 E 4 E E 1 E 2 a := b + c + d + e

S 7 E 5 6 E E 3 E 4 E E 1 E 2 a := b + c + d + e Generate: lw $t1,b lw $t2,c add $t3,$t1,$t2 lw $t4,d add $t5,$t3,$t4 lw $t6,e add $t7,$t5,$t6 S 7 E 5 6 E E 3 E 4 E E 1 E 2 a := b + c + d + e

Generate: lw $t1,b lw $t2,c add $t3,$t1,$t2 lw $t4,d add $t5,$t3,$t4 lw $t6,e add $t7,$t5,$t6 sw $t7,a S 7 E 5 6 E E 3 E 4 E E 1 E 2 a := b + c + d + e Pro: easy to rearrange code for global optimization Cons: lots of temporaries

Issues when Processing Expressions Type checking/conversion. Address calculation for more complex types (arrays, records, etc.). Expressions in control structures, such as loops and if tests.

4. The Expressions Language exprParse3.c builds a parse tree for the input file (reuses code from exprParse2.c). An intermediate code is generated from the parse tree, and saved to an output file. The input file is not executed by exprParse3.c that is done by a separate emulator.

Usage test1.txt let x = 2 let y = 3 + x stores intermediate > gcc -Wall -o exprParse3 exprParse3.c > ./exprParse3 < test1.txt > cat codeGen.txt PUSH 2 STORE x WRITE PUSH 3 LOAD x ADD STORE y STOP stores intermediate code in codeGen.txt test1.txt exprParse3 codeGen.txt

Emulator Usage codeGen.txt emulator it runs the intermediate code > ./emulator codeGen.txt Reading code from codeGen.txt == 2 == 5 Stop codeGen.txt emulator it runs the intermediate code

4.1. The Instruction Set The instructions in codeGen.txt are executed by a emulator. it emulates (simulates) real hardware The instructions refer to two data structures used in the emulator.

The Emulator's Data Structures a symbol table of IDs and their integer values a stack of integers for evaluating the expressions x 4 stack symbol table 2

The Instructions WRITE // pop top element off stack and print STOP // exit code emulation LOAD ID // get ID value from symbol table, and push onto stack STORE ID // copy stack top into symbol table for ID continued

PUSH integer // push integer onto stack STORE0 ID // push 0 onto stack, and save to table as value for ID ( same as push 0; store ID) MULT // pop two stack values, multiply them, push result back ADD, MINUS, DIV // same for those ops

Intermediate Code Type Since the intermediate code uses a stack to store values rather than registers, then it is a stack-based (postfix) representation.

4.2. exprParse3.c Coding All the parsing code in exprParse3.c is the same as exprParse2.c. The difference is that the parse tree is passed to a generateCode() function to convert it to intermediate code see main()

main() #define CODE_FNM "codeGen.txt" // where to store generated code int main(void) /* parse, print the tree, then generate code which is stored in CODE_FNM */ { Tree *t; nextToken(); t = statements(); match(SCANEOF); printTree(t, 0); generateCode(CODE_FNM, t); return 0; }

Generating the Code void generateCode(char *fnm, Tree *t) /* Open the intermediate code file, fnm, and write to it. */ { FILE *fp; if ((fp = fopen(fnm, "w")) == NULL) { printf("Could not write to %s\n", fnm); exit(1); } else { printf("Writing code to %s\n", fnm); cgTree(fp, t); fprintf(fp, "STOP\n"); // last instruction in file fclose(fp); } // end of generateCode()

void cgTree(FILE. fp, Tree. t) / void cgTree(FILE *fp, Tree *t) /* Recurse over the parse tree looking for non-NEWLINE subtrees to convert into code Each block of code generated for a non-NEWLINE subtree ends with a WRITE instruction, to print out the value of the line. */ { if (t == NULL) return; Token tok = TreeOper(t); if (tok == NEWLINE) { cgTree(fp, TreeLeft(t)); cgTree(fp, TreeRight(t)); } else { codeGen(fp, t); fprintf(fp, "WRITE\n"); // print value at EOL } // end of cgTree()

void codeGen(FILE. fp, Tree. t) / void codeGen(FILE *fp, Tree *t) /* Convert the tree nodes for ID, INT, ASSIGNOP, PLUSOP, MINUSOP, MULTOP, DIVOP into instructions. The load/store instructions: LOAD ID, STORE ID, STORE0 ID, PUSH integer The math instructions: MULT, ADD, MINUS, DIV */ { if (t == NULL) return; : continued

Token tok = TreeOper(t); if (tok == ID) codeGenID(fp, TreeID(t)); else if (tok == INT) fprintf(fp, "PUSH %d\n", TreeValue(t)); else if (tok == ASSIGNOP) { // id = expr char *id = TreeID(TreeLeft(t)); getIDEntry(id); // don't use Symbol info codeGen(fp, TreeRight(t)); fprintf(fp, "STORE %s\n", id); } : continued

else if (tok == PLUSOP) { codeGen(fp, TreeLeft(t)); codeGen(fp, TreeRight(t)); fprintf(fp, "ADD\n"); } else if (tok == MINUSOP) { fprintf(fp, "MINUS\n"); : continued

else if (tok == MULTOP) { codeGen(fp, TreeLeft(t)); codeGen(fp, TreeRight(t)); fprintf(fp, "MULT\n"); } else if (tok == DIVOP) { fprintf(fp, "DIV\n"); } // end of codeGen()

void codeGenID(FILE. fp, char. id) / void codeGenID(FILE *fp, char *id) /* An ID may already be in the symbol table, or be new, which is converted into a LOAD or a STORE0 code operation. */ { SymbolInfo *si = NULL; if ((si = lookupID(id)) != NULL) // already declared fprintf(fp, "LOAD %s\n", id); else { // new, so add to table addID(id, 0); // 0 is default value fprintf(fp, "STORE0 %s\n", id); } } // end of codeGenID()

From Tree to Code \n PUSH 2 STORE x WRITE PUSH 3 LOAD x ADD STORE y let x = 2 let y = 3 + x \n PUSH 2 STORE x WRITE PUSH 3 LOAD x ADD STORE y STOP \n = y NULL = + x 2 3 x symbol table in exprParse3.c x y

4.3. The Emulator > gcc –Wall –o emulator emulator.c > ./emulator codeGen.txt Reading code from codeGen.txt == 2 == 5 Stop

Emulator Data Structures #define MAX_SYMS 15 // max no of vars #define STACK_SIZE 10 // stack data structure int stack[STACK_SIZE]; int stackTop = -1; // symbol table data structures typedef struct SymInfo { char *id; int value; } SymbolInfo; int symNum = 0; // number of symbols stored SymbolInfo syms[MAX_SYMS]; 2 x 4

Evaluating Input Lines void eval(FILE *fp) /* Read in the code file a line at a time and process the lines. An instruction on a line may be a single command (e.g. WRITE) or a instruction name and an argument (e.g. LOAD x). */ { char buf[BUFSIZ]; char cmd[MAX_LEN], arg[MAX_LEN]; int no; : continued

while (fgets(buf, sizeof(buf), fp) != NULL) { no = sscanf(buf, "%s %s\n", cmd, arg); if ((no < 1) || (no > 2)) printf("Unknown format: %s\n", buf); else processCmd(cmd, arg); // process commands as they are read in } } // end of eval()

Processing an Instruction void processCmd(char *cmd, char *arg) { SymbolInfo *si; if (strcmp(cmd, "LOAD") == 0) { if ((si = lookupID(arg)) == NULL) { printf("Error: load cannot find %s\n", arg); exit(1); } push(si->value); else if (strcmp(cmd, "STORE") == 0) addID(arg, topOf()); else if (strcmp(cmd, "STORE0") == 0) { push(0); addID(arg, 0); continued

else if (strcmp(cmd, "PUSH") == 0) push( atoi(arg) ); else if (strcmp(cmd, "MULT") == 0) { int v2 = pop(); int v1 = pop(); push( v1*v2 ); } else if (strcmp(cmd, "ADD") == 0) { push( v1+v2 ); else if (strcmp(cmd, "MINUS") == 0) { push( v1-v2 ); continued

else if (strcmp(cmd, "DIV") == 0) { int v2 = pop(); if (v2 == 0) { printf("Error: div by 0; using 1\n"); v2 = 1; } int v1 = pop(); push( v1/v2 ); else if (strcmp(cmd, "WRITE") == 0) printf("== %d\n", pop()); else if (strcmp(cmd, "STOP") == 0) { printf("Stop\n"); exit(1); continued

else printf("Unknown instruction: %s\n", cmd); } // end of processCmd()

Evaluating the Code for test1.txt codeGen.txt let x = 2 let y = 3 + x PUSH 2 STORE x WRITE PUSH 3 LOAD x ADD STORE y STOP continued

PUSH 2 STORE X WRITE PUSH 3 stack symbol table 2 x x 2 2 x 2 2 x 3 2 continued

LOAD X ADD STORE Y WRITE STOP stack symbol table x 2 2 3 x 2 2+ 3 5 x