CS 715: The Design and Implementation of Gnu Compiler Generation Framework

(1)

CS 715: The Design and Implementation of Gnu Compiler Generation Framework

Uday Khedker

(www.cse.iitb.ac.in/˜uday)

GCC Resource Center,

Department of Computer Science and Engineering, Indian Institute of Technology, Bombay

January 2012

(2)

CS 715 Gnu Compiler Collection: Outline 1/50

Outline

•

An Overview of Compilation

Introduction, compilation sequence, compilation models

•

GCC: The Great Compiler Challenge Difficulties in understanding GCC

•

Meeting the GCC Challenge: CS 715

The course plan

(3)

Part 1

Introduction to Compilation

(4)

CS 715 Gnu Compiler Collection: Introduction to Compilation 2/50

Binding

Time No.of

unbound objects

Nothing is known except the problem

(5)

Binding

Time No.of

unbound objects

Conceptualisation

Overall strategy, algorithm, data structures etc.

Uday Khedker GRC, IIT Bombay

(6)

Binding

Time No.of

unbound objects

Conceptualisation Coding

Functions, variables, their types etc.

(7)

Binding

Time No.of

unbound objects

Conceptualisation Coding Compiling

Machine instructions, registers etc.

(8)

Binding

Time No.of

unbound objects

Conceptualisation Coding Compiling Linking

Addresses of functions, external data etc.

(9)

Binding

Time No.of

unbound objects

Conceptualisation Coding Compiling Linking Loading

Actual addresses of code and data

(10)

Binding

Time No.of

unbound objects

Conceptualisation Coding Compiling Linking Loading Execution Values of variables

(11)

Implementation Mechanisms

Source Program

Translator Target Program

Machine

(12)

Implementation Mechanisms

Source Program

Translator Target Program

Machine

Input Data

(13)

Implementation Mechanisms

Source Program

Translator Target Program

Machine

Input Data

Source Program

Interpreter Machine

(14)

Implementation Mechanisms as “Bridges”

•

“Gap” between the “levels” of program specification and execution

Program Specification

Machine

(15)

Implementation Mechanisms as “Bridges”

•

“Gap” between the “levels” of program specification and execution

Program Specification

Machine Translation

(16)

Implementation Mechanisms as “Bridges”

•

“Gap” between the “levels” of program specification and execution

Program Specification

Machine

Translation Interpretation

(17)

Implementation Mechanisms as “Bridges”

•

“Gap” between the “levels” of program specification and execution

Program Specification

Machine

Translation Interpretation

State : Variables Operations: Expressions,

Control Flow

State : Memory, Registers Operations: Machine

Instructions

(18)

High and Low Level Abstractions

Input C statement a = b<10?b:c;

Spim Assembly Equivalent

lw $t0, 4($fp) ; t0 <- b # Is b smaller slti $t0, $t0, 10 ; t0 <- t0 < 10 # than 10?

not $t0, $t0 ; t0 <- !t0

bgtz $t0, L0: ; if t0>=0 goto L0 lw $t0, 4($fp) ; t0 <- b # YES

b L1: ; goto L1

L0: lw $t0, 8($fp) ;L0: t0 <- c # NO L1: sw 0($fp), $t0 ;L1: a <- t0

(19)

High and Low Level Abstractions

not $t0, $t0 ; t0 <- !t0

b L1: ; goto L1

Condition False Part True Part

Fall through Conditional jump

(20)

High and Low Level Abstractions

not $t0, $t0 ; t0 <- !t0

b L1: ; goto L1

NOT Condition True Part False Part

(21)

High and Low Level Abstractions

not $t0, $t0 ; t0 <- !t0

b L1: ; goto L1

NOT Condition True Part False Part

Fall through Conditional jump

(22)

Implementation Mechanisms

•

Translation = Analysis + Synthesis

Interpretation = Analysis + Execution

(23)

Implementation Mechanisms

•

Translation = Analysis + Synthesis Interpretation = Analysis + Execution

•

Translation Instructions Equivalent Instructions

(24)

Implementation Mechanisms

•

Translation = Analysis + Synthesis Interpretation = Analysis + Execution

•

Translation Instructions Equivalent Instructions

Interpretation Instructions Actions Implied

by Instructions

(25)

Language Implementation Models

