diff options
Diffstat (limited to 'contrib/llvm/tools/clang/www')
76 files changed, 10933 insertions, 0 deletions
diff --git a/contrib/llvm/tools/clang/www/CheckerNotes.html b/contrib/llvm/tools/clang/www/CheckerNotes.html new file mode 100644 index 0000000..523048d --- /dev/null +++ b/contrib/llvm/tools/clang/www/CheckerNotes.html @@ -0,0 +1,9 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> +<html> +<head> +<title>Static Analysis</title> +<meta http-equiv="REFRESH" content="0;url=http://clang.llvm.org/StaticAnalysis.html"></HEAD> +<BODY> +This page has relocated: <a href="http://clang.llvm.org/StaticAnalysis.html">http://clang.llvm.org/StaticAnalysis.html</a>. +</BODY> +</HTML> diff --git a/contrib/llvm/tools/clang/www/OpenProjects.html b/contrib/llvm/tools/clang/www/OpenProjects.html new file mode 100644 index 0000000..46d9716 --- /dev/null +++ b/contrib/llvm/tools/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>Compile your favorite C/ObjC project with Clang</b>: +Clang's type-checking and code generation is very close to complete (but not bug free!) for C and Objective-C. We appreciate all reports of code that is +rejected or miscompiled by the front-end. If you notice invalid code that is not rejected, or poor diagnostics when code is rejected, that is also very important to us. For make-based projects, +the <a href="get_started.html#driver"><code>clang</code></a> driver works as a drop-in replacement for GCC.</li> + +<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. Two examples are <a href="http://distcc.samba.org/">distcc</a> +and the <a href="http://delta.tigris.org/">delta testcase reduction tool</a>. +The former can be improved to scale better and be more efficient. The latter +could also be faster and more efficient at reducing C-family programs if built +on the clang preprocessor.</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++ support</b>: Implementing all of C++ is a very big +job, but there are lots of little pieces that can be picked off and implemented. Here are some small- to mid-sized C++ implementation projects: +<ul> + <li>Fix bugs: there are a number of XFAIL'd test cases in Clang's repository (particularly in the CXX subdirectory). Pick a test case and fix Clang to make it work!</li> + <li>Write tests: the CXX test subdirectory in Clang's repository has placeholders for tests of every paragraph in the C++ standard. Pick a paragraph, write a few tests, and see if they work! Even if they don't we'd still like the new tests (with XFAIL'd) so that we know what to fix.</li> + <li>Parsing and semantic analysis for using declarations in classes</li> + <li>Inherited conversion functions</li> + <li>Improved diagnostics for overloading failures and ambiguities</li> + <li>Improved template error messages, e.g., with more informative backtraces</li> +</ul> + +Also, see the <a href="cxx_status.html">C++ status report page</a> to +find out what is missing and what is already at least partially +supported.</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> + +<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> + +</div> +</body> +</html> diff --git a/contrib/llvm/tools/clang/www/StaticAnalysis.html b/contrib/llvm/tools/clang/www/StaticAnalysis.html new file mode 100644 index 0000000..a701c0ff0 --- /dev/null +++ b/contrib/llvm/tools/clang/www/StaticAnalysis.html @@ -0,0 +1,21 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <meta HTTP-EQUIV="REFRESH" content="0; url=http://clang-analyzer.llvm.org"> + <title>LLVM/Clang Static Analyzer</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"> + +<p>This page has moved: <a href="http://clang-analyzer.llvm.org">clang.analyzer.llvm.org</a>.</p> + +</div> +</body> +</html> + diff --git a/contrib/llvm/tools/clang/www/StaticAnalysisUsage.html b/contrib/llvm/tools/clang/www/StaticAnalysisUsage.html new file mode 100644 index 0000000..a701c0ff0 --- /dev/null +++ b/contrib/llvm/tools/clang/www/StaticAnalysisUsage.html @@ -0,0 +1,21 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <meta HTTP-EQUIV="REFRESH" content="0; url=http://clang-analyzer.llvm.org"> + <title>LLVM/Clang Static Analyzer</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"> + +<p>This page has moved: <a href="http://clang-analyzer.llvm.org">clang.analyzer.llvm.org</a>.</p> + +</div> +</body> +</html> + diff --git a/contrib/llvm/tools/clang/www/UniversalDriver.html b/contrib/llvm/tools/clang/www/UniversalDriver.html new file mode 100644 index 0000000..82ccc8de --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/analyzer/annotations.html b/contrib/llvm/tools/clang/www/analyzer/annotations.html new file mode 100644 index 0000000..5184aed --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/annotations.html @@ -0,0 +1,458 @@ +<!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> + <script type="text/javascript" src="scripts/dbtree.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 id="collapsetree" class="dbtree onclick multiple"> +<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> + </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"> + +<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> +<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 contais 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"> + +<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).</p> +</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(); // No leak. +} + +- (NSDate*) alsoReturnsRetained { + return (NSDate*) returnsRetainedCFDate(); // Always report a leak. +} + +- (NSDate*) returnsNSRetained { + return (NSDate*) returnsRetainedCFDate(); // Report a leak when using GC. +} +@end +</pre> + +<p>Running <tt>scan-build</tt> on this example produces the following output:</p> + +<img src="images/example_cf_returns_retained.png"> + +</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"> + +<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> + +<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> +<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 __clang__ +<span class="code_highlight">#define CLANG_ANALYZER_NORETURN __attribute__((analyzer_noreturn))</span> +#else +#define CLANG_ANALYZER_NORETURN +#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/contrib/llvm/tools/clang/www/analyzer/available_checks.html b/contrib/llvm/tools/clang/www/analyzer/available_checks.html new file mode 100644 index 0000000..7af0865 --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/available_checks.html @@ -0,0 +1,37 @@ +<!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> +</head> +<body> + +<div id="page"> +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<h1>Available Checks</h1> + +<p>This page is slated to contain a list of the current checks the analyzer +performs along with some self-contained code examples. In the meantime, please +check out any of the following writeups about the analyzer that contain examples +of some of the bugs that it finds:</p> + +<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/contrib/llvm/tools/clang/www/analyzer/content.css b/contrib/llvm/tools/clang/www/analyzer/content.css new file mode 100644 index 0000000..b22cca9 --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/analyzer/dev_cxx.html b/contrib/llvm/tools/clang/www/analyzer/dev_cxx.html new file mode 100644 index 0000000..b5ef2b1 --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/dev_cxx.html @@ -0,0 +1,52 @@ +<!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:</li> + <ul> + <li>Model C++ destructors</li> + <li>Model C++ initializers (in constructors)</li> + </ul> + <li>Path-Sensitive Analysis Engine (GRExprEngine):</li> + <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> +</ul> + +</div> +</div> +</body> +</html> + diff --git a/contrib/llvm/tools/clang/www/analyzer/filing_bugs.html b/contrib/llvm/tools/clang/www/analyzer/filing_bugs.html new file mode 100644 index 0000000..746f1cb --- /dev/null +++ b/contrib/llvm/tools/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>llvm - checker</b> component.</p> +</div> +</div> +</body> +</html> + diff --git a/contrib/llvm/tools/clang/www/analyzer/images/analyzer_html.png b/contrib/llvm/tools/clang/www/analyzer/images/analyzer_html.png Binary files differnew file mode 100644 index 0000000..607ea18 --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/images/analyzer_html.png diff --git a/contrib/llvm/tools/clang/www/analyzer/images/analyzer_xcode.png b/contrib/llvm/tools/clang/www/analyzer/images/analyzer_xcode.png Binary files differnew file mode 100644 index 0000000..84c6980 --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/images/analyzer_xcode.png diff --git a/contrib/llvm/tools/clang/www/analyzer/images/example_attribute_nonnull.png b/contrib/llvm/tools/clang/www/analyzer/images/example_attribute_nonnull.png Binary files differnew file mode 100644 index 0000000..919af61 --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/images/example_attribute_nonnull.png diff --git a/contrib/llvm/tools/clang/www/analyzer/images/example_cf_returns_retained.png b/contrib/llvm/tools/clang/www/analyzer/images/example_cf_returns_retained.png Binary files differnew file mode 100644 index 0000000..4bee499 --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/images/example_cf_returns_retained.png diff --git a/contrib/llvm/tools/clang/www/analyzer/images/example_cf_returns_retained_gc.png b/contrib/llvm/tools/clang/www/analyzer/images/example_cf_returns_retained_gc.png Binary files differnew file mode 100644 index 0000000..023f1a2 --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/images/example_cf_returns_retained_gc.png diff --git a/contrib/llvm/tools/clang/www/analyzer/images/example_ns_returns_retained.png b/contrib/llvm/tools/clang/www/analyzer/images/example_ns_returns_retained.png Binary files differnew file mode 100644 index 0000000..61316e1 --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/images/example_ns_returns_retained.png diff --git a/contrib/llvm/tools/clang/www/analyzer/images/scan_build_cmd.png b/contrib/llvm/tools/clang/www/analyzer/images/scan_build_cmd.png Binary files differnew file mode 100644 index 0000000..464fd4e --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/images/scan_build_cmd.png diff --git a/contrib/llvm/tools/clang/www/analyzer/images/tree/bullet.gif b/contrib/llvm/tools/clang/www/analyzer/images/tree/bullet.gif Binary files differnew file mode 100644 index 0000000..de15348 --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/images/tree/bullet.gif diff --git a/contrib/llvm/tools/clang/www/analyzer/images/tree/minus.gif b/contrib/llvm/tools/clang/www/analyzer/images/tree/minus.gif Binary files differnew file mode 100644 index 0000000..225f40d --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/images/tree/minus.gif diff --git a/contrib/llvm/tools/clang/www/analyzer/images/tree/plus.gif b/contrib/llvm/tools/clang/www/analyzer/images/tree/plus.gif Binary files differnew file mode 100644 index 0000000..5398c80 --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/images/tree/plus.gif diff --git a/contrib/llvm/tools/clang/www/analyzer/index.html b/contrib/llvm/tools/clang/www/analyzer/index.html new file mode 100644 index 0000000..082d35f --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/index.html @@ -0,0 +1,227 @@ +<!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> +</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> + +<!-- 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; +} +</style> + +<style type="text/css"> + #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> + +<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 (Universal binary, 10.5+):<br> + <!--#include virtual="latest_checker.html.incl"--> + </li> + <li>Can be used both from the command line and 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="450x" border=0></a> +<center><b>Viewing static analyzer results in Xcode 3.2</b></center> +<a href="images/analyzer_html.png"><img src="images/analyzer_html.png" width="450px" border=0></a> +<center><b>Viewing static analyzer results in a web browser</b></center> +</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></li> + +<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/contrib/llvm/tools/clang/www/analyzer/installation.html b/contrib/llvm/tools/clang/www/analyzer/installation.html new file mode 100644 index 0000000..b84f263 --- /dev/null +++ b/contrib/llvm/tools/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</em> build of LLVM/Clang, the +resultant<tt>clang</tt> binary will be in $(OBJDIR)/Debug +(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/contrib/llvm/tools/clang/www/analyzer/latest_checker.html.incl b/contrib/llvm/tools/clang/www/analyzer/latest_checker.html.incl new file mode 100644 index 0000000..ecc516a --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/latest_checker.html.incl @@ -0,0 +1 @@ +<b><a href="http://files.me.com/tkremenek/mt0ve6">checker-241.tar.bz2</a></b> (built May 26, 2010) diff --git a/contrib/llvm/tools/clang/www/analyzer/menu.css b/contrib/llvm/tools/clang/www/analyzer/menu.css new file mode 100644 index 0000000..05c1bbf --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/analyzer/menu.html.incl b/contrib/llvm/tools/clang/www/analyzer/menu.html.incl new file mode 100644 index 0000000..a06eb58 --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/menu.html.incl @@ -0,0 +1,40 @@ +<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="/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/contrib/llvm/tools/clang/www/analyzer/menu.js b/contrib/llvm/tools/clang/www/analyzer/menu.js new file mode 100644 index 0000000..6b393c0 --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/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/contrib/llvm/tools/clang/www/analyzer/scan-build.html b/contrib/llvm/tools/clang/www/analyzer/scan-build.html new file mode 100644 index 0000000..1db15fe --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/scan-build.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>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%" border="0" 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. By default, this fake compiler +executes <tt>gcc</tt> to compile your code (assuming that <tt>gcc</tt> is your +compiler) 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"> +<center> + <img src="images/scan_build_cmd.png" width="450px" border=0><br> + <a href="images/analyzer_html.png"><img src="images/analyzer_html.png" width="450px" border=0></a> +<br><b>Viewing static analyzer results in a web browser</b></center> +</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> 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 <nobr><tt>-j4</tt></nobr> 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><nobr>(or no arguments)</nobr></i></td><td>Display all +<tt>scan-build</tt> options.</td></tr> + +<tr><td><b>-k</b><br><nobr><b>--keep-going</b></nobr></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 <tt>gcc</tt> 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 targetting 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 <tt>gcc</tt> to +compile the project and <tt>clang</tt> to analyze your project. When analyzing +iPhone projects, <b>scan-build</b> may pick the wrong compiler than the one +Xcode would use to build your project. This is because multiple versions of +<tt>gcc</tt> may be installed on your system, especially if you are developing +for the iPhone.</p> + +<p>Where this particularly might be a problem is if you are using Mac OS 10.5 +(Leopard) to develop for iPhone OS 3.0. The default desktop compiler on Leopard +is gcc-4.0, while the compiler for iPhone OS 3.0 is gcc-4.2. When compiling your +application to run on the simulator, it is important that <b>scan-build</b> +finds the correct version of <tt>gcc</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/contrib/llvm/tools/clang/www/analyzer/scripts/dbtree.js b/contrib/llvm/tools/clang/www/analyzer/scripts/dbtree.js new file mode 100644 index 0000000..5face5d --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/analyzer/scripts/menu.js b/contrib/llvm/tools/clang/www/analyzer/scripts/menu.js new file mode 100644 index 0000000..6b393c0 --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/analyzer/xcode.html b/contrib/llvm/tools/clang/www/analyzer/xcode.html new file mode 100644 index 0000000..474156e --- /dev/null +++ b/contrib/llvm/tools/clang/www/analyzer/xcode.html @@ -0,0 +1,136 @@ +<!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"> +<center> + <a href="images/analyzer_xcode.png"><img src="images/analyzer_xcode.png" width="620px" border=0></a> +<br><b>Viewing static analyzer results in Xcode</b></center> +</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>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 +$ 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"> +$ 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"> +$ set-xcode-analyzer --use-xcode-clang +</pre> + +</div> +</div> +</body> +</html> + diff --git a/contrib/llvm/tools/clang/www/carbon-compile.png b/contrib/llvm/tools/clang/www/carbon-compile.png Binary files differnew file mode 100644 index 0000000..e8516c7 --- /dev/null +++ b/contrib/llvm/tools/clang/www/carbon-compile.png diff --git a/contrib/llvm/tools/clang/www/clang-tutorial.html b/contrib/llvm/tools/clang/www/clang-tutorial.html new file mode 100644 index 0000000..0e17046 --- /dev/null +++ b/contrib/llvm/tools/clang/www/clang-tutorial.html @@ -0,0 +1,56 @@ +<!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 - Quick Tutorial</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>Tutorial</h1> + + <p>Invoking the BoostCon tool:</p> + <pre> +$ clang -cc1 -boostcon t.cpp +</pre> + + <p>Teach the BoostCon action to identify and print C++ classes:</p> + <pre> +bool VisitCXXRecordDecl(CXXRecordDecl *D) { + std::cout << D->getNameAsString() + << '\n'; + return false; +} +</pre> + + <p>Walk and print base classes of a class:</p> + <pre> +for(CXXRecordDecl::base_class_iterator + B = D->bases_begin(), BEnd = D->bases_end(); + B != BEnd; ++B) { + QualType BaseType = B->getType(); + std::cout << " " << BaseType.getAsString() + << '\n'; +} +</pre> + + <p>Retrieve the C++ class declaration from a base type:</p> + <pre> +if (const RecordType *RTy + = BaseType->getAs<RecordType>()) { + RecordDecl *Base = RTy->getDecl(); + if (CXXRecordDecl *BaseCXX + = dyn_cast<CXXRecordDecl>(Base)) { + + } +} +</pre> +</div> +</body> +</html> diff --git a/contrib/llvm/tools/clang/www/clang_video-05-25-2007.html b/contrib/llvm/tools/clang/www/clang_video-05-25-2007.html new file mode 100644 index 0000000..a85cadc --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/clang_video-07-25-2007.html b/contrib/llvm/tools/clang/www/clang_video-07-25-2007.html new file mode 100644 index 0000000..179e499 --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/comparison.html b/contrib/llvm/tools/clang/www/comparison.html new file mode 100644 index 0000000..dcf6220 --- /dev/null +++ b/contrib/llvm/tools/clang/www/comparison.html @@ -0,0 +1,191 @@ +<!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><a href="cxx_status.html">Clang support for C++</a> is more compliant + than GCC's in many ways, but is not as mature as GCC's. GCC has several + C++'0x features that Clang does not yet support (e.g. variadic + templates).</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> + </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>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> + + <p>Note that there is a fork of Elsa known as "Pork". It addresses some of + these shortcomings by loosely integrating a preprocessor. This allows it + to map from a source location in the AST to the original position before + preprocessing, providing it better support for static analysis and + refactoring. Note that Pork is in stasis now too.</p> + + + <!--=====================================================================--> + <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> + </div> +</body> +</html> diff --git a/contrib/llvm/tools/clang/www/content.css b/contrib/llvm/tools/clang/www/content.css new file mode 100644 index 0000000..dca6a32 --- /dev/null +++ b/contrib/llvm/tools/clang/www/content.css @@ -0,0 +1,27 @@ +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 } + +/* Tables */ +tr { vertical-align:top } diff --git a/contrib/llvm/tools/clang/www/cxx_compatibility.html b/contrib/llvm/tools/clang/www/cxx_compatibility.html new file mode 100644 index 0000000..fe03240 --- /dev/null +++ b/contrib/llvm/tools/clang/www/cxx_compatibility.html @@ -0,0 +1,303 @@ +<!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++ 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> +<!-- ======================================================================= --> + +<ul> +<li><a href="#intro">Introduction</a></li> +<li><a href="#vla">Variable-length arrays</a></li> +<li><a href="#init_static_const">Initialization of non-integral static const data members within a class definition</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="#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> +</ul> + +<!-- ======================================================================= --> +<h2 id="intro">Introduction</h2> +<!-- ======================================================================= --> + +<p>Clang strives to strictly conform to the C++ standard. That means +it will reject invalid C++ code that another compiler may accept. +This page helps you decide whether a Clang error message means a +C++-conformance bug in your code and how you can fix it.</p> + +<!-- ======================================================================= --> +<h2 id="vla">Variable-length arrays</h2> +<!-- ======================================================================= --> + +<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, base classes, or any + members if 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 definition of <tt>size</tt> is a compile-time + integral constant);</li> +<li>use an <tt>std::string</tt> instead of a <tt>char []</tt>;</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> + +<!-- ======================================================================= --> +<h2 id="init_static_const">Initialization of non-integral static const data members within a class definition</h2> +<!-- ======================================================================= --> + +The following code is ill-formed in C++'03: + +<pre> +class SomeClass { + public: + static const double SomeConstant = 0.5; +}; + +const double SomeClass::SomeConstant; +</pre> + +Clang errors with something similar to: + +<pre> +.../your_file.h:42:42: error: 'SomeConstant' can only be initialized if it is a static const integral data member + static const double SomeConstant = 0.5; + ^ ~~~ +</pre> + +Only <i>integral</i> constant expressions are allowed as initializers +within the class definition. See C++'03 [class.static.data] p4 for the +details of this restriction. The fix here is straightforward: move +the initializer to the definition of the static data member, which +must exist outside of the class definition: + +<pre> +class SomeClass { + public: + static const double SomeConstant; +}; + +const double SomeClass::SomeConstant<b> = 0.5</b>; +</pre> + +Note that the forthcoming C++0x standard will allow this. + +<!-- ======================================================================= --> +<h2 id="dep_lookup">Unqualified lookup in templates</h2> +<!-- ======================================================================= --> + +Some versions of GCC accept the following invalid code: + +<pre> +template <typename T> struct Foo { + void Work(T x) { + func(x); + } +}; +... +void func(int x); +... +template struct Foo<int>; // or anything else that instantiates Foo<int>::Work +</pre> + +The standard says that unqualified names like <tt>func</tt> are looked up +when the template is defined, not when it's instantiated. Since +<tt>void func(int)</tt> was not declared yet when <tt>Foo</tt> was +defined, it's not considered. The fix is usually to +declare <tt>func</tt> before <tt>Foo</tt>. + +<p>This is complicated by <i>argument-dependent lookup</i> (ADL), +which is done when unqualified names are called as functions, +like <tt>func(x)</tt> above. The standard says that ADL is performed +in both places if any of the arguments are type-dependent, like +<tt>x</tt> is in this example. However, ADL does nothing for builtin +types like <tt>int</tt>, so the example is still invalid. See +[basic.lookup.argdep] for more information. + +<!-- ======================================================================= --> +<h2 id="dep_lookup_bases">Unqualified lookup into dependent bases of class templates</h2> +<!-- ======================================================================= --> + +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! + +<!-- ======================================================================= --> +<h2 id="bad_templates">Templates with no valid instantiations</h2> +<!-- ======================================================================= --> + +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. + +<!-- ======================================================================= --> +<h2 id="default_init_const">Default initialization of const variable of a class type requires user-defined default constructor</h2> +<!-- ======================================================================= --> + +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> + +</div> +</body> +</html> diff --git a/contrib/llvm/tools/clang/www/cxx_status.html b/contrib/llvm/tools/clang/www/cxx_status.html new file mode 100644 index 0000000..8fccc2a --- /dev/null +++ b/contrib/llvm/tools/clang/www/cxx_status.html @@ -0,0 +1,234 @@ +<!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++ and C++'0x Status</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <style type="text/css"> + .na { background-color: #C0C0C0; text-align: center; } + .broken { background-color: #C11B17 } + .basic { background-color: #F88017 } + .medium { background-color: #FDD017 } + .advanced { background-color: #347C17 } + .complete { background-color: #00FF00 } + </style> +</head> +<body> + +<!--#include virtual="menu.html.incl"--> + +<div id="content"> + +<!--*************************************************************************--> +<h1>C++ and C++'0x Support in Clang</h1> +<!--*************************************************************************--> +<p>Last updated: $Date: 2010-05-21 23:16:21 +0200 (Fri, 21 May 2010) $</p> + + <ul> + <li><a href="#projects">Projects Building with Clang</a></li> + <li><a href="#specification">Implementation Status by Section</a></li> + <li><a href="#cxx0x">C++0x Status</a></li> + </ul> + +<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 from the C++'0x draft). + However, the implementation of Clang C++ is still somewhat immature, with + remaining bugs that may cause compiler crashes, erroneous errors and warnings, + or miscompiled code. 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="projects">Projects Building with Clang</h2> + + <p>Clang is now capable of compiling large C++ projects, and the following + table describes various projects that we have attempted to compile with + Clang++.</p> + +<table width="689" border="1" cellspacing="0"> + <tr> + <th>Project</th> + <th>Status</th> + <th>Last Tested</th> + <th>Tracking Bug</th> + </tr> + <tr> + <td><a href="http://clang.llvm.org">Clang</a> and <a href="http://llvm.org">LLVM</a></td> + <td>Successful self-hosting achieved</td> + <td>Continually</td> + <td></td> + </tr> + <tr> + <td><a href="http://www.cmake.org">CMake</a></td> + <td>Compiles, passes regression tests (debug build)</td> + <td>February 9, 2010</td> + <td></td> + </tr> + <tr> + <td><a href="http://www.boost.org">Boost</a></td> + <td><a href="http://blog.llvm.org/2010/05/clang-builds-boost.html">Compiles + and passes regression tests</a> on Darwin/X86-64.</td> + <td>May 20, 2010</td> + <td><a href="http://llvm.org/bugs/show_bug.cgi?id=6023">PR6023</a></td> + </tr> + <tr> + <td><a href="http://qt.nokia.com">Qt</a></td> + <td>Partially compiles; miscompilation of uic prevents complete compilation, qmake works, some small examples also.</td> + <td>February 9, 2010</td> + <td><a href="http://llvm.org/bugs/show_bug.cgi?id=5881">PR5881</a></td> + </tr> +</table> + +<h2 id="cxx0x">C++0x Implementation status</h2> + +<p>Clang's development effort is focused primarily on fixing bugs in the current +ISO C++ standard (1998/2003). This section tracks the status of various C++0x +features.</p> + + +<h2 id="specification">Implementation Status by Feature</h2> + + +<!-- Within this table: The colors we're using to color-code our level +of support for a given section: + + White (no background): not considered/tested. + #C11B17: Broken. + #F88017: Some useful examples work + #FDD017: Many examples work + #347C17: Nearly everything works + #00FF00 + check mark: Implementation complete! + --> + +<p>The following table is used to help track our implementation + progress toward implementing the complete C++'0x standard. We use a + simple, somewhat arbitrary color-coding scheme to describe the + relative completeness of features:</p> + +<table width="689" border="1" cellspacing="0"> + <tr> + <th>Not started/not evaluated</th> + <th>Not Applicable</th> + <th>Broken</th> + <th>Some examples work</th> + <th>Many examples work</th> + <th>Nearly everything works</th> + <th>Complete</th> + <th>Complete (with tests for each paragraph)</th> + </tr> + <tr> + <td></td> + <td class="na">N/A</td> + <td class="broken"></td> + <td class="basic"></td> + <td class="medium"></td> + <td class="advanced"></td> + <td class="complete"></td> + <td class="complete" align="center">✓</td> + </tr> +</table> + +<p>A feature is "complete" when the appropriate Clang component (Parse, AST, +Sema, CodeGen) implements the behavior described in all of the +paragraphs in the relevant C++'0x draft standard. The major +components are:</p> + +<dl> + <dt>Parse</dt> + <dd>Clang is able to parse the grammar of this feature (or the grammar + described by this section), but does not necessarily do anything with the + parsed result. Use Clang's <code>-fsyntax-only</code> option to parse C++ + programs.</dd> + + <dt>AST</dt> + <dd>Clang builds an abstract syntax tree (AST) for the feature, but does not + necessarily perform any type-checking. Use Clang's <code>-ast-print</code> + option to print the resulting ASTs.</dd> + + <dt>Sema</dt> + <dd>Clang parses and type-checks this feature and provides a well-formed AST + annotated with types. Use Clang's <code>-fsyntax-only</code> to type-check + code.</dd> + + <dt>CodeGen</dt> + <dd>Clang parses, type-checks, and generates code for this feature, allowing + one to compile and execute programs.</dd> +</dl> + +<p>Updates to this table are welcome! Tests for the various features are also +welcome!</p> + +<table width="689" border="1" cellspacing="0"> +<tr><td colspan="6" align="center" bgcolor="#ffffcc">C++0x Features</td> +</tr> + <tr> + <th>Feature</th> + <th>Parse</th> + <th>AST</th> + <th>Sema</th> + <th>CodeGen</th> + <th>Notes</th> + </tr> + +<tr> + <td>Explicit conversion operators (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf">N2437</a>)</td> + <td class="complete" align="center"></td> + <td class="medium" align="center"></td> + <td class="advanced" align="center"></td> + <td class="broken"></td> + <td>No name mangling; ASTs don't contain calls to conversion operators</td> +</tr> +<tr> + <td>Static assertions (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.pdf">N1720</a>)</td> + <td class="complete" align="center"></td> + <td class="complete" align="center"></td> + <td class="complete" align="center"></td> + <td class="na">N/A</td> + <td></td> +</tr> +<tr> + <td>Deleted functions (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm">N2346</a>)</td> + <td class="complete" align="center"></td> + <td class="complete" align="center"></td> + <td class="complete" align="center"></td> + <td class="na">N/A</td> + <td></td> +</tr> +<tr> + <td>Rvalue references (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html">N2118</a> + <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2831.html">N2831</a>)</td> + <td class="complete" align="center"></td> + <td class="complete" align="center"></td> + <td class="complete" align="center"></td> + <td class="broken"></td> + <td></td> +</tr> +<tr> + <td>nullptr (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf">N2431</a>)</td> + <td class="complete" align="center"></td> + <td class="complete" align="center"></td> + <td class="complete" align="center"></td> + <td class="broken"></td> + <td></td> +</tr> +<tr> + <td>Right angle brackets (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html">N1757</a>)</td> + <td class="complete" align="center"></td> + <td class="na" align="center">N/A</td> + <td class="na" align="center">N/A</td> + <td class="na">N/A</td> + <td></td> +</tr> +<tr> + <td>Decltype (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf">N2343</a>)</td> + <td class="complete" align="center">✓</td> + <td class="complete" align="center">✓</td> + <td class="complete" align="center">✓</td> + <td class="na">N/A</td> + <td></td> +</tr> +</table> +<br /> +</div> +</body> +</html> diff --git a/contrib/llvm/tools/clang/www/demo/DemoInfo.html b/contrib/llvm/tools/clang/www/demo/DemoInfo.html new file mode 100644 index 0000000..54a5afa --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/demo/cathead.png b/contrib/llvm/tools/clang/www/demo/cathead.png Binary files differnew file mode 100644 index 0000000..3bf1a45 --- /dev/null +++ b/contrib/llvm/tools/clang/www/demo/cathead.png diff --git a/contrib/llvm/tools/clang/www/demo/index.cgi b/contrib/llvm/tools/clang/www/demo/index.cgi new file mode 100644 index 0000000..b29efb6 --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/demo/syntax.css b/contrib/llvm/tools/clang/www/demo/syntax.css new file mode 100644 index 0000000..90daf5f --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/demo/what is this directory.txt b/contrib/llvm/tools/clang/www/demo/what is this directory.txt new file mode 100644 index 0000000..a1306ac --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/diagnostics.html b/contrib/llvm/tools/clang/www/diagnostics.html new file mode 100644 index 0000000..4f7d025 --- /dev/null +++ b/contrib/llvm/tools/clang/www/diagnostics.html @@ -0,0 +1,349 @@ +<!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"> +</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, and use this to print "caret diagnostics". This 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, an example is:</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: <font color="magenta">warning:</font> '.*' specified field precision is missing a matching 'int' argument + <font color="darkgreen"> printf("%.*d");</font> + <font color="blue"> ^</font> +</pre> + +<p>The caret (the blue "^" character) exactly shows where the problem is, even +inside of the 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> + +<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. For example, here's a somewhat +nonsensical example to illustrate this:</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: <font color="red">error:</font> invalid operands to binary expression ('int' and 'struct A') + <font color="darkgreen"> return y + func(y ? ((SomeA.X + 40) + SomeA) / 42 + SomeA.X : SomeA.X);</font> + <font color="blue"> ~~~~~~~~~~~~~~ ^ ~~~~~</font> +</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 cases.</p> + +<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 +caret (that this is a "binary +"). Many other examples abound, here is a simple +one:</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: <font color="red">error:</font> indirection requires pointer operand ('int' invalid) + <font color="darkgreen"> int y = *SomeA.X;</font> + <font color="blue"> ^~~~~~~~</font> +</pre> + +<p>In this 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> + +<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. This is particularly bad in G++ (which often emits errors +containing lowered vtable references), but even 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: <font color="red">error:</font> called object type 'int' is not a function or function pointer + <font color="darkgreen"> (P-Q)();</font> + <font color="blue"> ~~~~~^</font> +</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>For example, here is an example that shows where it is important to preserve +a typedef in C:</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: <font color="red">error:</font> can't convert between vector values of different size ('__m128' and 'int const *') + <font color="darkgreen"> myvec[1]/P;</font> + <font color="blue"> ~~~~~~~~^~</font> +</pre> + +<p>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. Here's an example where it +is useful for the compiler to expose underlying details of a typedef:</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: <font color="red">error:</font> member reference base type 'pid_t' (aka 'int') is not a structure or union + <font color="darkgreen"> myvar = myvar.x;</font> + <font color="blue"> ~~~~~ ^</font> +</pre> + +<p>If the user was somehow confused about how the system "pid_t" typedef is +defined, Clang helpfully displays it with "aka".</p> + +<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: <font color="red">error:</font> invalid operands to binary expression ('servers::Server const' and '::services::WebService const *') + <font color="darkgreen">server += http;</font> + <font color="blue">~~~~~~ ^ ~~~~</font> +</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: <font color="red">error:</font> incompatible type assigning 'vector<Real>', expected 'std::string' (aka 'class std::basic_string<char>') + <font color="darkgreen">str = vec</font>; + <font color="blue">^ ~~~</font> +</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. For example, here Clang warns about the use of a GCC +extension that has been considered obsolete since 1993:</p> + +<pre> + $ <b>clang t.c</b> + t.c:5:28: <font color="magenta">warning:</font> use of GNU old-style field designator extension + <font color="darkgreen">struct point origin = { x: 0.0, y: 0.0 };</font> + <font color="red">~~</font> <font color="blue">^</font> + <font color="darkgreen">.x = </font> + t.c:5:36: <font color="magenta">warning:</font> use of GNU old-style field designator extension + <font color="darkgreen">struct point origin = { x: 0.0, y: 0.0 };</font> + <font color="red">~~</font> <font color="blue">^</font> + <font color="darkgreen">.y = </font> +</pre> + +<p>The underlined code should be removed, then replaced with the code below the +caret line (".x =" or ".y =", respectively). "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 following error:</p> + +<pre> + $ <b>clang t.cpp</b> + t.cpp:9:3: <font color="red">error:</font> template specialization requires 'template<>' + struct iterator_traits<file_iterator> { + <font color="blue">^</font> + <font color="darkgreen">template<> </font> +</pre> + +<p>Again, after describing the problem, Clang provides the fix--add <code>template<></code>--as part of the diagnostic.<p> + +<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. Here's a simple example that shows how +Clang helps you out:</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: <font color="red">error:</font> invalid operands to binary expression ('typeof(P)' (aka 'struct mystruct') and 'typeof(F)' (aka 'float')) + <font color="darkgreen"> X = MYMAX(P, F);</font> + <font color="blue"> ^~~~~~~~~~~</font> + t.c:76:94: note: instantiated from: + <font color="darkgreen">#define MYMAX(A,B) __extension__ ({ __typeof__(A) __a = (A); __typeof__(B) __b = (B); __a < __b ? __b : __a; })</font> + <font color="blue"> ~~~ ^ ~~~</font> +</pre> + +<p>This shows how clang automatically prints 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. 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: <font color="magenta">warning:</font> type specifier missing, defaults to 'int' + <font color="darkgreen"> ILPAD();</font> + <font color="blue"> ^</font> + t.c:17:17: note: instantiated from: + <font color="darkgreen">#define ILPAD() PAD((NROW - tt.tt_row) * 10) /* 1 ms per char */</font> + <font color="blue"> ^</font> + t.c:14:2: note: instantiated from: + <font color="darkgreen"> register i; \</font> + <font color="blue"> ^</font> +</pre> + +<p>In practice, we've found that this 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. Three +examples are:</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: <font color="red">error:</font> expected ';' after expression + <font color="darkgreen"> bar()</font> + <font color="blue"> ^</font> + <font color="blue"> ;</font> +</pre> + +<p>This 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 caret diagnostics, because otherwise you don't get the important context. +</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: <font color="red">error:</font> unknown type name 'foo_t' + <font color="darkgreen">foo_t *P = 0;</font> + <font color="blue">^</font> +</pre> + +<p>This shows an example of much better error recovery. 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>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: <font color="red">error:</font> expected ';' after class + <font color="darkgreen">class a {}</font> + <font color="blue"> ^</font> + <font color="blue"> ;</font> + t.cc:6:2: <font color="red">error:</font> expected ';' after struct + <font color="darkgreen">}</font> + <font color="blue"> ^</font> + <font color="blue"> ;</font> +</pre> + +<p>This shows that we recover from the simple case of forgetting a ; after +a struct definition much better than GCC.</p> + +<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/contrib/llvm/tools/clang/www/distclang_status.html b/contrib/llvm/tools/clang/www/distclang_status.html new file mode 100644 index 0000000..26ba314 --- /dev/null +++ b/contrib/llvm/tools/clang/www/distclang_status.html @@ -0,0 +1,30 @@ +<!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 - Distributed Compilation Support</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>Distributed Compilation Support in Clang</h1> +<!--*************************************************************************--> + +<p> +This page tracks the status of Distributed Compilation support in Clang.<br> +Currently some basic features are working but the code is under heavy +development. </p> + + +</div> +</body> +</html> diff --git a/contrib/llvm/tools/clang/www/feature-compile1.png b/contrib/llvm/tools/clang/www/feature-compile1.png Binary files differnew file mode 100644 index 0000000..cec7c48 --- /dev/null +++ b/contrib/llvm/tools/clang/www/feature-compile1.png diff --git a/contrib/llvm/tools/clang/www/feature-compile2.png b/contrib/llvm/tools/clang/www/feature-compile2.png Binary files differnew file mode 100644 index 0000000..0eb9300 --- /dev/null +++ b/contrib/llvm/tools/clang/www/feature-compile2.png diff --git a/contrib/llvm/tools/clang/www/feature-memory1.png b/contrib/llvm/tools/clang/www/feature-memory1.png Binary files differnew file mode 100644 index 0000000..29368aa --- /dev/null +++ b/contrib/llvm/tools/clang/www/feature-memory1.png diff --git a/contrib/llvm/tools/clang/www/features.html b/contrib/llvm/tools/clang/www/features.html new file mode 100644 index 0000000..6034ae7 --- /dev/null +++ b/contrib/llvm/tools/clang/www/features.html @@ -0,0 +1,424 @@ +<!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" /> + +<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" /> + +<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" /> + +<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') + <font color="darkgreen"> return y + func(y ? ((SomeA.X + 40) + SomeA) / 42 + SomeA.X : SomeA.X);</font> + <font color="blue"> ~~~~~~~~~~~~~~ ^ ~~~~~</font> +</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> +"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."</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><a href="docs/libIndex.html">libindex</a></b> - Cross-translation-unit infrastructure and indexing 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><a name="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 indend for clang (and a LLVM as a whole) to be used for +commercial projects, and the BSD license is the simplest way to allow this. We +feel that the license encourages contributors to pick up the source and work +with it, and believe that those individuals and organizations will contribute +back their work if they do not want to have to maintain a fork forever (which is +time consuming and expensive when merges are involved). Further, nobody makes +money on compilers these days, but many people need them to get bigger goals +accomplished: it makes sense for everyone to work together.</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/contrib/llvm/tools/clang/www/get_involved.html b/contrib/llvm/tools/clang/www/get_involved.html new file mode 100644 index 0000000..a383d70 --- /dev/null +++ b/contrib/llvm/tools/clang/www/get_involved.html @@ -0,0 +1,61 @@ +<!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, bug +reports, 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.</p> + +</div> +</body> +</html> diff --git a/contrib/llvm/tools/clang/www/get_started.html b/contrib/llvm/tools/clang/www/get_started.html new file mode 100644 index 0000000..96979af --- /dev/null +++ b/contrib/llvm/tools/clang/www/get_started.html @@ -0,0 +1,275 @@ +<!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> or bring up the issue +on the +<a href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-dev">Clang development +mailing list</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:</li> + <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>Checkout Clang:</li> + <ul> + <li><tt>cd llvm/tools</tt> + <li><tt>svn co http://llvm.org/svn/llvm-project/cfe/trunk clang</tt></li> + </ul> + <li>Build LLVM and Clang:</li> + <ul> + <li><tt>cd ..</tt> (back to llvm)</li> + <li><tt>./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> + </ul> + + <p>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.</p> + + <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:</li> + <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>Try it out (assuming you add llvm/Debug/bin to your path):</li> + <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> +</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:</li> + <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 2005 or 2008</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>Checkout LLVM:</li> + <ul> + <li><tt>svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm</tt></li> + </ul> + <li>Checkout Clang:</li> + <ul> + <li><tt>cd llvm\tools</tt> + <li><tt>svn co http://llvm.org/svn/llvm-project/cfe/trunk clang</tt></li> + </ul> + <li>Run cmake to generate the Visual Studio solution and project files:</li> + <ul> + <li><tt>cd ..</tt> (Change directory back to the llvm top.)</li> + <li>If you are using Visual Studio 2005: <tt>cmake .</tt></li> + <li>Or if you are using Visual Studio 2008: <tt>cmake -G "Visual Studio 9 2008" .</tt></li> + <li>The above, if successful, will have created an LLVM.sln file in the + llvm directory. + </ul> + <li>Build Clang:</li> + <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>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> + +<a name="driver"><h2>Clang Compiler Driver (Drop-in Substitute for GCC)</h2></a> + +<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: warning: extension used +typedef float V __attribute__((vector_size(16))); + ^ +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/contrib/llvm/tools/clang/www/hacking.html b/contrib/llvm/tools/clang/www/hacking.html new file mode 100644 index 0000000..3bbc0ea --- /dev/null +++ b/contrib/llvm/tools/clang/www/hacking.html @@ -0,0 +1,270 @@ +<!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" /> +</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></li> + <ul> + <li><a href="#testingNonWindows">Testing on Unix-like Systems</a></li> + <li><a href="#testingWindows">Testing using Visual Studio on Windows</a></li> + </ul> + <li><a href="#patches">Creating Patch Files</a></li> + <li><a href="#irgen">LLVM IR Generation</a></li> + </ul> + + <!--=====================================================================--> + <h2 id="docs">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> + + <!--=====================================================================--> + <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>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> + + <ul><tt>--- Running clang tests for i686-pc-linux-gnu ---</tt></ul> + + <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> + + <tt><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></tt> + + <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. + (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>.</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>To run all the tests from the command line, execute a command like + the following:</p> + + <tt> + python (path to llvm)/llvm/utils/lit/lit.py -sv --no-progress-bar + (path to llvm)/llvm/tools/clang/test + </tt> + + <p>To run a single test:</p> + + <tt> + python (path to llvm)/llvm/utils/lit/lit.py -sv --no-progress-bar + (path to llvm)/llvm/tools/clang/test/(dir)/(test) + </tt> + + <p>For example:</p> + + <tt> + python C:/Tools/llvm/utils/lit/lit.py -sv --no-progress-bar + C:/Tools/llvm/tools/clang/test/Sema/wchar.c + </tt> + + <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>Note that a few tests currently fail on Windows. We are working to + correct this. Therefore your output might look something like this:</p> + +<tt><pre>lit.py: lit.cfg:152: note: using clang: 'C:/Tools/llvm/bin/Debug\\clang.EXE' +-- Testing: 1723 tests, 2 threads -- +FAIL: Clang::(test path) (659 of 1723) +******************** TEST 'Clang::(test path)' FAILED ******************** +Script: + (commands run) +Command Output (stdout): + (output here) +Command Output (stderr): + (output here) +******************** +Testing Time: 83.66s +******************** +Failing Tests (1): + Clang::(test path) + Expected Passes : 1704 + Expected Failures : 18 + Unexpected Failures: 1 +</pre></tt> + + <p>The last statistic, "Unexpected Failures", 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 prefered way is to send patch files to the + cfe-commits mailing list, with an explanation of what the patch is for. + Or, if you have questions, or want to have a wider discussion of what + you are doing, such as if you are new to Clang development, you can use + the cfe-dev mailing list also. + </p> + + <p>To create these patch files, change directory + to the llvm/tools/clang root and run:</p> + + <ul><tt>svn diff (relative path) >(patch file name)</tt></ul> + + <p>For example, for getting the diffs of all of clang:</p> + + <ul><tt>svn diff . >~/mypatchfile.patch</tt></ul> + + <p>For example, for getting the diffs of a single file:</p> + + <ul><tt>svn diff lib/Parse/ParseDeclCXX.cpp >~/ParseDeclCXX.patch</tt></ul> + + <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/contrib/llvm/tools/clang/www/index.html b/contrib/llvm/tools/clang/www/index.html new file mode 100644 index 0000000..9adf640 --- /dev/null +++ b/contrib/llvm/tools/clang/www/index.html @@ -0,0 +1,119 @@ +<!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 and Objective-C compiler when targetting + X86-32 and X86-64 (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's C++ support is currently alpha quality + at best, but is evolving rapidly: 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/contrib/llvm/tools/clang/www/menu.css b/contrib/llvm/tools/clang/www/menu.css new file mode 100644 index 0000000..4a887b1 --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/menu.html.incl b/contrib/llvm/tools/clang/www/menu.html.incl new file mode 100644 index 0000000..29ed3a3 --- /dev/null +++ b/contrib/llvm/tools/clang/www/menu.html.incl @@ -0,0 +1,58 @@ +<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="/docs/UsersManual.html">Users Manual</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-commit 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://t1.minormatter.com/~ddunbar/clang-cov/">Testing Coverage</a> + <a href="http://t1.minormatter.com/~ddunbar/references.html">Spec. References</a> + </div> + + <div class="submenu"> + <label>Events</label> + <a href="http://llvm.org/devmtg/2009-10/">October 2, 2009 - LLVM/Clang Developer Meeting</a> + </div> + +</div> diff --git a/contrib/llvm/tools/clang/www/performance-2008-10-31.html b/contrib/llvm/tools/clang/www/performance-2008-10-31.html new file mode 100644 index 0000000..5246ac3 --- /dev/null +++ b/contrib/llvm/tools/clang/www/performance-2008-10-31.html @@ -0,0 +1,134 @@ +<!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: +<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> +</p> + +<!--*************************************************************************--> +<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: + +<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> + +<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> +<!--=======================================================================--> + +<center><h4>Sketch</h4></center> +<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> + +<center><h4>176.gcc</h4></center> +<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/contrib/llvm/tools/clang/www/performance-2009-03-02.html b/contrib/llvm/tools/clang/www/performance-2009-03-02.html new file mode 100644 index 0000000..f76fc7a --- /dev/null +++ b/contrib/llvm/tools/clang/www/performance-2009-03-02.html @@ -0,0 +1,112 @@ +<!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: +<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> + +<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. + +<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> + +<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/contrib/llvm/tools/clang/www/performance.html b/contrib/llvm/tools/clang/www/performance.html new file mode 100644 index 0000000..2bb8fe2 --- /dev/null +++ b/contrib/llvm/tools/clang/www/performance.html @@ -0,0 +1,106 @@ +<!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: +<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> + +<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. + +<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> + +<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/contrib/llvm/tools/clang/www/timing-data/2008-10-31/176.gcc-01.txt b/contrib/llvm/tools/clang/www/timing-data/2008-10-31/176.gcc-01.txt new file mode 100644 index 0000000..3809e0d --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/timing-data/2008-10-31/176.gcc-02.txt b/contrib/llvm/tools/clang/www/timing-data/2008-10-31/176.gcc-02.txt new file mode 100644 index 0000000..dd898c1 --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/timing-data/2008-10-31/176.gcc.png b/contrib/llvm/tools/clang/www/timing-data/2008-10-31/176.gcc.png Binary files differnew file mode 100644 index 0000000..53efd87 --- /dev/null +++ b/contrib/llvm/tools/clang/www/timing-data/2008-10-31/176.gcc.png diff --git a/contrib/llvm/tools/clang/www/timing-data/2008-10-31/sketch-01.txt b/contrib/llvm/tools/clang/www/timing-data/2008-10-31/sketch-01.txt new file mode 100644 index 0000000..ff5d83e --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/timing-data/2008-10-31/sketch-02.txt b/contrib/llvm/tools/clang/www/timing-data/2008-10-31/sketch-02.txt new file mode 100644 index 0000000..88af326 --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/timing-data/2008-10-31/sketch.png b/contrib/llvm/tools/clang/www/timing-data/2008-10-31/sketch.png Binary files differnew file mode 100644 index 0000000..5ce3b11 --- /dev/null +++ b/contrib/llvm/tools/clang/www/timing-data/2008-10-31/sketch.png diff --git a/contrib/llvm/tools/clang/www/timing-data/2009-03-02/176.gcc.pdf b/contrib/llvm/tools/clang/www/timing-data/2009-03-02/176.gcc.pdf Binary files differnew file mode 100644 index 0000000..0b2e610 --- /dev/null +++ b/contrib/llvm/tools/clang/www/timing-data/2009-03-02/176.gcc.pdf diff --git a/contrib/llvm/tools/clang/www/timing-data/2009-03-02/176.gcc.png b/contrib/llvm/tools/clang/www/timing-data/2009-03-02/176.gcc.png Binary files differnew file mode 100644 index 0000000..4ae08e1 --- /dev/null +++ b/contrib/llvm/tools/clang/www/timing-data/2009-03-02/176.gcc.png diff --git a/contrib/llvm/tools/clang/www/timing-data/2009-03-02/176.gcc.txt b/contrib/llvm/tools/clang/www/timing-data/2009-03-02/176.gcc.txt new file mode 100644 index 0000000..f965e97 --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/timing-data/2009-03-02/sketch.pdf b/contrib/llvm/tools/clang/www/timing-data/2009-03-02/sketch.pdf Binary files differnew file mode 100644 index 0000000..3b98a3d --- /dev/null +++ b/contrib/llvm/tools/clang/www/timing-data/2009-03-02/sketch.pdf diff --git a/contrib/llvm/tools/clang/www/timing-data/2009-03-02/sketch.png b/contrib/llvm/tools/clang/www/timing-data/2009-03-02/sketch.png Binary files differnew file mode 100644 index 0000000..3d1bc14 --- /dev/null +++ b/contrib/llvm/tools/clang/www/timing-data/2009-03-02/sketch.png diff --git a/contrib/llvm/tools/clang/www/timing-data/2009-03-02/sketch.txt b/contrib/llvm/tools/clang/www/timing-data/2009-03-02/sketch.txt new file mode 100644 index 0000000..d2270e4 --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/timing-data/2009-06-26/176.gcc.pdf b/contrib/llvm/tools/clang/www/timing-data/2009-06-26/176.gcc.pdf Binary files differnew file mode 100644 index 0000000..50a8bc3 --- /dev/null +++ b/contrib/llvm/tools/clang/www/timing-data/2009-06-26/176.gcc.pdf diff --git a/contrib/llvm/tools/clang/www/timing-data/2009-06-26/176.gcc.png b/contrib/llvm/tools/clang/www/timing-data/2009-06-26/176.gcc.png Binary files differnew file mode 100644 index 0000000..da10f11 --- /dev/null +++ b/contrib/llvm/tools/clang/www/timing-data/2009-06-26/176.gcc.png diff --git a/contrib/llvm/tools/clang/www/timing-data/2009-06-26/176.gcc.txt b/contrib/llvm/tools/clang/www/timing-data/2009-06-26/176.gcc.txt new file mode 100644 index 0000000..e8b9c44 --- /dev/null +++ b/contrib/llvm/tools/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/contrib/llvm/tools/clang/www/timing-data/2009-06-26/sketch.pdf b/contrib/llvm/tools/clang/www/timing-data/2009-06-26/sketch.pdf Binary files differnew file mode 100644 index 0000000..0bcf4c3 --- /dev/null +++ b/contrib/llvm/tools/clang/www/timing-data/2009-06-26/sketch.pdf diff --git a/contrib/llvm/tools/clang/www/timing-data/2009-06-26/sketch.png b/contrib/llvm/tools/clang/www/timing-data/2009-06-26/sketch.png Binary files differnew file mode 100644 index 0000000..02a6321 --- /dev/null +++ b/contrib/llvm/tools/clang/www/timing-data/2009-06-26/sketch.png diff --git a/contrib/llvm/tools/clang/www/timing-data/2009-06-26/sketch.txt b/contrib/llvm/tools/clang/www/timing-data/2009-06-26/sketch.txt new file mode 100644 index 0000000..5e2331c --- /dev/null +++ b/contrib/llvm/tools/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""" |
