diff options
Diffstat (limited to 'clang/www')
79 files changed, 13290 insertions, 0 deletions
diff --git a/clang/www/OpenProjects.html b/clang/www/OpenProjects.html new file mode 100644 index 0000000..b2d4dae --- /dev/null +++ b/clang/www/OpenProjects.html @@ -0,0 +1,114 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>Clang - Get Involved</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> +</head> +<body> + +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<h1>Open Clang Projects</h1> + +<p>Here are a few tasks that are available for newcomers to work on, depending +on what your interests are. This list is provided to generate ideas, it is not +intended to be comprehensive. Please ask on cfe-dev for more specifics or to +verify that one of these isn't already completed. :)</p> + +<ul> +<li><b>Undefined behavior checking</b>: CodeGen could +insert runtime checks for all sorts of different undefined behaviors, from +reading uninitialized variables, buffer overflows, and many other things. This +checking would be expensive, but the optimizers could eliminate many of the +checks in some cases, and it would be very interesting to test code in this mode +for certain crowds of people. Because the inserted code is coming from clang, +the "abort" message could be very detailed about exactly what went wrong.</li> + +<li><b>Improve target support</b>: The current target interfaces are heavily +stubbed out and need to be implemented fully. See the FIXME's in TargetInfo. +Additionally, the actual target implementations (instances of TargetInfoImpl) +also need to be completed.</li> + +<li><b>Implement an tool to generate code documentation</b>: Clang's +library-based design allows it to be used by a variety of tools that reason +about source code. One great application of Clang would be to build an +auto-documentation system like doxygen that generates code documentation from +source code. The advantage of using Clang for such a tool is that the tool would +use the same preprocessor/parser/ASTs as the compiler itself, giving it a very +rich understanding of the code.</li> + +<li><b>Use clang libraries to implement better versions of existing tools</b>: +Clang is built as a set of libraries, which means that it is possible to +implement capabilities similar to other source language tools, improving them +in various ways. Three examples are <a +href="http://distcc.samba.org/">distcc</a>, the <a +href="http://delta.tigris.org/">delta testcase reduction tool</a>, and the +"indent" source reformatting tool. +distcc can be improved to scale better and be more efficient. Delta could be +faster and more efficient at reducing C-family programs if built on the clang +preprocessor, indent could do proper formatting for complex C++ features, and it +would be straight-forward to extend a clang-based implementation to handle +simple structural rules like those in <a +href="http://llvm.org/docs/CodingStandards.html#hl_earlyexit">the LLVM coding +standards</a>.</li> + +<li><b>Use clang libraries to extend Ragel with a JIT</b>: <a +href="http://research.cs.queensu.ca/~thurston/ragel/">Ragel</a> is a state +machine compiler that lets you embed C code into state machines and generate +C code. It would be relatively easy to turn this into a JIT compiler using +LLVM.</li> + +<li><b>Self-testing using clang</b>: There are several neat ways to +improve the quality of clang by self-testing. Some examples: +<ul> + <li>Improve the reliability of AST printing and serialization by + ensuring that the AST produced by clang on an input doesn't change + when it is reparsed or unserialized. + + <li>Improve parser reliability and error generation by automatically + or randomly changing the input checking that clang doesn't crash and + that it doesn't generate excessive errors for small input + changes. Manipulating the input at both the text and token levels is + likely to produce interesting test cases. +</ul> +</li> + +<li><b>Continue work on C++'11 support</b>: + C++'98 is feature complete, but there is still a lot of C++'11 features to + implement. Please see the <a href="cxx_status.html">C++ status report + page</a> to find out what is missing.</li> +</ul> + +<p>If you hit a bug with clang, it is very useful for us if you reduce the code +that demonstrates the problem down to something small. There are many ways to +do this; ask on cfe-dev for advice.</p> + +<ul> +<li><b>StringRef'ize APIs</b>: A thankless but incredibly useful project is +StringRef'izing (converting to use <tt>llvm::StringRef</tt> instead of <tt>const +char *</tt> or <tt>std::string</tt>) various clang interfaces. This generally +simplifies the code and makes it more efficient.</li> + +<li><b>Universal Driver</b>: Clang is inherently a cross compiler. We would like +to define a new model for cross compilation which provides a great user +experience -- it should be easy to cross compile applications, install support +for new architectures, access different compilers and tools, and be consistent +across different platforms. See the <a href="UniversalDriver.html">Universal +Driver</a> web page for more information.</li> + +<li><b>XML Representation of ASTs</b>: Clang maintains a rich Abstract Syntax Tree that describes the program. Clang could emit an XML document that describes the program, which others tools could consume rather than being tied directly to the Clang binary.The XML representation needs to meet several requirements: + <ul> + <li><i>General</i>, so that it's able to represent C/C++/Objective-C abstractly, and isn't tied to the specific internal ASTs that Clang uses.</li> + <li><i>Documented</i>, with appropriate Schema against which the output of Clang's XML formatter can be verified.</li> + <li><i>Stable</i> across Clang versions.</li> + </ul></li> +</ul> + +</div> +</body> +</html> diff --git a/clang/www/UniversalDriver.html b/clang/www/UniversalDriver.html new file mode 100644 index 0000000..2d41a62 --- /dev/null +++ b/clang/www/UniversalDriver.html @@ -0,0 +1,87 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>Clang - Universal Driver</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> +</head> +<body> + +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<h1>The Clang Universal Driver Project</h1> + +<p>Clang is inherently a cross compiler, in that it is always capable of +building code for targets which are a different architecture or even operating +system from the one running the compiler. However, actually cross compiling in +practice involves much more than just generating the right assembly code for a +target, it also requires having an appropriate tool chain (assemblers, linkers), +access to header files and libraries for the target, and many other details (for +example, the calling convention or whether software floating point is in +use). Traditionally, compilers and development environments provide little +assistance with this process, so users do not have easy access to the powerful +underlying cross-compilation abilities of clang.</p> + +<p>We would like to solve this problem by defining a new model for how cross +compilation is done, based on the idea of a <i>universal driver</i>. The key +point of this model is that the user would always access the compiler through a +single entry point (e.g., <tt>/usr/bin/cc</tt>) and provide an argument +specifying the <i>configuration</i> they would like to target. Under the hood +this entry point (the universal driver) would have access to all the information +that the driver, compiler, and other tools need to build applications for that +target.</p> + +<p>This is a large and open-ended project. It's eventual success depends not +just on implementing the model, but also on getting buy-in from compiler +developers, operating system distribution vendors and the development community +at large. Our plan is to begin by defining a clear list of the problems we want +to solve and a proposed implementation (from the user perspective).</p> + +<p>This project is in the very early (i.e., thought experiment) stages of +development. Stay tuned for more information, and of course, patches +welcome!</p> + +<p>See also <a href="http://llvm.org/PR4127">PR4127</a>.</p> + +<h2>Existing Solutions and Related Work</h2> + +<ul> + <li>gcc's command line arguments <tt>-V</tt>, <tt>-B</tt>, <tt>-b</tt> are + generic but limited solutions to related problems. Similarly, <tt>-m32</tt> + and <tt>-m64</tt> solve a small subset of the problem for specific + architectures.</li> + + <li>gcc's <a href="http://www.airs.com/ian/configure/configure_8.html">multilibs</a> + solve the part of the problem that relates to finding appropriate libraries + and include files based on particular feature support (soft float, + etc.).</li> + + <li>Apple's "driver driver" supported by gcc and clang solve a subset of the + problem by supporting <tt>-arch</tt>. Apple also provides a tool chain which + supports <a href="http://en.wikipedia.org/wiki/Universal_binary">universal + binaries</a> and object files which may include data for multiple + architectures. See <a href="http://developer.apple.com/mac/library/technotes/tn2005/tn2137.html">TN2137</a> + for an example of how this is used.</li> + + <li>Many operating systems and environments solve the problem by installing + complete development environments (including the IDE, tools, header files, + and libraries) for a single tool chain. This is cumbersome for users and + does not match well with tools which are inherently capable of cross + compiling.</li> + + <li>The Debian <a href="http://wiki.debian.org/ArmEabiPort">ArmEabiPort</a> + wiki page for their work to support the ARM EABI provide an interesting + glimpse into how related issues impact the operating system distribution.</li> + + <li><a href="http://icculus.org/fatelf/">FatELF</a> is a proposal for bringing + Mac OS X like "Universal Binary" support to ELF based platforms.</li> + +</ul> + +</div> +</body> +</html> diff --git a/clang/www/analyzer/annotations.html b/clang/www/analyzer/annotations.html new file mode 100644 index 0000000..9e3583d --- /dev/null +++ b/clang/www/analyzer/annotations.html @@ -0,0 +1,602 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <title>Source Annotations</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <script type="text/javascript" src="scripts/menu.js"></script> +</head> +<body> + +<div id="page"> +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<h1>Source Annotations</h1> + +<p>The Clang frontend supports several source-level annotations in the form of +<a href="http://gcc.gnu.org/onlinedocs/gcc/Attribute-Syntax.html">GCC-style +attributes</a> and pragmas that can help make using the Clang Static Analyzer +more useful. These annotations can both help suppress false positives as well as +enhance the analyzer's ability to find bugs.</p> + +<p>This page gives a practical overview of such annotations. For more technical +specifics regarding Clang-specific annotations please see the Clang's list of <a +href="http://clang.llvm.org/docs/LanguageExtensions.html">language +extensions</a>. Details of "standard" GCC attributes (that Clang also +supports) can be found in the <a href="http://gcc.gnu.org/onlinedocs/gcc/">GCC +manual</a>, with the majority of the relevant attributes being in the section on +<a href="http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html">function +attributes</a>.</p> + +<p>Note that attributes that are labeled <b>Clang-specific</b> are not +recognized by GCC. Their use can be conditioned using preprocessor macros +(examples included on this page).</p> + +<h4>Specific Topics</h4> + +<ul> +<li><a href="#generic">Annotations to Enhance Generic Checks</a> + <ul> + <li><a href="#null_checking"><span>Null Pointer Checking</span></a> + <ul> + <li><a href="#attr_nonnull"><span>Attribute 'nonnull'</span></a></li> + </ul> + </li> + </ul> +</li> +<li><a href="#macosx">Mac OS X API Annotations</a> + <ul> + <li><a href="#cocoa_mem">Cocoa & Core Foundation Memory Management Annotations</a> + <ul> + <li><a href="#attr_ns_returns_retained">Attribute 'ns_returns_retained'</a></li> + <li><a href="#attr_ns_returns_not_retained">Attribute 'ns_returns_not_retained'</a></li> + <li><a href="#attr_cf_returns_retained">Attribute 'cf_returns_retained'</a></li> + <li><a href="#attr_cf_returns_not_retained">Attribute 'cf_returns_not_retained'</a></li> + <li><a href="#attr_ns_consumed">Attribute 'ns_consumed'</a></li> + <li><a href="#attr_cf_consumed">Attribute 'cf_consumed'</a></li> + <li><a href="#attr_ns_consumes_self">Attribute 'ns_consumes_self'</a></li> + </ul> + </li> + </ul> +</li> +<li><a href="#custom_assertions">Custom Assertion Handlers</a> + <ul> + <li><a href="#attr_noreturn">Attribute 'noreturn'</a></li> + <li><a href="#attr_analyzer_noreturn">Attribute 'analyzer_noreturn'</a></li> + </ul> + </li> +</ul> + +<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> +<h2 id="generic">Annotations to Enhance Generic Checks</h2> +<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> + +<h3 id="null_checking">Null Pointer Checking</h3> + +<h4 id="attr_nonnull">Attribute 'nonnull'</h4> + +<p>The analyzer recognizes the GCC attribute 'nonnull', which indicates that a +function expects that a given function parameter is not a null pointer. Specific +details of the syntax of using the 'nonnull' attribute can be found in <a +href="http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html#index-g_t_0040code_007bnonnull_007d-function-attribute-2263">GCC's +documentation</a>.</p> + +<p>Both the Clang compiler and GCC will flag warnings for simple cases where a +null pointer is directly being passed to a function with a 'nonnull' parameter +(e.g., as a constant). The analyzer extends this checking by using its deeper +symbolic analysis to track what pointer values are potentially null and then +flag warnings when they are passed in a function call via a 'nonnull' +parameter.</p> + +<p><b>Example</b></p> + +<pre class="code_example"> +<span class="command">$ cat test.m</span> +int bar(int*p, int q, int *r) __attribute__((nonnull(1,3))); + +int foo(int *p, int *q) { + return !p ? bar(q, 2, p) + : bar(p, 2, q); +} +</pre> + +<p>Running <tt>scan-build</tt> over this source produces the following +output:</p> + +<img src="images/example_attribute_nonnull.png" alt="example attribute nonnull"> + +<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> +<h2 id="macosx">Mac OS X API Annotations</h2> +<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> + +<h3 id="cocoa_mem">Cocoa & Core Foundation Memory Management +Annotations</h3> + +<!-- +<p>As described in <a href="/available_checks.html#retain_release">Available +Checks</a>, +--> +<p>The analyzer supports the proper management of retain counts for +both Cocoa and Core Foundation objects. This checking is largely based on +enforcing Cocoa and Core Foundation naming conventions for Objective-C methods +(Cocoa) and C functions (Core Foundation). Not strictly following these +conventions can cause the analyzer to miss bugs or flag false positives.</p> + +<p>One can educate the analyzer (and others who read your code) about methods or +functions that deviate from the Cocoa and Core Foundation conventions using the +attributes described here.</p> + +<h4 id="attr_ns_returns_retained">Attribute 'ns_returns_retained' +(Clang-specific)</h4> + +<p>The GCC-style (Clang-specific) attribute 'ns_returns_retained' allows one to +annotate an Objective-C method or C function as returning a retained Cocoa +object that the caller is responsible for releasing (via sending a +<tt>release</tt> message to the object).</p> + +<p><b>Placing on Objective-C methods</b>: For Objective-C methods, this +annotation essentially tells the analyzer to treat the method as if its name +begins with "alloc" or "new" or contains the word +"copy".</p> + +<p><b>Placing on C functions</b>: For C functions returning Cocoa objects, the +analyzer typically does not make any assumptions about whether or not the object +is returned retained. Explicitly adding the 'ns_returns_retained' attribute to C +functions allows the analyzer to perform extra checking.</p> + +<p><b>Important note when using Garbage Collection</b>: Note that the analyzer +interprets this attribute slightly differently when using Objective-C garbage +collection (available on Mac OS 10.5+). When analyzing Cocoa code that uses +garbage collection, "alloc" methods are assumed to return an object +that is managed by the garbage collector (and thus doesn't have a retain count +the caller must balance). These same assumptions are applied to methods or +functions annotated with 'ns_returns_retained'. If you are returning a Core +Foundation object (which may not be managed by the garbage collector) you should +use 'cf_returns_retained'.</p> + +<p><b>Example</b></p> + +<pre class="code_example"> +<span class="command">$ cat test.m</span> +#import <Foundation/Foundation.h> + +#ifndef __has_feature // Optional. +#define __has_feature(x) 0 // Compatibility with non-clang compilers. +#endif + +#ifndef NS_RETURNS_RETAINED +#if __has_feature(attribute_ns_returns_retained) +<span class="code_highlight">#define NS_RETURNS_RETAINED __attribute__((ns_returns_retained))</span> +#else +#define NS_RETURNS_RETAINED +#endif +#endif + +@interface MyClass : NSObject {} +- (NSString*) returnsRetained <span class="code_highlight">NS_RETURNS_RETAINED</span>; +- (NSString*) alsoReturnsRetained; +@end + +@implementation MyClass +- (NSString*) returnsRetained { + return [[NSString alloc] initWithCString:"no leak here"]; +} +- (NSString*) alsoReturnsRetained { + return [[NSString alloc] initWithCString:"flag a leak"]; +} +@end +</pre> + +<p>Running <tt>scan-build</tt> on this source file produces the following output:</p> + +<img src="images/example_ns_returns_retained.png" alt="example returns retained"> + +<h4 id="attr_ns_returns_not_retained">Attribute 'ns_returns_not_retained' +(Clang-specific)</h4> + +<p>The 'ns_returns_not_retained' attribute is the complement of '<a +href="#attr_ns_returns_retained">ns_returns_retained</a>'. Where a function or +method may appear to obey the Cocoa conventions and return a retained Cocoa +object, this attribute can be used to indicate that the object reference +returned should not be considered as an "owning" reference being +returned to the caller.</p> + +<p>Usage is identical to <a +href="#attr_ns_returns_retained">ns_returns_retained</a>. When using the +attribute, be sure to declare it within the proper macro that checks for +its availability, as it is not available in earlier versions of the analyzer:</p> + +<pre class="code_example"> +<span class="command">$ cat test.m</span> +#ifndef __has_feature // Optional. +#define __has_feature(x) 0 // Compatibility with non-clang compilers. +#endif + +#ifndef NS_RETURNS_NOT_RETAINED +#if __has_feature(attribute_ns_returns_not_retained) +<span class="code_highlight">#define NS_RETURNS_NOT_RETAINED __attribute__((ns_returns_not_retained))</span> +#else +#define NS_RETURNS_NOT_RETAINED +#endif +#endif +</pre> + +<h4 id="attr_cf_returns_retained">Attribute 'cf_returns_retained' +(Clang-specific)</h4> + +<p>The GCC-style (Clang-specific) attribute 'cf_returns_retained' allows one to +annotate an Objective-C method or C function as returning a retained Core +Foundation object that the caller is responsible for releasing. + +<p><b>Placing on Objective-C methods</b>: With respect to Objective-C methods., +this attribute is identical in its behavior and usage to 'ns_returns_retained' +except for the distinction of returning a Core Foundation object instead of a +Cocoa object. This distinction is important for two reasons:</p> + +<ul> + <li>Core Foundation objects are not automatically managed by the Objective-C + garbage collector.</li> + <li>Because Core Foundation is a C API, the analyzer cannot always tell that a + pointer return value refers to a Core Foundation object. In contrast, it is + trivial for the analyzer to recognize if a pointer refers to a Cocoa object + (given the Objective-C type system). +</ul> + +<p><b>Placing on C functions</b>: When placing the attribute +'cf_returns_retained' on the declarations of C functions, the analyzer +interprets the function as:</p> + +<ol> + <li>Returning a Core Foundation Object</li> + <li>Treating the function as if it its name +contained the keywords "create" or "copy". This means the +returned object as a +1 retain count that must be released by the caller, either +by sending a <tt>release</tt> message (via toll-free bridging to an Objective-C +object pointer), calling <tt>CFRelease</tt> (or similar function), or using +<tt>CFMakeCollectable</tt> to register the object with the Objective-C garbage +collector.</li> +</ol> + +<p><b>Example</b></p> + +<p>In this example, observe the difference in output when the code is compiled +to not use garbage collection versus when it is compiled to only use garbage +collection (<tt>-fobjc-gc-only</tt>).</p> + +<pre class="code_example"> +<span class="command">$ cat test.m</span> +$ cat test.m +#import <Cocoa/Cocoa.h> + +#ifndef __has_feature // Optional. +#define __has_feature(x) 0 // Compatibility with non-clang compilers. +#endif + +#ifndef CF_RETURNS_RETAINED +#if __has_feature(attribute_cf_returns_retained) +<span class="code_highlight">#define CF_RETURNS_RETAINED __attribute__((cf_returns_retained))</span> +#else +#define CF_RETURNS_RETAINED +#endif +#endif + +@interface MyClass : NSObject {} +- (NSDate*) returnsCFRetained <span class="code_highlight">CF_RETURNS_RETAINED</span>; +- (NSDate*) alsoReturnsRetained; +- (NSDate*) returnsNSRetained <span class="code_highlight">NS_RETURNS_RETAINED</span>; +@end + +<span class="code_highlight">CF_RETURNS_RETAINED</span> +CFDateRef returnsRetainedCFDate() { + return CFDateCreate(0, CFAbsoluteTimeGetCurrent()); +} + +@implementation MyClass +- (NSDate*) returnsCFRetained { + return (NSDate*) returnsRetainedCFDate(); <b><i>// No leak.</i></b> +} + +- (NSDate*) alsoReturnsRetained { + return (NSDate*) returnsRetainedCFDate(); <b><i>// Always report a leak.</i></b> +} + +- (NSDate*) returnsNSRetained { + return (NSDate*) returnsRetainedCFDate(); <b><i>// Report a leak when using GC.</i></b> +} +@end +</pre> + +<p>Running <tt>scan-build</tt> on this example produces the following output:</p> + +<img src="images/example_cf_returns_retained.png" alt="example returns retained"> + +<p>When the above code is compiled using Objective-C garbage collection (i.e., +code is compiled with the flag <tt>-fobjc-gc</tt> or <tt>-fobjc-gc-only</tt>), +<tt>scan-build</tt> produces both the above error (with slightly different text +to indicate the code uses garbage collection) as well as the following warning, +which indicates a leak that occurs <em>only</em> when using garbage +collection:</p> + +<img src="images/example_cf_returns_retained_gc.png" alt="example returns retained gc"> + +<h4 id="attr_cf_returns_not_retained">Attribute 'cf_returns_not_retained' +(Clang-specific)</h4> + +<p>The 'cf_returns_not_retained' attribute is the complement of '<a +href="#attr_cf_returns_retained">cf_returns_retained</a>'. Where a function or +method may appear to obey the Core Foundation or Cocoa conventions and return +a retained Core Foundation object, this attribute can be used to indicate that +the object reference returned should not be considered as an +"owning" reference being returned to the caller.</p> + +<p>Usage is identical to <a +href="#attr_cf_returns_retained">cf_returns_retained</a>. When using the +attribute, be sure to declare it within the proper macro that checks for +its availability, as it is not available in earlier versions of the analyzer:</p> + +<pre class="code_example"> +<span class="command">$ cat test.m</span> +#ifndef __has_feature // Optional. +#define __has_feature(x) 0 // Compatibility with non-clang compilers. +#endif + +#ifndef CF_RETURNS_NOT_RETAINED +#if __has_feature(attribute_cf_returns_not_retained) +<span class="code_highlight">#define CF_RETURNS_NOT_RETAINED __attribute__((cf_returns_not_retained))</span> +#else +#define CF_RETURNS_NOT_RETAINED +#endif +#endif +</pre> + +<h4 id="attr_ns_consumed">Attribute 'ns_consumed' +(Clang-specific)</h4> + +<p>The 'ns_consumed' attribute can be placed on a specific parameter in either the declaration of a function or an Objective-C method. + It indicates to the static analyzer that a <tt>release</tt> message is implicitly sent to the parameter upon + completion of the call to the given function or method. + +<p><b>Important note when using Garbage Collection</b>: Note that the analyzer +essentially ignores this attribute when code is compiled to use Objective-C +garbage collection. This is because the <tt>release</tt> message does nothing +when using GC. If the underlying function/method uses something like +<tt>CFRelease</tt> to decrement the reference count, consider using +the <a href="#attr_cf_consumed">cf_consumed</a> attribute instead.</p> + +<p><b>Example</b></p> + +<pre class="code_example"> +<span class="command">$ cat test.m</span> +#ifndef __has_feature // Optional. +#define __has_feature(x) 0 // Compatibility with non-clang compilers. +#endif + +#ifndef NS_CONSUMED +#if __has_feature(attribute_ns_consumed) +<span class="code_highlight">#define NS_CONSUMED __attribute__((ns_consumed))</span> +#else +#define NS_CONSUMED +#endif +#endif + +void consume_ns(id <span class="code_highlight">NS_CONSUMED</span> x); + +void test() { + id x = [[NSObject alloc] init]; + consume_ns(x); <b><i>// No leak!</i></b> +} + +@interface Foo : NSObject ++ (void) releaseArg:(id) <span class="code_highlight">NS_CONSUMED</span> x; ++ (void) releaseSecondArg:(id)x second:(id) <span class="code_highlight">NS_CONSUMED</span> y; +@end + +void test_method() { + id x = [[NSObject alloc] init]; + [Foo releaseArg:x]; <b><i>// No leak!</i></b> +} + +void test_method2() { + id a = [[NSObject alloc] init]; + id b = [[NSObject alloc] init]; + [Foo releaseSecondArg:a second:b]; <b><i>// 'a' is leaked, but 'b' is released.</i></b> +} +</pre> + +<h4 id="attr_cf_consumed">Attribute 'cf_consumed' +(Clang-specific)</h4> + +<p>The 'cf_consumed' attribute is practically identical to <a href="#attr_ns_consumed">ns_consumed</a>. +The attribute can be placed on a specific parameter in either the declaration of a function or an Objective-C method. +It indicates to the static analyzer that the object reference is implicitly passed to a call to <tt>CFRelease</tt> upon +completion of the call to the given function or method.</p> + +<p>Operationally this attribute is nearly identical to ns_consumed +with the main difference that the reference count decrement still occurs when using Objective-C garbage +collection (which is import for Core Foundation types, which are not automatically garbage collected).</p> + +<p><b>Example</b></p> + +<pre class="code_example"> +<span class="command">$ cat test.m</span> +#ifndef __has_feature // Optional. +#define __has_feature(x) 0 // Compatibility with non-clang compilers. +#endif + +#ifndef CF_CONSUMED +#if __has_feature(attribute_cf_consumed) +<span class="code_highlight">#define CF_CONSUMED __attribute__((cf_consumed))</span> +#else +#define CF_CONSUMED +#endif +#endif + +void consume_cf(id <span class="code_highlight">CF_CONSUMED</span> x); +void consume_CFDate(CFDateRef <span class="code_highlight">CF_CONSUMED</span> x); + +void test() { + id x = [[NSObject alloc] init]; + consume_cf(x); <b><i>// No leak!</i></b> +} + +void test2() { + CFDateRef date = CFDateCreate(0, CFAbsoluteTimeGetCurrent()); + consume_CFDate(date); <b><i>// No leak, including under GC!</i></b> + +} + +@interface Foo : NSObject ++ (void) releaseArg:(CFDateRef) <span class="code_highlight">CF_CONSUMED</span> x; +@end + +void test_method() { + CFDateRef date = CFDateCreate(0, CFAbsoluteTimeGetCurrent()); + [Foo releaseArg:date]; <b><i>// No leak!</i></b> +} +</pre> + +<h4 id="attr_ns_consumes_self">Attribute 'ns_consumes_self' +(Clang-specific)</h4> + +<p>The 'ns_consumes_self' attribute can be placed only on an Objective-C method declaration. + It indicates that the receiver of the message is "consumed" (a single reference count decremented) + after the message is sent. This matches the semantics of all "init" methods. +</p> + +<p>One use of this attribute is declare your own init-like methods that do not follow the + standard Cocoa naming conventions.</p> + +<p><b>Example</b></p> + +<pre class="code_example"> +#ifndef __has_feature +#define __has_feature(x) 0 // Compatibility with non-clang compilers. +#endif + +#ifndef NS_CONSUMES_SELF +#if __has_feature((attribute_ns_consumes_self)) +<span class="code_highlight">#define NS_CONSUMES_SELF __attribute__((ns_consumes_self))</span> +#else +#define NS_CONSUMES_SELF +#endif +#endif + +@interface MyClass : NSObject +- initWith:(MyClass *)x; +- nonstandardInitWith:(MyClass *)x <span class="code_highlight">NS_CONSUMES_SELF</span> NS_RETURNS_RETAINED; +@end +</pre> + +<p>In this example, <tt>nonstandardInitWith:</tt> has the same ownership semantics as the init method <tt>initWith:</tt>. + The static analyzer will observe that the method consumes the receiver, and then returns an object with a +1 retain count.</p> + +<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> +<h2 id="custom_assertions">Custom Assertion Handlers</h2> +<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> + +<p>The analyzer exploits code assertions by pruning off paths where the +assertion condition is false. The idea is capture any program invariants +specified in the assertion that the developer may know but is not immediately +apparent in the code itself. In this way assertions make implicit assumptions +explicit in the code, which not only makes the analyzer more accurate when +finding bugs, but can help others better able to understand your code as well. +It can also help remove certain kinds of analyzer false positives by pruning off +false paths.</p> + +<p>In order to exploit assertions, however, the analyzer must understand when it +encounters an "assertion handler." Typically assertions are +implemented with a macro, with the macro performing a check for the assertion +condition and, when the check fails, calling an assertion handler. For example, consider the following code +fragment:</p> + +<pre class="code_example"> +void foo(int *p) { + assert(p != NULL); +} +</pre> + +<p>When this code is preprocessed on Mac OS X it expands to the following:</p> + +<pre class="code_example"> +void foo(int *p) { + (__builtin_expect(!(p != NULL), 0) ? __assert_rtn(__func__, "t.c", 4, "p != NULL") : (void)0); +} +</pre> + +<p>In this example, the assertion handler is <tt>__assert_rtn</tt>. When called, +most assertion handlers typically print an error and terminate the program. The +analyzer can exploit such semantics by ending the analysis of a path once it +hits a call to an assertion handler.</p> + +<p>The trick, however, is that the analyzer needs to know that a called function +is an assertion handler; otherwise the analyzer might assume the function call +returns and it will continue analyzing the path where the assertion condition +failed. This can lead to false positives, as the assertion condition usually +implies a safety condition (e.g., a pointer is not null) prior to performing +some action that depends on that condition (e.g., dereferencing a pointer).</p> + +<p>The analyzer knows about several well-known assertion handlers, but can +automatically infer if a function should be treated as an assertion handler if +it is annotated with the 'noreturn' attribute or the (Clang-specific) +'analyzer_noreturn' attribute.</p> + +<h4 id="attr_noreturn">Attribute 'noreturn'</h4> + +<p>The 'noreturn' attribute is a GCC-attribute that can be placed on the +declarations of functions. It means exactly what its name implies: a function +with a 'noreturn' attribute should never return.</p> + +<p>Specific details of the syntax of using the 'noreturn' attribute can be found +in <a +href="http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html#index-g_t_0040code_007bnoreturn_007d-function-attribute-2264">GCC's +documentation</a>.</p> + +<p>Not only does the analyzer exploit this information when pruning false paths, +but the compiler also takes it seriously and will generate different code (and +possibly better optimized) under the assumption that the function does not +return.</p> + +<p><b>Example</b></p> + +<p>On Mac OS X, the function prototype for <tt>__assert_rtn</tt> (declared in +<tt>assert.h</tt>) is specifically annotated with the 'noreturn' attribute:</p> + +<pre class="code_example"> +void __assert_rtn(const char *, const char *, int, const char *) <span class="code_highlight">__attribute__((__noreturn__))</span>; +</pre> + +<h4 id="attr_analyzer_noreturn">Attribute 'analyzer_noreturn' (Clang-specific)</h4> + +<p>The Clang-specific 'analyzer_noreturn' attribute is almost identical to +'noreturn' except that it is ignored by the compiler for the purposes of code +generation.</p> + +<p>This attribute is useful for annotating assertion handlers that actually +<em>can</em> return, but for the purpose of using the analyzer we want to +pretend that such functions do not return.</p> + +<p>Because this attribute is Clang-specific, its use should be conditioned with +the use of preprocessor macros.</p> + +<p><b>Example</b> + +<pre class="code_example"> +#ifndef CLANG_ANALYZER_NORETURN +#if __has_feature(attribute_analyzer_noreturn) +<span class="code_highlight">#define CLANG_ANALYZER_NORETURN __attribute__((analyzer_noreturn))</span> +#else +#define CLANG_ANALYZER_NORETURN +#endif +#endif + +void my_assert_rtn(const char *, const char *, int, const char *) <span class="code_highlight">CLANG_ANALYZER_NORETURN</span>; +</pre> + +</div> +</div> +</body> +</html> + diff --git a/clang/www/analyzer/available_checks.html b/clang/www/analyzer/available_checks.html new file mode 100644 index 0000000..3f40d32 --- /dev/null +++ b/clang/www/analyzer/available_checks.html @@ -0,0 +1,147 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <title>Available Checks</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <script type="text/javascript" src="scripts/menu.js"></script> + <style type="text/css"> + tr:first-child { width:20%; } + </style> +</head> +<body> + +<div id="page"> +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<h1>Available Checks</h1> + +<h3>The list of the checks the analyzer performs by default</h3> +<p> +<table border="0" cellpadding="3" cellspacing="3" width="100%"> +<!-- <tr> +<th><h4>Checker Name</h4></th> +<th><h4>Description</h4></th> +</tr>--> +<tr> +<td><b>core.AdjustedReturnValue</b></td><td>Check to see if the return value of a function call is different than the caller expects (e.g., from calls through function pointers).</td> +</tr> +<tr> +<td><b>core.AttributeNonNull</b></td><td>Check for null pointers passed as arguments to a function whose arguments are marked with the 'nonnull' attribute.</td> +</tr> +<tr> +<td><b>core.CallAndMessage</b></td><td>Check for logical errors for function calls and Objective-C message expressions (e.g., uninitialized arguments, null function pointers).</td> +</tr> +<tr> +<td><b>core.DivideZero</b></td><td>Check for division by zero.</td> +</tr> +<tr> +<td><b>core.NullDereference</b></td><td>Check for dereferences of null pointers.</td> +</tr> +<tr> +<td><b>core.StackAddressEscape</b></td><td>Check that addresses to stack memory do not escape the function.</td> +</tr> +<tr> +<td><b>core.UndefinedBinaryOperatorResult</b></td><td>Check for undefined results of binary operators.</td> +</tr> +<tr> +<td><b>core.VLASize</b></td><td>Check for declarations of VLA of undefined or zero size.</td> +</tr> +<tr> +<td><b>core.builtin.BuiltinFunctions</b></td><td>Evaluate compiler builtin functions (e.g., alloca()).</td> +</tr> +<tr> +<td><b>core.builtin.NoReturnFunctions</b></td><td>Evaluate "panic" functions that are known to not return to the caller.</td> +</tr> +<tr> +<td><b>core.uninitialized.ArraySubscript</b></td><td>Check for uninitialized values used as array subscripts.</td> +</tr> +<tr> +<td><b>core.uninitialized.Assign</b></td><td>Check for assigning uninitialized values.</td> +</tr> +<tr> +<td><b>core.uninitialized.Branch</b></td><td>Check for uninitialized values used as branch conditions.</td> +</tr> +<tr> +<td><b>core.uninitialized.CapturedBlockVariable</b></td><td>Check for blocks that capture uninitialized values.</td> +</tr> +<tr> +<td><b>core.uninitialized.UndefReturn</b></td><td>Check for uninitialized values being returned to the caller.</td> +</tr> +<tr> +<td><b>deadcode.DeadStores</b></td><td>Check for values stored to variables that are never read afterwards.</td> +</tr> +<tr> +<td><b>deadcode.IdempotentOperations</b></td><td>Warn about idempotent operations.</td> +</tr> +<tr> +<td><b>osx.API</b></td><td>Check for proper uses of various Mac OS X APIs.</td> +</tr> +<tr> +<td><b>osx.AtomicCAS</b></td><td>Evaluate calls to OSAtomic functions.</td> +</tr> +<tr> +<td><b>osx.SecKeychainAPI</b></td><td>Check for proper uses of Secure Keychain APIs.</td> +</tr> +<tr> +<td><b>osx.cocoa.AtSync</b></td><td>Check for null pointers used as mutexes for @synchronized.</td> +</tr> +<tr> +<td><b>osx.cocoa.ClassRelease</b></td><td>Check for sending 'retain', 'release', or 'autorelease' directly to a Class.</td> +</tr> +<tr> +<td><b>osx.cocoa.IncompatibleMethodTypes</b></td><td>Warn about Objective-C method signatures with type incompatibilities.</td> +</tr> +<tr> +<td><b>osx.cocoa.NSAutoreleasePool</b></td><td>Warn for suboptimal uses of NSAutoreleasePool in Objective-C GC mode.</td> +</tr> +<tr> +<td><b>osx.cocoa.NSError</b></td><td>Check usage of NSError** parameters.</td> +</tr> +<tr> +<td><b>osx.cocoa.NilArg</b></td><td>Check for prohibited nil arguments to ObjC method calls.</td> +</tr> +<tr> +<td><b>osx.cocoa.RetainCount</b></td><td>Check for leaks and improper reference count management.</td> +</tr> +<tr> +<td><b>osx.cocoa.UnusedIvars</b></td><td>Warn about private ivars that are never used.</td> +</tr> +<tr> +<td><b>osx.cocoa.VariadicMethodTypes</b></td><td>Check for passing non-Objective-C types to variadic methods that expect only Objective-C types.</td> +</tr> +<tr> +<td><b>osx.coreFoundation.CFError</b></td><td>Check usage of CFErrorRef* parameters.</td> +</tr> +<tr> +<td><b>osx.coreFoundation.CFNumber</b></td><td>Check for proper uses of CFNumberCreate.</td> +</tr> +<tr> +<td><b>osx.coreFoundation.CFRetainRelease</b></td><td>Check for null arguments to CFRetain/CFRelease.</td> +</tr> +<tr> +<td><b>unix.API</b></td><td>Check calls to various UNIX/Posix functions.</td> +</tr> +</table> + +<p>In addition to these the analyzer contains numerous experimental (beta) checkers.</p> + +<h3>Writeups with examples of some of the bugs that the analyzer finds</h3> + +<ul> +<li><a href="http://www.mobileorchard.com/bug-finding-with-clang-5-resources-to-get-you-started/">Bug Finding With Clang: 5 Resources To Get You Started</a></li> +<li><a href="http://fruitstandsoftware.com/blog/index.php/2008/08/finding-memory-leaks-with-the-llvmclang-static-analyzer/#comment-2">Finding Memory Leaks With The LLVM/Clang Static Analyzer</a></li> +<li><a href="http://www.therareair.com/howto-static-analyze-your-objective-c-code-using-the-clang-static-analyzer-tool-gallery/">HOWTO: Static Analyze Your Objective-C Code Using the Clang Static Analyzer Tool Gallery</a></li> +<li><a href="http://www.rogueamoeba.com/utm/2008/07/14/the-clang-static-analyzer/">Under the Microscope - The Clang Static Analyzer</a></li> +<li><a href="http://www.mikeash.com/?page=pyblog/friday-qa-2009-03-06-using-the-clang-static-analyzer.html">Mike Ash - Using the Clang Static Analyzer</a></li> +</ul> + + +</div> +</div> +</body> +</html> + diff --git a/clang/www/analyzer/checker_dev_manual.html b/clang/www/analyzer/checker_dev_manual.html new file mode 100644 index 0000000..fc9adf3 --- /dev/null +++ b/clang/www/analyzer/checker_dev_manual.html @@ -0,0 +1,346 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <title>Checker Developer Manual</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <script type="text/javascript" src="scripts/menu.js"></script> +</head> +<body> + +<div id="page"> +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<h1 style="color:red">This Page Is Under Construction</h1> + +<h1>Checker Developer Manual</h1> + +<p>The static analyzer engine performs symbolic execution of the program and +relies on a set of checkers to implement the logic for detecting and +constructing bug reports. This page provides hints and guidelines for anyone +who is interested in implementing their own checker. The static analyzer is a +part of the Clang project, so consult <a href="http://clang.llvm.org/hacking.html">Hacking on Clang</a> +and <a href="http://llvm.org/docs/ProgrammersManual.html">LLVM Programmer's Manual</a> +for general developer guidelines and information. </p> + + <ul> + <li><a href="#start">Getting Started</a></li> + <li><a href="#analyzer">Analyzer Overview</a></li> + <li><a href="#idea">Idea for a Checker</a></li> + <li><a href="#registration">Checker Registration</a></li> + <li><a href="#skeleton">Checker Skeleton</a></li> + <li><a href="#node">Exploded Node</a></li> + <li><a href="#bugs">Bug Reports</a></li> + <li><a href="#ast">AST Visitors</a></li> + <li><a href="#testing">Testing</a></li> + <li><a href="#commands">Useful Commands</a></li> + </ul> + +<h2 id=start>Getting Started</h2> + <ul> + <li>To check out the source code and build the project, follow steps 1-4 of + the <a href="http://clang.llvm.org/get_started.html">Clang Getting Started</a> + page.</li> + + <li>The analyzer source code is located under the Clang source tree: + <br><tt> + $ <b>cd llvm/tools/clang</b> + </tt> + <br>See: <tt>include/clang/StaticAnalyzer</tt>, <tt>lib/StaticAnalyzer</tt>, + <tt>test/Analysis</tt>.</li> + + <li>The analyzer regression tests can be executed from the Clang's build + directory: + <br><tt> + $ <b>cd ../../../; cd build/tools/clang; TESTDIRS=Analysis make test</b> + </tt></li> + + <li>Analyze a file with the specified checker: + <br><tt> + $ <b>clang -cc1 -analyze -analyzer-checker=core.DivideZero test.c</b> + </tt></li> + + <li>List the available checkers: + <br><tt> + $ <b>clang -cc1 -analyzer-checker-help</b> + </tt></li> + + <li>See the analyzer help for different output formats, fine tuning, and + debug options: + <br><tt> + $ <b>clang -cc1 -help | grep "analyzer"</b> + </tt></li> + + </ul> + +<h2 id=analyzer>Static Analyzer Overview</h2> + The analyzer core performs symbolic execution of the given program. All the + input values are represented with symbolic values; further, the engine deduces + the values of all the expressions in the program based on the input symbols + and the path. The execution is path sensitive and every possible path through + the program is explored. The explored execution traces are represented with + <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1ExplodedGraph.html">ExplidedGraph</a> object. + Each node of the graph is + <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1ExplodedNode.html">ExplodedNode</a>, + which consists of a <tt>ProgramPoint</tt> and a <tt>ProgramState</tt>. + <p> + <a href="http://clang.llvm.org/doxygen/classclang_1_1ProgramPoint.html">ProgramPoint</a> + represents the corresponding location in the program (or the CFG graph). + <tt>ProgramPoint</tt> is also used to record additional information on + when/how the state was added. For example, <tt>PostPurgeDeadSymbolsKind</tt> + kind means that the state is the result of purging dead symbols - the + analyzer's equivalent of garbage collection. + <p> + <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1ProgramState.html">ProgramState</a> + represents abstract state of the program. It consists of: + <ul> + <li><tt>Environment</tt> - a mapping from source code expressions to symbolic + values + <li><tt>Store</tt> - a mapping from memory locations to symbolic values + <li><tt>GenericDataMap</tt> - constraints on symbolic values + </ul> + + <h3>Interaction with Checkers</h3> + Checkers are not merely passive receivers of the analyzer core changes - they + actively participate in the <tt>ProgramState</tt> construction through the + <tt>GenericDataMap</tt> which can be used to store the checker-defined part + of the state. Each time the analyzer engine explores a new statement, it + notifies each checker registered to listen for that statement, giving it an + opportunity to either report a bug or modify the state. (As a rule of thumb, + the checker itself should be stateless.) The checkers are called one after another + in the predefined order; thus, calling all the checkers adds a chain to the + <tt>ExplodedGraph</tt>. + + <h3>Representing Values</h3> + During symbolic execution, <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1SVal.html">SVal</a> + objects are used to represent the semantic evaluation of expressions. They can + represent things like concrete integers, symbolic values, or memory locations + (which are memory regions). They are a discriminated union of "values", + symbolic and otherwise. + <p> + <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1SymExpr.html">SymExpr</a> (symbol) + is meant to represent abstract, but named, symbolic value. + Symbolic values can have constraints associated with them. Symbols represent + an actual (immutable) value. We might not know what its specific value is, but + we can associate constraints with that value as we analyze a path. + <p> + + <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1MemRegion.html">MemRegion</a> is similar to a symbol. + It is used to provide a lexicon of how to describe abstract memory. Regions can + layer on top of other regions, providing a layered approach to representing memory. + For example, a struct object on the stack might be represented by a <tt>VarRegion</tt>, + but a <tt>FieldRegion</tt> which is a subregion of the <tt>VarRegion</tt> could + be used to represent the memory associated with a specific field of that object. + So how do we represent symbolic memory regions? That's what <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1SymbolicRegion.html">SymbolicRegion</a> + is for. It is a <tt>MemRegion</tt> that has an associated symbol. Since the + symbol is unique and has a unique name; that symbol names the region. + <p> + Let's see how the analyzer processes the expressions in the following example: + <p> + <pre class="code_example"> + int foo(int x) { + int y = x * 2; + int z = x; + ... + } + </pre> + <p> +Let's look at how <tt>x*2</tt> gets evaluated. When <tt>x</tt> is evaluated, +we first construct an <tt>SVal</tt> that represents the lvalue of <tt>x</tt>, in +this case it is an <tt>SVal</tt> that references the <tt>MemRegion</tt> for <tt>x</tt>. +Afterwards, when we do the lvalue-to-rvalue conversion, we get a new <tt>SVal</tt>, +which references the value <b>currently bound</b> to <tt>x</tt>. That value is +symbolic; it's whatever <tt>x</tt> was bound to at the start of the function. +Let's call that symbol <tt>$0</tt>. Similarly, we evaluate the expression for <tt>2</tt>, +and get an <tt>SVal</tt> that references the concrete number <tt>2</tt>. When +we evaluate <tt>x*2</tt>, we take the two <tt>SVals</tt> of the subexpressions, +and create a new <tt>SVal</tt> that represents their multiplication (which in +this case is a new symbolic expression, which we might call <tt>$1</tt>). When we +evaluate the assignment to <tt>y</tt>, we again compute its lvalue (a <tt>MemRegion</tt>), +and then bind the <tt>SVal</tt> for the RHS (which references the symbolic value <tt>$1</tt>) +to the <tt>MemRegion</tt> in the symbolic store. +<br> +The second line is similar. When we evaluate <tt>x</tt> again, we do the same +dance, and create an <tt>SVal</tt> that references the symbol <tt>$0</tt>. Note, two <tt>SVals</tt> +might reference the same underlying values. + +<p> +To summarize, MemRegions are unique names for blocks of memory. Symbols are +unique names for abstract symbolic values. Some MemRegions represents abstract +symbolic chunks of memory, and thus are also based on symbols. SVals are just +references to values, and can reference either MemRegions, Symbols, or concrete +values (e.g., the number 1). + + <!-- + TODO: Add a picture. + <br> + Symbols<br> + FunctionalObjects are used throughout. + --> +<h2 id=idea>Idea for a Checker</h2> + Here are several questions which you should consider when evaluating your + checker idea: + <ul> + <li>Can the check be effectively implemented without path-sensitive + analysis? See <a href="#ast">AST Visitors</a>.</li> + + <li>How high the false positive rate is going to be? Looking at the occurrences + of the issue you want to write a checker for in the existing code bases might + give you some ideas. </li> + + <li>How the current limitations of the analysis will effect the false alarm + rate? Currently, the analyzer only reasons about one procedure at a time (no + inter-procedural analysis). Also, it uses a simple range tracking based + solver to model symbolic execution.</li> + + <li>Consult the <a + href="http://llvm.org/bugs/buglist.cgi?query_format=advanced&bug_status=NEW&bug_status=REOPENED&version=trunk&component=Static%20Analyzer&product=clang">Bugzilla database</a> + to get some ideas for new checkers and consider starting with improving/fixing + bugs in the existing checkers.</li> + </ul> + +<h2 id=registration>Checker Registration</h2> + All checker implementation files are located in <tt>clang/lib/StaticAnalyzer/Checkers</tt> + folder. Follow the steps below to register a new checker with the analyzer. +<ol> + <li>Create a new checker implementation file, for example <tt>./lib/StaticAnalyzer/Checkers/NewChecker.cpp</tt> +<pre class="code_example"> +using namespace clang; +using namespace ento; + +namespace { +class NewChecker: public Checker< check::PreStmt<CallExpr> > { +public: + void checkPreStmt(const CallExpr *CE, CheckerContext &Ctx) const {} +} +} +void ento::registerNewChecker(CheckerManager &mgr) { + mgr.registerChecker<NewChecker>(); +} +</pre> + +<li>Pick the package name for your checker and add the registration code to +<tt>./lib/StaticAnalyzer/Checkers/Checkers.td</tt>. Note, all checkers should +first be developed as experimental. Suppose our new checker performs security +related checks, then we should add the following lines under +<tt>SecurityExperimental</tt> package: +<pre class="code_example"> +let ParentPackage = SecurityExperimental in { +... +def NewChecker : Checker<"NewChecker">, + HelpText<"This text should give a short description of the checks performed.">, + DescFile<"NewChecker.cpp">; +... +} // end "security.experimental" +</pre> + +<li>Make the source code file visible to CMake by adding it to +<tt>./lib/StaticAnalyzer/Checkers/CMakeLists.txt</tt>. + +<li>Compile and see your checker in the list of available checkers by running:<br> +<tt><b>$clang -cc1 -analyzer-checker-help</b></tt> +</ol> + + +<h2 id=skeleton>Checker Skeleton</h2> + There are two main decisions you need to make: + <ul> + <li> Which events the checker should be tracking. + See <a href="http://clang.llvm.org/doxygen/classento_1_1CheckerDocumentation.html">CheckerDocumentation</a> + for the list of available checker callbacks.</li> + <li> What data you want to store as part of the checker-specific program + state. Try to minimize the checker state as much as possible. </li> + </ul> + +<h2 id=bugs>Bug Reports</h2> + +<h2 id=ast>AST Visitors</h2> + Some checks might not require path-sensitivity to be effective. Simple AST walk + might be sufficient. If that is the case, consider implementing a Clang + compiler warning. On the other hand, a check might not be acceptable as a compiler + warning; for example, because of a relatively high false positive rate. In this + situation, AST callbacks <tt><b>checkASTDecl</b></tt> and + <tt><b>checkASTCodeBody</b></tt> are your best friends. + +<h2 id=testing>Testing</h2> + Every patch should be well tested with Clang regression tests. The checker tests + live in <tt>clang/test/Analysis</tt> folder. To run all of the analyzer tests, + execute the following from the <tt>clang</tt> build directory: + <pre class="code"> + $ <b>TESTDIRS=Analysis make test</b> + </pre> + +<h2 id=commands>Useful Commands/Debugging Hints</h2> +<ul> +<li> +While investigating a checker-related issue, instruct the analyzer to only +execute a single checker: +<br><tt> +$ <b>clang -cc1 -analyze -analyzer-checker=osx.KeychainAPI test.c</b> +</tt> +</li> +<li> +To dump AST: +<br><tt> +$ <b>clang -cc1 -ast-dump test.c</b> +</tt> +</li> +<li> +To view/dump CFG use <tt>debug.ViewCFG</tt> or <tt>debug.DumpCFG</tt> checkers: +<br><tt> +$ <b>clang -cc1 -analyze -analyzer-checker=debug.ViewCFG test.c</b> +</tt> +</li> +<li> +To see all available debug checkers: +<br><tt> +$ <b>clang -cc1 -analyzer-checker-help | grep "debug"</b> +</tt> +</li> +<li> +To see which function is failing while processing a large file use +<tt>-analyzer-display-progress</tt> option. +</li> +<li> +While debugging execute <tt>clang -cc1 -analyze -analyzer-checker=core</tt> +instead of <tt>clang --analyze</tt>, as the later would call the compiler +in a separate process. +</li> +<li> +To view <tt>ExplodedGraph</tt> (the state graph explored by the analyzer) while +debugging, goto a frame that has <tt>clang::ento::ExprEngine</tt> object and +execute: +<br><tt> +(gdb) <b>p ViewGraph(0)</b> +</tt> +</li> +<li> +To see the <tt>ProgramState</tt> while debugging use the following command. +<br><tt> +(gdb) <b>p State->dump()</b> +</tt> +</li> +<li> +To see <tt>clang::Expr</tt> while debugging use the following command. If you +pass in a SourceManager object, it will also dump the corresponding line in the +source code. +<br><tt> +(gdb) <b>p E->dump()</b> +</tt> +</li> +<li> +To dump AST of a method that the current <tt>ExplodedNode</tt> belongs to: +<br><tt> +(gdb) <b>p C.getPredecessor()->getCodeDecl().getBody()->dump()</b> +(gdb) <b>p C.getPredecessor()->getCodeDecl().getBody()->dump(getContext().getSourceManager())</b> +</tt> +</li> +</ul> + +</div> +</div> +</body> +</html> diff --git a/clang/www/analyzer/content.css b/clang/www/analyzer/content.css new file mode 100644 index 0000000..b22cca9 --- /dev/null +++ b/clang/www/analyzer/content.css @@ -0,0 +1,79 @@ +html { margin: 0px; } body { margin: 8px; } + +html, body { + padding:0px; + margin:0px; + font-size:small; font-family:"Lucida Grande", "Lucida Sans Unicode", Arial, Verdana, Helvetica, sans-serif; background-color: #fff; color: #222; + line-height:1.5; + background-color: #808080; + +} + +h1, h2, h3, tt { color: #000 } + +h1 { padding-top:0px; margin-top:0px;} +h2 { color:#333333; padding-top:0.5em; } +h3 { padding-top: 0.5em; margin-bottom: -0.25em; color:#2d58b7 } +h4 { color:#2d58b7 } +li { padding-bottom: 0.5em } +ul { padding-left:1.5em; } + +.command { font-weight:bold } +.code_highlight { font-weight:bold; color:#2d58b7 } +.code_example { border-width:1px; border-style:solid; border-color:#cccccc; + background-color:#eeeeee; padding:10px } + +/* Slides */ +IMG.img_slide { + display: block; + margin-left: auto; + margin-right: auto +} + +#page { width:930px; text-align: left; margin: 0 auto; padding:0; + background-color: white; height:100%; + border-left: 1px solid #EBF0FA; +} + +#content { + clear: left; + padding: 1em 2em 0 2em; + background-color: #ffffff; +} + +.itemTitle { color:#2d58b7 } + + +/* Tables */ +tr { vertical-align:top } + +table.options thead { + background-color:#eee; color:#666666; + font-weight: bold; cursor: default; + text-align:left; + border-top: 2px solid #cccccc; + border-bottom: 2px solid #cccccc; + font-weight: bold; font-family: Verdana +} +table.options { border: 1px #cccccc solid } +table.options { border-collapse: collapse; border-spacing: 0px } +table.options { margin-left:0px; margin-top:20px; margin-bottom:20px } +table.options td { border-bottom: 1px #cccccc dotted } +table.options td { padding:5px; padding-left:8px; padding-right:8px } +table.options td { text-align:left; font-size:9pt } + +/* Collapsing Trees: http://dbtree.megalingo.com/web/demo/simple-collapsible-tree.cfm */ +#collapsetree, #collapsetree a:link, #collapsetree li a:link, #collapsetree a:visited, #collapsetree li a:visited{color:#000;text-decoration:none} +#collapsetree,#collapsetree ul{list-style-type:none; width:auto; margin:0; padding:0} +#collapsetree ul{padding-left:20px;display:none;overflow:auto} +#collapsetree li ul{margin:0 auto} +#collapsetree li{display:block;width:100%;line-height:20px;white-space:nowrap} +#collapsetree li a{display:block;padding-left:20px;color:#000;text-decoration:none;background:url(images/tree/bullet.gif) center left no-repeat;white-space:nowrap} +#collapsetree li a:hover{text-decoration:underline;background-color:transparent;color:#000} +#collapsetree li ul.click{display:block} +#collapsetree li.click a{background:url(images/tree/bullet.gif) center left no-repeat} +#collapsetree ul li.click a{background:url(images/tree/bullet.gif) center left no-repeat} +#collapsetree li a.subMenu,#collapsetree ul li a.subMenu{background:url(images/tree/plus.gif) center left no-repeat} +#collapsetree li a.click{background:url(images/tree/minus.gif) center left no-repeat} +#collapsetree ul li a.click{background:url(images/tree/minus.gif) center left no-repeat} + diff --git a/clang/www/analyzer/dev_cxx.html b/clang/www/analyzer/dev_cxx.html new file mode 100644 index 0000000..39dbf7b --- /dev/null +++ b/clang/www/analyzer/dev_cxx.html @@ -0,0 +1,54 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <title>Analyzer Development: C++ Support</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <script type="text/javascript" src="scripts/menu.js"></script> +</head> +<body> + +<div id="page"> +<!--#include virtual="menu.html.incl"--> +<div id="content"> + +<h1>C++ Support</h1> + +<p>The Clang frontend +now <a href="http://clang.llvm.org/cxx_status.html">supports the +majority of C++</a>. Support in the frontend for C++ language +features, however, does not automatically translate into support for +those features in the static analyzer. Language features need to be +specifically modeled in the static analyzer so their semantics can be +properly analyzed. Support for analyzing C++ and Objective-C++ files +is currently extremely limited, and we are only encouraging those who +are interested in contributing to the development of the analyzer to +try this functionality out at this time.</p> + +<p>Listed here are a set of open tasks that are prerequisites for +decent analysis of C++. This list is also not complete; new tasks +will be added as deemed necessary.</p> + +<ul> + <li>Control-Flow Graph Enhancements: + <ul> + <li>Model C++ destructors</li> + <li>Model C++ initializers (in constructors)</li> + </ul> + </li> + <li>Path-Sensitive Analysis Engine (GRExprEngine): + <ul> + <li>Model C++ casts</li> + <li>Model C++ constructors</li> + <li>Model C++ destructors</li> + <li>Model <tt>new</tt> and <tt>delete</tt></li> + </ul> + </li> +</ul> + +</div> +</div> +</body> +</html> + diff --git a/clang/www/analyzer/filing_bugs.html b/clang/www/analyzer/filing_bugs.html new file mode 100644 index 0000000..f32a8ab --- /dev/null +++ b/clang/www/analyzer/filing_bugs.html @@ -0,0 +1,62 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <title>Filing Bugs and Feature Requests</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <script type="text/javascript" src="scripts/menu.js"></script> +</head> +<body> + +<div id="page"> +<!--#include virtual="menu.html.incl"--> +<div id="content"> + +<h1>Filing Bugs and Feature Requests</h1> + +<p>We encourage users to file bug reports for any problems that they encounter. +We also welcome feature requests. When filing a bug report, please do the +following:</p> + +<ul> + +<li>Include the checker build (for prebuilt Mac OS X binaries) or the SVN +revision number.</li> + +<li>Provide a self-contained, reduced test case that exhibits the issue you are +experiencing.</li> + +<li>Test cases don't tell us everything. Please briefly describe the problem you +are seeing, including what you thought should have been the expected behavior +and why.</li> + +</ul> + +<h2>Outside of Apple</h2> + +<h3>Bugzilla</h3> + +<p>Please <a href="http://llvm.org/bugs/enter_bug.cgi?product=clang">file +bugs</a> in LLVM's Bugzilla database against the Clang <b>Static Analyzer</b> +component.</p> + +<h3>Bugreporter.apple.com</h3> + +<p>If you are using the analyzer to analyze code associated with an Apple NDA +(e.g., preview versions of SDKs or seed releases of Mac OS X) please file bug +reports to Apple's <a href="http://bugreporter.apple.com">Bug Reporter</a> web +site.</p> + +<p>You are free to always file bugs through this website, but this option is less +attractive than filing bug reports through Bugzilla as not everyone who works on +the analyzer has access to that bug database.</p> + +<h2>Apple-internal Users</h2> + +<p>Please file bugs in Radar against the <b>clang - static analyzer</b> component.</p> +</div> +</div> +</body> +</html> + diff --git a/clang/www/analyzer/images/analyzer_html.png b/clang/www/analyzer/images/analyzer_html.png Binary files differnew file mode 100644 index 0000000..607ea18 --- /dev/null +++ b/clang/www/analyzer/images/analyzer_html.png diff --git a/clang/www/analyzer/images/analyzer_xcode.png b/clang/www/analyzer/images/analyzer_xcode.png Binary files differnew file mode 100644 index 0000000..84c6980 --- /dev/null +++ b/clang/www/analyzer/images/analyzer_xcode.png diff --git a/clang/www/analyzer/images/example_attribute_nonnull.png b/clang/www/analyzer/images/example_attribute_nonnull.png Binary files differnew file mode 100644 index 0000000..919af61 --- /dev/null +++ b/clang/www/analyzer/images/example_attribute_nonnull.png diff --git a/clang/www/analyzer/images/example_cf_returns_retained.png b/clang/www/analyzer/images/example_cf_returns_retained.png Binary files differnew file mode 100644 index 0000000..4bee499 --- /dev/null +++ b/clang/www/analyzer/images/example_cf_returns_retained.png diff --git a/clang/www/analyzer/images/example_cf_returns_retained_gc.png b/clang/www/analyzer/images/example_cf_returns_retained_gc.png Binary files differnew file mode 100644 index 0000000..023f1a2 --- /dev/null +++ b/clang/www/analyzer/images/example_cf_returns_retained_gc.png diff --git a/clang/www/analyzer/images/example_ns_returns_retained.png b/clang/www/analyzer/images/example_ns_returns_retained.png Binary files differnew file mode 100644 index 0000000..61316e1 --- /dev/null +++ b/clang/www/analyzer/images/example_ns_returns_retained.png diff --git a/clang/www/analyzer/images/scan_build_cmd.png b/clang/www/analyzer/images/scan_build_cmd.png Binary files differnew file mode 100644 index 0000000..464fd4e --- /dev/null +++ b/clang/www/analyzer/images/scan_build_cmd.png diff --git a/clang/www/analyzer/images/tree/bullet.gif b/clang/www/analyzer/images/tree/bullet.gif Binary files differnew file mode 100644 index 0000000..de15348 --- /dev/null +++ b/clang/www/analyzer/images/tree/bullet.gif diff --git a/clang/www/analyzer/images/tree/minus.gif b/clang/www/analyzer/images/tree/minus.gif Binary files differnew file mode 100644 index 0000000..225f40d --- /dev/null +++ b/clang/www/analyzer/images/tree/minus.gif diff --git a/clang/www/analyzer/images/tree/plus.gif b/clang/www/analyzer/images/tree/plus.gif Binary files differnew file mode 100644 index 0000000..5398c80 --- /dev/null +++ b/clang/www/analyzer/images/tree/plus.gif diff --git a/clang/www/analyzer/index.html b/clang/www/analyzer/index.html new file mode 100644 index 0000000..18bafd0 --- /dev/null +++ b/clang/www/analyzer/index.html @@ -0,0 +1,224 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <title>Clang Static Analyzer</title> + <link type="text/css" rel="stylesheet" href="content.css"> + <link type="text/css" rel="stylesheet" href="menu.css"> + <script type="text/javascript" src="scripts/menu.js"></script> + <!-- Generated from: http://www.spiffycorners.com/index.php --> + +<style type="text/css"> +.spiffy{display:block} +.spiffy *{ + display:block; + height:1px; + overflow:hidden; + font-size:.01em; + background:#EBF0FA} +.spiffy1{ + margin-left:3px; + margin-right:3px; + padding-left:1px; + padding-right:1px; + border-left:1px solid #f6f8fc; + border-right:1px solid #f6f8fc; + background:#f0f3fb} +.spiffy2{ + margin-left:1px; + margin-right:1px; + padding-right:1px; + padding-left:1px; + border-left:1px solid #fdfdfe; + border-right:1px solid #fdfdfe; + background:#eef2fa} +.spiffy3{ + margin-left:1px; + margin-right:1px; + border-left:1px solid #eef2fa; + border-right:1px solid #eef2fa;} +.spiffy4{ + border-left:1px solid #f6f8fc; + border-right:1px solid #f6f8fc} +.spiffy5{ + border-left:1px solid #f0f3fb; + border-right:1px solid #f0f3fb} +.spiffyfg{ + background:#EBF0FA} + +.spiffyfg h2 { + margin:0px; padding:10px; +} + + #left { float:left; } + #left h2 { margin:1px; padding-top:0px; } + #right { float:left; margin-left:20px; margin-right:20px; padding:0px ;} + #right h2 { padding:0px; margin:0px; } + #wrappedcontent { padding:15px;} +</style> +</head> +<body> + +<div id="page"> +<!--#include virtual="menu.html.incl"--> +<div id="content"> + + +<table style="margin-top:0px" width="100%" border="0" cellpadding="0px" cellspacing="0"> +<tr><td> + +<h1>Clang Static Analyzer</h1> + +<p>The Clang Static Analyzer is source code analysis tool that find bugs in C +and Objective-C programs.</p> + +<p>Currently it can be run either as a <a href="/scan-build.html">standalone +tool</a> or <a href="/xcode.html">within Xcode</a>. The standalone tool is +invoked from the command-line, and is intended to be run in tandem with a build +of a codebase.</p> + +<p>The analyzer is 100% open source and is part of the <a +href="http://clang.llvm.org">Clang</a> project. Like the rest of Clang, the +analyzer is implemented as a C++ library that can be used by other tools and +applications.</p> + +<h2>Download</h2> + +<div style="padding:0px; font-size: 90%"> + <b class="spiffy"> + <b class="spiffy1"><b></b></b> + <b class="spiffy2"><b></b></b> + <b class="spiffy3"></b> + <b class="spiffy4"></b> + <b class="spiffy5"></b></b> + <div class="spiffyfg"> + <div style="padding:15px"> + <h3 style="margin:0px;padding:0px">Mac OS X</h3> + <ul> + <li>Latest build (Intel-only binary, 10.5+):<br> + <!--#include virtual="latest_checker.html.incl"--> + </li> + <li><a href="/release_notes.html">Release notes</a></li> + <li>This build can be used both from the command line and from within Xcode</li> + <li><a href="/installation.html">Installation</a> and <a href="/scan-build.html">usage</a></li> + </ul> + </div> + </div> + <b class="spiffy"> + <b class="spiffy5"></b> + <b class="spiffy4"></b> + <b class="spiffy3"></b> + <b class="spiffy2"><b></b></b> + <b class="spiffy1"><b></b></b></b> +</div> + +<div style="padding:0; margin-top:10px; font-size: 90%"> + <b class="spiffy"> + <b class="spiffy1"><b></b></b> + <b class="spiffy2"><b></b></b> + <b class="spiffy3"></b> + <b class="spiffy4"></b> + <b class="spiffy5"></b></b> + <div class="spiffyfg"> + <div style="padding:15px"> + <h3 style="margin:0px;padding:0px">Other Platforms</h3> + <p>For other platforms, please follow the instructions for <a + href="/installation#OtherPlatforms">building the analyzer</a> from + source code.<p> + </div> + </div> + <b class="spiffy"> + <b class="spiffy5"></b> + <b class="spiffy4"></b> + <b class="spiffy3"></b> + <b class="spiffy2"><b></b></b> + <b class="spiffy1"><b></b></b></b> +</div> + + +</td><td style="padding-left:10px"> +<a href="images/analyzer_xcode.png"><img src="images/analyzer_xcode.png" width="450" alt="analyzer in xcode"></a> +<div style="text-align:center"><b>Viewing static analyzer results in Xcode 3.2</b></div> +<a href="images/analyzer_html.png"><img src="images/analyzer_html.png" width="450" alt="analyzer in browser"></a> +<div style="text-align:center"><b>Viewing static analyzer results in a web browser</b></div> +</td></tr></table> + +<h2 id="StaticAnalysis">What is Static Analysis?</h2> + +<p>The term "static analysis" is conflated, but here we use it to mean +a collection of algorithms and techniques used to analyze source code in order +to automatically find bugs. The idea is similar in spirit to compiler warnings +(which can be useful for finding coding errors) but to take that idea a step +further and find bugs that are traditionally found using run-time debugging +techniques such as testing.</p> + +<p>Static analysis bug-finding tools have evolved over the last several decades +from basic syntactic checkers to those that find deep bugs by reasoning about +the semantics of code. The goal of the Clang Static Analyzer is to provide a +industrial-quality static analysis framework for analyzing C and Objective-C +programs that is freely available, extensible, and has a high quality of +implementation.</p> + +<h3 id="Clang">Part of Clang and LLVM</h3> + +<p>As its name implies, the Clang Static Analyzer is built on top of <a +href="http://clang.llvm.org">Clang</a> and <a href="http://llvm.org">LLVM</a>. +Strictly speaking, the analyzer is part of Clang, as Clang consists of a set of +reusable C++ libraries for building powerful source-level tools. The static +analysis engine used by the Clang Static Analyzer is a Clang library, and has +the capability to be reused in different contexts and by different clients.</p> + +<h2>Important Points to Consider</h2> + +<p>While we believe that the static analyzer is already very useful for finding +bugs, we ask you to bear in mind a few points when using it.</p> + +<h3>Work-in-Progress</h3> + +<p>The analyzer is a continuous work-in-progress. +There are many planned enhancements to improve both the precision and scope of +its analysis algorithms as well as the kinds bugs it will find. While there are +fundamental limitations to what static analysis can do, we have a long way to go +before hitting that wall.</p> + +<h3>Slower than Compilation</h3> + +<p>Operationally, using static analysis to +automatically find deep program bugs is about trading CPU time for the hardening +of code. Because of the deep analysis performed by state-of-the-art static +analysis tools, static analysis can be much slower than compilation.</p> + +<p>While the Clang Static Analyzer is being designed to be as fast and +light-weight as possible, please do not expect it to be as fast as compiling a +program (even with optimizations enabled). Some of the algorithms needed to find +bugs require in the worst case exponential time.</p> + +<p>The Clang Static Analyzer runs in a reasonable amount of time by both +bounding the amount of checking work it will do as well as using clever +algorithms to reduce the amount of work it must do to find bugs.</p> + +<h3>False Positives</h3> + +<p>Static analysis is not perfect. It can falsely flag bugs in a program where +the code behaves correctly. Because some code checks require more analysis +precision than others, the frequency of false positives can vary widely between +different checks. Our long-term goal is to have the analyzer have a low false +positive rate for most code on all checks.</p> + +<p>Please help us in this endeavor by <a href="filing_bugs.html">reporting false +positives</a>. False positives cannot be addressed unless we know about +them.</p> + +<h3>More Checks</h3> + +<p>Static analysis is not magic; a static analyzer can only find bugs that it +has been specifically engineered to find. If there are specific kinds of bugs +you would like the Clang Static Analyzer to find, please feel free to +file <a href="filing_bugs.html">feature requests</a> or contribute your own +patches.</p> + +</div> +</div> +</body> +</html> + diff --git a/clang/www/analyzer/installation.html b/clang/www/analyzer/installation.html new file mode 100644 index 0000000..ebccd07 --- /dev/null +++ b/clang/www/analyzer/installation.html @@ -0,0 +1,114 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <title>Obtaining the Static Analyzer</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <script type="text/javascript" src="scripts/menu.js"></script> +</head> +<body> + +<div id="page"> +<!--#include virtual="menu.html.incl"--> +<div id="content"> + +<h1>Obtaining the Static Analyzer</h1> + +<p>This page describes how to download and install the analyzer. Once +the analyzer is installed, follow the <a +href="/scan-build.html">instructions</a> on using <tt>scan-build</tt> to +get started analyzing your code.</p> + +<h2>Packaged Builds (Mac OS X)</h2> + +<p>Semi-regular pre-built binaries of the analyzer are available on Mac +OS X. These are built to run on Mac OS 10.5 and later.</p> + +<p>Builds are released frequently. Often the differences between build +numbers being a few bug fixes or minor feature improvements. When using +the analyzer, we recommend that you check back here occasionally for new +builds, especially if the build you are using is more than a couple +weeks old.</p> + +<p>The latest build is: + <!--#include virtual="latest_checker.html.incl"--> +</p> + +<p>Packaged builds for other platforms may eventually be provided, but +we need volunteers who are willing to help provide such regular builds. +If you wish to help contribute regular builds of the analyzer on other +platforms, please email the <a +href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-dev">Clang +Developers' mailing list</a>.</p> + +<h3>Using Packaged Builds</h3> + +<p>To use a package build, simply unpack it anywhere. If the build +archive has the name <b><tt>checker-XXX.tar.bz2</tt></b> then the +archive will expand to a directory called <b><tt>checker-XXX</tt></b>. +You do not need to place this directory or the contents of this +directory in any special place. Uninstalling the analyzer is as simple +as deleting this directory.</p> + +<p>Most of the files in the <b><tt>checker-XXX</tt></b> directory will +be supporting files for the analyzer that you can simply ignore. Most +users will only care about two files, which are located at the top of +the <b><tt>checker-XXX</tt></b> directory:</p> + +<ul> +<li><b>scan-build</b>: <tt>scan-build</tt> is the high-level command line utility for running the analyzer</li> +<li><b>scan-view</b>: <tt>scan-view</tt> a companion comannd line +utility to <tt>scan-build</tt>, <tt>scan-view</tt> is used to view +analysis results generated by <tt>scan-build</tt>. There is an option +that one can pass to <tt>scan-build</tt> to cause <tt>scan-view</tt> to +run as soon as it the analysis of a build completes</li> +</ul> + +<h4>Running scan-build</h4> + +<p>For specific details on using <tt>scan-build</tt>, please see +<tt>scan-build</tt>'s <a href="/scan-build">documentation</a>.</p> + +<p>To run <tt>scan-build</tt>, either add the +<b><tt>checker-XXX</tt></b> directory to your path or specify a complete +path for <tt>scan-build</tt> when running it. It is also possible to use +a symbolic link to <tt>scan-build</tt>, such one located in a directory +in your path. When <tt>scan-build</tt> runs it will automatically +determine where to find its accompanying files.</p> + +<h2 id="OtherPlatforms">Other Platforms (Building the Analyzer from Source)</h2> + +<p>For other platforms, you must build Clang and LLVM manually. To do +so, please follow the instructions for <a +href="http://clang.llvm.org/get_started.html#build">building Clang from +source code</a>.<p> + +<p>Once the Clang is built, you need to add the following to your path:</p> + +<ul> + +<li>The location of the <tt>clang</tt> binary. + +<p>For example, if you built a <em>Debug+Asserts</em> build of LLVM/Clang (the +default), the resultant <tt>clang</tt> binary will be in <tt>$(OBJDIR)/Debug+Asserts/bin</tt> +(where <tt>$(OBJDIR)</tt> is often the same as the root source directory). You +can also do <tt>make install</tt> to install the LLVM/Clang libaries and +binaries to the installation directory of your choice (specified when you run +<tt>configure</tt>).</p></li> + +<li>The locations of the <tt>scan-build</tt> and <tt>scan-view</tt> +programs. + +<p>Currently these are not installed using <tt>make install</tt>, and +are located in <tt>$(SRCDIR)/tools/clang/tools/scan-build</tt> and +<tt>$(SRCDIR)/tools/clang/tools/scan-view</tt> respectively (where +<tt>$(SRCDIR)</tt> is the root LLVM source directory). These locations +are subject to change.</p></li> + +</ul> +</div> +</div> +</body> +</html> + diff --git a/clang/www/analyzer/latest_checker.html.incl b/clang/www/analyzer/latest_checker.html.incl new file mode 100644 index 0000000..d1b0d06 --- /dev/null +++ b/clang/www/analyzer/latest_checker.html.incl @@ -0,0 +1 @@ +<b><a href="http://bit.ly/GUmtVB">checker-263.tar.bz2</a></b> (built March 22, 2012) diff --git a/clang/www/analyzer/menu.css b/clang/www/analyzer/menu.css new file mode 100644 index 0000000..05c1bbf --- /dev/null +++ b/clang/www/analyzer/menu.css @@ -0,0 +1,52 @@ +/* From 'A list apart', 'dropdowns' */ + +#nav { + clear: left; + margin:0; + padding:0; + font-weight: bold; + width:100%; + background-color: #EBF0FA; + border-bottom: 1px solid; + font-size: 80%; +} +#nav a { + text-decoration: none; +} +#nav a:hover { + text-decoration: underline; +} +.menubar ul { + list-style: none inside; +} +.menubar li { + margin: 0; + padding: 5px; + text-align: left; + text-indent: 0px; + list-style-position: inside; + list-style:none; + float: left; + position: relative; + width: 13em; + cursor: default; + background-color: #EBF0FA; +} +.menubar li ul /* second level lists */ { + display: none; + position: absolute; + left: 0; +} +.menubar li>ul { + border-left: 1px solid; + border-right: 1px solid; + border-bottom: 1px solid; + padding: 0; + margin: 5px 0; + left:auto; + font-weight: normal; +} +.menubar li:hover ul, li.over ul { /* lists nested under hovered list items */ + display: block; +} + diff --git a/clang/www/analyzer/menu.html.incl b/clang/www/analyzer/menu.html.incl new file mode 100644 index 0000000..53a4276 --- /dev/null +++ b/clang/www/analyzer/menu.html.incl @@ -0,0 +1,41 @@ +<table width="100%" id="nav" cellspacing=0 cellpadding=0> +<tr><td> +<ul style="margin:0; padding:0" class="menubar"> +<li style="padding-left:5em"> + <a href="/index.html">About</a> + <ul class="menubar"> + <li><a href="/index.html">About the Analyzer</a></li> + <li><a href="http://llvm.org/">LLVM Project</a></li> + <li><a href="http://clang.llvm.org/">Clang Project</a></li> + </ul> +</li> +<li> + <a href="/filing_bugs.html">Filing Bugs</a> +</li> +<li> + User Manual + <ul> + <li><a href="/installation.html">Obtaining the Analyzer</a></li> + <li><a href="/scan-build.html">Command line usage</a></li> + <li><a href="/xcode.html">Using within Xcode</a></li> + <li><a href="/available_checks.html">Available Checks</a></li> + <li><a href="/annotations.html">Source-level Annotations</a></li> + </ul> +</li> +<li> + Development + <ul> + <li><a href="/checker_dev_manual.html">Checker Developer Manual</a></li> + <li><a href="/dev_cxx.html">Analysis support for C++</a></li> + </ul> +</li> +<li> + Mailing Lists + <ul> + <li><a href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-dev">cfe-dev</a></li> + <li><a href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits">cfe-commits</a></li> + </ul> +</li> +</ul> +</td></tr> +</table> diff --git a/clang/www/analyzer/release_notes.html b/clang/www/analyzer/release_notes.html new file mode 100644 index 0000000..42de9dd --- /dev/null +++ b/clang/www/analyzer/release_notes.html @@ -0,0 +1,188 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <title>Release notes for checker-XXX builds</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <script type="text/javascript" src="scripts/menu.js"></script> +</head> +<body> + +<div id="page"> +<!--#include virtual="menu.html.incl"--> +<div id="content"> + +<h1>Release notes for <tt>checker-XXX</tt> builds</h1> + +<h4 id="checker_263">checker-263</h4> + +<p><b>built:</b> March 22, 2012</br> + <b>download:</b> <a href="http://bit.ly/GUmtVB">checker-263.tar.bz2</a></p> +<p><b>highlights:</b></p> + +<ul> +<li>Fixes several serious bugs with inter-procedural analysis, including a case where retain/releases would be "double-counted".</li> +</ul> + +<h4 id="checker_262">checker-262</h4> + +<p><b>built: </b>March 15, 2012</br> + <b>download:</b> <a href="http://bit.ly/xETQF0">checker-262.tar.bz2</a></p> +<p><b>highlights:</b></p> + +<ul> + <li>Enables experimental interprocedural analysis (within a file), which greatly amplifies the analyzer's ability to find issues.</li> + <li>Many bug fixes to the malloc/free checker.</li> + <li>Support for new Objective-C NSArray/NSDictionary/NSNumber literals syntax, and Objective-C container subscripting.</li> +</ul> + +<p>NOTE: This build contains new interprocedural analysis that allows the analyzer to find more complicated bugs that span function boundaries. It may have problems, performance issues, etc. We'd like to <a href="/filing_bugs.html">hear about them</a>. + +<h4 id="checker_261">checker-261</h4> + +<p><b>built: </b>February 22, 2012<br> +<b>download:</b> <a href="http://bit.ly/yN1Awv">checker-261.tar.bz2</a></p> +<p><b>highlights:</b></p> + +<ul> + <li>Contains a new experimental malloc/free checker.</li> + <li>Better support for projects using ARC.</li> + <li>Warns about null pointers passed as arguments to C string functions.</li> + <li>Warns about common anti-patterns in 'strncat' size argument, which can lead to buffer overflows.</li> + <li>set-xcode-analyzer now supports self-contained Xcode.app (Xcode 4.3 and later).</li> + <li>Contains a newer version of the analyzer than Xcode 4.3.</li> + <li>Misc. bug fixes and performance work.</li> +</ul> + +<h4 id="checker_260">checker-260</h4> + +<p><b>built: </b>January 25, 2012<br> +<b>download:</b> <a href="http://bit.ly/wpAqVP">checker-260.tar.bz2</a></p> +<p><b>highlights:</b></p> + +<p>This is essentially the same as checker-259, but enables the following <i>experimental</i> checkers (please provide feedback):</p> + +<ul> + <li>Warns about unsafe uses of CFArrayCreate, CFSetCreate, and CFDictionaryCreate</li> + <li>Warns about unsafe uses of getpw, gets, which are sources of buffer overflows</li> + <li>Warns about unsafe uses of mktemp and mktemps, which can lead to insecure temporary files</li> + <li>Warns about unsafe uses of vfork, which is <a href="https://www.securecoding.cert.org/confluence/display/seccode/POS33-C.+Do+not+use+vfork()">insecure</a> to use</li> + <li>Warns about not checking the return values of setuid, setgid, seteuid, setegid, setreuid, setregid (another security issue)</li> +</ul> + +<h4 id="checker_259">checker-259</h4> + +<p><b>built: </b>January 25, 2012<br> +<b>download:</b> <a href="http://bit.ly/zOWf1P">checker-259.tar.bz2</a></p> +<p><b>highlights:</b></p> + +<ul> + <li>Contains a newer version of the analyzer than the one shipped in Xcode 4.2.</li> + <li>Significant performance optimizations to reduce memory usage of the analyzer.</li> + <li>Tweaks to scan-build to have it work more easily with Xcode projects using Clang.</li> + <li>Numerous bug fixes to better support code using ARC.</li> +</ul> + +<h4 id="checker_258">checker-258</h4> + +<p><b>built: </b>October 13, 2011<br> +<p><b>highlights:</b></p> + +<ul> + <li>Contains a newer version of the analyzer than the one shipped in Xcode 4.2.</li> + <li>Adds a new security checker for looking at correct uses of the Mac OS KeyChain API.</li> + <li>Supports ARC (please file bugs where you see issues)</li> + <li>Major under-the-cover changes. This should result in more precise results in some cases, but this is laying the groundwork for major improvements. Please file bugs where you see regressions or issues.</li> +</ul> + +<h4 id="checker_257">checker-257</h4> + +<p><b>built: </b>May 25, 2011<br> +<p><b>highlights:</b></p> + +<ul> + <li>The analyzer is now far more aggressive with checking conformance with Core Foundation conventions. Any function that returns a CF type must now obey the Core Foundation naming conventions, or use the <a href="/annotations.html#attr_cf_returns_retained">cf_returns_retained</a> or <a href="/annotations.html#attr_cf_returns_not_retained">cf_returns_not_retained</a> annotations.</li> + <li>Fixed a serious regression where the analyzer would not analyze Objective-C methods in class extensions.</li> + <li>Misc. bug fixes to improve analyzer precision. + </li> +</ul> + +<h4 id="checker_256">checker-256</h4> + +<p><b>built: </b>April 13, 2011<br> +<p><b>highlights:</b></p> + +<ul> + <li>Lots of bug fixes and improvements to analyzer precision (fewer false positives, possibly more bugs found). + <li>Introductory analysis support for C++ and Objective-C++. +</ul> + +<p>This build contains basic support for C++ and Objective-C++ that is ready to be tried out + by general users. It is still in its infancy, but establishes a baseline for things to come. The main hope is that it can find some + issues and have a reasonable false positive rate.</p> + +<p><b>Please</b> <a href="/filing_bugs.html">file bugs</a> when you see issues of any kind so we can assess + where development on C++ analysis support needs to be focused.</p> + +<p>To try out C++ analysis support, it should work out of the box using <tt>scan-build</tt>. If you are using this checker build + as a replacement to the analyzer bundled with Xcode, first use the <tt>set-xcode-analyzer</tt> script to <a href="/xcode.html">change Xcode to use + your version of the analyzer</a>. You will then need to modify one configuration file in Xcode to enable C++ analysis support. This can + be done with the following steps:</p> + +<ol> + <li>Find the clang .xcspec file: +<pre>$ cd /Developer/Library +$ find . | grep xcspec | grep Clang +./Xcode/<b><SNIP></b>/Clang LLVM 1.0.xcplugin/Contents/Resources/Clang LLVM 1.0.xcspec +</pre></li> + <li>The exact location of the file may vary depending on your installation of Xcode. Edit that file, and look for the string "--analyze": +<pre> + SourceFileOption = "--analyze"; + FileTypes = ( + "sourcecode.c.c", + "sourcecode.c.objc", + ); + ... +</pre> + Change the "FileTypes" entry to: +<pre> + FileTypes = ( + "sourcecode.c.c", + "sourcecode.c.objc", + "sourcecode.cpp.cpp", + "sourcecode.cpp.objcpp", + ); +</pre></li> +<li>Restart Xcode.</li> +</ol> + +<h4 id="checker_255">checker-255</h4> + +<p><b>built: </b> February 11, 2011<br> +<p><b>highlights:</b></p> + +<ul> +<li>Mac OS X builds are now Intel <tt>i386</tt> and <tt>x86_64</tt> only (no <tt>ppc</tt> support)</li> +<li>Turns on new <tt>-init</tt> method checker by default</li> +<li>Reduces memory usage of analyzer by 10%</li> +<li>Misc. fixes to reduce false positives on dead stores and idempotent operations.</li> +</ul> + +<h4 id="checker_254">checker-254</h4> + +<p><b>built: </b> January 27, 2011<br> +<p><b>highlights:</b></p> + +<ul> +<li>Introduces new <tt>-init</tt> method checker to check if a super class's init method is properly called.</li> +<li>Objective-C retain/release checker now reasons about calls to property accessor methods (setter/getter).</li> +<li>Introduces new attribute <a href="annotations.html#attr_ns_consumes_self">ns_consumes_self</a> to educate the Objective-C retain/release checker about custom "init-like" methods that do not follow the standard Cocoa naming conventions.</li> +<li>Introduces new attributes <a href="annotations.html#attr_ns_consumed">ns_consumed</a> and <a href="annotations.html#attr_cf_consumed">cf_consumed</a> to educate the Objective-C retain/release checker about methods/functions that decrement the reference count of a parameter.</li> +</ul> + +</div> +</div> +</body> +</html> + diff --git a/clang/www/analyzer/scan-build.html b/clang/www/analyzer/scan-build.html new file mode 100644 index 0000000..710fa0f --- /dev/null +++ b/clang/www/analyzer/scan-build.html @@ -0,0 +1,344 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <title>scan-build: running the analyzer from the command line</title> + <link type="text/css" rel="stylesheet" href="content.css"> + <link type="text/css" rel="stylesheet" href="menu.css"> + <script type="text/javascript" src="scripts/menu.js"></script> + <script type="text/javascript" src="scripts/dbtree.js"></script> +</head> +<body> + +<div id="page"> +<!--#include virtual="menu.html.incl"--> +<div id="content"> + +<h1>scan-build: running the analyzer from the command line</h1> + +<table style="margin-top:0px" width="100%" cellpadding="0px" cellspacing="0"> +<tr><td> + +<h3>What is it?</h3> +<p><b>scan-build</b> is a command line utility that enables a user to run the +static analyzer over their codebase as part of performing a regular build (from +the command line).</p> + +<h3>How does it work?</h3> +<p>During a project build, as source files are compiled they are also analyzed +in tandem by the static analyzer.</p> + +<p>Upon completion of the build, results are then presented to the user within a +web browser.</p> + +<h3>Will it work with any build system?</h3> +<p><b>scan-build</b> has little or no knowledge about how you build your code. +It works by overriding the <tt>CC</tt> and <tt>CXX</tt> environment variables to +(hopefully) change your build to use a "fake" compiler instead of the +one that would normally build your project. This fake compiler executes either +<tt>clang</tt> or <tt>gcc</tt> (depending on the platform) to compile your +code and then executes the static analyzer to analyze your code.</p> + +<p>This "poor man's interposition" works amazingly well in many cases +and falls down in others. Please consult the information on this page on making +the best use of <b>scan-build</b>, which includes getting it to work when the +aforementioned hack fails to work.</p> + +</td> +<td style="padding-left:10px; text-align:center"> + <img src="images/scan_build_cmd.png" width="450px" alt="scan-build"><br> + <a href="images/analyzer_html.png"><img src="images/analyzer_html.png" width="450px" alt="analyzer in browser"></a> +<br><b>Viewing static analyzer results in a web browser</b> +</td></tr></table> + +<h2>Contents</h2> + +<ul id="collapsetree" class="dbtree onclick multiple"> +<li><a href="#scanbuild">Getting Started</a> + <ul> + <li><a href="#scanbuild_basicusage">Basic Usage</a></li> + <li><a href="#scanbuild_otheroptions">Other Options</a></li> + <li><a href="#scanbuild_output">Output of scan-build</a></li> + </ul> +</li> +<li><a href="#recommendedguidelines">Recommended Usage Guidelines</a> + <ul> + <li><a href="#recommended_debug">Always Analyze a Project in its "Debug" Configuration</a></li> + <li><a href="#recommended_verbose">Use Verbose Output when Debugging scan-build</a></li> + <li><a href="#recommended_autoconf">Run './configure' through scan-build</a></li> + </ul> +</li> +<li><a href="#iphone">Analyzing iPhone Projects</a></li> +</ul> + +<h2 id="scanbuild">Getting Started</h2> + +<p>The <tt>scan-build</tt> command can be used to analyze an entire project by +essentially interposing on a project's build process. This means that to run the +analyzer using <tt>scan-build</tt>, you will use <tt>scan-build</tt> to analyze +the source files compiled by <tt>gcc</tt>/<tt>clang</tt> during a project build. +This means that any files that are not compiled will also not be analyzed.</p> + +<h3 id="scanbuild_basicusage">Basic Usage</h3> + +<p>Basic usage of <tt>scan-build</tt> is designed to be simple: just place the +word "scan-build" in front of your build command:</p> + +<pre class="code_example"> +$ <span class="code_highlight">scan-build</span> make +$ <span class="code_highlight">scan-build</span> xcodebuild +</pre> + +<p>In the first case <tt>scan-build</tt> analyzes the code of a project built +with <tt>make</tt> and in the second case <tt>scan-build</tt> analyzes a project +built using <tt>xcodebuild</tt>.<p> + +<p>Here is the general format for invoking <tt>scan-build</tt>:</p> + +<pre class="code_example"> +$ <span class="code_highlight">scan-build</span> <i>[scan-build options]</i> <span class="code_highlight"><command></span> <i>[command options]</i> +</pre> + +<p>Operationally, <tt>scan-build</tt> literally runs <command> with all of the +subsequent options passed to it. For example, one can pass <tt>-j4</tt> to +<tt>make</tt> get a parallel build over 4 cores:</p> + +<pre class="code_example"> +$ scan-build make <span class="code_highlight">-j4</span> +</pre> + +<p>In almost all cases, <tt>scan-build</tt> makes no effort to interpret the +options after the build command; it simply passes them through. In general, +<tt>scan-build</tt> should support parallel builds, but <b>not distributed +builds</b>.</p> + +<p>It is also possible to use <tt>scan-build</tt> to analyze specific +files:</p> + +<pre class="code_example"> + $ scan-build gcc -c <span class="code_highlight">t1.c t2.c</span> +</pre> + +<p>This example causes the files <tt>t1.c</tt> and <tt>t2.c</tt> to be analyzed. +</p> + +<h3 id="scanbuild_otheroptions">Other Options</h3> + +<p>As mentioned above, extra options can be passed to <tt>scan-build</tt>. These +options prefix the build command. For example:</p> + +<pre class="code_example"> + $ scan-build <span class="code_highlight">-k -V</span> make + $ scan-build <span class="code_highlight">-k -V</span> xcodebuild +</pre> + +<p>Here is a subset of useful options:</p> + +<table class="options"> +<thead><tr><td>Option</td><td>Description</td></tr></thead> + +<tr><td><b>-o</b></td><td>Target directory for HTML report files. Subdirectories +will be created as needed to represent separate "runs" of the analyzer. If this +option is not specified, a directory is created in <tt>/tmp</tt> to store the +reports.</td></tr> + +<tr><td><b>-h</b><br><i>(or no arguments)</i></td><td>Display all +<tt>scan-build</tt> options.</td></tr> + +<tr><td><b>-k</b><br><b>--keep-going</b></td><td>Add a "keep on +going" option to the specified build command. <p>This option currently supports +<tt>make</tt> and <tt>xcodebuild</tt>.</p> <p>This is a convenience option; one +can specify this behavior directly using build options.</p></td></tr> + +<tr><td><b>-v</b></td><td>Verbose output from scan-build and the analyzer. <b>A +second and third "-v" increases verbosity</b>, and is useful for filing bug +reports against the analyzer.</td></tr> + +<tr><td><b>-V</b></td><td>View analysis results in a web browser when the build +command completes.</td></tr> </table> + +<p>A complete list of options can be obtained by running <tt>scan-build</tt> +with no arguments.</p> + +<h3 id="scanbuild_output">Output of scan-build</h3> + +<p> +The output of scan-build is a set of HTML files, each one which represents a +separate bug report. A single <tt>index.html</tt> file is generated for +surveying all of the bugs. You can then just open <tt>index.html</tt> in a web +browser to view the bug reports. +</p> + +<p> +Where the HTML files are generated is specified with a <b>-o</b> option to +<tt>scan-build</tt>. If <b>-o</b> isn't specified, a directory in <tt>/tmp</tt> +is created to store the files (<tt>scan-build</tt> will print a message telling +you where they are). If you want to view the reports immediately after the build +completes, pass <b>-V</b> to <tt>scan-build</tt>. +</p> + + +<h2 id="recommendedguidelines">Recommended Usage Guidelines</h2> + +<p>This section describes a few recommendations with running the analyzer.</p> + +<h3 id="recommended_debug">ALWAYS analyze a project in its "debug" configuration</h3> + +<p>Most projects can be built in a "debug" mode that enables assertions. +Assertions are picked up by the static analyzer to prune infeasible paths, which +in some cases can greatly reduce the number of false positives (bogus error +reports) emitted by the tool.</p> + +<h3 id="recommend_verbose">Use verbose output when debugging scan-build</h3> + +<p><tt>scan-build</tt> takes a <b>-v</b> option to emit verbose output about +what it's doing; two <b>-v</b> options emit more information. Redirecting the +output of <tt>scan-build</tt> to a text file (make sure to redirect standard +error) is useful for filing bug reports against <tt>scan-build</tt> or the +analyzer, as we can see the exact options (and files) passed to the analyzer. +For more comprehensible logs, don't perform a parallel build.</p> + +<h3 id="recommended_autoconf">Run './configure' through scan-build</h3> + +<p>If an analyzed project uses an autoconf generated <tt>configure</tt> script, +you will probably need to run <tt>configure</tt> script through +<tt>scan-build</tt> in order to analyze the project.</p> + +<p><b>Example</b></p> + +<pre class="code_example"> +$ scan-build ./configure +$ scan-build make +</pre> + +<p>The reason <tt>configure</tt> also needs to be run through +<tt>scan-build</tt> is because <tt>scan-build</tt> scans your source files by +<i>interposing</i> on the compiler. This interposition is currently done by +<tt>scan-build</tt> temporarily setting the environment variable <tt>CC</tt> to +<tt>ccc-analyzer</tt>. The program <tt>ccc-analyzer</tt> acts like a fake +compiler, forwarding its command line arguments over to the compiler to perform +regular compilation and <tt>clang</tt> to perform static analysis.</p> + +<p>Running <tt>configure</tt> typically generates makefiles that have hardwired +paths to the compiler, and by running <tt>configure</tt> through +<tt>scan-build</tt> that path is set to <tt>ccc-analyzer</tt>.</p> + +<!-- +<h2 id="Debugging">Debugging the Analyzer</h2> + +<p>This section provides information on debugging the analyzer, and troubleshooting +it when you have problems analyzing a particular project.</p> + +<h3>How it Works</h3> + +<p>To analyze a project, <tt>scan-build</tt> simply sets the environment variable +<tt>CC</tt> to the full path to <tt>ccc-analyzer</tt>. It also sets a few other +environment variables to communicate to <tt>ccc-analyzer</tt> where to dump HTML +report files.</p> + +<p>Some Makefiles (or equivalent project files) hardcode the compiler; for such +projects simply overriding <tt>CC</tt> won't cause <tt>ccc-analyzer</tt> to be +called. This will cause the compiled code <b>to not be analyzed.</b></p> If you +find that your code isn't being analyzed, check to see if <tt>CC</tt> is +hardcoded. If this is the case, you can hardcode it instead to the <b>full +path</b> to <tt>ccc-analyzer</tt>.</p> + +<p>When applicable, you can also run <tt>./configure</tt> for a project through +<tt>scan-build</tt> so that configure sets up the location of <tt>CC</tt> based +on the environment passed in from <tt>scan-build</tt>: + +<pre> + $ scan-build <b>./configure</b> +</pre> + +<p><tt>scan-build</tt> has special knowledge about <tt>configure</tt>, so it in +most cases will not actually analyze the configure tests run by +<tt>configure</tt>.</p> + +<p>Under the hood, <tt>ccc-analyzer</tt> directly invokes <tt>gcc</tt> to +compile the actual code in addition to running the analyzer (which occurs by it +calling <tt>clang</tt>). <tt>ccc-analyzer</tt> tries to correctly forward all +the arguments over to <tt>gcc</tt>, but this may not work perfectly (please +report bugs of this kind). + --> + +<h2 id="iphone">Analyzing iPhone Projects</h2> + +<p>Conceptually Xcode projects for iPhone applications are nearly the same as +their cousins for desktop applications. <b>scan-build</b> can analyze these +projects as well, but users often encounter problems with just building their +iPhone projects from the command line because there are a few extra preparative +steps they need to take (e.g., setup code signing).</p> + +<h3>Recommendation: use "Build and Analyze"</h3> + +<p>The absolute easiest way to analyze iPhone projects is to use the <a +href="http://developer.apple.com/mac/library/featuredarticles/StaticAnalysis/index.html"><i>Build +and Analyze</i> feature in Xcode 3.2</a> (which is based on the Clang Static +Analyzer). There a user can analyze their project with the click of a button +without most of the setup described later.</p> + +<p><a href="/xcode.html">Instructions are available</a> on this +website on how to use open source builds of the analyzer as a replacement for +the one bundled with Xcode.</p> + +<h3>Using scan-build directly</h3> + +<p>If you wish to use <b>scan-build</b> with your iPhone project, keep the +following things in mind:</p> + +<ul> + <li>Analyze your project in the <tt>Debug</tt> configuration, either by setting +this as your configuration with Xcode or by passing <tt>-configuration +Debug</tt> to <tt>xcodebuild</tt>.</li> + <li>Analyze your project using the <tt>Simulator</tt> as your base SDK. It is +possible to analyze your code when targeting the device, but this is much +easier to do when using Xcode's <i>Build and Analyze</i> feature.</li> + <li>Check that your code signing SDK is set to the simulator SDK as well, and make sure this option is set to <tt>Don't Code Sign</tt>.</li> +</ul> + +<p>Note that you can most of this without actually modifying your project. For +example, if your application targets iPhoneOS 2.2, you could run +<b>scan-build</b> in the following manner from the command line:</p> + +<pre class="code_example"> +$ scan-build xcodebuild -configuration Debug -sdk iphonesimulator2.2 +</pre> + +Alternatively, if your application targets iPhoneOS 3.0: + +<pre class="code_example"> +$ scan-build xcodebuild -configuration Debug -sdk iphonesimulator3.0 +</pre> + +<h3>Gotcha: using the right compiler</h3> + +<p>Recall that <b>scan-build</b> analyzes your project by using a compiler to +compile the project and <tt>clang</tt> to analyze your project. The script uses +simple heuristics to determine which compiler should be used (it defaults to +<tt>clang</tt> on Darwin and <tt>gcc</tt> on other platforms). When analyzing +iPhone projects, <b>scan-build</b> may pick the wrong compiler than the one +Xcode would use to build your project. For example, this could be because +multiple versions of a compiler may be installed on your system, especially if +you are developing for the iPhone.</p> + +<p>When compiling your application to run on the simulator, it is important that <b>scan-build</b> +finds the correct version of <tt>gcc/clang</tt>. Otherwise, you may see strange build +errors that only happen when you run <tt>scan-build</tt>. + +<p><b>scan-build</b> provides the <tt>--use-cc</tt> and <tt>--use-c++</tt> +options to hardwire which compiler scan-build should use for building your code. +Note that although you are chiefly interested in analyzing your project, keep in +mind that running the analyzer is intimately tied to the build, and not being +able to compile your code means it won't get fully analyzed (if at all).</p> + +<p>If you aren't certain which compiler Xcode uses to build your project, try +just running <tt>xcodebuild</tt> (without <b>scan-build</b>). You should see the +full path to the compiler that Xcode is using, and use that as an argument to +<tt>--use-cc</tt>.</p> + +</div> +</div> +</body> +</html> + diff --git a/clang/www/analyzer/scripts/dbtree.js b/clang/www/analyzer/scripts/dbtree.js new file mode 100644 index 0000000..5face5d --- /dev/null +++ b/clang/www/analyzer/scripts/dbtree.js @@ -0,0 +1 @@ +eval(function(p,a,c,k,e,r){e=function(c){return(c<a?'':e(parseInt(c/a)))+((c=c%a)>35?String.fromCharCode(c+29):c.toString(36))};if(!''.replace(/^/,String)){while(c--)r[e(c)]=k[c]||e(c);k=[function(e){return r[e]}];e=function(){return'\\w+'};c=1};while(c--)if(k[c])p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c]);return p}('7 5,r,Q,u;7 17=[];5=H;1i();9(!1Z.1j.20){1Z.1j.20=k(a){C[C.D]=a}}7 19=\'35+/\';k 36(a){7 b,R=\'\',i=0;I(;i<a.D;i+=4){b=(19.1k(a.1l(i))&1a)<<18|(19.1k(a.1l(i+1))&1a)<<12|(19.1k(a.1l(i+2))&1a)<<6|19.1k(a.1l(i+3))&1a;R+=37.38((b&39)>>16,(b&3a)>>8,b&1a)}9(a.21(i-2)==22)1m=R.23(0,R.D-2);s 9(a.21(i-1)==22)1m=R.23(0,R.D-1);s 1m=R;z 3b(1m)}7 A={24:k(){7 a=l.E(\'X\');I(7 i=0;i<a.D;i++){9(a[i].h.F(/\\1n\\b/)==-1)3c;7 b=a[i];9(b.h.F(/\\1E\\b/)!=-1){7 c=b.E(\'a\');I(7 j=0;j<c.D;j++){m.B(c[j],\'25\',1F,o);m.B(c[j],\'26\',1G,o);m.B(c[j],\'1o\',1b,o);c[j].Y=\'1H:1I(0)\'}}7 d=b.E(\'X\');I(7 j=0;j<d.D;j++){7 e=d[j].p;e.27=J;9(b.h.F(/\\3d\\b/)!=-1){m.B(e,\'w\',A.w,o);9(b.h.F(/\\3e\\b/)==-1){e.E(\'a\')[0].Y=\'1H:1I(0)\'}}s{7 t=b.h.3f(/1J(.*)1J/);t=t?t[1]:H;m.B(e,\'3g\',A.28(e,t),o);m.B(e,\'3h\',A.29(e),o)}e.E(\'a\')[0].h+=\' 2a\'}9(b.h.F(/\\3i\\b/)!=-1)A.2b(b.v)}},2b:k(a){7 b=l.G(a+\'3j\');9(b){A.1p(b);b=b.p;1c(!!b&&(b.v!=a)){9((!b.h)||(b.h==\'\')){b.h=\'w\'}s{b.h+=\' w\'}9(b.1d.K.L()==\'a\')b.1d.h+=\' w\';b=b.p}}},29:k(a){z k(){A.1p(a)}},28:k(a,b){z k(){A.2c(a,b)}},1p:k(a){7 b=a;3k(b.2d);I(7 i=0;i<b.S.D;i++){7 c=b.S[i];9(c.K.L()==\'X\'){b.E(\'a\')[0].h+=\' w\';b.h+=\' w\';c.h+=\' w\'}}},2c:k(a,b){7 c=a;c.2d=3l(k(){A.1q(c)},b)},1q:k(a){I(7 i=0;i<a.S.D;i++){7 b=a.S[i];9(b.K.L()==\'X\'){a.E(\'a\')[0].h=a.E(\'a\')[0].h.1K(/w/g,\'\');b.h=b.h.1K(/w/g,\'\');a.h=a.h.1K(/w/g,\'\')}}},w:k(e){9(M.T){M.T.1L=J}9(e&&e.1r){e.1r()}7 a=(M.T)?M.T.2e:(e)?e.1M:H;9(!a||!(a=A.1N(a,\'2f\')))z;9(a.E(\'a\')[0].h.F(/\\2g\\b/)==-1){7 b=1e(a);9(2h(b)){9(l.G(b).h.F(/\\3m\\b/)==-1){I(n=0;n<a.p.S.D;n++){N=a.p.S[n];9(N.K.L()==\'2f\'){9(N.h.F(/\\2g\\b/)!=-1)A.1q(a.p.S[n])}}}}A.1p(a)}s{A.1q(a)}9(2h(1e(a))){z J}s{z o}},1N:k(a,b){9(a.K.L()!=b&&a.K.L()!=\'U\'){z A.1N(a.p,b)}s 9(a.K.L()==\'U\'){z H}s{z a}}};k 1i(){3n{u=M.2i?O 2i():O 3o(\'3p.3q\')}3r(e){2j(\'2k 2l: 3s 3t 3u 3v 3w-3x!\')}}k 1O(a,x){a.1f.3y=x+\'2m\'}k 1P(a,y){a.1f.3z=y+\'2m\'}k 1e(a){1c(a.h.F(/\\1n\\b/)==-1){a=a.p}9((a.h.F(/\\1n\\b/)!=-1)&&(a.h.F(/\\1E\\b/)!=-1)){I(i=0;i<17.D;i++){9(a.v==17[i].q)z i}}z a.v}k 1G(a){a=O m(a);r=a.P.p.p.v;7 b=r.1s(\'Z\');r=b[1];5=17[1e(a.P)];7 c=l.G(5.q+\'10\').3A(J);7 d=l.G(5.q+\'10\');d.p.2n(d);c.v=5.q+\'10\';l.U.2o(c);1O(c,a.x);1P(c,a.y);c.1f.1Q=\'2p\';a.1t();m.B(l,\'1u\',1R,o);z o}k 1R(c){c=O m(c);7 e;7 a=c.P;7 b=a;1c((b!=H)&&(b.K.L()!=\'U\')){9(b.v==5.q+\'10\')1g;b=b.p}9((b!=H)&&(b.v==5.q+\'10\')){3B(a.p.h){1S\'3C\':a.Y=5.V+\'11=1T&N=\'+5.13;1g;1S\'1T\':a.Y=5.V+\'11=1T&N=\'+r;1g;1S\'2q\':a.Y=5.V+\'11=2q&N=\'+r;1g;3D:e=5.2r+\'?q=\'+5.q;e+=\'&13=\'+5.13;9(a.p.h==\'3E\'){e+=\'&11=2s&N=\'+r+\'&2t=\'+5.13}s{e+=\'&11=\'+a.p.h+\'&N=\'+r}7 d=O 2u();7 f=d.2v();e+=\'&2w=\'+f;e+=\'&1v=\'+5.1v;e+=\'&1w=\'+5.1w;e+=\'&1x=\'+5.1x;e+=\'&1y=\'+5.1y;e+=\'&1z=\'+5.1z;e+=\'&1A=\'+5.1A;e+=\'&v=\'+5.v;e+=\'&1B=\'+5.1B;e+=\'&1C=\'+5.1C;e+=\'&V=\'+5.V;u.2x=1U;u.1V(\'2y\',e,J);u.14(\'2z\',\'2A-2B\');u.14(\'2C-2D\',\'2E-2F\');u.14(\'2G-2H-2I\',l.2J);u.2K(H)}}7 g=l.G(5.q+\'10\');9(g){g.1f.1Q=\'3F\'};m.1h(l,\'1u\',1R,o)}k 1F(a){a=O m(a);r=a.P.p.p.v;7 b=r.1s(\'Z\');r=b[1];5=17[1e(a.P)];9(!l.G(5.q+\'15\')){7 c=(!l.G(5.q+\'15\'))?l.3G(\'3H\'):l.G(5.q+\'15\');c.v=5.q+\'15\';c.2L=a.P.1d.3I;l.U.2o(c)}m.B(l,\'2M\',1W,o);m.B(l,\'1u\',1X,o);m.B(l,\'1o\',1b,o);a.1t();z o}k 1b(a){9(!a&&M.T)a=M.T;9(a!=H){9(3J(a.1Y)==\'k\')a.1Y();s a.2N=o}z o}k 1W(a){a=O m(a);7 b=l.G(5.q+\'15\');1O(b,a.x);1P(b,a.y);b.1f.1Q=\'2p\';a.1t();z o}k 1X(a){a=O m(a);7 b=a.P.p;9(b.K.L()==\'a\'){r=5.q+\'Z\'+r;9(r!=b.p.v){7 c=J;7 d=b.p;1c(!!d&&(d.v!=5.q)){9(d.v==r){c=o;1g}s{d=d.p}}9(c==J){7 e=r.1s(\'Z\');r=e[1];Q=b.p.v;7 f=Q.1s(\'Z\');Q=f[1];2O(a)}}}7 g=l.G(5.q+\'15\');9(g){g.p.2n(g)};m.1h(l,\'2M\',1W,o);m.1h(l,\'1u\',1X,o);m.1h(l,\'1o\',1b,o)}k 2O(a){7 d=O 2u();7 b=d.2v();7 c;c=5.2r+\'?q=\'+5.q+\'&11=2s&13=\'+5.13+\'&N=\'+r+\'&2t=\'+Q+\'&2w=\'+b;c+=\'&1v=\'+5.1v;c+=\'&1w=\'+5.1w;c+=\'&1x=\'+5.1x;c+=\'&1y=\'+5.1y;c+=\'&1z=\'+5.1z;c+=\'&1A=\'+5.1A;c+=\'&v=\'+5.v;c+=\'&1B=\'+5.1B;c+=\'&1C=\'+5.1C;c+=\'&V=\'+5.V;u.2x=1U;u.1V(\'2y\',c,J);u.14(\'2z\',\'2A-2B\');u.14(\'2C-2D\',\'2E-2F\');u.14(\'2G-2H-2I\',l.2J);u.2K(H)}k 2P(){7 a=(!!Q)?Q:r;a=5.q+\'Z\'+a;a=l.G(a);9(a){a=a.E(\'X\')[0];1c(!!a&&(a.h.F(/\\1n\\b/)==-1)&&(a.h.F(/\\1E\\b/)==-1)){9((!a.h)||(a.h==\'\')){a.h=\'w\'}s{a.h+=\' w\'}9(a.1d.K.L()==\'a\')a.1d.h+=\' w\';a=a.p}}}k 3K(a,b){9(a!=\'3L\'){3M(a+".3N=\'"+b.2Q[b.2R].2S+"\'")}s{M.1V(b.2Q[b.2R].2S)}}k 2T(a){7 b=l.G(a);7 c=b.E(\'X\');I(7 j=0;j<c.D;j++){7 d=c[j].p;d.27=J;m.B(d,\'w\',A.w,o);d.E(\'a\')[0].h+=\' 2a\'}7 e=b.E(\'a\');I(7 j=0;j<e.D;j++){m.B(e[j],\'25\',1F,o);m.B(e[j],\'26\',1G,o);m.B(e[j],\'1o\',1b,o);e[j].Y=\'1H:1I(0)\'}}k 1U(){9(u.3O==4){9(u.3P==3Q){l.G(5.q+\'3R\').2L=u.3S;2T(5.q);2P();1i()}s{2j(\'2k 2l: 3T, 3U 3V 1J 3W a 3X 3Y 3Z 40:\\n\'+u.41);1i()}}}k m(a){C.W=a?a:M.T;C.P=a.1M?a.1M:a.2e;C.x=a.2U?(a.2U):(a.42+2V.2W(l.U.2X,l.2Y.2X));C.y=a.2Z?(a.2Z):(a.43+2V.2W(l.U.30,l.2Y.30))}m.1j.44=k(){z\'m [ x = \'+C.x+\', y = \'+C.y+\' ]\'};m.1j.1t=k(){9(C.W.1r){C.W.1r();C.W.1Y()}s 9(C.W.1L){C.W.1L=J;C.W.2N=o}};m.B=k(a,b,c,d){9(l.31){a.31(b,c,d)}s 9(l.32){a.32(\'1D\'+b,c,d)}s{a[\'1D\'+b]=c}};m.1h=k(a,b,c,d){9(l.33){a.33(b,c,d)}s 9(l.34){a.34(\'1D\'+b,c,d)}s{a[\'1D\'+b]=H}};m.B(M,\'45\',A.24,o);',62,254,'|||||instance||var||if||||||||className|||function|document|Evt||false|parentNode|instanceName|nid|else||client|id|click|||return|dbTree|addEvent|this|length|getElementsByTagName|search|getElementById|null|for|true|nodeName|toLowerCase|window|node|new|source|nto|decOut|childNodes|event|body|editpage|evt|ul|href|_|_options|action||rootnode|setRequestHeader|_tip||dbtreeObj||b64s|0xff|PreventDefault|while|firstChild|getObj|style|break|removeEvent|createClient|prototype|indexOf|charAt|undecOut|bdbtree|selectstart|mOver|mOut|stopPropagation|split|consume|mouseup|type|query|datasource|username|password|table|parent|contentfield|on|bedit|dragPress|contextMenu|javascript|void|to|replace|cancelBubble|target|getTarget|setX|setY|display|contextAction|case|add|callback|open|dragMove|dragRelease|preventDefault|Array|push|charCodeAt|61|substring|init|mousedown|contextmenu|hasSubMenu|getMoutFor|getMoverFor|subMenu|mExp|mTimeout|timeout|srcElement|li|bclick|isNaN|XMLHttpRequest|alert|DBTree|Error|px|removeChild|appendChild|block|edit|tagpath|move|nodeto|Date|getTime|time|onreadystatechange|get|Pragma|no|cache|Cache|Control|must|revalidate|If|Modified|Since|lastModified|send|innerHTML|mousemove|returnValue|dragBoxDropped|expandtree|options|selectedIndex|value|reinit|pageX|Math|max|scrollLeft|documentElement|pageY|scrollTop|addEventListener|attachEvent|removeEventListener|detachEvent|ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789|decode|String|fromCharCode|0xff0000|0xff00|unescape|continue|bonclick|blinkparent|match|mouseout|mouseover|bexpand|_active|clearTimeout|setTimeout|bmultiple|try|ActiveXObject|Microsoft|XMLHTTP|catch|Your|browser|is|not|Ajax|enabled|left|top|cloneNode|switch|addroot|default|moveroot|none|createElement|div|nodeValue|typeof|jumpTo|blank|eval|location|readyState|status|200|_edit|responseText|Sorry|there|seems|be|problem|retrieving|the|response|statusText|clientX|clientY|toString|load'.split('|'),0,{})) diff --git a/clang/www/analyzer/scripts/menu.js b/clang/www/analyzer/scripts/menu.js new file mode 100644 index 0000000..6b393c0 --- /dev/null +++ b/clang/www/analyzer/scripts/menu.js @@ -0,0 +1,17 @@ +startList = function() { + if (document.all&&document.getElementById) { + navRoot = document.getElementById("nav"); + for (i=0; i<navRoot.childNodes.length; i++) { + node = navRoot.childNodes[i]; + if (node.nodeName=="LI") { + node.onmouseover=function() { + this.className+=" over"; + } + node.onmouseout=function() { + this.className=this.className.replace(" over", ""); + } + } + } + } +} +window.onload=startList; diff --git a/clang/www/analyzer/xcode.html b/clang/www/analyzer/xcode.html new file mode 100644 index 0000000..ac75a04 --- /dev/null +++ b/clang/www/analyzer/xcode.html @@ -0,0 +1,143 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <title>Build and Analyze: running the analyzer within Xcode</title> + <link type="text/css" rel="stylesheet" href="content.css"> + <link type="text/css" rel="stylesheet" href="menu.css"> + <script type="text/javascript" src="scripts/menu.js"></script> + <script type="text/javascript" src="scripts/dbtree.js"></script> +</head> +<body> + +<div id="page"> +<!--#include virtual="menu.html.incl"--> +<div id="content"> + +<h1>Build and Analyze: running the analyzer within Xcode</h1> + +<table style="margin-top:0px" width="100%" border="0" cellpadding="0px" cellspacing="0"> +<tr><td> + +<h3>What is it?</h3> +<p><i>Build and Analyze</i> is an Xcode feature (introduced in Xcode 3.2) that +allows users to run the Clang Static Analyzer <a +href="http://developer.apple.com/mac/library/featuredarticles/StaticAnalysis/index.html">directly +within Xcode</a>.</p> + +<p>It integrates directly with the Xcode build system and +presents analysis results directly within Xcode's editor.</p> + +<h3>Can I use the open source analyzer builds with Xcode?</h3> + +<p><b>Yes</b>. Instructions are included below.</p> + +</td> +<td style="padding-left:10px; text-align:center"> + <a href="images/analyzer_xcode.png"><img src="images/analyzer_xcode.png" width="620px" alt="analyzer in xcode"></a> +<br><b>Viewing static analyzer results in Xcode</b> +</td></tr></table> + +<h3>Key features:</h3> +<ul> + <li><b>Integrated workflow:</b> Results are integrated within Xcode. There is + no experience of using a separate tool, and activating the analyzer requires a + single keystroke or mouse click.</li> + <li><b>Transparency:</b> Works effortlessly with Xcode projects (including iPhone projects). + <li><b>Cons:</b> Doesn't work well with non-Xcode projects. For those, + consider using <a href="/scan-build.html"><b>scan-build</b></a>. +</ul> + + +<h2>Getting Started</h2> + +<p>Xcode 3.2 is available as a free download from Apple, with <a +href="http://developer.apple.com/mac/library/featuredarticles/StaticAnalysis/index.html">instructions available</a> +for using <i>Build and Analyze</i>.</p> + +<h2>Using open source analyzer builds with <i>Build and Analyze</i></h2> + +<p>By default, Xcode uses the version of <tt>clang</tt> that came bundled with +it to provide the results for <i>Build and Analyze</i>. It is possible to change +Xcode's behavior to use an alternate version of <tt>clang</tt> for this purpose +while continuing to use the <tt>clang</tt> that came with Xcode for compiling +projects.</p> + +<h3>Why try open source builds?</h3> + +<p>The advantage of using open source analyzer builds (provided on this website) +is that they are often newer than the analyzer provided with Xcode, and thus can +contain bug fixes, new checks, or simply better analysis.</p> + +<p>On the other hand, new checks can be experimental, with results of variable +quality. Users are encouraged to <a href="filing_bugs.html">file bug reports</a> +(for any version of the analyzer) where they encounter false positives or other +issues.</p> + +<h3>set-xcode-analyzer</h3> + +<p>Starting with analyzer build checker-234, analyzer builds contain a command +line utility called <tt>set-xcode-analyzer</tt> that allows users to change what +copy of <tt>clang</tt> that Xcode uses for <i>Build and Analyze</i>:</p> + +<pre class="code_example"> +$ <b>set-xcode-analyzer -h</b> +Usage: set-xcode-analyzer [options] + +Options: + -h, --help show this help message and exit + --use-checker-build=PATH + Use the Clang located at the provided absolute path, + e.g. /Users/foo/checker-1 + --use-xcode-clang Use the Clang bundled with Xcode +</pre> + +<p>Operationally, <b>set-xcode-analyzer</b> edits Xcode's configuration files +(in <tt>/Developer</tt>) to point it to use the version of <tt>clang</tt> you +specify for static analysis. Within this model it provides you two basic modes:</p> + +<ul> + <li><b>--use-xcode-clang</b>: Switch Xcode (back) to using the <tt>clang</tt> that came bundled with it for static analysis.</li> + <li><b>--use-checker-build</b>: Switch Xcode to using the <tt>clang</tt> provided by the specified analyzer build.</li> +</ul> + +<h4>Things to keep in mind</h4> + +<ul> +<li>You should quit Xcode prior to running <tt>set-xcode-analyzer</tt>.</li> +<li>You will need to run <tt>set-xcode-analyzer</tt> under <b><tt>sudo</tt></b> + in order to have write privileges to modify the Xcode configuration files.</li> +</ul> + +<h4>Examples</h4> + +<p><b>Example 1</b>: Telling Xcode to use checker-235 for <i>Build and Analyze</i>:</p> + +<pre class="code_example"> +$ pwd +/tmp +$ tar xjf checker-235.tar.bz2 +$ sudo checker-235/set-xcode-analyzer --use-checker-build=/tmp/checker-235 +</pre> + +<p>Note that you typically won't install an analyzer build in <tt>/tmp</tt>, but +the point of this example is that <tt>set-xcode-analyzer</tt> just wants a full +path to an untarred analyzer build.</p> + +<p><b>Example 2</b>: Telling Xcode to use a very specific version of <tt>clang</tt>:</p> + +<pre class="code_example"> +$ sudo set-xcode-analyzer --use-checker-build=~/mycrazyclangbuild/bin/clang +</pre> + +<p><b>Example 3</b>: Resetting Xcode to its default behavior:</p> + +<pre class="code_example"> +$ sudo set-xcode-analyzer --use-xcode-clang +</pre> + +</div> +</div> +</body> +</html> + diff --git a/clang/www/builtins.py b/clang/www/builtins.py new file mode 100755 index 0000000..5e85770 --- /dev/null +++ b/clang/www/builtins.py @@ -0,0 +1,160 @@ +#!/usr/bin/env python + +import sys, fileinput + +err=0 + +# Giant associative set of builtin->intrinsic mappings where clang doesn't +# implement the builtin since the vector operation works by default. + +repl_map = { +'__builtin_ia32_addps': '_mm_add_ps', +'__builtin_ia32_addsd': '_mm_add_sd', +'__builtin_ia32_addpd': '_mm_add_pd', +'__builtin_ia32_addss': '_mm_add_ss', +'__builtin_ia32_paddb128': '_mm_add_epi8', +'__builtin_ia32_paddw128': '_mm_add_epi16', +'__builtin_ia32_paddd128': '_mm_add_epi32', +'__builtin_ia32_paddq128': '_mm_add_epi64', +'__builtin_ia32_subps': '_mm_sub_ps', +'__builtin_ia32_subsd': '_mm_sub_sd', +'__builtin_ia32_subpd': '_mm_sub_pd', +'__builtin_ia32_subss': '_mm_sub_ss', +'__builtin_ia32_psubb128': '_mm_sub_epi8', +'__builtin_ia32_psubw128': '_mm_sub_epi16', +'__builtin_ia32_psubd128': '_mm_sub_epi32', +'__builtin_ia32_psubq128': '_mm_sub_epi64', +'__builtin_ia32_mulsd': '_mm_mul_sd', +'__builtin_ia32_mulpd': '_mm_mul_pd', +'__builtin_ia32_mulps': '_mm_mul_ps', +'__builtin_ia32_mulss': '_mm_mul_ss', +'__builtin_ia32_pmullw128': '_mm_mullo_epi16', +'__builtin_ia32_divsd': '_mm_div_sd', +'__builtin_ia32_divpd': '_mm_div_pd', +'__builtin_ia32_divps': '_mm_div_ps', +'__builtin_ia32_subss': '_mm_div_ss', +'__builtin_ia32_andpd': '_mm_and_pd', +'__builtin_ia32_andps': '_mm_and_ps', +'__builtin_ia32_pand128': '_mm_and_si128', +'__builtin_ia32_andnpd': '_mm_andnot_pd', +'__builtin_ia32_andnps': '_mm_andnot_ps', +'__builtin_ia32_pandn128': '_mm_andnot_si128', +'__builtin_ia32_orpd': '_mm_or_pd', +'__builtin_ia32_orps': '_mm_or_ps', +'__builtin_ia32_por128': '_mm_or_si128', +'__builtin_ia32_xorpd': '_mm_xor_pd', +'__builtin_ia32_xorps': '_mm_xor_ps', +'__builtin_ia32_pxor128': '_mm_xor_si128', +'__builtin_ia32_cvtsd2ss': '_mm_cvtsd_ss', +'__builtin_ia32_cvtsi2sd': '_mm_cvtsi32_sd', +'__builtin_ia32_cvtss2sd': '_mm_cvtss_sd', +'__builtin_ia32_cvttsd2si': '_mm_cvttsd_si32', +'__builtin_ia32_vec_ext_v2df': '_mm_cvtsd_f64', +'__builtin_ia32_loadhpd': '_mm_loadh_pd', +'__builtin_ia32_loadlpd': '_mm_loadl_pd', +'__builtin_ia32_loadlv4si': '_mm_loadl_epi64', +'__builtin_ia32_cmpeqps': '_mm_cmpeq_ps', +'__builtin_ia32_cmpltps': '_mm_cmplt_ps', +'__builtin_ia32_cmpleps': '_mm_cmple_ps', +'__builtin_ia32_cmpgtps': '_mm_cmpgt_ps', +'__builtin_ia32_cmpgeps': '_mm_cmpge_ps', +'__builtin_ia32_cmpunordps': '_mm_cmpunord_ps', +'__builtin_ia32_cmpneqps': '_mm_cmpneq_ps', +'__builtin_ia32_cmpnltps': '_mm_cmpnlt_ps', +'__builtin_ia32_cmpnleps': '_mm_cmpnle_ps', +'__builtin_ia32_cmpngtps': '_mm_cmpngt_ps', +'__builtin_ia32_cmpordps': '_mm_cmpord_ps', +'__builtin_ia32_cmpeqss': '_mm_cmpeq_ss', +'__builtin_ia32_cmpltss': '_mm_cmplt_ss', +'__builtin_ia32_cmpless': '_mm_cmple_ss', +'__builtin_ia32_cmpunordss': '_mm_cmpunord_ss', +'__builtin_ia32_cmpneqss': '_mm_cmpneq_ss', +'__builtin_ia32_cmpnltss': '_mm_cmpnlt_ss', +'__builtin_ia32_cmpnless': '_mm_cmpnle_ss', +'__builtin_ia32_cmpngtss': '_mm_cmpngt_ss', +'__builtin_ia32_cmpngess': '_mm_cmpnge_ss', +'__builtin_ia32_cmpordss': '_mm_cmpord_ss', +'__builtin_ia32_movss': '_mm_move_ss', +'__builtin_ia32_movsd': '_mm_move_sd', +'__builtin_ia32_movhlps': '_mm_movehl_ps', +'__builtin_ia32_movlhps': '_mm_movelh_ps', +'__builtin_ia32_movqv4si': '_mm_move_epi64', +'__builtin_ia32_unpckhps': '_mm_unpackhi_ps', +'__builtin_ia32_unpckhpd': '_mm_unpackhi_pd', +'__builtin_ia32_punpckhbw128': '_mm_unpackhi_epi8', +'__builtin_ia32_punpckhwd128': '_mm_unpackhi_epi16', +'__builtin_ia32_punpckhdq128': '_mm_unpackhi_epi32', +'__builtin_ia32_punpckhqdq128': '_mm_unpackhi_epi64', +'__builtin_ia32_unpcklps': '_mm_unpacklo_ps', +'__builtin_ia32_unpcklpd': '_mm_unpacklo_pd', +'__builtin_ia32_punpcklbw128': '_mm_unpacklo_epi8', +'__builtin_ia32_punpcklwd128': '_mm_unpacklo_epi16', +'__builtin_ia32_punpckldq128': '_mm_unpacklo_epi32', +'__builtin_ia32_punpcklqdq128': '_mm_unpacklo_epi64', +'__builtin_ia32_cmpeqpd': '_mm_cmpeq_pd', +'__builtin_ia32_cmpltpd': '_mm_cmplt_pd', +'__builtin_ia32_cmplepd': '_mm_cmple_pd', +'__builtin_ia32_cmpgtpd': '_mm_cmpgt_pd', +'__builtin_ia32_cmpgepd': '_mm_cmpge_pd', +'__builtin_ia32_cmpunordpd': '_mm_cmpunord_pd', +'__builtin_ia32_cmpneqpd': '_mm_cmpneq_pd', +'__builtin_ia32_cmpnltpd': '_mm_cmpnlt_pd', +'__builtin_ia32_cmpnlepd': '_mm_cmpnle_pd', +'__builtin_ia32_cmpngtpd': '_mm_cmpngt_pd', +'__builtin_ia32_cmpngepd': '_mm_cmpnge_pd', +'__builtin_ia32_cmpordpd': '_mm_cmpord_pd', +'__builtin_ia32_cmpeqsd': '_mm_cmpeq_sd', +'__builtin_ia32_cmpltsd': '_mm_cmplt_sd', +'__builtin_ia32_cmplesd': '_mm_cmple_sd', +'__builtin_ia32_cmpunordsd': '_mm_cmpunord_sd', +'__builtin_ia32_cmpneqsd': '_mm_cmpneq_sd', +'__builtin_ia32_cmpnltsd': '_mm_cmpnlt_sd', +'__builtin_ia32_cmpnlesd': '_mm_cmpnle_sd', +'__builtin_ia32_cmpordsd': '_mm_cmpord_sd', +'__builtin_ia32_cvtsi642ss': '_mm_cvtsi64_ss', +'__builtin_ia32_cvttss2si64': '_mm_cvtss_si64', +'__builtin_ia32_shufps': '_mm_shuffle_ps', +'__builtin_ia32_shufpd': '_mm_shuffle_pd', +'__builtin_ia32_pshufhw': '_mm_shufflehi_epi16', +'__builtin_ia32_pshuflw': '_mm_shufflelo_epi16', +'__builtin_ia32_pshufd': '_mm_shuffle_epi32', +'__builtin_ia32_movshdup': '_mm_movehdup_ps', +'__builtin_ia32_movsldup': '_mm_moveldup_ps', +'__builtin_ia32_vec_set_v16qi': '_mm_insert_epi8', +'__builtin_ia32_vec_set_v8hi': '_mm_insert_epi16', +'__builtin_ia32_vec_set_v4si': '_mm_insert_epi32', +'__builtin_ia32_vec_set_v2di': '_mm_insert_epi64', +'__builtin_ia32_vec_set_v4hi': '_mm_insert_pi16', +'__builtin_ia32_vec_ext_v16qi': '_mm_extract_epi8', +'__builtin_ia32_vec_ext_v8hi': '_mm_extract_epi16', +'__builtin_ia32_vec_ext_v4si': '_mm_extract_epi32', +'__builtin_ia32_vec_ext_v2di': '_mm_extract_epi64', +'__builtin_ia32_vec_ext_v4hi': '_mm_extract_pi16', +'__builtin_ia32_vec_ext_v4sf': '_mm_extract_ps' +} + +# Special unhandled cases: +# __builtin_ia32_vec_ext_*(__P, idx) -> _mm_store_sd/_mm_storeh_pd +# depending on index. No abstract insert/extract for these oddly. +unhandled = [ +'__builtin_ia32_vec_ext_v2df', +'__builtin_ia32_vec_ext_v2si', +] + +def report_repl(builtin, repl): + sys.stderr.write("%s:%d: x86 builtin %s used, replaced with %s\n" % (fileinput.filename(), fileinput.filelineno(), builtin, repl)) + +def report_cant(builtin): + sys.stderr.write("%s:%d: x86 builtin %s used, too many replacements\n" % (fileinput.filename(), fileinput.filelineno(), builtin)) + +for line in fileinput.input(inplace=1): + for builtin, repl in repl_map.iteritems(): + if builtin in line: + line = line.replace(builtin, repl) + report_repl(builtin, repl) + for unh in unhandled: + if unh in line: + report_cant(unh) + sys.stdout.write(line) + +sys.exit(err)
\ No newline at end of file diff --git a/clang/www/carbon-compile.png b/clang/www/carbon-compile.png Binary files differnew file mode 100644 index 0000000..e8516c7 --- /dev/null +++ b/clang/www/carbon-compile.png diff --git a/clang/www/clang_video-05-25-2007.html b/clang/www/clang_video-05-25-2007.html new file mode 100644 index 0000000..f0acaed --- /dev/null +++ b/clang/www/clang_video-05-25-2007.html @@ -0,0 +1,27 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ --> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>2007 LLVM Developer's Meeting</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> +</head> +<body> + <!--#include virtual="menu.html.incl"--> + <div id="content"> + <h1>2007 LLVM Developer's Meeting</h1> + Discussion about Clang at the <a href="http://llvm.org/devmtg/2007-05/">2007 LLVM Developer's Meeting</a>. + <h2>About:</h2> + <p>In this video, Steve Naroff introduces the Clang project and talks about some of the goals and motivations for starting the project. + <br><br> + <p><b>Details:</b> New LLVM C Front-end - This talk describes a new from-scratch C frontend (which is aiming to support Objective C and C++ someday) for LLVM, built as a native part of the LLVM system and in the LLVM design style. + <h2>The Presentation:</h2> + <p>You can download a copy of the presentation in mov format. However, due to the picture quality, it is recommended that you also download the lecture slides for viewing while you watch the video. + <ul> + <li><a href="http://llvm.org/devmtg/2007-05/09-Naroff-CFE.mov">Video (mov file)</a> + <li><a href="http://llvm.org/devmtg/2007-05/09-Naroff-CFE.pdf">Lecture slides (PDF)</a> + </ul> + </div> +</body> +</html> diff --git a/clang/www/clang_video-07-25-2007.html b/clang/www/clang_video-07-25-2007.html new file mode 100644 index 0000000..0fee7bc --- /dev/null +++ b/clang/www/clang_video-07-25-2007.html @@ -0,0 +1,30 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ --> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>LLVM 2.0 and Beyond!</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> +</head> +<body> + <!--#include virtual="menu.html.incl"--> + <div id="content"> + <h1>LLVM 2.0 and Beyond!</h1> + A Google Techtalk by <a href="http://www.nondot.org/sabre/">Chris Lattner</a> + <h2>About:</h2> + <p>In this video, Chris Lattner talks about some of the features of Clang, especially in regards to performance. + <br><br> + <p><b>Details:</b> The LLVM 2.0 release brings a number of new features and capabilities to the LLVM toolset. This talk briefly describes those features, then moves on to talk about what is next: llvm 2.1, llvm-gcc 4.2, and puts a special emphasis on the 'clang' C front-end. This describes how the 'clang' preprocessor can be used to improve the scalability of distcc by up to 4.4x. + <h2>The Presentation:</h2> + <p>You can view the presentation through google video. In addition, the slides from the presentation are also available, if you wish to retain a copy. + <ul> + <li><a href="http://video.google.com/videoplay?docid=1921156852099786640">Google Tech Talk Video (19:00-)</a> (Note: the Clang lecture starts at 19 minutes into the video.) + <li><a href="http://llvm.org/pubs/2007-07-25-LLVM-2.0-and-Beyond.pdf">LLVM 2.0 and Beyond! slides (PDF)</a> + </ul> + <h2>Publishing Information:</h2> + "LLVM 2.0 and Beyond!", Chris Lattner,<br> + <i>Google Tech Talk</i>, Mountain View, CA, July 2007. + </div> +</body> +</html> diff --git a/clang/www/comparison.html b/clang/www/comparison.html new file mode 100644 index 0000000..2898ce8 --- /dev/null +++ b/clang/www/comparison.html @@ -0,0 +1,189 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ --> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>Comparing clang to other open source compilers</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> +</head> +<body> + <!--#include virtual="menu.html.incl"--> + <div id="content"> + <h1>Clang vs Other Open Source Compilers</h1> + + <p>Building an entirely new compiler front-end is a big task, and it isn't + always clear to people why we decided to do this. Here we compare clang + and its goals to other open source compiler front-ends that are + available. We restrict the discussion to very specific objective points + to avoid controversy where possible. Also, software is infinitely + mutable, so we don't talk about little details that can be fixed with + a reasonable amount of effort: we'll talk about issues that are + difficult to fix for architectural or political reasons.</p> + + <p>The goal of this list is to describe how differences in goals lead to + different strengths and weaknesses, not to make some compiler look bad. + This will hopefully help you to evaluate whether using clang is a good + idea for your personal goals. Because we don't know specifically what + <em>you</em> want to do, we describe the features of these compilers in + terms of <em>our</em> goals: if you are only interested in static + analysis, you may not care that something lacks codegen support, for + example.</p> + + <p>Please email cfe-dev if you think we should add another compiler to this + list or if you think some characterization is unfair here.</p> + + <ul> + <li><a href="#gcc">Clang vs GCC</a> (GNU Compiler Collection)</li> + <li><a href="#elsa">Clang vs Elsa</a> (Elkhound-based C++ Parser)</li> + <li><a href="#pcc">Clang vs PCC</a> (Portable C Compiler)</li> + </ul> + + + <!--=====================================================================--> + <h2><a name="gcc">Clang vs GCC (GNU Compiler Collection)</a></h2> + <!--=====================================================================--> + + <p>Pro's of GCC vs clang:</p> + + <ul> + <li>GCC supports languages that clang does not aim to, such as Java, Ada, + FORTRAN, etc.</li> + <li>GCC has a few <a href="cxx_status.html">C++'11 features</a> that Clang + does not yet support.</li> + <li>GCC supports more targets than LLVM.</li> + <li>GCC is popular and widely adopted.</li> + <li>GCC does not require a C++ compiler to build it.</li> + </ul> + + <p>Pro's of clang vs GCC:</p> + + <ul> + <li>The Clang ASTs and design are intended to be <a + href="features.html#simplecode">easily understandable</a> by + anyone who is familiar with the languages involved and who has a basic + understanding of how a compiler works. GCC has a very old codebase + which presents a steep learning curve to new developers.</li> + <li>Clang is designed as an API from its inception, allowing it to be reused + by source analysis tools, refactoring, IDEs (etc) as well as for code + generation. GCC is built as a monolithic static compiler, which makes + it extremely difficult to use as an API and integrate into other tools. + Further, its historic design and <a + href="http://gcc.gnu.org/ml/gcc/2007-11/msg00460.html">current</a> + <a href="http://gcc.gnu.org/ml/gcc/2004-12/msg00888.html">policy</a> + makes it difficult to decouple the front-end from the rest of the + compiler. </li> + <li>Various GCC design decisions make it very difficult to reuse: its build + system is difficult to modify, you can't link multiple targets into one + binary, you can't link multiple front-ends into one binary, it uses a + custom garbage collector, uses global variables extensively, is not + reentrant or multi-threadable, etc. Clang has none of these problems. + </li> + <li>For every token, clang tracks information about where it was written and + where it was ultimately expanded into if it was involved in a macro. + GCC does not track information about macro instantiations when parsing + source code. This makes it very difficult for source rewriting tools + (e.g. for refactoring) to work in the presence of (even simple) + macros.</li> + <li>Clang does not implicitly simplify code as it parses it like GCC does. + Doing so causes many problems for source analysis tools: as one simple + example, if you write "x-x" in your source code, the GCC AST will + contain "0", with no mention of 'x'. This is extremely bad for a + refactoring tool that wants to rename 'x'.</li> + <li>Clang can serialize its AST out to disk and read it back into another + program, which is useful for whole program analysis. GCC does not have + this. GCC's PCH mechanism (which is just a dump of the compiler + memory image) is related, but is architecturally only + able to read the dump back into the exact same executable as the one + that produced it (it is not a structured format).</li> + <li>Clang is <a href="features.html#performance">much faster and uses far + less memory</a> than GCC.</li> + <li>Clang aims to provide extremely clear and concise diagnostics (error and + warning messages), and includes support for <a + href="diagnostics.html">expressive diagnostics</a>. GCC's warnings are + sometimes acceptable, but are often confusing and it does not support + expressive diagnostics. Clang also preserves typedefs in diagnostics + consistently, showing macro expansions and many other features.</li> + <li>GCC is licensed under the GPL license. clang uses a BSD license, which + allows it to be used by projects that do not themselves want to be + GPL.</li> + <li>Clang inherits a number of features from its use of LLVM as a backend, + including support for a bytecode representation for intermediate code, + pluggable optimizers, link-time optimization support, Just-In-Time + compilation, ability to link in multiple code generators, etc.</li> + <li><a href="compatibility.html#c++">Clang's support for C++</a> is more + compliant than GCC's in many ways (e.g. conformant two phase name + lookup).</li> + </ul> + + <!--=====================================================================--> + <h2><a name="elsa">Clang vs Elsa (Elkhound-based C++ Parser)</a></h2> + <!--=====================================================================--> + + <p>Pro's of Elsa vs clang:</p> + + <ul> + <li>Elsa's parser and AST is designed to be easily extensible by adding + grammar rules. Clang has a very simple and easily hackable parser, + but requires you to write C++ code to do it.</li> + </ul> + + <p>Pro's of clang vs Elsa:</p> + + <ul> + <li>Clang's C and C++ support is far more mature and practically useful than + Elsa's, and includes many C++'11 features.</li> + <li>The Elsa community is extremely small and major development work seems + to have ceased in 2005. Work continued to be used by other small + projects (e.g. Oink), but Oink is apparently dead now too. Clang has a + vibrant community including developers that + are paid to work on it full time. In practice this means that you can + file bugs against Clang and they will often be fixed for you. If you + use Elsa, you are (mostly) on your own for bug fixes and feature + enhancements.</li> + <li>Elsa is not built as a stack of reusable libraries like clang is. It is + very difficult to use part of Elsa without the whole front-end. For + example, you cannot use Elsa to parse C/ObjC code without building an + AST. You can do this in Clang and it is much faster than building an + AST.</li> + <li>Elsa does not have an integrated preprocessor, which makes it extremely + difficult to accurately map from a source location in the AST back to + its original position before preprocessing. Like GCC, it does not keep + track of macro expansions.</li> + <li>Elsa is even slower and uses more memory than GCC, which itself requires + far more space and time than clang.</li> + <li>Elsa only does partial semantic analysis. It is intended to work on + code that is already validated by GCC, so it does not do many semantic + checks required by the languages it implements.</li> + <li>Elsa does not support Objective-C.</li> + <li>Elsa does not support native code generation.</li> + </ul> + + + <!--=====================================================================--> + <h2><a name="pcc">Clang vs PCC (Portable C Compiler)</a></h2> + <!--=====================================================================--> + + <p>Pro's of PCC vs clang:</p> + + <ul> + <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> + + <ul> + <li>PCC dates from the 1970's and has been dormant for most of that time. + The clang + llvm communities are very active.</li> + <li>PCC doesn't support Objective-C or C++ and doesn't aim to support + C++.</li> + <li>PCC's code generation is very limited compared to LLVM. It produces very + inefficient code and does not support many important targets.</li> + <li>Like Elsa, PCC's does not have an integrated preprocessor, making it + extremely difficult to use it for source analysis tools.</li> + </ul> + </div> +</body> +</html> diff --git a/clang/www/compatibility.html b/clang/www/compatibility.html new file mode 100644 index 0000000..725c52f --- /dev/null +++ b/clang/www/compatibility.html @@ -0,0 +1,869 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>Language Compatibility</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <style type="text/css"> +</style> +</head> +<body> + +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<!-- ======================================================================= --> +<h1>Language Compatibility</h1> +<!-- ======================================================================= --> + +<p>Clang strives to both conform to current language standards (C99, + C++98) and also to implement many widely-used extensions available + in other compilers, so that most correct code will "just work" when + compiler with Clang. However, Clang is more strict than other + popular compilers, and may reject incorrect code that other + compilers allow. This page documents common compatibility and + portability issues with Clang to help you understand and fix the + problem in your code when Clang emits an error message.</p> + +<ul> + <li><a href="#c">C compatibility</a> + <ul> + <li><a href="#inline">C99 inline functions</a></li> + <li><a href="#vector_builtins">"missing" vector __builtin functions</a></li> + <li><a href="#lvalue-cast">Lvalue casts</a></li> + <li><a href="#blocks-in-protected-scope">Jumps to within <tt>__block</tt> variable scope</a></li> + <li><a href="#block-variable-initialization">Non-initialization of <tt>__block</tt> variables</a></li> + <li><a href="#inline-asm">Inline assembly</a></li> + </ul> + </li> + <li><a href="#objective-c">Objective-C compatibility</a> + <ul> + <li><a href="#super-cast">Cast of super</a></li> + <li><a href="#sizeof-interface">Size of interfaces</a></li> + <li><a href="#objc_objs-cast">Internal Objective-C types</a></li> + <li><a href="#c_variables-class">C variables in @class or @protocol</a></li> + </ul> + </li> + <li><a href="#cxx">C++ compatibility</a> + <ul> + <li><a href="#vla">Variable-length arrays</a></li> + <li><a href="#dep_lookup">Unqualified lookup in templates</a></li> + <li><a href="#dep_lookup_bases">Unqualified lookup into dependent bases of class templates</a></li> + <li><a href="#undep_incomplete">Incomplete types in templates</a></li> + <li><a href="#bad_templates">Templates with no valid instantiations</a></li> + <li><a href="#default_init_const">Default initialization of const + variable of a class type requires user-defined default + constructor</a></li> + <li><a href="#param_name_lookup">Parameter name lookup</a></li> + </ul> + </li> + <li><a href="#cxx11">C++11 compatibility</a> + <ul> + <li><a href="#deleted-special-func">Deleted special member + functions</a></li> + </ul> + </li> + <li><a href="#objective-cxx">Objective-C++ compatibility</a> + <ul> + <li><a href="#implicit-downcasts">Implicit downcasts</a></li> + </ul> + <ul> + <li><a href="#class-as-property-name">Using <code>class</code> as a property name</a></li> + </ul> + </li> +</ul> + +<!-- ======================================================================= --> +<h2 id="c">C compatibility</h2> +<!-- ======================================================================= --> + +<!-- ======================================================================= --> +<h3 id="inline">C99 inline functions</h3> +<!-- ======================================================================= --> +<p>By default, Clang builds C code according to the C99 standard, +which provides different semantics for the <code>inline</code> keyword +than GCC's default behavior. For example, consider the following +code:</p> +<pre> +inline int add(int i, int j) { return i + j; } + +int main() { + int i = add(4, 5); + return i; +} +</pre> + +<p>In C99, <code>inline</code> means that a function's definition is +provided only for inlining, and that there is another definition +(without <code>inline</code>) somewhere else in the program. That +means that this program is incomplete, because if <code>add</code> +isn't inlined (for example, when compiling without optimization), then +<code>main</code> will have an unresolved reference to that other +definition. Therefore we'll get a (correct) link-time error like this:</p> + +<pre> +Undefined symbols: + "_add", referenced from: + _main in cc-y1jXIr.o +</pre> + +<p>By contrast, GCC's default behavior follows the GNU89 dialect, +which is the C89 standard plus a lot of extensions. C89 doesn't have +an <code>inline</code> keyword, but GCC recognizes it as an extension +and just treats it as a hint to the optimizer.</p> + +<p>There are several ways to fix this problem:</p> + +<ul> + <li>Change <code>add</code> to a <code>static inline</code> + function. This is usually the right solution if only one + translation unit needs to use the function. <code>static + inline</code> functions are always resolved within the translation + unit, so you won't have to add a non-<code>inline</code> definition + of the function elsewhere in your program.</li> + + <li>Remove the <code>inline</code> keyword from this definition of + <code>add</code>. The <code>inline</code> keyword is not required + for a function to be inlined, nor does it guarantee that it will be. + Some compilers ignore it completely. Clang treats it as a mild + suggestion from the programmer.</li> + + <li>Provide an external (non-<code>inline</code>) definition + of <code>add</code> somewhere else in your program. The two + definitions must be equivalent!</li> + + <li>Compile with the GNU89 dialect by adding + <code>-std=gnu89</code> to the set of Clang options. This option is + only recommended if the program source cannot be changed or if the + program also relies on additional C89-specific behavior that cannot + be changed.</li> +</ul> + +<p>All of this only applies to C code; the meaning of <code>inline</code> +in C++ is very different from its meaning in either GNU89 or C99.</p> + +<!-- ======================================================================= --> +<h3 id="vector_builtins">"missing" vector __builtin functions</h3> +<!-- ======================================================================= --> + +<p>The Intel and AMD manuals document a number "<tt><*mmintrin.h></tt>" +header files, which define a standardized API for accessing vector operations +on X86 CPUs. These functions have names like <tt>_mm_xor_ps</tt> and +<tt>_mm256_addsub_pd</tt>. Compilers have leeway to implement these functions +however they want. Since Clang supports an excellent set of <a +href="../docs/LanguageExtensions.html#vectors">native vector operations</a>, +the Clang headers implement these interfaces in terms of the native vector +operations. +</p> + +<p>In contrast, GCC implements these functions mostly as a 1-to-1 mapping to +builtin function calls, like <tt>__builtin_ia32_paddw128</tt>. These builtin +functions are an internal implementation detail of GCC, and are not portable to +the Intel compiler, the Microsoft compiler, or Clang. If you get build errors +mentioning these, the fix is simple: switch to the *mmintrin.h functions.</p> + +<p>The same issue occurs for NEON and Altivec for the ARM and PowerPC +architectures respectively. For these, make sure to use the <arm_neon.h> +and <altivec.h> headers.</p> + +<p>For x86 architectures this <a href="builtins.py">script</a> should help with +the manual migration process. It will rewrite your source files in place to +use the APIs instead of builtin function calls. Just call it like this:</p> + +<pre> + builtins.py *.c *.h +</pre> + +<p>and it will rewrite all of the .c and .h files in the current directory to +use the API calls instead of calls like <tt>__builtin_ia32_paddw128</tt>.</p> + +<!-- ======================================================================= --> +<h3 id="lvalue-cast">Lvalue casts</h3> +<!-- ======================================================================= --> + +<p>Old versions of GCC permit casting the left-hand side of an assignment to a +different type. Clang produces an error on similar code, e.g.,</p> + +<pre> +lvalue.c:2:3: error: assignment to cast is illegal, lvalue casts are not + supported + (int*)addr = val; + ^~~~~~~~~~ ~ +</pre> + +<p>To fix this problem, move the cast to the right-hand side. In this +example, one could use:</p> + +<pre> + addr = (float *)val; +</pre> + +<!-- ======================================================================= --> +<h3 id="blocks-in-protected-scope">Jumps to within <tt>__block</tt> variable scope</h3> +<!-- ======================================================================= --> + +<p>Clang disallows jumps into the scope of a <tt>__block</tt> +variable. Variables marked with <tt>__block</tt> require special +runtime initialization. A jump into the scope of a <tt>__block</tt> +variable bypasses this initialization, leaving the variable's metadata +in an invalid state. Consider the following code fragment:</p> + +<pre> +int fetch_object_state(struct MyObject *c) { + if (!c->active) goto error; + + __block int result; + run_specially_somehow(^{ result = c->state; }); + return result; + + error: + fprintf(stderr, "error while fetching object state"); + return -1; +} +</pre> + +<p>GCC accepts this code, but it produces code that will usually crash +when <code>result</code> goes out of scope if the jump is taken. (It's +possible for this bug to go undetected because it often won't crash if +the stack is fresh, i.e. still zeroed.) Therefore, Clang rejects this +code with a hard error:</p> + +<pre> +t.c:3:5: error: goto into protected scope + goto error; + ^ +t.c:5:15: note: jump bypasses setup of __block variable + __block int result; + ^ +</pre> + +<p>The fix is to rewrite the code to not require jumping into a +<tt>__block</tt> variable's scope, e.g. by limiting that scope:</p> + +<pre> + { + __block int result; + run_specially_somehow(^{ result = c->state; }); + return result; + } +</pre> + +<!-- ======================================================================= --> +<h3 id="block-variable-initialization">Non-initialization of <tt>__block</tt> +variables</h3> +<!-- ======================================================================= --> + +<p>In the following example code, the <tt>x</tt> variable is used before it is +defined:</p> +<pre> +int f0() { + __block int x; + return ^(){ return x; }(); +} +</pre> + +<p>By an accident of implementation, GCC and llvm-gcc unintentionally always +zero initialized <tt>__block</tt> variables. However, any program which depends +on this behavior is relying on unspecified compiler behavior. Programs must +explicitly initialize all local block variables before they are used, as with +other local variables.</p> + +<p>Clang does not zero initialize local block variables, and programs which rely +on such behavior will most likely break when built with Clang.</p> + + +<!-- ======================================================================= --> +<h3 id="inline-asm">Inline assembly</h3> +<!-- ======================================================================= --> + +<p>In general, Clang is highly compatible with the GCC inline assembly +extensions, allowing the same set of constraints, modifiers and operands as GCC +inline assembly.</p> + +<p>On targets that use the integrated assembler (such as most X86 targets), +inline assembly is run through the integrated assembler instead of your system +assembler (which is most commonly "gas", the GNU assembler). The LLVM +integrated assembler is extremely compatible with GAS, but there are a couple of +minor places where it is more picky, particularly due to outright GAS bugs.</p> + +<p>One specific example is that the assembler rejects ambiguous X86 instructions +that don't have suffixes. For example:</p> + +<pre> + asm("add %al, (%rax)"); + asm("addw $4, (%rax)"); + asm("add $4, (%rax)"); +</pre> + +<p>Both clang and GAS accept the first instruction: because the first +instruction uses the 8-bit <tt>%al</tt> register as an operand, it is clear that +it is an 8-bit add. The second instruction is accepted by both because the "w" +suffix indicates that it is a 16-bit add. The last instruction is accepted by +GAS even though there is nothing that specifies the size of the instruction (and +the assembler randomly picks a 32-bit add). Because it is ambiguous, Clang +rejects the instruction with this error message: +</p> + +<pre> +<inline asm>:3:1: error: ambiguous instructions require an explicit suffix (could be 'addb', 'addw', 'addl', or 'addq') +add $4, (%rax) +^ +1 error generated. +</pre> + +<p>To fix this compatibility issue, add an explicit suffix to the instruction: +this makes your code more clear and is compatible with both GCC and Clang.</p> + +<!-- ======================================================================= --> +<h2 id="objective-c">Objective-C compatibility</h2> +<!-- ======================================================================= --> + +<!-- ======================================================================= --> +<h3 id="super-cast">Cast of super</h3> +<!-- ======================================================================= --> + +<p>GCC treats the <code>super</code> identifier as an expression that +can, among other things, be cast to a different type. Clang treats +<code>super</code> as a context-sensitive keyword, and will reject a +type-cast of <code>super</code>:</p> + +<pre> +super.m:11:12: error: cannot cast 'super' (it isn't an expression) + [(Super*)super add:4]; + ~~~~~~~~^ +</pre> + +<p>To fix this problem, remove the type cast, e.g.</p> +<pre> + [super add:4]; +</pre> + +<!-- ======================================================================= --> +<h3 id="sizeof-interface">Size of interfaces</h3> +<!-- ======================================================================= --> + +<p>When using the "non-fragile" Objective-C ABI in use, the size of an +Objective-C class may change over time as instance variables are added +(or removed). For this reason, Clang rejects the application of the +<code>sizeof</code> operator to an Objective-C class when using this +ABI:</p> + +<pre> +sizeof.m:4:14: error: invalid application of 'sizeof' to interface 'NSArray' in + non-fragile ABI + int size = sizeof(NSArray); + ^ ~~~~~~~~~ +</pre> + +<p>Code that relies on the size of an Objective-C class is likely to +be broken anyway, since that size is not actually constant. To address +this problem, use the Objective-C runtime API function +<code>class_getInstanceSize()</code>:</p> + +<pre> + class_getInstanceSize([NSArray class]) +</pre> + +<!-- ======================================================================= --> +<h3 id="objc_objs-cast">Internal Objective-C types</h3> +<!-- ======================================================================= --> + +<p>GCC allows using pointers to internal Objective-C objects, <tt>struct objc_object*</tt>, +<tt>struct objc_selector*</tt>, and <tt>struct objc_class*</tt> in place of the types +<tt>id</tt>, <tt>SEL</tt>, and <tt>Class</tt> respectively. Clang treats the +internal Objective-C structures as implementation detail and won't do implicit conversions: + +<pre> +t.mm:11:2: error: no matching function for call to 'f' + f((struct objc_object *)p); + ^ +t.mm:5:6: note: candidate function not viable: no known conversion from 'struct objc_object *' to 'id' for 1st argument +void f(id x); + ^ +</pre> + +<p>Code should use types <tt>id</tt>, <tt>SEL</tt>, and <tt>Class</tt> +instead of the internal types.</p> + +<!-- ======================================================================= --> +<h3 id="c_variables-class">C variables in @interface or @protocol</h3> +<!-- ======================================================================= --> + +<p>GCC allows the declaration of C variables in +an <code>@interface</code> or <code>@protocol</code> +declaration. Clang does not allow variable declarations to appear +within these declarations unless they are marked <code>extern</code>.</p> + +<p>Variables may still be declared in an @implementation.</p> + +<pre> +@interface XX +int a; // not allowed in clang +int b = 1; // not allowed in clang +extern int c; // allowed +@end + +</pre> + +<!-- ======================================================================= --> +<h2 id="cxx">C++ compatibility</h2> +<!-- ======================================================================= --> + +<!-- ======================================================================= --> +<h3 id="vla">Variable-length arrays</h3> +<!-- ======================================================================= --> + +<p>GCC and C99 allow an array's size to be determined at run +time. This extension is not permitted in standard C++. However, Clang +supports such variable length arrays in very limited circumstances for +compatibility with GNU C and C99 programs:</p> + +<ul> + <li>The element type of a variable length array must be a POD + ("plain old data") type, which means that it cannot have any + user-declared constructors or destructors, any base classes, or any + members of non-POD type. All C types are POD types.</li> + + <li>Variable length arrays cannot be used as the type of a non-type +template parameter.</li> </ul> + +<p>If your code uses variable length arrays in a manner that Clang doesn't support, there are several ways to fix your code: + +<ol> +<li>replace the variable length array with a fixed-size array if you can + determine a reasonable upper bound at compile time; sometimes this is as + simple as changing <tt>int size = ...;</tt> to <tt>const int size + = ...;</tt> (if the initializer is a compile-time constant);</li> +<li>use <tt>std::vector</tt> or some other suitable container type; + or</li> +<li>allocate the array on the heap instead using <tt>new Type[]</tt> - + just remember to <tt>delete[]</tt> it.</li> +</ol> + +<!-- ======================================================================= --> +<h3 id="dep_lookup">Unqualified lookup in templates</h3> +<!-- ======================================================================= --> + +<p>Some versions of GCC accept the following invalid code: + +<pre> +template <typename T> T Squared(T x) { + return Multiply(x, x); +} + +int Multiply(int x, int y) { + return x * y; +} + +int main() { + Squared(5); +} +</pre> + +<p>Clang complains: + +<pre> <b>my_file.cpp:2:10: <span class="error">error:</span> call to function 'Multiply' that is neither visible in the template definition nor found by argument-dependent lookup</b> + return Multiply(x, x); + <span class="caret"> ^</span> + <b>my_file.cpp:10:3: <span class="note">note:</span> in instantiation of function template specialization 'Squared<int>' requested here</b> + Squared(5); + <span class="caret"> ^</span> + <b>my_file.cpp:5:5: <span class="note">note:</span> 'Multiply' should be declared prior to the call site</b> + int Multiply(int x, int y) { + <span class="caret"> ^</span> +</pre> + +<p>The C++ standard says that unqualified names like <q>Multiply</q> +are looked up in two ways. + +<p>First, the compiler does <i>unqualified lookup</i> in the scope +where the name was written. For a template, this means the lookup is +done at the point where the template is defined, not where it's +instantiated. Since <tt>Multiply</tt> hasn't been declared yet at +this point, unqualified lookup won't find it. + +<p>Second, if the name is called like a function, then the compiler +also does <i>argument-dependent lookup</i> (ADL). (Sometimes +unqualified lookup can suppress ADL; see [basic.lookup.argdep]p3 for +more information.) In ADL, the compiler looks at the types of all the +arguments to the call. When it finds a class type, it looks up the +name in that class's namespace; the result is all the declarations it +finds in those namespaces, plus the declarations from unqualified +lookup. However, the compiler doesn't do ADL until it knows all the +argument types. + +<p>In our example, <tt>Multiply</tt> is called with dependent +arguments, so ADL isn't done until the template is instantiated. At +that point, the arguments both have type <tt>int</tt>, which doesn't +contain any class types, and so ADL doesn't look in any namespaces. +Since neither form of lookup found the declaration +of <tt>Multiply</tt>, the code doesn't compile. + +<p>Here's another example, this time using overloaded operators, +which obey very similar rules. + +<pre>#include <iostream> + +template<typename T> +void Dump(const T& value) { + std::cout << value << "\n"; +} + +namespace ns { + struct Data {}; +} + +std::ostream& operator<<(std::ostream& out, ns::Data data) { + return out << "Some data"; +} + +void Use() { + Dump(ns::Data()); +}</pre> + +<p>Again, Clang complains:</p> + +<pre> <b>my_file2.cpp:5:13: <span class="error">error:</span> call to function 'operator<<' that is neither visible in the template definition nor found by argument-dependent lookup</b> + std::cout << value << "\n"; + <span class="caret"> ^</span> + <b>my_file2.cpp:17:3: <span class="error">note:</span> in instantiation of function template specialization 'Dump<ns::Data>' requested here</b> + Dump(ns::Data()); + <span class="caret"> ^</span> + <b>my_file2.cpp:12:15: <span class="error">note:</span> 'operator<<' should be declared prior to the call site or in namespace 'ns'</b> + std::ostream& operator<<(std::ostream& out, ns::Data data) { + <span class="caret"> ^</span> +</pre> + +<p>Just like before, unqualified lookup didn't find any declarations +with the name <tt>operator<<</tt>. Unlike before, the argument +types both contain class types: one of them is an instance of the +class template type <tt>std::basic_ostream</tt>, and the other is the +type <tt>ns::Data</tt> that we declared above. Therefore, ADL will +look in the namespaces <tt>std</tt> and <tt>ns</tt> for +an <tt>operator<<</tt>. Since one of the argument types was +still dependent during the template definition, ADL isn't done until +the template is instantiated during <tt>Use</tt>, which means that +the <tt>operator<<</tt> we want it to find has already been +declared. Unfortunately, it was declared in the global namespace, not +in either of the namespaces that ADL will look in! + +<p>There are two ways to fix this problem:</p> +<ol><li>Make sure the function you want to call is declared before the +template that might call it. This is the only option if none of its +argument types contain classes. You can do this either by moving the +template definition, or by moving the function definition, or by +adding a forward declaration of the function before the template.</li> +<li>Move the function into the same namespace as one of its arguments +so that ADL applies.</li></ol> + +<p>For more information about argument-dependent lookup, see +[basic.lookup.argdep]. For more information about the ordering of +lookup in templates, see [temp.dep.candidate]. + +<!-- ======================================================================= --> +<h3 id="dep_lookup_bases">Unqualified lookup into dependent bases of class templates</h3> +<!-- ======================================================================= --> + +Some versions of GCC accept the following invalid code: + +<pre> +template <typename T> struct Base { + void DoThis(T x) {} + static void DoThat(T x) {} +}; + +template <typename T> struct Derived : public Base<T> { + void Work(T x) { + DoThis(x); // Invalid! + DoThat(x); // Invalid! + } +}; +</pre> + +Clang correctly rejects it with the following errors +(when <tt>Derived</tt> is eventually instantiated): + +<pre> +my_file.cpp:8:5: error: use of undeclared identifier 'DoThis' + DoThis(x); + ^ + this-> +my_file.cpp:2:8: note: must qualify identifier to find this declaration in dependent base class + void DoThis(T x) {} + ^ +my_file.cpp:9:5: error: use of undeclared identifier 'DoThat' + DoThat(x); + ^ + this-> +my_file.cpp:3:15: note: must qualify identifier to find this declaration in dependent base class + static void DoThat(T x) {} +</pre> + +Like we said <a href="#dep_lookup">above</a>, unqualified names like +<tt>DoThis</tt> and <tt>DoThat</tt> are looked up when the template +<tt>Derived</tt> is defined, not when it's instantiated. When we look +up a name used in a class, we usually look into the base classes. +However, we can't look into the base class <tt>Base<T></tt> +because its type depends on the template argument <tt>T</tt>, so the +standard says we should just ignore it. See [temp.dep]p3 for details. + +<p>The fix, as Clang tells you, is to tell the compiler that we want a +class member by prefixing the calls with <tt>this-></tt>: + +<pre> + void Work(T x) { + <b>this-></b>DoThis(x); + <b>this-></b>DoThat(x); + } +</pre> + +Alternatively, you can tell the compiler exactly where to look: + +<pre> + void Work(T x) { + <b>Base<T></b>::DoThis(x); + <b>Base<T></b>::DoThat(x); + } +</pre> + +This works whether the methods are static or not, but be careful: +if <tt>DoThis</tt> is virtual, calling it this way will bypass virtual +dispatch! + +<!-- ======================================================================= --> +<h3 id="undep_incomplete">Incomplete types in templates</h3> +<!-- ======================================================================= --> + +The following code is invalid, but compilers are allowed to accept it: + +<pre> + class IOOptions; + template <class T> bool read(T &value) { + IOOptions opts; + return read(opts, value); + } + + class IOOptions { bool ForceReads; }; + bool read(const IOOptions &opts, int &x); + template bool read<>(int &); +</pre> + +The standard says that types which don't depend on template parameters +must be complete when a template is defined if they affect the +program's behavior. However, the standard also says that compilers +are free to not enforce this rule. Most compilers enforce it to some +extent; for example, it would be an error in GCC to +write <tt>opts.ForceReads</tt> in the code above. In Clang, we feel +that enforcing the rule consistently lets us provide a better +experience, but unfortunately it also means we reject some code that +other compilers accept. + +<p>We've explained the rule here in very imprecise terms; see +[temp.res]p8 for details. + +<!-- ======================================================================= --> +<h3 id="bad_templates">Templates with no valid instantiations</h3> +<!-- ======================================================================= --> + +The following code contains a typo: the programmer +meant <tt>init()</tt> but wrote <tt>innit()</tt> instead. + +<pre> + template <class T> class Processor { + ... + void init(); + ... + }; + ... + template <class T> void process() { + Processor<T> processor; + processor.innit(); // <-- should be 'init()' + ... + } +</pre> + +Unfortunately, we can't flag this mistake as soon as we see it: inside +a template, we're not allowed to make assumptions about "dependent +types" like <tt>Processor<T></tt>. Suppose that later on in +this file the programmer adds an explicit specialization +of <tt>Processor</tt>, like so: + +<pre> + template <> class Processor<char*> { + void innit(); + }; +</pre> + +Now the program will work — as long as the programmer only ever +instantiates <tt>process()</tt> with <tt>T = char*</tt>! This is why +it's hard, and sometimes impossible, to diagnose mistakes in a +template definition before it's instantiated. + +<p>The standard says that a template with no valid instantiations is +ill-formed. Clang tries to do as much checking as possible at +definition-time instead of instantiation-time: not only does this +produce clearer diagnostics, but it also substantially improves +compile times when using pre-compiled headers. The downside to this +philosophy is that Clang sometimes fails to process files because they +contain broken templates that are no longer used. The solution is +simple: since the code is unused, just remove it. + +<!-- ======================================================================= --> +<h3 id="default_init_const">Default initialization of const variable of a class type requires user-defined default constructor</h3> +<!-- ======================================================================= --> + +If a <tt>class</tt> or <tt>struct</tt> has no user-defined default +constructor, C++ doesn't allow you to default construct a <tt>const</tt> +instance of it like this ([dcl.init], p9): + +<pre> +class Foo { + public: + // The compiler-supplied default constructor works fine, so we + // don't bother with defining one. + ... +}; + +void Bar() { + const Foo foo; // Error! + ... +} +</pre> + +To fix this, you can define a default constructor for the class: + +<pre> +class Foo { + public: + Foo() {} + ... +}; + +void Bar() { + const Foo foo; // Now the compiler is happy. + ... +} +</pre> + +<!-- ======================================================================= --> +<h3 id="param_name_lookup">Parameter name lookup</h3> +<!-- ======================================================================= --> + +<p>Due to a bug in its implementation, GCC allows the redeclaration of function parameter names within a function prototype in C++ code, e.g.</p> +<blockquote> +<pre> +void f(int a, int a); +</pre> +</blockquote> +<p>Clang diagnoses this error (where the parameter name has been redeclared). To fix this problem, rename one of the parameters.</p> + +<!-- ======================================================================= --> +<h2 id="cxx11">C++11 compatibility</h2> +<!-- ======================================================================= --> + +<!-- ======================================================================= --> +<h3 id="deleted-special-func">Deleted special member functions</h3> +<!-- ======================================================================= --> + +<p>In C++11, the explicit declaration of a move constructor or a move +assignment operator within a class deletes the implicit declaration +of the copy constructor and copy assignment operator. This change came +fairly late in the C++11 standardization process, so early +implementations of C++11 (including Clang before 3.0, GCC before 4.7, +and Visual Studio 2010) do not implement this rule, leading them to +accept this ill-formed code:</p> + +<pre> +struct X { + X(X&&); <i>// deletes implicit copy constructor:</i> + <i>// X(const X&) = delete;</i> +}; + +void f(X x); +void g(X x) { + f(x); <i>// error: X has a deleted copy constructor</i> +} +</pre> + +<p>This affects some early C++11 code, including Boost's popular <a +href="http://www.boost.org/doc/libs/release/libs/smart_ptr/shared_ptr.htm"><tt>shared_ptr</tt></a> +up to version 1.47.0. The fix for Boost's <tt>shared_ptr</tt> is +<a href="https://svn.boost.org/trac/boost/changeset/73202">available here</a>.</p> + +<!-- ======================================================================= --> +<h2 id="objective-cxx">Objective-C++ compatibility</h2> +<!-- ======================================================================= --> + +<!-- ======================================================================= --> +<h3 id="implicit-downcasts">Implicit downcasts</h3> +<!-- ======================================================================= --> + +<p>Due to a bug in its implementation, GCC allows implicit downcasts +of Objective-C pointers (from a base class to a derived class) when +calling functions. Such code is inherently unsafe, since the object +might not actually be an instance of the derived class, and is +rejected by Clang. For example, given this code:</p> + +<pre> +@interface Base @end +@interface Derived : Base @end + +void f(Derived *p); +void g(Base *p) { + f(p); +} +</pre> + +<p>Clang produces the following error:</p> + +<pre> +downcast.mm:6:3: error: no matching function for call to 'f' + f(p); + ^ +downcast.mm:4:6: note: candidate function not viable: cannot convert from + superclass 'Base *' to subclass 'Derived *' for 1st argument +void f(Derived *p); + ^ +</pre> + +<p>If the downcast is actually correct (e.g., because the code has +already checked that the object has the appropriate type), add an +explicit cast:</p> + +<pre> + f((Derived *)base); +</pre> + +<!-- ======================================================================= --> +<h3 id="class-as-property-name">Using <code>class</code> as a property name</h3> +<!-- ======================================================================= --> + +<p>In C and Objective-C, <code>class</code> is a normal identifier and +can be used to name fields, ivars, methods, and so on. In +C++, <code>class</code> is a keyword. For compatibility with existing +code, Clang permits <code>class</code> to be used as part of a method +selector in Objective-C++, but this does not extend to any other part +of the language. In particular, it is impossible to use property dot +syntax in Objective-C++ with the property name <code>class</code>, so +the following code will fail to parse:</p> + +<pre> +@interface I { +int cls; +} ++ (int)class; +@end + +@implementation I +- (int) Meth { return I.class; } +@end +</pre> + +<p>Use explicit message-send syntax instead, i.e. <code>[I class]</code>.</p> + +</div> +</body> +</html> diff --git a/clang/www/content.css b/clang/www/content.css new file mode 100644 index 0000000..574b98e --- /dev/null +++ b/clang/www/content.css @@ -0,0 +1,30 @@ +html { margin: 0px; } body { margin: 8px; } + +html, body { + padding:0px; + font-size:small; font-family:"Lucida Grande", "Lucida Sans Unicode", Arial, Verdana, Helvetica, sans-serif; background-color: #fff; color: #222; + line-height:1.5; +} + +h1, h2, h3, tt { color: #000 } + +h1 { padding-top:0px; margin-top:0px;} +h2 { color:#333333; padding-top:0.5em; } +h3 { padding-top: 0.5em; margin-bottom: -0.25em; color:#2d58b7} +li { padding-bottom: 0.5em; } +ul { padding-left:1.5em; } + +/* Slides */ +IMG.img_slide { + display: block; + margin-left: auto; + margin-right: auto +} + +.itemTitle { color:#2d58b7 } + +span.error { color:red } +span.caret { color:green; font-weight:bold } + +/* Tables */ +tr { vertical-align:top } diff --git a/clang/www/cxx_compatibility.html b/clang/www/cxx_compatibility.html new file mode 100644 index 0000000..5351a02 --- /dev/null +++ b/clang/www/cxx_compatibility.html @@ -0,0 +1,27 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> +<meta HTTP-EQUIV="REFRESH" content="5; url=compatibility.html#c++"> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>Clang - C++ Compatibility</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <style type="text/css"> +</style> +</head> +<body> + +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<!-- ======================================================================= --> +<h1>Clang's C++ Compatibility</h1> +<!-- ======================================================================= --> + + <p>The Clang C++ compatibility page has moved. You will be directed <a href="compatibility.html#c++">to its new home</a> in 5 seconds.</p> + +</div> +</body> +</html> diff --git a/clang/www/cxx_status.html b/clang/www/cxx_status.html new file mode 100644 index 0000000..3687376 --- /dev/null +++ b/clang/www/cxx_status.html @@ -0,0 +1,381 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>Clang - C++98 and C++11 Status</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <style type="text/css"> + .none { background-color: #FFCCCC } + .svn { background-color: #FFFF99 } + .full { background-color: #CCFF99 } + .na { background-color: #DDDDDD } + th { background-color: #FFDDAA } + </style> +</head> +<body> + +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<!--*************************************************************************--> +<h1>C++98 and C++11 Support in Clang</h1> +<!--*************************************************************************--> +<p>Last updated: $Date: 2012-04-16 18:04:22 -0700 (Mon, 16 Apr 2012) $</p> + +<h2 id="cxx98">C++98 implementation status</h2> + +<p>Clang currently implements all of the ISO C++ 1998 standard + (including the defects addressed in the ISO C++ 2003 standard) + except for 'export' (which has been removed in C++11) + and is considered a production-quality C++ compiler. The <a + href="http://llvm.org/bugs/">LLVM bug tracker</a> contains a Clang + C++ component that tracks known Clang C++ bugs.</p> + +<h2 id="cxx11">C++11 implementation status</h2> + + <p>Clang provides support for a number of features included in the new <a href="http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=50372">ISO C++ Standard, ISO/IEC 14882:2011</a>. The following table describes which C++11 features have been implemented in Clang and in which Clang versions they became available.</p> + +<p>You can use Clang in C++11 mode either +with <a href="http://libcxx.llvm.org/">libc++</a> or with gcc's libstdc++. +Patches are needed to make <a href="libstdc++4.4-clang0x.patch">libstdc++-4.4</a> +and <a href="libstdc++4.7-clang11.patch">libstdc++-4.7</a> work with Clang in +C++11 mode.</p> + +<table width="689" border="1" cellspacing="0"> + <tr> + <th>Language Feature</th> + <th>C++11 Proposal</th> + <th>Available in Clang?</th> + </tr> + <tr> + <td>Rvalue references</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html">N2118</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td> Rvalue references for <code>*this</code></td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm">N2439</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Initialization of class objects by rvalues</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1610.html">N1610</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Non-static data member initializers</td> + <td><a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2756.htm">N2756</a></td> + <td class="full" align="center">Clang 3.0</td> + </tr> + <tr> + <td>Variadic templates</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf">N2242</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td> Extending variadic template template parameters</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf">N2555</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Initializer lists</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm">N2672</a></td> + <td class="svn" align="center">SVN</td> + </tr> + <tr> + <td>Static assertions</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html">N1720</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td><code>auto</code>-typed variables</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf">N1984</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td> Multi-declarator <code>auto</code></td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1737.pdf">N1737</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td> Removal of auto as a storage-class specifier</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2546.htm">N2546</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td> New function declarator syntax</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2541.htm">N2541</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Lambda expressions</td> + <td><a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2927.pdf">N2927</a></td> + <td class="svn" align="center">SVN</td> + </tr> + <tr> + <td>Declared type of an expression</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf">N2343</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td> Incomplete return types</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3276.pdf">N3276</a></td> + <td class="svn" align="center">SVN</td> + </tr> + <tr> + <td>Right angle brackets</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html">N1757</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Default template arguments for function templates</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#226">DR226</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Solving the SFINAE problem for expressions</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2634.html">DR339</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Alias templates</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf">N2258</a></td> + <td class="full" align="center">Clang 3.0</td> + </tr> + <tr> + <td>Extern templates</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1987.htm">N1987</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Null pointer constant</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf">N2431</a></td> + <td class="full" align="center">Clang 3.0</td> + </tr> + <tr> + <td>Strongly-typed enums</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf">N2347</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Forward declarations for enums</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf">N2764</a> + <br><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1206">DR1206</a></td> + <td class="svn" align="center">SVN</td> + </tr> + <tr> + <td>Generalized attributes</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf">N2761</a></td> + <td class="none" align="center">No</td> + </tr> + <tr> + <td>Generalized constant expressions</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf">N2235</a></td> + <td class="svn" align="center">SVN</td> + </tr> + <tr> + <td>Alignment support</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf">N2341</a></td> + <td class="full" align="center">Clang 3.0</td> + </tr> + <!-- Skipped N1627: Conditionally-support behavior --> + <!-- Skipped N1727: Changing Undefined Behavior into Diagnosable Errors --> + <tr> + <td>Delegating constructors</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf">N1986</a></td> + <td class="full" align="center">Clang 3.0</td> + </tr> + <tr> + <td>Inheriting constructors</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm">N2540</a></td> + <td class="none" align="center">No</td> + </tr> + <tr> + <td>Explicit conversion operators</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf">N2437</a></td> + <td class="full" align="center">Clang 3.0</td> + </tr> + <tr> + <td>New character types</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2249.html">N2249</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Unicode string literals</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm">N2442</a></td> + <td class="full" align="center">Clang 3.0</td> + </tr> + <tr> + <td>Raw string literals</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm">N2442</a></td> + <td class="full" align="center">Clang 3.0</td> + </tr> + <tr> + <td>Universal character names in literals</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2170.html">N2170</a></td> + <td class="svn" align="center">SVN</td> + </tr> + <tr> + <td>User-defined literals</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf">N2765</a></td> + <td class="svn" align="center">SVN</td> + </tr> + <tr> + <td>Standard Layout Types</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm">N2342</a></td> + <td class="full" align="center">Clang 3.0</td> + </tr> + <tr> + <td>Defaulted functions</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm">N2346</a></td> + <td class="full" align="center">Clang 3.0</td> + </tr> + <tr> + <td>Deleted functions</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm">N2346</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Extended friend declarations</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf">N1791</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Extending <code>sizeof</code></td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html">N2253</a> + <br><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#850">DR850</a></td> + <td class="svn" align="center">SVN</td> + </tr> + <tr> + <td>Inline namespaces</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm">N2535</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Unrestricted unions</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf">N2544</a></td> + <td class="svn" align="center">SVN</td> + </tr> + <tr> + <td>Local and unnamed types as template arguments</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm">N2657</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Range-based for</td> + <td><a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2930.html">N2930</a></td> + <td class="full" align="center">Clang 3.0</td> + </tr> + <tr> + <td>Explicit virtual overrides</td> + <td><a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2928.htm">N2928</a> + <br><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm">N3206</a> + <br><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm">N3272</a></td> + <td class="full" align="center">Clang 3.0</td> + </tr> + <tr> + <td>Minimal support for garbage collection and reachability-based leak detection</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2670.htm">N2670</a></td> + <td class="na" align="center">N/A</td> + </tr> + <tr> + <td>Allowing move constructors to throw [noexcept]</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html">N3050</a></td> + <td class="full" align="center">Clang 3.0</td> + </tr> + <tr> + <td>Defining move special member functions</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html">N3053</a></td> + <td class="full" align="center">Clang 3.0</td> + </tr> + + <tr class="separator"> + <th align="center" colspan="3">Concurrency</th> + </tr> + <tr> + <td>Sequence points</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html">N2239</a></td> + <td class="none" align="center">No</td> + </tr> + <tr> + <td>Atomic operations</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html">N2427</a></td> + <td class="svn" align="center">SVN</td> + </tr> + <tr> + <td>Strong Compare and Exchange</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2748.html">N2748</a></td> + <td class="none" align="center">No</td> + </tr> + <tr> + <td>Bidirectional Fences</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2752.htm">N2752</a></td> + <td class="svn" align="center">SVN</td> + </tr> + + <tr> + <td>Memory model</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2429.htm">N2429</a></td> + <td class="none" align="center">No</td> + </tr> + <tr> + <td>Data-dependency ordering: atomics and memory model</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2664.htm">N2664</a></td> + <td class="none" align="center">No</td> + </tr> + <tr> + <td>Propagating exceptions</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2179.html">N2179</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Abandoning a process and at_quick_exit</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2440.htm">N2440</a></td> + <td class="na" align="center">N/A</td> + </tr> + <tr> + <td>Allow atomics use in signal handlers</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2547.htm">N2547</a></td> + <td class="svn" align="center">SVN</td> + </tr> + <tr> + <td>Thread-local storage</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2659.htm">N2659</a></td> + <td class="none" align="center">No</td> + </tr> + <tr> + <td>Dynamic initialization and destruction with concurrency</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm">N2660</a></td> + <td class="none" align="center">No</td> + </tr> + + <tr class="separator"> + <th align="center" colspan="3">C99 Features in C++11</th> + </tr> + <tr> + <td><code>__func__</code> predefined identifier</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2340.htm">N2340</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>C99 preprocessor</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm">N1653</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td><code>long long</code></td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf">N1811</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Extended integral types</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1988.pdf">N1988</a></td> + <td class="none" align="center">No</td> + </tr> +</table> +</div> +</body> +</html> diff --git a/clang/www/demo/DemoInfo.html b/clang/www/demo/DemoInfo.html new file mode 100644 index 0000000..54a5afa --- /dev/null +++ b/clang/www/demo/DemoInfo.html @@ -0,0 +1,83 @@ + +<html> +<head> +<title> +Demo page information +</title> +</head> + +<body> + +<h1>Demo page information</h1> + +<p>Press "back" or <a href=".">click here</a> to return to the demo +page.</p> + +<h2><a name="hints">Hints and Advice</a></h2> + +<ul> +<li>The generated LLVM code will be easier to read if +you use stdio (e.g., printf) than iostreams (e.g., std::cout).</li> + +<li>Unused inline functions and methods are not generated. Instead +of '<tt>class foo { void bar() {}};</tt>', +try writing '<tt>class foo { void bar(); }; void foo::bar() {}</tt>'.</li> + +<li>If you want to try out a file that uses non-standard header files, you should + preprocess it (e.g., with the <tt>-save-temps</tt> or <tt>-E</tt> options to + <tt>gcc</tt>) then upload the result.</li> + +</ul> + + +<h2><a name="demangle">Demangle C++ names with C++ filt</a></h2> + +<p> +Select this option if you want to run the output LLVM IR through "c++filt", +which converts 'mangled' C++ names to their unmangled version. +Note that LLVM code produced will not be lexically valid, but it will +be easier to understand. +</p> + +<h2><a name="lto">Run link-time optimizer</a></h2> + +<p> +Select this option to run the LLVM link-time optimizer, which is designed to +optimize across files in your application. Since the demo page doesn't allow +you to upload multiple files at once, and does not link in any libraries, we +configured the demo page optimizer to assume there are no calls +coming in from outside the source file, allowing it to optimize more +aggressively.</p> + +<p>Note that you have to define 'main' in your program for this +to make much of a difference. +</p> + +<h2><a name="stats">Show detailed pass statistics</a></h2> + +<p> +Select this option to enable compilation timings and statistics from various +optimizers.</p> + + +<h2><a name="bcanalyzer">Analyze generated bytecode</a></h2> + +<p> +Select this option to run the <a +href="http://llvm.org/cmds/llvm-bcanalyzer.html">llvm-bcanalyzer</a> tool +on the generated bytecode, which introspects into the format of the .bc file +itself. </p> + + +<h2><a name="llvm2cpp">Show C++ API code</a></h2> + +<p> +Select this option to run the <a +href="http://llvm.org/cmds/llvm2cpp.html">llvm2cpp</a> tool +on the generated bytecode, which auto generates the C++ API calls that could +be used to create the .bc file. +</p> + +</body> +</html> + diff --git a/clang/www/demo/cathead.png b/clang/www/demo/cathead.png Binary files differnew file mode 100644 index 0000000..3bf1a45 --- /dev/null +++ b/clang/www/demo/cathead.png diff --git a/clang/www/demo/index.cgi b/clang/www/demo/index.cgi new file mode 100644 index 0000000..901b009 --- /dev/null +++ b/clang/www/demo/index.cgi @@ -0,0 +1,461 @@ +#!/usr/dcs/software/supported/bin/perl -w +# LLVM Web Demo script +# + +use strict; +use CGI; +use POSIX; +use Mail::Send; + +$| = 1; + +my $ROOT = "/tmp/webcompile"; +#my $ROOT = "/home/vadve/lattner/webcompile"; + +open( STDERR, ">&STDOUT" ) or die "can't redirect stderr to stdout"; + +if ( !-d $ROOT ) { mkdir( $ROOT, 0777 ); } + +my $LOGFILE = "$ROOT/log.txt"; +my $FORM_URL = 'index.cgi'; +my $MAILADDR = 'sabre@nondot.org'; +my $CONTACT_ADDRESS = 'Questions or comments? Email the <a href="http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev">LLVMdev mailing list</a>.'; +my $LOGO_IMAGE_URL = 'cathead.png'; +my $TIMEOUTAMOUNT = 20; +$ENV{'LD_LIBRARY_PATH'} = '/home/vadve/shared/localtools/fc1/lib/'; + +my @PREPENDPATHDIRS = + ( + '/home/vadve/shared/llvm-gcc4.0-2.1/bin/', + '/home/vadve/shared/llvm-2.1/Release/bin'); + +my $defaultsrc = "#include <stdio.h>\n#include <stdlib.h>\n\n" . + "int power(int X) {\n if (X == 0) return 1;\n" . + " return X*power(X-1);\n}\n\n" . + "int main(int argc, char **argv) {\n" . + " printf(\"%d\\n\", power(atoi(argv[0])));\n}\n"; + +sub getname { + my ($extension) = @_; + for ( my $count = 0 ; ; $count++ ) { + my $name = + sprintf( "$ROOT/_%d_%d%s", $$, $count, $extension ); + if ( !-f $name ) { return $name; } + } +} + +my $c; + +sub barf { + print "<b>", @_, "</b>\n"; + print $c->end_html; + system("rm -f $ROOT/locked"); + exit 1; +} + +sub writeIntoFile { + my $extension = shift @_; + my $contents = join "", @_; + my $name = getname($extension); + local (*FILE); + open( FILE, ">$name" ) or barf("Can't write to $name: $!"); + print FILE $contents; + close FILE; + return $name; +} + +sub addlog { + my ( $source, $pid, $result ) = @_; + open( LOG, ">>$LOGFILE" ); + my $time = scalar localtime; + my $remotehost = $ENV{'REMOTE_ADDR'}; + print LOG "[$time] [$remotehost]: $pid\n"; + print LOG "<<<\n$source\n>>>\nResult is: <<<\n$result\n>>>\n"; + close LOG; +} + +sub dumpFile { + my ( $header, $file ) = @_; + my $result; + open( FILE, "$file" ) or barf("Can't read $file: $!"); + while (<FILE>) { + $result .= $_; + } + close FILE; + my $UnhilightedResult = $result; + my $HtmlResult = + "<h3>$header</h3>\n<pre>\n" . $c->escapeHTML($result) . "\n</pre>\n"; + if (wantarray) { + return ( $UnhilightedResult, $HtmlResult ); + } + else { + return $HtmlResult; + } +} + +sub syntaxHighlightLLVM { + my ($input) = @_; + $input =~ s@\b(void|i8|i1|i16|i32|i64|float|double|type|label|opaque)\b@<span class="llvm_type">$1</span>@g; + $input =~ s@\b(add|sub|mul|div|rem|and|or|xor|setne|seteq|setlt|setgt|setle|setge|phi|tail|call|cast|to|shl|shr|vaarg|vanext|ret|br|switch|invoke|unwind|malloc|alloca|free|load|store|getelementptr|begin|end|true|false|declare|global|constant|const|internal|uninitialized|external|implementation|linkonce|weak|appending|null|to|except|not|target|endian|pointersize|big|little|volatile)\b@<span class="llvm_keyword">$1</span>@g; + + # Add links to the FAQ. + $input =~ s@(_ZNSt8ios_base4Init[DC]1Ev)@<a href="../docs/FAQ.html#iosinit">$1</a>@g; + $input =~ s@\bundef\b@<a href="../docs/FAQ.html#undef">undef</a>@g; + return $input; +} + +sub mailto { + my ( $recipient, $body ) = @_; + my $msg = + new Mail::Send( Subject => "LLVM Demo Page Run", To => $recipient ); + my $fh = $msg->open(); + print $fh $body; + $fh->close(); +} + +$c = new CGI; +print $c->header; + +print <<EOF; +<html> +<head> + <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"> + <title>Try out LLVM in your browser!</title> + <style> + \@import url("syntax.css"); + \@import url("http://llvm.org/llvm.css"); + </style> +</head> +<body leftmargin="10" marginwidth="10"> + +<div class="www_sectiontitle"> + Try out LLVM in your browser! +</div> + +<table border=0><tr><td> +<img align=right width=100 height=111 src="$LOGO_IMAGE_URL"> +</td><td> +EOF + +if ( -f "$ROOT/locked" ) { + my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$locktime) = + stat("$ROOT/locked"); + my $currtime = time(); + if ($locktime + 60 > $currtime) { + print "This page is already in use by someone else at this "; + print "time, try reloading in a second or two. Meow!</td></tr></table>'\n"; + exit 0; + } +} + +system("touch $ROOT/locked"); + +print <<END; +Bitter Melon the cat says, paste a C/C++ program in the text box or upload +one from your computer, and you can see LLVM compile it, meow!! +</td></tr></table><p> +END + +print $c->start_multipart_form( 'POST', $FORM_URL ); + +my $source = $c->param('source'); + + +# Start the user out with something valid if no code. +$source = $defaultsrc if (!defined($source)); + +print '<table border="0"><tr><td>'; + +print "Type your source code in below: (<a href='DemoInfo.html#hints'>hints and +advice</a>)<br>\n"; + +print $c->textarea( + -name => "source", + -rows => 16, + -columns => 60, + -default => $source +), "<br>"; + +print "Or upload a file: "; +print $c->filefield( -name => 'uploaded_file', -default => '' ); + +print "<p />\n"; + + +print '<p></td><td valign=top>'; + +print "<center><h3>General Options</h3></center>"; + +print "Source language: ", + $c->radio_group( + -name => 'language', + -values => [ 'C', 'C++' ], + -default => 'C' + ), "<p>"; + +print $c->checkbox( + -name => 'linkopt', + -label => 'Run link-time optimizer', + -checked => 'checked' + ),' <a href="DemoInfo.html#lto">?</a><br>'; + +print $c->checkbox( + -name => 'showstats', + -label => 'Show detailed pass statistics' + ), ' <a href="DemoInfo.html#stats">?</a><br>'; + +print $c->checkbox( + -name => 'cxxdemangle', + -label => 'Demangle C++ names' + ),' <a href="DemoInfo.html#demangle">?</a><p>'; + + +print "<center><h3>Output Options</h3></center>"; + +print $c->checkbox( + -name => 'showbcanalysis', + -label => 'Show detailed bytecode analysis' + ),' <a href="DemoInfo.html#bcanalyzer">?</a><br>'; + +print $c->checkbox( + -name => 'showllvm2cpp', + -label => 'Show LLVM C++ API code' + ), ' <a href="DemoInfo.html#llvm2cpp">?</a>'; + +print "</td></tr></table>"; + +print "<center>", $c->submit(-value=> 'Compile Source Code'), + "</center>\n", $c->endform; + +print "\n<p>If you have questions about the LLVM code generated by the +front-end, please check the <a href='/docs/FAQ.html#cfe_code'>FAQ</a> and +the demo page <a href='DemoInfo.html#hints'>hints section</a>. +</p>\n"; + +$ENV{'PATH'} = ( join ( ':', @PREPENDPATHDIRS ) ) . ":" . $ENV{'PATH'}; + +sub sanitychecktools { + my $sanitycheckfail = ''; + + # insert tool-specific sanity checks here + $sanitycheckfail .= ' llvm-dis' + if `llvm-dis --help 2>&1` !~ /ll disassembler/; + + $sanitycheckfail .= ' llvm-gcc' + if ( `llvm-gcc --version 2>&1` !~ /Free Software Foundation/ ); + + $sanitycheckfail .= ' llvm-ld' + if `llvm-ld --help 2>&1` !~ /llvm linker/; + + $sanitycheckfail .= ' llvm-bcanalyzer' + if `llvm-bcanalyzer --help 2>&1` !~ /bcanalyzer/; + + barf( +"<br/>The demo page is currently unavailable. [tools: ($sanitycheckfail ) failed sanity check]" + ) + if $sanitycheckfail; +} + +sanitychecktools(); + +sub try_run { + my ( $program, $commandline, $outputFile ) = @_; + my $retcode = 0; + + eval { + local $SIG{ALRM} = sub { die "timeout"; }; + alarm $TIMEOUTAMOUNT; + $retcode = system($commandline); + alarm 0; + }; + if ( $@ and $@ =~ /timeout/ ) { + barf("Program $program took too long, compile time limited for the web script, sorry!\n"); + } + if ( -s $outputFile ) { + print scalar dumpFile( "Output from $program", $outputFile ); + } + #print "<p>Finished dumping command output.</p>\n"; + if ( WIFEXITED($retcode) && WEXITSTATUS($retcode) != 0 ) { + barf( +"$program exited with an error. Please correct source and resubmit.<p>\n" . +"Please note that this form only allows fully formed and correct source" . +" files. It will not compile fragments of code.<p>" + ); + } + if ( WIFSIGNALED($retcode) != 0 ) { + my $sig = WTERMSIG($retcode); + barf( + "Ouch, $program caught signal $sig. Sorry, better luck next time!\n" + ); + } +} + +my %suffixes = ( + 'Java' => '.java', + 'JO99' => '.jo9', + 'C' => '.c', + 'C++' => '.cc', + 'Stacker' => '.st', + 'preprocessed C' => '.i', + 'preprocessed C++' => '.ii' +); +my %languages = ( + '.jo9' => 'JO99', + '.java' => 'Java', + '.c' => 'C', + '.i' => 'preprocessed C', + '.ii' => 'preprocessed C++', + '.cc' => 'C++', + '.cpp' => 'C++', + '.st' => 'Stacker' +); + +my $uploaded_file_name = $c->param('uploaded_file'); +if ($uploaded_file_name) { + if ($source) { + barf( +"You must choose between uploading a file and typing code in. You can't do both at the same time." + ); + } + $uploaded_file_name =~ s/^.*(\.[A-Za-z]+)$/$1/; + my $language = $languages{$uploaded_file_name}; + $c->param( 'language', $language ); + + print "<p>Processing uploaded file. It looks like $language.</p>\n"; + my $fh = $c->upload('uploaded_file'); + if ( !$fh ) { + barf( "Error uploading file: " . $c->cgi_error ); + } + while (<$fh>) { + $source .= $_; + } + close $fh; +} + +if ($c->param('source')) { + print $c->hr; + my $extension = $suffixes{ $c->param('language') }; + barf "Unknown language; can't compile\n" unless $extension; + + # Add a newline to the source here to avoid a warning from gcc. + $source .= "\n"; + + # Avoid security hole due to #including bad stuff. + $source =~ +s@(\n)?#include.*[<"](.*\.\..*)[">].*\n@$1#error "invalid #include file $2 detected"\n@g; + + my $inputFile = writeIntoFile( $extension, $source ); + my $pid = $$; + + my $bytecodeFile = getname(".bc"); + my $outputFile = getname(".llvm-gcc.out"); + my $timerFile = getname(".llvm-gcc.time"); + + my $stats = ''; + if ( $extension eq ".st" ) { + $stats = "-stats -time-passes " + if ( $c->param('showstats') ); + try_run( "llvm Stacker front-end (stkrc)", + "stkrc $stats -o $bytecodeFile $inputFile > $outputFile 2>&1", + $outputFile ); + } else { + #$stats = "-Wa,--stats,--time-passes,--info-output-file=$timerFile" + $stats = "-ftime-report" + if ( $c->param('showstats') ); + try_run( "llvm C/C++ front-end (llvm-gcc)", + "llvm-gcc -emit-llvm -W -Wall -O2 $stats -o $bytecodeFile -c $inputFile > $outputFile 2>&1", + $outputFile ); + } + + if ( $c->param('showstats') && -s $timerFile ) { + my ( $UnhilightedResult, $HtmlResult ) = + dumpFile( "Statistics for front-end compilation", $timerFile ); + print "$HtmlResult\n"; + } + + if ( $c->param('linkopt') ) { + my $stats = ''; + my $outputFile = getname(".gccld.out"); + my $timerFile = getname(".gccld.time"); + $stats = "--stats --time-passes --info-output-file=$timerFile" + if ( $c->param('showstats') ); + my $tmpFile = getname(".bc"); + try_run( + "optimizing linker (llvm-ld)", +"llvm-ld $stats -o=$tmpFile $bytecodeFile > $outputFile 2>&1", + $outputFile + ); + system("mv $tmpFile.bc $bytecodeFile"); + system("rm $tmpFile"); + + if ( $c->param('showstats') && -s $timerFile ) { + my ( $UnhilightedResult, $HtmlResult ) = + dumpFile( "Statistics for optimizing linker", $timerFile ); + print "$HtmlResult\n"; + } + } + + print " Bytecode size is ", -s $bytecodeFile, " bytes.\n"; + + my $disassemblyFile = getname(".ll"); + try_run( "llvm-dis", + "llvm-dis -o=$disassemblyFile $bytecodeFile > $outputFile 2>&1", + $outputFile ); + + if ( $c->param('cxxdemangle') ) { + print " Demangling disassembler output.\n"; + my $tmpFile = getname(".ll"); + system("c++filt < $disassemblyFile > $tmpFile 2>&1"); + system("mv $tmpFile $disassemblyFile"); + } + + my ( $UnhilightedResult, $HtmlResult ); + if ( -s $disassemblyFile ) { + ( $UnhilightedResult, $HtmlResult ) = + dumpFile( "Output from LLVM disassembler", $disassemblyFile ); + print syntaxHighlightLLVM($HtmlResult); + } + else { + print "<p>Hmm, that's weird, llvm-dis didn't produce any output.</p>\n"; + } + + if ( $c->param('showbcanalysis') ) { + my $analFile = getname(".bca"); + try_run( "llvm-bcanalyzer", "llvm-bcanalyzer $bytecodeFile > $analFile 2>&1", + $analFile); + } + if ($c->param('showllvm2cpp') ) { + my $l2cppFile = getname(".l2cpp"); + try_run("llvm2cpp","llvm2cpp $bytecodeFile -o $l2cppFile 2>&1", + $l2cppFile); + } + + # Get the source presented by the user to CGI, convert newline sequences to simple \n. + my $actualsrc = $c->param('source'); + $actualsrc =~ s/\015\012/\n/go; + # Don't log this or mail it if it is the default code. + if ($actualsrc ne $defaultsrc) { + addlog( $source, $pid, $UnhilightedResult ); + + my ( $ip, $host, $lg, $lines ); + chomp( $lines = `wc -l < $inputFile` ); + $lg = $c->param('language'); + $ip = $c->remote_addr(); + chomp( $host = `host $ip` ) if $ip; + mailto( $MAILADDR, + "--- Query: ---\nFrom: ($ip) $host\nInput: $lines lines of $lg\n" + . "C++ demangle = " + . ( $c->param('cxxdemangle') ? 1 : 0 ) + . ", Link opt = " + . ( $c->param('linkopt') ? 1 : 0 ) . "\n\n" + . ", Show stats = " + . ( $c->param('showstats') ? 1 : 0 ) . "\n\n" + . "--- Source: ---\n$source\n" + . "--- Result: ---\n$UnhilightedResult\n" ); + } + unlink( $inputFile, $bytecodeFile, $outputFile, $disassemblyFile ); +} + +print $c->hr, "<address>$CONTACT_ADDRESS</address>", $c->end_html; +system("rm $ROOT/locked"); +exit 0; diff --git a/clang/www/demo/syntax.css b/clang/www/demo/syntax.css new file mode 100644 index 0000000..90daf5f --- /dev/null +++ b/clang/www/demo/syntax.css @@ -0,0 +1,4 @@ +/* LLVM syntax highlighting for the Web */ + +.llvm_type { font-style: oblique; color: green } +.llvm_keyword { font-weight: bold; color: blue } diff --git a/clang/www/demo/what is this directory.txt b/clang/www/demo/what is this directory.txt new file mode 100644 index 0000000..a1306ac --- /dev/null +++ b/clang/www/demo/what is this directory.txt @@ -0,0 +1,15 @@ +This is for the LLVM+Clang browser based demo. +It is supposed to work like the LLVM+GCC demo here: http://llvm.org/demo/ but for the BSD licensed Clang instead. + +Perhaps it could also be used for getting crash information and details on errors.... I'm not sure if this would require some major changes or not to report this info. Maybe also adding ways that people can use it to test for errors and a way to report such errors would also be good. + +Status: +Anyways, right now, these file a basically just a copy of the LLVM+GCC demo (no changes have been made). The files don't even work right in this location on the server. As such, someone will need to edit the file or rewrite it. + +If nobody in the LLVM community has the skills, one suggestion would be to post a request on a friendly Perl forum and see if anybody might be interested in taking on the challenge. + +Alternatively, you could try a PHP, Python, Ruby, or Lisp mailing list and see if there are any takers who would be interested (and willing to do a rewrite to their language of choice). + +-- +BTW, once this feature was working, my intention was to link to it from the index.html page in the section entitled: +Try Clang
\ No newline at end of file diff --git a/clang/www/diagnostics.html b/clang/www/diagnostics.html new file mode 100644 index 0000000..45f6907 --- /dev/null +++ b/clang/www/diagnostics.html @@ -0,0 +1,374 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <meta http-equiv="content-type" content="text/html; charset=iso-8859-1"> + <title>Clang - Expressive Diagnostics</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <style type="text/css"> + .warn { color:magenta; } + .err { color:red; } + .snip { color:darkgreen; } + .point { color:blue; } + </style> +</head> +<body> + +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + + +<!--=======================================================================--> +<h1>Expressive Diagnostics</h1> +<!--=======================================================================--> + +<p>In addition to being fast and functional, we aim to make Clang extremely user +friendly. As far as a command-line compiler goes, this basically boils down to +making the diagnostics (error and warning messages) generated by the compiler +be as useful as possible. There are several ways that we do this. This section +talks about the experience provided by the command line compiler, contrasting +Clang output to GCC 4.2's output in several examples. +<!-- +Other clients +that embed Clang and extract equivalent information through internal APIs.--> +</p> + +<h2>Column Numbers and Caret Diagnostics</h2> + +<p>First, all diagnostics produced by clang include full column number +information. The clang command-line compiler driver uses this information +to print "point diagnostics". +(IDEs can use the information to display in-line error markup.) +Precise error location in the source is a feature provided by many commercial +compilers, but is generally missing from open source +compilers. This is nice because it makes it very easy to understand exactly +what is wrong in a particular piece of code</p> + +<p>The point (the blue "^" character) exactly shows where the problem is, even +inside of a string. This makes it really easy to jump to the problem and +helps when multiple instances of the same character occur on a line. (We'll +revisit this more in following examples.)</p> + +<pre> + $ <b>gcc-4.2 -fsyntax-only -Wformat format-strings.c</b> + format-strings.c:91: warning: too few arguments for format + $ <b>clang -fsyntax-only format-strings.c</b> + format-strings.c:91:13: <span class="warn">warning:</span> '.*' specified field precision is missing a matching 'int' argument + <span class="snip"> printf("%.*d");</span> + <span class="point"> ^</span> +</pre> + +<h2>Range Highlighting for Related Text</h2> + +<p>Clang captures and accurately tracks range information for expressions, +statements, and other constructs in your program and uses this to make +diagnostics highlight related information. In the following somewhat +nonsensical example you can see that you don't even need to see the original source code to +understand what is wrong based on the Clang error. Because clang prints a +point, you know exactly <em>which</em> plus it is complaining about. The range +information highlights the left and right side of the plus which makes it +immediately obvious what the compiler is talking about. +Range information is very useful for +cases involving precedence issues and many other cases.</p> + +<pre> + $ <b>gcc-4.2 -fsyntax-only t.c</b> + t.c:7: error: invalid operands to binary + (have 'int' and 'struct A') + $ <b>clang -fsyntax-only t.c</b> + t.c:7:39: <span class="err">error:</span> invalid operands to binary expression ('int' and 'struct A') + <span class="snip"> return y + func(y ? ((SomeA.X + 40) + SomeA) / 42 + SomeA.X : SomeA.X);</span> + <span class="point"> ~~~~~~~~~~~~~~ ^ ~~~~~</span> +</pre> + +<h2>Precision in Wording</h2> + +<p>A detail is that we have tried really hard to make the diagnostics that come +out of clang contain exactly the pertinent information about what is wrong and +why. In the example above, we tell you what the inferred types are for +the left and right hand sides, and we don't repeat what is obvious from the +point (e.g., that this is a "binary +").</p> + +<p>Many other examples abound. In the following example, not only do we tell you that there is a problem with the * +and point to it, we say exactly why and tell you what the type is (in case it is +a complicated subexpression, such as a call to an overloaded function). This +sort of attention to detail makes it much easier to understand and fix problems +quickly.</p> + +<pre> + $ <b>gcc-4.2 -fsyntax-only t.c</b> + t.c:5: error: invalid type argument of 'unary *' + $ <b>clang -fsyntax-only t.c</b> + t.c:5:11: <span class="err">error:</span> indirection requires pointer operand ('int' invalid) + <span class="snip"> int y = *SomeA.X;</span> + <span class="point"> ^~~~~~~~</span> +</pre> + +<h2>No Pretty Printing of Expressions in Diagnostics</h2> + +<p>Since Clang has range highlighting, it never needs to pretty print your code +back out to you. GCC can produce inscrutible error messages in some cases when +it tries to do this. In this example P and Q have type "int*":</p> + +<pre> + $ <b>gcc-4.2 -fsyntax-only t.c</b> + #'exact_div_expr' not supported by pp_c_expression#'t.c:12: error: called object is not a function + $ <b>clang -fsyntax-only t.c</b> + t.c:12:8: <span class="err">error:</span> called object type 'int' is not a function or function pointer + <span class="snip"> (P-Q)();</span> + <span class="point"> ~~~~~^</span> +</pre> + +<p>This can be particularly bad in G++, which often emits errors + containing lowered vtable references. For example:</p> + +<pre> + $ <b>cat t.cc</b> + struct a { + virtual int bar(); + }; + + struct foo : public virtual a { + }; + + void test(foo *P) { + return P->bar() + *P; + } + $ <b>gcc-4.2 t.cc</b> + t.cc: In function 'void test(foo*)': + t.cc:9: error: no match for 'operator+' in '(((a*)P) + (*(long int*)(P->foo::<anonymous>.a::_vptr$a + -0x00000000000000020)))->a::bar() + * P' + t.cc:9: error: return-statement with a value, in function returning 'void' + $ <b>clang t.cc</b> + t.cc:9:18: <span class="err">error:</span> invalid operands to binary expression ('int' and 'foo') + <span class="snip"> return P->bar() + *P;</span> + <span class="point"> ~~~~~~~~ ^ ~~</span> +</pre> + + +<h2>Typedef Preservation and Selective Unwrapping</h2> + +<p>Many programmers use high-level user defined types, typedefs, and other +syntactic sugar to refer to types in their program. This is useful because they +can abbreviate otherwise very long types and it is useful to preserve the +typename in diagnostics. However, sometimes very simple typedefs can wrap +trivial types and it is important to strip off the typedef to understand what +is going on. Clang aims to handle both cases well.<p> + +<p>The following example shows where it is important to preserve +a typedef in C. Here the type printed by GCC isn't even valid, but if the error +were about a very long and complicated type (as often happens in C++) the error +message would be ugly just because it was long and hard to read.</p> + +<pre> + $ <b>gcc-4.2 -fsyntax-only t.c</b> + t.c:15: error: invalid operands to binary / (have 'float __vector__' and 'const int *') + $ <b>clang -fsyntax-only t.c</b> + t.c:15:11: <span class="err">error:</span> can't convert between vector values of different size ('__m128' and 'int const *') + <span class="snip"> myvec[1]/P;</span> + <span class="point"> ~~~~~~~~^~</span> +</pre> + +<p>The following example shows where it is useful for the compiler to expose +underlying details of a typedef. If the user was somehow confused about how the +system "pid_t" typedef is defined, Clang helpfully displays it with "aka".</p> + +<pre> + $ <b>gcc-4.2 -fsyntax-only t.c</b> + t.c:13: error: request for member 'x' in something not a structure or union + $ <b>clang -fsyntax-only t.c</b> + t.c:13:9: <span class="err">error:</span> member reference base type 'pid_t' (aka 'int') is not a structure or union + <span class="snip"> myvar = myvar.x;</span> + <span class="point"> ~~~~~ ^</span> +</pre> + +<p>In C++, type preservation includes retaining any qualification written into type names. For example, if we take a small snippet of code such as: + +<blockquote> +<pre> +namespace services { + struct WebService { }; +} +namespace myapp { + namespace servers { + struct Server { }; + } +} + +using namespace myapp; +void addHTTPService(servers::Server const &server, ::services::WebService const *http) { + server += http; +} +</pre> +</blockquote> + +<p>and then compile it, we see that Clang is both providing more accurate information and is retaining the types as written by the user (e.g., "servers::Server", "::services::WebService"): + +<pre> + $ <b>g++-4.2 -fsyntax-only t.cpp</b> + t.cpp:9: error: no match for 'operator+=' in 'server += http' + $ <b>clang -fsyntax-only t.cpp</b> + t.cpp:9:10: <span class="err">error:</span> invalid operands to binary expression ('servers::Server const' and '::services::WebService const *') + <span class="snip">server += http;</span> + <span class="point">~~~~~~ ^ ~~~~</span> +</pre> + +<p>Naturally, type preservation extends to uses of templates, and Clang retains information about how a particular template specialization (like <code>std::vector<Real></code>) was spelled within the source code. For example:</p> + +<pre> + $ <b>g++-4.2 -fsyntax-only t.cpp</b> + t.cpp:12: error: no match for 'operator=' in 'str = vec' + $ <b>clang -fsyntax-only t.cpp</b> + t.cpp:12:7: <span class="err">error:</span> incompatible type assigning 'vector<Real>', expected 'std::string' (aka 'class std::basic_string<char>') + <span class="snip">str = vec</span>; + <span class="point">^ ~~~</span> +</pre> + +<h2>Fix-it Hints</h2> + +<p>"Fix-it" hints provide advice for fixing small, localized problems +in source code. When Clang produces a diagnostic about a particular +problem that it can work around (e.g., non-standard or redundant +syntax, missing keywords, common mistakes, etc.), it may also provide +specific guidance in the form of a code transformation to correct the +problem. In the following example, Clang warns about the use of a GCC +extension that has been considered obsolete since 1993. The underlined +code should be removed, then replaced with the code below the +point line (".x =" or ".y =", respectively).</p> + +<pre> + $ <b>clang t.c</b> + t.c:5:28: <span class="warn">warning:</span> use of GNU old-style field designator extension + <span class="snip">struct point origin = { x: 0.0, y: 0.0 };</span> + <span class="err">~~</span> <span class="point">^</span> + <span class="snip">.x = </span> + t.c:5:36: <span class="warn">warning:</span> use of GNU old-style field designator extension + <span class="snip">struct point origin = { x: 0.0, y: 0.0 };</span> + <span class="err">~~</span> <span class="point">^</span> + <span class="snip">.y = </span> +</pre> + +<p>"Fix-it" hints are most useful for +working around common user errors and misconceptions. For example, C++ users +commonly forget the syntax for explicit specialization of class templates, +as in the error in the following example. Again, after describing the problem, +Clang provides the fix--add <code>template<></code>--as part of the +diagnostic.<p> + +<pre> + $ <b>clang t.cpp</b> + t.cpp:9:3: <span class="err">error:</span> template specialization requires 'template<>' + struct iterator_traits<file_iterator> { + <span class="point">^</span> + <span class="snip">template<> </span> +</pre> + +<h2>Automatic Macro Expansion</h2> + +<p>Many errors happen in macros that are sometimes deeply nested. With +traditional compilers, you need to dig deep into the definition of the macro to +understand how you got into trouble. The following simple example shows how +Clang helps you out by automatically printing instantiation information and +nested range information for diagnostics as they are instantiated through macros +and also shows how some of the other pieces work in a bigger example.</p> + +<pre> + $ <b>gcc-4.2 -fsyntax-only t.c</b> + t.c: In function 'test': + t.c:80: error: invalid operands to binary < (have 'struct mystruct' and 'float') + $ <b>clang -fsyntax-only t.c</b> + t.c:80:3: <span class="err">error:</span> invalid operands to binary expression ('typeof(P)' (aka 'struct mystruct') and 'typeof(F)' (aka 'float')) + <span class="snip"> X = MYMAX(P, F);</span> + <span class="point"> ^~~~~~~~~~~</span> + t.c:76:94: note: instantiated from: + <span class="snip">#define MYMAX(A,B) __extension__ ({ __typeof__(A) __a = (A); __typeof__(B) __b = (B); __a < __b ? __b : __a; })</span> + <span class="point"> ~~~ ^ ~~~</span> +</pre> + +<p>Here's another real world warning that occurs in the "window" Unix package (which +implements the "wwopen" class of APIs):</p> + +<pre> + $ <b>clang -fsyntax-only t.c</b> + t.c:22:2: <span class="warn">warning:</span> type specifier missing, defaults to 'int' + <span class="snip"> ILPAD();</span> + <span class="point"> ^</span> + t.c:17:17: note: instantiated from: + <span class="snip">#define ILPAD() PAD((NROW - tt.tt_row) * 10) /* 1 ms per char */</span> + <span class="point"> ^</span> + t.c:14:2: note: instantiated from: + <span class="snip"> register i; \</span> + <span class="point"> ^</span> +</pre> + +<p>In practice, we've found that Clang's treatment of macros is actually more useful in multiply nested +macros that in simple ones.</p> + +<h2>Quality of Implementation and Attention to Detail</h2> + +<p>Finally, we have put a lot of work polishing the little things, because +little things add up over time and contribute to a great user experience.</p> + +<p>The following example shows a trivial little tweak, where we tell you to put the semicolon at +the end of the line that is missing it (line 4) instead of at the beginning of +the following line (line 5). This is particularly important with fixit hints +and point diagnostics, because otherwise you don't get the important context. +</p> + +<pre> + $ <b>gcc-4.2 t.c</b> + t.c: In function 'foo': + t.c:5: error: expected ';' before '}' token + $ <b>clang t.c</b> + t.c:4:8: <span class="err">error:</span> expected ';' after expression + <span class="snip"> bar()</span> + <span class="point"> ^</span> + <span class="point"> ;</span> +</pre> + +<p>The following example shows much better error recovery than GCC. The message coming out +of GCC is completely useless for diagnosing the problem. Clang tries much harder +and produces a much more useful diagnosis of the problem.</p> + +<pre> + $ <b>gcc-4.2 t.c</b> + t.c:3: error: expected '=', ',', ';', 'asm' or '__attribute__' before '*' token + $ <b>clang t.c</b> + t.c:3:1: <span class="err">error:</span> unknown type name 'foo_t' + <span class="snip">foo_t *P = 0;</span> + <span class="point">^</span> +</pre> + +<p>The following example shows that we recover from the simple case of +forgetting a ; after a struct definition much better than GCC.</p> + +<pre> + $ <b>cat t.cc</b> + template<class T> + class a {} + class temp {}; + a<temp> b; + struct b { + } + $ <b>gcc-4.2 t.cc</b> + t.cc:3: error: multiple types in one declaration + t.cc:4: error: non-template type 'a' used as a template + t.cc:4: error: invalid type in declaration before ';' token + t.cc:6: error: expected unqualified-id at end of input + $ <b>clang t.cc</b> + t.cc:2:11: <span class="err">error:</span> expected ';' after class + <span class="snip">class a {}</span> + <span class="point"> ^</span> + <span class="point"> ;</span> + t.cc:6:2: <span class="err">error:</span> expected ';' after struct + <span class="snip">}</span> + <span class="point"> ^</span> + <span class="point"> ;</span> +</pre> + +<p>While each of these details is minor, we feel that they all add up to provide +a much more polished experience.</p> + +</div> +</body> +</html> diff --git a/clang/www/favicon.ico b/clang/www/favicon.ico Binary files differnew file mode 100644 index 0000000..724ad6e --- /dev/null +++ b/clang/www/favicon.ico diff --git a/clang/www/feature-compile1.png b/clang/www/feature-compile1.png Binary files differnew file mode 100644 index 0000000..cec7c48 --- /dev/null +++ b/clang/www/feature-compile1.png diff --git a/clang/www/feature-compile2.png b/clang/www/feature-compile2.png Binary files differnew file mode 100644 index 0000000..0eb9300 --- /dev/null +++ b/clang/www/feature-compile2.png diff --git a/clang/www/feature-memory1.png b/clang/www/feature-memory1.png Binary files differnew file mode 100644 index 0000000..29368aa --- /dev/null +++ b/clang/www/feature-memory1.png diff --git a/clang/www/features.html b/clang/www/features.html new file mode 100644 index 0000000..d55391a --- /dev/null +++ b/clang/www/features.html @@ -0,0 +1,426 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>Clang - Features and Goals</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <style type="text/css"> +</style> +</head> +<body> + +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<!--*************************************************************************--> +<h1>Clang - Features and Goals</h1> +<!--*************************************************************************--> + +<p> +This page describes the <a href="index.html#goals">features and goals</a> of +Clang in more detail and gives a more broad explanation about what we mean. +These features are: +</p> + +<p>End-User Features:</p> + +<ul> +<li><a href="#performance">Fast compiles and low memory use</a></li> +<li><a href="#expressivediags">Expressive diagnostics</a></li> +<li><a href="#gcccompat">GCC compatibility</a></li> +</ul> + +<p>Utility and Applications:</p> + +<ul> +<li><a href="#libraryarch">Library based architecture</a></li> +<li><a href="#diverseclients">Support diverse clients</a></li> +<li><a href="#ideintegration">Integration with IDEs</a></li> +<li><a href="#license">Use the LLVM 'BSD' License</a></li> +</ul> + +<p>Internal Design and Implementation:</p> + +<ul> +<li><a href="#real">A real-world, production quality compiler</a></li> +<li><a href="#simplecode">A simple and hackable code base</a></li> +<li><a href="#unifiedparser">A single unified parser for C, Objective C, C++, + and Objective C++</a></li> +<li><a href="#conformance">Conformance with C/C++/ObjC and their + variants</a></li> +</ul> + +<!--*************************************************************************--> +<h2><a name="enduser">End-User Features</a></h2> +<!--*************************************************************************--> + + +<!--=======================================================================--> +<h3><a name="performance">Fast compiles and Low Memory Use</a></h3> +<!--=======================================================================--> + +<p>A major focus of our work on clang is to make it fast, light and scalable. +The library-based architecture of clang makes it straight-forward to time and +profile the cost of each layer of the stack, and the driver has a number of +options for performance analysis.</p> + +<p>While there is still much that can be done, we find that the clang front-end +is significantly quicker than gcc and uses less memory For example, when +compiling "Carbon.h" on Mac OS/X, we see that clang is 2.5x faster than GCC:</p> + +<img class="img_slide" src="feature-compile1.png" width="400" height="300" + alt="Time to parse carbon.h: -fsyntax-only"> + +<p>Carbon.h is a monster: it transitively includes 558 files, 12.3M of code, +declares 10000 functions, has 2000 struct definitions, 8000 fields, 20000 enum +constants, etc (see slide 25+ of the <a href="clang_video-07-25-2007.html">clang +talk</a> for more information). It is also #include'd into almost every C file +in a GUI app on the Mac, so its compile time is very important.</p> + +<p>From the slide above, you can see that we can measure the time to preprocess +the file independently from the time to parse it, and independently from the +time to build the ASTs for the code. GCC doesn't provide a way to measure the +parser without AST building (it only provides -fsyntax-only). In our +measurements, we find that clang's preprocessor is consistently 40% faster than +GCCs, and the parser + AST builder is ~4x faster than GCC's. If you have +sources that do not depend as heavily on the preprocessor (or if you +use Precompiled Headers) you may see a much bigger speedup from clang. +</p> + +<p>Compile time performance is important, but when using clang as an API, often +memory use is even moreso: the less memory the code takes the more code you can +fit into memory at a time (useful for whole program analysis tools, for +example).</p> + +<img class="img_slide" src="feature-memory1.png" width="400" height="300" + alt="Space"> + +<p>Here we see a huge advantage of clang: its ASTs take <b>5x less memory</b> +than GCC's syntax trees, despite the fact that clang's ASTs capture far more +source-level information than GCC's trees do. This feat is accomplished through +the use of carefully designed APIs and efficient representations.</p> + +<p>In addition to being efficient when pitted head-to-head against GCC in batch +mode, clang is built with a <a href="#libraryarch">library based +architecture</a> that makes it relatively easy to adapt it and build new tools +with it. This means that it is often possible to apply out-of-the-box thinking +and novel techniques to improve compilation in various ways.</p> + +<img class="img_slide" src="feature-compile2.png" width="400" height="300" + alt="Preprocessor Speeds: GCC 4.2 vs clang-all"> + +<p>This slide shows how the clang preprocessor can be used to make "distcc" +parallelization <b>3x</b> more scalable than when using the GCC preprocessor. +"distcc" quickly bottlenecks on the preprocessor running on the central driver +machine, so a fast preprocessor is very useful. Comparing the first two bars +of each group shows how a ~40% faster preprocessor can reduce preprocessing time +of these large C++ apps by about 40% (shocking!).</p> + +<p>The third bar on the slide is the interesting part: it shows how trivial +caching of file system accesses across invocations of the preprocessor allows +clang to reduce time spent in the kernel by 10x, making distcc over 3x more +scalable. This is obviously just one simple hack, doing more interesting things +(like caching tokens across preprocessed files) would yield another substantial +speedup.</p> + +<p>The clean framework-based design of clang means that many things are possible +that would be very difficult in other systems, for example incremental +compilation, multithreading, intelligent caching, etc. We are only starting +to tap the full potential of the clang design.</p> + + +<!--=======================================================================--> +<h3><a name="expressivediags">Expressive Diagnostics</a></h3> +<!--=======================================================================--> + +<p>In addition to being fast and functional, we aim to make Clang extremely user +friendly. As far as a command-line compiler goes, this basically boils down to +making the diagnostics (error and warning messages) generated by the compiler +be as useful as possible. There are several ways that we do this, but the +most important are pinpointing exactly what is wrong in the program, +highlighting related information so that it is easy to understand at a glance, +and making the wording as clear as possible.</p> + +<p>Here is one simple example that illustrates the difference between a typical +GCC and Clang diagnostic:</p> + +<pre> + $ <b>gcc-4.2 -fsyntax-only t.c</b> + t.c:7: error: invalid operands to binary + (have 'int' and 'struct A') + $ <b>clang -fsyntax-only t.c</b> + t.c:7:39: error: invalid operands to binary expression ('int' and 'struct A') + <span style="color:darkgreen"> return y + func(y ? ((SomeA.X + 40) + SomeA) / 42 + SomeA.X : SomeA.X);</span> + <span style="color:blue"> ~~~~~~~~~~~~~~ ^ ~~~~~</span> +</pre> + +<p>Here you can see that you don't even need to see the original source code to +understand what is wrong based on the Clang error: Because clang prints a +caret, you know exactly <em>which</em> plus it is complaining about. The range +information highlights the left and right side of the plus which makes it +immediately obvious what the compiler is talking about, which is very useful for +cases involving precedence issues and many other situations.</p> + +<p>Clang diagnostics are very polished and have many features. For more +information and examples, please see the <a href="diagnostics.html">Expressive +Diagnostics</a> page.</p> + +<!--=======================================================================--> +<h3><a name="gcccompat">GCC Compatibility</a></h3> +<!--=======================================================================--> + +<p>GCC is currently the defacto-standard open source compiler today, and it +routinely compiles a huge volume of code. GCC supports a huge number of +extensions and features (many of which are undocumented) and a lot of +code and header files depend on these features in order to build.</p> + +<p>While it would be nice to be able to ignore these extensions and focus on +implementing the language standards to the letter, pragmatics force us to +support the GCC extensions that see the most use. Many users just want their +code to compile, they don't care to argue about whether it is pedantically C99 +or not.</p> + +<p>As mentioned above, all +extensions are explicitly recognized as such and marked with extension +diagnostics, which can be mapped to warnings, errors, or just ignored. +</p> + + +<!--*************************************************************************--> +<h2><a name="applications">Utility and Applications</a></h2> +<!--*************************************************************************--> + +<!--=======================================================================--> +<h3><a name="libraryarch">Library Based Architecture</a></h3> +<!--=======================================================================--> + +<p>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).</p> + +<blockquote><p> +"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."</p></blockquote> + +<p> +Currently, clang is divided into the following libraries and tool: +</p> + +<ul> +<li><b>libsupport</b> - Basic support library, from LLVM.</li> +<li><b>libsystem</b> - System abstraction library, from LLVM.</li> +<li><b>libbasic</b> - Diagnostics, SourceLocations, SourceBuffer abstraction, + file system caching for input source files.</li> +<li><b>libast</b> - Provides classes to represent the C AST, the C type system, + builtin functions, and various helpers for analyzing and manipulating the + AST (visitors, pretty printers, etc).</li> +<li><b>liblex</b> - Lexing and preprocessing, identifier hash table, pragma + handling, tokens, and macro expansion.</li> +<li><b>libparse</b> - Parsing. This library invokes coarse-grained 'Actions' + provided by the client (e.g. libsema builds ASTs) but knows nothing about + ASTs or other client-specific data structures.</li> +<li><b>libsema</b> - Semantic Analysis. This provides a set of parser actions + to build a standardized AST for programs.</li> +<li><b>libcodegen</b> - Lower the AST to LLVM IR for optimization & code + generation.</li> +<li><b>librewrite</b> - Editing of text buffers (important for code rewriting + transformation, like refactoring).</li> +<li><b>libanalysis</b> - Static analysis support.</li> +<li><b>clang</b> - A driver program, client of the libraries at various + levels.</li> +</ul> + +<p>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.</p> + +<p>For more information about the low-level implementation details of the +various clang libraries, please see the <a href="docs/InternalsManual.html"> +clang Internals Manual</a>.</p> + +<!--=======================================================================--> +<h3><a name="diverseclients">Support Diverse Clients</a></h3> +<!--=======================================================================--> + +<p>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.</p> + +<p>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.</p> + +<p>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 +<em>across the whole program</em> 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.</p> + +<p>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.</p> + +<p>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.</p> + +<!--=======================================================================--> +<h3 id="ideintegration">Integration with IDEs</h3> +<!--=======================================================================--> + +<p> +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.</p> + +<p>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.</p> + +<p>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. +</p> + + +<!--=======================================================================--> +<h3><a name="license">Use the LLVM 'BSD' License</a></h3> +<!--=======================================================================--> + +<p>We actively intend for clang (and 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.</p> + +<p>For more information about the LLVM/clang license, please see the <a +href="http://llvm.org/docs/DeveloperPolicy.html#license">LLVM License +Description</a> for more information.</p> + + + +<!--*************************************************************************--> +<h2><a name="design">Internal Design and Implementation</a></h2> +<!--*************************************************************************--> + +<!--=======================================================================--> +<h3><a name="real">A real-world, production quality compiler</a></h3> +<!--=======================================================================--> + +<p> +Clang is designed and built by experienced compiler developers who +are increasingly frustrated with the problems that <a +href="comparison.html">existing open source compilers</a> have. Clang is +carefully and thoughtfully designed and built to provide the foundation of a +whole new generation of C/C++/Objective C development tools, and we intend for +it to be production quality.</p> + +<p>Being a production quality compiler means many things: it means being high +performance, being solid and (relatively) bug free, and it means eventually +being used and depended on by a broad range of people. While we are still in +the early development stages, we strongly believe that this will become a +reality.</p> + +<!--=======================================================================--> +<h3><a name="simplecode">A simple and hackable code base</a></h3> +<!--=======================================================================--> + +<p>Our goal is to make it possible for anyone with a basic understanding +of compilers and working knowledge of the C/C++/ObjC languages to understand and +extend the clang source base. A large part of this falls out of our decision to +make the AST mirror the languages as closely as possible: you have your friendly +if statement, for statement, parenthesis expression, structs, unions, etc, all +represented in a simple and explicit way.</p> + +<p>In addition to a simple design, we work to make the source base approachable +by commenting it well, including citations of the language standards where +appropriate, and designing the code for simplicity. Beyond that, clang offers +a set of AST dumpers, printers, and visualizers that make it easy to put code in +and see how it is represented.</p> + +<!--=======================================================================--> +<h3><a name="unifiedparser">A single unified parser for C, Objective C, C++, +and Objective C++</a></h3> +<!--=======================================================================--> + +<p>Clang is the "C Language Family Front-end", which means we intend to support +the most popular members of the C family. We are convinced that the right +parsing technology for this class of languages is a hand-built recursive-descent +parser. Because it is plain C++ code, recursive descent makes it very easy for +new developers to understand the code, it easily supports ad-hoc rules and other +strange hacks required by C/C++, and makes it straight-forward to implement +excellent diagnostics and error recovery.</p> + +<p>We believe that implementing C/C++/ObjC in a single unified parser makes the +end result easier to maintain and evolve than maintaining a separate C and C++ +parser which must be bugfixed and maintained independently of each other.</p> + +<!--=======================================================================--> +<h3><a name="conformance">Conformance with C/C++/ObjC and their + variants</a></h3> +<!--=======================================================================--> + +<p>When you start work on implementing a language, you find out that there is a +huge gap between how the language works and how most people understand it to +work. This gap is the difference between a normal programmer and a (scary? +super-natural?) "language lawyer", who knows the ins and outs of the language +and can grok standardese with ease.</p> + +<p>In practice, being conformant with the languages means that we aim to support +the full language, including the dark and dusty corners (like trigraphs, +preprocessor arcana, C99 VLAs, etc). Where we support extensions above and +beyond what the standard officially allows, we make an effort to explicitly call +this out in the code and emit warnings about it (which are disabled by default, +but can optionally be mapped to either warnings or errors), allowing you to use +clang in "strict" mode if you desire.</p> + +<p>We also intend to support "dialects" of these languages, such as C89, K&R +C, C++'03, Objective-C 2, etc.</p> + +</div> +</body> +</html> diff --git a/clang/www/get_involved.html b/clang/www/get_involved.html new file mode 100644 index 0000000..9ed2d47 --- /dev/null +++ b/clang/www/get_involved.html @@ -0,0 +1,90 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>Clang - Get Involved</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> +</head> +<body> + +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<h1>Getting Involved with the Clang Project</h1> + +<p>Once you have <a href="get_started.html">checked out and built</a> clang and +played around with it, you might be wondering what you can do to make it better +and contribute to its development. Alternatively, maybe you just want to follow +the development of the project to see it progress. +</p> + +<h2>Follow what's going on</h2> + +<p>Clang is a subproject of the <a href="http://llvm.org">LLVM Project</a>, but +has its own mailing lists because the communities have people with different +interests. The two clang lists are:</p> + +<ul> +<li><a href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits">cfe-commits +</a> - This list is for patch submission/discussion.</li> + +<li><a href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-dev">cfe-dev</a> - +This list is for everything else Clang related (questions and answers, design +discussions, etc).</li> + +</ul> + +<p>If you are interested in clang only, these two lists should be all +you need. If you are interested in the LLVM optimizer and code generator, +please consider signing up for <a +href="http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev">llvmdev</a> and <a +href="http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits">llvm-commits</a> +as well.</p> + + +<p>The best way to talk with other developers on the project is through the <a +href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-dev">cfe-dev mailing +list</a>. The clang mailing list is a very friendly place and we welcome +newcomers. In addition to the cfe-dev list, a significant amount of design +discussion takes place on the <a +href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits">cfe-commits mailing +list</a>. All of these lists have archives, so you can browse through previous +discussions or follow the list development on the web if you prefer.</p> + +<p>If you're looking for something to work on, check out our <a href="OpenProjects.html">Open Projects</a> page or go look through the <a href="http://llvm.org/bugs/">Bugzilla bug database</a>.</p> + +<h2 id="criteria">Contributing Extensions to Clang</h2> + +<p>Clang has always been designed as a platform for experimentation, +allowing programmers to easily extend the compiler to support great +new language features and tools. At some point, the authors of these +extensions may propose that the extensions become a part of Clang +itself, to benefit the whole Clang community. But not every idea--not +even every great idea--should become part of Clang. Extensions +(particularly language extensions) pose a long-term maintenance burden +on Clang, and therefore the benefits of the extension must outweight +those costs. Hence, these are the seven criteria used to evaluate the +merits of a proposed extension:</p> + +<ol> + <li>Evidence of a significant user community: This is based on a number of factors, including an actual, existing user community, the perceived likelihood that users would adopt such a feature if it were available, and any "trickle-down" effects that come from, e.g., a library adopting the feature and providing benefits to its users.</li> + + <li>A specific need to reside within the Clang tree: There are some extensions that would be better expressed as a separate tool, and should remain as separate tools even if they end up being hosted as part of the LLVM umbrella project.</li> + + <li>A complete specification: The specification must be sufficient to understand the design of the feature as well as interpret the meaning of specific examples. The specification should be detailed enough that another compiler vendor could conceivably implement the feature.</li> + + <li>Representation within the appropriate governing organization: For extensions to a language governed by a standards committee (C, C++, OpenCL), the extension itself must have an active proposal and proponent within that committee and have a reasonable chance of acceptance. Clang should drive the standard, not diverge from it. This criterion does not apply to all extensions, since some extensions fall outside of the realm of the standards bodies.</li> + + <li>A long-term support plan: Contributing a non-trivial extension to Clang implies a commitment to supporting that extension, improving the implementation and specification as Clang evolves. The capacity of the contributor to make that commitment is as important as the commitment itself.</li> + + <li>A high-quality implementation: The implementation must fit well into Clang's architecture, follow LLVM's coding conventions, and meet Clang's quality standards, including high-quality diagnostics and rich AST representations. This is particularly important for language extensions, because users will learn how those extensions work through the behavior of the compiler.</li> + + <li>A proper test suite: Extensive testing is crucial to ensure that the language extension is not broken by ongoing maintenance in Clang. The test suite should be complete enough that another compiler vendor could conceivably validate their implementation of the feature against it.</li> +</ol> + +</div> +</body> +</html> diff --git a/clang/www/get_started.html b/clang/www/get_started.html new file mode 100644 index 0000000..d819532 --- /dev/null +++ b/clang/www/get_started.html @@ -0,0 +1,306 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>Clang - Getting Started</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> +</head> +<body> + +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<h1>Getting Started: Building and Running Clang</h1> + +<p>This page gives you the shortest path to checking out Clang and demos a few +options. This should get you up and running with the minimum of muss and fuss. +If you like what you see, please consider <a href="get_involved.html">getting +involved</a> with the Clang community. If you run into problems, please file +bugs in <a href="http://llvm.org/bugs/">LLVM Bugzilla</a>.</p> + +<h2 id="download">Release Clang Versions</h2> + +<p>Clang has been released as part of regular LLVM releases since LLVM 2.6. You +can download the release versions +from <a href="http://llvm.org/releases/">http://llvm.org/releases/</a>.</p> + +<h2 id="build">Building Clang and Working with the Code</h2> + +<h3 id="buildNix">On Unix-like Systems</h3> + +<p>If you would like to check out and build Clang, the current procedure is as +follows:</p> + +<ol> + <li>Get the required tools. + <ul> + <li>See + <a href="http://llvm.org/docs/GettingStarted.html#requirements"> + Getting Started with the LLVM System - Requirements</a>.</li> + <li>Note also that Python is needed for running the test suite. + Get it at: <a href="http://www.python.org/download"> + http://www.python.org/download</a></li> + </ul> + + <li>Checkout LLVM: + <ul> + <li>Change directory to where you want the llvm directory placed.</li> + <li><tt>svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm</tt></li> + </ul> + </li> + <li>Checkout Clang: + <ul> + <li><tt>cd llvm/tools</tt> + <li><tt>svn co http://llvm.org/svn/llvm-project/cfe/trunk clang</tt></li> + </ul> + </li> + <li>Checkout Compiler-RT: + <ul> + <li><tt>cd ../..</tt> (back to where you started)</li> + <li><tt>cd llvm/projects</tt> + <li><tt>svn co http://llvm.org/svn/llvm-project/compiler-rt/trunk + compiler-rt</tt></li> + </ul> + </li> + <li>Build LLVM and Clang: + <ul> + <li><tt>cd ../..</tt> (back to where you started)</li> + <li><tt>mkdir build</tt> (for building without polluting the source dir) + </li> + <li><tt>cd build</tt></li> + <li><tt>../llvm/configure</tt></li> + <li><tt>make</tt></li> + <li>This builds both LLVM and Clang for debug mode.</li> + <li>Note: For subsequent Clang development, you can just do make at the + clang directory level.</li> + <li>It is also possible to use CMake instead of the makefiles. With CMake + it is also possible to generate project files for several IDEs: Eclipse + CDT4, CodeBlocks, Qt-Creator (use the CodeBlocks generator), KDevelop3.</li> + </ul> + </li> + + <li>If you intend to work on Clang C++ support, you may need to tell it how + to find your C++ standard library headers. If Clang cannot find your + system libstdc++ headers, please follow these instructions: + <ul> + <li>'<tt>gcc -v -x c++ /dev/null -fsyntax-only</tt>' to get the + path.</li> + <li>Look for the comment "FIXME: temporary hack: + hard-coded paths" in <tt>clang/lib/Frontend/InitHeaderSearch.cpp</tt> and + change the lines below to include that path.</li> + </ul> + </li> + <li>Try it out (assuming you add llvm/Debug+Asserts/bin to your path): + <ul> + <li><tt>clang --help</tt></li> + <li><tt>clang file.c -fsyntax-only</tt> (check for correctness)</li> + <li><tt>clang file.c -S -emit-llvm -o -</tt> (print out unoptimized llvm code)</li> + <li><tt>clang file.c -S -emit-llvm -o - -O3</tt></li> + <li><tt>clang file.c -S -O3 -o -</tt> (output native machine code)</li> + </ul> + </li> +</ol> + +<p>Note that the C front-end uses LLVM, but does not depend on llvm-gcc. If you +encounter problems with building Clang, make sure you have the latest SVN +version of LLVM. LLVM contains support libraries for Clang that will be updated +as well as development on Clang progresses.</p> + +<h3>Simultaneously Building Clang and LLVM:</h3> + +<p>Once you have checked out Clang into the llvm source tree it will build along +with the rest of <tt>llvm</tt>. To build all of LLVM and Clang together all at +once simply run <tt>make</tt> from the root LLVM directory.</p> + +<p><em>Note:</em> Observe that Clang is technically part of a separate +Subversion repository. As mentioned above, the latest Clang sources are tied to +the latest sources in the LLVM tree. You can update your toplevel LLVM project +and all (possibly unrelated) projects inside it with <tt><b>make +update</b></tt>. This will run <tt>svn update</tt> on all subdirectories related +to subversion. </p> + +<h3 id="buildWindows">Using Visual Studio</h3> + +<p>The following details setting up for and building Clang on Windows using +Visual Studio:</p> + +<ol> + <li>Get the required tools: + <ul> + <li><b>Subversion</b>. Source code control program. Get it from: + <a href="http://subversion.tigris.org/getting.html"> + http://subversion.tigris.org/getting.html</a></li> + <li><b>cmake</b>. This is used for generating Visual Studio solution and + project files. Get it from: + <a href="http://www.cmake.org/cmake/resources/software.html"> + http://www.cmake.org/cmake/resources/software.html</a></li> + <li><b>Visual Studio 2008 or 2010</b></li> + <li><b>Python</b>. This is needed only if you will be running the tests + (which is essential, if you will be developing for clang). + Get it from: + <a href="http://www.python.org/download/"> + http://www.python.org/download/</a></li> + <li><b>GnuWin32 tools</b> + These are also necessary for running the tests. + (Note that the grep from MSYS or Cygwin doesn't work with the tests + because of embedded double-quotes in the search strings. The GNU + grep does work in this case.) + Get them from <a href="http://getgnuwin32.sourceforge.net/"> + http://getgnuwin32.sourceforge.net/</a>.</li> + </ul> + </li> + + <li>Checkout LLVM: + <ul> + <li><tt>svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm</tt></li> + </ul> + </li> + <li>Checkout Clang: + <ul> + <li><tt>cd llvm\tools</tt> + <li><tt>svn co http://llvm.org/svn/llvm-project/cfe/trunk clang</tt></li> + </ul> + </li> + <li>Run cmake to generate the Visual Studio solution and project files: + <ul> + <li><tt>cd ..\..</tt> (back to where you started)</li> + <li><tt>mkdir build</tt> (for building without polluting the source dir)</li> + <li><tt>cd build</tt></li> + <li>If you are using Visual Studio 2008: <tt>cmake -G "Visual Studio 9 2008" ..\llvm</tt></li> + <li>Or if you are using Visual Studio 2010: <tt>cmake -G "Visual Studio 10" ..\llvm</tt></li> + <li>By default, cmake will target LLVM to X86. If you want all targets + (needed if you want to run the LLVM tests), add the <tt>-DLLVM_TARGETS_TO_BUILD=all</tt> option to the + cmake command line. Or specify a target from the LLVM_TARGETS_TO_BUILD + definition in CMakeLists.txt.</li> + <li>See the <a href="http://www.llvm.org/docs/CMake.html">LLVM CMake guide</a> for + more information on other configuration options for cmake.</li> + <li>The above, if successful, will have created an LLVM.sln file in the + <tt>build</tt> directory. + </ul> + </li> + <li>Build Clang: + <ul> + <li>Open LLVM.sln in Visual Studio.</li> + <li>Build the "clang" project for just the compiler driver and front end, or + the "ALL_BUILD" project to build everything, including tools.</li> + </ul> + </li> + <li>Try it out (assuming you added llvm/debug/bin to your path). (See the + running examples from above.)</li> + <li>See <a href="hacking.html#testingWindows"> + Hacking on clang - Testing using Visual Studio on Windows</a> for information + on running regression tests on Windows.</li> +</ol> + +<p>Note that once you have checked out both llvm and clang, to synchronize +to the latest code base, use the <tt>svn update</tt> command in both the +llvm and llvm\tools\clang directories, as they are separate repositories.</p> + +<h2 id="driver">Clang Compiler Driver (Drop-in Substitute for GCC)</h2> + +<p>The <tt>clang</tt> tool is the compiler driver and front-end, which is +designed to be a drop-in replacement for the <tt>gcc</tt> command. Here are +some examples of how to use the high-level driver: +</p> + +<pre class="code"> +$ <b>cat t.c</b> +#include <stdio.h> +int main(int argc, char **argv) { printf("hello world\n"); } +$ <b>clang t.c</b> +$ <b>./a.out</b> +hello world +</pre> + +<p>The 'clang' driver is designed to work as closely to GCC as possible to + maximize portability. The only major difference between the two is that + Clang defaults to gnu99 mode while GCC defaults to gnu89 mode. If you see + weird link-time errors relating to inline functions, try passing -std=gnu89 + to clang.</p> + +<h2>Examples of using Clang</h2> + +<!-- Thanks to + http://shiflett.org/blog/2006/oct/formatting-and-highlighting-php-code-listings +Site suggested using pre in CSS, but doesn't work in IE, so went for the <pre> +tag. --> + +<pre class="code"> +$ <b>cat ~/t.c</b> +typedef float V __attribute__((vector_size(16))); +V foo(V a, V b) { return a+b*a; } +</pre> + + +<h3>Preprocessing:</h3> + +<pre class="code"> +$ <b>clang ~/t.c -E</b> +# 1 "/Users/sabre/t.c" 1 + +typedef float V __attribute__((vector_size(16))); + +V foo(V a, V b) { return a+b*a; } +</pre> + + +<h3>Type checking:</h3> + +<pre class="code"> +$ <b>clang -fsyntax-only ~/t.c</b> +</pre> + + +<h3>GCC options:</h3> + +<pre class="code"> +$ <b>clang -fsyntax-only ~/t.c -pedantic</b> +/Users/sabre/t.c:2:17: <span style="color:magenta">warning:</span> extension used +<span style="color:darkgreen">typedef float V __attribute__((vector_size(16)));</span> +<span style="color:blue"> ^</span> +1 diagnostic generated. +</pre> + + +<h3>Pretty printing from the AST:</h3> + +<p>Note, the <tt>-cc1</tt> argument indicates the the compiler front-end, and +not the driver, should be run. The compiler front-end has several additional +Clang specific features which are not exposed through the GCC compatible driver +interface.</p> + +<pre class="code"> +$ <b>clang -cc1 ~/t.c -ast-print</b> +typedef float V __attribute__(( vector_size(16) )); +V foo(V a, V b) { + return a + b * a; +} +</pre> + + +<h3>Code generation with LLVM:</h3> + +<pre class="code"> +$ <b>clang ~/t.c -S -emit-llvm -o -</b> +define <4 x float> @foo(<4 x float> %a, <4 x float> %b) { +entry: + %mul = mul <4 x float> %b, %a + %add = add <4 x float> %mul, %a + ret <4 x float> %add +} +$ <b>clang -fomit-frame-pointer -O3 -S -o - t.c</b> <i># On x86_64</i> +... +_foo: +Leh_func_begin1: + mulps %xmm0, %xmm1 + addps %xmm1, %xmm0 + ret +Leh_func_end1: +</pre> + +</div> +</body> +</html> diff --git a/clang/www/hacking.html b/clang/www/hacking.html new file mode 100644 index 0000000..aa13b8d --- /dev/null +++ b/clang/www/hacking.html @@ -0,0 +1,326 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ --> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>Hacking on clang</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <style type="text/css"> + pre { margin-left: 1.5em; } + </style> +</head> +<body> +<!--#include virtual="menu.html.incl"--> +<div id="content"> + <!--*********************************************************************--> + <h1>Hacking on Clang</h1> + <!--*********************************************************************--> + + <p>This document provides some hints for how to get started hacking + on Clang for developers who are new to the Clang and/or LLVM + codebases.</p> + <ul> + <li><a href="#style">Coding Standards</a></li> + <li><a href="#docs">Developer Documentation</a></li> + <li><a href="#debugging">Debugging</a></li> + <li><a href="#testing">Testing</a> + <ul> + <li><a href="#testingNonWindows">Testing on Unix-like Systems</a></li> + <li><a href="#testingWindows">Testing using Visual Studio on Windows</a></li> + <li><a href="#testingCommands">Testing on the Command Line</a></li> + </ul> + </li> + <li><a href="#patches">Creating Patch Files</a></li> + <li><a href="#irgen">LLVM IR Generation</a></li> + </ul> + + <!--=====================================================================--> + <h2 id="style">Coding Standards</h2> + <!--=====================================================================--> + + <p>Clang follows the + LLVM <a href="http://llvm.org/docs/CodingStandards.html">Coding + Standards</a>. When submitting patches, please take care to follow these standards + and to match the style of the code to that present in Clang (for example, in + terms of indentation, bracing, and statement spacing).</p> + + <p>Clang has a few additional coding standards:</p> + <ul> + <li><i>cstdio is forbidden</i>: library code should not output diagnostics + or other information using <tt>cstdio</tt>; debugging routines should + use <tt>llvm::errs()</tt>. Other uses of <tt>cstdio</tt> impose behavior + upon clients and block integrating Clang as a library. Libraries should + support <tt>raw_ostream</tt> based interfaces for textual + output. See <a href="http://llvm.org/docs/CodingStandards.html#ll_raw_ostream">Coding + Standards</a>.</li> + </ul> + + <!--=====================================================================--> + <h2 id="docs">Developer Documentation</h2> + <!--=====================================================================--> + + <p>Both Clang and LLVM use doxygen to provide API documentation. Their + respective web pages (generated nightly) are here:</p> + <ul> + <li><a href="http://clang.llvm.org/doxygen">Clang</a></li> + <li><a href="http://llvm.org/doxygen">LLVM</a></li> + </ul> + + <p>For work on the LLVM IR generation, the LLVM assembly language + <a href="http://llvm.org/docs/LangRef.html">reference manual</a> is + also useful.</p> + + <!--=====================================================================--> + <h2 id="debugging">Debugging</h2> + <!--=====================================================================--> + + <p>Inspecting data structures in a debugger:</p> + <ul> + <li>Many LLVM and Clang data structures provide + a <tt>dump()</tt> method which will print a description of the + data structure to <tt>stderr</tt>.</li> + <li>The <a href="docs/InternalsManual.html#QualType"><tt>QualType</tt></a> + structure is used pervasively. This is a simple value class for + wrapping types with qualifiers; you can use + the <tt>isConstQualified()</tt>, for example, to get one of the + qualifiers, and the <tt>getTypePtr()</tt> method to get the + wrapped <tt>Type*</tt> which you can then dump.</li> + </ul> + + <!--=====================================================================--> + <h3 id="debuggingVisualStudio">Debugging using Visual Studio</h3> + <!--=====================================================================--> + + <p>The file <tt>utils/clangVisualizers.txt</tt> provides debugger visualizers that make debugging + of more complex data types much easier.</p> + <p>There are two ways to install them:</p> + + <ul> + <li>Put the path to <tt>clangVisualizers.txt</tt> in the environment variable called + <tt>_vcee_autoexp</tt>. This method should work for Visual Studio 2008 and above. + </li> + <li>Edit your local <tt>autoexp.dat</tt> (make sure you make a backup first!), + located in <tt>Visual Studio Directory\Common7\Packages\Debugger</tt> and append + the contents of <tt>clangVisuailzers.txt</tt> to it. This method should work for + Visual Studio 2008 and above. + </li> + </ul> + + <p><i>[Note: To disable the visualizer for any specific variable, type + <tt>variable_name,!</tt> inside the watch window.]</i></p> + + <!--=====================================================================--> + <h2 id="testing">Testing</h2> + <!--=====================================================================--> + + <p><i>[Note: The test running mechanism is currently under revision, so the + following might change shortly.]</i></p> + + <!--=====================================================================--> + <h3 id="testingNonWindows">Testing on Unix-like Systems</h3> + <!--=====================================================================--> + + <p>Clang includes a basic regression suite in the tree which can be + run with <tt>make test</tt> from the top-level clang directory, or + just <tt>make</tt> in the <em>test</em> sub-directory. + <tt>make VERBOSE=1</tt> can be used to show more detail + about what is being run.</p> + + <p>If you built LLVM and Clang using CMake, the test suite can be run + with <tt>make clang-test</tt> from the top-level LLVM directory.</p> + + <p>The tests primarily consist of a test runner script running the compiler + under test on individual test files grouped in the directories under the + test directory. The individual test files include comments at the + beginning indicating the Clang compile options to use, to be read + by the test runner. Embedded comments also can do things like telling + the test runner that an error is expected at the current line. + Any output files produced by the test will be placed under + a created Output directory.</p> + + <p>During the run of <tt>make test</tt>, the terminal output will + display a line similar to the following:</p> + + <pre>--- Running clang tests for i686-pc-linux-gnu ---</pre> + + <p>followed by a line continually overwritten with the current test + file being compiled, and an overall completion percentage.</p> + + <p>After the <tt>make test</tt> run completes, the absence of any + <tt>Failing Tests (count):</tt> message indicates that no tests + failed unexpectedly. If any tests did fail, the + <tt>Failing Tests (count):</tt> message will be followed by a list + of the test source file paths that failed. For example:</p> + + <pre> + Failing Tests (3): + /home/john/llvm/tools/clang/test/SemaCXX/member-name-lookup.cpp + /home/john/llvm/tools/clang/test/SemaCXX/namespace-alias.cpp + /home/john/llvm/tools/clang/test/SemaCXX/using-directive.cpp +</pre> + + <p>If you used the <tt>make VERBOSE=1</tt> option, the terminal + output will reflect the error messages from the compiler and + test runner.</p> + + <p>The regression suite can also be run with Valgrind by running + <tt>make test VG=1</tt> in the top-level clang directory.</p> + + <p>For more intensive changes, running + the <a href="http://llvm.org/docs/TestingGuide.html#testsuiterun">LLVM + Test Suite</a> with clang is recommended. Currently the best way to + override LLVMGCC, as in: <tt>make LLVMGCC="clang -std=gnu89" + TEST=nightly report</tt> (make sure <tt>clang</tt> is in your PATH or use the + full path).</p> + + <!--=====================================================================--> + <h3 id="testingWindows">Testing using Visual Studio on Windows</h3> + <!--=====================================================================--> + + <p>The Clang test suite can be run from either Visual Studio or + the command line.</p> + + <p>Note that the test runner is based on + Python, which must be installed. Find Python at: + <a href="http://www.python.org/download/">http://www.python.org/download/</a>. + Download the latest stable version (2.6.2 at the time of this writing).</p> + + <p>The GnuWin32 tools are also necessary for running the tests. + Get them from <a href="http://getgnuwin32.sourceforge.net/"> + http://getgnuwin32.sourceforge.net/</a>. + If the environment variable <tt>%PATH%</tt> does not have GnuWin32, + or if other grep(s) supercedes GnuWin32 on <tt>%PATH%,</tt> + you should specify <tt>LLVM_LIT_TOOLS_DIR</tt> + to CMake explicitly.</p> + + <p>The cmake build tool is set up to create Visual Studio project files + for running the tests, "clang-test" being the root. Therefore, to + run the test from Visual Studio, right-click the clang-test project + and select "Build".</p> + + <p> + Please see also + <a href="http://llvm.org/docs/GettingStartedVS.html">Getting Started + with the LLVM System using Microsoft Visual Studio</a> and + <a href="http://llvm.org/docs/CMake.html">Building LLVM with CMake</a>. + </p> + + <!--=====================================================================--> + <h3 id="testingCommands">Testing on the Command Line</h3> + <!--=====================================================================--> + + <p>If you want more control over how the tests are run, it may + be convenient to run the test harness on the command-line directly. Before + running tests from the command line, you will need to ensure that + <tt>lit.site.cfg</tt> files have been created for your build. You can do + this by running the tests as described in the previous sections. Once the + tests have started running, you can stop them with control+C, as the + files are generated before running any tests.</p> + + <p>Once that is done, to run all the tests from the command line, + execute a command like the following:</p> + + <pre> + python (path to llvm)\llvm\utils\lit\lit.py -sv + --param=build_mode=Win32 --param=build_config=Debug + --param=clang_site_config=(build dir)\tools\clang\test\lit.site.cfg + (path to llvm)\llvm\tools\clang\test +</pre> + + <p>For CMake builds e.g. on Windows with Visual Studio, you will need + to specify your build configuration (Debug, Release, etc.) via + <tt>--param=build_config=(build config)</tt>. You may also need to specify + the build mode (Win32, etc) via <tt>--param=build_mode=(build mode)</tt>.</p> + + <p>Additionally, you will need to specify the lit site configuration which + lives in (build dir)\tools\clang\test, via + <tt>--param=clang_site_config=(build dir)\tools\clang\test\lit.site.cfg</tt>. + </p> + + <p>To run a single test:</p> + + <pre> + python (path to llvm)\llvm\utils\lit\lit.py -sv + --param=build_mode=Win32 --param=build_config=Debug + --param=clang_site_config=(build dir)\tools\clang\test\lit.site.cfg + (path to llvm)\llvm\tools\clang\test\(dir)\(test) +</pre> + + <p>For example:</p> + + <pre> + python C:\Tool\llvm\utils\lit\lit.py -sv + --param=build_mode=Win32 --param=build_config=Debug + --param=clang_site_config=c:\Tools\build\tools\clang\test\lit.site.cfg + C:\Tools\llvm\tools\clang\test\Sema\wchar.c +</pre> + + <p>The -sv option above tells the runner to show the test output if + any tests failed, to help you determine the cause of failure.</p> + + <p>You can also pass in the --no-progress-bar option if you wish to disable + progress indications while the tests are running.</p> + + <p>Your output might look something like this:</p> + + <pre>lit.py: lit.cfg:152: note: using clang: 'C:\Tools\llvm\bin\Release\clang.EXE' +-- Testing: Testing: 2534 tests, 4 threads -- +Testing: 0 .. 10.. 20.. 30.. 40.. 50.. 60.. 70.. 80.. 90.. +Testing Time: 81.52s + Expected Passes : 2503 + Expected Failures : 28 + Unsupported Tests : 3 +</pre> + + <p>The statistic, "Unexpected Failures" (not shown if all tests pass), is the important one.</p> + + <!--=====================================================================--> + <h2 id="patches">Creating Patch Files</h2> + <!--=====================================================================--> + + <p>To return changes to the Clang team, unless you have checkin + privileges, the preferred way is to send patch files to the + cfe-commits mailing list, with an explanation of what the patch is + for. If your patch requires a wider discussion (for example, + because it is an architectural change), you can use the cfe-dev + mailing list. </p> + + <p>To create these patch files, change directory + to the llvm/tools/clang root and run:</p> + + <pre>svn diff (relative path) >(patch file name)</pre> + + <p>For example, for getting the diffs of all of clang:</p> + + <pre>svn diff . >~/mypatchfile.patch</pre> + + <p>For example, for getting the diffs of a single file:</p> + + <pre>svn diff lib/Parse/ParseDeclCXX.cpp >~/ParseDeclCXX.patch</pre> + + <p>Note that the paths embedded in the patch depend on where you run it, + so changing directory to the llvm/tools/clang directory is recommended.</p> + + <!--=====================================================================--> + <h2 id="irgen">LLVM IR Generation</h2> + <!--=====================================================================--> + + <p>The LLVM IR generation part of clang handles conversion of the + AST nodes output by the Sema module to the LLVM Intermediate + Representation (IR). Historically, this was referred to as + "codegen", and the Clang code for this lives + in <tt>lib/CodeGen</tt>.</p> + + <p>The output is most easily inspected using the <tt>-emit-llvm</tt> + option to clang (possibly in conjunction with <tt>-o -</tt>). You + can also use <tt>-emit-llvm-bc</tt> to write an LLVM bitcode file + which can be processed by the suite of LLVM tools + like <tt>llvm-dis</tt>, <tt>llvm-nm</tt>, etc. See the LLVM + <a href="http://llvm.org/docs/CommandGuide/">Command Guide</a> + for more information.</p> + +</div> +</body> +</html> diff --git a/clang/www/index.html b/clang/www/index.html new file mode 100644 index 0000000..6455262 --- /dev/null +++ b/clang/www/index.html @@ -0,0 +1,118 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ --> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>"clang" C Language Family Frontend for LLVM</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> +</head> +<body> +<!--#include virtual="menu.html.incl"--> +<div id="content"> + <!--*********************************************************************--> + <h1>clang: a C language family frontend for LLVM</h1> + <!--*********************************************************************--> + + <p>The goal of the Clang project is to create a new C, C++, Objective C and + Objective C++ front-end for the <a href="http://www.llvm.org/">LLVM</a> + compiler. You can <a href="get_started.html">get and build</a> the source + today.</p> + + <!--=====================================================================--> + <h2 id="goals">Features and Goals</h2> + <!--=====================================================================--> + + <p>Some of the goals for the project include the following:</p> + + <p><b><a href="features.html#enduser">End-User Features</a></b>:</p> + + <ul> + <li>Fast compiles and low memory use</li> + <li>Expressive diagnostics (<a href="diagnostics.html">examples</a>)</li> + <li>GCC compatibility</li> + </ul> + + <p><b><a href="features.html#applications">Utility and + Applications</a></b>:</p> + + <ul> + <li>Modular library based architecture</li> + <li>Support diverse clients (refactoring, static analysis, code generation, + etc)</li> + <li>Allow tight integration with IDEs</li> + <li>Use the LLVM 'BSD' License</li> + </ul> + + <p><b><a href="features.html#design">Internal Design and + Implementation</a></b>:</p> + + <ul> + <li>A real-world, production quality compiler</li> + <li>A simple and hackable code base</li> + <li>A single unified parser for C, Objective C, C++, and Objective C++</li> + <li>Conformance with C/C++/ObjC and their variants</li> + </ul> + + <p>Of course this is only a rough outline of the goals and features of + Clang. To get a true sense of what it is all about, see the <a + href="features.html">Features</a> section, which breaks + each of these down and explains them in more detail.</p> + + + <!--=====================================================================--> + <h2>Why?</h2> + <!--=====================================================================--> + + <p>The development of a new front-end was started out of a need -- a need + for a compiler that allows better diagnostics, better integration with + IDEs, a license that is compatible with commercial products, and a + nimble compiler that is easy to develop and maintain. All of these were + motivations for starting work on a new front-end that could + meet these needs.</p> + + <p>A good (but quite dated) introduction to Clang can be found in the + following video lectures:</p> + + <ul> + <li><a href="clang_video-05-25-2007.html">Clang Introduction</a> + (May 2007)</li> + <li><a href="clang_video-07-25-2007.html">Features and Performance of + Clang</a> (July 2007)</li> + </ul> + + <p>For a more detailed comparison between Clang and other compilers, please + see the <a href="comparison.html">clang comparison page</a>.</p> + + <!--=====================================================================--> + <h2>Current Status</h2> + <!--=====================================================================--> + + <p>Clang is still under heavy development. Clang is considered to + be a production quality C, Objective-C, C++ and Objective-C++ compiler when + targeting X86-32, X86-64, and ARM (other targets may have caveats, but are + usually easy to fix). If you are looking for source analysis or + source-to-source transformation tools, clang is probably a great + solution for you. Clang supports most of C++11, please see the <a + href="cxx_status.html">C++ status</a> page for more + information.</p> + + <!--=====================================================================--> + <h2>Get it and get involved!</h2> + <!--=====================================================================--> + + <p>Start by <a href="get_started.html">getting the code, building it, and + playing with it</a>. This will show you the sorts of things we can do + today and will let you have the "clang experience" first hand: hopefully + it will "resonate" with you. :)</p> + + <p>Once you've done that, please consider <a href="get_involved.html">getting + involved in the clang community</a>. The clang developers include numerous + volunteer contributors with a variety of backgrounds. If you're + interested in + following the development of clang, signing up for a mailing list is a good + way to learn about how the project works.</p> +</div> +</body> +</html> diff --git a/clang/www/libstdc++4.4-clang0x.patch b/clang/www/libstdc++4.4-clang0x.patch new file mode 100644 index 0000000..db43583 --- /dev/null +++ b/clang/www/libstdc++4.4-clang0x.patch @@ -0,0 +1,608 @@ +This patch was generated from the headers installed by MacPorts +gcc-4.4 on OS X 10.6. You can apply it there with +`cd /opt/local/include/gcc44/c++ ; sudo patch -p1 <this_patch`, or similar +on other operating systems. Mail cfe-dev if you find other problems in the +standard headers. + +This patch is offered under the same modified GPLv3 as libstdc++-4.4. + +diff -ur a/bits/forward_list.h b/bits/forward_list.h +--- a/bits/forward_list.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/forward_list.h 2011-05-02 23:51:33.000000000 -0700 +@@ -983,7 +983,7 @@ + * function. + */ + void +- swap(forward_list&& __list) ++ swap(forward_list& __list) + { _Node_base::swap(this->_M_impl._M_head, __list._M_impl._M_head); } + + /** +diff -ur a/bits/move.h b/bits/move.h +--- a/bits/move.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/move.h 2011-03-29 10:33:39.000000000 -0700 +@@ -48,13 +48,35 @@ + + template<typename _Tp> + inline _Tp&& +- forward(typename std::identity<_Tp>::type&& __t) ++ forward(typename std::remove_reference<_Tp>::type& __t) ++#ifdef __clang__ ++ { return static_cast<_Tp&&>(__t); } ++#else + { return __t; } ++#endif ++ ++ template<typename _Tp> ++ inline _Tp&& ++ forward(typename std::remove_reference<_Tp>::type&& __t) ++ { ++#ifdef __clang__ ++ static_assert(!std::is_lvalue_reference<_Tp>::value, ++ "Can't instantiate this forward() with an" ++ " lvalue reference type."); ++ return static_cast<_Tp&&>(__t); ++#else ++ return __t; ++#endif ++ } + + template<typename _Tp> + inline typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) ++#ifdef __clang__ ++ { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); } ++#else + { return __t; } ++#endif + + _GLIBCXX_END_NAMESPACE + +diff -ur a/bits/shared_ptr.h b/bits/shared_ptr.h +--- a/bits/shared_ptr.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/shared_ptr.h 2011-03-31 16:40:45.000000000 -0700 +@@ -833,7 +833,7 @@ + { return _M_refcount._M_get_use_count(); } + + void +- swap(__shared_ptr<_Tp, _Lp>&& __other) // never throws ++ swap(__shared_ptr<_Tp, _Lp>& __other) // never throws + { + std::swap(_M_ptr, __other._M_ptr); + _M_refcount._M_swap(__other._M_refcount); +@@ -943,16 +943,6 @@ + swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) + { __a.swap(__b); } + +- template<typename _Tp, _Lock_policy _Lp> +- inline void +- swap(__shared_ptr<_Tp, _Lp>&& __a, __shared_ptr<_Tp, _Lp>& __b) +- { __a.swap(__b); } +- +- template<typename _Tp, _Lock_policy _Lp> +- inline void +- swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>&& __b) +- { __a.swap(__b); } +- + // 2.2.3.9 shared_ptr casts + /** @warning The seemingly equivalent + * <code>shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))</code> +@@ -1372,16 +1362,6 @@ + swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) + { __a.swap(__b); } + +- template<typename _Tp> +- inline void +- swap(shared_ptr<_Tp>&& __a, shared_ptr<_Tp>& __b) +- { __a.swap(__b); } +- +- template<typename _Tp> +- inline void +- swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>&& __b) +- { __a.swap(__b); } +- + // 20.8.13.2.10 shared_ptr casts. + template<typename _Tp, typename _Tp1> + inline shared_ptr<_Tp> +diff -ur a/bits/stl_bvector.h b/bits/stl_bvector.h +--- a/bits/stl_bvector.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_bvector.h 2011-05-02 23:34:46.000000000 -0700 +@@ -743,11 +743,7 @@ + } + + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(vector&& __x) +-#else + swap(vector& __x) +-#endif + { + std::swap(this->_M_impl._M_start, __x._M_impl._M_start); + std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); +diff -ur a/bits/stl_deque.h b/bits/stl_deque.h +--- a/bits/stl_deque.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_deque.h 2011-03-29 10:33:39.000000000 -0700 +@@ -1395,11 +1395,7 @@ + * std::swap(d1,d2) will feed to this function. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(deque&& __x) +-#else + swap(deque& __x) +-#endif + { + std::swap(this->_M_impl._M_start, __x._M_impl._M_start); + std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); +diff -ur a/bits/stl_iterator.h b/bits/stl_iterator.h +--- a/bits/stl_iterator.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_iterator.h 2011-03-29 10:33:39.000000000 -0700 +@@ -913,7 +913,7 @@ + + reference + operator*() const +- { return *_M_current; } ++ { return std::move(*_M_current); } + + pointer + operator->() const +diff -ur a/bits/stl_list.h b/bits/stl_list.h +--- a/bits/stl_list.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_list.h 2011-03-29 10:33:39.000000000 -0700 +@@ -1106,11 +1106,7 @@ + * function. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(list&& __x) +-#else + swap(list& __x) +-#endif + { + _List_node_base::swap(this->_M_impl._M_node, __x._M_impl._M_node); + +@@ -1160,6 +1156,12 @@ + } + } + ++#ifdef __GXX_EXPERIMENTAL_CXX0X__ ++ void ++ splice(iterator __position, list& __x) ++ { splice(__position, std::move(__x)); } ++#endif ++ + /** + * @brief Insert element from another %list. + * @param position Iterator referencing the element to insert before. +@@ -1187,6 +1189,12 @@ + this->_M_transfer(__position, __i, __j); + } + ++#ifdef __GXX_EXPERIMENTAL_CXX0X__ ++ void ++ splice(iterator __position, list& __x, iterator __i) ++ { splice(__position, std::move(__x), __i); } ++#endif ++ + /** + * @brief Insert range from another %list. + * @param position Iterator referencing the element to insert before. +@@ -1217,6 +1225,13 @@ + } + } + ++#ifdef __GXX_EXPERIMENTAL_CXX0X__ ++ void ++ splice(iterator __position, list& __x, iterator __first, ++ iterator __last) ++ { splice(__position, std::move(__x), __first, __last); } ++#endif ++ + /** + * @brief Remove all elements equal to value. + * @param value The value to remove. +@@ -1287,6 +1302,10 @@ + void + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + merge(list&& __x); ++ ++ void ++ merge(list& __x) ++ { merge(std::move(__x)); } + #else + merge(list& __x); + #endif +@@ -1307,6 +1326,11 @@ + void + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + merge(list&&, _StrictWeakOrdering); ++ ++ template<typename _StrictWeakOrdering> ++ void ++ merge(list& __l, _StrictWeakOrdering __comp) ++ { merge(std::move(__l), __comp); } + #else + merge(list&, _StrictWeakOrdering); + #endif +diff -ur a/bits/stl_map.h b/bits/stl_map.h +--- a/bits/stl_map.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_map.h 2011-03-29 10:33:39.000000000 -0700 +@@ -608,11 +608,7 @@ + * that std::swap(m1,m2) will feed to this function. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(map&& __x) +-#else + swap(map& __x) +-#endif + { _M_t.swap(__x._M_t); } + + /** +diff -ur a/bits/stl_multimap.h b/bits/stl_multimap.h +--- a/bits/stl_multimap.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_multimap.h 2011-03-29 10:33:39.000000000 -0700 +@@ -544,11 +544,7 @@ + * std::swap(m1,m2) will feed to this function. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(multimap&& __x) +-#else + swap(multimap& __x) +-#endif + { _M_t.swap(__x._M_t); } + + /** +diff -ur a/bits/stl_multiset.h b/bits/stl_multiset.h +--- a/bits/stl_multiset.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_multiset.h 2011-03-29 10:33:39.000000000 -0700 +@@ -376,11 +376,7 @@ + * std::swap(s1,s2) will feed to this function. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(multiset&& __x) +-#else + swap(multiset& __x) +-#endif + { _M_t.swap(__x._M_t); } + + // insert/erase +diff -ur a/bits/stl_pair.h b/bits/stl_pair.h +--- a/bits/stl_pair.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_pair.h 2011-03-29 10:33:39.000000000 -0700 +@@ -84,10 +84,21 @@ + : first(__a), second(__b) { } + + #ifdef __GXX_EXPERIMENTAL_CXX0X__ +- template<class _U1, class _U2> ++ template<class _U1, class = typename ++ std::enable_if<std::is_convertible<_U1, _T1>::value>::type> ++ pair(_U1&& __x, const _T2& __y) ++ : first(std::forward<_U1>(__x)), second(__y) { } ++ ++ template<class _U2, class = typename ++ std::enable_if<std::is_convertible<_U2, _T2>::value>::type> ++ pair(const _T1& __x, _U2&& __y) ++ : first(__x), second(std::forward<_U2>(__y)) { } ++ ++ template<class _U1, class _U2, class = typename ++ std::enable_if<std::is_convertible<_U1, _T1>::value ++ && std::is_convertible<_U2, _T2>::value>::type> + pair(_U1&& __x, _U2&& __y) +- : first(std::forward<_U1>(__x)), +- second(std::forward<_U2>(__y)) { } ++ : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { } + + pair(pair&& __p) + : first(std::move(__p.first)), +@@ -107,11 +118,19 @@ + second(std::move(__p.second)) { } + + // http://gcc.gnu.org/ml/libstdc++/2007-08/msg00052.html ++ ++#if 0 ++ // This constructor is incompatible with libstdc++-4.6, and it ++ // interferes with passing NULL pointers to the 2-argument ++ // constructors, so we disable it. map::emplace isn't ++ // implemented in libstdc++-4.4 anyway, and that's what this ++ // constructor was here for. + template<class _U1, class _Arg0, class... _Args> + pair(_U1&& __x, _Arg0&& __arg0, _Args&&... __args) + : first(std::forward<_U1>(__x)), + second(std::forward<_Arg0>(__arg0), + std::forward<_Args>(__args)...) { } ++#endif + + pair& + operator=(pair&& __p) +@@ -131,7 +150,7 @@ + } + + void +- swap(pair&& __p) ++ swap(pair& __p) + { + using std::swap; + swap(first, __p.first); +diff -ur a/bits/stl_queue.h b/bits/stl_queue.h +--- a/bits/stl_queue.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_queue.h 2011-05-02 23:36:15.000000000 -0700 +@@ -249,7 +249,7 @@ + + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + void +- swap(queue&& __q) ++ swap(queue& __q) + { c.swap(__q.c); } + #endif + }; +@@ -550,7 +550,7 @@ + + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + void +- swap(priority_queue&& __pq) ++ swap(priority_queue& __pq) + { + using std::swap; + c.swap(__pq.c); +diff -ur a/bits/stl_set.h b/bits/stl_set.h +--- a/bits/stl_set.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_set.h 2011-03-29 10:33:39.000000000 -0700 +@@ -383,11 +383,7 @@ + * std::swap(s1,s2) will feed to this function. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(set&& __x) +-#else + swap(set& __x) +-#endif + { _M_t.swap(__x._M_t); } + + // insert/erase +diff -ur a/bits/stl_stack.h b/bits/stl_stack.h +--- a/bits/stl_stack.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_stack.h 2011-05-02 23:36:36.000000000 -0700 +@@ -213,7 +213,7 @@ + + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + void +- swap(stack&& __s) ++ swap(stack& __s) + { c.swap(__s.c); } + #endif + }; +diff -ur a/bits/stl_tree.h b/bits/stl_tree.h +--- a/bits/stl_tree.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_tree.h 2011-03-29 10:33:39.000000000 -0700 +@@ -675,11 +675,7 @@ + { return _M_get_Node_allocator().max_size(); } + + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(_Rb_tree&& __t); +-#else + swap(_Rb_tree& __t); +-#endif + + // Insert/erase. + pair<iterator, bool> +@@ -1104,11 +1100,7 @@ + typename _Compare, typename _Alloc> + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&& __t) +-#else + swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t) +-#endif + { + if (_M_root() == 0) + { +diff -ur a/bits/stl_vector.h b/bits/stl_vector.h +--- a/bits/stl_vector.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_vector.h 2011-03-29 10:33:39.000000000 -0700 +@@ -923,11 +923,7 @@ + * std::swap(v1,v2) will feed to this function. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(vector&& __x) +-#else + swap(vector& __x) +-#endif + { + std::swap(this->_M_impl._M_start, __x._M_impl._M_start); + std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); +diff -ur a/bits/unique_ptr.h b/bits/unique_ptr.h +--- a/bits/unique_ptr.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/unique_ptr.h 2011-03-31 16:40:45.000000000 -0700 +@@ -204,7 +204,7 @@ + } + + void +- swap(unique_ptr&& __u) ++ swap(unique_ptr& __u) + { + using std::swap; + swap(_M_t, __u._M_t); +@@ -350,7 +350,7 @@ + void reset(_Up) = delete; + + void +- swap(unique_ptr&& __u) ++ swap(unique_ptr& __u) + { + using std::swap; + swap(_M_t, __u._M_t); +@@ -389,18 +389,6 @@ + unique_ptr<_Tp, _Tp_Deleter>& __y) + { __x.swap(__y); } + +- template<typename _Tp, typename _Tp_Deleter> +- inline void +- swap(unique_ptr<_Tp, _Tp_Deleter>&& __x, +- unique_ptr<_Tp, _Tp_Deleter>& __y) +- { __x.swap(__y); } +- +- template<typename _Tp, typename _Tp_Deleter> +- inline void +- swap(unique_ptr<_Tp, _Tp_Deleter>& __x, +- unique_ptr<_Tp, _Tp_Deleter>&& __y) +- { __x.swap(__y); } +- + template<typename _Tp, typename _Tp_Deleter, + typename _Up, typename _Up_Deleter> + inline bool +diff -ur a/exception_ptr.h b/exception_ptr.h +--- a/exception_ptr.h 2011-03-15 14:49:08.000000000 -0700 ++++ b/exception_ptr.h 2011-03-29 10:33:39.000000000 -0700 +@@ -140,7 +140,7 @@ + friend bool + operator==(const exception_ptr&, const exception_ptr&) throw(); + +- const type_info* ++ const class type_info* + __cxa_exception_type() const throw(); + }; + +diff -ur a/ext/algorithm b/ext/algorithm +--- a/ext/algorithm 2011-03-15 14:49:05.000000000 -0700 ++++ b/ext/algorithm 2011-03-29 10:33:39.000000000 -0700 +@@ -423,6 +423,9 @@ + __out_last - __out_first); + } + ++#ifdef __GXX_EXPERIMENTAL_CXX0X__ ++ using std::is_heap; ++#else + /** + * This is an SGI extension. + * @ingroup SGIextensions +@@ -462,6 +465,7 @@ + + return std::__is_heap(__first, __comp, __last - __first); + } ++#endif + + // is_sorted, a predicated testing whether a range is sorted in + // nondescending order. This is an extension, not part of the C++ +diff -ur a/ext/vstring.h b/ext/vstring.h +--- a/ext/vstring.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/ext/vstring.h 2011-03-29 10:33:39.000000000 -0700 +@@ -152,7 +152,7 @@ + * string. + */ + __versa_string(__versa_string&& __str) +- : __vstring_base(std::forward<__vstring_base>(__str)) { } ++ : __vstring_base(std::move(__str)) { } + + /** + * @brief Construct string from an initializer list. +@@ -1439,11 +1439,7 @@ + * constant time. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(__versa_string&& __s) +-#else + swap(__versa_string& __s) +-#endif + { this->_M_swap(__s); } + + // String operations: +diff -ur a/tr1_impl/hashtable b/tr1_impl/hashtable +--- a/tr1_impl/hashtable 2011-03-15 14:49:07.000000000 -0700 ++++ b/tr1_impl/hashtable 2011-05-02 23:41:55.000000000 -0700 +@@ -225,11 +225,7 @@ + + ~_Hashtable(); + +-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X +- void swap(_Hashtable&&); +-#else + void swap(_Hashtable&); +-#endif + + // Basic container operations + iterator +@@ -732,11 +728,7 @@ + void + _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: +-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X +- swap(_Hashtable&& __x) +-#else + swap(_Hashtable& __x) +-#endif + { + // The only base class with member variables is hash_code_base. We + // define _Hash_code_base::_M_swap because different specializations +diff -ur a/tuple b/tuple +--- a/tuple 2011-03-15 14:49:07.000000000 -0700 ++++ b/tuple 2011-05-02 23:33:23.000000000 -0700 +@@ -77,7 +77,7 @@ + _Head& _M_head() { return *this; } + const _Head& _M_head() const { return *this; } + +- void _M_swap_impl(_Head&&) { /* no-op */ } ++ void _M_swap_impl(_Head&) { /* no-op */ } + }; + + template<std::size_t _Idx, typename _Head> +@@ -97,7 +97,7 @@ + const _Head& _M_head() const { return _M_head_impl; } + + void +- _M_swap_impl(_Head&& __h) ++ _M_swap_impl(_Head& __h) + { + using std::swap; + swap(__h, _M_head_impl); +@@ -125,7 +125,7 @@ + struct _Tuple_impl<_Idx> + { + protected: +- void _M_swap_impl(_Tuple_impl&&) { /* no-op */ } ++ void _M_swap_impl(_Tuple_impl&) { /* no-op */ } + }; + + /** +@@ -214,7 +214,7 @@ + + protected: + void +- _M_swap_impl(_Tuple_impl&& __in) ++ _M_swap_impl(_Tuple_impl& __in) + { + _Base::_M_swap_impl(__in._M_head()); + _Inherited::_M_swap_impl(__in._M_tail()); +@@ -292,7 +292,7 @@ + } + + void +- swap(tuple&& __in) ++ swap(tuple& __in) + { _Inherited::_M_swap_impl(__in); } + }; + +@@ -301,7 +301,7 @@ + class tuple<> + { + public: +- void swap(tuple&&) { /* no-op */ } ++ void swap(tuple&) { /* no-op */ } + }; + + /// tuple (2-element), with construction and assignment from a pair. +@@ -394,7 +394,7 @@ + } + + void +- swap(tuple&& __in) ++ swap(tuple& __in) + { + using std::swap; + swap(this->_M_head(), __in._M_head()); diff --git a/clang/www/libstdc++4.7-clang11.patch b/clang/www/libstdc++4.7-clang11.patch new file mode 100644 index 0000000..3f03007 --- /dev/null +++ b/clang/www/libstdc++4.7-clang11.patch @@ -0,0 +1,13 @@ +Index: include/std/type_traits +=================================================================== +--- include/std/type_traits (revision 185724) ++++ include/std/type_traits (working copy) +@@ -1746,7 +1746,7 @@ + + template<typename _Tp, typename _Up> + struct common_type<_Tp, _Up> +- { typedef decltype(true ? declval<_Tp>() : declval<_Up>()) type; }; ++ { typedef typename decay<decltype(true ? declval<_Tp>() : declval<_Up>())>::type type; }; + + template<typename _Tp, typename _Up, typename... _Vp> + struct common_type<_Tp, _Up, _Vp...> diff --git a/clang/www/menu.css b/clang/www/menu.css new file mode 100644 index 0000000..4a887b1 --- /dev/null +++ b/clang/www/menu.css @@ -0,0 +1,39 @@ +/***************/ +/* page layout */ +/***************/ + +[id=menu] { + position:fixed; + width:25ex; +} +[id=content] { + /* ***** EDIT THIS VALUE IF CONTENT OVERLAPS MENU ***** */ + position:absolute; + left:29ex; + padding-right:4ex; +} + +/**************/ +/* menu style */ +/**************/ + +#menu .submenu { + padding-top:1em; + display:block; +} + +#menu label { + display:block; + font-weight: bold; + text-align: center; + background-color: rgb(192,192,192); +} +#menu a { + padding:0 .2em; + display:block; + text-align: center; + background-color: rgb(235,235,235); +} +#menu a:visited { + color:rgb(100,50,100); +} diff --git a/clang/www/menu.html.incl b/clang/www/menu.html.incl new file mode 100644 index 0000000..878e678 --- /dev/null +++ b/clang/www/menu.html.incl @@ -0,0 +1,61 @@ +<div id="menu"> + <div> + <a href="http://llvm.org/">LLVM Home</a> + </div> + + <div class="submenu"> + <label>Clang Info</label> + <a href="/index.html">About</a> + <a href="/features.html">Features</a> + <a href="/comparison.html">Comparisons</a> + <a href="/related.html">Related Projects</a> + <a href="/docs/UsersManual.html">User's Manual</a> + <a href="/compatibility.html">Language Compatibility</a> + <a href="/docs/LanguageExtensions.html">Language Extensions</a> + <a href="/cxx_status.html">C++ Status</a> + </div> + + <div class="submenu"> + <label>Clang Development</label> + <a href="/get_started.html">Get Started</a> + <a href="/get_involved.html">Get Involved</a> + <a href="/OpenProjects.html">Open Projects</a> + <a href="/docs/InternalsManual.html">Clang Internals</a> + <a href="/hacking.html">Hacking on Clang</a> + <a href="/performance.html">Performance</a> + </div> + + <div class="submenu"> + <label>Clang Tools</label> + <a href="http://clang-analyzer.llvm.org">Automatic Bug-Finding</a> + </div> + + <div class="submenu"> + <label>Communication</label> + <a href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-dev">cfe-dev List</a> + <a href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits">cfe-commits List</a> + <a href="irc://irc.oftc.net/llvm">IRC: irc.oftc.net#llvm</a> + <a href="http://llvm.org/bugs/">Bug Reports</a> + </div> + + <div class="submenu"> + <label>The Code</label> + <a href="/get_started.html#build">Check Out SVN</a> + <a href="http://llvm.org/svn/llvm-project/cfe/trunk/">Browse SVN</a> + <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/">Browse ViewVC</a> + <a href="http://clang.llvm.org/doxygen/">doxygen</a> + </div> + + <div class="submenu"> + <label>Quick Links</label> + <a href="http://test.minormatter.com/~ddunbar/clang-cov/">Testing Coverage</a> + <a href="http://test.minormatter.com/~ddunbar/references.html">Spec. References</a> + </div> + + <div class="submenu"> + <label>Clang Events</label> + <a href="http://llvm.org/devmtg/2009-10/">October 2009</a> + <a href="http://llvm.org/devmtg/2010-11/">November 2010</a> + </div> + +</div> diff --git a/clang/www/performance-2008-10-31.html b/clang/www/performance-2008-10-31.html new file mode 100644 index 0000000..b287667 --- /dev/null +++ b/clang/www/performance-2008-10-31.html @@ -0,0 +1,132 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>Clang - Performance</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <style type="text/css"> +</style> +</head> +<body> + +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<!--*************************************************************************--> +<h1>Clang - Performance</h1> +<!--*************************************************************************--> + +<p>This page tracks the compile time performance of Clang on two +interesting benchmarks:</p> +<ul> + <li><i>Sketch</i>: The Objective-C example application shipped on + Mac OS X as part of Xcode. <i>Sketch</i> is indicative of a + "typical" Objective-C app. The source itself has a relatively + small amount of code (~7,500 lines of source code), but it relies + on the extensive Cocoa APIs to build its functionality. Like many + Objective-C applications, it includes + <tt>Cocoa/Cocoa.h</tt> in all of its source files, which represents a + significant stress test of the front-end's performance on lexing, + preprocessing, parsing, and syntax analysis.</li> + <li><i>176.gcc</i>: This is the gcc-2.7.2.2 code base as present in + SPECINT 2000. In contrast to Sketch, <i>176.gcc</i> consists of a + large amount of C source code (~220,000 lines) with few system + dependencies. This stresses the back-end's performance on generating + assembly code and debug information.</li> +</ul> + +<!--*************************************************************************--> +<h2><a name="enduser">Experiments</a></h2> +<!--*************************************************************************--> + +<p>Measurements are done by serially processing each file in the +respective benchmark, using Clang, gcc, and llvm-gcc as compilers. In +order to track the performance of various subsystems the timings have +been broken down into separate stages where possible:</p> + +<ul> + <li><tt>-Eonly</tt>: This option runs the preprocessor but does not + perform any output. For gcc and llvm-gcc, the -MM option is used + as a rough equivalent to this step.</li> + <li><tt>-parse-noop</tt>: This option runs the parser on the input, + but without semantic analysis or any output. gcc and llvm-gcc have + no equivalent for this option.</li> + <li><tt>-fsyntax-only</tt>: This option runs the parser with semantic + analysis.</li> + <li><tt>-emit-llvm -O0</tt>: For Clang and llvm-gcc, this option + converts to the LLVM intermediate representation but doesn't + generate native code.</li> + <li><tt>-S -O0</tt>: Perform actual code generation to produce a + native assembler file.</li> + <li><tt>-S -O0 -g</tt>: This adds emission of debug information to + the assembly output.</li> +</ul> + +<p>This set of stages is chosen to be approximately additive, that is +each subsequent stage simply adds some additional processing. The +timings measure the delta of the given stage from the previous +one. For example, the timings for <tt>-fsyntax-only</tt> below show +the difference of running with <tt>-fsyntax-only</tt> versus running +with <tt>-parse-noop</tt> (for clang) or <tt>-MM</tt> with gcc and +llvm-gcc. This amounts to a fairly accurate measure of only the time +to perform semantic analysis (and parsing, in the case of gcc and llvm-gcc).</p> + +<p>These timings are chosen to break down the compilation process for +clang as much as possible. The graphs below show these numbers +combined so that it is easy to see how the time for a particular task +is divided among various components. For example, <tt>-S -O0</tt> +includes the time of <tt>-fsyntax-only</tt> and <tt>-emit-llvm -O0</tt>.</p> + +<p>Note that we already know that the LLVM optimizers are substantially (30-40%) +faster than the GCC optimizers at a given -O level, so we only focus on -O0 +compile time here.</p> + +<!--*************************************************************************--> +<h2><a name="enduser">Timing Results</a></h2> +<!--*************************************************************************--> + +<!--=======================================================================--> +<h3><a name="2008-10-31">2008-10-31</a></h3> +<!--=======================================================================--> + +<h4 style="text-align:center">Sketch</h4> +<img class="img_slide" + src="timing-data/2008-10-31/sketch.png" alt="Sketch Timings"> + +<p>This shows Clang's substantial performance improvements in +preprocessing and semantic analysis; over 90% faster on +-fsyntax-only. As expected, time spent in code generation for this +benchmark is relatively small. One caveat, Clang's debug information +generation for Objective-C is very incomplete; this means the <tt>-S +-O0 -g</tt> numbers are unfair since Clang is generating substantially +less output.</p> + +<p>This chart also shows the effect of using precompiled headers (PCH) +on compiler time. gcc and llvm-gcc see a large performance improvement +with PCH; about 4x in wall time. Unfortunately, Clang does not yet +have an implementation of PCH-style optimizations, but we are actively +working to address this.</p> + +<h4 style="text-align:center">176.gcc</h4> +<img class="img_slide" + src="timing-data/2008-10-31/176.gcc.png" alt="176.gcc Timings"> + +<p>Unlike the <i>Sketch</i> timings, compilation of <i>176.gcc</i> +involves a large amount of code generation. The time spent in Clang's +LLVM IR generation and code generation is on par with gcc's code +generation time but the improved parsing & semantic analysis +performance means Clang still comes in at ~29% faster versus gcc +on <tt>-S -O0 -g</tt> and ~20% faster versus llvm-gcc.</p> + +<p>These numbers indicate that Clang still has room for improvement in +several areas, notably our LLVM IR generation is significantly slower +than that of llvm-gcc, and both Clang and llvm-gcc incur a +significantly higher cost for adding debugging information compared to +gcc.</p> + +</div> +</body> +</html> diff --git a/clang/www/performance-2009-03-02.html b/clang/www/performance-2009-03-02.html new file mode 100644 index 0000000..3e8c411 --- /dev/null +++ b/clang/www/performance-2009-03-02.html @@ -0,0 +1,110 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>Clang - Performance</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <style type="text/css"> +</style> +</head> +<body> + +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<!--*************************************************************************--> +<h1>Clang - Performance</h1> +<!--*************************************************************************--> + +<p>This page shows the compile time performance of Clang on two +interesting benchmarks:</p> +<ul> + <li><i>Sketch</i>: The Objective-C example application shipped on + Mac OS X as part of Xcode. <i>Sketch</i> is indicative of a + "typical" Objective-C app. The source itself has a relatively + small amount of code (~7,500 lines of source code), but it relies + on the extensive Cocoa APIs to build its functionality. Like many + Objective-C applications, it includes <tt>Cocoa/Cocoa.h</tt> in + all of its source files, which represents a significant stress + test of the front-end's performance on lexing, preprocessing, + parsing, and syntax analysis.</li> + <li><i>176.gcc</i>: This is the gcc-2.7.2.2 code base as present in + SPECINT 2000. In contrast to Sketch, <i>176.gcc</i> consists of a + large amount of C source code (~200,000 lines) with few system + dependencies. This stresses the back-end's performance on generating + assembly code and debug information.</li> +</ul> + +<p> +For previous performance numbers, please +go <a href="performance-2008-10-31.html">here</a>. +</p> + +<!--*************************************************************************--> +<h2><a name="experiments">Experiments</a></h2> +<!--*************************************************************************--> + +<p>Measurements are done by running a full build (using xcodebuild or +make for Sketch and 176.gcc respectively) using Clang and gcc 4.2 as +compilers; gcc is run both with and without the new clang driver (ccc) +in order to evaluate the overhead of the driver itself.</p> + +<p>In order to track the performance of various subsystems the timings +have been broken down into separate stages where possible. This is +done by over-riding the CC environment variable used during the build +to point to one of a few simple shell scripts which may skip part of +the build.</p> + +<ul> + <li><tt>non-compiler</tt>: The overhead of the build system itself; + for Sketch this also includes the time to build/copy various + non-source code resource files.</li> + <li><tt>+ driver</tt>: Add execution of the driver, but do not execute any + commands (by using the -### driver option).</li> + <li><tt>+ pch gen</tt>: Add generation of PCH files.</li> + <li><tt>+ cpp</tt>: Add preprocessing of source files (this time is + include in syntax for gcc).</li> + <li><tt>+ parse</tt>: Add parsing of source files (this time is + include in syntax for gcc).</li> + <li><tt>+ syntax</tt>: Add semantic checking of source files (for + gcc, this includes preprocessing and parsing as well).</li> + <li><tt>+ IRgen</tt>: Add generation of LLVM IR (gcc has no + corresponding phase).</li> + <li><tt>+ codegen</tt>: Add generation of assembler files.</li> + <li><tt>+ assembler</tt>: Add assembler time to generate .o files.</li> + <li><tt>+ linker</tt>: Add linker time.</li> +</ul> + +<p>This set of stages is chosen to be approximately additive, that is +each subsequent stage simply adds some additional processing. The +timings measure the delta of the given stage from the previous +one. For example, the timings for <tt>+ syntax</tt> below show the +difference of running with <tt>+ syntax</tt> versus running with <tt>+ +parse</tt> (for clang) or <tt>+ driver</tt> with gcc. This amounts to +a fairly accurate measure of only the time to perform semantic +analysis (and preprocessing/parsing, in the case of gcc).</p> + +<!--*************************************************************************--> +<h2><a name="timings">Timing Results</a></h2> +<!--*************************************************************************--> + +<!--=======================================================================--> +<h3><a name="2009-03-02">2009-03-02</a></h3> +<!--=======================================================================--> + +<a href="timing-data/2009-03-02/sketch.pdf"> +<img class="img_slide" + src="timing-data/2009-03-02/sketch.png" alt="Sketch Timings"> +</a> + +<a href="timing-data/2009-03-02/176.gcc.pdf"> +<img class="img_slide" + src="timing-data/2009-03-02/176.gcc.png" alt="176.gcc Timings"> +</a> + +</div> +</body> +</html> diff --git a/clang/www/performance.html b/clang/www/performance.html new file mode 100644 index 0000000..e85f191 --- /dev/null +++ b/clang/www/performance.html @@ -0,0 +1,104 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>Clang - Performance</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <style type="text/css"> +</style> +</head> +<body> + +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<!--*************************************************************************--> +<h1>Clang - Performance</h1> +<!--*************************************************************************--> + +<p>This page shows the compile time performance of Clang on two +interesting benchmarks:</p> +<ul> + <li><i>Sketch</i>: The Objective-C example application shipped on + Mac OS X as part of Xcode. <i>Sketch</i> is indicative of a + "typical" Objective-C app. The source itself has a relatively + small amount of code (~7,500 lines of source code), but it relies + on the extensive Cocoa APIs to build its functionality. Like many + Objective-C applications, it includes <tt>Cocoa/Cocoa.h</tt> in + all of its source files, which represents a significant stress + test of the front-end's performance on lexing, preprocessing, + parsing, and syntax analysis.</li> + <li><i>176.gcc</i>: This is the gcc-2.7.2.2 code base as present in + SPECINT 2000. In contrast to Sketch, <i>176.gcc</i> consists of a + large amount of C source code (~200,000 lines) with few system + dependencies. This stresses the back-end's performance on generating + assembly code and debug information.</li> +</ul> + +<p> +For previous performance numbers, please +go <a href="performance-2009-03-02.html">here</a>. +</p> + +<!--*************************************************************************--> +<h2><a name="experiments">Experiments</a></h2> +<!--*************************************************************************--> + +<p>Measurements are done by running a full build (using xcodebuild or +make for Sketch and 176.gcc respectively) using Clang and gcc 4.2 as +compilers.</p> + +<p>In order to track the performance of various subsystems the timings +have been broken down into separate stages where possible. This is +done by over-riding the CC environment variable used during the build +to point to one of a few simple shell scripts which may skip part of +the build.</p> + +<ul> + <li><tt>non-compiler</tt>: The overhead of the build system itself; + for Sketch this also includes the time to build/copy various + non-source code resource files.</li> + <li><tt>+ driver</tt>: Add execution of the driver, but do not execute any + commands (by using the -### driver option).</li> + <li><tt>+ pch gen</tt>: Add generation of PCH files (if used).</li> + <li><tt>+ syntax</tt>: Add preprocessing, parsing, and semantic checking of + source files.</li> + <li><tt>+ IRgen</tt>: Add generation of LLVM IR (gcc has no + corresponding phase).</li> + <li><tt>+ codegen</tt>: Add generation of assembler files.</li> + <li><tt>+ assembler</tt>: Add assembler time to generate .o files.</li> + <li><tt>+ linker</tt>: Add linker time.</li> +</ul> + +<p>This set of stages is chosen to be approximately additive, that is each +subsequent stage simply adds some additional processing. The timings measure the +delta of the given stage from the previous one. For example, the timings +for <tt>+ syntax</tt> below show the difference of running with <tt>+ +syntax</tt> versus the times for <tt>+ pch gen</tt>. This amounts to a fairly +accurate measure of only the time to perform preprocessing, parsing, and +semantic analysis after PCH generation is done.</p> + +<!--*************************************************************************--> +<h2><a name="timings">Timing Results</a></h2> +<!--*************************************************************************--> + +<!--=======================================================================--> +<h3><a name="2009-06-26">2009-06-26</a></h3> +<!--=======================================================================--> + +<a href="timing-data/2009-06-26/sketch.pdf"> +<img class="img_slide" + src="timing-data/2009-06-26/sketch.png" alt="Sketch Timings"> +</a> + +<a href="timing-data/2009-06-26/176.gcc.pdf"> +<img class="img_slide" + src="timing-data/2009-06-26/176.gcc.png" alt="176.gcc Timings"> +</a> + +</div> +</body> +</html> diff --git a/clang/www/related.html b/clang/www/related.html new file mode 100644 index 0000000..a1ff79b --- /dev/null +++ b/clang/www/related.html @@ -0,0 +1,55 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ --> +<html> +<head> + <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>Clang Related Projects</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> +</head> +<body> + <!--#include virtual="menu.html.incl"--> + <div id="content"> + <h1>Clang Related Projects</h1> + + <p>As Clang matures, more and more projects are being built atop the Clang + libraries and other open source projects are starting their own Clang + related subprojects, like building their source code with Clang or writing + custom analysis tools using Clang. This page tracks some of those Clang + related projects.</p> + + <p>Please email cfe-dev if you have a Clang related project you would like + added to this list.</p> + + <dl> + <dt>FreeBSD Clang Page</dt> + <dd> + <p> + <b>Site:</b> + <a href="http://wiki.freebsd.org/BuildingFreeBSDWithClang"> + http://wiki.freebsd.org/BuildingFreeBSDWithClang</a> + </p> + <p> + This is an effort to get FreeBSD to build with clang/llvm. Clang is a + compiler built on the Low Level Virtual Machine compiler + infrastructure. Both clang and llvm are released under a BSD like + license. + </p> + </dd> + + <dt>Chromium Clang Page</dt> + <dd> + <p> + <b>Site:</b> + <a href="http://code.google.com/p/chromium/wiki/Clang"> + http://code.google.com/p/chromium/wiki/Clang</a> + </p> + <p> + Notes on using Clang to build the Chromium web browser. + </p> + </dd> + </dl> + </div> +</body> +</html> diff --git a/clang/www/robots.txt b/clang/www/robots.txt new file mode 100644 index 0000000..9e60f97 --- /dev/null +++ b/clang/www/robots.txt @@ -0,0 +1,2 @@ +User-agent: * +Disallow: diff --git a/clang/www/timing-data/2008-10-31/176.gcc-01.txt b/clang/www/timing-data/2008-10-31/176.gcc-01.txt new file mode 100644 index 0000000..3809e0d --- /dev/null +++ b/clang/www/timing-data/2008-10-31/176.gcc-01.txt @@ -0,0 +1,135 @@ +Title: 176.gcc Timings +Timestamp: 2008-10-31_17-10 +Uname: Darwin lordcrumb.apple.com 10.0.0d3 Darwin Kernel Version 10.0.0d3: Fri Oct 24 02:12:11 PDT 2008; root:xnu-1353~2/RELEASE_I386 i386 +Path: /Users/ddunbar/nightlytest/176.gcc +Runs: 3 + +LLVM SVN Rev.: 58536 + +clang: /Users/ddunbar/llvm/Release-Asserts/bin//clang +gcc: /usr/bin/gcc-4.2 +llvm-gcc: /Users/ddunbar/llvm-gcc/install/bin/llvm-gcc + +Mode: Eonly Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 0.8321 0.8274 0.8274 0.8435 0.0080 2.4964 + sys 0.4209 0.4140 0.4140 0.4307 0.0071 1.2626 +wall 1.2965 1.2829 1.2829 1.3176 0.0152 3.8894 + +Mode: Eonly Compiler: gcc PCH: 0 Flags: +name avg min med max SD total +user 0.8534 0.8465 0.8563 0.8575 0.0050 2.5603 + sys 0.5327 0.5200 0.5291 0.5490 0.0121 1.5980 +wall 1.4336 1.4104 1.4330 1.4575 0.0192 4.3009 + +Mode: Eonly Compiler: llvm-gcc PCH: 0 Flags: +name avg min med max SD total +user 1.1313 1.1277 1.1304 1.1359 0.0034 3.3940 + sys 0.5579 0.5530 0.5539 0.5669 0.0063 1.6738 +wall 1.7860 1.7669 1.7890 1.8020 0.0145 5.3580 + + +Mode: parse-noop Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 0.9276 0.9267 0.9269 0.9292 0.0011 2.7827 + sys 0.4284 0.4244 0.4255 0.4353 0.0049 1.2852 +wall 1.3994 1.3941 1.3954 1.4086 0.0066 4.1981 + + +Mode: disable-free Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 1.2716 1.2497 1.2713 1.2937 0.0180 3.8147 + sys 0.4835 0.4815 0.4738 0.4953 0.0089 1.4506 +wall 1.8149 1.7838 1.8137 1.8471 0.0259 5.4446 + + +Mode: syntax Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 1.4042 1.4031 1.4044 1.4044 0.0009 4.2127 + sys 0.4818 0.4802 0.4838 0.4838 0.0015 1.4454 +wall 1.9359 1.9333 1.9376 1.9376 0.0019 5.8077 + +Mode: syntax Compiler: gcc PCH: 0 Flags: +name avg min med max SD total +user 3.9188 3.8766 3.8846 3.9951 0.0541 11.7563 + sys 1.0207 1.0195 1.0141 1.0285 0.0059 3.0622 +wall 5.0500 5.0023 5.0092 5.1386 0.0627 15.1500 + +Mode: syntax Compiler: llvm-gcc PCH: 0 Flags: +name avg min med max SD total +user 3.8854 3.8647 3.8868 3.9048 0.0164 11.6563 + sys 0.8548 0.8436 0.8455 0.8753 0.0145 2.5644 +wall 4.8695 4.8369 4.8614 4.9103 0.0305 14.6086 + + +Mode: llvm Compiler: clang PCH: 0 Flags: -O0 +name avg min med max SD total +user 2.7903 2.7606 2.8026 2.8079 0.0211 8.3710 + sys 0.6645 0.6509 0.6759 0.6667 0.0104 1.9935 +wall 3.5577 3.4894 3.5650 3.6186 0.0530 10.6730 + +Mode: llvm Compiler: llvm-gcc PCH: 0 Flags: -O0 +name avg min med max SD total +user 4.1711 4.1389 4.1729 4.2015 0.0256 12.5133 + sys 0.9335 0.9339 0.9218 0.9448 0.0094 2.8004 +wall 5.2380 5.1985 5.2417 5.2738 0.0309 15.7140 + + +Mode: asm Compiler: clang PCH: 0 Flags: -O0 +name avg min med max SD total +user 5.2797 5.1709 5.2643 5.4040 0.0958 15.8392 + sys 0.7739 0.7547 0.7726 0.7944 0.0162 2.3217 +wall 6.1807 6.1082 6.1174 6.3165 0.0961 18.5421 + Asm Lines: 735931 + +Mode: asm Compiler: gcc PCH: 0 Flags: -O0 +name avg min med max SD total +user 8.2410 8.1034 8.2230 8.3965 0.1203 24.7230 + sys 1.1924 1.1576 1.2112 1.2082 0.0246 3.5771 +wall 9.6010 9.3792 9.6800 9.7438 0.1590 28.8030 + Asm Lines: 514962 + +Mode: asm Compiler: llvm-gcc PCH: 0 Flags: -O0 +name avg min med max SD total +user 6.3978 6.3894 6.3894 6.4726 0.0579 19.1935 + sys 1.0638 1.0562 1.0562 1.0861 0.0160 3.1914 +wall 7.6185 7.5807 7.5807 7.6876 0.0489 22.8555 + Asm Lines: 597193 + + +Mode: llvm Compiler: clang PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 3.9798 3.9728 3.9752 3.9914 0.0083 11.9393 + sys 0.7313 0.7260 0.7326 0.7353 0.0039 2.1938 +wall 4.7915 4.7799 4.7878 4.8066 0.0112 14.3744 + +Mode: llvm Compiler: llvm-gcc PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 5.4838 5.4701 5.4701 5.5172 0.0238 16.4513 + sys 1.0527 1.0401 1.0401 1.0757 0.0163 3.1581 +wall 6.7059 6.6768 6.6768 6.7254 0.0210 20.1177 + + +Mode: asm Compiler: clang PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 6.8213 6.7836 6.8060 6.8743 0.0386 20.4639 + sys 0.8527 0.8376 0.8598 0.8607 0.0107 2.5582 +wall 7.8055 7.7154 7.8109 7.8902 0.0714 23.4165 + Asm Lines: 1581804 + +Mode: asm Compiler: gcc PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 8.7962 8.6334 8.7861 8.9691 0.1373 26.3887 + sys 1.2758 1.2395 1.2780 1.3100 0.0288 3.8275 +wall 10.2714 10.1274 10.2232 10.4635 0.1414 30.8142 + Asm Lines: 1403421 + +Mode: asm Compiler: llvm-gcc PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 7.9903 7.9383 7.9821 8.0504 0.0461 23.9708 + sys 1.1587 1.1374 1.1592 1.1794 0.0171 3.4760 +wall 9.3711 9.2555 9.2884 9.5692 0.1408 28.1132 + Asm Lines: 1580849 + + + Done: 2008-10-31_17-16 diff --git a/clang/www/timing-data/2008-10-31/176.gcc-02.txt b/clang/www/timing-data/2008-10-31/176.gcc-02.txt new file mode 100644 index 0000000..dd898c1 --- /dev/null +++ b/clang/www/timing-data/2008-10-31/176.gcc-02.txt @@ -0,0 +1,135 @@ +Title: 176.gcc Timings +Timestamp: 2008-10-31_17-17 +Uname: Darwin lordcrumb.apple.com 10.0.0d3 Darwin Kernel Version 10.0.0d3: Fri Oct 24 02:12:11 PDT 2008; root:xnu-1353~2/RELEASE_I386 i386 +Path: /Users/ddunbar/nightlytest/176.gcc +Runs: 3 + +LLVM SVN Rev.: 58536 + +clang: /Users/ddunbar/llvm/Release-Asserts/bin//clang +gcc: /usr/bin/gcc-4.2 +llvm-gcc: /Users/ddunbar/llvm-gcc/install/bin/llvm-gcc + +Mode: Eonly Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 0.8238 0.8184 0.8187 0.8342 0.0074 2.4713 + sys 0.4030 0.3891 0.3953 0.4247 0.0155 1.2091 +wall 1.2731 1.2477 1.2565 1.3152 0.0299 3.8194 + +Mode: Eonly Compiler: gcc PCH: 0 Flags: +name avg min med max SD total +user 0.8584 0.8501 0.8560 0.8692 0.0080 2.5753 + sys 0.5426 0.5268 0.5453 0.5556 0.0119 1.6277 +wall 1.4485 1.4214 1.4503 1.4737 0.0214 4.3454 + +Mode: Eonly Compiler: llvm-gcc PCH: 0 Flags: +name avg min med max SD total +user 1.1289 1.1338 1.1322 1.1207 0.0058 3.3866 + sys 0.5857 0.5787 0.5734 0.6051 0.0138 1.7572 +wall 1.8195 1.8110 1.8124 1.8350 0.0110 5.4585 + + +Mode: parse-noop Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 0.9286 0.9250 0.9250 0.9370 0.0059 2.7859 + sys 0.4255 0.4163 0.4163 0.4417 0.0115 1.2764 +wall 1.3970 1.3826 1.3826 1.4241 0.0192 4.1910 + + +Mode: disable-free Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 1.2962 1.2963 1.2963 1.3114 0.0125 3.8885 + sys 0.4842 0.4864 0.4864 0.4901 0.0059 1.4527 +wall 1.8424 1.8356 1.8356 1.8534 0.0078 5.5273 + + +Mode: syntax Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 1.4120 1.4055 1.4118 1.4188 0.0054 4.2360 + sys 0.4824 0.4786 0.4821 0.4864 0.0032 1.4471 +wall 1.9573 1.9467 1.9570 1.9682 0.0088 5.8719 + +Mode: syntax Compiler: gcc PCH: 0 Flags: +name avg min med max SD total +user 3.9243 3.8431 3.9624 3.9675 0.0575 11.7730 + sys 1.0094 0.9967 1.0135 1.0180 0.0091 3.0282 +wall 5.0495 4.9447 5.1012 5.1025 0.0741 15.1484 + +Mode: syntax Compiler: llvm-gcc PCH: 0 Flags: +name avg min med max SD total +user 3.9287 3.8760 3.9226 3.9874 0.0457 11.7860 + sys 0.8949 0.8684 0.9014 0.9147 0.0195 2.6846 +wall 4.9625 4.8722 4.9601 5.0550 0.0747 14.8874 + + +Mode: llvm Compiler: clang PCH: 0 Flags: -O0 +name avg min med max SD total +user 2.8082 2.7806 2.8106 2.8334 0.0216 8.4246 + sys 0.6608 0.6564 0.6582 0.6677 0.0049 1.9823 +wall 3.5453 3.5150 3.5559 3.5650 0.0218 10.6359 + +Mode: llvm Compiler: llvm-gcc PCH: 0 Flags: -O0 +name avg min med max SD total +user 4.1471 4.1512 4.1505 4.1395 0.0053 12.4413 + sys 0.9221 0.9069 0.9203 0.9391 0.0132 2.7663 +wall 5.2138 5.1919 5.2001 5.2495 0.0255 15.6415 + + +Mode: asm Compiler: clang PCH: 0 Flags: -O0 +name avg min med max SD total +user 5.1674 5.1537 5.1637 5.1637 0.0129 15.5022 + sys 0.7424 0.7404 0.7376 0.7376 0.0049 2.2271 +wall 6.0284 5.9844 6.0964 6.0964 0.0487 18.0852 + Asm Lines: 735931 + +Mode: asm Compiler: gcc PCH: 0 Flags: -O0 +name avg min med max SD total +user 8.0945 8.0259 8.1235 8.1342 0.0487 24.2835 + sys 1.1599 1.1517 1.1626 1.1654 0.0059 3.4796 +wall 9.4120 9.2935 9.4036 9.5390 0.1004 28.2361 + Asm Lines: 514962 + +Mode: asm Compiler: llvm-gcc PCH: 0 Flags: -O0 +name avg min med max SD total +user 6.4405 6.3577 6.4623 6.5014 0.0607 19.3214 + sys 1.0571 1.0454 1.0359 1.0902 0.0237 3.1714 +wall 7.6688 7.5631 7.6376 7.8058 0.1015 23.0065 + Asm Lines: 597193 + + +Mode: llvm Compiler: clang PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 3.9883 3.9539 3.9626 4.0485 0.0427 11.9650 + sys 0.7333 0.7209 0.7377 0.7413 0.0089 2.1998 +wall 4.8088 4.7485 4.7821 4.8957 0.0630 14.4263 + +Mode: llvm Compiler: llvm-gcc PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 5.4875 5.4528 5.5017 5.5017 0.0247 16.4626 + sys 1.0308 1.0231 1.0248 1.0248 0.0097 3.0923 +wall 6.6781 6.6372 6.7006 6.7006 0.0290 20.0342 + + +Mode: asm Compiler: clang PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 6.7945 6.6664 6.7352 6.9819 0.1355 20.3835 + sys 0.8359 0.8172 0.8329 0.8577 0.0167 2.5077 +wall 7.7458 7.6003 7.7080 7.9290 0.1368 23.2374 + Asm Lines: 1581804 + +Mode: asm Compiler: gcc PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 8.7280 8.6884 8.7084 8.7870 0.0426 26.1839 + sys 1.3031 1.2940 1.3118 1.3037 0.0073 3.9094 +wall 10.2039 10.1039 10.1162 10.3916 0.1328 30.6116 + Asm Lines: 1403421 + +Mode: asm Compiler: llvm-gcc PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 7.9987 7.9805 7.9805 8.0493 0.0362 23.9962 + sys 1.1561 1.1523 1.1523 1.1626 0.0047 3.4682 +wall 9.3154 9.2801 9.2801 9.3606 0.0336 27.9463 + Asm Lines: 1580849 + + + Done: 2008-10-31_17-23 diff --git a/clang/www/timing-data/2008-10-31/176.gcc.png b/clang/www/timing-data/2008-10-31/176.gcc.png Binary files differnew file mode 100644 index 0000000..53efd87 --- /dev/null +++ b/clang/www/timing-data/2008-10-31/176.gcc.png diff --git a/clang/www/timing-data/2008-10-31/sketch-01.txt b/clang/www/timing-data/2008-10-31/sketch-01.txt new file mode 100644 index 0000000..ff5d83e --- /dev/null +++ b/clang/www/timing-data/2008-10-31/sketch-01.txt @@ -0,0 +1,187 @@ +Title: Sketch Timings +Timestamp: 2008-10-31_16-46 +Uname: Darwin lordcrumb.apple.com 10.0.0d3 Darwin Kernel Version 10.0.0d3: Fri Oct 24 02:12:11 PDT 2008; root:xnu-1353~2/RELEASE_I386 i386 +Path: /Users/ddunbar/nightlytest/Sketch.ref +Runs: 3 + +LLVM SVN Rev.: 58536 + +clang: /Users/ddunbar/llvm/Release-Asserts/bin//clang +gcc: /usr/bin/gcc-4.2 +llvm-gcc: /Users/ddunbar/llvm-gcc/install/bin/llvm-gcc + +Mode: Eonly Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 1.3762 1.3711 1.3724 1.3849 0.0062 4.1285 + sys 0.8306 0.8276 0.8274 0.8367 0.0044 2.4917 +wall 2.2290 2.2207 2.2219 2.2445 0.0109 6.6870 + +Mode: Eonly Compiler: gcc PCH: 0 Flags: +name avg min med max SD total +user 2.2970 2.2352 2.2374 2.4184 0.0858 6.8910 + sys 1.0716 1.0338 1.0342 1.1470 0.0533 3.2149 +wall 3.4039 3.3027 3.3046 3.6043 0.1417 10.2116 + +Mode: Eonly Compiler: llvm-gcc PCH: 0 Flags: +name avg min med max SD total +user 2.8472 2.7770 2.7770 2.9893 0.1005 8.5416 + sys 1.3153 1.2699 1.2699 1.4079 0.0655 3.9460 +wall 4.2134 4.0909 4.0909 4.4421 0.1618 12.6403 + + +Mode: parse-noop Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 1.7295 1.7228 1.7237 1.7421 0.0089 5.1886 + sys 0.8510 0.8468 0.8448 0.8615 0.0074 2.5530 +wall 2.6034 2.5913 2.5914 2.6277 0.0172 7.8103 + + +Mode: disable-free Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 2.7310 2.7274 2.7288 2.7288 0.0042 8.1930 + sys 0.9950 0.9890 0.9917 0.9917 0.0068 2.9851 +wall 3.7720 3.7515 3.7866 3.7866 0.0150 11.3161 + + +Mode: syntax Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 3.1817 3.1284 3.1620 3.2547 0.0534 9.5451 + sys 1.0815 1.0569 1.0737 1.1138 0.0239 3.2444 +wall 4.2918 4.2129 4.2635 4.3991 0.0786 12.8755 + +Mode: syntax Compiler: gcc PCH: 0 Flags: +name avg min med max SD total +user 6.4086 6.3289 6.4012 6.4956 0.0682 19.2258 + sys 1.7617 1.7257 1.7615 1.7979 0.0295 5.2851 +wall 8.2403 8.1235 8.2432 8.3541 0.0942 24.7208 + +Mode: syntax Compiler: llvm-gcc PCH: 0 Flags: +name avg min med max SD total +user 6.9711 6.8657 6.9738 7.0739 0.0850 20.9133 + sys 1.7577 1.7226 1.7801 1.7702 0.0251 5.2730 +wall 8.8020 8.6601 8.8243 8.9216 0.1079 26.4061 + +Mode: syntax Compiler: gcc PCH: 1 Flags: +name avg min med max SD total +user 0.6082 0.6078 0.6083 0.6085 0.0003 1.8245 + sys 0.8901 0.8826 0.8949 0.8927 0.0053 2.6702 +wall 1.5593 1.5558 1.5605 1.5617 0.0025 4.6780 + +Mode: syntax Compiler: llvm-gcc PCH: 1 Flags: +name avg min med max SD total +user 0.6413 0.6409 0.6409 0.6407 0.0008 1.9240 + sys 0.7872 0.7805 0.7805 0.7954 0.0062 2.3615 +wall 1.4837 1.4760 1.4760 1.4877 0.0054 4.4510 + + +Mode: llvm Compiler: clang PCH: 0 Flags: -O0 +name avg min med max SD total +user 3.3512 3.2800 3.3205 3.4530 0.0739 10.0535 + sys 1.0991 1.0690 1.0833 1.1450 0.0330 3.2974 +wall 4.4934 4.4015 4.4394 4.6392 0.1043 13.4801 + +Mode: llvm Compiler: llvm-gcc PCH: 0 Flags: -O0 +name avg min med max SD total +user 7.1104 7.0581 7.1061 7.1670 0.0446 21.3311 + sys 1.7621 1.7462 1.7556 1.7845 0.0163 5.2863 +wall 8.9510 8.8993 8.9352 9.0187 0.0500 26.8531 + +Mode: llvm Compiler: llvm-gcc PCH: 1 Flags: -O0 +name avg min med max SD total +user 0.8446 0.8300 0.8499 0.8538 0.0104 2.5338 + sys 0.8742 0.8366 0.8861 0.9000 0.0272 2.6227 +wall 1.7871 1.7366 1.8046 1.8201 0.0362 5.3613 + + +Mode: asm Compiler: clang PCH: 0 Flags: -O0 +name avg min med max SD total +user 3.4794 3.4750 3.4794 3.4794 0.0035 10.4381 + sys 1.0876 1.0817 1.0874 1.0874 0.0049 3.2628 +wall 4.6112 4.5958 4.6223 4.6223 0.0112 13.8337 + Asm Lines: 46279 + +Mode: asm Compiler: gcc PCH: 0 Flags: -O0 +name avg min med max SD total +user 6.8875 6.7735 6.8748 7.0143 0.0987 20.6626 + sys 1.8035 1.7586 1.8049 1.8472 0.0362 5.4106 +wall 8.7785 8.6100 8.7574 8.9682 0.1470 26.3356 + Asm Lines: 41008 + +Mode: asm Compiler: llvm-gcc PCH: 0 Flags: -O0 +name avg min med max SD total +user 7.3392 7.2327 7.3071 7.4779 0.1026 22.0176 + sys 1.8018 1.7703 1.7930 1.8420 0.0299 5.4053 +wall 9.2274 9.0793 9.1968 9.4062 0.1352 27.6823 + Asm Lines: 47243 + +Mode: asm Compiler: gcc PCH: 1 Flags: -O0 +name avg min med max SD total +user 1.0485 1.0361 1.0429 1.0666 0.0131 3.1456 + sys 1.0277 1.0097 1.0437 1.0296 0.0140 3.0830 +wall 2.1621 2.1181 2.1496 2.2185 0.0419 6.4862 + Asm Lines: 41001 + +Mode: asm Compiler: llvm-gcc PCH: 1 Flags: -O0 +name avg min med max SD total +user 0.9927 0.9898 0.9932 0.9951 0.0022 2.9781 + sys 0.8640 0.8529 0.8610 0.8781 0.0105 2.5920 +wall 1.9183 1.9041 1.9193 1.9315 0.0112 5.7550 + Asm Lines: 47238 + + +Mode: llvm Compiler: clang PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 3.3843 3.3639 3.3719 3.4173 0.0235 10.1530 + sys 1.0862 1.0743 1.0789 1.1053 0.0136 3.2585 +wall 4.5248 4.4754 4.4906 4.6084 0.0595 13.5744 + +Mode: llvm Compiler: llvm-gcc PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 7.4463 7.3855 7.3897 7.5638 0.0831 22.3390 + sys 1.7927 1.7653 1.7841 1.8286 0.0265 5.3780 +wall 9.3259 9.2350 9.2660 9.4767 0.1074 27.9777 + +Mode: llvm Compiler: llvm-gcc PCH: 1 Flags: -O0 -g +name avg min med max SD total +user 1.1532 1.1527 1.1527 1.1556 0.0018 3.4596 + sys 0.8746 0.8663 0.8663 0.8774 0.0060 2.6238 +wall 2.1168 2.0914 2.0914 2.1464 0.0226 6.3503 + + +Mode: asm Compiler: clang PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 3.6819 3.5955 3.7080 3.7422 0.0627 11.0458 + sys 1.1386 1.0879 1.1480 1.1798 0.0381 3.4158 +wall 4.8606 4.7204 4.8947 4.9668 0.1034 14.5819 + Asm Lines: 106056 + +Mode: asm Compiler: gcc PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 7.9271 7.8581 7.8581 8.0696 0.1008 23.7814 + sys 2.0275 1.9943 1.9943 2.0711 0.0322 6.0826 +wall 10.0313 9.9266 9.9266 10.2314 0.1415 30.0939 + Asm Lines: 177342 + +Mode: asm Compiler: llvm-gcc PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 7.7083 7.6793 7.6941 7.6941 0.0312 23.1249 + sys 1.8122 1.7971 1.8204 1.8204 0.0107 5.4365 +wall 9.6227 9.5591 9.6555 9.6555 0.0450 28.8682 + Asm Lines: 203358 + +Mode: asm Compiler: gcc PCH: 1 Flags: -O0 -g +name avg min med max SD total +user 1.2589 1.2129 1.2130 1.3509 0.0650 3.7767 + sys 1.2141 1.1467 1.1601 1.3355 0.0860 3.6423 +wall 2.5426 2.4325 2.4357 2.7596 0.1534 7.6278 + Asm Lines: 177335 + +Mode: asm Compiler: llvm-gcc PCH: 1 Flags: -O0 -g +name avg min med max SD total +user 1.4234 1.3843 1.4009 1.4849 0.0440 4.2701 + sys 0.9822 0.9153 0.9446 1.0867 0.0749 2.9466 +wall 2.4856 2.3713 2.4482 2.6372 0.1117 7.4567 + Asm Lines: 203353 + + + Done: 2008-10-31_16-55 diff --git a/clang/www/timing-data/2008-10-31/sketch-02.txt b/clang/www/timing-data/2008-10-31/sketch-02.txt new file mode 100644 index 0000000..88af326 --- /dev/null +++ b/clang/www/timing-data/2008-10-31/sketch-02.txt @@ -0,0 +1,187 @@ +Title: Sketch Timings +Timestamp: 2008-10-31_16-59 +Uname: Darwin lordcrumb.apple.com 10.0.0d3 Darwin Kernel Version 10.0.0d3: Fri Oct 24 02:12:11 PDT 2008; root:xnu-1353~2/RELEASE_I386 i386 +Path: /Users/ddunbar/nightlytest/Sketch.ref +Runs: 3 + +LLVM SVN Rev.: 58536 + +clang: /Users/ddunbar/llvm/Release-Asserts/bin//clang +gcc: /usr/bin/gcc-4.2 +llvm-gcc: /Users/ddunbar/llvm-gcc/install/bin/llvm-gcc + +Mode: Eonly Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 1.4030 1.3765 1.3887 1.4437 0.0293 4.2089 + sys 0.8561 0.8388 0.8497 0.8796 0.0173 2.5682 +wall 2.2809 2.2373 2.2586 2.3468 0.0474 6.8426 + +Mode: Eonly Compiler: gcc PCH: 0 Flags: +name avg min med max SD total +user 2.3041 2.2821 2.2821 2.3563 0.0371 6.9123 + sys 1.0772 1.0593 1.0593 1.0976 0.0157 3.2316 +wall 3.4323 3.3918 3.3918 3.4905 0.0422 10.2970 + +Mode: Eonly Compiler: llvm-gcc PCH: 0 Flags: +name avg min med max SD total +user 2.7593 2.7038 2.7831 2.7831 0.0393 8.2778 + sys 1.2805 1.2605 1.2868 1.2868 0.0144 3.8414 +wall 4.0893 4.0056 4.1319 4.1319 0.0592 12.2679 + + +Mode: parse-noop Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 1.7430 1.7252 1.7429 1.7610 0.0146 5.2291 + sys 0.8573 0.8457 0.8605 0.8656 0.0085 2.5718 +wall 2.6237 2.5942 2.6266 2.6504 0.0230 7.8711 + + +Mode: disable-free Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 2.7684 2.7291 2.7310 2.8450 0.0542 8.3051 + sys 1.0088 0.9948 0.9960 1.0356 0.0189 3.0263 +wall 3.8203 3.7581 3.7635 3.9394 0.0842 11.4610 + + +Mode: syntax Compiler: clang PCH: 0 Flags: +name avg min med max SD total +user 3.1106 3.1115 3.1107 3.1095 0.0008 9.3317 + sys 1.0674 1.0630 1.0672 1.0721 0.0037 3.2022 +wall 4.2059 4.2015 4.2077 4.2085 0.0031 12.6176 + +Mode: syntax Compiler: gcc PCH: 0 Flags: +name avg min med max SD total +user 6.4166 6.3461 6.4479 6.4559 0.0500 19.2499 + sys 1.7649 1.7256 1.7836 1.7854 0.0278 5.2946 +wall 8.2536 8.1547 8.3018 8.3045 0.0700 24.7609 + +Mode: syntax Compiler: llvm-gcc PCH: 0 Flags: +name avg min med max SD total +user 7.0297 6.9018 7.0003 7.1869 0.1182 21.0890 + sys 1.7782 1.7336 1.7875 1.8136 0.0333 5.3347 +wall 8.8942 8.7128 8.8699 9.0999 0.1590 26.6826 + +Mode: syntax Compiler: gcc PCH: 1 Flags: +name avg min med max SD total +user 0.6133 0.6065 0.6089 0.6244 0.0079 1.8398 + sys 0.9115 0.8880 0.9019 0.9446 0.0241 2.7345 +wall 1.5864 1.5593 1.5669 1.6330 0.0331 4.7592 + +Mode: syntax Compiler: llvm-gcc PCH: 1 Flags: +name avg min med max SD total +user 0.6412 0.6387 0.6387 0.6477 0.0047 1.9235 + sys 0.7820 0.7654 0.7654 0.7955 0.0125 2.3461 +wall 1.4909 1.4783 1.4783 1.5124 0.0153 4.4726 + + +Mode: llvm Compiler: clang PCH: 0 Flags: -O0 +name avg min med max SD total +user 3.2926 3.2939 3.2939 3.2998 0.0065 9.8778 + sys 1.0746 1.0728 1.0728 1.0793 0.0034 3.2237 +wall 4.4097 4.4045 4.4045 4.4150 0.0043 13.2290 + +Mode: llvm Compiler: llvm-gcc PCH: 0 Flags: -O0 +name avg min med max SD total +user 7.3232 7.2559 7.3145 7.3991 0.0588 21.9695 + sys 1.8050 1.7967 1.7982 1.8201 0.0107 5.4151 +wall 9.2155 9.1243 9.2130 9.3092 0.0755 27.6465 + +Mode: llvm Compiler: llvm-gcc PCH: 1 Flags: -O0 +name avg min med max SD total +user 0.8337 0.8288 0.8288 0.8444 0.0076 2.5011 + sys 0.8575 0.8484 0.8484 0.8773 0.0140 2.5725 +wall 1.7973 1.7406 1.7406 1.9054 0.0764 5.3919 + + +Mode: asm Compiler: clang PCH: 0 Flags: -O0 +name avg min med max SD total +user 3.4909 3.4823 3.4896 3.4896 0.0077 10.4728 + sys 1.0997 1.1027 1.1028 1.1028 0.0043 3.2991 +wall 4.6332 4.6179 4.6483 4.6483 0.0124 13.8996 + Asm Lines: 46279 + +Mode: asm Compiler: gcc PCH: 0 Flags: -O0 +name avg min med max SD total +user 6.8956 6.7882 6.9057 6.9929 0.0839 20.6868 + sys 1.7978 1.7703 1.7928 1.8302 0.0247 5.3933 +wall 8.7724 8.6360 8.7818 8.8994 0.1077 26.3172 + Asm Lines: 41008 + +Mode: asm Compiler: llvm-gcc PCH: 0 Flags: -O0 +name avg min med max SD total +user 7.2722 7.2087 7.3014 7.3014 0.0450 21.8167 + sys 1.8020 1.7828 1.8083 1.8083 0.0139 5.4060 +wall 9.1527 9.0609 9.2011 9.2011 0.0650 27.4582 + Asm Lines: 47243 + +Mode: asm Compiler: gcc PCH: 1 Flags: -O0 +name avg min med max SD total +user 1.0563 1.0337 1.0373 1.0979 0.0294 3.1689 + sys 1.0249 0.9862 0.9837 1.1048 0.0565 3.0747 +wall 2.1458 2.0764 2.0838 2.2772 0.0930 6.4374 + Asm Lines: 41001 + +Mode: asm Compiler: llvm-gcc PCH: 1 Flags: -O0 +name avg min med max SD total +user 0.9983 0.9929 0.9929 1.0110 0.0090 2.9950 + sys 0.8616 0.8525 0.8525 0.8822 0.0146 2.5849 +wall 1.9268 1.9061 1.9061 1.9632 0.0259 5.7804 + Asm Lines: 47238 + + +Mode: llvm Compiler: clang PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 3.4344 3.3999 3.4302 3.4730 0.0300 10.3032 + sys 1.1155 1.0881 1.1394 1.1191 0.0211 3.3466 +wall 4.5875 4.5279 4.6054 4.6292 0.0432 13.7626 + +Mode: llvm Compiler: llvm-gcc PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 7.5996 7.5021 7.5389 7.7578 0.1129 22.7988 + sys 1.8546 1.8469 1.8262 1.8908 0.0270 5.5639 +wall 9.5392 9.4246 9.4575 9.7353 0.1394 28.6175 + +Mode: llvm Compiler: llvm-gcc PCH: 1 Flags: -O0 -g +name avg min med max SD total +user 1.1556 1.1512 1.1542 1.1542 0.0042 3.4667 + sys 0.9021 0.8890 0.8971 0.8971 0.0131 2.7062 +wall 2.1308 2.1126 2.1487 2.1487 0.0147 6.3924 + + +Mode: asm Compiler: clang PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 3.6020 3.5895 3.5904 3.6259 0.0169 10.8059 + sys 1.0967 1.0879 1.0879 1.1143 0.0124 3.2901 +wall 4.7362 4.7169 4.7182 4.7736 0.0264 14.2087 + Asm Lines: 106056 + +Mode: asm Compiler: gcc PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 8.0264 7.8409 8.0350 8.2033 0.1481 24.0792 + sys 2.0315 1.9767 2.0315 2.0864 0.0448 6.0946 +wall 10.1477 9.9000 10.1584 10.3846 0.1980 30.4430 + Asm Lines: 177342 + +Mode: asm Compiler: llvm-gcc PCH: 0 Flags: -O0 -g +name avg min med max SD total +user 7.8449 7.8189 7.8471 7.8687 0.0204 23.5346 + sys 1.8727 1.8768 1.8539 1.8874 0.0140 5.6181 +wall 9.8164 9.7803 9.8029 9.8661 0.0363 29.4492 + Asm Lines: 203358 + +Mode: asm Compiler: gcc PCH: 1 Flags: -O0 -g +name avg min med max SD total +user 1.2216 1.2137 1.2168 1.2342 0.0090 3.6647 + sys 1.1771 1.1627 1.1630 1.2055 0.0201 3.5312 +wall 2.4619 2.4419 2.4429 2.5008 0.0275 7.3856 + Asm Lines: 177335 + +Mode: asm Compiler: llvm-gcc PCH: 1 Flags: -O0 -g +name avg min med max SD total +user 1.3980 1.3682 1.3688 1.4569 0.0416 4.1939 + sys 0.9354 0.8951 0.9181 0.9930 0.0418 2.8062 +wall 2.4380 2.3312 2.3606 2.6224 0.1309 7.3141 + Asm Lines: 203353 + + + Done: 2008-10-31_17-08 diff --git a/clang/www/timing-data/2008-10-31/sketch.png b/clang/www/timing-data/2008-10-31/sketch.png Binary files differnew file mode 100644 index 0000000..5ce3b11 --- /dev/null +++ b/clang/www/timing-data/2008-10-31/sketch.png diff --git a/clang/www/timing-data/2009-03-02/176.gcc.pdf b/clang/www/timing-data/2009-03-02/176.gcc.pdf Binary files differnew file mode 100644 index 0000000..0b2e610 --- /dev/null +++ b/clang/www/timing-data/2009-03-02/176.gcc.pdf diff --git a/clang/www/timing-data/2009-03-02/176.gcc.png b/clang/www/timing-data/2009-03-02/176.gcc.png Binary files differnew file mode 100644 index 0000000..4ae08e1 --- /dev/null +++ b/clang/www/timing-data/2009-03-02/176.gcc.png diff --git a/clang/www/timing-data/2009-03-02/176.gcc.txt b/clang/www/timing-data/2009-03-02/176.gcc.txt new file mode 100644 index 0000000..f965e97 --- /dev/null +++ b/clang/www/timing-data/2009-03-02/176.gcc.txt @@ -0,0 +1,1120 @@ +ccc_path = """/Volumes/Data/ddunbar/llvm.install/bin/ccc""" +ccc_clang = """/Volumes/Data/ddunbar/zorg/xcb_scripts/cc/xcc.fb""" +ccc_gcc = """/Volumes/Data/ddunbar/zorg/xcb_scripts/cc/xcc.fb -ccc-no-clang""" +gcc = """/usr/bin/gcc-4.2""" +ccc_clang_info = """ +ccc version 1.0 (https://ddunbar@llvm.org/svn/llvm-project/cfe/trunk) + "/Volumes/Data/ddunbar/llvm.install/bin/clang" "-S" "-disable-free" "--relocation-model=pic" "--disable-fp-elim" "--nozero-initialized-in-bss" "--unwind-tables=1" "--mcpu=core2" "--fmath-errno=0" "-mmacosx-version-min=10.6.0" "-arch" "x86_64" "-o" "/tmp/tmp62ee6x.s" "-x" "c" "/dev/null" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/as" "-arch" "x86_64" "-force_cpusubtype_ALL" "-o" "/tmp/tmpyLxO26.o" "/tmp/tmp62ee6x.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/collect2" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-weak_reference_mismatches" "non-weak" "-o" "a.out" "-lcrt1.10.5.o" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../../i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../.." "/tmp/tmpyLxO26.o" "-lgcc_s.10.5" "-lgcc" "-lSystem" +""" +ccc_gcc_info = """ +ccc version 1.0 (https://ddunbar@llvm.org/svn/llvm-project/cfe/trunk) + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/cc1" "-quiet" "-imultilib" "x86_64" "-D__DYNAMIC__" "/dev/null" "-fPIC" "-quiet" "-dumpbase" "null" "-mmacosx-version-min=10.6.0" "-m64" "-mtune=core2" "-auxbase" "null" "-o" "/tmp/tmpDx0Rtr.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/as" "-arch" "x86_64" "-force_cpusubtype_ALL" "-o" "/tmp/tmpNbvYrM.o" "/tmp/tmpDx0Rtr.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/collect2" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-weak_reference_mismatches" "non-weak" "-o" "a.out" "-lcrt1.10.5.o" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../../i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../.." "/tmp/tmpNbvYrM.o" "-lgcc_s.10.5" "-lgcc" "-lSystem" +""" +gcc_info = """ +Using built-in specs. +Target: i686-apple-darwin10 +Configured with: /var/tmp/gcc/gcc-5641~3/src/configure --disable-checking --enable-werror --prefix=/usr --mandir=/share/man --enable-languages=c,objc,c++,obj-c++ --program-transform-name=/^[cg][^.-]*$/s/$/-4.2/ --with-slibdir=/usr/lib --build=i686-apple-darwin10 --with-gxx-include-dir=/include/c++/4.2.1 --program-prefix=i686-apple-darwin10- --host=x86_64-apple-darwin10 --target=i686-apple-darwin10 +Thread model: posix +gcc version 4.2.1 (Apple Inc. build 5641) + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/cc1" "-quiet" "-imultilib" "x86_64" "-D__DYNAMIC__" "/dev/null" "-fPIC" "-quiet" "-dumpbase" "null" "-mmacosx-version-min=10.6.0" "-m64" "-mtune=core2" "-auxbase" "null" "-o" "/var/tmp//ccDnCoVC.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/as" "-arch" "x86_64" "-force_cpusubtype_ALL" "-o" "/var/tmp//ccwsOXBR.o" "/var/tmp//ccDnCoVC.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/collect2" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-weak_reference_mismatches" "non-weak" "-o" "a.out" "-lcrt1.10.6.o" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../../i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../.." "/var/tmp//ccwsOXBR.o" "-lgcc" "-lSystem" +""" +style = """make""" +runs = [] +runs.append(( { 'cc':"ccc_clang", + 'script':"null", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.041626, 0.067272, 0.122191), + (1, 0.041643, 0.067045, 0.122192), + (2, 0.041655, 0.067055, 0.121649), + (3, 0.041562, 0.066648, 0.121432), + (4, 0.041613, 0.066810, 0.121305), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"null", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.041606, 0.066993, 0.121704), + (1, 0.041581, 0.066630, 0.121471), + (2, 0.041602, 0.066922, 0.121765), + (3, 0.041581, 0.066859, 0.121405), + (4, 0.041689, 0.066980, 0.124326), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.041675, 0.067138, 0.121728), + (1, 0.041612, 0.066859, 0.121205), + (2, 0.041580, 0.066483, 0.120964), + (3, 0.041594, 0.066483, 0.120985), + (4, 0.041568, 0.066532, 0.120499), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"###", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.186639, 1.937014, 4.437061), + (1, 2.186681, 1.945610, 4.433872), + (2, 2.188041, 1.947231, 4.462319), + (3, 2.188190, 1.943516, 4.470365), + (4, 2.187020, 1.950682, 4.436890), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"###", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.195748, 1.947951, 4.443053), + (1, 2.194402, 1.940449, 4.432535), + (2, 2.195423, 1.943498, 4.447053), + (3, 2.196253, 1.950332, 4.448664), + (4, 2.195660, 1.942226, 4.437071), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.136111, 0.313413, 0.499384), + (1, 0.136203, 0.313310, 0.500697), + (2, 0.136639, 0.314917, 0.558877), + (3, 0.136173, 0.313843, 0.501008), + (4, 0.135965, 0.312723, 0.498594), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"cpp", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.819676, 2.374582, 5.801642), + (1, 2.819568, 2.375962, 5.525720), + (2, 2.819725, 2.377977, 5.526612), + (3, 2.819563, 2.374766, 5.525245), + (4, 2.820020, 2.378179, 5.531853), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"parse", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.979842, 2.393759, 5.773241), + (1, 2.978360, 2.388217, 5.699588), + (2, 2.979615, 2.392749, 5.713015), + (3, 2.978055, 2.388861, 5.697303), + (4, 2.979260, 2.390138, 5.710568), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"syntax", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.525414, 2.495433, 6.457547), + (1, 3.523990, 2.498728, 6.378505), + (2, 3.523183, 2.492712, 6.370535), + (3, 3.523363, 2.494413, 6.376960), + (4, 3.525216, 2.501657, 6.413753), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"syntax", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 6.143927, 2.857721, 9.407785), + (1, 6.144766, 2.871091, 9.396498), + (2, 6.143893, 2.860256, 9.392155), + (3, 6.146454, 2.866420, 9.447510), + (4, 6.146771, 2.864488, 9.664806), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.975961, 1.044303, 5.199328), + (1, 3.976843, 1.044060, 5.209434), + (2, 3.976622, 1.043787, 5.223585), + (3, 3.975836, 1.043403, 5.198575), + (4, 3.975980, 1.035674, 5.196275), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"irgen", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 5.707728, 2.859466, 9.115580), + (1, 5.709064, 2.858221, 9.094858), + (2, 5.707868, 2.868881, 9.006296), + (3, 5.706836, 2.856589, 8.998487), + (4, 5.706603, 2.857047, 9.028045), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_asm", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 7.855523, 3.041195, 11.679531), + (1, 7.855184, 3.046897, 11.389012), + (2, 7.855530, 3.039149, 11.435265), + (3, 7.856299, 3.037483, 11.382391), + (4, 7.854147, 3.043133, 11.373174), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_asm", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.926280, 3.168833, 14.542014), + (1, 10.931726, 3.174573, 14.573554), + (2, 10.933809, 3.163183, 14.857843), + (3, 10.927966, 3.164824, 14.543822), + (4, 10.927423, 3.166222, 14.658131), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.755856, 1.342961, 10.311273), + (1, 8.756782, 1.346296, 10.314137), + (2, 8.760167, 1.338744, 10.442545), + (3, 8.759031, 1.346241, 10.333765), + (4, 8.758174, 1.339294, 10.328992), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_compile", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.159773, 3.431851, 13.319311), + (1, 9.156190, 3.421113, 13.203571), + (2, 9.157752, 3.417859, 13.220865), + (3, 9.156178, 3.413504, 13.204341), + (4, 9.150167, 3.412242, 13.252471), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_compile", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 12.062994, 3.497204, 16.184210), + (1, 12.065757, 3.486858, 16.503552), + (2, 12.063830, 3.499430, 16.171503), + (3, 12.065427, 3.500838, 16.268848), + (4, 12.063384, 3.503007, 16.164980), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.836694, 1.570806, 11.863629), + (1, 9.835162, 1.580921, 11.762224), + (2, 9.836416, 1.572111, 11.893337), + (3, 9.835066, 1.571860, 11.751330), + (4, 9.836771, 1.575158, 11.783299), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"all", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.262905, 3.437217, 13.459870), + (1, 9.262539, 3.446216, 13.349994), + (2, 9.260750, 3.445077, 13.357125), + (3, 9.263932, 3.448647, 13.366228), + (4, 9.258133, 3.443125, 13.369278), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"all", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 12.163348, 3.513017, 16.559292), + (1, 12.159476, 3.526493, 16.430252), + (2, 12.157784, 3.513763, 16.306505), + (3, 12.159307, 3.530832, 16.495815), + (4, 12.160843, 3.516564, 16.331499), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.945925, 1.592199, 11.971326), + (1, 9.944375, 1.603629, 11.899797), + (2, 9.945863, 1.601172, 11.917642), + (3, 9.946878, 1.601530, 12.113196), + (4, 9.943168, 1.596300, 11.910257), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"null", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.042234, 0.072110, 0.068216), + (1, 0.042155, 0.071582, 0.067917), + (2, 0.042120, 0.071280, 0.067838), + (3, 0.042134, 0.071281, 0.067688), + (4, 0.042182, 0.071185, 0.068571), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"null", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.042195, 0.072394, 0.067753), + (1, 0.042154, 0.071378, 0.067667), + (2, 0.042126, 0.071503, 0.067645), + (3, 0.042142, 0.071525, 0.067641), + (4, 0.042137, 0.071263, 0.067512), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.042117, 0.071863, 0.067866), + (1, 0.042095, 0.071587, 0.067778), + (2, 0.042123, 0.071824, 0.067718), + (3, 0.042017, 0.071448, 0.067336), + (4, 0.042098, 0.071669, 0.067649), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"###", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.312764, 2.250083, 2.579668), + (1, 2.313524, 2.255599, 2.581617), + (2, 2.314576, 2.236269, 2.751308), + (3, 2.313798, 2.247632, 2.576000), + (4, 2.308146, 2.127675, 2.449384), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"###", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.319161, 2.248583, 2.579843), + (1, 2.320569, 2.254949, 2.582595), + (2, 2.319615, 2.254838, 2.582868), + (3, 2.317640, 2.234440, 2.566378), + (4, 2.319468, 2.253768, 2.582185), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.138760, 0.342468, 0.274713), + (1, 0.138529, 0.338083, 0.270603), + (2, 0.138419, 0.339997, 0.272035), + (3, 0.138474, 0.339942, 0.271676), + (4, 0.138476, 0.339545, 0.271208), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"cpp", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.927601, 2.621882, 3.040263), + (1, 2.928817, 2.618327, 3.042979), + (2, 2.925842, 2.616328, 3.034669), + (3, 2.933845, 2.642455, 3.077028), + (4, 2.947212, 2.620121, 3.167388), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"parse", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.095391, 2.632837, 3.130378), + (1, 3.096120, 2.626309, 3.120448), + (2, 3.095708, 2.622912, 3.125333), + (3, 3.096435, 2.628234, 3.124718), + (4, 3.095836, 2.623590, 3.124194), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"syntax", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.674570, 2.716479, 3.444615), + (1, 3.673243, 2.720120, 3.443432), + (2, 3.673080, 2.709820, 3.443546), + (3, 3.673200, 2.709185, 3.426130), + (4, 3.670534, 2.711744, 3.427015), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"syntax", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 6.389665, 3.072630, 4.983543), + (1, 6.385878, 3.080763, 4.975980), + (2, 6.389956, 3.069652, 4.982242), + (3, 6.388396, 3.078156, 4.977871), + (4, 6.391305, 3.090905, 4.994381), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.079359, 1.112710, 2.692685), + (1, 4.077052, 1.114109, 2.689234), + (2, 4.078218, 1.119202, 2.693919), + (3, 4.077124, 1.108491, 2.690559), + (4, 4.077296, 1.112142, 2.684408), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"irgen", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 6.043907, 3.082369, 4.874229), + (1, 6.044110, 3.072240, 4.860724), + (2, 6.049991, 3.085666, 4.927778), + (3, 6.050681, 3.087747, 4.866959), + (4, 6.046383, 3.081174, 4.865700), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_asm", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.277376, 3.241075, 6.041627), + (1, 8.274767, 3.246052, 6.032635), + (2, 8.273632, 3.240323, 6.034355), + (3, 8.283322, 3.235898, 6.055232), + (4, 8.279572, 3.237813, 6.040545), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_asm", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 11.267468, 3.368598, 7.582008), + (1, 11.264991, 3.356817, 7.573902), + (2, 11.258736, 3.371794, 7.616322), + (3, 11.272174, 3.375177, 7.750662), + (4, 11.265369, 3.355828, 7.569228), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.948892, 1.408841, 5.346675), + (1, 8.947425, 1.388794, 5.341078), + (2, 8.959290, 1.397633, 5.703015), + (3, 8.948915, 1.391639, 5.351654), + (4, 8.946706, 1.404458, 5.345449), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_compile", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.576401, 3.659016, 6.972346), + (1, 9.577255, 3.641158, 6.953448), + (2, 9.572443, 3.647954, 7.051130), + (3, 9.571615, 3.646782, 6.956555), + (4, 9.572963, 3.653229, 6.957711), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_compile", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 12.425333, 3.720605, 8.468826), + (1, 12.420657, 3.729020, 8.648778), + (2, 12.424221, 3.709511, 8.467562), + (3, 12.425595, 3.726297, 8.449276), + (4, 12.422584, 3.718660, 8.713483), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.042865, 1.647364, 6.147098), + (1, 10.038624, 1.646965, 6.107788), + (2, 10.036193, 1.643319, 6.100944), + (3, 10.037764, 1.637319, 6.121365), + (4, 10.044532, 1.648919, 6.354301), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"all", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.686781, 3.657538, 7.098294), + (1, 9.679355, 3.674326, 7.109849), + (2, 9.678938, 3.659032, 7.093127), + (3, 9.683371, 3.655282, 7.396885), + (4, 9.677578, 3.661111, 7.086666), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"all", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 12.511083, 3.753316, 8.574587), + (1, 12.517391, 3.745202, 8.579089), + (2, 12.515167, 3.747517, 8.906780), + (3, 12.510503, 3.744116, 8.561728), + (4, 12.516263, 3.740046, 8.578455), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.139224, 1.659640, 6.213839), + (1, 10.144829, 1.668260, 6.423697), + (2, 10.144182, 1.670476, 6.213931), + (3, 10.144068, 1.658834, 6.211693), + (4, 10.138223, 1.667654, 6.222308), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"null", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.044057, 0.093485, 0.045956), + (1, 0.044004, 0.092769, 0.045605), + (2, 0.043901, 0.092551, 0.045247), + (3, 0.043818, 0.091785, 0.045295), + (4, 0.043924, 0.091899, 0.045216), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"null", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.043938, 0.092531, 0.045317), + (1, 0.043985, 0.092990, 0.045413), + (2, 0.043847, 0.091943, 0.044986), + (3, 0.043889, 0.091626, 0.045207), + (4, 0.043936, 0.091446, 0.045068), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.043935, 0.092137, 0.045550), + (1, 0.044036, 0.092432, 0.045443), + (2, 0.043907, 0.092597, 0.045207), + (3, 0.043906, 0.092773, 0.045220), + (4, 0.043932, 0.092273, 0.045162), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"###", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.510229, 2.524326, 1.447378), + (1, 2.511153, 2.582682, 1.463158), + (2, 2.509131, 2.551808, 1.443700), + (3, 2.530506, 2.606601, 1.631594), + (4, 2.525546, 2.556516, 1.460912), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"###", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.519330, 2.572381, 1.455862), + (1, 2.519059, 2.662137, 1.521106), + (2, 2.506144, 2.556738, 1.456221), + (3, 2.511366, 2.577441, 1.459606), + (4, 2.526218, 2.553722, 1.574747), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.147023, 0.430956, 0.176525), + (1, 0.147430, 0.429136, 0.175834), + (2, 0.146893, 0.428812, 0.175145), + (3, 0.147174, 0.429968, 0.175169), + (4, 0.147492, 0.431385, 0.174682), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"cpp", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.167799, 3.158706, 1.805685), + (1, 3.167239, 3.135936, 1.802571), + (2, 3.157960, 3.130196, 1.803330), + (3, 3.146711, 3.153077, 1.813078), + (4, 3.149927, 3.152081, 1.801526), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"parse", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.342516, 3.109718, 1.823208), + (1, 3.353297, 3.103074, 1.819566), + (2, 3.333260, 3.149734, 1.829796), + (3, 3.338234, 3.103725, 1.822010), + (4, 3.336550, 3.100652, 1.832110), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"syntax", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.970523, 3.209725, 1.991844), + (1, 3.937210, 3.198855, 1.976041), + (2, 3.955488, 3.206959, 1.989544), + (3, 3.946574, 3.198149, 1.980601), + (4, 3.948581, 3.205880, 1.983994), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"syntax", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 6.732216, 3.619584, 2.782476), + (1, 6.745420, 3.616948, 2.790903), + (2, 6.750526, 3.594650, 2.790881), + (3, 6.738845, 3.612443, 2.790569), + (4, 6.747457, 3.617553, 2.788687), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.194680, 1.292044, 1.444048), + (1, 4.190321, 1.300927, 1.441506), + (2, 4.198820, 1.293219, 1.444174), + (3, 4.209445, 1.289162, 1.447259), + (4, 4.187489, 1.282234, 1.440277), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"irgen", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 6.517757, 3.615464, 2.854763), + (1, 6.519460, 3.617775, 2.756124), + (2, 6.498704, 3.602169, 2.756365), + (3, 6.509982, 3.621462, 2.745702), + (4, 6.489827, 3.608797, 2.747793), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_asm", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.825143, 3.794072, 3.362608), + (1, 8.824013, 3.765690, 3.355471), + (2, 8.813541, 3.783641, 3.357039), + (3, 8.786371, 3.786659, 3.345793), + (4, 8.772730, 3.771638, 3.454307), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_asm", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 11.738484, 3.836784, 4.120546), + (1, 11.739288, 3.848616, 4.125808), + (2, 11.738261, 3.837534, 4.136642), + (3, 11.735003, 3.844597, 4.120444), + (4, 11.761638, 3.862457, 4.145417), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.155087, 1.561075, 2.833868), + (1, 9.154934, 1.538791, 2.833134), + (2, 9.183035, 1.553281, 2.902132), + (3, 9.151130, 1.546822, 2.879777), + (4, 9.151844, 1.542450, 2.825560), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_compile", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.166988, 4.242308, 3.894601), + (1, 10.218686, 4.265537, 3.896997), + (2, 10.208211, 4.256174, 3.905990), + (3, 10.182169, 4.254989, 4.094963), + (4, 10.165336, 4.239672, 3.873703), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_compile", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 12.960833, 4.319633, 4.628599), + (1, 12.997509, 4.323695, 4.942418), + (2, 12.940625, 4.326994, 4.624419), + (3, 12.947641, 4.300034, 4.597456), + (4, 12.942562, 4.308688, 4.619190), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.300396, 1.823967, 3.250894), + (1, 10.305252, 1.822285, 3.244746), + (2, 10.307011, 1.845773, 3.260861), + (3, 10.319953, 1.831435, 3.500671), + (4, 10.320805, 1.834782, 3.246639), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"all", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.297812, 4.264184, 4.013061), + (1, 10.315407, 4.293257, 4.021099), + (2, 10.257966, 4.265659, 4.006248), + (3, 10.307857, 4.273741, 4.044614), + (4, 10.273398, 4.260286, 4.216469), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"all", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 13.040233, 4.302015, 4.719135), + (1, 13.046999, 4.316412, 5.773880), + (2, 13.081143, 4.324329, 4.745519), + (3, 13.025611, 4.311093, 4.738916), + (4, 13.063041, 4.336277, 4.771969), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.419745, 1.855515, 3.343652), + (1, 10.447391, 1.858839, 3.374031), + (2, 10.428436, 1.866242, 3.381289), + (3, 10.428931, 1.879273, 3.582034), + (4, 10.410715, 1.836761, 3.371333), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"null", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.044629, 0.104236, 0.047124), + (1, 0.044357, 0.101072, 0.046054), + (2, 0.044261, 0.099350, 0.045512), + (3, 0.044279, 0.099032, 0.045401), + (4, 0.044291, 0.098233, 0.045262), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"null", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.044388, 0.101047, 0.045972), + (1, 0.044267, 0.100816, 0.045836), + (2, 0.044319, 0.100931, 0.045829), + (3, 0.044242, 0.102208, 0.046286), + (4, 0.044197, 0.101894, 0.046310), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.044199, 0.099476, 0.045336), + (1, 0.044064, 0.099032, 0.045431), + (2, 0.044081, 0.097169, 0.044910), + (3, 0.044055, 0.099088, 0.044957), + (4, 0.044322, 0.099454, 0.045563), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"###", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.768949, 3.566605, 1.008622), + (1, 2.753933, 3.515221, 1.011067), + (2, 2.790210, 3.581213, 1.006835), + (3, 2.742393, 3.612996, 1.065939), + (4, 2.783563, 3.457715, 0.977203), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"###", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.803126, 3.542212, 1.140376), + (1, 2.794538, 3.523127, 1.000266), + (2, 2.821545, 3.533185, 0.996633), + (3, 2.754702, 3.604113, 1.127400), + (4, 2.773800, 3.590831, 1.023085), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.162694, 0.629660, 0.131824), + (1, 0.162231, 0.630903, 0.131937), + (2, 0.162713, 0.636833, 0.133010), + (3, 0.163527, 0.627696, 0.130973), + (4, 0.162591, 0.628073, 0.128269), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"cpp", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.398995, 4.386961, 1.222372), + (1, 3.433913, 4.302404, 1.191109), + (2, 3.403972, 4.249079, 1.179600), + (3, 3.430418, 4.241026, 1.173406), + (4, 3.405708, 4.295249, 1.192367), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"parse", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.589608, 4.234909, 1.206952), + (1, 3.595580, 4.250801, 1.195809), + (2, 3.598782, 4.186360, 1.189533), + (3, 3.576135, 4.210771, 1.192198), + (4, 3.596508, 4.272774, 1.195682), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"syntax", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.188318, 4.323380, 1.272841), + (1, 4.204432, 4.301331, 1.276169), + (2, 4.232123, 4.359346, 1.308850), + (3, 4.254709, 4.295013, 1.277959), + (4, 4.214074, 4.293825, 1.275462), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"syntax", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 7.056727, 4.672983, 1.677022), + (1, 7.064183, 4.697158, 1.685536), + (2, 7.013256, 4.653804, 1.669026), + (3, 7.077917, 4.720479, 1.692836), + (4, 7.028864, 4.654591, 1.674130), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.250811, 1.598520, 0.822128), + (1, 4.255341, 1.616523, 0.819562), + (2, 4.282720, 1.628032, 0.823764), + (3, 4.296236, 1.628292, 0.828753), + (4, 4.263254, 1.614337, 0.822968), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"irgen", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 6.828563, 4.698920, 1.665128), + (1, 6.887088, 4.678607, 1.660858), + (2, 6.867776, 4.703203, 1.657673), + (3, 6.841523, 4.645255, 1.637169), + (4, 6.904172, 4.682556, 1.690968), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_asm", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.164624, 4.728257, 2.026243), + (1, 9.258789, 4.757386, 1.996115), + (2, 9.215979, 4.740186, 1.995604), + (3, 9.241390, 4.750833, 2.007054), + (4, 9.161773, 4.742841, 1.987729), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_asm", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 12.113609, 4.726450, 2.385739), + (1, 12.121322, 4.784194, 2.416434), + (2, 12.095256, 4.762198, 2.394130), + (3, 12.125848, 4.743744, 2.386863), + (4, 12.117883, 4.759723, 2.384746), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.196017, 1.794764, 1.538604), + (1, 9.293693, 1.830825, 1.559088), + (2, 9.210498, 1.813935, 1.538989), + (3, 9.207860, 1.799598, 1.536893), + (4, 9.202729, 1.797648, 1.530905), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_compile", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.574802, 5.298921, 2.539728), + (1, 10.657320, 5.376201, 2.329437), + (2, 10.650595, 5.345177, 2.311878), + (3, 10.611628, 5.366770, 2.319432), + (4, 10.599574, 5.358888, 2.479782), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_compile", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 13.432160, 5.417611, 2.691172), + (1, 13.443341, 5.377409, 2.678012), + (2, 13.343336, 5.338212, 2.812471), + (3, 13.333183, 5.333529, 2.687594), + (4, 13.384371, 5.414969, 2.837339), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.381974, 2.152140, 1.786428), + (1, 10.378996, 2.143003, 1.774503), + (2, 10.453921, 2.187323, 1.794154), + (3, 10.398109, 2.212740, 2.013101), + (4, 10.435604, 2.197729, 1.779200), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"all", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.786656, 5.383657, 2.435159), + (1, 10.689933, 5.362047, 2.435158), + (2, 10.761754, 5.406655, 2.462640), + (3, 10.760319, 5.401706, 2.571526), + (4, 10.666932, 5.361587, 2.444485), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"all", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 13.519919, 5.421898, 2.821722), + (1, 13.447262, 5.364940, 2.926024), + (2, 13.464838, 5.369476, 2.802961), + (3, 13.514555, 5.440290, 2.831226), + (4, 13.443975, 5.410124, 2.947296), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.498388, 2.171118, 2.153460), + (1, 10.524313, 2.175829, 1.899075), + (2, 10.502688, 2.185754, 1.894639), + (3, 10.498667, 2.201617, 1.888811), + (4, 10.488970, 2.166527, 1.885400), +]} +)) diff --git a/clang/www/timing-data/2009-03-02/sketch.pdf b/clang/www/timing-data/2009-03-02/sketch.pdf Binary files differnew file mode 100644 index 0000000..3b98a3d --- /dev/null +++ b/clang/www/timing-data/2009-03-02/sketch.pdf diff --git a/clang/www/timing-data/2009-03-02/sketch.png b/clang/www/timing-data/2009-03-02/sketch.png Binary files differnew file mode 100644 index 0000000..3d1bc14 --- /dev/null +++ b/clang/www/timing-data/2009-03-02/sketch.png diff --git a/clang/www/timing-data/2009-03-02/sketch.txt b/clang/www/timing-data/2009-03-02/sketch.txt new file mode 100644 index 0000000..d2270e4 --- /dev/null +++ b/clang/www/timing-data/2009-03-02/sketch.txt @@ -0,0 +1,2368 @@ +ccc_path = """/Volumes/Data/ddunbar/llvm.install/bin/ccc""" +ccc_clang = """/Volumes/Data/ddunbar/zorg/xcb_scripts/cc/xcc.fb""" +ccc_gcc = """/Volumes/Data/ddunbar/zorg/xcb_scripts/cc/xcc.fb -ccc-no-clang""" +gcc = """/usr/bin/gcc-4.2""" +ccc_clang_info = """ +ccc version 1.0 (https://ddunbar@llvm.org/svn/llvm-project/cfe/trunk) + "/Volumes/Data/ddunbar/llvm.install/bin/clang" "-S" "-disable-free" "--relocation-model=pic" "--disable-fp-elim" "--nozero-initialized-in-bss" "--unwind-tables=1" "--mcpu=core2" "--fmath-errno=0" "-mmacosx-version-min=10.6.0" "-arch" "x86_64" "-o" "/tmp/tmpugUQni.s" "-x" "c" "/dev/null" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/as" "-arch" "x86_64" "-force_cpusubtype_ALL" "-o" "/tmp/tmpH8AOZI.o" "/tmp/tmpugUQni.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/collect2" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-weak_reference_mismatches" "non-weak" "-o" "a.out" "-lcrt1.10.5.o" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../../i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../.." "/tmp/tmpH8AOZI.o" "-lgcc_s.10.5" "-lgcc" "-lSystem" +""" +ccc_gcc_info = """ +ccc version 1.0 (https://ddunbar@llvm.org/svn/llvm-project/cfe/trunk) + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/cc1" "-quiet" "-imultilib" "x86_64" "-D__DYNAMIC__" "/dev/null" "-fPIC" "-quiet" "-dumpbase" "null" "-mmacosx-version-min=10.6.0" "-m64" "-mtune=core2" "-auxbase" "null" "-o" "/tmp/tmpTiOyJZ.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/as" "-arch" "x86_64" "-force_cpusubtype_ALL" "-o" "/tmp/tmpTi0lCN.o" "/tmp/tmpTiOyJZ.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/collect2" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-weak_reference_mismatches" "non-weak" "-o" "a.out" "-lcrt1.10.5.o" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../../i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../.." "/tmp/tmpTi0lCN.o" "-lgcc_s.10.5" "-lgcc" "-lSystem" +""" +gcc_info = """ +Using built-in specs. +Target: i686-apple-darwin10 +Configured with: /var/tmp/gcc/gcc-5630~5/src/configure --disable-checking --enable-werror --prefix=/usr --mandir=/share/man --enable-languages=c,objc,c++,obj-c++ --program-transform-name=/^[cg][^.-]*$/s/$/-4.2/ --with-slibdir=/usr/lib --build=i686-apple-darwin10 --with-gxx-include-dir=/include/c++/4.2.1 --program-prefix=i686-apple-darwin10- --host=x86_64-apple-darwin10 --target=i686-apple-darwin10 +Thread model: posix +gcc version 4.2.1 (Apple Inc. build 5630) + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/cc1" "-quiet" "-imultilib" "x86_64" "-D__DYNAMIC__" "/dev/null" "-fPIC" "-quiet" "-dumpbase" "null" "-mmacosx-version-min=10.6.0" "-m64" "-mtune=core2" "-auxbase" "null" "-o" "/var/tmp//ccuvh82w.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/as" "-arch" "x86_64" "-force_cpusubtype_ALL" "-o" "/var/tmp//ccb3T8Fr.o" "/var/tmp//ccuvh82w.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/collect2" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-weak_reference_mismatches" "non-weak" "-o" "a.out" "-lcrt1.10.5.o" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../../i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../.." "/var/tmp//ccb3T8Fr.o" "-lgcc_s.10.5" "-lgcc" "-lSystem" +""" +style = """xcb""" +runs = [] +runs.append(( { 'cc':"ccc_clang", + 'script':"null", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.405425, 0.222438, 0.698198), + (1, 0.403472, 0.218381, 0.695599), + (2, 0.403354, 0.217344, 0.695414), + (3, 0.403856, 0.218787, 0.703370), + (4, 0.404353, 0.221186, 0.695619), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"null", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.393260, 0.212802, 0.656048), + (1, 0.393075, 0.211285, 0.654796), + (2, 0.394300, 0.213498, 0.695105), + (3, 0.393851, 0.213657, 0.695272), + (4, 0.395458, 0.213304, 0.695908), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"null", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.403360, 0.216918, 0.704434), + (1, 0.403818, 0.219731, 0.696158), + (2, 0.402206, 0.218530, 0.697751), + (3, 0.403133, 0.218441, 0.695443), + (4, 0.403311, 0.218882, 0.695080), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"null", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.395200, 0.213912, 0.696117), + (1, 0.395331, 0.213822, 0.695887), + (2, 0.395293, 0.212402, 0.697557), + (3, 0.395446, 0.213684, 0.695732), + (4, 0.394667, 0.213321, 0.656472), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.403665, 0.217763, 0.694820), + (1, 0.403482, 0.217606, 0.695959), + (2, 0.404965, 0.219817, 0.819840), + (3, 0.404437, 0.217515, 0.695675), + (4, 0.402886, 0.216456, 0.703275), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.393583, 0.212237, 0.655196), + (1, 0.394063, 0.212744, 0.695220), + (2, 0.393998, 0.212889, 0.695448), + (3, 0.394364, 0.213507, 0.695090), + (4, 0.395886, 0.214974, 0.696254), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"###", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.129656, 0.771133, 2.056006), + (1, 1.129855, 0.772644, 2.055649), + (2, 1.130559, 0.768629, 2.055976), + (3, 1.130291, 0.769030, 2.059280), + (4, 1.130861, 0.771000, 2.055720), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"###", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.086760, 0.741197, 1.976344), + (1, 1.087919, 0.739640, 1.975560), + (2, 1.087589, 0.739815, 2.015386), + (3, 1.087730, 0.738847, 1.976232), + (4, 1.088193, 0.739529, 2.016033), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"###", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.138506, 0.768675, 2.064631), + (1, 1.138085, 0.770549, 2.097210), + (2, 1.138889, 0.771511, 2.096435), + (3, 1.138765, 0.770142, 2.064291), + (4, 1.138779, 0.768611, 2.095530), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"###", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.096902, 0.741661, 2.015757), + (1, 1.097165, 0.740449, 2.015432), + (2, 1.096494, 0.740608, 2.016453), + (3, 1.096410, 0.739960, 1.975427), + (4, 1.096579, 0.743114, 2.016444), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.444144, 0.284384, 0.814217), + (1, 0.445853, 0.286540, 0.816314), + (2, 0.446338, 0.287002, 0.814997), + (3, 0.445384, 0.284369, 0.823090), + (4, 0.444071, 0.284531, 0.815854), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.435113, 0.278547, 0.817260), + (1, 0.433108, 0.275659, 0.775024), + (2, 0.434473, 0.276611, 0.784047), + (3, 0.434224, 0.275786, 0.775677), + (4, 0.433396, 0.276622, 0.775240), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_pch", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.328464, 0.973747, 2.577016), + (1, 1.324318, 0.855290, 2.424347), + (2, 1.323693, 0.856675, 2.416951), + (3, 1.323004, 0.857324, 2.417132), + (4, 1.323843, 0.856000, 2.415804), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_pch", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.748207, 1.141266, 4.576484), + (1, 2.744640, 1.137930, 4.416237), + (2, 2.745616, 1.136230, 4.495978), + (3, 2.746108, 1.139037, 4.496219), + (4, 2.746059, 1.137958, 4.416920), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_pch", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.051374, 0.650962, 3.144706), + (1, 2.050914, 0.648174, 3.215974), + (2, 2.050343, 0.649010, 3.176205), + (3, 2.051910, 0.648745, 3.176613), + (4, 2.051386, 0.648306, 3.217578), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"cpp", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.835919, 1.148648, 3.257076), + (1, 1.835307, 1.146862, 3.264809), + (2, 1.834812, 1.147964, 3.257005), + (3, 1.835016, 1.144979, 3.256861), + (4, 1.836571, 1.148836, 3.256094), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"cpp", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.288802, 1.569778, 4.095720), + (1, 2.288176, 1.573356, 4.176816), + (2, 2.287878, 1.573807, 4.096939), + (3, 2.288041, 1.571541, 4.097750), + (4, 2.288190, 1.569398, 4.097146), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"parse", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.220738, 1.167367, 3.657062), + (1, 2.219840, 1.170754, 3.657627), + (2, 2.220897, 1.172925, 3.657043), + (3, 2.221644, 1.167701, 3.656328), + (4, 2.223199, 1.171444, 3.657134), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"parse", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.717655, 1.602645, 4.536037), + (1, 2.716324, 1.603188, 4.536210), + (2, 2.718783, 1.605672, 4.576816), + (3, 2.718146, 1.602360, 4.536958), + (4, 2.718544, 1.606428, 4.577367), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"syntax", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.453390, 1.390902, 5.176330), + (1, 3.453408, 1.394547, 5.176325), + (2, 3.453141, 1.392043, 5.176946), + (3, 3.457040, 1.390031, 5.257617), + (4, 3.453262, 1.395063, 5.138977), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"syntax", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.077200, 1.866592, 6.223139), + (1, 4.076044, 1.873001, 6.214158), + (2, 4.079719, 1.869271, 6.235665), + (3, 4.078223, 1.866927, 6.217922), + (4, 4.076013, 1.867985, 6.204512), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"syntax", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.397072, 2.178746, 6.177185), + (1, 3.397804, 2.167804, 6.177276), + (2, 3.398193, 2.168075, 6.250655), + (3, 3.397029, 2.165686, 6.184421), + (4, 3.397568, 2.178013, 6.179279), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"syntax", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 7.486708, 2.445768, 10.254543), + (1, 7.491379, 2.458432, 10.337225), + (2, 7.486408, 2.433698, 10.257034), + (3, 7.487016, 2.456457, 10.270939), + (4, 7.487323, 2.439337, 10.258257), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.670173, 1.622433, 4.897808), + (1, 2.666760, 1.609756, 4.776822), + (2, 2.667040, 1.610998, 4.856885), + (3, 2.671149, 1.594163, 4.816301), + (4, 2.669699, 1.607578, 4.866539), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 6.803057, 1.908280, 8.963127), + (1, 6.805076, 1.939662, 8.969825), + (2, 6.802844, 1.921782, 8.970996), + (3, 6.805031, 1.913186, 8.967523), + (4, 6.805252, 1.919294, 8.959788), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"irgen", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.627373, 1.415978, 5.377556), + (1, 3.625026, 1.415306, 5.337455), + (2, 3.624699, 1.411942, 5.377834), + (3, 3.627468, 1.422229, 5.376680), + (4, 3.625721, 1.421354, 5.377509), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"irgen", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.249780, 1.891114, 6.438770), + (1, 4.248041, 1.893114, 6.416578), + (2, 4.248877, 1.890255, 6.422580), + (3, 4.248459, 1.891867, 6.425267), + (4, 4.251042, 1.896335, 6.438381), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_asm", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.813308, 1.436255, 5.577048), + (1, 3.812973, 1.436260, 5.577759), + (2, 3.814667, 1.436329, 5.576892), + (3, 3.814164, 1.439684, 5.577863), + (4, 3.816874, 1.432057, 5.625098), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_asm", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.438589, 1.914821, 6.634438), + (1, 4.436802, 1.913064, 6.628424), + (2, 4.438023, 1.918364, 6.632666), + (3, 4.438494, 1.922851, 6.645062), + (4, 4.439727, 1.920331, 6.685016), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_asm", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.975290, 2.296164, 6.913135), + (1, 3.977464, 2.309821, 6.916908), + (2, 3.976537, 2.309954, 6.848258), + (3, 3.977155, 2.305060, 7.357985), + (4, 3.974276, 2.289059, 6.862249), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_asm", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.928091, 2.684142, 11.969055), + (1, 8.929295, 2.683263, 11.988445), + (2, 8.929175, 2.678390, 11.956474), + (3, 8.926613, 2.665122, 11.965071), + (4, 8.926613, 2.680630, 11.964381), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.249871, 1.745454, 5.497846), + (1, 3.249460, 1.737577, 5.538376), + (2, 3.253966, 1.727548, 5.616847), + (3, 3.251405, 1.725884, 5.496698), + (4, 3.250563, 1.721386, 5.536694), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.249350, 2.147359, 10.672894), + (1, 8.252421, 2.146136, 10.687439), + (2, 8.252766, 2.142015, 10.683719), + (3, 8.279512, 2.152184, 11.070527), + (4, 8.250015, 2.161431, 10.703253), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_compile", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.917675, 1.531758, 5.777717), + (1, 3.917453, 1.532169, 5.777704), + (2, 3.920630, 1.538518, 5.857605), + (3, 3.917549, 1.535710, 5.776730), + (4, 3.917673, 1.529128, 5.776450), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_compile", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.536313, 2.003164, 6.831313), + (1, 4.537451, 2.014513, 6.846562), + (2, 4.540679, 2.016759, 6.865437), + (3, 4.538081, 2.008899, 6.845811), + (4, 4.538438, 2.009600, 6.836498), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_compile", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.123486, 2.383752, 7.115483), + (1, 4.127545, 2.372840, 7.151675), + (2, 4.125900, 2.381678, 7.138942), + (3, 4.123891, 2.369579, 7.127788), + (4, 4.125164, 2.370661, 7.117664), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_compile", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.076157, 2.771491, 12.341310), + (1, 9.074681, 2.764608, 12.205139), + (2, 9.076881, 2.766755, 12.228073), + (3, 9.073910, 2.771638, 12.204252), + (4, 9.076773, 2.777037, 12.235749), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.388061, 1.779190, 5.737793), + (1, 3.387862, 1.790856, 5.697850), + (2, 3.387800, 1.789477, 5.780238), + (3, 3.387509, 1.788586, 5.743236), + (4, 3.388152, 1.784450, 6.178092), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.376118, 2.205600, 10.877337), + (1, 8.372512, 2.219382, 10.868894), + (2, 8.375968, 2.225479, 10.996566), + (3, 8.379525, 2.215791, 10.910221), + (4, 8.375433, 2.210534, 10.890280), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"all", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.948571, 1.553366, 5.857777), + (1, 3.946872, 1.549844, 5.817926), + (2, 3.948643, 1.545410, 5.817794), + (3, 3.947022, 1.548687, 5.816790), + (4, 3.951557, 1.560511, 5.937022), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"all", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.568105, 2.037309, 6.888153), + (1, 4.567872, 2.037818, 6.893678), + (2, 4.569582, 2.037795, 6.894469), + (3, 4.571991, 2.042292, 6.920444), + (4, 4.568506, 2.036233, 6.895221), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"all", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.153075, 2.389230, 7.183219), + (1, 4.150947, 2.401330, 7.175264), + (2, 4.150807, 2.390926, 7.237253), + (3, 4.152335, 2.393576, 7.265347), + (4, 4.154240, 2.408743, 7.201345), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"all", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.104507, 2.799196, 12.284425), + (1, 9.102214, 2.804734, 12.263326), + (2, 9.102799, 2.797758, 12.263314), + (3, 9.102472, 2.797718, 12.283471), + (4, 9.101655, 2.799231, 12.257987), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.412096, 1.803347, 5.817859), + (1, 3.412334, 1.792039, 5.897059), + (2, 3.413608, 1.789291, 5.817810), + (3, 3.413812, 1.785669, 5.827047), + (4, 3.413291, 1.782601, 5.738213), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.402455, 2.228676, 10.943842), + (1, 8.396442, 2.225608, 10.902714), + (2, 8.401735, 2.220712, 10.918381), + (3, 8.400619, 2.226284, 10.926158), + (4, 8.398896, 2.221540, 10.901292), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"null", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.421126, 0.234655, 0.534969), + (1, 0.418396, 0.232067, 0.536121), + (2, 0.419512, 0.236062, 0.536636), + (3, 0.420755, 0.236390, 0.535508), + (4, 0.421343, 0.234614, 0.537189), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"null", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.411128, 0.230994, 0.499097), + (1, 0.412593, 0.231427, 0.536123), + (2, 0.407668, 0.229908, 0.495794), + (3, 0.410890, 0.229289, 0.535618), + (4, 0.412812, 0.229662, 0.535043), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"null", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.421792, 0.234957, 0.536236), + (1, 0.421073, 0.235668, 0.538946), + (2, 0.418909, 0.236416, 0.535464), + (3, 0.420363, 0.235692, 0.535257), + (4, 0.419598, 0.234400, 0.534633), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"null", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.409040, 0.230090, 0.534802), + (1, 0.411753, 0.232552, 0.537293), + (2, 0.415536, 0.231495, 0.536877), + (3, 0.410714, 0.227612, 0.535090), + (4, 0.409547, 0.230152, 0.497187), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.421181, 0.235033, 0.535407), + (1, 0.420747, 0.236700, 0.535928), + (2, 0.418786, 0.235032, 0.534312), + (3, 0.420015, 0.233378, 0.535452), + (4, 0.421154, 0.235218, 0.535269), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.411356, 0.231786, 0.537593), + (1, 0.412772, 0.230723, 0.537039), + (2, 0.410034, 0.228264, 0.494194), + (3, 0.412693, 0.230932, 0.536339), + (4, 0.411372, 0.228262, 0.497113), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"###", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.185856, 0.840347, 1.416460), + (1, 1.186435, 0.854091, 1.415674), + (2, 1.183343, 0.844916, 1.415643), + (3, 1.181560, 0.857296, 1.415242), + (4, 1.187699, 0.853918, 1.415647), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"###", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.138810, 0.818035, 1.335935), + (1, 1.141064, 0.827249, 1.337062), + (2, 1.138410, 0.811996, 1.335346), + (3, 1.142644, 0.820159, 1.337486), + (4, 1.138460, 0.815423, 1.335647), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"###", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.194684, 0.841290, 1.415885), + (1, 1.195720, 0.844873, 1.416552), + (2, 1.194440, 0.850513, 1.415595), + (3, 1.191931, 0.850890, 1.414722), + (4, 1.192481, 0.853052, 1.416102), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"###", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.148891, 0.817183, 1.335717), + (1, 1.149617, 0.823096, 1.336040), + (2, 1.149791, 0.805679, 1.337424), + (3, 1.150876, 0.814239, 1.336748), + (4, 1.153157, 0.809177, 1.336246), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.463514, 0.310817, 0.614767), + (1, 0.464612, 0.310198, 0.618455), + (2, 0.463460, 0.308990, 0.616282), + (3, 0.463413, 0.311280, 0.617026), + (4, 0.467009, 0.310382, 0.857752), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.453517, 0.301571, 0.575912), + (1, 0.452100, 0.300588, 0.576359), + (2, 0.448456, 0.297936, 0.575121), + (3, 0.451645, 0.298907, 0.577323), + (4, 0.450964, 0.301582, 0.574520), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_pch", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.381350, 0.944251, 1.776275), + (1, 1.380373, 0.930919, 1.775617), + (2, 1.379352, 0.937129, 1.736723), + (3, 1.380977, 0.944068, 1.737369), + (4, 1.381796, 0.938486, 1.776093), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_pch", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.805408, 1.220930, 3.697693), + (1, 2.804236, 1.204836, 3.657105), + (2, 2.803037, 1.210121, 3.696933), + (3, 2.807280, 1.219531, 3.779261), + (4, 2.802821, 1.208316, 3.736487), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_pch", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.076567, 0.672051, 2.896169), + (1, 2.070465, 0.668786, 2.895749), + (2, 2.077549, 0.673245, 2.896393), + (3, 2.075634, 0.671026, 2.976119), + (4, 2.074463, 0.671262, 2.975937), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"cpp", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.909827, 1.258607, 2.215806), + (1, 1.910547, 1.261354, 2.255924), + (2, 1.907436, 1.262299, 2.216659), + (3, 1.908875, 1.254564, 2.256077), + (4, 1.906568, 1.264632, 2.215638), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"cpp", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.384586, 1.708563, 2.495874), + (1, 2.386876, 1.705256, 2.456596), + (2, 2.383560, 1.707485, 2.456364), + (3, 2.388580, 1.714631, 2.496008), + (4, 2.383943, 1.709754, 2.455848), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"parse", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.296978, 1.274825, 2.415106), + (1, 2.303460, 1.279010, 2.456151), + (2, 2.300862, 1.277879, 2.536542), + (3, 2.297727, 1.277312, 2.416137), + (4, 2.299045, 1.281014, 2.457338), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"parse", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.823962, 1.752509, 2.738192), + (1, 2.825617, 1.738546, 2.736478), + (2, 2.825608, 1.744360, 2.735298), + (3, 2.822577, 1.756988, 2.735053), + (4, 2.828362, 1.751245, 2.737930), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"syntax", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.586428, 1.498329, 3.258357), + (1, 3.581922, 1.510793, 3.258049), + (2, 3.584574, 1.523963, 3.256754), + (3, 3.585929, 1.525886, 3.296728), + (4, 3.583339, 1.509529, 3.255773), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"syntax", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.249019, 2.030066, 3.658088), + (1, 4.244427, 1.997319, 3.618002), + (2, 4.247446, 2.034549, 3.656419), + (3, 4.250734, 1.984081, 3.616241), + (4, 4.247304, 2.029095, 3.656926), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"syntax", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.533690, 2.339185, 4.777496), + (1, 3.542505, 2.348833, 4.697715), + (2, 3.544757, 2.349717, 4.658518), + (3, 3.542116, 2.342489, 4.697843), + (4, 3.532830, 2.358614, 4.777230), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"syntax", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 7.911000, 2.638922, 5.859227), + (1, 7.898019, 2.606325, 5.856922), + (2, 7.905536, 2.635740, 5.857377), + (3, 7.904312, 2.612189, 5.858381), + (4, 7.905098, 2.630487, 5.896411), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.751623, 1.803556, 3.817713), + (1, 2.747727, 1.810833, 3.816503), + (2, 2.748505, 1.805853, 3.937231), + (3, 2.751082, 1.785040, 3.856857), + (4, 2.712181, 1.628194, 4.458047), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 7.130218, 2.046734, 5.375091), + (1, 7.178329, 2.050762, 5.101087), + (2, 7.169060, 2.043104, 5.099096), + (3, 7.173283, 2.044239, 5.098124), + (4, 7.175252, 2.051192, 5.098199), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"irgen", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.789165, 1.527458, 3.336326), + (1, 3.777274, 1.538660, 3.375557), + (2, 3.784557, 1.519313, 3.376128), + (3, 3.787602, 1.522217, 3.335926), + (4, 3.787288, 1.526795, 3.337409), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"irgen", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.447726, 2.033431, 3.740433), + (1, 4.442726, 2.033703, 3.738224), + (2, 4.442734, 2.032771, 3.738289), + (3, 4.444849, 2.031724, 3.737305), + (4, 4.447839, 2.041379, 3.737854), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_asm", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.976113, 1.536616, 3.457503), + (1, 3.982885, 1.550541, 3.459236), + (2, 3.980745, 1.542500, 3.418313), + (3, 3.983197, 1.534735, 3.416768), + (4, 3.984319, 1.549369, 3.456912), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_asm", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.646497, 2.058736, 3.857968), + (1, 4.645902, 2.056331, 3.816948), + (2, 4.644425, 2.042617, 3.817483), + (3, 4.650170, 2.053945, 3.816996), + (4, 4.652057, 2.054087, 3.817612), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_asm", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.227559, 2.531595, 5.137862), + (1, 4.227397, 2.523166, 5.177460), + (2, 4.221999, 2.507393, 5.217410), + (3, 4.222567, 2.526250, 5.217654), + (4, 4.227901, 2.540431, 5.098870), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_asm", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.519619, 2.893774, 6.844787), + (1, 9.519173, 2.909991, 6.855886), + (2, 9.510792, 2.877242, 6.838998), + (3, 9.510783, 2.891383, 6.824785), + (4, 9.519126, 2.885516, 6.833841), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.451087, 1.898383, 4.336398), + (1, 3.449852, 1.892527, 4.337959), + (2, 3.454374, 1.893303, 4.658079), + (3, 3.455111, 1.882656, 4.378217), + (4, 3.450626, 1.869007, 4.337978), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.787702, 2.320593, 6.058270), + (1, 8.789275, 2.306274, 6.057923), + (2, 8.784843, 2.316817, 6.057423), + (3, 8.783675, 2.311861, 6.060013), + (4, 8.781261, 2.313746, 6.057873), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_compile", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.083893, 1.630474, 3.536216), + (1, 4.087591, 1.635289, 3.497630), + (2, 4.085695, 1.632900, 3.538942), + (3, 4.091750, 1.621504, 3.537607), + (4, 4.083429, 1.624206, 3.538044), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_compile", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.741063, 2.114975, 3.939181), + (1, 4.742471, 2.134199, 3.937271), + (2, 4.751861, 2.134679, 3.937887), + (3, 4.748915, 2.139128, 3.937938), + (4, 4.744369, 2.118603, 4.016509), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_compile", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.373580, 2.603582, 5.297729), + (1, 4.375890, 2.576323, 5.258865), + (2, 4.371432, 2.583884, 5.297363), + (3, 4.374495, 2.589453, 5.257298), + (4, 4.369606, 2.606228, 5.257661), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_compile", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.661360, 2.976421, 7.177350), + (1, 9.668097, 2.986125, 6.963308), + (2, 9.667800, 2.983053, 6.959276), + (3, 9.663941, 2.979323, 6.939242), + (4, 9.662299, 2.970007, 6.988974), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.579784, 1.946620, 4.378033), + (1, 3.579704, 1.964725, 4.377985), + (2, 3.584964, 1.951670, 4.376971), + (3, 3.576692, 1.920906, 4.418008), + (4, 3.590239, 1.966765, 4.377119), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.908318, 2.358443, 6.137820), + (1, 8.900847, 2.342913, 6.137705), + (2, 8.902168, 2.355932, 6.179136), + (3, 8.903369, 2.363490, 6.097751), + (4, 8.896827, 2.364196, 6.098246), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"all", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.122590, 1.633583, 3.696664), + (1, 4.114949, 1.638141, 3.578111), + (2, 4.114996, 1.631617, 3.536742), + (3, 4.118038, 1.641230, 3.578327), + (4, 4.112972, 1.639592, 3.575918), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"all", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.774701, 2.146296, 3.977572), + (1, 4.775361, 2.153011, 3.979860), + (2, 4.767364, 2.152865, 4.057217), + (3, 4.762550, 2.149360, 3.979342), + (4, 4.778981, 2.139902, 3.978489), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"all", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.400574, 2.604084, 5.299578), + (1, 4.404470, 2.623904, 5.338578), + (2, 4.396282, 2.608549, 5.297828), + (3, 4.410117, 2.614698, 5.340116), + (4, 4.406122, 2.619452, 5.337443), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"all", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.691876, 2.983326, 7.028989), + (1, 9.686101, 2.995257, 6.984466), + (2, 9.699200, 2.989842, 7.028152), + (3, 9.694729, 2.989742, 6.973924), + (4, 9.684670, 2.977108, 6.989194), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.603234, 1.964083, 4.458006), + (1, 3.607074, 1.941178, 4.417525), + (2, 3.603034, 1.943612, 4.737094), + (3, 3.602477, 1.935710, 4.378785), + (4, 3.603014, 1.920944, 4.496731), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.919863, 2.380177, 6.178527), + (1, 8.915304, 2.377547, 6.139442), + (2, 8.912262, 2.361640, 6.382166), + (3, 8.928109, 2.368477, 6.192743), + (4, 8.926360, 2.372693, 6.196191), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"null", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.433816, 0.270779, 0.497217), + (1, 0.435460, 0.270028, 0.496532), + (2, 0.433553, 0.269600, 0.496135), + (3, 0.444402, 0.277012, 0.497745), + (4, 0.435023, 0.270357, 0.496884), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"null", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.427882, 0.266594, 0.456246), + (1, 0.436036, 0.268734, 0.457465), + (2, 0.432485, 0.268278, 0.495730), + (3, 0.431188, 0.269520, 0.457981), + (4, 0.429806, 0.265927, 0.457372), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"null", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.439986, 0.271715, 0.496550), + (1, 0.433586, 0.270013, 0.496199), + (2, 0.432029, 0.268060, 0.497939), + (3, 0.439059, 0.272464, 0.497620), + (4, 0.434181, 0.272563, 0.497461), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"null", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.432427, 0.269396, 0.457136), + (1, 0.428288, 0.270302, 0.737128), + (2, 0.431231, 0.268325, 0.456252), + (3, 0.427926, 0.267086, 0.456874), + (4, 0.420557, 0.264270, 0.457617), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.434424, 0.272190, 0.498161), + (1, 0.434165, 0.269235, 0.494824), + (2, 0.432662, 0.270415, 0.500255), + (3, 0.438368, 0.274265, 0.496769), + (4, 0.436696, 0.274610, 0.495729), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.433117, 0.267209, 0.457335), + (1, 0.431207, 0.267527, 0.457362), + (2, 0.427488, 0.263088, 0.456154), + (3, 0.424716, 0.264632, 0.456745), + (4, 0.430324, 0.266478, 0.457237), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"###", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.243380, 0.979720, 1.137169), + (1, 1.278996, 0.992319, 1.137506), + (2, 1.287192, 0.993761, 1.138362), + (3, 1.287132, 0.979672, 1.137975), + (4, 1.280673, 0.991069, 1.134803), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"###", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.199258, 0.944011, 1.056302), + (1, 1.238243, 0.967198, 1.055378), + (2, 1.251064, 0.952736, 1.058118), + (3, 1.238275, 0.953812, 1.056281), + (4, 1.230085, 0.961011, 1.058278), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"###", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.303555, 1.002749, 1.177122), + (1, 1.297516, 0.987769, 1.179257), + (2, 1.291316, 0.989683, 1.134877), + (3, 1.297521, 0.998087, 1.177932), + (4, 1.298070, 0.996104, 1.136646), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"###", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.242426, 0.951754, 1.054691), + (1, 1.251845, 0.955747, 1.055754), + (2, 1.216099, 0.939568, 1.057614), + (3, 1.252534, 0.953115, 1.057181), + (4, 1.255139, 0.957134, 1.056560), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.480008, 0.367388, 0.535985), + (1, 0.482634, 0.363998, 0.537057), + (2, 0.487524, 0.362915, 0.536461), + (3, 0.486824, 0.371502, 0.536601), + (4, 0.486100, 0.368487, 0.536231), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.471967, 0.356792, 0.537280), + (1, 0.471389, 0.351906, 0.537328), + (2, 0.476653, 0.364830, 0.536856), + (3, 0.473745, 0.360644, 0.536245), + (4, 0.471692, 0.358740, 0.536919), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_pch", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.488745, 1.084366, 1.498790), + (1, 1.477772, 1.072057, 1.497152), + (2, 1.481656, 1.079815, 1.497487), + (3, 1.488131, 1.086291, 1.497713), + (4, 1.484908, 1.083611, 1.497307), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_pch", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.892219, 1.358115, 3.416973), + (1, 2.908085, 1.361083, 3.458190), + (2, 2.911845, 1.363507, 3.498229), + (3, 2.861631, 1.340626, 3.497350), + (4, 2.902695, 1.349841, 3.498252), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_pch", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.094289, 0.731166, 2.856787), + (1, 2.094159, 0.727149, 3.098345), + (2, 2.099123, 0.725737, 2.857987), + (3, 2.099356, 0.725484, 2.857824), + (4, 2.092198, 0.722902, 2.856964), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"cpp", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.072042, 1.472173, 1.777206), + (1, 2.082600, 1.489627, 1.777280), + (2, 2.056884, 1.488123, 1.817614), + (3, 2.070744, 1.497244, 1.776597), + (4, 2.067240, 1.482836, 1.777571), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"cpp", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.533060, 2.043311, 1.777522), + (1, 2.628373, 2.047752, 1.777593), + (2, 2.630915, 2.051977, 1.777852), + (3, 2.630455, 2.065881, 1.777911), + (4, 2.631787, 2.049902, 1.778263), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"parse", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.505337, 1.496155, 1.898006), + (1, 2.495744, 1.488942, 1.897842), + (2, 2.515831, 1.484552, 1.897723), + (3, 2.498317, 1.488449, 1.897741), + (4, 2.515904, 1.484614, 1.897771), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"parse", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.125124, 2.066737, 1.896962), + (1, 3.066430, 2.061710, 1.897127), + (2, 2.951498, 2.032558, 1.899777), + (3, 3.102248, 2.072226, 1.938907), + (4, 2.965375, 2.034301, 1.901575), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"syntax", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.959637, 1.775658, 2.417471), + (1, 3.731703, 1.768139, 2.338378), + (2, 3.938876, 1.797903, 2.376989), + (3, 3.942618, 1.776899, 2.376468), + (4, 3.955662, 1.784850, 2.417537), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"syntax", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.711232, 2.418611, 2.457315), + (1, 4.710700, 2.405150, 2.458243), + (2, 4.701677, 2.393935, 2.458244), + (3, 4.700064, 2.411945, 2.458502), + (4, 4.435552, 2.373475, 2.417904), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"syntax", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.765235, 3.147148, 4.457806), + (1, 3.792075, 3.092380, 4.138512), + (2, 3.755530, 3.109232, 4.099198), + (3, 3.775577, 3.132702, 4.259349), + (4, 3.765380, 3.153395, 4.138279), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"syntax", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.733600, 3.141350, 3.819429), + (1, 8.729315, 3.130464, 3.818712), + (2, 8.758360, 3.153188, 3.898371), + (3, 8.284330, 3.049157, 3.698701), + (4, 8.287672, 3.024545, 3.697567), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.874930, 2.387032, 3.537592), + (1, 2.912332, 2.467479, 3.577891), + (2, 2.864476, 2.410851, 3.499089), + (3, 2.907625, 2.451013, 3.618200), + (4, 2.911261, 2.404477, 4.099524), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 7.915458, 2.450591, 3.219913), + (1, 7.956233, 2.439542, 3.300366), + (2, 7.913691, 2.473252, 3.218957), + (3, 7.509113, 2.397069, 3.138018), + (4, 7.904014, 2.456804, 3.218425), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"irgen", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.942240, 1.800567, 2.417458), + (1, 4.154844, 1.814089, 2.457805), + (2, 4.176584, 1.830900, 2.457020), + (3, 4.158194, 1.830085, 2.778865), + (4, 4.150232, 1.830750, 2.459318), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"irgen", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.905547, 2.434522, 2.537988), + (1, 4.924605, 2.457269, 2.538644), + (2, 4.657417, 2.378047, 2.458053), + (3, 4.911690, 2.470984, 2.537993), + (4, 4.929673, 2.455544, 2.538190), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_asm", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.418219, 1.850523, 2.536990), + (1, 4.366724, 1.852566, 2.538399), + (2, 4.384926, 1.854429, 2.539958), + (3, 4.394250, 1.842192, 2.539435), + (4, 4.397239, 1.838145, 2.540060), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_asm", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 5.130585, 2.493244, 2.579148), + (1, 5.162982, 2.497135, 2.578713), + (2, 5.129066, 2.472889, 2.619872), + (3, 4.874468, 2.405774, 2.497419), + (4, 5.128376, 2.467295, 2.578880), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_asm", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.630875, 3.227827, 4.420094), + (1, 4.603130, 3.292521, 4.698425), + (2, 4.637749, 3.169974, 4.378697), + (3, 4.662829, 3.216485, 4.459226), + (4, 4.661186, 3.194321, 4.459337), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_asm", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.094412, 3.382733, 4.299690), + (1, 10.607728, 3.485426, 4.420339), + (2, 10.672437, 3.500697, 4.499281), + (3, 10.081432, 3.369802, 4.260940), + (4, 10.637020, 3.507006, 4.419349), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.756469, 2.606486, 3.858024), + (1, 3.742525, 2.585514, 3.860432), + (2, 3.763984, 2.594155, 3.858338), + (3, 3.750329, 2.597445, 3.861970), + (4, 3.780330, 2.594397, 4.178249), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.783391, 2.778921, 3.858346), + (1, 9.291026, 2.713206, 3.741779), + (2, 9.763105, 2.769221, 3.818018), + (3, 9.781831, 2.771892, 3.860051), + (4, 9.795868, 2.814192, 3.861095), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_compile", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.526822, 1.970779, 2.579904), + (1, 4.516155, 1.962200, 2.579553), + (2, 4.502726, 1.967558, 2.657639), + (3, 4.475255, 1.944838, 2.578810), + (4, 4.552333, 1.965428, 2.620439), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_compile", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 5.260314, 2.603498, 2.660341), + (1, 4.995161, 2.487917, 2.539731), + (2, 5.272310, 2.582304, 2.619170), + (3, 5.297074, 2.584287, 2.659045), + (4, 5.276844, 2.591704, 2.658579), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_compile", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.820446, 3.357945, 4.457265), + (1, 4.695519, 3.299694, 4.700489), + (2, 4.802906, 3.355605, 4.499002), + (3, 4.790937, 3.298910, 4.497635), + (4, 4.807253, 3.403019, 4.538081), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_compile", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.775635, 3.627255, 4.498454), + (1, 10.819002, 3.627111, 4.498795), + (2, 10.777939, 3.603335, 4.579594), + (3, 10.261991, 3.489692, 4.340296), + (4, 10.783511, 3.603470, 4.497803), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.926690, 2.635944, 3.858194), + (1, 3.904631, 2.622227, 3.819312), + (2, 3.902995, 2.656935, 3.899565), + (3, 3.842353, 2.559599, 3.939178), + (4, 3.912334, 2.629019, 3.858092), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.417663, 2.778879, 3.779754), + (1, 9.981881, 2.854902, 3.981156), + (2, 9.922719, 2.849422, 3.895627), + (3, 9.932923, 2.851789, 3.899661), + (4, 9.882651, 2.809967, 3.860299), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"all", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.524352, 1.986189, 2.979131), + (1, 4.571793, 1.979632, 2.617329), + (2, 4.551874, 1.976839, 2.657311), + (3, 4.535069, 1.982461, 2.660565), + (4, 4.517949, 1.967234, 2.619985), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"all", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 5.308971, 2.608535, 2.660880), + (1, 5.300322, 2.591561, 2.698928), + (2, 5.007866, 2.516937, 2.617425), + (3, 5.004273, 2.518780, 2.620204), + (4, 5.298584, 2.603459, 2.697609), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"all", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.829605, 3.306560, 4.499574), + (1, 4.834964, 3.359516, 4.499708), + (2, 4.848950, 3.406535, 4.500607), + (3, 4.846305, 3.301867, 4.501270), + (4, 4.841747, 3.311314, 4.460786), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"all", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.261230, 3.487758, 4.377307), + (1, 10.821449, 3.608144, 4.579734), + (2, 10.818690, 3.639902, 4.538873), + (3, 10.288671, 3.520532, 4.378760), + (4, 10.827655, 3.621076, 4.540632), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.945245, 2.727926, 4.020004), + (1, 3.927023, 2.718237, 3.937944), + (2, 3.864097, 2.645215, 4.258710), + (3, 3.959593, 2.659668, 3.857486), + (4, 3.949860, 2.636461, 3.860314), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.988320, 2.894515, 3.979462), + (1, 9.984554, 2.865497, 3.978603), + (2, 9.969262, 2.894911, 3.940909), + (3, 9.971215, 2.860655, 3.939045), + (4, 9.928752, 2.859610, 4.140611), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"null", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.437223, 0.305541, 0.456598), + (1, 0.437365, 0.302782, 0.455612), + (2, 0.444941, 0.302766, 0.458539), + (3, 0.443284, 0.309348, 0.457267), + (4, 0.438558, 0.302788, 0.456867), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"null", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.433141, 0.299426, 0.457566), + (1, 0.433713, 0.302028, 0.456971), + (2, 0.432310, 0.301072, 0.457115), + (3, 0.431210, 0.298571, 0.456809), + (4, 0.432891, 0.306442, 0.458554), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"null", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.440129, 0.307891, 0.457005), + (1, 0.441966, 0.305756, 0.456712), + (2, 0.444503, 0.310015, 0.457176), + (3, 0.439473, 0.304319, 0.457442), + (4, 0.443194, 0.306398, 0.457362), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"null", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.431106, 0.301673, 0.458410), + (1, 0.434829, 0.302589, 0.456891), + (2, 0.430545, 0.302707, 0.457500), + (3, 0.436609, 0.301462, 0.456980), + (4, 0.429837, 0.300629, 0.456958), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.441827, 0.306401, 0.457803), + (1, 0.440791, 0.307818, 0.456863), + (2, 0.441486, 0.306428, 0.456280), + (3, 0.441639, 0.303644, 0.457488), + (4, 0.435752, 0.302272, 0.456606), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.434382, 0.299908, 0.458576), + (1, 0.430466, 0.299767, 0.458895), + (2, 0.433482, 0.301923, 0.457146), + (3, 0.437816, 0.305736, 0.460591), + (4, 0.433787, 0.300150, 0.457657), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"###", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.248580, 1.078897, 1.137297), + (1, 1.240939, 1.052455, 1.415574), + (2, 1.241209, 1.084570, 1.136554), + (3, 1.240406, 1.093724, 1.136429), + (4, 1.240385, 1.082323, 1.136401), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"###", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.290192, 1.199382, 0.936326), + (1, 1.276522, 1.198278, 0.936272), + (2, 1.273170, 1.185225, 0.935751), + (3, 1.281657, 1.188458, 0.934154), + (4, 1.285165, 1.186782, 0.935658), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"###", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.261013, 1.087419, 1.135864), + (1, 1.261208, 1.088418, 1.134847), + (2, 1.243520, 1.091952, 1.135702), + (3, 1.256916, 1.061697, 1.138041), + (4, 1.262088, 1.105355, 1.137939), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"###", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.304031, 1.188856, 0.937909), + (1, 1.293276, 1.188637, 0.935459), + (2, 1.278288, 1.189283, 0.936833), + (3, 1.302987, 1.181945, 0.936069), + (4, 1.293851, 1.192556, 0.936999), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.490107, 0.418154, 0.575664), + (1, 0.489843, 0.413785, 0.535501), + (2, 0.487683, 0.415899, 0.535610), + (3, 0.484014, 0.413119, 0.535279), + (4, 0.491381, 0.413503, 0.537277), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.486695, 0.445844, 0.494296), + (1, 0.481367, 0.455675, 0.497159), + (2, 0.481974, 0.481187, 0.496221), + (3, 0.479369, 0.425384, 0.495441), + (4, 0.478301, 0.457115, 0.494315), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_pch", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.434857, 1.168123, 1.455765), + (1, 1.436208, 1.190995, 1.496024), + (2, 1.439552, 1.161674, 1.455066), + (3, 1.436967, 1.180953, 1.494596), + (4, 1.435067, 1.162529, 1.456440), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_pch", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.854271, 1.448036, 3.456023), + (1, 2.864284, 1.464534, 3.456831), + (2, 2.860290, 1.477350, 3.377527), + (3, 2.857286, 1.458217, 3.417068), + (4, 2.855595, 1.464395, 3.376247), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_pch", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.095114, 0.776987, 2.855911), + (1, 2.099607, 0.795455, 2.856180), + (2, 2.095073, 0.792649, 2.896811), + (3, 2.094082, 0.789727, 2.897515), + (4, 2.100236, 0.781259, 2.774968), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"cpp", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.999042, 1.594807, 1.777251), + (1, 1.990498, 1.601683, 1.736392), + (2, 2.006314, 1.599276, 1.897380), + (3, 1.994969, 1.622299, 1.775973), + (4, 1.988203, 1.577170, 1.736153), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"cpp", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.703651, 2.613281, 1.374149), + (1, 2.700635, 2.658189, 1.415542), + (2, 2.723514, 2.623613, 1.375880), + (3, 2.698653, 2.597336, 1.376495), + (4, 2.682678, 2.616761, 1.377316), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"parse", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.415923, 1.586213, 1.856706), + (1, 2.413466, 1.580113, 1.854297), + (2, 2.415569, 1.611288, 1.856562), + (3, 2.398350, 1.569858, 1.855165), + (4, 2.394427, 1.597305, 1.856311), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"parse", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.166052, 2.593652, 1.456512), + (1, 3.196717, 2.604754, 1.456743), + (2, 3.101508, 2.536190, 1.456607), + (3, 3.174828, 2.591447, 1.456659), + (4, 3.201618, 2.596692, 1.457126), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"syntax", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.712949, 1.873531, 2.336073), + (1, 3.691984, 1.870964, 2.297376), + (2, 3.733735, 1.860346, 2.296816), + (3, 3.702759, 1.885194, 2.336534), + (4, 3.725368, 1.861191, 2.296488), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"syntax", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.674568, 2.896322, 1.777463), + (1, 4.751183, 2.932167, 1.774656), + (2, 4.619575, 2.943985, 1.775820), + (3, 4.831743, 2.966127, 1.785376), + (4, 4.696926, 2.918956, 1.774947), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"syntax", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.619956, 3.111231, 4.057294), + (1, 3.634434, 3.079039, 4.176458), + (2, 3.619489, 3.150783, 4.138602), + (3, 3.621266, 3.104540, 4.058816), + (4, 3.608454, 3.122193, 4.057912), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"syntax", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.685876, 3.735123, 2.538354), + (1, 8.928202, 3.820031, 2.775907), + (2, 9.001593, 3.780341, 2.615105), + (3, 8.914982, 3.802006, 2.576587), + (4, 8.672801, 3.745031, 2.537300), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.804784, 2.299355, 3.497193), + (1, 2.837757, 2.362386, 3.538558), + (2, 2.872059, 2.437397, 3.497046), + (3, 2.822245, 2.354290, 3.416766), + (4, 2.852352, 2.360742, 3.536904), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 7.840658, 2.912237, 2.176625), + (1, 7.786177, 2.867490, 2.098460), + (2, 8.029733, 2.900113, 2.094914), + (3, 7.787848, 2.850907, 2.096058), + (4, 8.009086, 2.890278, 2.097071), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"irgen", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.924865, 1.882098, 2.377105), + (1, 3.946578, 1.907070, 2.377384), + (2, 3.942964, 1.879682, 2.376026), + (3, 3.891159, 1.892699, 2.377748), + (4, 3.967042, 1.868087, 2.417171), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"irgen", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.959364, 2.975161, 1.817129), + (1, 5.054176, 2.984549, 1.817835), + (2, 4.919681, 2.991480, 1.815857), + (3, 4.910313, 2.971126, 1.816666), + (4, 4.951734, 2.972542, 1.815437), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_asm", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.101830, 1.911448, 2.454536), + (1, 4.134987, 1.907901, 2.417187), + (2, 4.137531, 1.889402, 2.416253), + (3, 4.106261, 1.900297, 2.418632), + (4, 4.116540, 1.914047, 2.415859), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_asm", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 5.144013, 2.981688, 1.855810), + (1, 5.084562, 2.953167, 1.816353), + (2, 5.123251, 2.985708, 1.937743), + (3, 5.218549, 3.005248, 1.816337), + (4, 5.121341, 2.958136, 1.817163), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_asm", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.391211, 3.194895, 4.297978), + (1, 4.320212, 3.215877, 4.336974), + (2, 4.317236, 3.185048, 4.297096), + (3, 4.347551, 3.210930, 4.337750), + (4, 4.340133, 3.158959, 4.298051), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_asm", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.533776, 4.099156, 2.857560), + (1, 10.875003, 4.167712, 2.978028), + (2, 10.559224, 4.084177, 2.898004), + (3, 10.529217, 4.091320, 2.857602), + (4, 10.531274, 4.079794, 2.857786), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.572211, 2.564058, 3.657172), + (1, 3.610311, 2.554201, 3.738315), + (2, 3.503969, 2.457425, 3.656664), + (3, 3.497522, 2.477225, 3.776817), + (4, 3.516315, 2.450350, 3.697352), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.667563, 3.247271, 2.416874), + (1, 9.737532, 3.221747, 2.496587), + (2, 9.683672, 3.255651, 2.416956), + (3, 9.897372, 3.270324, 2.457738), + (4, 9.960110, 3.282960, 2.536374), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_compile", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.216047, 2.040267, 2.417042), + (1, 4.198596, 2.057673, 2.417291), + (2, 4.355761, 2.050442, 2.456578), + (3, 4.269654, 2.046761, 2.414728), + (4, 4.258278, 2.065794, 2.415867), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"only_compile", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 5.364820, 3.155647, 1.856490), + (1, 5.380241, 3.164256, 1.895779), + (2, 5.258991, 3.099702, 1.858494), + (3, 5.408499, 3.143804, 1.858232), + (4, 5.433442, 3.172182, 1.896951), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_compile", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.509842, 3.336711, 4.298495), + (1, 4.493119, 3.342058, 4.338363), + (2, 4.497302, 3.391293, 4.376365), + (3, 4.552023, 3.326395, 4.296523), + (4, 4.511749, 3.315174, 4.258914), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"only_compile", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 11.063909, 4.331076, 2.975250), + (1, 10.750918, 4.265164, 2.897127), + (2, 10.773158, 4.274519, 2.858005), + (3, 10.989661, 4.295921, 2.937906), + (4, 10.991448, 4.334725, 2.977596), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.668731, 2.619398, 3.657468), + (1, 3.654504, 2.592248, 3.696077), + (2, 3.665061, 2.625732, 3.699196), + (3, 3.673349, 2.573183, 3.697462), + (4, 3.682111, 2.613733, 3.738984), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.810406, 3.300637, 2.416778), + (1, 10.048934, 3.350114, 2.496649), + (2, 9.875004, 3.340279, 2.537774), + (3, 10.160045, 3.376951, 2.619453), + (4, 10.115032, 3.362591, 2.537008), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"all", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.241536, 2.082256, 2.455986), + (1, 4.286330, 2.067488, 2.496313), + (2, 4.291944, 2.084961, 2.496839), + (3, 4.299382, 2.050242, 2.497274), + (4, 4.256038, 2.063266, 2.497293), +]} +)) +runs.append(( { 'cc':"ccc_clang", + 'script':"all", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 5.421218, 3.170845, 1.936421), + (1, 5.384884, 3.153992, 1.897806), + (2, 5.296851, 3.153219, 1.951468), + (3, 5.260795, 3.139369, 2.177163), + (4, 5.278498, 3.141780, 1.895288), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"all", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.484287, 3.364861, 4.377941), + (1, 4.531560, 3.308326, 4.377562), + (2, 4.578896, 3.345062, 4.377173), + (3, 4.566615, 3.446052, 4.417550), + (4, 4.515315, 3.375575, 4.336788), +]} +)) +runs.append(( { 'cc':"ccc_gcc", + 'script':"all", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.788959, 4.299290, 2.977905), + (1, 11.090341, 4.345425, 3.058836), + (2, 11.066430, 4.319885, 2.976521), + (3, 10.779432, 4.283670, 3.018155), + (4, 10.788091, 4.327036, 2.978633), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.682013, 2.568734, 3.737019), + (1, 3.782095, 2.599814, 3.777516), + (2, 3.694371, 2.626584, 3.858657), + (3, 3.701257, 2.616141, 4.138741), + (4, 3.772297, 2.652233, 3.697378), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.129212, 3.382389, 2.576426), + (1, 10.165855, 3.362136, 2.579688), + (2, 10.085414, 3.375557, 2.539346), + (3, 10.106707, 3.375161, 2.777265), + (4, 10.163243, 3.374295, 2.579247), +]} +)) diff --git a/clang/www/timing-data/2009-06-26/176.gcc.pdf b/clang/www/timing-data/2009-06-26/176.gcc.pdf Binary files differnew file mode 100644 index 0000000..50a8bc3 --- /dev/null +++ b/clang/www/timing-data/2009-06-26/176.gcc.pdf diff --git a/clang/www/timing-data/2009-06-26/176.gcc.png b/clang/www/timing-data/2009-06-26/176.gcc.png Binary files differnew file mode 100644 index 0000000..da10f11 --- /dev/null +++ b/clang/www/timing-data/2009-06-26/176.gcc.png diff --git a/clang/www/timing-data/2009-06-26/176.gcc.txt b/clang/www/timing-data/2009-06-26/176.gcc.txt new file mode 100644 index 0000000..e8b9c44 --- /dev/null +++ b/clang/www/timing-data/2009-06-26/176.gcc.txt @@ -0,0 +1,699 @@ +start = """2009-06-26_10-19""" +clang = """/Volumes/Data/ddunbar/llvm.install/bin/clang""" +gcc = """/usr/bin/gcc-4.2""" +clang_info = """ +clang version 1.0 (https://ddunbar@llvm.org/svn/llvm-project/cfe/trunk 70266M) +Target: x86_64-apple-darwin10 + "/Volumes/Data/ddunbar/llvm.install/bin/../libexec/clang-cc" "-triple" "x86_64-apple-darwin10" "-S" "-disable-free" "-main-file-name" "null" "--relocation-model" "pic" "-pic-level=1" "--disable-fp-elim" "--unwind-tables=1" "--fmath-errno=0" "-mmacosx-version-min=10.6.0" "-fdiagnostics-show-option" "-o" "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-/cc-CVKyzP.s" "-x" "c" "/dev/null" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/as" "-arch" "x86_64" "-force_cpusubtype_ALL" "-o" "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-/cc-yeTCzJ.o" "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-/cc-CVKyzP.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/ld" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-weak_reference_mismatches" "non-weak" "-o" "a.out" "-lcrt1.10.6.o" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../../i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../.." "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-/cc-yeTCzJ.o" "-lSystem" "-lgcc" +""" +gcc_info = """ +Using built-in specs. +Target: i686-apple-darwin10 +Configured with: /var/tmp/gcc/gcc-5646~6/src/configure --disable-checking --enable-werror --prefix=/usr --mandir=/share/man --enable-languages=c,objc,c++,obj-c++ --program-transform-name=/^[cg][^.-]*$/s/$/-4.2/ --with-slibdir=/usr/lib --build=i686-apple-darwin10 --with-gxx-include-dir=/include/c++/4.2.1 --program-prefix=i686-apple-darwin10- --host=x86_64-apple-darwin10 --target=i686-apple-darwin10 +Thread model: posix +gcc version 4.2.1 (Apple Inc. build 5646) + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/cc1" "-quiet" "-imultilib" "x86_64" "-D__DYNAMIC__" "/dev/null" "-fPIC" "-quiet" "-dumpbase" "null" "-mmacosx-version-min=10.6.0" "-m64" "-mtune=core2" "-auxbase" "null" "-o" "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-//cc1kQh9M.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/as" "-arch" "x86_64" "-force_cpusubtype_ALL" "-o" "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-//ccQcv4DT.o" "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-//cc1kQh9M.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/collect2" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-weak_reference_mismatches" "non-weak" "-o" "a.out" "-lcrt1.10.6.o" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../../i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../.." "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-//ccQcv4DT.o" "-lSystem" "-lgcc" "-lSystem" +""" +style = """make""" +runs = [] +runs.append(( { 'cc':"clang_pch", + 'script':"null", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.065445, 0.110578, 0.041286), + (1, 0.064915, 0.107837, 0.038992), + (2, 0.065191, 0.106475, 0.039233), + (3, 0.064924, 0.107004, 0.039142), + (4, 0.065260, 0.108901, 0.038903), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.066126, 0.112036, 0.040769), + (1, 0.065207, 0.108471, 0.038945), + (2, 0.065186, 0.107970, 0.038926), + (3, 0.065149, 0.108577, 0.039189), + (4, 0.065456, 0.109348, 0.039253), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"###", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.206667, 0.425607, 0.110976), + (1, 0.204719, 0.410080, 0.107065), + (2, 0.204989, 0.410953, 0.108714), + (3, 0.204985, 0.407392, 0.107438), + (4, 0.203424, 0.408111, 0.108717), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.265631, 0.798950, 0.161461), + (1, 0.263615, 0.805888, 0.160308), + (2, 0.263824, 0.686335, 0.145542), + (3, 0.262625, 0.949966, 0.177774), + (4, 0.263458, 0.820937, 0.162473), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"syntax", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.464727, 0.818916, 0.657338), + (1, 1.492318, 0.850179, 0.351025), + (2, 1.492530, 0.861113, 0.349530), + (3, 1.515402, 0.868510, 0.354163), + (4, 1.501033, 0.855415, 0.351763), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.339387, 1.362012, 0.808105), + (1, 4.327148, 1.319992, 0.794006), + (2, 4.327374, 1.320020, 0.793893), + (3, 4.319876, 1.319808, 0.787893), + (4, 4.329951, 1.344321, 0.796930), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"irgen", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.977307, 1.244670, 0.754129), + (1, 3.948981, 1.236009, 0.751078), + (2, 3.987417, 1.247336, 0.750608), + (3, 3.973621, 1.227822, 0.746016), + (4, 3.947019, 1.234332, 0.741703), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_asm", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 6.749291, 1.404829, 1.149195), + (1, 6.750589, 1.434406, 1.151828), + (2, 6.744767, 1.415306, 1.146994), + (3, 6.738192, 1.425966, 1.147283), + (4, 6.755475, 1.410701, 1.147945), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.403397, 1.560103, 1.539962), + (1, 9.398348, 1.540148, 1.526404), + (2, 9.421496, 1.551876, 1.744563), + (3, 9.456310, 1.589165, 1.539901), + (4, 9.417963, 1.545186, 1.528347), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_compile", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.032359, 1.747400, 1.467280), + (1, 7.962687, 1.720919, 1.391892), + (2, 7.986155, 1.694753, 1.426921), + (3, 7.978081, 1.695359, 1.416691), + (4, 7.977982, 1.687328, 1.419240), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.750102, 1.794398, 1.729777), + (1, 10.730841, 1.801150, 1.728536), + (2, 10.723943, 1.779271, 1.701177), + (3, 10.730824, 1.778987, 1.705904), + (4, 10.741052, 1.819326, 1.724089), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"all", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.070440, 1.732707, 1.518658), + (1, 8.111095, 1.739793, 1.542162), + (2, 8.106386, 1.751412, 1.552584), + (3, 8.062847, 1.723786, 1.540230), + (4, 8.075670, 1.701288, 1.509957), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"8", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.803240, 1.832409, 1.822466), + (1, 10.797956, 1.833142, 1.875121), + (2, 10.815192, 1.818826, 1.835845), + (3, 10.826268, 1.809307, 1.823997), + (4, 10.815709, 1.809185, 1.840403), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"null", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.060892, 0.065833, 0.155946), + (1, 0.060517, 0.064263, 0.133922), + (2, 0.060487, 0.064208, 0.133807), + (3, 0.060484, 0.063849, 0.134039), + (4, 0.060465, 0.064026, 0.133506), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.060780, 0.064833, 0.136229), + (1, 0.060581, 0.064090, 0.134156), + (2, 0.060534, 0.064191, 0.133656), + (3, 0.060524, 0.064027, 0.133635), + (4, 0.060523, 0.063964, 0.133708), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"###", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.182177, 0.218261, 0.480256), + (1, 0.181253, 0.215086, 0.446808), + (2, 0.181503, 0.215725, 0.450776), + (3, 0.181187, 0.215330, 0.447765), + (4, 0.181176, 0.215050, 0.446595), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.236347, 0.301491, 0.583495), + (1, 0.235946, 0.299452, 0.568506), + (2, 0.235676, 0.298048, 0.559954), + (3, 0.235782, 0.298448, 0.561808), + (4, 0.235882, 0.299948, 0.563575), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"syntax", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.355242, 0.589876, 2.134110), + (1, 1.354939, 0.586215, 2.111487), + (2, 1.354329, 0.589784, 2.109410), + (3, 1.355080, 0.586192, 2.122027), + (4, 1.354042, 0.581133, 2.111260), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.044141, 0.951252, 5.162733), + (1, 4.043237, 0.954487, 5.147568), + (2, 4.043888, 0.952179, 5.146153), + (3, 4.043125, 0.948038, 5.147289), + (4, 4.043883, 0.943084, 5.147096), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"irgen", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.444049, 0.848918, 4.534581), + (1, 3.444084, 0.854620, 4.525171), + (2, 3.444498, 0.862757, 4.598576), + (3, 3.442347, 0.856215, 4.518719), + (4, 3.443622, 0.866269, 4.532286), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_asm", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 6.065809, 1.034261, 7.390113), + (1, 6.064420, 1.027780, 7.396403), + (2, 6.065132, 1.030652, 7.471856), + (3, 6.060587, 1.031604, 7.337894), + (4, 6.064466, 1.050338, 7.360592), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 8.960646, 1.236906, 10.456741), + (1, 8.957264, 1.234577, 10.357447), + (2, 8.956407, 1.237590, 10.352680), + (3, 8.957027, 1.241364, 10.398440), + (4, 8.956120, 1.239588, 10.355988), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_compile", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 7.277301, 1.238993, 8.973009), + (1, 7.277048, 1.246566, 9.027985), + (2, 7.277032, 1.226791, 8.944300), + (3, 7.277537, 1.242752, 8.970441), + (4, 7.278972, 1.238938, 8.989529), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.081783, 1.335714, 11.707981), + (1, 10.081742, 1.344538, 11.682596), + (2, 10.079740, 1.330281, 11.681210), + (3, 10.074737, 1.324856, 11.632253), + (4, 10.075030, 1.350316, 11.633475), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"all", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 7.377028, 1.265309, 9.283505), + (1, 7.376723, 1.253489, 9.102278), + (2, 7.376104, 1.255404, 9.094650), + (3, 7.376589, 1.260461, 9.246790), + (4, 7.377455, 1.255013, 9.095294), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"1", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.172422, 1.355756, 11.797816), + (1, 10.173442, 1.357210, 11.808185), + (2, 10.173484, 1.346743, 11.781768), + (3, 10.170524, 1.352371, 11.749764), + (4, 10.171428, 1.362057, 11.760581), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"null", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.061930, 0.070826, 0.090142), + (1, 0.061012, 0.067330, 0.073687), + (2, 0.060994, 0.067246, 0.073681), + (3, 0.061099, 0.067234, 0.074369), + (4, 0.061022, 0.066989, 0.073428), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.061591, 0.069558, 0.083641), + (1, 0.061059, 0.067184, 0.073565), + (2, 0.061076, 0.067165, 0.073724), + (3, 0.061096, 0.066990, 0.073567), + (4, 0.061062, 0.067199, 0.073221), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"###", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.185243, 0.234231, 0.256557), + (1, 0.184673, 0.232841, 0.245015), + (2, 0.184453, 0.232130, 0.244661), + (3, 0.184370, 0.230836, 0.243152), + (4, 0.184320, 0.231212, 0.244266), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.239474, 0.325816, 0.314883), + (1, 0.238393, 0.326431, 0.306354), + (2, 0.238299, 0.326449, 0.307918), + (3, 0.237867, 0.325013, 0.305753), + (4, 0.238329, 0.326355, 0.306446), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"syntax", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.386532, 0.594929, 1.083410), + (1, 1.385214, 0.591925, 1.071299), + (2, 1.385670, 0.596527, 1.071159), + (3, 1.385205, 0.595489, 1.071494), + (4, 1.385904, 0.590797, 1.067600), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.154845, 0.996239, 2.665919), + (1, 4.149680, 0.998786, 2.651533), + (2, 4.150974, 1.006984, 2.655142), + (3, 4.152007, 1.008280, 2.659809), + (4, 4.152938, 1.003288, 2.658114), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"irgen", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.644865, 0.892229, 2.404722), + (1, 3.639556, 0.887595, 2.387664), + (2, 3.643246, 0.880541, 2.387287), + (3, 3.643391, 0.883751, 2.401062), + (4, 3.644145, 0.886052, 2.392286), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_asm", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 6.307048, 1.072104, 3.873967), + (1, 6.313464, 1.064256, 3.870116), + (2, 6.307031, 1.064902, 3.865455), + (3, 6.309147, 1.070336, 3.900830), + (4, 6.307909, 1.066836, 3.868847), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.143474, 1.275600, 5.365390), + (1, 9.141933, 1.276966, 5.352204), + (2, 9.141995, 1.270270, 5.353590), + (3, 9.143375, 1.285837, 5.356607), + (4, 9.144897, 1.283080, 5.494642), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_compile", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 7.533151, 1.293809, 4.718994), + (1, 7.528865, 1.295241, 4.726586), + (2, 7.528888, 1.303576, 4.729746), + (3, 7.525020, 1.295358, 4.716415), + (4, 7.528346, 1.289752, 4.721087), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.287174, 1.382953, 6.031426), + (1, 10.283068, 1.389433, 6.021822), + (2, 10.283543, 1.392869, 6.004187), + (3, 10.284358, 1.377433, 5.997940), + (4, 10.289169, 1.391765, 6.007507), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"all", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 7.619409, 1.304847, 4.862155), + (1, 7.623702, 1.312795, 4.906194), + (2, 7.621269, 1.306275, 4.840736), + (3, 7.621495, 1.319364, 4.862966), + (4, 7.621999, 1.304611, 4.860783), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"2", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.367482, 1.401449, 6.145377), + (1, 10.373043, 1.412685, 6.172106), + (2, 10.373049, 1.398992, 6.103300), + (3, 10.373781, 1.396096, 6.107375), + (4, 10.366926, 1.406716, 6.112696), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"null", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.064425, 0.090165, 0.056533), + (1, 0.062985, 0.083843, 0.047935), + (2, 0.062983, 0.083616, 0.047921), + (3, 0.063039, 0.084145, 0.048157), + (4, 0.063026, 0.084462, 0.048349), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.064141, 0.088108, 0.053766), + (1, 0.063195, 0.084658, 0.048108), + (2, 0.063350, 0.085147, 0.049666), + (3, 0.063052, 0.083725, 0.047925), + (4, 0.063048, 0.083896, 0.048249), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"###", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.195147, 0.299573, 0.157355), + (1, 0.193085, 0.296310, 0.156304), + (2, 0.193189, 0.295669, 0.155085), + (3, 0.193301, 0.292950, 0.152589), + (4, 0.193210, 0.292226, 0.154638), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.250242, 0.409797, 0.192336), + (1, 0.248762, 0.398072, 0.187157), + (2, 0.248680, 0.433130, 0.196985), + (3, 0.248853, 0.398547, 0.187603), + (4, 0.248648, 0.405913, 0.188482), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"syntax", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.451387, 0.687142, 0.597211), + (1, 1.446637, 0.676693, 0.591064), + (2, 1.449276, 0.677468, 0.591800), + (3, 1.444318, 0.671687, 0.589322), + (4, 1.444476, 0.681194, 0.592248), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.264736, 1.132651, 1.424788), + (1, 4.261695, 1.143089, 1.416857), + (2, 4.264731, 1.138831, 1.422684), + (3, 4.264711, 1.140477, 1.417779), + (4, 4.260991, 1.147619, 1.419141), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"irgen", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.837203, 1.035623, 1.327415), + (1, 3.869828, 1.033702, 1.331966), + (2, 3.878679, 1.043199, 1.336928), + (3, 3.865577, 1.033086, 1.330496), + (4, 3.854501, 1.024146, 1.328011), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_asm", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 6.576067, 1.224910, 2.082887), + (1, 6.555647, 1.214275, 2.066679), + (2, 6.564496, 1.225676, 2.082281), + (3, 6.563023, 1.202289, 2.074234), + (4, 6.574312, 1.203879, 2.075939), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 9.320291, 1.388042, 2.820785), + (1, 9.321238, 1.374025, 2.817582), + (2, 9.312721, 1.370752, 2.815972), + (3, 9.321560, 1.382464, 2.905396), + (4, 9.315155, 1.367614, 2.814303), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_compile", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 7.799699, 1.445598, 2.532217), + (1, 7.793440, 1.427494, 2.537293), + (2, 7.794819, 1.451267, 2.540644), + (3, 7.802867, 1.449885, 2.537256), + (4, 7.811558, 1.454217, 2.549762), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.518288, 1.557086, 3.158364), + (1, 10.524251, 1.541390, 3.138438), + (2, 10.526541, 1.538375, 3.142480), + (3, 10.516332, 1.562218, 3.192590), + (4, 10.526898, 1.540009, 3.152245), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"all", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 7.894470, 1.472428, 2.647063), + (1, 7.880948, 1.497803, 2.666059), + (2, 7.877924, 1.457295, 2.623934), + (3, 7.880090, 1.463151, 2.671976), + (4, 7.876586, 1.463586, 2.653038), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"4", + 'pch':"no_pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 10.608510, 1.562882, 3.262625), + (1, 10.609805, 1.556848, 3.285292), + (2, 10.618056, 1.550407, 3.276770), + (3, 10.618343, 1.584988, 3.335703), + (4, 10.613029, 1.560418, 3.287023), +]} +)) +finished = """2009-06-26_10-31""" diff --git a/clang/www/timing-data/2009-06-26/sketch.pdf b/clang/www/timing-data/2009-06-26/sketch.pdf Binary files differnew file mode 100644 index 0000000..0bcf4c3 --- /dev/null +++ b/clang/www/timing-data/2009-06-26/sketch.pdf diff --git a/clang/www/timing-data/2009-06-26/sketch.png b/clang/www/timing-data/2009-06-26/sketch.png Binary files differnew file mode 100644 index 0000000..02a6321 --- /dev/null +++ b/clang/www/timing-data/2009-06-26/sketch.png diff --git a/clang/www/timing-data/2009-06-26/sketch.txt b/clang/www/timing-data/2009-06-26/sketch.txt new file mode 100644 index 0000000..5e2331c --- /dev/null +++ b/clang/www/timing-data/2009-06-26/sketch.txt @@ -0,0 +1,803 @@ +start = """2009-06-26_10-04""" +clang = """/Volumes/Data/ddunbar/llvm.install/bin/clang""" +gcc = """/usr/bin/gcc-4.2""" +clang_info = """ +clang version 1.0 (https://ddunbar@llvm.org/svn/llvm-project/cfe/trunk 70266M) +Target: x86_64-apple-darwin10 + "/Volumes/Data/ddunbar/llvm.install/bin/../libexec/clang-cc" "-triple" "x86_64-apple-darwin10" "-S" "-disable-free" "-main-file-name" "null" "--relocation-model" "pic" "-pic-level=1" "--disable-fp-elim" "--unwind-tables=1" "--fmath-errno=0" "-mmacosx-version-min=10.6.0" "-fdiagnostics-show-option" "-o" "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-/cc-vpL9h3.s" "-x" "c" "/dev/null" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/as" "-arch" "x86_64" "-force_cpusubtype_ALL" "-o" "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-/cc-qdRbcC.o" "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-/cc-vpL9h3.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/ld" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-weak_reference_mismatches" "non-weak" "-o" "a.out" "-lcrt1.10.6.o" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../../i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../.." "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-/cc-qdRbcC.o" "-lSystem" "-lgcc" +""" +gcc_info = """ +Using built-in specs. +Target: i686-apple-darwin10 +Configured with: /var/tmp/gcc/gcc-5646~6/src/configure --disable-checking --enable-werror --prefix=/usr --mandir=/share/man --enable-languages=c,objc,c++,obj-c++ --program-transform-name=/^[cg][^.-]*$/s/$/-4.2/ --with-slibdir=/usr/lib --build=i686-apple-darwin10 --with-gxx-include-dir=/include/c++/4.2.1 --program-prefix=i686-apple-darwin10- --host=x86_64-apple-darwin10 --target=i686-apple-darwin10 +Thread model: posix +gcc version 4.2.1 (Apple Inc. build 5646) + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/cc1" "-quiet" "-imultilib" "x86_64" "-D__DYNAMIC__" "/dev/null" "-fPIC" "-quiet" "-dumpbase" "null" "-mmacosx-version-min=10.6.0" "-m64" "-mtune=core2" "-auxbase" "null" "-o" "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-//ccvaleXF.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/as" "-arch" "x86_64" "-force_cpusubtype_ALL" "-o" "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-//ccV9sWHa.o" "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-//ccvaleXF.s" + "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/collect2" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-weak_reference_mismatches" "non-weak" "-o" "a.out" "-lcrt1.10.6.o" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64" "-L/usr/lib/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../../i686-apple-darwin10/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../.." "/var/folders/cl/clrOX6SaG+moCeRKEI4PtU+++TI/-Tmp-//ccV9sWHa.o" "-lSystem" "-lgcc" "-lSystem" +""" +style = """xcb""" +runs = [] +runs.append(( { 'cc':"clang_pch", + 'script':"null", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.454775, 0.429118, 0.894442), + (1, 0.456816, 0.263663, 0.473584), + (2, 0.455418, 0.263616, 0.471947), + (3, 0.457123, 0.264847, 0.476358), + (4, 0.455484, 0.265836, 0.472721), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.456015, 0.267448, 0.475121), + (1, 0.457929, 0.266122, 0.474585), + (2, 0.457145, 0.265216, 0.474808), + (3, 0.458294, 0.263764, 0.475413), + (4, 0.457468, 0.262464, 0.475923), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"###", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.486632, 0.345058, 0.560472), + (1, 0.493027, 0.344064, 0.516340), + (2, 0.492830, 0.342958, 0.515723), + (3, 0.490442, 0.345107, 0.516254), + (4, 0.496280, 0.343245, 0.518030), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.514260, 0.372418, 0.544621), + (1, 0.513040, 0.372859, 0.536797), + (2, 0.512094, 0.370682, 0.534324), + (3, 0.512872, 0.373514, 0.535788), + (4, 0.514620, 0.371925, 0.536016), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_pch", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.913210, 0.501577, 4.006777), + (1, 0.887095, 0.443278, 1.071434), + (2, 0.889139, 0.440980, 1.078436), + (3, 0.887708, 0.443451, 1.070797), + (4, 0.890721, 0.442759, 1.079390), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_pch", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.388931, 0.727417, 3.522403), + (1, 2.383308, 0.731864, 3.460458), + (2, 2.387928, 0.735731, 3.453216), + (3, 2.378387, 0.727654, 3.672474), + (4, 2.381366, 0.724858, 3.474937), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"syntax", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.037409, 0.613406, 1.215209), + (1, 1.040770, 0.634141, 1.205919), + (2, 1.034234, 0.618161, 1.210088), + (3, 1.035743, 0.626183, 1.194313), + (4, 1.035466, 0.621088, 1.181653), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.151380, 2.414929, 4.130644), + (1, 3.152197, 2.432369, 4.145959), + (2, 3.169057, 2.386287, 4.135253), + (3, 3.146057, 2.403489, 4.493451), + (4, 3.152363, 2.441579, 4.118788), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"irgen", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.400262, 0.704892, 1.375730), + (1, 1.404950, 0.676989, 1.295341), + (2, 1.395974, 0.686132, 1.318555), + (3, 1.402644, 0.668249, 1.302908), + (4, 1.394704, 0.675209, 1.326093), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_asm", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.616115, 0.717480, 1.452331), + (1, 1.624647, 0.706313, 1.364950), + (2, 1.621780, 0.711227, 1.364399), + (3, 1.615129, 0.708090, 1.350312), + (4, 1.627133, 0.705681, 1.380502), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.021269, 2.613351, 4.403274), + (1, 3.972482, 2.627701, 4.451196), + (2, 3.966213, 2.540204, 4.303024), + (3, 3.951820, 2.599589, 4.339412), + (4, 3.980372, 2.566508, 4.337338), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_compile", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.735196, 0.782129, 1.452587), + (1, 1.739009, 0.764330, 1.425707), + (2, 1.740858, 0.769880, 1.437086), + (3, 1.741419, 0.762191, 1.403820), + (4, 1.747043, 0.780665, 1.420343), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.102902, 2.665367, 4.390574), + (1, 4.097269, 2.666010, 4.359247), + (2, 4.147762, 2.644022, 4.382155), + (3, 4.196482, 2.724179, 4.465809), + (4, 4.137713, 2.652589, 4.396584), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"all", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.778593, 0.860038, 1.933043), + (1, 1.783723, 0.779371, 1.463440), + (2, 1.776279, 0.782745, 1.449608), + (3, 1.776952, 0.782233, 1.478619), + (4, 1.770755, 0.782444, 1.652835), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"8", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.133649, 2.666723, 4.502220), + (1, 4.164545, 2.606363, 4.423237), + (2, 4.141087, 2.729139, 4.466176), + (3, 4.186804, 2.692518, 4.448523), + (4, 4.135804, 2.680580, 4.428858), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"null", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.645824, 0.336540, 1.040349), + (1, 0.758601, 0.377669, 1.198545), + (2, 0.802384, 0.385620, 1.256802), + (3, 0.667186, 0.257789, 0.986552), + (4, 0.677381, 0.323771, 1.067715), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.654302, 0.326431, 1.043052), + (1, 0.610937, 0.202433, 0.879312), + (2, 0.821695, 0.241481, 1.127804), + (3, 0.633888, 0.315185, 1.009161), + (4, 0.606823, 0.209530, 0.874705), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"###", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.543719, 0.249359, 0.878529), + (1, 0.864268, 0.407639, 1.357842), + (2, 0.505443, 0.253217, 0.842801), + (3, 1.168525, 0.628933, 1.885143), + (4, 0.860483, 0.294474, 1.244566), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.730678, 0.350816, 1.158314), + (1, 0.833076, 0.402332, 1.310570), + (2, 0.626271, 0.280957, 0.987633), + (3, 0.705011, 0.360332, 1.149777), + (4, 0.708342, 0.304606, 1.086816), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_pch", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.243931, 0.544136, 1.943868), + (1, 1.178064, 0.357476, 1.703040), + (2, 0.921374, 0.438177, 1.525808), + (3, 1.153771, 0.486733, 1.796961), + (4, 0.968192, 0.355170, 1.483673), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_pch", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.493859, 0.712226, 4.011872), + (1, 2.940300, 0.921172, 4.652497), + (2, 2.715094, 0.893861, 4.490923), + (3, 2.610419, 0.709403, 4.118227), + (4, 2.526798, 0.679792, 3.994116), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"syntax", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.458838, 0.694208, 2.378138), + (1, 1.817837, 0.740143, 2.805735), + (2, 1.300085, 0.703071, 2.229211), + (3, 1.262175, 0.539189, 2.048597), + (4, 1.191437, 0.497072, 1.923328), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.120749, 1.789574, 5.789810), + (1, 3.273377, 1.967923, 6.133188), + (2, 3.037123, 1.733381, 5.596823), + (3, 3.042984, 1.730581, 5.650857), + (4, 3.188306, 1.759639, 5.884737), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"irgen", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.542473, 0.612384, 2.425046), + (1, 1.545307, 0.697333, 2.515996), + (2, 1.600507, 0.604696, 2.460228), + (3, 1.632270, 0.718514, 2.592235), + (4, 1.928976, 0.629692, 2.794199), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_asm", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.770525, 0.684705, 2.712227), + (1, 1.887006, 0.676721, 2.808092), + (2, 1.625953, 0.651827, 2.513331), + (3, 1.773543, 0.671273, 2.695842), + (4, 1.601478, 0.621009, 2.649159), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.114128, 2.094426, 7.063334), + (1, 4.025352, 1.957465, 6.838969), + (2, 3.821735, 1.946024, 6.632936), + (3, 3.907138, 2.007547, 7.016114), + (4, 4.024595, 2.043679, 6.922250), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_compile", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.056124, 0.710399, 3.025185), + (1, 1.804336, 0.726053, 2.772563), + (2, 1.967191, 0.656225, 2.892478), + (3, 2.201167, 1.485126, 3.955987), + (4, 1.994297, 0.676570, 2.914002), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.153794, 1.918740, 6.996844), + (1, 4.211883, 1.937034, 7.076586), + (2, 4.084567, 1.959342, 6.944548), + (3, 4.648222, 2.460079, 7.979059), + (4, 4.136109, 1.985068, 6.960107), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"all", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.028821, 0.718882, 3.022737), + (1, 1.843870, 0.711606, 2.811073), + (2, 1.985330, 0.640222, 2.873062), + (3, 2.060936, 0.694181, 3.004850), + (4, 1.897412, 0.741471, 2.895000), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"1", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.126488, 1.921937, 7.213964), + (1, 4.030952, 2.008876, 6.892632), + (2, 4.003183, 1.903866, 6.818411), + (3, 4.002316, 1.899865, 6.714604), + (4, 4.241685, 2.074201, 7.178083), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"null", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.438307, 0.207037, 0.506107), + (1, 0.443102, 0.205874, 0.504716), + (2, 0.439711, 0.209035, 0.506141), + (3, 0.436863, 0.206002, 0.504331), + (4, 0.439627, 0.206224, 0.505025), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.439477, 0.207192, 0.504912), + (1, 0.437463, 0.209372, 0.504820), + (2, 0.437903, 0.206376, 0.506661), + (3, 0.442930, 0.207493, 0.505236), + (4, 0.437359, 0.206906, 0.505647), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"###", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.476966, 0.260986, 0.572957), + (1, 0.478184, 0.263035, 0.573059), + (2, 0.469230, 0.262187, 0.571016), + (3, 0.469081, 0.262310, 0.570270), + (4, 0.487872, 0.261247, 0.573296), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.500065, 0.287104, 0.600696), + (1, 0.490454, 0.288579, 0.599350), + (2, 0.489178, 0.290420, 0.595453), + (3, 0.504358, 0.305761, 0.621200), + (4, 0.488484, 0.284586, 0.593988), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_pch", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.863838, 0.365213, 1.134056), + (1, 0.879504, 0.384604, 1.159071), + (2, 0.865340, 0.363764, 1.135322), + (3, 0.870478, 0.367344, 1.160674), + (4, 0.872049, 0.365320, 1.137567), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_pch", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.356240, 0.639645, 3.459472), + (1, 2.360200, 0.659262, 3.524492), + (2, 2.357683, 0.643919, 3.503642), + (3, 2.356418, 0.645647, 3.487224), + (4, 2.373107, 0.644771, 3.481359), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"syntax", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.020421, 0.527766, 1.342095), + (1, 1.015704, 0.514000, 1.336929), + (2, 1.012705, 0.511238, 1.355272), + (3, 1.017781, 0.525921, 1.395570), + (4, 1.018256, 0.517513, 1.810392), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.236664, 1.833475, 5.064647), + (1, 3.116394, 1.846229, 4.585106), + (2, 3.109082, 1.861524, 4.545915), + (3, 3.105011, 1.846408, 4.555086), + (4, 3.098872, 1.865976, 4.564655), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"irgen", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.380699, 0.583314, 1.565867), + (1, 1.388951, 0.550808, 1.551250), + (2, 1.413442, 0.605844, 2.090865), + (3, 1.387903, 0.560118, 1.544868), + (4, 1.380258, 0.556370, 1.545919), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_asm", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.594818, 0.585227, 1.667099), + (1, 1.592606, 0.587092, 1.672961), + (2, 1.593256, 0.589412, 1.669080), + (3, 1.593986, 0.587601, 1.669540), + (4, 1.596080, 0.588672, 1.661919), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.936649, 2.035445, 5.031351), + (1, 3.945642, 1.975630, 5.060494), + (2, 3.944102, 1.986388, 5.217065), + (3, 3.942765, 1.958722, 5.007943), + (4, 3.942774, 1.998893, 5.220903), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_compile", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.712580, 0.646710, 1.767951), + (1, 1.726718, 0.639926, 1.762359), + (2, 1.715856, 0.663728, 1.801439), + (3, 1.710717, 0.642142, 1.748022), + (4, 1.711775, 0.639969, 1.762574), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.100132, 2.051387, 5.193869), + (1, 4.080168, 2.011265, 5.256560), + (2, 4.081965, 2.023322, 5.162267), + (3, 4.095547, 2.044797, 5.131689), + (4, 4.083693, 2.027487, 5.067421), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"all", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.750192, 0.645773, 1.781508), + (1, 1.751823, 0.651023, 1.799043), + (2, 1.746203, 0.648456, 1.799824), + (3, 1.743422, 0.650594, 1.813096), + (4, 1.743223, 0.647433, 1.804423), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"2", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.112210, 2.030036, 5.210062), + (1, 4.134068, 2.036290, 5.134560), + (2, 4.106223, 2.031620, 5.167160), + (3, 4.111138, 2.067136, 5.242598), + (4, 4.114321, 2.105259, 5.219405), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"null", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.450242, 0.234466, 0.468920), + (1, 0.452251, 0.234237, 0.472734), + (2, 0.449428, 0.230498, 0.469181), + (3, 0.451854, 0.234653, 0.471594), + (4, 0.450034, 0.233853, 0.470746), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"null", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.451976, 0.237066, 0.471837), + (1, 0.451032, 0.232549, 0.469509), + (2, 0.450837, 0.235248, 0.469812), + (3, 0.451435, 0.236156, 0.471181), + (4, 0.454297, 0.235811, 0.472732), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"###", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.487874, 0.301226, 0.520971), + (1, 0.485966, 0.302353, 0.522738), + (2, 0.487933, 0.320309, 0.538211), + (3, 0.484292, 0.301703, 0.518200), + (4, 0.485094, 0.300915, 0.519927), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"###", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.507246, 0.328269, 0.538592), + (1, 0.504679, 0.327246, 0.536575), + (2, 0.506116, 0.325455, 0.534917), + (3, 0.504966, 0.325033, 0.535512), + (4, 0.504264, 0.325877, 0.537850), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_pch", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 0.878871, 0.406325, 1.083290), + (1, 0.881664, 0.406706, 1.089465), + (2, 0.879953, 0.403525, 1.089816), + (3, 0.880059, 0.403838, 1.081420), + (4, 0.882767, 0.404104, 1.081738), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_pch", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 2.376690, 0.683461, 3.481408), + (1, 2.371811, 0.678423, 3.554769), + (2, 2.373430, 0.687361, 3.496073), + (3, 2.371478, 0.675612, 3.438700), + (4, 2.377505, 0.688872, 3.424400), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"syntax", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.042312, 0.579073, 1.213381), + (1, 1.044438, 0.584515, 1.205995), + (2, 1.038797, 0.582026, 1.219606), + (3, 1.040786, 0.577159, 1.215521), + (4, 1.043000, 0.577868, 1.223773), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"syntax", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 3.231130, 2.567647, 4.158387), + (1, 3.235798, 2.498238, 4.418977), + (2, 3.238465, 2.529717, 4.211575), + (3, 3.239709, 2.495562, 4.156266), + (4, 3.231558, 2.493020, 4.108168), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"irgen", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.421647, 0.642906, 1.341418), + (1, 1.421549, 0.646429, 1.343189), + (2, 1.433072, 0.641680, 1.327081), + (3, 1.428600, 0.639478, 1.332256), + (4, 1.427077, 0.643784, 1.322933), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_asm", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.654124, 0.663628, 1.402498), + (1, 1.643467, 0.662131, 1.386214), + (2, 1.653972, 0.671458, 1.393807), + (3, 1.646365, 0.671024, 1.395913), + (4, 1.651021, 0.662302, 1.404011), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_asm", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.297588, 2.725803, 4.463298), + (1, 4.286029, 2.678946, 4.487945), + (2, 4.280374, 2.696217, 4.492516), + (3, 4.305121, 2.681000, 4.491615), + (4, 4.290141, 2.697022, 4.485084), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"only_compile", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.763493, 0.720256, 1.438810), + (1, 1.766202, 0.720674, 1.581947), + (2, 1.766634, 0.722865, 1.439302), + (3, 1.767231, 0.726466, 1.455122), + (4, 1.765071, 0.725319, 1.443411), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"only_compile", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.439486, 2.767478, 4.493862), + (1, 4.450584, 2.723827, 4.523759), + (2, 4.446754, 2.728436, 4.522514), + (3, 4.418589, 2.747071, 4.539960), + (4, 4.449233, 2.763071, 4.578583), +]} +)) +runs.append(( { 'cc':"clang_pch", + 'script':"all", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 1.796239, 0.738339, 1.484091), + (1, 1.804887, 0.734832, 1.484408), + (2, 1.799010, 0.745599, 1.487400), + (3, 1.795834, 0.735356, 1.480006), + (4, 1.806408, 0.745381, 1.483771), +]} +)) +runs.append(( { 'cc':"gcc", + 'script':"all", + 'threads':"4", + 'pch':"pch" }, +{ 'version' : 0, + 'samples' : [ + (0, 4.450745, 2.820108, 4.598335), + (1, 4.492508, 2.802745, 4.608004), + (2, 4.484814, 2.762586, 4.664950), + (3, 4.428110, 2.724648, 4.700769), + (4, 4.451598, 2.814003, 4.559797), +]} +)) +finished = """2009-06-26_10-19""" |
