From ead27db1b95bfa771bf26674af3fb08d210998a9 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 10 Dec 2007 08:12:49 +0000 Subject: [PATCH] finish the features description. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@44787 91177308-0d34-0410-b5e6-96231b3b80d8 --- www/content.css | 5 -- www/features.html | 214 +++++++++++++++++++++++++++++++++++++--------- 2 files changed, 174 insertions(+), 45 deletions(-) diff --git a/www/content.css b/www/content.css index 3fa7be0145..d205c715d4 100644 --- a/www/content.css +++ b/www/content.css @@ -17,11 +17,6 @@ table,tr,td { padding:.4ex; } -.weak_txt { - font-size:.9em; - color:rgb(100,100,100); -} - .code { font:Courier,Arial; } diff --git a/www/features.html b/www/features.html index 91ebf43183..f260d1c0ea 100644 --- a/www/features.html +++ b/www/features.html @@ -15,7 +15,10 @@
+

Clang - Features and Goals

+ +

This page describes the features and goals of Clang in more detail and gives a more broad explanation about what we mean. @@ -25,12 +28,22 @@ These features are:

End-User Features:

-

Driving Goals and Internal Design:

+

Utility and Applications:

+ + + +

Internal Design and Implementation:

+ - +

End-User Features

- + @@ -169,10 +182,165 @@ diagnostics, which can be mapped to warnings, errors, or just ignored.

+ +

Utility and Applications

+ + -

Driving Goals and Internal Design

+

Library Based Architecture

+

A major design concept for clang is its use of a library-based +architecture. In this design, various parts of the front-end can be cleanly +divided into separate libraries which can then be mixed up for different needs +and uses. In addition, the library-based approach encourages good interfaces +and makes it easier for new developers to get involved (because they only need +to understand small pieces of the big picture).

+ +
+"The world needs better compiler tools, tools which are built as libraries. +This design point allows reuse of the tools in new and novel ways. However, +building the tools as libraries isn't enough: they must have clean APIs, be as +decoupled from each other as possible, and be easy to modify/extend. This +requires clean layering, decent design, and keeping the libraries independent of +any specific client."
+ +

+Currently, clang is divided into the following libraries and tool: +

+ + + +

As an example of the power of this library based design.... If you wanted to +build a preprocessor, you would take the Basic and Lexer libraries. If you want +an indexer, you would take the previous two and add the Parser library and +some actions for indexing. If you want a refactoring, static analysis, or +source-to-source compiler tool, you would then add the AST building and +semantic analyzer libraries.

+ +

For more information about the low-level implementation details of the +various clang libraries, please see the +clang Internals Manual.

+ + +

Support Diverse Clients

+ + +

Clang is designed and built with many grand plans for how we can use it. The +driving force is the fact that we use C and C++ daily, and have to suffer due to +a lack of good tools available for it. We believe that the C and C++ tools +ecosystem has been significantly limited by how difficult it is to parse and +represent the source code for these languages, and we aim to rectify this +problem in clang.

+ +

The problem with this goal is that different clients have very different +requirements. Consider code generation, for example: a simple front-end that +parses for code generation must analyze the code for validity and emit code +in some intermediate form to pass off to a optimizer or backend. Because +validity analysis and code generation can largely be done on the fly, there is +not hard requirement that the front-end actually build up a full AST for all +the expressions and statements in the code. TCC and GCC are examples of +compilers that either build no real AST (in the former case) or build a stripped +down and simplified AST (in the later case) because they focus primarily on +codegen.

+ +

On the opposite side of the spectrum, some clients (like refactoring) want +highly detailed information about the original source code and want a complete +AST to describe it with. Refactoring wants to have information about macro +expansions, the location of every paren expression '(((x)))' vs 'x', full +position information, and much more. Further, refactoring wants to look +across the whole program to ensure that it is making transformations +that are safe. Making this efficient and getting this right requires a +significant amount of engineering and algorithmic work that simply are +unnecessary for a simple static compiler.

