First Level Gray Box Probing
|
|
|
- Kathryn Boyd
- 5 years ago
- Views:
Transcription
1 First Level Gray Box Probing ( uday) GCC Resource Center, Department of Computer Science and Engineering, Indian Institute of Technology, Bombay January 2012
2 CS 715 Graybox Probing-I: Outline 1/45 Outline Introduction to Graybox Probing of GCC Examining GIMPLE Dumps Translation of data accesses Translation of intraprocedural control flow Translation of interprocedural control flow Examining RTL Dumps Examining Assembly Dumps Conclusions
3 Part 1 Preliminaries
4 CS 715 Graybox Probing-I: Preliminaries 2/45 What is Gray Box Probing of GCC? Black Box probing: Examining only the input and output relationship of a system White Box probing: Examining internals of a system for a given set of inputs Gray Box probing: Examining input and output of various components/modules Overview of translation sequence in GCC Overview of intermediate representations Intermediate representations of programs across important phases
5 CS 715 Graybox Probing-I: Preliminaries 3/45 First Level Gray Box Probing of GCC Restricted to the most important translations in GCC
6 CS 715 Graybox Probing-I: Preliminaries 4/45 Basic Transformations in GCC Tranformation from a language to a different language Target Independent Target Dependent Parse Gimplify Tree SSA Optimize Generate RTL Optimize RTL Generate ASM GIMPLE RTL RTL ASM
7 CS 715 Graybox Probing-I: Preliminaries 4/45 Basic Transformations in GCC Tranformation from a language to a different language Target Independent Target Dependent Parse Gimplify Tree SSA Optimize Generate RTL Optimize RTL Generate ASM GIMPLE RTL RTL ASM GIMPLE Passes RTL Passes
8 CS 715 Graybox Probing-I: Preliminaries 5/45 Transformation Passes in GCC A total of 207 unique pass names initialized in ${SOURCE/gcc/passes.c Total number of passes is 241. Some passes are called multiple times in different contexts Conditional constant propagation and dead code elimination are called thrice Some passes are enabled for specific architectures Some passes have many variations (eg. special cases for loops) Common subexpression elimination, dead code elimination The pass sequence can be divided broadly in two parts Passes on GIMPLE Passes on RTL Some passes are organizational passes to group related passes
9 CS 715 Graybox Probing-I: Preliminaries 6/45 Passes On GIMPLE in GCC Pass Group Examples Number of passes Lowering GIMPLE IR, CFG Construction 10 Simple Interprocedural Conditional Constant Propagation, 38 Passes (Non-LTO) Inlining, SSA Construction Regular Interprocedural Constant Propagation, Inlining, 10 Passes (LTO) Pointer Analysis LTO generation passes 02 Other Intraprocedural Constant Propagation, Dead Code 65 Optimizations Elimination, PRE Value Range Propagation, Rename SSA Loop Optimizations Vectorization, Parallelization, Copy 28 Propagation, Dead Code Elimination Generating RTL 01 Total number of passes on GIMPLE 154
10 CS 715 Graybox Probing-I: Preliminaries 7/45 Passes On RTL in GCC Pass Group Examples Number of passes Intraprocedural CSE, Jump Optimization, Dead Code 27 Optimizations Elimination, Jump Optimization Loop Optimizations Loop Invariant Movement, Peeling, 07 Unswitching Machine Dependent Register Allocation, Instruction 50 Optimizations Scheduling, Peephole Optimizations Assembly Emission and Finishing 03 Total number of passes on RTL 87
11 CS 715 Graybox Probing-I: Preliminaries 8/45 Finding Out List of Optimizations Along with the associated flags A complete list of optimizations with a brief description gcc -c --help=optimizers Optimizations enabled at level 2 (other levels are 0, 1, 3, and s) gcc -c -O2 --help=optimizers -Q
12 CS 715 Graybox Probing-I: Preliminaries 9/45 Producing the Output of GCC Passes Use the option -fdump-<ir>-<passname> <ir> could be tree: Intraprocedural passes on GIMPLE ipa: Interprocedural passes on GIMPLE rtl: Intraprocedural passes on RTL Use all in place of <pass> to see all dumps Example: gcc -fdump-tree-all -fdump-rtl-all test.c Dumping more details: Suffix raw for tree passes and details or slim for RTL passes Individual passes may have more verbosity options (e.g. -fsched-verbose=5) Use -S to stop the compilation with assembly generation Use --verbose-asm to see more detailed assembly dump
13 CS 715 Graybox Probing-I: Preliminaries 10/45 Total Number of Dumps Optimization Level Number of Dumps Goals Default 47 Fast compilation O1 134 O2 158 O3 168 Os 156 Optimize for space
14 CS 715 Graybox Probing-I: Preliminaries 11/45 Selected Dumps for Our Example Program GIMPLE dumps (t) 001t.tu 003t.original 004t.gimple 006t.vcg 009t.omplower 010t.lower 012t.eh 013t.cfg 017t.ssa 018t.veclower 019t.inline param1 020t.einline 037t.release ssa 038t.inline param2 044i.whole-program 048i.inline 138t.cplxlower0 143t.optimized 224t.statistics ipa dumps (i) 000i.cgraph 014i.visibility 015i.early local cleanups 044i.whole-program 048i.inline rtl dumps (r) 144r.expand 145r.sibling 147r.initvals 148r.unshare 149r.vregs 150r.into cfglayout 151r.jump 163r.reginfo 183r.outof cfglayout 184r.split1 186r.dfinit 187r.mode sw 188r.asmcons 191r.ira 194r.split2 198r.pro and epilogue 211r.stack 212r.alignments 215r.mach 216r.barriers 220r.shorten 221r.nothrow 222r.final 223r.dfinish assembly
15 CS 715 Graybox Probing-I: Preliminaries 12/45 Passes for First Level Graybox Probing of GCC C Source Code Parser AST Gimplifier GIMPLE CFG Generator CFG RTL Generator RTL expand Reg Allocator ira pro epilogue generation prologue-epilogue Pattern Matcher ASM Program Lowering of abstraction!
16 Part 2 Examining AST Dump
17 CS 715 Graybox Probing-I: Examining AST Dump 13/45 Generating Abstract Syntax Tree $ gcc -fdump-tree-original-raw test.c
18 CS 715 Graybox Probing-I: Examining AST Dump 14/45 Abstract Syntax Tree test.c test.c.003t.original ;; Function main (null) ;; enabled by -tree-original int a; int main() { a = bind expr body: void type algn: modify expr op type decl type: integer type algn: 32 prec: 32 sign: signed min var decl srcp: t1.c:1 algn: 32 used: integer cst low : identifier node strg: void lngt: type decl type: integer cst low : integer cst high: -1 low : integer cst low : identifier node strg: a lngt: identifier node strg: int lngt: integer type algn: 64 prec: 64 sign: unsigned min identifier node strg: bit size type lngt: integer cst low : integer cst low : integer cst low : -1
19 CS 715 Graybox Probing-I: Examining AST Dump 14/45 Abstract Syntax Tree test.c test.c.003t.original ;; Function main (null) ;; enabled by -tree-original int a; int main() { a = bind expr body: void type algn: modify expr op type decl type: integer type algn: 32 prec: 32 sign: signed min var decl srcp: t1.c:1 algn: 32 used: integer cst low : identifier node strg: void lngt: type decl type: integer cst low : integer cst high: -1 low : integer cst low : identifier node strg: a lngt: identifier node strg: int lngt: integer type algn: 64 prec: 64 sign: unsigned min identifier node strg: bit size type lngt: integer cst low : integer cst low : integer cst low : -1
20 CS 715 Graybox Probing-I: Examining AST Dump 14/45 Abstract Syntax Tree test.c test.c.003t.original ;; Function main (null) ;; enabled by -tree-original int a; int main() { a = bind expr body: void type algn: modify expr op type decl type: integer type algn: 32 prec: 32 sign: signed min var decl srcp: t1.c:1 algn: 32 used: integer cst low : identifier node strg: void lngt: type decl type: integer cst low : integer cst high: -1 low : integer cst low : identifier node strg: a lngt: identifier node strg: int lngt: integer type algn: 64 prec: 64 sign: unsigned min identifier node strg: bit size type lngt: integer cst low : integer cst low : integer cst low : -1
21 CS 715 Graybox Probing-I: Examining AST Dump 14/45 Abstract Syntax Tree test.c test.c.003t.original ;; Function main (null) ;; enabled by -tree-original int a; int main() { a = bind expr body: void type algn: modify expr op type decl type: integer type algn: 32 prec: 32 sign: signed min var decl srcp: t1.c:1 algn: 32 used: integer cst low : identifier node strg: void lngt: type decl type: integer cst low : integer cst high: -1 low : integer cst low : identifier node strg: a lngt: identifier node strg: int lngt: integer type algn: 64 prec: 64 sign: unsigned min identifier node strg: bit size type lngt: integer cst low : integer cst low : integer cst low : -1
22 CS 715 Graybox Probing-I: Examining AST Dump 14/45 Abstract Syntax Tree test.c test.c.003t.original ;; Function main (null) ;; enabled by -tree-original int a; int main() { a = bind expr body: void type algn: modify expr op type decl type: integer type algn: 32 prec: 32 sign: signed min var decl srcp: t1.c:1 algn: 32 used: integer cst low : identifier node strg: void lngt: type decl type: integer cst low : integer cst high: -1 low : integer cst low : identifier node strg: a lngt: identifier node strg: int lngt: integer type algn: 64 prec: 64 sign: unsigned min identifier node strg: bit size type lngt: integer cst low : integer cst low : integer cst low : -1
23 CS 715 Graybox Probing-I: Examining AST Dump 14/45 Abstract Syntax Tree test.c test.c.003t.original ;; Function main (null) ;; enabled by -tree-original int a; int main() { a = bind expr body: void type algn: modify expr op type decl type: integer type algn: 32 prec: 32 sign: signed min var decl srcp: t1.c:1 algn: 32 used: integer cst low : identifier node strg: void lngt: type decl type: integer cst low : integer cst high: -1 low : integer cst low : identifier node strg: a lngt: identifier node strg: int lngt: integer type algn: 64 prec: 64 sign: unsigned min identifier node strg: bit size type lngt: integer cst low : integer cst low : integer cst low : -1
24 CS 715 Graybox Probing-I: Examining AST Dump 14/45 Abstract Syntax Tree test.c test.c.003t.original ;; Function main (null) ;; enabled by -tree-original int a; int main() { a = bind expr body: void type algn: modify expr op type decl type: integer type algn: 32 prec: 32 sign: signed min var decl srcp: t1.c:1 algn: 32 used: integer cst low : identifier node strg: void lngt: type decl type: integer cst low : integer cst high: -1 low : integer cst low : identifier node strg: a lngt: identifier node strg: int lngt: integer type algn: 64 prec: 64 sign: unsigned min identifier node strg: bit size type lngt: integer cst low : integer cst low : integer cst low : -1
25 Part 3 Examining GIMPLE Dumps
26 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 15/45 Gimplifier About GIMPLE Three-address representation derived from GENERIC Computation represented as a sequence of basic operations Temporaries introduced to hold intermediate values Control construct are explicated into conditional jumps Examining GIMPLE Dumps Examining translation of data accesses Examining translation of control flow Examining translation of function calls
27 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 16/45 GIMPLE: Composite Expressions Involving Local and Global Variables test.c int a; test.c.004t.gimple int main() { int x = 10; int y = 5; x = a + x * y; y = y - a * x; x = 10; y = 5; D.1954 = x * y; a.0 = a; x = D a.0; a.1 = a; D.1957 = a.1 * x; y = y - D.1957; Global variables are treated as memory locations and local variables are treated as registers
28 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 16/45 GIMPLE: Composite Expressions Involving Local and Global Variables test.c int a; test.c.004t.gimple int main() { int x = 10; int y = 5; x = a + x * y; y = y - a * x; x = 10; y = 5; D.1954 = x * y; a.0 = a; x = D a.0; a.1 = a; D.1957 = a.1 * x; y = y - D.1957; Global variables are treated as memory locations and local variables are treated as registers
29 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 16/45 GIMPLE: Composite Expressions Involving Local and Global Variables test.c int a; test.c.004t.gimple int main() { int x = 10; int y = 5; x = a + x * y; y = y - a * x; x = 10; y = 5; D.1954 = x * y; a.0 = a; x = D a.0; a.1 = a; D.1957 = a.1 * x; y = y - D.1957; Global variables are treated as memory locations and local variables are treated as registers
30 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 16/45 GIMPLE: Composite Expressions Involving Local and Global Variables test.c int a; test.c.004t.gimple int main() { int x = 10; int y = 5; x = a + x * y; y = y - a * x; x = 10; y = 5; D.1954 = x * y; a.0 = a; x = D a.0; a.1 = a; D.1957 = a.1 * x; y = y - D.1957; Global variables are treated as memory locations and local variables are treated as registers
31 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 17/45 GIMPLE: 1-D Array Accesses test.c test.c.004t.gimple int main() { int a[3], x; a[1] = a[2] = 10; x = a[1] + a[2]; a[0] = a[1] + a[1]*x; a[2] = 10; D.1952 = a[2]; a[1] = D.1952; D.1953 = a[1]; D.1954 = a[2]; x = D D.1954; D.1955 = x + 1; D.1956 = a[1]; D.1957 = D.1955 * D.1956; a[0] = D.1957;
32 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 17/45 GIMPLE: 1-D Array Accesses test.c test.c.004t.gimple int main() { int a[3], x; a[1] = a[2] = 10; x = a[1] + a[2]; a[0] = a[1] + a[1]*x; a[2] = 10; D.1952 = a[2]; a[1] = D.1952; D.1953 = a[1]; D.1954 = a[2]; x = D D.1954; D.1955 = x + 1; D.1956 = a[1]; D.1957 = D.1955 * D.1956; a[0] = D.1957;
33 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 17/45 GIMPLE: 1-D Array Accesses test.c test.c.004t.gimple int main() { int a[3], x; a[1] = a[2] = 10; x = a[1] + a[2]; a[0] = a[1] + a[1]*x; a[2] = 10; D.1952 = a[2]; a[1] = D.1952; D.1953 = a[1]; D.1954 = a[2]; x = D D.1954; D.1955 = x + 1; D.1956 = a[1]; D.1957 = D.1955 * D.1956; a[0] = D.1957;
34 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 17/45 GIMPLE: 1-D Array Accesses test.c test.c.004t.gimple int main() { int a[3], x; a[1] = a[2] = 10; x = a[1] + a[2]; a[0] = a[1] + a[1]*x; a[2] = 10; D.1952 = a[2]; a[1] = D.1952; D.1953 = a[1]; D.1954 = a[2]; x = D D.1954; D.1955 = x + 1; D.1956 = a[1]; D.1957 = D.1955 * D.1956; a[0] = D.1957;
35 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 17/45 GIMPLE: 1-D Array Accesses test.c test.c.004t.gimple int main() { int a[3], x; a[1] = a[2] = 10; x = a[1] + a[2]; a[0] = a[1] + a[1]*x; a[2] = 10; D.1952 = a[2]; a[1] = D.1952; D.1953 = a[1]; D.1954 = a[2]; x = D D.1954; D.1955 = x + 1; D.1956 = a[1]; D.1957 = D.1955 * D.1956; a[0] = D.1957;
36 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 18/45 GIMPLE: 2-D Array Accesses test.c test.c.004t.gimple int main() { int a[3][3], x, y; a[0][0] = 7; a[1][1] = 8; a[2][2] = 9; x = a[0][0] / a[1][1]; y = a[1][1] % a[2][2]; a[0][0] = 7; a[1][1] = 8; a[2][2] = 9; D.1953 = a[0][0]; D.1954 = a[1][1]; x = D.1953 / D.1954; D.1955 = a[1][1]; D.1956 = a[2][2]; y = D.1955 % D.1956;
37 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 18/45 GIMPLE: 2-D Array Accesses test.c test.c.004t.gimple int main() { int a[3][3], x, y; a[0][0] = 7; a[1][1] = 8; a[2][2] = 9; x = a[0][0] / a[1][1]; y = a[1][1] % a[2][2]; a[0][0] = 7; a[1][1] = 8; a[2][2] = 9; D.1953 = a[0][0]; D.1954 = a[1][1]; x = D.1953 / D.1954; D.1955 = a[1][1]; D.1956 = a[2][2]; y = D.1955 % D.1956; No notion of addressable memory in GIMPLE. Array reference is a single operation in GIMPLE and is linearized in RTL during expansion
38 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 19/45 GIMPLE: Use of Pointers test.c test.c.004t.gimple int main() { int **a,*b,c; b = &c; a = &b; **a = 10; /* c = 10 */ ~ main () { int * D.1953; int * * a; int * b; int c; b = &c; a = &b; D.1953 = *a; *D.1953 = 10;
39 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 19/45 GIMPLE: Use of Pointers test.c test.c.004t.gimple int main() { int **a,*b,c; b = &c; a = &b; **a = 10; /* c = 10 */ ~ main () { int * D.1953; int * * a; int * b; int c; b = &c; a = &b; D.1953 = *a; *D.1953 = 10;
40 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 20/45 GIMPLE: Use of Structures test.c test.c.004t.gimple typedef struct address { char *name; ad; typedef struct student { int roll; ad *ct; st; int main() { st *s; s = malloc(sizeof(st)); s->roll = 1; s->ct=malloc(sizeof(ad)); s->ct->name = "Mumbai"; main () { void * D.1957; struct ad * D.1958; struct st * s; extern void * malloc (unsigned int); s = malloc (8); s->roll = 1; D.1957 = malloc (4); s->ct = D.1957; D.1958 = s->ct; D.1958->name = "Mumbai";
41 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 20/45 GIMPLE: Use of Structures test.c test.c.004t.gimple typedef struct address { char *name; ad; typedef struct student { int roll; ad *ct; st; int main() { st *s; s = malloc(sizeof(st)); s->roll = 1; s->ct=malloc(sizeof(ad)); s->ct->name = "Mumbai"; main () { void * D.1957; struct ad * D.1958; struct st * s; extern void * malloc (unsigned int); s = malloc (8); s->roll = 1; D.1957 = malloc (4); s->ct = D.1957; D.1958 = s->ct; D.1958->name = "Mumbai";
42 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 20/45 GIMPLE: Use of Structures test.c test.c.004t.gimple typedef struct address { char *name; ad; typedef struct student { int roll; ad *ct; st; int main() { st *s; s = malloc(sizeof(st)); s->roll = 1; s->ct=malloc(sizeof(ad)); s->ct->name = "Mumbai"; main () { void * D.1957; struct ad * D.1958; struct st * s; extern void * malloc (unsigned int); s = malloc (8); s->roll = 1; D.1957 = malloc (4); s->ct = D.1957; D.1958 = s->ct; D.1958->name = "Mumbai";
43 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 20/45 GIMPLE: Use of Structures test.c test.c.004t.gimple typedef struct address { char *name; ad; typedef struct student { int roll; ad *ct; st; int main() { st *s; s = malloc(sizeof(st)); s->roll = 1; s->ct=malloc(sizeof(ad)); s->ct->name = "Mumbai"; main () { void * D.1957; struct ad * D.1958; struct st * s; extern void * malloc (unsigned int); s = malloc (8); s->roll = 1; D.1957 = malloc (4); s->ct = D.1957; D.1958 = s->ct; D.1958->name = "Mumbai";
44 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 21/45 GIMPLE: Pointer to Array test.c test.c.004t.gimple int main() { int *p a, a[3]; p a = &a[0]; *p a = 10; *(p a+1) = 20; *(p a+2) = 30; main () { int * D.2048; int * D.2049; int * p a; int a[3]; p a = &a[0]; *p a = 10; D.2048 = p a + 4; *D.2048 = 20; D.2049 = p a + 8; *D.2049 = 30;
45 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 21/45 GIMPLE: Pointer to Array test.c test.c.004t.gimple int main() { int *p a, a[3]; p a = &a[0]; *p a = 10; *(p a+1) = 20; *(p a+2) = 30; main () { int * D.2048; int * D.2049; int * p a; int a[3]; p a = &a[0]; *p a = 10; D.2048 = p a + 4; *D.2048 = 20; D.2049 = p a + 8; *D.2049 = 30;
46 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 21/45 GIMPLE: Pointer to Array test.c test.c.004t.gimple int main() { int *p a, a[3]; p a = &a[0]; *p a = 10; *(p a+1) = 20; *(p a+2) = 30; main () { int * D.2048; int * D.2049; int * p a; int a[3]; p a = &a[0]; *p a = 10; D.2048 = p a + 4; *D.2048 = 20; D.2049 = p a + 8; *D.2049 = 30;
47 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 21/45 GIMPLE: Pointer to Array test.c test.c.004t.gimple int main() { int *p a, a[3]; p a = &a[0]; *p a = 10; *(p a+1) = 20; *(p a+2) = 30; main () { int * D.2048; int * D.2049; int * p a; int a[3]; p a = &a[0]; *p a = 10; D.2048 = p a + 4; *D.2048 = 20; D.2049 = p a + 8; *D.2049 = 30;
48 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 22/45 GIMPLE: Translation of Conditional Statements test.c test.c.004t.gimple int main() { int a=2, b=3, c=4; while (a<=7) { a = a+1; if (a<=12) a = a+b+c; if (a <= 12) goto <D.1200>; else goto <D.1201>; <D.1200>: D.1199 = a + b; a = D c; <D.1201>:
49 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 22/45 GIMPLE: Translation of Conditional Statements test.c test.c.004t.gimple int main() { int a=2, b=3, c=4; while (a<=7) { a = a+1; if (a<=12) a = a+b+c; if (a <= 12) goto <D.1200>; else goto <D.1201>; <D.1200>: D.1199 = a + b; a = D c; <D.1201>:
50 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 22/45 GIMPLE: Translation of Conditional Statements test.c test.c.004t.gimple int main() { int a=2, b=3, c=4; while (a<=7) { a = a+1; if (a<=12) a = a+b+c; if (a <= 12) goto <D.1200>; else goto <D.1201>; <D.1200>: D.1199 = a + b; a = D c; <D.1201>:
51 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 23/45 GIMPLE: Translation of Loops test.c test.c.004t.gimple int main() { int a=2, b=3, c=4; while (a<=7) { a = a+1; if (a<=12) a = a+b+c; goto <D.1197>; <D.1196>: a = a + 1; <D.1197>: if (a <= 7) goto <D.1196>; else goto <D.1198>; <D.1198>:
52 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 23/45 GIMPLE: Translation of Loops test.c test.c.004t.gimple int main() { int a=2, b=3, c=4; while (a<=7) { a = a+1; if (a<=12) a = a+b+c; goto <D.1197>; <D.1196>: a = a + 1; <D.1197>: if (a <= 7) goto <D.1196>; else goto <D.1198>; <D.1198>:
53 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 23/45 GIMPLE: Translation of Loops test.c test.c.004t.gimple int main() { int a=2, b=3, c=4; while (a<=7) { a = a+1; if (a<=12) a = a+b+c; goto <D.1197>; <D.1196>: a = a + 1; <D.1197>: if (a <= 7) goto <D.1196>; else goto <D.1198>; <D.1198>:
54 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 23/45 GIMPLE: Translation of Loops test.c test.c.004t.gimple int main() { int a=2, b=3, c=4; while (a<=7) { a = a+1; if (a<=12) a = a+b+c; goto <D.1197>; <D.1196>: a = a + 1; <D.1197>: if (a <= 7) goto <D.1196>; else goto <D.1198>; <D.1198>:
55 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 24/45 Control Flow Graph: Textual View test.c.004t.gimple test.c.013t.cfg if (a <= 12) goto <D.1200>; else goto <D.1201>; <D.1200>: D.1199 = a + b; a = D c; <D.1201>: <bb 5>: if (a <= 12) goto <bb 6>; else goto <bb 7>; <bb 6>: D.1199 = a + b; a = D c; <bb 7>: return;
56 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 24/45 Control Flow Graph: Textual View test.c.004t.gimple test.c.013t.cfg if (a <= 12) goto <D.1200>; else goto <D.1201>; <D.1200>: D.1199 = a + b; a = D c; <D.1201>: <bb 5>: if (a <= 12) goto <bb 6>; else goto <bb 7>; <bb 6>: D.1199 = a + b; a = D c; <bb 7>: return;
57 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 24/45 Control Flow Graph: Textual View test.c.004t.gimple test.c.013t.cfg if (a <= 12) goto <D.1200>; else goto <D.1201>; <D.1200>: D.1199 = a + b; a = D c; <D.1201>: <bb 5>: if (a <= 12) goto <bb 6>; else goto <bb 7>; <bb 6>: D.1199 = a + b; a = D c; <bb 7>: return;
58 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 24/45 Control Flow Graph: Textual View test.c.004t.gimple test.c.013t.cfg if (a <= 12) goto <D.1200>; else goto <D.1201>; <D.1200>: D.1199 = a + b; a = D c; <D.1201>: <bb 5>: if (a <= 12) goto <bb 6>; else goto <bb 7>; <bb 6>: D.1199 = a + b; a = D c; <bb 7>: return;
59 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 24/45 Control Flow Graph: Textual View test.c.004t.gimple test.c.013t.cfg if (a <= 12) goto <D.1200>; else goto <D.1201>; <D.1200>: D.1199 = a + b; a = D c; <D.1201>: <bb 5>: if (a <= 12) goto <bb 6>; else goto <bb 7>; <bb 6>: D.1199 = a + b; a = D c; <bb 7>: return;
60 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 25/45 Control Flow Graph: Pictorial View test.c.013t.cfg False Block 4: if(a<=7) True True Block 6: D.1199= a + b; a= D c; Block 5: if(a<=12) False Block 3: a = a +1; Block 7: return;
61 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 25/45 Control Flow Graph: Pictorial View test.c.013t.cfg while(a <= 7) a = a + 1; False Block 4: if(a<=7) True True Block 6: D.1199= a + b; a= D c; Block 5: if(a<=12) False Block 3: a = a +1; Block 7: return;
62 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 25/45 Control Flow Graph: Pictorial View test.c.013t.cfg if(a <= 12) a = a + b + c; True Block 6: D.1199= a + b; a= D c; False Block 5: if(a<=12) False Block 4: if(a<=7) True Block 3: a = a +1; Block 7: return;
63 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 26/45 GIMPLE: Function Calls and Call Graph test.c test.c.000i.cgraph extern int divide(int, int); int multiply(int a, int b) { return a*b; int main() { int x,y; x = divide(20,5); y = multiply(x,2); printf("%d\n", y); availabilit called by: main/1 (1.00 per call) calls: availabilit called by: main/1 (1.00 per call) calls: availability:a called by: calls: printf/3 (1.00 per call) multiply/0 (1.00 per call) divide/2 (1.00 per call) vailabilit called by: main/1 (1.00 per call) calls:
64 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 26/45 GIMPLE: Function Calls and Call Graph test.c test.c.000i.cgraph extern int divide(int, int); int multiply(int a, int b) { return a*b; int main() { int x,y; x = divide(20,5); y = multiply(x,2); printf("%d\n", y); availabilit called by: main/1 (1.00 per call) calls: availabilit called by: main/1 (1.00 per call) calls: availability:a called by: calls: printf/3 (1.00 per call) multiply/0 (1.00 per call) divide/2 (1.00 per call) vailabilit called by: main/1 (1.00 per call) calls:
65 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 26/45 GIMPLE: Function Calls and Call Graph test.c test.c.000i.cgraph extern int divide(int, int); int multiply(int a, int b) { return a*b; int main() { int x,y; x = divide(20,5); y = multiply(x,2); printf("%d\n", y); availabilit called by: main/1 (1.00 per call) calls: availabilit called by: main/1 (1.00 per call) calls: availability:a called by: calls: printf/3 (1.00 per call) multiply/0 (1.00 per call) divide/2 (1.00 per call) vailabilit called by: main/1 (1.00 per call) calls:
66 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 27/45 GIMPLE: Function Calls and Call Graph test.c test.c.000i.cgraph call graph extern int divide(int, int); int multiply(int a, int b) { return a*b; int main() { int x,y; x = divide(20,5); y = multiply(x,2); printf("%d\n", y); printf/3(-1) called by: main/1 calls: divide/2(-1) called by: main/1 calls: main/1(1) called by: calls: printf/3 multiply/0 divide/2 multiply/0(0) called by: main/1 calls: printf main multiply divide
67 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 27/45 GIMPLE: Function Calls and Call Graph test.c test.c.000i.cgraph call graph extern int divide(int, int); int multiply(int a, int b) { return a*b; int main() { int x,y; x = divide(20,5); y = multiply(x,2); printf("%d\n", y); printf/3(-1) called by: main/1 calls: divide/2(-1) called by: main/1 calls: main/1(1) called by: calls: printf/3 multiply/0 divide/2 multiply/0(0) called by: main/1 calls: printf main multiply divide
68 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 28/45 GIMPLE: Call Graphs for Recursive Functions test.c call graph int even(int n) { if (n == 0) return 1; else return (!odd(n-1)); int odd(int n) { if (n == 1) return 1; else return (!even(n-1)); main() { int n; n = abs(readnumber()); if (even(n)) printf ("n is even\n"); else printf ("n is odd\n"); main readnumber abs even printf odd
69 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 29/45 Inspect GIMPLE When in Doubt (1) int x=2,y=3; x = y x + ++y; What are the values of x and y?
70 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 29/45 Inspect GIMPLE When in Doubt (1) int x=2,y=3; x = y x + ++y; What are the values of x and y? x = 10, y =5
71 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 29/45 Inspect GIMPLE When in Doubt (1) int x=2,y=3; x = y x + ++y; What are the values of x and y? x = 10, y =5 x 2 y 3 (y +x) (y +x)+y
72 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 29/45 Inspect GIMPLE When in Doubt (1) int x=2,y=3; x = y x + ++y; What are the values of x and y? x = 10, y =5 x 3 y 3 (y +x) (y +x)+y
73 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 29/45 Inspect GIMPLE When in Doubt (1) int x=2,y=3; x = y x + ++y; What are the values of x and y? x = 10, y =5 x 3 y 3 (y +x) 6 (y +x)+y
74 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 29/45 Inspect GIMPLE When in Doubt (1) int x=2,y=3; x = y x + ++y; What are the values of x and y? x = 10, y =5 x 3 y 4 (y +x) 6 (y +x)+y
75 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 29/45 Inspect GIMPLE When in Doubt (1) int x=2,y=3; x = y x + ++y; What are the values of x and y? x = 10, y =5 x 3 y 5 (y +x) 6 (y +x)+y
76 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 29/45 Inspect GIMPLE When in Doubt (1) int x=2,y=3; x = y x + ++y; What are the values of x and y? x = 10, y =5 x 3 y 5 (y +x) 6 (y +x)+y 11
77 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 29/45 Inspect GIMPLE When in Doubt (1) int x=2,y=3; x = y x + ++y; What are the values of x and y? x = 10, y =5 x 3 y 5 (y +x) 6 (y +x)+y 11 x = 2; y = 3; x = x + 1; D.1572 = y + x; y = y + 1; x = D y; y = y + 1;
78 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 29/45 Inspect GIMPLE When in Doubt (1) int x=2,y=3; x = y x + ++y; What are the values of x and y? x = 10, y =5 x = 2; y = 3; x = x + 1; /* 3 */ D.1572 = y + x; y = y + 1; x = D y; y = y + 1;
79 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 29/45 Inspect GIMPLE When in Doubt (1) int x=2,y=3; x = y x + ++y; What are the values of x and y? x = 10, y =5 x = 2; y = 3; x = x + 1; /* 3 */ D.1572 = y + x; /* 6 */ y = y + 1; x = D y; y = y + 1;
80 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 29/45 Inspect GIMPLE When in Doubt (1) int x=2,y=3; x = y x + ++y; What are the values of x and y? x = 10, y =5 x = 2; y = 3; x = x + 1; /* 3 */ D.1572 = y + x; /* 6 */ y = y + 1; /* 4 */ x = D y; y = y + 1;
81 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 29/45 Inspect GIMPLE When in Doubt (1) int x=2,y=3; x = y x + ++y; What are the values of x and y? x = 10, y =5 x = 2; y = 3; x = x + 1; /* 3 */ D.1572 = y + x; /* 6 */ y = y + 1; /* 4 */ x = D y; /* 10 */ y = y + 1;
82 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 29/45 Inspect GIMPLE When in Doubt (1) int x=2,y=3; x = y x + ++y; What are the values of x and y? x = 10, y =5 x = 2; y = 3; x = x + 1; /* 3 */ D.1572 = y + x; /* 6 */ y = y + 1; /* 4 */ x = D y; /* 10 */ y = y + 1; /* 5 */
83 CS 715 Graybox Probing-I: Examining GIMPLE Dumps 30/45 Inspect GIMPLE When in Doubt (2) How is a[i] = i++ handled? This is an undefined behaviour as per C standards. What is the order of parameter evaluation? For a call f(getx(),gety()), is the order left to right? arbitrary? Is the evaluation order in GCC consistent? Understanding complicated declarations in C can be difficult What does the following declaration mean : int * (* (*MYVAR) (int) ) [10]; Hint: Use -fdump-tree-original-raw-verbose option. The dump to see is 003t.original
84 Part 4 Examining RTL Dumps
85 CS 715 Graybox Probing-I: Examining RTL Dumps 31/45 RTL for i386: Arithmetic Operations (1) Translation of a =a+1 Dump file: test.c.144r.expand (insn (parallel [ ( set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil))
86 CS 715 Graybox Probing-I: Examining RTL Dumps 31/45 RTL for i386: Arithmetic Operations (1) Translation of a =a+1 Dump file: test.c.144r.expand (insn (parallel [ ( set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) mem (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si plus (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) reg 54-4 plus (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil)) set mem plus reg
87 CS 715 Graybox Probing-I: Examining RTL Dumps 31/45 RTL for i386: Arithmetic Operations (1) Translation of a =a+1 Dump file: test.c.144r.expand (insn (parallel [ ( set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) mem (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si plus (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) reg 54-4 plus (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil)) set mem plus reg
88 CS 715 Graybox Probing-I: Examining RTL Dumps 31/45 RTL for i386: Arithmetic Operations (1) Translation of a =a+1 Dump file: test.c.144r.expand a is a local variable allocated on stack (insn (parallel [ ( set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) mem (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si plus (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) reg 54-4 plus (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil)) set mem plus reg
89 CS 715 Graybox Probing-I: Examining RTL Dumps 31/45 RTL for i386: Arithmetic Operations (1) Translation of a =a+1 Dump file: test.c.144r.expand a is a local variable allocated on stack (insn (parallel [ ( set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) mem (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si plus (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) reg 54-4 plus (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil)) set mem plus reg
90 CS 715 Graybox Probing-I: Examining RTL Dumps 31/45 RTL for i386: Arithmetic Operations (1) Translation of a =a+1 Dump file: test.c.144r.expand (insn (parallel [ ( set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) set side-effect of plus may modify condition code register non-deterministically parallel clobber (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si reg:cc (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil))
91 CS 715 Graybox Probing-I: Examining RTL Dumps 31/45 RTL for i386: Arithmetic Operations (1) Translation of a =a+1 Dump file: test.c.144r.expand Output with slim suffix {[r54:si-0x4]=[r54:si-0x4]+0x1; (insn (parallel [ clobber flags:cc; ( set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil))
92 CS 715 Graybox Probing-I: Examining RTL Dumps 32/45 Additional Information in RTL (insn (parallel [ (set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil))
93 CS 715 Graybox Probing-I: Examining RTL Dumps 32/45 Additional Information in RTL (insn (parallel [ (set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) Current Instruction (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil))
94 CS 715 Graybox Probing-I: Examining RTL Dumps 32/45 Additional Information in RTL (insn (parallel [ (set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) Previous Instruction (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil))
95 CS 715 Graybox Probing-I: Examining RTL Dumps 32/45 Additional Information in RTL (insn (parallel [ (set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) Next Instruction (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil))
96 CS 715 Graybox Probing-I: Examining RTL Dumps 32/45 Additional Information in RTL (insn (parallel [ (set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) Basic Block (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil))
97 CS 715 Graybox Probing-I: Examining RTL Dumps 32/45 Additional Information in RTL (insn (parallel [ (set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) File name: Line number (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil))
98 CS 715 Graybox Probing-I: Examining RTL Dumps 32/45 Additional Information in RTL (insn (parallel [ (set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) memory reference that does not trap (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil))
99 CS 715 Graybox Probing-I: Examining RTL Dumps 32/45 Additional Information in RTL (insn (parallel [ (set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) scalar that is not a part of an aggregate (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil))
100 CS 715 Graybox Probing-I: Examining RTL Dumps 32/45 Additional Information in RTL (insn (parallel [ (set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) register that holds a pointer (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil))
101 CS 715 Graybox Probing-I: Examining RTL Dumps 32/45 Additional Information in RTL (insn (parallel [ (set (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 54 virtual-stack-vars) single integer (const_int -4 [0xfffffffc])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:24-1 (nil))
102 CS 715 Graybox Probing-I: Examining RTL Dumps 33/45 RTL for i386: Arithmetic Operations (2) Translation of a = a+1 when a is a global variable Dump file: test.c.144r.expand (insn (set (reg:si 64 [ a.0 ]) (mem/c/i:si (symbol_ref:si ("a") <var_decl 0xb7d8d000 a>) [0 a+0 S4 A32])) t.c:26-1 (nil)) (insn (parallel [ (set (reg:si 63 [ a.1 ]) (plus:si (reg:si 64 [ a.0 ]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:26-1 (nil)) (insn (set (mem/c/i:si (symbol_ref:si ("a") <var_decl 0xb7d8d000 a>) [0 a+0 S4 A32]) (reg:si 63 [ a.1 ])) t.c:26-1 (nil))
103 CS 715 Graybox Probing-I: Examining RTL Dumps 33/45 RTL for i386: Arithmetic Operations (2) Translation of a = a+1 when a is a global variable Dump file: test.c.144r.expand (insn (set (reg:si 64 [ a.0 ]) Load a into reg64 (mem/c/i:si (symbol_ref:si ("a") <var_decl 0xb7d8d000 a>) [0 a+0 S4 A32])) t.c:26-1 (nil)) (insn (parallel [ (set (reg:si 63 [ a.1 ]) (plus:si (reg:si 64 [ a.0 ]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:26-1 (nil)) (insn (set (mem/c/i:si (symbol_ref:si ("a") <var_decl 0xb7d8d000 a>) [0 a+0 S4 A32]) (reg:si 63 [ a.1 ])) t.c:26-1 (nil))
104 CS 715 Graybox Probing-I: Examining RTL Dumps 33/45 RTL for i386: Arithmetic Operations (2) Translation of a = a+1 when a is a global variable Dump file: test.c.144r.expand (insn (set (reg:si 64 [ a.0 ]) Load a into reg64 (mem/c/i:si (symbol_ref:si ("a") <var_decl 0xb7d8d000 a>) [0 a+0 S4reg63 A32])) = reg64 t.c: (nil)) (insn (parallel [ (set (reg:si 63 [ a.1 ]) (plus:si (reg:si 64 [ a.0 ]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:26-1 (nil)) (insn (set (mem/c/i:si (symbol_ref:si ("a") <var_decl 0xb7d8d000 a>) [0 a+0 S4 A32]) (reg:si 63 [ a.1 ])) t.c:26-1 (nil))
105 CS 715 Graybox Probing-I: Examining RTL Dumps 33/45 RTL for i386: Arithmetic Operations (2) Translation of a = a+1 when a is a global variable Dump file: test.c.144r.expand (insn (set (reg:si 64 [ a.0 ]) Load a into reg64 (mem/c/i:si (symbol_ref:si ("a") <var_decl 0xb7d8d000 a>) [0 a+0 S4reg63 A32])) = reg64 t.c: (nil)) store reg63 into a (insn (parallel [ (set (reg:si 63 [ a.1 ]) (plus:si (reg:si 64 [ a.0 ]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:26-1 (nil)) (insn (set (mem/c/i:si (symbol_ref:si ("a") <var_decl 0xb7d8d000 a>) [0 a+0 S4 A32]) (reg:si 63 [ a.1 ])) t.c:26-1 (nil))
106 CS 715 Graybox Probing-I: Examining RTL Dumps 33/45 RTL for i386: Arithmetic Operations (2) Translation of a = a+1 when a is a global variable Dump file: test.c.144r.expand (insn (set (reg:si 64 [ a.0 ]) Load a into reg64 (mem/c/i:si (symbol_ref:si ("a") <var_decl 0xb7d8d000 a>) [0 a+0 S4reg63 A32])) = reg64 t.c: (nil)) store reg63 into a (insn (parallel [ (set (reg:si 63 [ a.1 ]) (plus:si (reg:si 64 [ a.0 ]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t.c:26-1 (nil)) (insn (set (mem/c/i:si (symbol_ref:si ("a") <var_decl 0xb7d8d000 a>) [0 a+0 S4 A32]) (reg:si 63 [ a.1 ])) t.c:26-1 (nil)) Output with slim suffix r64:si=[ a ] {r63:si=r64:si+0x1; clobber flags:cc; [ a ]=r63:si
107 CS 715 Graybox Probing-I: Examining RTL Dumps 34/45 RTL for i386: Arithmetic Operations (3) Translation of a = a+1 when a is a formal parameter Dump file: test.c.144r.expand (insn (parallel [ (set (mem/c/i:si (reg/f:si 53 virtual-incoming-args) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (reg/f:si 53 virtual-incoming-args) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t1.c:25-1 (nil))
108 CS 715 Graybox Probing-I: Examining RTL Dumps 34/45 RTL for i386: Arithmetic Operations (3) Translation of a = a+1 when a is a formal parameter Dump file: test.c.144r.expand Access through argument pointer register instead of (insn (parallel [ frame pointer register (set (mem/c/i:si (reg/f:si 53 virtual-incoming-args) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (reg/f:si 53 virtual-incoming-args) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t1.c:25-1 (nil))
109 CS 715 Graybox Probing-I: Examining RTL Dumps 34/45 RTL for i386: Arithmetic Operations (3) Translation of a = a+1 when a is a formal parameter Dump file: test.c.144r.expand (insn (parallel [ (set (mem/c/i:si Access through argument pointer register instead of frame pointer register No offset required? (reg/f:si 53 virtual-incoming-args) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (reg/f:si 53 virtual-incoming-args) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t1.c:25-1 (nil))
110 CS 715 Graybox Probing-I: Examining RTL Dumps 34/45 RTL for i386: Arithmetic Operations (3) Translation of a = a+1 when a is a formal parameter Dump file: test.c.144r.expand (insn (parallel [ (set (mem/c/i:si (reg/f:si 53 virtual-incoming-args) Output [0 with a+0 slim S4 A32]) suffix (plus:si (mem/c/i:si {[r53:si]=[r53:si]+0x1; (reg/f:si 53 virtual-incoming-args) clobber[0flags:cc; a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t1.c:25-1 (nil)) Access through argument pointer register instead of frame pointer register No offset required?
111 CS 715 Graybox Probing-I: Examining RTL Dumps 35/45 RTL for i386: Arithmetic Operation (4) Translation of a = a+1 when a is the second formal parameter Dump file: test.c.144r.expand (insn (parallel [ (set (mem/c/i:si (plus:si (reg/f:si 53 virtual-incoming-args) (const_int 4 [0x4])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 53 virtual-incoming-args) (const_int 4 [0x4])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t1.c:25-1 (nil))
112 CS 715 Graybox Probing-I: Examining RTL Dumps 35/45 RTL for i386: Arithmetic Operation (4) Translation of a = a+1 when a is the second formal parameter Dump file: test.c.144r.expand (insn (parallel [ (set (mem/c/i:si (plus:si (reg/f:si 53 virtual-incoming-args) Offset 4 added to the argument pointer register (const_int 4 [0x4])) [0 a+0 S4 A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 53 virtual-incoming-args) (const_int 4 [0x4])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t1.c:25-1 (nil))
113 CS 715 Graybox Probing-I: Examining RTL Dumps 35/45 RTL for i386: Arithmetic Operation (4) Translation of a = a+1 when a is the second formal parameter Dump file: test.c.144r.expand (insn (parallel [ (set (mem/c/i:si (plus:si Offset 4 added to the argument pointer register (reg/f:si 53 virtual-incoming-args) When a is the first parameter, its (const_int 4 [0x4])) [0 offset a+0 S4 is 0! A32]) (plus:si (mem/c/i:si (plus:si (reg/f:si 53 virtual-incoming-args) (const_int 4 [0x4])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t1.c:25-1 (nil))
114 CS 715 Graybox Probing-I: Examining RTL Dumps 35/45 RTL for i386: Arithmetic Operation (4) Translation of a = a+1 when a is the second formal parameter Dump file: test.c.144r.expand (insn (parallel [ (set (mem/c/i:si (plus:si (reg/f:si 53 virtual-incoming-args) When a is the first parameter, its (const_int 4 [0x4])) [0 offset a+0 S4 is 0! A32]) (plus:si (mem/c/i:si (plus:si {[r53:si+0x4]=[r53:si+0x4]+0x1; (reg/f:si 53 virtual-incoming-args) clobber flags:cc; (const_int 4 [0x4])) [0 a+0 S4 A32]) (const_int 1 [0x1]))) (clobber (reg:cc 17 flags)) ]) t1.c:25-1 (nil)) Offset 4 added to the argument pointer register Output with slim suffix
115 CS 715 Graybox Probing-I: Examining RTL Dumps 36/45 RTL for spim: Arithmetic Operations Translation of a = a+1 when a is a local variable Dump file: test.c.144r.expand r39=stack($fp - 4) r40=r39+1 stack($fp - 4)=r40 (insn (set (reg:si 39) (mem/c/i:si (plus:si (reg/f:si 33 virtual-stack-vars) (const_int -4 [...])) [...])) -1 (nil)) (insn test.c:6 (set (reg:si 40) (plus:si (reg:si 39) (const_int 1 [...]))) -1 (nil)) (insn test.c:6 (set (mem/c/i:si (plus:si (reg/f:si 33 virtual-stack-vars) (const_int -4 [...])) [...]) (reg:si 40)) test.c:6-1 (nil)) In spim, a variable is loaded into register to perform any instruction, hence three instructions are generated
116 CS 715 Graybox Probing-I: Examining RTL Dumps 36/45 RTL for spim: Arithmetic Operations Translation of a = a+1 when a is a local variable Dump file: test.c.144r.expand r39=stack($fp - 4) r40=r39+1 stack($fp - 4)=r40 (insn (set (reg:si 39) (mem/c/i:si (plus:si (reg/f:si 33 virtual-stack-vars) (const_int -4 [...])) [...])) -1 (nil)) (insn test.c:6 (set (reg:si 40) (plus:si (reg:si 39) (const_int 1 [...]))) -1 (nil)) (insn test.c:6 (set (mem/c/i:si (plus:si (reg/f:si 33 virtual-stack-vars) (const_int -4 [...])) [...]) (reg:si 40)) test.c:6-1 (nil)) In spim, a variable is loaded into register to perform any instruction, hence three instructions are generated
117 CS 715 Graybox Probing-I: Examining RTL Dumps 36/45 RTL for spim: Arithmetic Operations Translation of a = a+1 when a is a local variable Dump file: test.c.144r.expand r39=stack($fp - 4) r40=r39+1 stack($fp - 4)=r40 (insn (set (reg:si 39) (mem/c/i:si (plus:si (reg/f:si 33 virtual-stack-vars) (const_int -4 [...])) [...])) -1 (nil)) (insn test.c:6 (set (reg:si 40) (plus:si (reg:si 39) (const_int 1 [...]))) -1 (nil)) (insn test.c:6 (set (mem/c/i:si (plus:si (reg/f:si 33 virtual-stack-vars) (const_int -4 [...])) [...]) (reg:si 40)) test.c:6-1 (nil)) In spim, a variable is loaded into register to perform any instruction, hence three instructions are generated
GCC Internals: A Conceptual View Part II
: A Conceptual View Part II Abhijat Vichare CFDVS, Indian Institute of Technology, Bombay January 2008 Plan Part I GCC: Conceptual Structure C Program through GCC Building GCC Part II Gimple The MD-RTL
INTERMEDIATE REPRESENTATIONS RTL EXAMPLE
INTERMEDIATE REPRESENTATIONS CS 403: Intermediate Representations and Code Generation Stefan D. Bruda Winter 2015 Code generation is typically not done directly The functioning of a compiler is typically
An Overview of Compilation
An Overview of Compilation (www.cse.iitb.ac.in/ uday) Department of Computer Science and Engineering, Indian Institute of Technology, Bombay January 2014 cs306 Compilation Overview: Outline 1/18 Outline
The Design and Implementation of Gnu Compiler Collection
The Design and Implementation of Gnu Compiler Collection Uday Khedker (www.cse.iitb.ac.in/ uday) Department of Computer Science and Engineering, Indian Institute of Technology, Bombay July 2008 Part 1
University of Arizona, Department of Computer Science. CSc 453 Assignment 5 Due 23:59, Dec points. Christian Collberg November 19, 2002
University of Arizona, Department of Computer Science CSc 453 Assignment 5 Due 23:59, Dec 4 100 points Christian Collberg November 19, 2002 1 Introduction Your task is to write a code generator for the
Intermediate Representation
CS143 Handout 23 Summer 2011 August 3, 2011 Intermediate Representation Handout written by Maggie Johnson and revised by Julie Zelenski. Most compilers translate the source program first to some form of
Intermediate Code Generation
Intermediate Code Generation In the analysis-synthesis model of a compiler, the front end analyzes a source program and creates an intermediate representation, from which the back end generates target
Compiler Optimization
Compiler Optimization The compiler translates programs written in a high-level language to assembly language code Assembly language code is translated to object code by an assembler Object code modules
Plugin Mechanisms in GCC
Plugin Mechanisms in GCC (www.cse.iitb.ac.in/ uday) GCC Resource Center, Department of Computer Science and Engineering, Indian Institute of Technology, Bombay 13 June 2014 EAGCC-PLDI-14 Plugins: Outline
Compiler Theory. (GCC the GNU Compiler Collection) Sandro Spina 2009
Compiler Theory (GCC the GNU Compiler Collection) Sandro Spina 2009 GCC Probably the most used compiler. Not only a native compiler but it can also cross-compile any program, producing executables for
Retargeting GCC to Spim: A Recap
Workshop on Essential Abstractions in GCC July 09 Spim MD Levels 0 & 1: Outline 1/32 Outline Incremental Machine Descriptions for Spim: Levels 0 and 1 GCC Resource Center (www.cse.iitb.ac.in/grc Department
The Quest for Cheaper Variable Tracking in GCC Alexandre Oliva
1 The Quest for Cheaper Variable Tracking in GCC Alexandre Oliva aoliva@redhat.com http://identi.ca/lxoliva/ http://people.redhat.com/~aoliva/ GNU Tools Cauldron, 2012 Copyright 2012 Red Hat, Inc. This
Advanced C Programming
Advanced C Programming Compilers Sebastian Hack hack@cs.uni-sb.de Christoph Weidenbach weidenbach@mpi-inf.mpg.de 20.01.2009 saarland university computer science 1 Contents Overview Optimizations Program
ECS 142 Project: Code generation hints
ECS 142 Project: Code generation hints Winter 2011 1 Overview This document provides hints for the code generation phase of the project. I have written this in a rather informal way. However, you should
G Programming Languages - Fall 2012
G22.2110-003 Programming Languages - Fall 2012 Lecture 4 Thomas Wies New York University Review Last week Control Structures Selection Loops Adding Invariants Outline Subprograms Calling Sequences Parameter
The Compiler So Far. CSC 4181 Compiler Construction. Semantic Analysis. Beyond Syntax. Goals of a Semantic Analyzer.
The Compiler So Far CSC 4181 Compiler Construction Scanner - Lexical analysis Detects inputs with illegal tokens e.g.: main 5 (); Parser - Syntactic analysis Detects inputs with ill-formed parse trees
CSc 453. Compilers and Systems Software. 13 : Intermediate Code I. Department of Computer Science University of Arizona
CSc 453 Compilers and Systems Software 13 : Intermediate Code I Department of Computer Science University of Arizona collberg@gmail.com Copyright c 2009 Christian Collberg Introduction Compiler Phases
CS2210: Compiler Construction. Code Generation
Modern Compiler Project Fortran program Fortran s Lexer, Parser, and Static Checker Intermediate Code Generator IR MIPS Code Generator MIPS code C program C s Lexer, Parser, and Static Checker Intermediate
Introduction to Machine Descriptions
Tutorial on Essential Abstractions in GCC Introduction to Machine Descriptions (www.cse.iitb.ac.in/grc) GCC Resource Center, Department of Computer Science and Engineering, Indian Institute of Technology,
Intermediate Representations
Compiler Design 1 Intermediate Representations Compiler Design 2 Front End & Back End The portion of the compiler that does scanning, parsing and static semantic analysis is called the front-end. The translation
Final CSE 131B Spring 2004
Login name Signature Name Student ID Final CSE 131B Spring 2004 Page 1 Page 2 Page 3 Page 4 Page 5 Page 6 Page 7 Page 8 (25 points) (24 points) (32 points) (24 points) (28 points) (26 points) (22 points)
Intermediate Code & Local Optimizations
Lecture Outline Intermediate Code & Local Optimizations Intermediate code Local optimizations Compiler Design I (2011) 2 Code Generation Summary We have so far discussed Runtime organization Simple stack
Lectures 5-6: Introduction to C
Lectures 5-6: Introduction to C Motivation: C is both a high and a low-level language Very useful for systems programming Faster than Java This intro assumes knowledge of Java Focus is on differences Most
Short Notes of CS201
#includes: Short Notes of CS201 The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with < and > if the file is a system
Lectures 5-6: Introduction to C
Lectures 5-6: Introduction to C Motivation: C is both a high and a low-level language Very useful for systems programming Faster than Java This intro assumes knowledge of Java Focus is on differences Most
Aryan College. Fundamental of C Programming. Unit I: Q1. What will be the value of the following expression? (2017) A + 9
Fundamental of C Programming Unit I: Q1. What will be the value of the following expression? (2017) A + 9 Q2. Write down the C statement to calculate percentage where three subjects English, hindi, maths
CS201 - Introduction to Programming Glossary By
CS201 - Introduction to Programming Glossary By #include : The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with
Incremental Machine Descriptions for GCC
Incremental Machine Descriptions for GCC Sameera Deshpande Uday Khedker. (www.cse.iitb.ac.in/ {sameera,uday}) Department of Computer Science and Engineering, Indian Institute of Technology, Bombay September
Under the Compiler's Hood: Supercharge Your PLAYSTATION 3 (PS3 ) Code. Understanding your compiler is the key to success in the gaming world.
Under the Compiler's Hood: Supercharge Your PLAYSTATION 3 (PS3 ) Code. Understanding your compiler is the key to success in the gaming world. Supercharge your PS3 game code Part 1: Compiler internals.
G Programming Languages Spring 2010 Lecture 4. Robert Grimm, New York University
G22.2110-001 Programming Languages Spring 2010 Lecture 4 Robert Grimm, New York University 1 Review Last week Control Structures Selection Loops 2 Outline Subprograms Calling Sequences Parameter Passing
CSE P 501 Exam 12/1/11
Name There are 7 questions worth a total of 100 points. Please budget your time so you get to all of the questions. Keep your answers brief and to the point. You may refer to the following references:
Compiler construction in4020 lecture 5
Compiler construction in4020 lecture 5 Semantic analysis Assignment #1 Chapter 6.1 Overview semantic analysis identification symbol tables type checking CS assignment yacc LLgen language grammar parser
Announcements. My office hours are today in Gates 160 from 1PM-3PM. Programming Project 3 checkpoint due tomorrow night at 11:59PM.
IR Generation Announcements My office hours are today in Gates 160 from 1PM-3PM. Programming Project 3 checkpoint due tomorrow night at 11:59PM. This is a hard deadline and no late submissions will be
CSCI565 Compiler Design
CSCI565 Compiler Design Spring 2011 Homework 4 Solution Due Date: April 6, 2011 in class Problem 1: Activation Records and Stack Layout [50 points] Consider the following C source program shown below.
CSE 401/M501 Compilers
CSE 401/M501 Compilers x86-64, Running MiniJava, Basic Code Generation and Bootstrapping Hal Perkins Autumn 2018 UW CSE 401/M501 Autumn 2018 M-1 Running MiniJava Programs To run a MiniJava program Space
Homework #3: CMPT-379 Distributed on Oct 23; due on Nov 6 Anoop Sarkar
Homework #3: CMPT-379 Distributed on Oct 23; due on Nov 6 Anoop Sarkar anoop@cs.sfu.ca Only submit answers for questions marked with. Provide a makefile such that make compiles all your programs, and make
Compiler Code Generation COMP360
Compiler Code Generation COMP360 Students who acquire large debts putting themselves through school are unlikely to think about changing society. When you trap people in a system of debt, they can t afford
Intermediate Code Generation
Intermediate Code Generation Rupesh Nasre. CS3300 Compiler Design IIT Madras Aug 2015 Character stream Lexical Analyzer Machine-Independent Code Optimizer F r o n t e n d Token stream Syntax Analyzer Syntax
Where We Are. Lexical Analysis. Syntax Analysis. IR Generation. IR Optimization. Code Generation. Machine Code. Optimization.
Where We Are Source Code Lexical Analysis Syntax Analysis Semantic Analysis IR Generation IR Optimization Code Generation Optimization Machine Code Where We Are Source Code Lexical Analysis Syntax Analysis
CS 326 Operating Systems C Programming. Greg Benson Department of Computer Science University of San Francisco
CS 326 Operating Systems C Programming Greg Benson Department of Computer Science University of San Francisco Why C? Fast (good optimizing compilers) Not too high-level (Java, Python, Lisp) Not too low-level
Intermediate Representations
Most of the material in this lecture comes from Chapter 5 of EaC2 Intermediate Representations Note by Baris Aktemur: Our slides are adapted from Cooper and Torczon s slides that they prepared for COMP
5. Semantic Analysis!
5. Semantic Analysis! Prof. O. Nierstrasz! Thanks to Jens Palsberg and Tony Hosking for their kind permission to reuse and adapt the CS132 and CS502 lecture notes.! http://www.cs.ucla.edu/~palsberg/! http://www.cs.purdue.edu/homes/hosking/!
6.035 Project 3: Unoptimized Code Generation. Jason Ansel MIT - CSAIL
6.035 Project 3: Unoptimized Code Generation Jason Ansel MIT - CSAIL Quiz Monday 50 minute quiz Monday Covers everything up to yesterdays lecture Lexical Analysis (REs, DFAs, NFAs) Syntax Analysis (CFGs,
Concepts Introduced in Chapter 6
Concepts Introduced in Chapter 6 types of intermediate code representations translation of declarations arithmetic expressions boolean expressions flow-of-control statements backpatching EECS 665 Compiler
Code Generation. Dragon: Ch (Just part of it) Holub: Ch 6.
Code Generation Dragon: Ch 7. 8. (Just part of it) Holub: Ch 6. Compilation Processes Again Choice of Intermediate Code Representation (IR) IR examples Parse tree Three address code (e.g., x := y op z)
Compiler construction 2005 lecture 5
Compiler construction in400 lecture 5 Semantic analysis Assignment #1 Chapter 6.1 Overview semantic analysis identification symbol tables type checking CS assignment yacc LLgen language parser generator
Intermediate Code Generation
Intermediate Code Generation Rupesh Nasre. CS3300 Compiler Design IIT Madras July 2018 Character stream Lexical Analyzer Machine-Independent Code Code Optimizer F r o n t e n d Token stream Syntax Analyzer
CS5363 Final Review. cs5363 1
CS5363 Final Review cs5363 1 Programming language implementation Programming languages Tools for describing data and algorithms Instructing machines what to do Communicate between computers and programmers
Comp 204: Computer Systems and Their Implementation. Lecture 22: Code Generation and Optimisation
Comp 204: Computer Systems and Their Implementation Lecture 22: Code Generation and Optimisation 1 Today Code generation Three address code Code optimisation Techniques Classification of optimisations
W4118: PC Hardware and x86. Junfeng Yang
W4118: PC Hardware and x86 Junfeng Yang A PC How to make it do something useful? 2 Outline PC organization x86 instruction set gcc calling conventions PC emulation 3 PC board 4 PC organization One or more
Code No: R Set No. 1
Code No: R05010106 Set No. 1 1. (a) Draw a Flowchart for the following The average score for 3 tests has to be greater than 80 for a candidate to qualify for the interview. Representing the conditional
Compiler Construction: LLVMlite
Compiler Construction: LLVMlite Direct compilation Expressions X86lite Input Output Compile directly from expression language to x86 Syntax-directed compilation scheme Special cases can improve generated
We can emit stack-machine-style code for expressions via recursion
Code Generation The Main Idea of Today s Lecture We can emit stack-machine-style code for expressions via recursion (We will use MIPS assembly as our target language) 2 Lecture Outline What are stack machines?
CS 4240: Compilers and Interpreters Project Phase 1: Scanner and Parser Due Date: October 4 th 2015 (11:59 pm) (via T-square)
CS 4240: Compilers and Interpreters Project Phase 1: Scanner and Parser Due Date: October 4 th 2015 (11:59 pm) (via T-square) Introduction This semester, through a project split into 3 phases, we are going
GCC Control Flow and Plugins
Workshop on GCC Control Flow and Plugins GCC Resource Center (www.cse.iitb.ac.in/grc) Department of Computer Science and Engineering, Indian Institute of Technology, Bombay July 2010 July 2010 Plugins:
Principles of Compiler Design
Principles of Compiler Design Intermediate Representation Compiler Lexical Analysis Syntax Analysis Semantic Analysis Source Program Token stream Abstract Syntax tree Unambiguous Program representation
Calling Conventions. Hakim Weatherspoon CS 3410, Spring 2012 Computer Science Cornell University. See P&H 2.8 and 2.12
Calling Conventions Hakim Weatherspoon CS 3410, Spring 2012 Computer Science Cornell University See P&H 2.8 and 2.12 Goals for Today Calling Convention for Procedure Calls Enable code to be reused by allowing
Intermediate Code Generation
Intermediate Code Generation Basic Approach and Application to Assignment and xpressions Array xpressions Boolean xpressions Copyright 2017, Pedro C. Diniz, all rights reserved. Students enrolled in the
Intermediate Programming, Spring 2017*
600.120 Intermediate Programming, Spring 2017* Misha Kazhdan *Much of the code in these examples is not commented because it would otherwise not fit on the slides. This is bad coding practice in general
Semantic actions for declarations and expressions
Semantic actions for declarations and expressions Semantic actions Semantic actions are routines called as productions (or parts of productions) are recognized Actions work together to build up intermediate
COMPILER CONSTRUCTION Seminar 03 TDDB
COMPILER CONSTRUCTION Seminar 03 TDDB44 2016 Martin Sjölund (martin.sjolund@liu.se) Mahder Gebremedhin (mahder.gebremedhin@liu.se) Department of Computer and Information Science Linköping University LABS
GENERIC and GIMPLE: A New Tree Representation for Entire Functions
GENERIC and GIMPLE: A New Tree Representation for Entire Functions Jason Merrill Red Hat, Inc. jason@redhat.com 1 Abstract The tree SSA project requires a tree representation of functions for the optimizers
Acknowledgement. CS Compiler Design. Semantic Processing. Alternatives for semantic processing. Intro to Semantic Analysis. V.
Acknowledgement CS3300 - Compiler Design Intro to Semantic Analysis V. Krishna Nandivada IIT Madras Copyright c 2000 by Antony L. Hosking. Permission to make digital or hard copies of part or all of this
Tour of common optimizations
Tour of common optimizations Simple example foo(z) { x := 3 + 6; y := x 5 return z * y } Simple example foo(z) { x := 3 + 6; y := x 5; return z * y } x:=9; Applying Constant Folding Simple example foo(z)
NARESHKUMAR.R, AP\CSE, MAHALAKSHMI ENGINEERING COLLEGE, TRICHY Page 1
SEM / YEAR : VI / III CS2352 PRINCIPLES OF COMPLIERS DESIGN UNIT III INTERMEDIATE CODE GENERATION PART A 1. What are the benefits of intermediate code generation? (A.U May 2008) A Compiler for different
Compilers Project 3: Semantic Analyzer
Compilers Project 3: Semantic Analyzer CSE 40243 Due April 11, 2006 Updated March 14, 2006 Overview Your compiler is halfway done. It now can both recognize individual elements of the language (scan) and
Concepts Introduced in Chapter 6
Concepts Introduced in Chapter 6 types of intermediate code representations translation of declarations arithmetic expressions boolean expressions flow-of-control statements backpatching EECS 665 Compiler
Semantic actions for declarations and expressions. Monday, September 28, 15
Semantic actions for declarations and expressions Semantic actions Semantic actions are routines called as productions (or parts of productions) are recognized Actions work together to build up intermediate
CSCI Compiler Design
CSCI 565 - Compiler Design Spring 2015 Midterm Exam March 04, 2015 at 8:00 AM in class (RTH 217) Duration: 2h 30 min. Please label all pages you turn in with your name and student number. Name: Number:
Intermediate Representation Prof. James L. Frankel Harvard University
Intermediate Representation Prof. James L. Frankel Harvard University Version of 5:25 PM 10-Dec-2016 Copyright 2016, 2015 James L. Frankel. All rights reserved. Benefits Compiling i languages for j instruction
Introduction to Code Optimization. Lecture 36: Local Optimization. Basic Blocks. Basic-Block Example
Lecture 36: Local Optimization [Adapted from notes by R. Bodik and G. Necula] Introduction to Code Optimization Code optimization is the usual term, but is grossly misnamed, since code produced by optimizers
An Architectural Overview of GCC
An Architectural Overview of GCC Diego Novillo dnovillo@redhat.com Red Hat Canada Linux Symposium Ottawa, Canada, July 2006 Topics 1. Overview 2. Development model 3. Compiler infrastructure 4. Intermediate
CS415 Compilers. Intermediate Represeation & Code Generation
CS415 Compilers Intermediate Represeation & Code Generation These slides are based on slides copyrighted by Keith Cooper, Ken Kennedy & Linda Torczon at Rice University Review - Types of Intermediate Representations
Programmin Languages/Variables and Storage
Programmin Languages/Variables and Storage Onur Tolga Şehitoğlu Computer Engineering 4 Mart 2007 Outline 1 Storage Array Variables 2 Semantics of Assignment 3 Variable Lifetime Global Lifetime Local Lifetime
SEMANTIC ANALYSIS TYPES AND DECLARATIONS
SEMANTIC ANALYSIS CS 403: Type Checking Stefan D. Bruda Winter 2015 Parsing only verifies that the program consists of tokens arranged in a syntactically valid combination now we move to check whether
CSCI565 Compiler Design
CSCI565 Compiler Design Spring 2015 Homework 2 - Solution Problem 1: Attributive Grammar and Syntax-Directed Translation [25 points] Conser the grammar fragment below. It allows for the declaration of
Intermediate Representations
Intermediate Representations Akim Demaille Étienne Renault Roland Levillain first.last@lrde.epita.fr EPITA École Pour l Informatique et les Techniques Avancées April 18, 2017 Intermediate Representations
CMPT 379 Compilers. Anoop Sarkar. 11/13/07 1. TAC: Intermediate Representation. Language + Machine Independent TAC
CMPT 379 Compilers Anoop Sarkar http://www.cs.sfu.ca/~anoop 11/13/07 1 TAC: Intermediate Representation Language Specific Language + Machine Independent Machine Dependent Front End AST Intermediate Code
Intermediate Code Generation
Intermediate Code Generation Basic Approach and Application to Assignment and xpressions Array xpressions Boolean xpressions Copyright 2015, Pedro C. Diniz, all rights reserved. Students enrolled in the
CSc 453 Intermediate Code Generation
CSc 453 Intermediate Code Generation Saumya Debray The University of Arizona Tucson Overview Intermediate representations span the gap between the source and target languages: closer to target language;
Compiler Theory. (Intermediate Code Generation Abstract S yntax + 3 Address Code)
Compiler Theory (Intermediate Code Generation Abstract S yntax + 3 Address Code) 006 Why intermediate code? Details of the source language are confined to the frontend (analysis phase) of a compiler, while
CS412/CS413. Introduction to Compilers Tim Teitelbaum. Lecture 21: Generating Pentium Code 10 March 08
CS412/CS413 Introduction to Compilers Tim Teitelbaum Lecture 21: Generating Pentium Code 10 March 08 CS 412/413 Spring 2008 Introduction to Compilers 1 Simple Code Generation Three-address code makes it
Semantic Processing. Semantic Errors. Semantics - Part 1. Semantics - Part 1
Semantic Processing The Lexer and Parser Found lexical and syntax errors Built Abstract Syntax Tree Now!Find semantic errors.!build information about the program. Later!Generate IR Code!Optimize IR Code!Generate
CS 2210 Programming Project (Part IV)
CS 2210 Programming Project (Part IV) April 25, 2018 Code Generation This project is intended to give you experience in writing a code generator as well as bring together the various issues of code generation
Implementing Procedure Calls
1 / 39 Implementing Procedure Calls February 18 22, 2013 2 / 39 Outline Intro to procedure calls Caller vs. callee Procedure call basics Calling conventions The stack Interacting with the stack Structure
CS1622. Semantic Analysis. The Compiler So Far. Lecture 15 Semantic Analysis. How to build symbol tables How to use them to find
CS1622 Lecture 15 Semantic Analysis CS 1622 Lecture 15 1 Semantic Analysis How to build symbol tables How to use them to find multiply-declared and undeclared variables. How to perform type checking CS
CS 314 Principles of Programming Languages. Lecture 9
CS 314 Principles of Programming Languages Lecture 9 Zheng Zhang Department of Computer Science Rutgers University Wednesday 5 th October, 2016 Zheng Zhang 1 CS@Rutgers University Class Information Homework
Semantic Analysis and Type Checking
Semantic Analysis and Type Checking The compilation process is driven by the syntactic structure of the program as discovered by the parser Semantic routines: interpret meaning of the program based on
Compiler Optimization Intermediate Representation
Compiler Optimization Intermediate Representation Virendra Singh Associate Professor Computer Architecture and Dependable Systems Lab Department of Electrical Engineering Indian Institute of Technology
Intermediate Representations. Reading & Topics. Intermediate Representations CS2210
Intermediate Representations CS2210 Lecture 11 Reading & Topics Muchnick: chapter 6 Topics today: Intermediate representations Automatic code generation with pattern matching Optimization Overview Control
CS153: Compilers Lecture 15: Local Optimization
CS153: Compilers Lecture 15: Local Optimization Stephen Chong https://www.seas.harvard.edu/courses/cs153 Announcements Project 4 out Due Thursday Oct 25 (2 days) Project 5 out Due Tuesday Nov 13 (21 days)
5. Semantic Analysis. Mircea Lungu Oscar Nierstrasz
5. Semantic Analysis Mircea Lungu Oscar Nierstrasz Thanks to Jens Palsberg and Tony Hosking for their kind permission to reuse and adapt the CS132 and CS502 lecture notes. http://www.cs.ucla.edu/~palsberg/
specrtl: A Language for GCC Machine Descriptions
specrtl: A Language for GCC Machine Descriptions GCC Resource Center, Department of Computer Science and Engineering, Indian Institute of Technology, Bombay April 2011 GROW 2011, Chamonix specrtl: Outline
Intermediate Code Generation
Intermediate Code Generation Front-end intermediate code generation source program Lexical Analyzer Syntax Analyzer Semantic Analyzer Int. Code Generator intermediate representation Symbol Table Advantages
Chapter 2 A Quick Tour
Chapter 2 A Quick Tour 2.1 The Compiler Toolchain A compiler is one component in a toolchain of programs used to create executables from source code. Typically, when you invoke a single command to compile
CSE P 501 Exam Sample Solution 12/1/11
Question 1. (10 points, 5 each) Regular expressions. Give regular expressions that generate the following sets of strings. You may only use the basic operations of concatenation, choice ( ), and repetition
Intermediate Code & Local Optimizations. Lecture 20
Intermediate Code & Local Optimizations Lecture 20 Lecture Outline Intermediate code Local optimizations Next time: global optimizations 2 Code Generation Summary We have discussed Runtime organization
Assignment 11: functions, calling conventions, and the stack
Assignment 11: functions, calling conventions, and the stack ECEN 4553 & 5013, CSCI 4555 & 5525 Prof. Jeremy G. Siek December 5, 2008 The goal of this week s assignment is to remove function definitions
Compiler Passes. Optimization. The Role of the Optimizer. Optimizations. The Optimizer (or Middle End) Traditional Three-pass Compiler
Compiler Passes Analysis of input program (front-end) character stream Lexical Analysis Synthesis of output program (back-end) Intermediate Code Generation Optimization Before and after generating machine
Functions & First Class Function Values
Functions & First Class Function Values PLAI 1st ed Chapter 4, PLAI 2ed Chapter 5 The concept of a function is itself very close to substitution, and to our with form. Consider the following morph 1 {