specrtl: A Language for GCC Machine Descriptions
|
|
|
- Garey Pitts
- 5 years ago
- Views:
Transcription
1 specrtl: A Language for GCC Machine Descriptions GCC Resource Center, Department of Computer Science and Engineering, Indian Institute of Technology, Bombay April 2011
2 GROW 2011, Chamonix specrtl: Outline 1/29 Outline Introduction and motivation Introduction to specrtl Conclusions and Future Work
3 GROW 2011, Chamonix specrtl: Outline 1/29 Outline Introduction and motivation Introduction to specrtl Conclusions and Future Work Disclaimer: Preliminary work that is still evolving
4 Part 1 Introduction
5 GROW 2011, Chamonix specrtl: Introduction 2/29 Aho Ullman Model Compilation Models Davidson Fraser Model
6 GROW 2011, Chamonix specrtl: Introduction 2/29 Aho Ullman Model Compilation Models Davidson Fraser Model Front End Input Source Program AST
7 GROW 2011, Chamonix specrtl: Introduction 2/29 Aho Ullman Model Compilation Models Davidson Fraser Model Front End Input Source Program AST Optimizer Target Indep. IR
8 GROW 2011, Chamonix specrtl: Introduction 2/29 Aho Ullman Model Compilation Models Davidson Fraser Model Front End Input Source Program AST Optimizer Target Indep. IR Code Generator Target Program
9 GROW 2011, Chamonix specrtl: Introduction 2/29 Aho Ullman Model Compilation Models Davidson Fraser Model Front End Input Source Program Front End AST AST Optimizer Target Indep. IR Code Generator Target Program
10 GROW 2011, Chamonix specrtl: Introduction 2/29 Aho Ullman Model Compilation Models Davidson Fraser Model Front End Input Source Program Front End AST Optimizer Target Indep. IR AST Expander Register Transfers Code Generator Target Program
11 GROW 2011, Chamonix specrtl: Introduction 2/29 Aho Ullman Model Compilation Models Davidson Fraser Model Front End Input Source Program Front End AST Optimizer Target Indep. IR Code Generator AST Expander Register Transfers Optimizer Register Transfers Target Program
12 GROW 2011, Chamonix specrtl: Introduction 2/29 Aho Ullman Model Compilation Models Davidson Fraser Model Front End Input Source Program Front End AST Optimizer Target Indep. IR Code Generator AST Expander Register Transfers Optimizer Register Transfers Target Program Recognizer Target Program
13 GROW 2011, Chamonix specrtl: Introduction 2/29 Aho Ullman Model Compilation Models Davidson Fraser Model Front End AST Optimizer Target Indep. IR Code Generator Target Program Aho Ullman: Instruction selection over optimized IR using cost based tree pattern matching Davidson Fraser: Instruction selection over AST using structural tree pattern matching naive code which is target dependent, and is optimized subsequently Front End AST Expander Register Transfers Optimizer Register Transfers Recognizer Target Program
14 GROW 2011, Chamonix specrtl: Introduction 3/29 Retargetability in Aho Ullman and Davidson Fraser Models Instruction Selection Aho Ullman Model Davisdon Fraser Model Machine independent IR is expressed in the form of trees Machine instructions are described in the form of trees Trees in the IR are covered using the instruction trees Optimization
15 GROW 2011, Chamonix specrtl: Introduction 3/29 Retargetability in Aho Ullman and Davidson Fraser Models Instruction Selection Aho Ullman Model Davisdon Fraser Model Machine independent IR is expressed in the form of trees Machine instructions are described in the form of trees Trees in the IR are covered using the instruction trees Cost based tree pattern matching Optimization
16 GROW 2011, Chamonix specrtl: Introduction 3/29 Retargetability in Aho Ullman and Davidson Fraser Models Instruction Selection Aho Ullman Model Davisdon Fraser Model Machine independent IR is expressed in the form of trees Machine instructions are described in the form of trees Trees in the IR are covered using the instruction trees Cost based tree pattern Structual tree pattern matching matching Optimization
17 GROW 2011, Chamonix specrtl: Introduction 3/29 Retargetability in Aho Ullman and Davidson Fraser Models Instruction Selection Aho Ullman Model Davisdon Fraser Model Machine independent IR is expressed in the form of trees Machine instructions are described in the form of trees Trees in the IR are covered using the instruction trees Cost based tree pattern Structual tree pattern matching matching Optimization Machine independent
18 GROW 2011, Chamonix specrtl: Introduction 3/29 Retargetability in Aho Ullman and Davidson Fraser Models Instruction Selection Aho Ullman Model Davisdon Fraser Model Machine independent IR is expressed in the form of trees Machine instructions are described in the form of trees Trees in the IR are covered using the instruction trees Cost based tree pattern Structual tree pattern matching matching Machine dependent Optimization Machine independent
19 GROW 2011, Chamonix specrtl: Introduction 3/29 Retargetability in Aho Ullman and Davidson Fraser Models Instruction Selection Aho Ullman Model Davisdon Fraser Model Machine independent IR is expressed in the form of trees Machine instructions are described in the form of trees Trees in the IR are covered using the instruction trees Cost based tree pattern Structual tree pattern matching matching Machine dependent Optimization Machine independent Key Insight: Register transfers are target specific but their form is target independent
20 GROW 2011, Chamonix specrtl: Introduction 4/29 GCC s Adaptation of Davidson Fraser Model toplev main front end pass manager langhook... code for chosen language GIMPLE passes... pass 1 pass 2 code for pass 1 code for pass 2 expander code generated code pass expand RTL passes... pass n 1 pass n optab table code for pass n 1 Pattern matcher insn data
21 GROW 2011, Chamonix specrtl: Introduction 5/29 Comparing Code Generators in Davidson Fraser Model GCC Zephyr/VPO Quick C-- Expander Recognizer Transformation Trees (TT) Nature of TT Fixing shapes of TT TT Inst method TT Inst mapping Time of devising TT Inst mapping RTL templates Target dependent MD writing Pattern matching using finite automaton Fixed manually MD writing RTL templates Expansion tiles Target dependent MD writing LR parsing (Yacc based) Discovered automatically Compilation Target independent Framework design Pattern matching Discovered automatically Compiler construction
22 Part 2 Motivation
23 GROW 2011, Chamonix specrtl: Motivation 6/29 The Need for Improving Machine Descriptions The Problems: The specification mechanism for Machine descriptions is quite adhoc Adhoc design decisions
24 GROW 2011, Chamonix specrtl: Motivation 6/29 The Need for Improving Machine Descriptions The Problems: The specification mechanism for Machine descriptions is quite adhoc Adhoc design decisions
25 GROW 2011, Chamonix specrtl: Motivation 6/29 The Need for Improving Machine Descriptions The Problems: The specification mechanism for Machine descriptions is quite adhoc Only syntax borrowed from LISP, neither semantics not spirit! Non-composable rules Mode and code iterator mechanisms are insufficient Adhoc design decisions
26 GROW 2011, Chamonix specrtl: Motivation 6/29 The Need for Improving Machine Descriptions The Problems: The specification mechanism for Machine descriptions is quite adhoc Only syntax borrowed from LISP, neither semantics not spirit! Non-composable rules Mode and code iterator mechanisms are insufficient Adhoc design decisions Honouring operand constraints delayed to global register allocation During GIMPLE to RTL translation, a lot of C code is required Choice of insertion of NOPs
27 GROW 2011, Chamonix specrtl: Motivation 7/29 Symptom of Poor Specification Mechanism Machine descriptions are large, verbose, repetitive, and contain large chunks of C code Size in terms of line counts for gcc Target *.md *.c *.h Total i mips
28 GROW 2011, Chamonix specrtl: Motivation 7/29 Symptom of Poor Specification Mechanism Machine descriptions are large, verbose, repetitive, and contain large chunks of C code Size in terms of line counts for gcc Target *.md *.c *.h Total i mips Machine descriptions are difficult to construct, understand, debug, and enhance
29 GROW 2011, Chamonix specrtl: Motivation 8/29 Typical Instruction Specification in GCC (define_insn "movsi" [(set (match_operand:si 0 "register_operand" "r") (match_operand:si 1 "const_int_operand" "k") )] "" /* C boolean expression, if required */ "li %0, %1" )
30 GROW 2011, Chamonix specrtl: Motivation 8/29 Typical Instruction Specification in GCC Define instruction pattern Standard Pattern Name (define_insn "movsi" [(set (match_operand:si 0 "register_operand" "r") (match_operand:si 1 "const_int_operand" "k") )] "" /* C boolean expression, if required */ "li %0, %1" ) RTL Expression (RTX): Semantics of target instruction target asm inst. = Concrete syntax for RTX
31 GROW 2011, Chamonix specrtl: Motivation 8/29 Typical Instruction Specification in GCC RTL operator MD constructs (define_insn "movsi" [(set (match_operand:si 0 "register_operand" "r") (match_operand:si 1 "const_int_operand" "k") )] "" /* C boolean expression, if required */ "li %0, %1" ) Mode Predicates Constraints
32 GROW 2011, Chamonix specrtl: Motivation 9/29 Design Flaws in Machine Descriptions Multiple patterns with same structure Repetition of almost similar RTL expressions across multiple define insn an define expand patterns Some Modes, Predicates, Constraints, Boolean Condition, or RTL Expression may differ everything else may be identical One RTL expression may appears as a sub-expression of some other RTL expression Repetition of C code along with RTL expressions in these patterns.
33 GROW 2011, Chamonix specrtl: Motivation 10/29 Redundancy in MIPS Machine Descriptions: Example 1 [(set (match_operand:m 0 "register_operand" "c0") (plus:m (match_operand:m 1 "register_operand" "c1") (match_operand:m 2 "p" "c2")))] RTL Template
34 GROW 2011, Chamonix specrtl: Motivation 10/29 Redundancy in MIPS Machine Descriptions: Example 1 [(set (match_operand:m 0 "register_operand" "c0") (plus:m (match_operand:m 1 "register_operand" "c1") (match_operand:m 2 "p" "c2")))] RTL Template Structure = +
35 GROW 2011, Chamonix specrtl: Motivation 10/29 Redundancy in MIPS Machine Descriptions: Example 1 [(set (match_operand:m 0 "register_operand" "c0") (plus:m (match_operand:m 1 "register_operand" "c1") (match_operand:m 2 "p" "c2")))] RTL Template Structure = + Details Pattern name m p c0 c1 c2 define insn add<mode>3 ANYF register operand =f f f define expand add<mode>3 GPR arith operand define insn *add<mode>3 GPR arith operand =d,d d,d d,q
36 GROW 2011, Chamonix specrtl: Motivation 11/29 Redundancy in MIPS Machine Descriptions: Example 2 [(set (match_operand:m 0 "register_operand" "c0") (mult:m (match_operand:m 1 "register_operand" "c1") (match_operand:m 2 "register_operand" "c2")))] RTL Template
37 GROW 2011, Chamonix specrtl: Motivation 11/29 Redundancy in MIPS Machine Descriptions: Example 2 [(set (match_operand:m 0 "register_operand" "c0") (mult:m (match_operand:m 1 "register_operand" "c1") (match_operand:m 2 "register_operand" "c2")))] RTL Template = Structure
38 GROW 2011, Chamonix specrtl: Motivation 11/29 Redundancy in MIPS Machine Descriptions: Example 2 [(set (match_operand:m 0 "register_operand" "c0") (mult:m (match_operand:m 1 "register_operand" "c1") (match_operand:m 2 "register_operand" "c2")))] RTL Template = Structure Details Pattern name m c0 c1 c2 define insn *mul<mode>3 SCALARF =f f f define insn *mul<mode>3 r4300 SCALARF =f f f define insn mulv2sf3 V2SF =f f f define expand mul<mode>3 GPR define insn mul<mode>3 mul3 loongson GPR =d d d define insn mul<mode>3 mul3 GPR d,1 d,d d,d
39 GROW 2011, Chamonix specrtl: Motivation 12/29 Redundancy in MIPS Machine Descriptions: Example 3 [(set (match_operand:m 0 "register_operand" "c0") (plus:m (mult:m (match_operand:m 1 "register_operand" "c1") (match_operand:m 2 "register_operand" "c2")))] (match_operand:m 3 "register_operand" "c3")))] RTL Template
40 GROW 2011, Chamonix specrtl: Motivation 12/29 Redundancy in MIPS Machine Descriptions: Example 3 [(set (match_operand:m 0 "register_operand" "c0") (plus:m (mult:m (match_operand:m 1 "register_operand" "c1") (match_operand:m 2 "register_operand" "c2")))] (match_operand:m 3 "register_operand" "c3")))] RTL Template = Structure +
41 GROW 2011, Chamonix specrtl: Motivation 12/29 Redundancy in MIPS Machine Descriptions: Example 3 [(set (match_operand:m 0 "register_operand" "c0") (plus:m (mult:m (match_operand:m 1 "register_operand" "c1") (match_operand:m 2 "register_operand" "c2")))] (match_operand:m 3 "register_operand" "c3")))] RTL Template = Structure + Details Pattern name m c0 c1 c2 c3 *mul acc si SI =l*?*?,d? d,d d,d 0,d *mul acc si r3900 SI =l*?*?,d*?,d? d,d,d d,d,d 0,1,d *macc SI =l,d d,d d,d 0,1 *madd4<mode> ANYF =f f f f *madd3<mode> ANYF =f f f 0
42 GROW 2011, Chamonix specrtl: Motivation 13/29 Insufficient Iterator Mechanism Iterators cannot be used across define insn, define expand, define peephole2 and other patterns Defining iterator attribute for each varying parameter becomes tedious For same set of modes and rtx codes, change in other fields of pattern makes use of iterators impossible Mode and code attributes cannot be defined for operator or operand number, name of the pattern etc. Patterns with different RTL template share attribute value vector for which iterators can not be used
43 GROW 2011, Chamonix specrtl: Motivation 14/29 Many Similar Patterns Cannot be Combined (define expand iordi3 [(set (match operand:di 0 nonimmediate operand ) (ior:di (match operand:di 1 nonimmediate operand ) (match operand:di 2 x86 64 general operand ))) (clobber (reg:cc FLAGS REG))] TARGET 64BIT ix86 expand binary operator (IOR, DImode, operands); DONE; ) (define insn *iordi 1 rex64 [(set (match operand:di 0 nonimmediate operand =rm,r ) (ior:di (match operand:di 1 nonimmediate operand %0,0 ) (match operand:di 2 x86 64 general operand re,rme ))) (clobber (reg:cc FLAGS REG))] TARGET 64BIT && ix86 binary operator ok (IOR, DImode, operands) or{q}\t{%2, %0 %0, %2} [(set attr type alu ) (set attr mode DI )])
44 GROW 2011, Chamonix specrtl: Motivation 15/29 Measuring Redundancy in RTL Templates MD File Total number of patterns Number of primitive trees Number of times primitive trees are used to create composite trees i386.md arm.md mips.md
45 Part 3 Introduction to specrtl
46 GROW 2011, Chamonix specrtl: Introduction to specrtl 16/29 Key Observation Behind specrtl Davidson Fraser insight Register transfers are target specific but their form is target independent GCC s approach Use Target independent RTL for machine specification Generate expander and recognizer by reading machine descriptions Main problems with GCC s Approach Although the shapes of RTL statements are target independent, they have to be provided in RTL templates Our key idea: Separate shapes of RTL statements from the target specific details
47 GROW 2011, Chamonix specrtl: Introduction to specrtl 17/29 Specification Goals of specrtl Support all of the following Separation of shapes from target specific details Creation of new shapes by composing shapes Associtiating concrete details with shapes Overriding concrete details
48 GROW 2011, Chamonix specrtl: Introduction to specrtl 18/29 Software Engineering Goals of specrtl Allow non-disruptive migration for existing machine descriptions Incremental changes No need to change GCC source until we are sure of the new specification GCC must remain usable after each small change made in the machine descriptions
49 GROW 2011, Chamonix specrtl: Introduction to specrtl 19/29 Meeting the Specification Goals: Key Idea Separation of shapes from target specific details: Shape tree structure of RTL templates Details attributes of tree nodes (eg. modes, predicates, constraints etc.)
50 GROW 2011, Chamonix specrtl: Introduction to specrtl 19/29 Meeting the Specification Goals: Key Idea Separation of shapes from target specific details: Shape tree structure of RTL templates Details attributes of tree nodes (eg. modes, predicates, constraints etc.) Abstract patterns and Concrete patterns Abstract patterns are shapes with holes in them that represent missing information Concrete patterns are shapes in which all holes are plugged in using target specific information
51 GROW 2011, Chamonix specrtl: Introduction to specrtl 19/29 Meeting the Specification Goals: Key Idea Separation of shapes from target specific details: Shape tree structure of RTL templates Details attributes of tree nodes (eg. modes, predicates, constraints etc.) Abstract patterns and Concrete patterns Abstract patterns are shapes with holes in them that represent missing information Concrete patterns are shapes in which all holes are plugged in using target specific information Abstract patterns capture shapes which can be concretized by providing details
52 GROW 2011, Chamonix specrtl: Introduction to specrtl 20/29 Meeting the Specification Goals: Operations Creating new shapes by composing shapes: extends
53 GROW 2011, Chamonix specrtl: Introduction to specrtl 20/29 Meeting the Specification Goals: Operations Creating new shapes by composing shapes: extends Associtiating concrete details with shapes: instantiates
54 GROW 2011, Chamonix specrtl: Introduction to specrtl 20/29 Meeting the Specification Goals: Operations Creating new shapes by composing shapes: extends Associtiating concrete details with shapes: instantiates Overriding concrete details: overrides
55 GROW 2011, Chamonix specrtl: Introduction to specrtl 21/29 Properties of Operations Operation Base pattern Derived pattern Nodes influenced Can change extends Abstract Abstract Leaf nodes Structure instantiates Abstract Concrete All nodes Attributes Abstract Abstract Internal nodes Attributes overrides Concrete Concrete All nodes Attributes
56 GROW 2011, Chamonix specrtl: Introduction to specrtl 22/29 Creating Abstract Patterns abstract set_plus extends set { root.2 = plus; } root.1 root.2.1 = root + root.2 root.2.2 abstract set_macc extends set_plus { root.2.2 = mult; } = root + root.2 root.1 root.2.2 root.2.1 root root.2.2.2
57 GROW 2011, Chamonix specrtl: Introduction to specrtl 23/29 Creating Concrete Patterns abstract set_plus extends set { root.2 = plus; } root.1 root.2.1 = root concrete add<mode>3.insn instantiates set_plus { set_plus(register_operand:anyf:"=f", register_operand:anyf:"f", register_operand:anyf:"f"); root.2.mode = ANYF; } concrete add<mode>3.expand instantiates set_plus { set_plus(register_operand:gpr:"", register_operand:gpr:"", arith_operand:gpr:""); root.2.mode = GPR; } + root.2 root.2.2
58 GROW 2011, Chamonix specrtl: Introduction to specrtl 24/29 Generating Conventional Machine Descriptions abstract set_plus extends set { root.2 = plus; } root.1 root.2.1 = root + root.2 root.2.2 concrete add<mode>3.insn instantiates set_plus { set_plus(register_operand:anyf:"=f", register_operand:anyf:"f", register_operand:anyf:"f"); root.2.mode = ANYF; } {: /* Conventional Machine Description Fragments */ :} (define_insn "add<mode>3" [(set (match_operand:anyf 0 "register_operand" "=f") (plus:anyf (match_operand:anyf 1 "register_operand" "f") (match_operand:anyf 2 "register_operand" "f")))] /* Conventional Machine Description Fragments */ )
59 GROW 2011, Chamonix specrtl: Introduction to specrtl 24/29 Generating Conventional Machine Descriptions abstract set_plus extends set { root.2 = plus; } root.1 root.2.1 = root + root.2 root.2.2 concrete add<mode>3.insn instantiates set_plus { set_plus(register_operand:anyf:"=f", register_operand:anyf:"f", register_operand:anyf:"f"); root.2.mode = ANYF; } {: /* Conventional Machine Description Fragments */ :} (define_insn "add<mode>3" [(set (match_operand:anyf 0 "register_operand" "=f") (plus:anyf (match_operand:anyf 1 "register_operand" "f") (match_operand:anyf 2 "register_operand" "f")))] /* Conventional Machine Description Fragments */ )
60 GROW 2011, Chamonix specrtl: Introduction to specrtl 24/29 Generating Conventional Machine Descriptions abstract set_plus extends set { root.2 = plus; } root.1 root.2.1 = root + root.2 root.2.2 concrete add<mode>3.insn instantiates set_plus { set_plus(register_operand:anyf:"=f", register_operand:anyf:"f", register_operand:anyf:"f"); root.2.mode = ANYF; } {: /* Conventional Machine Description Fragments */ :} Resulting MD Specification (define_insn "add<mode>3" [(set (match_operand:anyf 0 "register_operand" "=f") (plus:anyf (match_operand:anyf 1 "register_operand" "f") (match_operand:anyf 2 "register_operand" "f")))] /* Conventional Machine Description Fragments */ )
61 GROW 2011, Chamonix specrtl: Introduction to specrtl 25/29 Overriding Details abstract set_plus extends set { root.2 = plus; } root.1 root.2.1 = root concrete add<mode>3.expand instantiates set_plus { set_plus(register_operand:gpr:"", register_operand:gpr:"", arith_operand:gpr:""); root.2.mode = GPR; } + root.2 root.2.2 concrete *add<mode>3.insn overrides add<mode>3.expand { allconstraints = ("=d,d", "d,d", "d,q"); }
62 GROW 2011, Chamonix specrtl: Introduction to specrtl 25/29 Overriding Details abstract set_plus extends set { root.2 = plus; } root.1 root.2.1 = root concrete add<mode>3.expand instantiates set_plus { set_plus(register_operand:gpr:"", register_operand:gpr:"", arith_operand:gpr:""); root.2.mode = GPR; } + root.2 root.2.2 concrete *add<mode>3.insn overrides add<mode>3.expand { allconstraints = ("=d,d", "d,d", "d,q"); }
63 GROW 2011, Chamonix specrtl: Introduction to specrtl 26/29 Some More Examples Omitting conventional MD fragments concrete *mul<mode>3.insn instantiates set_mult { set_mult(register_operand:scalarf:"=f", register_operand:scalarf:"f", register_operand:scalarf:"f"); root.2.mode = SCALARF; } concrete *mul<mode>3_r4300.insn overrides *mul<mode>3.insn {} concrete mulv2sf3 overrides *mul<mode>3.insn { SCALARF -> V2SF; }
64 GROW 2011, Chamonix specrtl: Introduction to specrtl 26/29 Some More Examples Omitting conventional MD fragments concrete *mul<mode>3.insn instantiates set_mult { set_mult(register_operand:scalarf:"=f", register_operand:scalarf:"f", register_operand:scalarf:"f"); root.2.mode = SCALARF; } concrete *mul<mode>3_r4300.insn overrides *mul<mode>3.insn {} concrete mulv2sf3 overrides *mul<mode>3.insn { SCALARF -> V2SF; }
65 Part 4 Conclusions
66 GROW 2011, Chamonix specrtl: Conclusions 27/29 Current Status and Plans for Future Work specrtl parser has been augmented with semantic checks Emitting conventional machine descriptions is pending i386 move instructions and spim add instructions have been rewritten Other instructions are being rewritten Suggestions have been received to improve the syntax
67 GROW 2011, Chamonix specrtl: Conclusions 28/29 Conclusions Separating shapes from concrete details is very helpful It may be possible to identify a large number of common shapes Machine descriptions may become much smaller Only the concrete details need to be specified Non-disruptive and incremental migration to new machine descriptions GCC source need not change until these machine descriptions have been found useful
68 GROW 2011, Chamonix specrtl: Conclusions 29/29 Last but not the least... Thank You!
specrtl: A Language for GCC Machine Descriptions
specrtl: A Language for GCC Machine Descriptions Uday P. Khedker, Ankita Mathur GCC Resource Center, Dept. of Computer Science and Engg., IIT Bombay, India {uday,ankitam}@cse.iitb.ac.in Abstract. The mechanism
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,
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
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
arxiv: v1 [cs.pl] 30 Sep 2013
![arxiv: v1 [cs.pl] 30 Sep 2013](/thumbs/79/79113744.jpg "arxiv: v1 [cs.pl] 30 Sep 2013")
Retargeting GCC: Do We Reinvent the Wheel Every Time? Saravana Perumal P Department of CSE, IIT Kanpur saravanan1986@gmail.com Amey Karkare Department of CSE, IIT Kanpur karkare@cse.iitk.ac.in arxiv:1309.7685v1
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
CSE 504: Compiler Design. Instruction Selection
Instruction Selection Pradipta De pradipta.de@sunykorea.ac.kr Current Topic Instruction Selection techniques Tree Walk Tiling based approach Peephole Optimization Instruction Selection Difficulty of Instruction
Instruction Selection, II Tree-pattern matching
Instruction Selection, II Tree-pattern matching Copyright 2003, Keith D. Cooper, Ken Kennedy & Linda Torczon, all rights reserved. Students enrolled in Comp 4 at Rice University have explicit permission
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:
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
Compiler Design (40-414)
Compiler Design (40-414) Main Text Book: Compilers: Principles, Techniques & Tools, 2 nd ed., Aho, Lam, Sethi, and Ullman, 2007 Evaluation: Midterm Exam 35% Final Exam 35% Assignments and Quizzes 10% Project
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
Agenda. CSE P 501 Compilers. Big Picture. Compiler Organization. Intermediate Representations. IR for Code Generation. CSE P 501 Au05 N-1
Agenda CSE P 501 Compilers Instruction Selection Hal Perkins Autumn 2005 Compiler back-end organization Low-level intermediate representations Trees Linear Instruction selection algorithms Tree pattern
Instruction Selection: Peephole Matching. Copyright 2003, Keith D. Cooper, Ken Kennedy & Linda Torczon, all rights reserved.
Instruction Selection: Peephole Matching Copyright 2003, Keith D. Cooper, Ken Kennedy & Linda Torczon, all rights reserved. The Problem Writing a compiler is a lot of work Would like to reuse components
The Phasewise File Groups of GCC
The Phasewise File Groups of GCC GCC Version 4.0.2 Abhijat Vichare (amvichare@iitb.ac.in) Indian Institute of Technology, Bombay (http://www.iitb.ac.in) This is edition 1.0 of The Phasewise File Groups
Compiler Design Overview. Compiler Design 1
Compiler Design Overview Compiler Design 1 Preliminaries Required Basic knowledge of programming languages. Basic knowledge of FSA and CFG. Knowledge of a high programming language for the programming
CS 406/534 Compiler Construction Instruction Selection and Global Register Allocation
CS 406/534 Compiler Construction Instruction Selection and Global Register Allocation Prof. Li Xu Dept. of Computer Science UMass Lowell Fall 2004 Part of the course lecture notes are based on Prof. Keith
Adding custom instructions to the Simplescalar infrastructure
Adding custom instructions to the Simplescalar infrastructure Somasundaram Meiyappan HT023601A School of Computing National University of Singapore meisoms@ieee.org ABSTRACT Synthesizable processors like
First Level Gray Box Probing
First Level Gray Box Probing (www.cse.iitb.ac.in/ uday) GCC Resource Center, Department of Computer Science and Engineering, Indian Institute of Technology, Bombay January 2012 CS 715 Graybox Probing-I:
Combined Object-Lambda Architectures
www.jquigley.com jquigley#jquigley.com Chicago Lisp April 2008 Research Goals System Goals Conventional Systems Unconventional Systems Research Goals Question: How to make with Pepsi and Coke? The Goal:
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
Faculty of Electrical Engineering, Mathematics, and Computer Science Delft University of Technology
Faculty of Electrical Engineering, Mathematics, and Computer Science Delft University of Technology exam Compiler Construction in4303 April 9, 2010 14.00-15.30 This exam (6 pages) consists of 52 True/False
Topic 6 Basic Back-End Optimization
Topic 6 Basic Back-End Optimization Instruction Selection Instruction scheduling Register allocation 2008/4/8 \course\cpeg421-08s\topic-6.ppt 1 ABET Outcome Ability to apply knowledge of basic code generation
Group B Assignment 9. Code generation using DAG. Title of Assignment: Problem Definition: Code generation using DAG / labeled tree.
Group B Assignment 9 Att (2) Perm(3) Oral(5) Total(10) Sign Title of Assignment: Code generation using DAG. 9.1.1 Problem Definition: Code generation using DAG / labeled tree. 9.1.2 Perquisite: Lex, Yacc,
Crafting a Compiler with C (II) Compiler V. S. Interpreter
Crafting a Compiler with C (II) 資科系 林偉川 Compiler V S Interpreter Compilation - Translate high-level program to machine code Lexical Analyzer, Syntax Analyzer, Intermediate code generator(semantics Analyzer),
About the Authors... iii Introduction... xvii. Chapter 1: System Software... 1
Table of Contents About the Authors... iii Introduction... xvii Chapter 1: System Software... 1 1.1 Concept of System Software... 2 Types of Software Programs... 2 Software Programs and the Computing Machine...
A Simple Tree Pattern Matching Algorithm for Code Generator
A Simple Tree Pattern Matching Algorithm for Code Generator Tzer-Shyong Chen, Feipei Lai, and Rung-Ji Shang Dept. of Electrical Engineering National Taiwan University, Taipei, Taiwan, R.O.C. E-mail: flai@cc.ee.ntu.edu.tw
CSE 5317 Midterm Examination 4 March Solutions
CSE 5317 Midterm Examination 4 March 2010 1. / [20 pts] Solutions (parts a j; -1 point for each wrong answer, 0 points for each blank answer, 2 point for each correct answer. Therefore, the score for this
What do Compilers Produce?
What do Compilers Produce? Pure Machine Code Compilers may generate code for a particular machine, not assuming any operating system or library routines. This is pure code because it includes nothing beyond
CS 406/534 Compiler Construction Putting It All Together
CS 406/534 Compiler Construction Putting It All Together Prof. Li Xu Dept. of Computer Science UMass Lowell Fall 2004 Part of the course lecture notes are based on Prof. Keith Cooper, Prof. Ken Kennedy
Instruction Selection and Scheduling
Instruction Selection and Scheduling The Problem Writing a compiler is a lot of work Would like to reuse components whenever possible Would like to automate construction of components Front End Middle
Formats of Translated Programs
Formats of Translated Programs Compilers differ in the format of the target code they generate. Target formats may be categorized as assembly language, relocatable binary, or memory-image. Assembly Language
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
CMPT 379 Compilers. Parse trees
CMPT 379 Compilers Anoop Sarkar http://www.cs.sfu.ca/~anoop 10/25/07 1 Parse trees Given an input program, we convert the text into a parse tree Moving to the backend of the compiler: we will produce intermediate
Lecture 12: Compiler Backend
CS 515 Programming Language and Compilers I Lecture 1: Compiler Backend (The lectures are based on the slides copyrighted by Keith Cooper and Linda Torczon from Rice University.) Zheng (Eddy) Zhang Rutgers
The Structure of a Syntax-Directed Compiler
Source Program (Character Stream) Scanner Tokens Parser Abstract Syntax Tree Type Checker (AST) Decorated AST Translator Intermediate Representation Symbol Tables Optimizer (IR) IR Code Generator Target
Alternatives for semantic processing
Semantic Processing Copyright c 2000 by Antony L. Hosking. Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies
CST-402(T): Language Processors
CST-402(T): Language Processors Course Outcomes: On successful completion of the course, students will be able to: 1. Exhibit role of various phases of compilation, with understanding of types of grammars
Instruction Selection: Preliminaries. Comp 412
COMP 412 FALL 2017 Instruction Selection: Preliminaries Comp 412 source code Front End Optimizer Back End target code Copyright 2017, Keith D. Cooper & Linda Torczon, all rights reserved. Students enrolled
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
CSc 453. Code Generation I Christian Collberg. Compiler Phases. Code Generation Issues. Slide Compilers and Systems Software.
Slide 16 2 Lexing, Parsing Semantic Analysis, Intermediate Code Generation Peephole Optimization Assembly Code Assembler Machine Code Register Allocation Intermediate Code Selection Scheduling Register
Introduction to Compiler Construction
Introduction to Compiler Construction Robert van Engelen http://www.cs.fsu.edu/~engelen/courses/cop5621 COP5621 Compiler Construction Copyright Robert van Engelen, Florida State University, 2005 Syllabus
Intermediate Representations
COMP 506 Rice University Spring 2018 Intermediate Representations source code IR Front End Optimizer Back End IR target code Copyright 2018, Keith D. Cooper & Linda Torczon, all rights reserved. Students
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
Introduction. CSc 453. Compilers and Systems Software. 19 : Code Generation I. Department of Computer Science University of Arizona.
CSc 453 Compilers and Systems Software 19 : Code Generation I Introduction Department of Computer Science University of Arizona collberg@gmail.com Copyright c 2009 Christian Collberg Compiler Phases Optimize
The Structure of a Compiler
The Structure of a Compiler A compiler performs two major tasks: Analysis of the source program being compiled Synthesis of a target program Almost all modern compilers are syntax-directed: The compilation
Experiences in Building a Compiler for an Object-Oriented Language
Experiences in Building a Compiler for an Object-Oriented Language José de Oliveira Guimarães Departamento de Computação UFSCar, São Carlos - SP, Brazil jose@dc.ufscar.br Abstract Traditionally books on
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
Compilers and Code Optimization EDOARDO FUSELLA
Compilers and Code Optimization EDOARDO FUSELLA The course covers Compiler architecture Pre-requisite Front-end Strong programming background in C, C++ Back-end LLVM Code optimization A case study: nu+
Compiler Optimization Techniques
Compiler Optimization Techniques Department of Computer Science, Faculty of ICT February 5, 2014 Introduction Code optimisations usually involve the replacement (transformation) of code from one sequence
CSE 582 Autumn 2002 Exam 11/26/02
Name There are 8 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 reference materials:
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?
Code Generation: Integrated Instruction Selection and Register Allocation Algorithms
Code Generation: Integrated Instruction Selection and Register Allocation Algorithms (www.cse.iitb.ac.in/ as) Department of Computer Science and Engineering, Indian Institute of Technology, Bombay February
What is a compiler? var a var b mov 3 a mov 4 r1 cmpi a r1 jge l_e mov 2 b jmp l_d l_e: mov 3 b l_d: ;done
What is a compiler? What is a compiler? Traditionally: Program that analyzes and translates from a high level language (e.g., C++) to low-level assembly language that can be executed by hardware int a,
CA Compiler Construction
CA4003 - Compiler Construction David Sinclair Overview This module will cover the compilation process, reading and parsing a structured language, storing it in an appropriate data structure, analysing
Front End. Hwansoo Han
Front nd Hwansoo Han Traditional Two-pass Compiler Source code Front nd IR Back nd Machine code rrors High level functions Recognize legal program, generate correct code (OS & linker can accept) Manage
Introduction to Parsing. Lecture 5
Introduction to Parsing Lecture 5 1 Outline Regular languages revisited Parser overview Context-free grammars (CFG s) Derivations Ambiguity 2 Languages and Automata Formal languages are very important
Introduction to Compiler Construction
Introduction to Compiler Construction Robert van Engelen http://www.cs.fsu.edu/~engelen/courses/cop5621 COP5621 Compiler Construction Copyright Robert van Engelen, Florida State University, 2007-2011 Syllabus
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
Working of the Compilers
Working of the Compilers Manisha Yadav Nisha Thakran IT DEPARTMENT IT DEPARTMENT DCE,GURGAON DCE,GURGAON Abstract- The objective of the paper is to depict the working of the compilers that were designed
Low-level optimization
Low-level optimization Advanced Course on Compilers Spring 2015 (III-V): Lecture 6 Vesa Hirvisalo ESG/CSE/Aalto Today Introduction to code generation finding the best translation Instruction selection
Control & Execution. Finite State Machines for Control. MIPS Execution. Comp 411. L14 Control & Execution 1
Control & Execution Finite State Machines for Control MIPS Execution L14 Control & Execution 1 Synchronous Systems data Latch Combinational logic Latch Clock leading edge trailing edge On the leading edge
A Set of Tools to Teach Compiler Construction
A Set of Tools to Teach Compiler Construction Akim Demaille Roland Levillain Benoît Perrot EPITA Research and Development Laboratory (LRDE) Paris, France 13th Annual Conference on Innovation and Technology
Goals of Program Optimization (1 of 2)
Goals of Program Optimization (1 of 2) Goal: Improve program performance within some constraints Ask Three Key Questions for Every Optimization 1. Is it legal? 2. Is it profitable? 3. Is it compile-time
Introduction to Syntax Analysis. Compiler Design Syntax Analysis s.l. dr. ing. Ciprian-Bogdan Chirila
Introduction to Syntax Analysis Compiler Design Syntax Analysis s.l. dr. ing. Ciprian-Bogdan Chirila chirila@cs.upt.ro http://www.cs.upt.ro/~chirila Outline Syntax Analysis Syntax Rules The Role of the
Lecture Notes on Intermediate Representation
Lecture Notes on Intermediate Representation 15-411: Compiler Design Frank Pfenning Lecture 10 September 26, 2013 1 Introduction In this lecture we discuss the middle end of the compiler. After the source
COMPILER CONSTRUCTION Seminar 02 TDDB44
COMPILER CONSTRUCTION Seminar 02 TDDB44 Martin Sjölund (martin.sjolund@liu.se) Adrian Horga (adrian.horga@liu.se) Department of Computer and Information Science Linköping University LABS Lab 3 LR parsing
Better Extensibility through Modular Syntax. Robert Grimm New York University
Better Extensibility through Modular Syntax Robert Grimm New York University Syntax Matters More complex syntactic specifications Extensions to existing programming languages Transactions, event-based
Introduction to Parsing. Lecture 5
Introduction to Parsing Lecture 5 1 Outline Regular languages revisited Parser overview Context-free grammars (CFG s) Derivations Ambiguity 2 Languages and Automata Formal languages are very important
List of Figures. About the Authors. Acknowledgments
List of Figures Preface About the Authors Acknowledgments xiii xvii xxiii xxv 1 Compilation 1 1.1 Compilers..................................... 1 1.1.1 Programming Languages......................... 1
LECTURE NOTES ON COMPILER DESIGN P a g e 2
LECTURE NOTES ON COMPILER DESIGN P a g e 1 (PCCS4305) COMPILER DESIGN KISHORE KUMAR SAHU SR. LECTURER, DEPARTMENT OF INFORMATION TECHNOLOGY ROLAND INSTITUTE OF TECHNOLOGY, BERHAMPUR LECTURE NOTES ON COMPILER
1 Lexical Considerations
Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Spring 2013 Handout Decaf Language Thursday, Feb 7 The project for the course is to write a compiler
Faculty of Electrical Engineering, Mathematics, and Computer Science Delft University of Technology
Faculty of Electrical Engineering, Mathematics, and Computer Science Delft University of Technology exam Compiler Construction in4020 July 5, 2007 14.00-15.30 This exam (8 pages) consists of 60 True/False
Peephole Optimization Technique for analysis and review of Compiler Design and Construction
IOSR Journal of Computer Engineering (IOSR-JCE) e-issn: 2278-0661, p- ISSN: 2278-8727Volume 9, Issue 4 (Mar. - Apr. 2013), PP 80-86 Peephole Optimization Technique for analysis and review of Compiler Design
9/5/17. The Design and Implementation of Programming Languages. Compilation. Interpretation. Compilation vs. Interpretation. Hybrid Implementation
Language Implementation Methods The Design and Implementation of Programming Languages Compilation Interpretation Hybrid In Text: Chapter 1 2 Compilation Interpretation Translate high-level programs to
Review. Pat Morin COMP 3002
Review Pat Morin COMP 3002 What is a Compiler A compiler translates from a source language S to a target language T while preserving the meaning of the input 2 Structure of a Compiler program text syntactic
7 Translation to Intermediate Code
7 Translation to Intermediate Code ( 7. Translation to Intermediate Code, p. 150) This chpater marks the transition from the source program analysis phase to the target program synthesis phase. All static
Introduction to Compiler
Formal Languages and Compiler (CSE322) Introduction to Compiler Jungsik Choi chjs@khu.ac.kr 2018. 3. 8 Traditional Two-pass Compiler Source Front End Back End Compiler Target High level functions Recognize
CSE 401 Midterm Exam Sample Solution 2/11/15
Question 1. (10 points) Regular expression warmup. For regular expression questions, you must restrict yourself to the basic regular expression operations covered in class and on homework assignments:
Discovering Machine-Specific Code Improvements. Technical Report. S. L. Graham (415)
Discovering Machine-Specific Code Improvements Technical Report CM to S. L. Graham (415) 642-2059 < I Q < "The views and conclusions contained in this document are those of the authors and should not be
Important Project Dates
Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Fall 2002 Handout 4 Project Overview Wednesday, September 4 This is an overview of the course project
I ve been getting this a lot lately So, what are you teaching this term? Computer Organization. Do you mean, like keeping your computer in place?
I ve been getting this a lot lately So, what are you teaching this term? Computer Organization. Do you mean, like keeping your computer in place? here s the monitor, here goes the CPU, Do you need a class
Fall Compiler Principles Lecture 6: Intermediate Representation. Roman Manevich Ben-Gurion University of the Negev
Fall 2015-2016 Compiler Principles Lecture 6: Intermediate Representation Roman Manevich Ben-Gurion University of the Negev Tentative syllabus Front End Intermediate Representation Optimizations Code Generation
CS131: Programming Languages and Compilers. Spring 2017
CS131: Programming Languages and Compilers Spring 2017 Course Information Instructor: Fu Song Office: Room 1A-504C, SIST Building Email: songfu@shanghaitech.edu.cn Class Hours : Tuesday and Thursday, 8:15--9:55
Code generation and local optimization
Code generation and local optimization Generating assembly How do we convert from three-address code to assembly? Seems easy! But easy solutions may not be the best option What we will cover: Instruction
Compilers Crash Course
Compilers Crash Course Prof. Michael Clarkson CSci 6907.85 Spring 2014 Slides Acknowledgment: Prof. Andrew Myers (Cornell) What are Compilers? Translators from one representation of program code to another
Code Generation. The Main Idea of Today s Lecture. We can emit stack-machine-style code for expressions via recursion. Lecture Outline.
The Main Idea of Today s Lecture Code Generation 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?
CSE 413 Languages & Implementation. Hal Perkins Winter 2019 Structs, Implementing Languages (credits: Dan Grossman, CSE 341)
CSE 413 Languages & Implementation Hal Perkins Winter 2019 Structs, Implementing Languages (credits: Dan Grossman, CSE 341) 1 Goals Representing programs as data Racket structs as a better way to represent
Code generation and local optimization
Code generation and local optimization Generating assembly How do we convert from three-address code to assembly? Seems easy! But easy solutions may not be the best option What we will cover: Instruction
STEVEN R. BAGLEY THE ASSEMBLER
STEVEN R. BAGLEY THE ASSEMBLER INTRODUCTION Looking at how to build a computer from scratch Started with the NAND gate and worked up Until we can build a CPU Reached the divide between hardware and software
Formal Languages and Grammars. Chapter 2: Sections 2.1 and 2.2
Formal Languages and Grammars Chapter 2: Sections 2.1 and 2.2 Formal Languages Basis for the design and implementation of programming languages Alphabet: finite set Σ of symbols String: finite sequence
Syntax Analysis Part I
Syntax Analysis Part I Chapter 4: Context-Free Grammars Slides adapted from : Robert van Engelen, Florida State University Position of a Parser in the Compiler Model Source Program Lexical Analyzer Token,
Fall Compiler Principles Lecture 5: Intermediate Representation. Roman Manevich Ben-Gurion University of the Negev
Fall 2016-2017 Compiler Principles Lecture 5: Intermediate Representation Roman Manevich Ben-Gurion University of the Negev Tentative syllabus Front End Intermediate Representation Optimizations Code Generation
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
5 The Control Structure Diagram (CSD)
5 The Control Structure Diagram (CSD) The Control Structure Diagram (CSD) is an algorithmic level diagram intended to improve the comprehensibility of source code by clearly depicting control constructs,
Computer Software: Introduction
Software: A collection of programs Computer Software: Introduction Program: Sequence of instructions for the computer to carry out Programs written using a programming language Types of languages: Machine
Compilers. Intermediate representations and code generation. Yannis Smaragdakis, U. Athens (original slides by Sam
Compilers Intermediate representations and code generation Yannis Smaragdakis, U. Athens (original slides by Sam Guyer@Tufts) Today Intermediate representations and code generation Scanner Parser Semantic
Design of Embedded DSP Processors Unit 7: Programming toolchain. 9/26/2017 Unit 7 of TSEA H1 1
Design of Embedded DSP Processors Unit 7: Programming toolchain 9/26/2017 Unit 7 of TSEA26 2017 H1 1 Toolchain introduction There are two kinds of tools 1.The ASIP design tool for HW designers Frontend
Code generation and optimization
Code generation and timization Generating assembly How do we convert from three-address code to assembly? Seems easy! But easy solutions may not be the best tion What we will cover: Peephole timizations
10/18/18. Outline. Semantic Analysis. Two types of semantic rules. Syntax vs. Semantics. Static Semantics. Static Semantics.
Outline Semantic Analysis In Text: Chapter 3 Static semantics Attribute grammars Dynamic semantics Operational semantics Denotational semantics N. Meng, S. Arthur 2 Syntax vs. Semantics Syntax concerns