www/comparison.html

   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 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>
  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, etc.</li>
  53     <li><a href="cxx_status.html">Clang support for C++</a> is more compliant
  54         than GCC's in many ways, but is not as mature as GCC's.  GCC has several
  55         C++'0x features that Clang does not yet support (e.g. variadic
  56         templates).</li>
  57     <li>GCC supports more targets than LLVM.</li>
  58     <li>GCC is popular and widely adopted.</li>
  59     <li>GCC does not require a C++ compiler to build it.</li>
  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>For every token, clang tracks information about where it was written and
  86         where it was ultimately expanded into if it was involved in a macro.
  87         GCC does not track information about macro instantiations when parsing
  88         source code.  This makes it very difficult for source rewriting tools
  89         (e.g. for refactoring) to work in the presence of (even simple)
  90         macros.</li>
  91     <li>Clang does not implicitly simplify code as it parses it like GCC does.
  92         Doing so causes many problems for source analysis tools: as one simple
  93         example, if you write "x-x" in your source code, the GCC AST will
  94         contain "0", with no mention of 'x'.  This is extremely bad for a
  95         refactoring tool that wants to rename 'x'.</li>
  96     <li>Clang can serialize its AST out to disk and read it back into another
  97         program, which is useful for whole program analysis.  GCC does not have
  98         this.  GCC's PCH mechanism (which is just a dump of the compiler
  99         memory image) is related, but is architecturally only
 100         able to read the dump back into the exact same executable as the one
 101         that produced it (it is not a structured format).</li>
 102     <li>Clang is <a href="features.html#performance">much faster and uses far
 103         less memory</a> than GCC.</li>
 104     <li>Clang aims to provide extremely clear and concise diagnostics (error and
 105         warning messages), and includes support for <a
 106         href="diagnostics.html">expressive diagnostics</a>.  GCC's warnings are
 107         sometimes acceptable, but are often confusing and it does not support
 108         expressive diagnostics.  Clang also preserves typedefs in diagnostics
 109         consistently, showing macro expansions and many other features.</li>
 110     <li>GCC is licensed under the GPL license.  clang uses a BSD license, which
 111         allows it to be used by projects that do not themselves want to be
 112         GPL.</li>
 113     <li>Clang inherits a number of features from its use of LLVM as a backend,
 114         including support for a bytecode representation for intermediate code,
 115         pluggable optimizers, link-time optimization support, Just-In-Time
 116         compilation, ability to link in multiple code generators, etc.</li>
 117     </ul>
 118
 119     <!--=====================================================================-->
 120     <h2><a name="elsa">Clang vs Elsa (Elkhound-based C++ Parser)</a></h2>
 121     <!--=====================================================================-->
 122
 123     <p>Pro's of Elsa vs clang:</p>
 124
 125     <ul>
 126     <li>Elsa's parser and AST is designed to be easily extensible by adding
 127         grammar rules.  Clang has a very simple and easily hackable parser,
 128         but requires you to write C++ code to do it.</li>
 129     </ul>
 130
 131     <p>Pro's of clang vs Elsa:</p>
 132
 133     <ul>
 134     <li>The Elsa community is extremely small and major development work seems
 135         to have ceased in 2005. Work continued to be used by other small
 136         projects (e.g. Oink), but Oink is apparently dead now too.  Clang has a
 137         vibrant community including developers that
 138         are paid to work on it full time.  In practice this means that you can
 139         file bugs against Clang and they will often be fixed for you.  If you
 140         use Elsa, you are (mostly) on your own for bug fixes and feature
 141         enhancements.</li>
 142     <li>Elsa is not built as a stack of reusable libraries like clang is.  It is
 143         very difficult to use part of Elsa without the whole front-end.  For
 144         example, you cannot use Elsa to parse C/ObjC code without building an
 145         AST.  You can do this in Clang and it is much faster than building an
 146         AST.</li>
 147     <li>Elsa does not have an integrated preprocessor, which makes it extremely
 148         difficult to accurately map from a source location in the AST back to
 149         its original position before preprocessing.  Like GCC, it does not keep
 150         track of macro expansions.</li>
 151     <li>Elsa is even slower and uses more memory than GCC, which itself requires
 152         far more space and time than clang.</li>
 153     <li>Elsa only does partial semantic analysis.  It is intended to work on
 154         code that is already validated by GCC, so it does not do many semantic
 155         checks required by the languages it implements.</li>
 156     <li>Elsa does not support Objective-C.</li>
 157     <li>Elsa does not support native code generation.</li>
 158     </ul>
 159
 160     <p>Note that there is a fork of Elsa known as "Pork". It addresses some of
 161        these shortcomings by loosely integrating a preprocessor. This allows it
 162        to map from a source location in the AST to the original position before
 163        preprocessing, providing it better support for static analysis and
 164        refactoring.  Note that Pork is in stasis now too.</p>
 165
 166
 167     <!--=====================================================================-->
 168     <h2><a name="pcc">Clang vs PCC (Portable C Compiler)</a></h2>
 169     <!--=====================================================================-->
 170
 171     <p>Pro's of PCC vs clang:</p>
 172
 173     <ul>
 174     <li>The PCC source base is very small and builds quickly with just a C
 175         compiler.</li>
 176     </ul>
 177
 178     <p>Pro's of clang vs PCC:</p>
 179
 180     <ul>
 181     <li>PCC dates from the 1970's and has been dormant for most of that time.
 182         The clang + llvm communities are very active.</li>
 183     <li>PCC doesn't support Objective-C or C++ and doesn't aim to support
 184         C++.</li>
 185     <li>PCC's code generation is very limited compared to LLVM.  It produces very
 186         inefficient code and does not support many important targets.</li>
 187     <li>Like Elsa, PCC's does not have an integrated preprocessor, making it
 188         extremely difficult to use it for source analysis tools.</li>
 189   </div>
 190 </body>
 191 </html>