Blame - www/comparison.html - platform/external/clang

Cedric Venet

3d65864

2009-02-14 20:20:19 +0000

[diff] [blame]

1

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"

2

"http://www.w3.org/TR/html4/strict.dtd">

3

<html>

<head>

<title>Comparing clang to other open source compilers</title>

</head>

<body>

13

14

<h1>Clang vs Other Open Source Compilers</h1>

15

16

<p>Building an entirely new compiler front-end is a big task, and it isn't

17

always clear to people why we decided to do this. Here we compare clang

18

and its goals to other open source compiler front-ends that are

19

available. We restrict the discussion to very specific objective points

20

to avoid controversy where possible. Also, software is infinitely

21

mutable, so we don't talk about little details that can be fixed with

22

a reasonable amount of effort: we'll talk about issues that are

23

difficult to fix for architectural or political reasons.</p>

24

25

<p>The goal of this list is to describe how differences in goals lead to

26

different strengths and weaknesses, not to make some compiler look bad.

27

This will hopefully help you to evaluate whether using clang is a good

28

idea for your personal goals. Because we don't know specifically what

29

<em>you</em> want to do, we describe the features of these compilers in

30

terms of <em>our</em> goals: if you are only interested in static

31

analysis, you may not care that something lacks codegen support, for

32

example.</p>

33

34

<p>Please email cfe-dev if you think we should add another compiler to this

35

list or if you think some characterization is unfair here.</p>

36

37

<ul>

38

<li><a href="#gcc">Clang vs GCC</a> (GNU Compiler Collection)</li>

39

<li><a href="#elsa">Clang vs Elsa</a> (Elkhound-based C++ Parser)</li>

40

<li><a href="#pcc">Clang vs PCC</a> (Portable C Compiler)</li>

</ul>

45

<h2><a name="gcc">Clang vs GCC (GNU Compiler Collection)</a></h2>

46

47

48

<p>Pro's of GCC vs clang:</p>

49

50

<ul>

51

<li>GCC supports languages that clang does not aim to, such as Java, Ada,

52

FORTRAN, etc.</li>

53

<li>GCC front-ends are very mature and already support C/C++/ObjC and all

54

the variants we are interested in. <a href="cxx_status.html">clang's

55

support for C++</a> in particular is nowhere near what GCC supports.</li>

56

<li>GCC supports more targets than LLVM.</li>

57

<li>GCC is popular and widely adopted.</li>

58

<li>GCC does not require a C++ compiler to build it.</li>

59

</ul>

60

61

<p>Pro's of clang vs GCC:</p>

62

63

<ul>

64

<li>The Clang ASTs and design are intended to be <a

65

href="features.html#simplecode">easily understandable</a> by

66

anyone who is familiar with the languages involved and who has a basic

67

understanding of how a compiler works. GCC has a very old codebase

68

which presents a steep learning curve to new developers.</li>

69

<li>Clang is designed as an API from its inception, allowing it to be reused

70

by source analysis tools, refactoring, IDEs (etc) as well as for code

71

generation. GCC is built as a monolithic static compiler, which makes

72

it extremely difficult to use as an API and integrate into other tools.

73

Further, its historic design and <a

74

href="http://gcc.gnu.org/ml/gcc/2007-11/msg00460.html">current</a>

75

<a href="http://gcc.gnu.org/ml/gcc/2004-12/msg00888.html">policy</a>

76

makes it difficult to decouple the front-end from the rest of the

77

compiler. </li>

78

<li>Various GCC design decisions make it very difficult to reuse: its build

79

system is difficult to modify, you can't link multiple targets into one

80

binary, you can't link multiple front-ends into one binary, it uses a

81

custom garbage collector, uses global variables extensively, is not

82

reentrant or multi-threadable, etc. Clang has none of these problems.

83

</li>

84

<li>For every token, clang tracks information about where it was written and

85

where it was ultimately expanded into if it was involved in a macro.

86

GCC does not track information about macro instantiations when parsing

87

source code. This makes it very difficult for source rewriting tools

88

(e.g. for refactoring) to work in the presence of (even simple)

89

macros.</li>

90

<li>Clang does not implicitly simplify code as it parses it like GCC does.

91

Doing so causes many problems for source analysis tools: as one simple

92

example, if you write "x-x" in your source code, the GCC AST will

93

contain "0", with no mention of 'x'. This is extremely bad for a

94

refactoring tool that wants to rename 'x'.</li>

95

<li>Clang can serialize its AST out to disk and read it back into another