+ +

The beauty of the clang approach is that it does not restrict how you use it. +In particular, it is possible to use the clang preprocessor and parser to build +an extremely quick and light-weight on-the-fly code generator (similar to TCC) +that does not build an AST at all. As an intermediate step, clang supports +using the current AST generation and semantic analysis code and having a code +generation client free the AST for each function after code generation. Finally, +clang provides support for building and retaining fully-fledged ASTs, and even +supports writing them out to disk.

+ +

Designing the libraries with clean and simple APIs allows these high-level +policy decisions to be determined in the client, instead of forcing "one true +way" in the implementation of any of these libraries. Getting this right is +hard, and we don't always get it right the first time, but we fix any problems +when we realize we made a mistake.

+ + +

Integration with IDEs

+ + +

+We believe that Integrated Development Environments (IDE's) are a great way +to pull together various pieces of the development puzzle, and aim to make clang +work well in such an environment. The chief advantage of an IDE is that they +typically have visibility across your entire project and are long-lived +processes, whereas stand-alone compiler tools are typically invoked on each +individual file in the project, and thus have limited scope.

+ +

There are many implications of this difference, but a significant one has to +do with efficiency and caching: sharing an address space across different files +in a project, means that you can use intelligent caching and other techniques to +dramatically reduce analysis/compilation time.

+ +

A further difference between IDEs and batch compiler is that they often +impose very different requirements on the front-end: they depend on high +performance in order to provide a "snappy" experience, and thus really want +techniques like "incremental compilation", "fuzzy parsing", etc. Finally, IDEs +often have very different requirements than code generation, often requiring +information that a codegen-only frontend can throw away. Clang is +specifically designed and built to capture this information. +

+ + + +

Use the LLVM 'BSD' License

+ + +

We actively indend for clang (and a LLVM as a whole) to be used for +commercial projects, and the BSD license is the simplest way to allow this. We +feel that the license encourages contributors to pick up the source and work +with it, and believe that those individuals and organizations will contribute +back their work if they do not want to have to maintain a fork forever (which is +time consuming and expensive when merges are involved). Further, nobody makes +money on compilers these days, but many people need them to get bigger goals +accomplished: it makes sense for everyone to work together.

+ +

For more information about the LLVM/clang license, please see the LLVM License +Description for more information.

+ + + + +

Internal Design and Implementation

+ +

A real-world, production quality compiler

@@ -247,40 +415,6 @@ clang in "strict" mode if you desire.

We also intend to support "dialects" of these languages, such as C89, K&R C, C++'03, Objective-C 2, etc.

- - -

Library based architecture

- - -A major design concept for the LLVM front-end involves using a library based architecture. In this library based architecture, various parts of the front-end can be cleanly divided into separate libraries which can then be mixed up for different needs and uses. In addition, the library based approach makes it much easier for new developers to get involved and extend LLVM to do new and unique things. In the words of Chris, - -
-"The world needs better compiler tools, tools which are built as libraries. -This design point allows reuse of the tools in new and novel ways. However, -building the tools as libraries isn't enough: they must have clean APIs, be as -decoupled from each other as possible, and be easy to modify/extend. This -requires clean layering, decent design, and keeping the libraries independent of -any specific client."
- -Currently, the LLVM front-end is divided into the following libraries: - -As an example of the power of this library based design.... If you wanted to build a preprocessor, you would take the Basic and Lexer libraries. If you want an indexer, you would take the previous two and add the Parser library and some actions for indexing. If you want a refactoring, static analysis, or source-to-source compiler tool, you would then add the AST building and semantic analyzer libraries. -In the end, LLVM's library based design will provide developers with many more possibilities. - -

Better Integration with IDEs

-Another design goal of Clang is to integrate extremely well with IDEs. IDEs often have very different requirements than code generation, often requiring information that a codegen-only frontend can throw away. Clang is specifically designed and built to capture this information.
-- 2.40.0