Analysis

Synthesis

Execution

Compilation

Interpretation

(26)

Language Processor Models

C,C

++

Java, C#

Front

End Optimizer

Back End

Virtual

Machine

(27)

Typical Front Ends

Parser

(28)

Typical Front Ends

Parser Source

Program

Scanner

Tokens

(29)

Typical Front Ends

Parser Source

Program

Scanner

Tokens

Semantic Analyzer AST

Parse Tree

AST or Linear IR Symbol Table+

(30)

Typical Front Ends

Parser Source

Program

Scanner

Tokens

Semantic Analyzer AST

Parse Tree

AST or Linear IR Symbol Table+

Error Handler Symtab

Handler

(31)

Typical Back Ends

m/c Ind.

IR

m/c Ind.

Optimizer

−

Compile time evaluations

−

Eliminating redundant computations

m/c Ind.

IR

(32)

Typical Back Ends

m/c Ind.

IR

m/c Ind.

Optimizer

−

Compile time evaluations

−

Eliminating redundant computations

m/c Ind.

IR

Code Generator

Dep. m/c IR

−

Instruction Selection

−

Local Reg Allocation

−

Choice of Order of

Evaluation

(33)

Typical Back Ends

m/c Ind.

IR

m/c Ind.

Optimizer

−

Compile time evaluations

−

Eliminating redundant computations

m/c Ind.

IR

Code Generator

Dep. m/c IR

−

Instruction Selection

−

Local Reg Allocation

−

Choice of Order of Evaluation

m/c Dep.

Optimizer

Assembly Code

(34)

Typical Back Ends

m/c Ind.

IR

m/c Ind.

Optimizer

−

Compile time evaluations

−

Eliminating redundant computations

m/c Ind.

IR

Code Generator

Dep. m/c IR

−

Instruction Selection

−

Local Reg Allocation

−

Choice of Order of Evaluation

Assembly Code Register

Allocator

Instruction Scheduler Peephole

Optimizer

(35)

Part 2

An Overview of Compilation Phases

(36)

CS 715 Gnu Compiler Collection: An Overview of Compilation Phases 11/50

The Structure of a Simple Compiler

Parser

Scanner Semantic Analyser

Symtab Handler Source Program

(37)

The Structure of a Simple Compiler

Parser

Instruction Selector AST

Register Allocator

Assembly Emitter Insn

Assembly Program

(38)

The Structure of a Simple Compiler

Parser

Instruction Selector AST

Register Allocator

Assembly Emitter Insn

Assembly Program

Front End Back End

(39)

Translation Sequence in Our Compiler: Parsing

a=b<10?b:c;

Input

(40)

Translation Sequence in Our Compiler: Parsing

a=b<10?b:c;

Input

AsgnStmnt

Lhs = ^E ;

E ? ^E : ^E

E < E name

name name

name num

Parse Tree Issues:

• Grammar rules, terminals, non-terminals

• Order of application of grammar rules eg. is it(a = b<10?) followed by(b:c)?

• Values of terminal symbols

eg. string “10” vs. integer number 10.

(41)

Translation Sequence in Our Compiler: Semantic Analysis

a=b<10?b:c;

Input

AsgnStmnt

Lhs = ^E ;

E ? ^E : ^E

E < E name

name name

name num

Parse Tree

(42)

Translation Sequence in Our Compiler: Semantic Analysis

a=b<10?b:c;

Input

AsgnStmnt

Lhs = ^E ;

E ? ^E : ^E

E < E name

name name

name num

Parse Tree

= name

(a,int) ?: (int)

<

(bool) name (b,int)

name (c,int) name

(b,int) num (10,int) Abstract Syntax Tree

(with attributes) Issues:

• Symbol tables

Have variables been declared? What are their types?

What is their scope?

• Type consistency of operators and operands The result of computing b<10?is bool and not int

(43)

Translation Sequence in Our Compiler: IR Generation

a=b<10?b:c;

Input

AsgnStmnt

Lhs = ^E ;

E ? ^E : ^E

E < E name

name name

name num

Parse Tree

= name

(a,int) ?: (int)

<

(bool) name (b,int)

name (c,int) name

(with attributes)

(44)

Translation Sequence in Our Compiler: IR Generation

a=b<10?b:c;

Input

AsgnStmnt