96

program, which is useful for whole program analysis. GCC does not have

97

this. GCC's PCH mechanism (which is just a dump of the compiler

98

memory image) is related, but is architecturally only

99

able to read the dump back into the exact same executable as the one

100

that produced it (it is not a structured format).</li>

101

<li>Clang is <a href="features.html#performance">much faster and uses far

102

less memory</a> than GCC.</li>

103

<li>Clang aims to provide extremely clear and concise diagnostics (error and

104

warning messages), and includes support for <a

105

href="features.html#expressivediags">expressive diagnostics</a>. GCC's

106

warnings are acceptable, but are often confusing and it does not support

107

expressive diagnostics. Clang also preserves typedefs in diagnostics

108

consistently.</li>

109

<li>GCC is licensed under the GPL license. clang uses a BSD license, which

110

allows it to be used by projects that do not themselves want to be

111

GPL.</li>

112

<li>Clang inherits a number of features from its use of LLVM as a backend,

113

including support for a bytecode representation for intermediate code,

114

pluggable optimizers, link-time optimization support, Just-In-Time

115

compilation, ability to link in multiple code generators, etc.</li>

116

</ul>

117

118

119

<h2><a name="elsa">Clang vs Elsa (Elkhound-based C++ Parser)</a></h2>

120

121

122

<p>Pro's of Elsa vs clang:</p>

123

124

<ul>

125

<li>Elsa's support for C++ is far beyond what clang provides. If you need

126

C++ support in the next year, Elsa is a great way to get it. That said,

127

Elsa is missing important support for templates and other pieces: for

128

example, it is not capable of compiling the GCC STL headers from any

129

version newer than GCC 3.4.</li>

130

<li>Elsa's parser and AST is designed to be easily extensible by adding

131

grammar rules. Clang has a very simple and easily hackable parser,

132

but requires you to write C++ code to do it.</li>

133

</ul>

134

135

<p>Pro's of clang vs Elsa:</p>

136

137

<ul>

138

<li>The Elsa community is extremely small and major development work seems

139

to have ceased in 2005, though it continues to be used by other small

140

projects

141

(e.g. Oink). Clang has a vibrant community including developers that

142

are paid to work on it full time. In practice this means that you can

143

file bugs against Clang and they will often be fixed for you. If you

144

use Elsa, you are (mostly) on your own for bug fixes and feature

145

enhancements.</li>

146

<li>Elsa is not built as a stack of reusable libraries like clang is. It is

147

very difficult to use part of Elsa without the whole front-end. For

148

example, you cannot use Elsa to parse C/ObjC code without building an

149

AST. You can do this in Clang and it is much faster than building an

150

AST.</li>

151

<li>Elsa does not have an integrated preprocessor, which makes it extremely

152

difficult to accurately map from a source location in the AST back to

153

its original position before preprocessing. Like GCC, it does not keep

154

track of macro expansions.</li>

155

<li>Elsa is even slower and uses more memory than GCC, which itself requires

156

far more space and time than clang.</li>

157

<li>Elsa only does partial semantic analysis. It is intended to work on

158

code that is already validated by GCC, so it does not do many semantic

159

checks required by the languages it implements.</li>

160

<li>Elsa does not support Objective-C.</li>

161

<li>Elsa does not support native code generation.</li>

162

</ul>

163

164

<p>Note that there is a fork of Elsa known as "Pork". It addresses some of

165

these shortcomings by loosely integrating a preprocessor. This allows it

166

to map from a source location in the AST to the original position before

167

preprocessing, providing it better support for static analysis and

168

refactoring. Note that Pork is in stasis now too.</p>

169

170

171

172

<h2><a name="pcc">Clang vs PCC (Portable C Compiler)</a></h2>

173

174

175

<p>Pro's of PCC vs clang:</p>

176

177

<ul>

178

<li>The PCC source base is very small and builds quickly with just a C

compiler.</li>

</ul>

<p>Pro's of clang vs PCC:</p>

183

184

<ul>

185

<li>PCC dates from the 1970's and has been dormant for most of that time.

186

The clang + llvm communities are very active.</li>

187

<li>PCC doesn't support C99, Objective-C, and doesn't aim to support

188

C++.</li>

189

<li>PCC's code generation is very limited compared to LLVM. It produces very

190

inefficient code and does not support many important targets.</li>

191

<li>Like Elsa, PCC's does not have an integrated preprocessor, making it

192

extremely difficult to use it for source analysis tools.</li>

193

</div>

194

</body>

195

</html>