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

GCC Resource Center,

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

January 2011

(2)

CS 715 Gnu Compiler Collection: Outline 1/55

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/55

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/55

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/55

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 Model

Instruction selection

•

over optimized IR using

•

intelligent tree tiling based algorithms Key idea in retargetability:

•

Machine independent IR is expressed in the form of trees

•

Machine instructions are described in the form of trees

•

Trees in the IR are tiled using the instruction trees

(60)

Retargetability in Davidson Fraser Model

Recognizer Target Program

Instruction selection

•

over AST using

•

simple full tree matching based algorithms that generate

•

naive code which is

◮ machine dependent, and is

◮ optimized subsequently

Key idea in retargetability:

•

Register transfers are machine specific but

•

their form is machine independent

(61)

Full Tree Matching (Davidson Fraser Model)

Instructions are viewed as independent non-composable rules

Machine Instructions Subject Tree (IR) Modified Trees

=

reg +

reg reg

=

reg

∗

reg reg

(62)

Full Tree Matching (Davidson Fraser Model)

Instructions are viewed as independent non-composable rules

Machine Instructions Subject Tree (IR) Modified Trees

=

reg +

reg reg

=

reg

∗

reg reg

=

a

+

a ∗

b c

(63)

Full Tree Matching (Davidson Fraser Model)

Instructions are viewed as independent non-composable rules

Machine Instructions Subject Tree (IR) Modified Trees

=

reg +

reg reg

=

reg

∗

reg reg

=

a

+

a ∗

b c

(64)

Full Tree Matching (Davidson Fraser Model)

Instructions are viewed as independent non-composable rules

Machine Instructions Subject Tree (IR) Modified Trees

=

reg +

reg reg

=

reg

∗

reg reg

=

a

+

a ∗

b c

=

t ∗

b c

=

a

+

a t

(65)

Full Tree Matching (Davidson Fraser Model)

Instructions are viewed as independent non-composable rules

Machine Instructions Subject Tree (IR) Modified Trees

=

reg +

reg reg

=

reg

∗

reg reg

=

a

+

a ∗

b c

=

t ∗

b c

=

a

+

a t

(66)

Full Tree Matching (Davidson Fraser Model)

Instructions are viewed as independent non-composable rules

Machine Instructions Subject Tree (IR) Modified Trees

=

reg +

reg reg

=

reg

∗

reg reg

=

a

+

a ∗

b c

=

t ∗

b c

=

a

+

a t

(67)

Tree Tiling (Aho Ullman Model) Instructions are viewed as composable rules

Machine Instructions Subject Tree (IR)

=

reg Reg

reg +

Reg Reg

∗

Reg Reg

(68)

Tree Tiling (Aho Ullman Model) Instructions are viewed as composable rules

Machine Instructions Subject Tree (IR)

=

reg Reg

Reg reg

+

Reg Reg

Reg

∗

Reg Reg

Reg

(69)

Tree Tiling (Aho Ullman Model) Instructions are viewed as composable rules

Machine Instructions Subject Tree (IR)

=

reg Reg

Reg reg

+

Reg Reg

Reg

∗

Reg Reg

Reg

=

a

+

a ∗

b c

(70)

Tree Tiling (Aho Ullman Model) Instructions are viewed as composable rules

Machine Instructions Subject Tree (IR)

=

reg Reg

Reg reg

+

Reg Reg

Reg

∗

Reg Reg

Reg

=

a

+

a ∗

b c

(71)

Tree Tiling (Aho Ullman Model) Instructions are viewed as composable rules

Machine Instructions Subject Tree (IR)

=

reg Reg

Reg reg

+

Reg Reg

Reg

∗

Reg Reg

Reg

=

a

+

Reg

∗

Reg Reg

(72)

Tree Tiling (Aho Ullman Model) Instructions are viewed as composable rules

Machine Instructions Subject Tree (IR)

=

reg Reg

Reg reg

+

Reg Reg

Reg

∗

Reg Reg

Reg

=

a

+

Reg

∗

Reg Reg

(73)

Tree Tiling (Aho Ullman Model) Instructions are viewed as composable rules

Machine Instructions Subject Tree (IR)

=

reg Reg

Reg reg

+

Reg Reg

Reg

∗

Reg Reg

Reg

=

a

+

Reg Reg

(74)

Tree Tiling (Aho Ullman Model) Instructions are viewed as composable rules

Machine Instructions Subject Tree (IR)

=

reg Reg

Reg reg

+

Reg Reg

Reg

∗

Reg Reg

Reg

=

a

+

Reg Reg

(75)

Tree Tiling (Aho Ullman Model) Instructions are viewed as composable rules

Machine Instructions Subject Tree (IR)

=

reg Reg

Reg reg

+

Reg Reg

Reg

∗

Reg Reg

Reg

=

a

Reg

(76)

Tree Tiling (Aho Ullman Model) Instructions are viewed as composable rules

Machine Instructions Subject Tree (IR)

=

reg Reg

Reg reg

+

Reg Reg

Reg

∗

Reg Reg

Reg

=

a

Reg

(77)

Part 4

GCC ≡ The Great Compiler Challenge

(78)

CS 715 Gnu Compiler Collection: GCC≡The Great Compiler Challenge 22/55

The Gnu Tool Chain

gcc Source Program

Target Program

(79)

The Gnu Tool Chain

gcc Source Program

Target Program

cc1

cpp

(80)

The Gnu Tool Chain

gcc Source Program

Target Program

cc1 cpp

(81)

The Gnu Tool Chain

gcc Source Program

Target Program

cc1 cpp

as

(82)

The Gnu Tool Chain

gcc Source Program

Target Program

cc1 cpp

as

ld

(83)

The Gnu Tool Chain

gcc Source Program

Target Program

cc1 cpp

as

ld

glibc/newlib

(84)

The Gnu Tool Chain

gcc Source Program

Target Program

cc1 cpp

as

ld

glibc/newlib

GCC

(85)

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

(86)

Why is Understanding GCC Difficult?

•

Deeper technical reasons:

◮ GCC is not a compiler but acompiler generation framework Two distinct gaps that need to be bridged:

◮ Input-output of the generation framework

◮ Input-output of the generated compiler

◮ GCC generated compiler uses a derivative of the Davidson-Fraser model of compilation

◮ Early instruction selection

◮ Machine dependent intermediate representation

◮ Simplistic instruction selection and retargatibility mechanism

(87)

Comprehensiveness of GCC: Wide Applicability

•

Input languages supported:

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

•

Processors supported in standard releases:

(88)

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:

(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,

(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,

(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,

(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,

(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,

(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,

(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),

(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,

(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,

(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,

(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,

(100)

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,

(101)

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,

(102)

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,

(103)

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,

(104)

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,

(105)

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,

(106)

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,

(107)

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,

(108)

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

(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,

(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,

(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,

(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,

(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,

(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,

(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,

(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,

(117)

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,