Lhs = ^E ;

E ? ^E : ^E

E < E name

name name

name num

Parse Tree

= name

(a,int) ?: (int)

<

(bool) name (b,int)

name (c,int) name

(with attributes)

= T₀ <

b 10

IfGoto

Not L0:

T₀

= T₁ b

Goto L1:

= T₁ c L0:

= T₁ a

L1:

Tree List

Issues:

• Convert to maximal trees which can be implemented without altering control flow Simplifies instruction selection and scheduling, register allocation etc.

• Linearise control flow by flattening nested control constructs

(45)

Translation Sequence in Our Compiler: Instruction Selection

a=b<10?b:c;

Input

AsgnStmnt

Lhs = ^E ;

E ? ^E : ^E

E < E name

name name

name num

Parse Tree

= name

(a,int) ?: (int)

<

(bool) name (b,int)

name (c,int) name

(with attributes)

= T₀ <

b 10

IfGoto

Not L0:

T₀

= T₁ b

Goto L1:

= T₁ c L0:

= T₁ a

L1:

Tree List

(46)

Translation Sequence in Our Compiler: Instruction Selection

a=b<10?b:c;

Input

AsgnStmnt

Lhs = ^E ;

E ? ^E : ^E

E < E name

name name

name num

Parse Tree

= name

(a,int) ?: (int)

<

(bool) name (b,int)

name (c,int) name

(with attributes)

= T₀ <

b 10

IfGoto

Not L0:

T₀

= T₁ b

Goto L1:

= T₁ c L0:

= T₁ a

L1:

Tree List

T₀ ←b T₀ ← T₀ <10 T₀ ←!T₀ ifT0 > 0 goto L0:

T1 ←b goto L1:

L0:T₁ ←c L1: a← T₁

Instruction List Issues:

• Cover trees with as few machine instructions as possible

• Use temporaries and local registers

(47)

Translation Sequence in Our Compiler: Emitting Instructions

a=b<10?b:c;

Input

AsgnStmnt

Lhs = ^E ;

E ? ^E : ^E

E < E name

name name

name num

Parse Tree

= name

(a,int) ?: (int)

<

(bool) name (b,int)

name (c,int) name

(with attributes)

= T₀ <

b 10

IfGoto

Not L0:

T₀

= T₁ b

Goto L1:

= T₁ c L0:

= T₁ a

L1:

Tree List

T₀ ←b T₀ ← T₀ <10 T₀ ←!T₀ ifT0 > 0 goto L0:

T1 ←b goto L1:

L0:T₁ ←c L1: a← T₁

Instruction List

(48)

Translation Sequence in Our Compiler: Emitting Instructions

a=b<10?b:c;

Input

AsgnStmnt

Lhs = ^E ;

E ? ^E : ^E

E < E name

name name

name num

Parse Tree

= name

(a,int) ?: (int)

<

(bool) name (b,int)

name (c,int) name

(with attributes)

= T₀ <

b 10

IfGoto

Not L0:

T₀

= T₁ b

Goto L1:

= T₁ c L0:

= T₁ a

L1:

Tree List

T₀ ←b T₀ ← T₀ <10 T₀ ←!T₀ ifT0 > 0 goto L0:

T1 ←b goto L1:

L0:T₁ ←c L1: a← T₁

Instruction List

lw $t0, 4($fp) slti $t0, $t0, 10 not $t0, $t0 bgtz $t0, L0:

lw $t0, 4($fp) b L1:

L0: lw $t0, 8($fp) L1: sw 0($fp), $t0 Assembly Code Issues:

• Offsets of variables in the stack frame

• Actual register numbers and assembly mnemonics

• Code to construct and discard activation records

(49)

Part 3

Compilation Models, Instruction Selection, and

Retargetability

(50)

CS 715Gnu Compiler Collection: Compilation Models, Instruction Selection, and Retargetability 17/50

Compilation Models

Aho Ullman Model

Davidson Fraser Model

(51)

Compilation Models

Aho Ullman Model

Davidson Fraser Model Input Source Program

Front End AST

(52)

Compilation Models

Aho Ullman Model

Front End AST Optimizer m/c indep. IR

(53)

Compilation Models

Aho Ullman Model

Code Generator Target Program

(54)

Compilation Models

