comparison.html source code [clang_source

1	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
2	"http://www.w3.org/TR/html4/strict.dtd">
3	<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
4	<html>
5	<head>
6	<META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
7	<title>Comparing Clang to other open source compilers</title>
8	<link type="text/css" rel="stylesheet" href="menu.css">
9	<link type="text/css" rel="stylesheet" href="content.css">
10	</head>
11	<body>
12	<!--#include virtual="menu.html.incl"-->
13	<div id="content">
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 <a href="get_involved.html">cfe-dev</a> 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>
41	</ul>
42
43
44	<!--=====================================================================-->
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, Go, etc.</li>
53	<li>GCC supports more targets than LLVM.</li>
54	<li>GCC supports many language extensions, some of which are not implemented
55	by Clang. For instance, in C mode, GCC supports
56	<a href="http://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html">nested
57	functions</a> and has an
58	<a href="https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html">extension
59	allowing VLAs in structs</a>.
60	</ul>
61
62	<p>Pro's of Clang vs GCC:</p>
63
64	<ul>
65	<li>The Clang ASTs and design are intended to be <a
66	href="features.html#simplecode">easily understandable</a> by
67	anyone who is familiar with the languages involved and who has a basic
68	understanding of how a compiler works. GCC has a very old codebase
69	which presents a steep learning curve to new developers.</li>
70	<li>Clang is designed as an API from its inception, allowing it to be reused
71	by source analysis tools, refactoring, IDEs (etc) as well as for code
72	generation. GCC is built as a monolithic static compiler, which makes
73	it extremely difficult to use as an API and integrate into other tools.
74	Further, its historic design and <a
75	href="http://gcc.gnu.org/ml/gcc/2007-11/msg00460.html">current</a>
76	<a href="http://gcc.gnu.org/ml/gcc/2004-12/msg00888.html">policy</a>
77	makes it difficult to decouple the front-end from the rest of the
78	compiler. </li>
79	<li>Various GCC design decisions make it very difficult to reuse: its build
80	system is difficult to modify, you can't link multiple targets into one
81	binary, you can't link multiple front-ends into one binary, it uses a
82	custom garbage collector, uses global variables extensively, is not
83	reentrant or multi-threadable, etc. Clang has none of these problems.
84	</li>
85	<li>Clang does not implicitly simplify code as it parses it like GCC does.
86	Doing so causes many problems for source analysis tools: as one simple
87	example, if you write "x-x" in your source code, the GCC AST will
88	contain "0", with no mention of 'x'. This is extremely bad for a
89	refactoring tool that wants to rename 'x'.</li>
90	<li>Clang can serialize its AST out to disk and read it back into another
91	program, which is useful for whole program analysis. GCC does not have
92	this. GCC's PCH mechanism (which is just a dump of the compiler
93	memory image) is related, but is architecturally only
94	able to read the dump back into the exact same executable as the one
95	that produced it (it is not a structured format).</li>
96	<li>Clang is <a href="features.html#performance">much faster and uses far
97	less memory</a> than GCC.</li>
98	<li>Clang has been designed from the start to provide extremely clear and
99	concise diagnostics (error and warning messages), and includes support
100	for <a href="diagnostics.html">expressive diagnostics</a>.
101	Modern versions of GCC have made significant advances in this area,
102	incorporating various Clang features such as preserving typedefs in
103	diagnostics and showing macro expansions, but GCC is still catching
104	up.</li>
105	<li>GCC is licensed under the GPL license. <a href="features.html#license">
106	Clang uses a BSD license,</a> which allows it to be embedded in
107	software that is not GPL-licensed.</li>
108	<li>Clang inherits a number of features from its use of LLVM as a backend,
109	including support for a bytecode representation for intermediate code,
110	pluggable optimizers, link-time optimization support, Just-In-Time
111	compilation, ability to link in multiple code generators, etc.</li>
112	<li><a href="compatibility.html#cxx">Clang's support for C++</a> is more
113	compliant than GCC's in many ways.</li>
114	<li>Clang supports
115	<a href="http://clang.llvm.org/docs/LanguageExtensions.html">many language
116	extensions</a>, some of which are not implemented by GCC. For instance,
117	Clang provides attributes for checking thread safety and extended vector
118	types.</li>
119	</ul>
120
121	<!--=====================================================================-->
122	<h2><a name="elsa">Clang vs Elsa (Elkhound-based C++ Parser)</a></h2>
123	<!--=====================================================================-->
124
125	<p>Pro's of Elsa vs Clang:</p>
126
127	<ul>
128	<li>Elsa's parser and AST is designed to be easily extensible by adding
129	grammar rules. Clang has a very simple and easily hackable parser,
130	but requires you to write C++ code to do it.</li>
131	</ul>
132
133	<p>Pro's of Clang vs Elsa:</p>
134
135	<ul>
136	<li>Clang's C and C++ support is far more mature and practically useful than
137	Elsa's, and includes many C++'11 features.</li>
138	<li>The Elsa community is extremely small and major development work seems
139	to have ceased in 2005. Work continued to be used by other small
140	projects (e.g. Oink), but Oink is apparently dead now too. Clang has a
141	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
165	<!--=====================================================================-->
166	<h2><a name="pcc">Clang vs PCC (Portable C Compiler)</a></h2>
167	<!--=====================================================================-->
168
169	<p>Pro's of PCC vs Clang:</p>
170
171	<ul>
172	<li>The PCC source base is very small and builds quickly with just a C
173	compiler.</li>
174	</ul>
175
176	<p>Pro's of Clang vs PCC:</p>
177
178	<ul>
179	<li>PCC dates from the 1970's and has been dormant for most of that time.
180	The Clang and LLVM communities are very active.</li>
181	<li>PCC doesn't support Objective-C or C++ and doesn't aim to support
182	C++.</li>
183	<li>PCC's code generation is very limited compared to LLVM. It produces very
184	inefficient code and does not support many important targets.</li>
185	<li>Like Elsa, PCC's does not have an integrated preprocessor, making it
186	extremely difficult to use it for source analysis tools.</li>
187	</ul>
188	</div>
189	</body>
190	</html>
191

Clang Project