Aho Ullman Model

Front End AST

(55)

Compilation Models

Aho Ullman Model

Front End AST Expander register transfers

(56)

Compilation Models

Aho Ullman Model

Optimizer register transfers

(57)

Compilation Models

Aho Ullman Model

Recognizer Target Program

(58)

Compilation Models

Aho Ullman Model

Davidson Fraser Model

Recognizer Target Program Aho Ullman: Instruction selection

• over optimized IR using

• intelligent tree tiling based algorithms

Davidson Fraser: Instruction selection

• over AST using

• simple full tree matching based algorithms that generate

• naive code which is

◮ machine dependent, and is

◮ optimized subsequently

(59)

Retargetability in Aho Ullman and Davidson Fraser Models

Aho Ullman Model Davisdon Fraser Model Instruction

Selection

• 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

(60)

Retargetability in Aho Ullman and Davidson Fraser Models

Selection

• Trees in the IR are “covered” using the instruction trees Cost based tree pattern

matching

Optimization

(61)

Retargetability in Aho Ullman and Davidson Fraser Models

Selection

matching Structual tree pattern matching

Optimization

(62)

Retargetability in Aho Ullman and Davidson Fraser Models

Selection

Optimization Machine independent

(63)

Retargetability in Aho Ullman and Davidson Fraser Models

Selection

Machine dependent

(64)

Retargetability in Aho Ullman and Davidson Fraser Models

Selection

Machine dependent Key Insight: Register transfers are target specific but their form is target independent

(65)

Part 4

GCC ≡ The Great Compiler Challenge

(66)

CS 715 Gnu Compiler Collection: GCC≡The Great Compiler Challenge 19/50

What is GCC?

•

For the GCC developer community: The GNU Compiler Collection

•

For other compiler writers: The Great Compiler Challenge

(67)

The Gnu Tool Chain for C

gcc Source Program

Target Program

(68)

The Gnu Tool Chain for C

gcc Source Program

Target Program

cc1

cpp

(69)

The Gnu Tool Chain for C

gcc Source Program

Target Program

cc1 cpp

(70)

The Gnu Tool Chain for C

gcc Source Program

Target Program

cc1 cpp

as

(71)

The Gnu Tool Chain for C

gcc Source Program

Target Program

cc1 cpp

as

ld

(72)

The Gnu Tool Chain for C

gcc Source Program

Target Program

cc1 cpp

as

ld

glibc/newlib

(73)

The Gnu Tool Chain for C

gcc Source Program

Target Program

cc1 cpp

as

ld

glibc/newlib GCC

(74)

Why is Understanding GCC Difficult?

Some of the obvious reasons:

•

Comprehensiveness

GCC is a production quality framework in terms of completeness and practical usefulness

•

Open development model

Could lead to heterogeneity. Design flaws may be difficult to correct

•

Rapid versioning

GCC maintenance is a race against time. Disruptive corrections are

difficult

(75)

Open Source and Free Software Development Model

The Cathedral and the Bazaar [Eric S Raymond, 1997]

(76)

Open Source and Free Software Development Model

The Cathedral and the Bazaar [Eric S Raymond, 1997]

•

Cathedral: Total Centralized Control

Design, implement, test, release

(77)

Open Source and Free Software Development Model

The Cathedral and the Bazaar [Eric S Raymond, 1997]

•

Cathedral: Total Centralized Control

•

Bazaar: Total Decentralization

Release early, release often, make users partners in software development

(78)

Open Source and Free Software Development Model

The Cathedral and the Bazaar [Eric S Raymond, 1997]

•

Cathedral: Total Centralized Control

•

Bazaar: Total Decentralization

“Given enough eyeballs, all bugs are shallow”

(79)

Open Source and Free Software Development Model

The Cathedral and the Bazaar [Eric S Raymond, 1997]

•

Cathedral: Total Centralized Control

•

Bazaar: Total Decentralization

“Given enough eyeballs, all bugs are shallow”

Code errors, logical errors, and architectural errors

(80)

Open Source and Free Software Development Model

The Cathedral and the Bazaar [Eric S Raymond, 1997]

•

Cathedral: Total Centralized Control

•

Bazaar: Total Decentralization

“Given enough eyeballs, all bugs are shallow”

Code errors, logical errors, and architectural errors

A combination of the two seems more sensible

(81)

The Current Development Model of GCC

GCC follows a combination of the Cathedral and the Bazaar approaches

•

GCC Steering Committee: Free Software Foundation has given charge

◮ Major policy decisions

◮ Handling Administrative and Political issues

•

Release Managers:

◮ Coordination of releases

•

Maintainers:

◮ Usually area/branch/module specific

◮ Responsible for design and implementation

◮ Take help of reviewers to evaluate submitted changes

(82)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

(83)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

◮ Common processors:

◮ Lesser-known target processors:

◮ Additional processors independently supported:

(84)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha,

(85)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM,

(86)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM, Atmel AVR,

(87)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM, Atmel AVR, Blackfin,

(88)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM, Atmel AVR, Blackfin, HC12,

(89)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM, Atmel AVR, Blackfin, HC12, H8/300,

(90)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM, Atmel AVR, Blackfin, HC12, H8/300, IA-32 (x86),

(91)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM, Atmel AVR, Blackfin, HC12, H8/300, IA-32 (x86), x86-64,

(92)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM, Atmel AVR, Blackfin, HC12, H8/300, IA-32 (x86), x86-64, IA-64,

(93)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM, Atmel AVR, Blackfin, HC12, H8/300, IA-32 (x86), x86-64, IA-64, Motorola 68000,

(94)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM, Atmel AVR, Blackfin, HC12, H8/300, IA-32 (x86), x86-64, IA-64, Motorola 68000, MIPS,

(95)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM, Atmel AVR, Blackfin, HC12, H8/300, IA-32 (x86), x86-64, IA-64, Motorola 68000, MIPS, PA-RISC,

(96)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM, Atmel AVR, Blackfin, HC12, H8/300, IA-32 (x86), x86-64, IA-64, Motorola 68000, MIPS, PA-RISC, PDP-11,

(97)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM, Atmel AVR, Blackfin, HC12, H8/300, IA-32 (x86), x86-64, IA-64, Motorola 68000, MIPS, PA-RISC, PDP-11, PowerPC,

(98)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM, Atmel AVR, Blackfin, HC12, H8/300, IA-32 (x86), x86-64, IA-64, Motorola 68000, MIPS, PA-RISC, PDP-11, PowerPC, R8C/M16C/M32C,

(99)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

Alpha, ARM, Atmel AVR, Blackfin, HC12, H8/300, IA-32 (x86), x86-64, IA-64, Motorola 68000, MIPS, PA-RISC, PDP-11, PowerPC, R8C/M16C/M32C, SPU,

(100)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

System/390/zSeries,

(101)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

System/390/zSeries, SuperH,

(102)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

System/390/zSeries, SuperH, SPARC,

(103)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

System/390/zSeries, SuperH, SPARC, VAX

(104)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

A29K,

(105)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

A29K, ARC,

(106)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

A29K, ARC, ETRAX CRIS,

(107)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

A29K, ARC, ETRAX CRIS, D30V,

(108)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

A29K, ARC, ETRAX CRIS, D30V, DSP16xx,

(109)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

A29K, ARC, ETRAX CRIS, D30V, DSP16xx, FR-30,

(110)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

A29K, ARC, ETRAX CRIS, D30V, DSP16xx, FR-30, FR-V,

(111)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

A29K, ARC, ETRAX CRIS, D30V, DSP16xx, FR-30, FR-V, Intel i960,

(112)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

A29K, ARC, ETRAX CRIS, D30V, DSP16xx, FR-30, FR-V, Intel i960, IP2000,

(113)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

A29K, ARC, ETRAX CRIS, D30V, DSP16xx, FR-30, FR-V, Intel i960, IP2000, M32R,

(114)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

A29K, ARC, ETRAX CRIS, D30V, DSP16xx, FR-30, FR-V, Intel i960, IP2000, M32R, 68HC11,

(115)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

A29K, ARC, ETRAX CRIS, D30V, DSP16xx, FR-30, FR-V, Intel i960, IP2000, M32R, 68HC11, MCORE,

(116)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada

•

Processors supported in standard releases:

A29K, ARC, ETRAX CRIS, D30V, DSP16xx, FR-30, FR-V, Intel i960, IP2000, M32R, 68HC11, MCORE, MMIX,