Diff 524033

clang-tools-extra/docs/_templates/clangd_redirect.html

	<!DOCTYPE html>			<!DOCTYPE html>
	{% set target = meta.redirect_target %}			{% set target = meta.redirect_target %}
	<html>			<html>
	<head>			<head>
	<title>The clangd documentation has moved to clangd.llvm.org</title>			<title>The clangd documentation has moved to clangd.llvm.org</title>
	<link rel="canonical" href="{{ target }}"/>			<link rel="canonical" href="{{ target }}"/>
	<meta http-equiv="refresh" content="0;url={{ target }}" />			<meta http-equiv="refresh" content="0;url={{ target }}" />
	</head>			</head>
	<body>			<body>
	<h1>The clangd documentation has moved to clangd.llvm.org</h1>			<h1>The clangd documentation has moved to clangd.llvm.org</h1>
	<a href="{{ target }}">The new site<a>			<a href="{{ target }}">The new site</a>
	<script>window.location='{{ target }}'</script>			<script>window.location='{{ target }}'</script>
	</body>			</body>
	</html>			</html>

clang/docs/LibASTMatchersReference.html

This file is larger than 256 KB, so syntax highlighting is disabled by default.

	Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
	<div id="content">			<div id="content">

	<h1>AST Matcher Reference</h1>			<h1>AST Matcher Reference</h1>

	<p>This document shows all currently implemented matchers. The matchers are grouped			<p>This document shows all currently implemented matchers. The matchers are grouped
	by category and node type they match. You can click on matcher names to show the			by category and node type they match. You can click on matcher names to show the
	matcher's source documentation.</p>			matcher's source documentation.</p>

	<p>There are three different basic categories of matchers:			<p>There are three different basic categories of matchers:</p>
	<ul>			<ul>
	<li><a href="#decl-matchers">Node Matchers:</a> Matchers that match a specific type of AST node.</li>			<li><a href="#decl-matchers">Node Matchers:</a> Matchers that match a specific type of AST node.</li>
	<li><a href="#narrowing-matchers">Narrowing Matchers:</a> Matchers that match attributes on AST nodes.</li>			<li><a href="#narrowing-matchers">Narrowing Matchers:</a> Matchers that match attributes on AST nodes.</li>
	<li><a href="#traversal-matchers">Traversal Matchers:</a> Matchers that allow traversal between AST nodes.</li>			<li><a href="#traversal-matchers">Traversal Matchers:</a> Matchers that allow traversal between AST nodes.</li>
	</ul>			</ul>
	</p>

	<p>Within each category the matchers are ordered by node type they match on.			<p>Within each category the matchers are ordered by node type they match on.
	Note that if a matcher can match multiple node types, it will appear			Note that if a matcher can match multiple node types, it will appear
	multiple times. This means that by searching for Matcher<Stmt> you can			multiple times. This means that by searching for Matcher<Stmt> you can
	find all matchers that can be used to match on Stmt nodes.</p>			find all matchers that can be used to match on Stmt nodes.</p>

	<p>The exception to that rule are matchers that can match on any node. Those			<p>The exception to that rule are matchers that can match on any node. Those
	are marked with a * and are listed in the beginning of each category.</p>			are marked with a * and are listed in the beginning of each category.</p>

	<p>Note that the categorization of matchers is a great help when you combine			<p>Note that the categorization of matchers is a great help when you combine
	them into matcher expressions. You will usually want to form matcher expressions			them into matcher expressions. You will usually want to form matcher expressions
	that read like english sentences by alternating between node matchers and			that read like english sentences by alternating between node matchers and
	narrowing or traversal matchers, like this:			narrowing or traversal matchers, like this:</p>
	<pre>			<pre>
	recordDecl(hasDescendant(			recordDecl(hasDescendant(
	ifStmt(hasTrueExpression(			ifStmt(hasTrueExpression(
	expr(hasDescendant(			expr(hasDescendant(
	ifStmt()))))))			ifStmt()))))))
	</pre>			</pre>
	</p>

	<!-- ======================================================================= -->			<!-- ======================================================================= -->
	<h2 id="traverse-mode">Traverse Mode</h2>			<h2 id="traverse-mode">Traverse Mode</h2>
	<!-- ======================================================================= -->			<!-- ======================================================================= -->

	<p>The default mode of operation of AST Matchers visits all nodes in the AST,			<p>The default mode of operation of AST Matchers visits all nodes in the AST,
	even if they are not spelled in the source. This is			even if they are not spelled in the source. This is
	<span class="mono">AsIs</span> mode. This mode requires writing AST matchers			<span class="mono">AsIs</span> mode. This mode requires writing AST matchers
	Show All 11 Lines

	<p>For these reasons, it is possible to ignore AST nodes which are not spelled			<p>For these reasons, it is possible to ignore AST nodes which are not spelled
	in the source using the <span class="mono">IgnoreUnlessSpelledInSource</span>			in the source using the <span class="mono">IgnoreUnlessSpelledInSource</span>
	mode. This is likely to be far less error-prone for users who are not already			mode. This is likely to be far less error-prone for users who are not already
	very familiar with where implicit nodes appear in the AST. It is also likely			very familiar with where implicit nodes appear in the AST. It is also likely
	to be less error-prone for experienced AST users, as difficult cases do not			to be less error-prone for experienced AST users, as difficult cases do not
	need to be encountered and matcher expressions adjusted for these cases.</p>			need to be encountered and matcher expressions adjusted for these cases.</p>

	<p>In clang-query, the mode can be changed with			<p>In clang-query, the mode can be changed with</p>
	<pre>			<pre>
	set traversal IgnoreUnlessSpelledInSource			set traversal IgnoreUnlessSpelledInSource
	</pre>			</pre>
	</p>			<p>This affects both matchers and AST dump output in results.</p>
	This affects both matchers and AST dump output in results.

	<p>When using the C++ API such as in clang-tidy checks, the			<p>When using the C++ API such as in clang-tidy checks, the
	<span class="mono">traverse()</span> matcher is used to set the mode:			<span class="mono">traverse()</span> matcher is used to set the mode:</p>
	<pre>			<pre>
	Finder->addMatcher(traverse(TK_IgnoreUnlessSpelledInSource,			Finder->addMatcher(traverse(TK_IgnoreUnlessSpelledInSource,
	returnStmt(hasReturnValue(integerLiteral(equals(0))))			returnStmt(hasReturnValue(integerLiteral(equals(0))))
	), this);			), this);
	</pre>			</pre>
	</p>
	<p>The following table compares the <span class="mono">AsIs</span> mode with			<p>The following table compares the <span class="mono">AsIs</span> mode with
	the <span class="mono">IgnoreUnlessSpelledInSource</span> mode:</p>			the <span class="mono">IgnoreUnlessSpelledInSource</span> mode:</p>

	<table class="traverse_compare">			<table class="traverse_compare">
	<tr>			<tr>
	<th></th>			<th></th>
	<th><span class="mono">AsIs</span></th>			<th><span class="mono">AsIs</span></th>
	<th><span class="mono">IgnoreUnlessSpelledInSource</span></th>			<th><span class="mono">IgnoreUnlessSpelledInSource</span></th>
	▲ Show 20 Lines • Show All 386 Lines • ▼ Show 20 Lines
	</pre>			</pre>
	given:			given:
	<pre>			<pre>
	#include <compare>			#include <compare>

	class HasSpaceship {			class HasSpaceship {
	public:			public:
	int x;			int x;
	bool operator==(const HasSpaceship&) const = default;			bool operator==(const HasSpaceship&) const = default;
	std::strong_ordering operator<=>(const HasSpaceship&) const = default;			std::strong_ordering operator<=>(const HasSpaceship&) const = default;
	};			};

	bool isLess(const HasSpaceship& a, const HasSpaceship& b) {			bool isLess(const HasSpaceship& a, const HasSpaceship& b) {
	return a < b;			return a < b;
	}			}
	</pre>			</pre>
	</td>			</td>
	<td>			<td>
	1 match found.			1 match found.

	<pre>			<pre>
	return a < b;			return a < b;
	^~~~~			^~~~~
	</pre>			</pre>

	</td>			</td>
	<td>			<td>
	No match found.			No match found.
	</td>			</td>
	</tr>			</tr>
	Show All 13 Lines

	<p>Node matchers are the only matchers that support the bind("id") call to			<p>Node matchers are the only matchers that support the bind("id") call to
	bind the matched node to the given string, to be later retrieved from the			bind the matched node to the given string, to be later retrieved from the
	match callback.</p>			match callback.</p>

	<p>It is important to remember that the arguments to node matchers are			<p>It is important to remember that the arguments to node matchers are
	predicates on the same node, just with additional information about the type.			predicates on the same node, just with additional information about the type.
	This is often useful to make matcher expression more readable by inlining bind			This is often useful to make matcher expression more readable by inlining bind
	calls into redundant node matchers inside another node matcher:			calls into redundant node matchers inside another node matcher:</p>
	<pre>			<pre>
	// This binds the CXXRecordDecl to "id", as the decl() matcher will stay on			// This binds the CXXRecordDecl to "id", as the decl() matcher will stay on
	// the same node.			// the same node.
	recordDecl(decl().bind("id"), hasName("::MyClass"))			recordDecl(decl().bind("id"), hasName("::MyClass"))
	</pre>			</pre>
	</p>

	<table>			<table>
	<tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>			<tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
	<!-- START_DECL_MATCHERS -->			<!-- START_DECL_MATCHERS -->

	<tr><td>Matcher<<a href="https://clang.llvm.org/doxygen/classclang_1_1Attr.html">Attr</a>></td><td class="name" onclick="toggle('attr0')"><a name="attr0Anchor">attr</a></td><td>Matcher<<a href="https://clang.llvm.org/doxygen/classclang_1_1Attr.html">Attr</a>>...</td></tr>			<tr><td>Matcher<<a href="https://clang.llvm.org/doxygen/classclang_1_1Attr.html">Attr</a>></td><td class="name" onclick="toggle('attr0')"><a name="attr0Anchor">attr</a></td><td>Matcher<<a href="https://clang.llvm.org/doxygen/classclang_1_1Attr.html">Attr</a>>...</td></tr>
	<tr><td colspan="4" class="doc" id="attr0"><pre>Matches attributes.			<tr><td colspan="4" class="doc" id="attr0"><pre>Matches attributes.
	Attributes may be attached with a variety of different syntaxes (including			Attributes may be attached with a variety of different syntaxes (including
	▲ Show 20 Lines • Show All 9,496 Lines • Show Last 20 Lines

clang/www/OpenProjects.html

	Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines
	of command-line options. Such file should be simple JSON / INI or anything that			of command-line options. Such file should be simple JSON / INI or anything that
	a text editor could change.</p></li>			a text editor could change.</p></li>
	</ul>			</ul>

	<p>If you hit a bug with Clang, it is very useful for us if you reduce the code			<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			that demonstrates the problem down to something small. There are many ways to
	do this; ask on <a href="https://discourse.llvm.org/c/clang">Discourse</a>,			do this; ask on <a href="https://discourse.llvm.org/c/clang">Discourse</a>,
	<a href="https://discord.com/channels/636084430946959380/636725486533345280">Discord</a>,			<a href="https://discord.com/channels/636084430946959380/636725486533345280">Discord</a>,
	or <a href="https://llvm.org/docs/GettingInvolved.html#irc"IRC</a> for advice.</p>			or <a href="https://llvm.org/docs/GettingInvolved.html#irc">IRC</a> for advice.</p>

	</div>			</div>
	</body>			</body>
	</html>			</html>

clang/www/analyzer/alpha_checks.html

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
(C, C++, ObjC)</span><div class="descr">		(C, C++, ObjC)</span><div class="descr">
Reports similar pieces of code.</div></div></a></td>		Reports similar pieces of code.</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
void log();		void log();

int max(int a, int b) { // warn		int max(int a, int b) { // warn
log();		log();
if (a > b)		if (a > b)
return a;		return a;
return b;		return b;
}		}

int maxClone(int x, int y) { // similar code here		int maxClone(int x, int y) { // similar code here
log();		log();
if (x > y)		if (x > y)
return x;		return x;
return y;		return y;
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>
</tbody></table>		</tbody></table>

<!-- ============================= core alpha ============================= -->		<!-- ============================= core alpha ============================= -->
<h3 id="core_alpha_checkers">Core Alpha Checkers</h3>		<h3 id="core_alpha_checkers">Core Alpha Checkers</h3>
Show All 18 Lines
alpha.core.CallAndMessageUnInitRefArg</span><span class="lang">		alpha.core.CallAndMessageUnInitRefArg</span><span class="lang">
(C, C++)</span><div class="descr">		(C, C++)</span><div class="descr">
Check for uninitialized arguments in function calls and Objective-C		Check for uninitialized arguments in function calls and Objective-C
message expressions.</div></div></a></td>		message expressions.</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
void test(void) {		void test(void) {
int t;		int t;
int &p = t;		int &p = t;
int &s = p;		int &s = p;
int &q = s;		int &q = s;
foo(q); // warn		foo(q); // warn
}		}
</pre></div><div class="separator"></div>		</pre></div><div class="separator"></div>
<div class="example"><pre>		<div class="example"><pre>
void test(void) {		void test(void) {
int x;		int x;
foo(&x); // warn		foo(&x); // warn
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>


<tr><td><a id="alpha.core.CastSize"><div class="namedescr expandable"><span class="name">		<tr><td><a id="alpha.core.CastSize"><div class="namedescr expandable"><span class="name">
alpha.core.CastSize</span><span class="lang">		alpha.core.CastSize</span><span class="lang">
(C)</span><div class="descr">		(C)</span><div class="descr">
Check when casting a malloc'ed type T, whether the size is a multiple of the		Check when casting a malloc'ed type T, whether the size is a multiple of the
Show All 33 Lines

<tr><td><a id="alpha.core.Conversion"><div class="namedescr expandable"><span class="name">		<tr><td><a id="alpha.core.Conversion"><div class="namedescr expandable"><span class="name">
alpha.core.Conversion</span><span class="lang">		alpha.core.Conversion</span><span class="lang">
(C, C++, ObjC)</span><div class="descr">		(C, C++, ObjC)</span><div class="descr">
Loss of sign or precision in implicit conversions</div></div></a></td>		Loss of sign or precision in implicit conversions</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
void test(unsigned U, signed S) {		void test(unsigned U, signed S) {
if (S > 10) {		if (S > 10) {
if (U < S) {		if (U < S) {
}		}
}		}
if (S < -10) {		if (S < -10) {
if (U < S) { // warn (loss of sign)		if (U < S) { // warn (loss of sign)
}		}
}		}
}		}
</pre></div><div class="separator"></div>		</pre></div><div class="separator"></div>
<div class="example"><pre>		<div class="example"><pre>
void test() {		void test() {
long long A = 1LL << 60;		long long A = 1LL << 60;
short X = A; // warn (loss of precision)		short X = A; // warn (loss of precision)
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>


<tr><td><a id="alpha.core.DynamicTypeChecker"><div class="namedescr expandable"><span class="name">		<tr><td><a id="alpha.core.DynamicTypeChecker"><div class="namedescr expandable"><span class="name">
alpha.core.DynamicTypeChecker</span><span class="lang">		alpha.core.DynamicTypeChecker</span><span class="lang">
(ObjC)</span><div class="descr">		(ObjC)</span><div class="descr">
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines


<tr><td><a id="alpha.core.StackAddressAsyncEscape"><div class="namedescr expandable"><span class="name">		<tr><td><a id="alpha.core.StackAddressAsyncEscape"><div class="namedescr expandable"><span class="name">
alpha.core.StackAddressAsyncEscape</span><span class="lang">		alpha.core.StackAddressAsyncEscape</span><span class="lang">
(C)</span><div class="descr">		(C)</span><div class="descr">
Check that addresses to stack memory do not escape the function that involves		Check that addresses to stack memory do not escape the function that involves
<code>dispatch_after</code> or <code>dispatch_async</code>. This checker is		<code>dispatch_after</code> or <code>dispatch_async</code>. This checker is
a part of core.StackAddressEscape, but is		a part of core.StackAddressEscape, but is
<a href=https://reviews.llvm.org/D41042>temporarily disabled</a> until some		<a href="https://reviews.llvm.org/D41042">temporarily disabled</a> until some
false positives are fixed.</div></div></a></td>		false positives are fixed.</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
dispatch_block_t test_block_inside_block_async_leak() {		dispatch_block_t test_block_inside_block_async_leak() {
int x = 123;		int x = 123;
void (^inner)(void) = ^void(void) {		void (^inner)(void) = ^void(void) {
int y = x;		int y = x;
++y;		++y;
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
</div></div></a></td>		</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
enum TestEnum {		enum TestEnum {
A = 0		A = 0
};		};

void foo() {		void foo() {
TestEnum t = static_cast<TestEnum>(-1);		TestEnum t = static_cast<TestEnum>(-1);
// warn: the value provided to the cast expression is not in		// warn: the value provided to the cast expression is not in
the valid range of values for the enum		the valid range of values for the enum
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>


<tr><td><a id="alpha.cplusplus.InvalidatedIterator"><div class="namedescr expandable"><span class="name">		<tr><td><a id="alpha.cplusplus.InvalidatedIterator"><div class="namedescr expandable"><span class="name">
alpha.cplusplus.InvalidatedIterator</span><span class="lang">		alpha.cplusplus.InvalidatedIterator</span><span class="lang">
(C++)</span><div class="descr">		(C++)</span><div class="descr">
Check for use of invalidated iterators.		Check for use of invalidated iterators.
</div></div></a></td>		</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
void bad_copy_assign_operator_list1(std::list<int> &L1,		void bad_copy_assign_operator_list1(std::list<int> &L1,
const std::list<int> &L2) {		const std::list<int> &L2) {
auto i0 = L1.cbegin();		auto i0 = L1.cbegin();
L1 = L2;		L1 = L2;
*i0; // warn: invalidated iterator accessed		*i0; // warn: invalidated iterator accessed
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>


<tr><td><a id="alpha.cplusplus.IteratorRange"><div class="namedescr expandable"><span class="name">		<tr><td><a id="alpha.cplusplus.IteratorRange"><div class="namedescr expandable"><span class="name">
alpha.cplusplus.IteratorRange</span><span class="lang">		alpha.cplusplus.IteratorRange</span><span class="lang">
(C++)</span><div class="descr">		(C++)</span><div class="descr">
Check for iterators used outside their valid ranges.		Check for iterators used outside their valid ranges.
</div></div></a></td>		</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
void simple_bad_end(const std::vector<int> &v) {		void simple_bad_end(const std::vector<int> &v) {
auto i = v.end();		auto i = v.end();
*i; // warn: iterator accessed outside of its range		*i; // warn: iterator accessed outside of its range
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>


<tr><td><a id="alpha.cplusplus.MismatchedIterator"><div class="namedescr expandable"><span class="name">		<tr><td><a id="alpha.cplusplus.MismatchedIterator"><div class="namedescr expandable"><span class="name">
alpha.cplusplus.MismatchedIterator</span><span class="lang">		alpha.cplusplus.MismatchedIterator</span><span class="lang">
(C++)</span><div class="descr">		(C++)</span><div class="descr">
Check for use of iterators of different containers where iterators of the same		Check for use of iterators of different containers where iterators of the same
container are expected.		container are expected.
</div></div></a></td>		</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
void bad_insert3(std::vector<int> &v1, std::vector<int> &v2) {		void bad_insert3(std::vector<int> &v1, std::vector<int> &v2) {
v2.insert(v1.cbegin(), v2.cbegin(), v2.cend()); // warn: container accessed		v2.insert(v1.cbegin(), v2.cbegin(), v2.cend()); // warn: container accessed
// using foreign		// using foreign
// iterator argument		// iterator argument
v1.insert(v1.cbegin(), v1.cbegin(), v2.cend()); // warn: iterators of		v1.insert(v1.cbegin(), v1.cbegin(), v2.cend()); // warn: iterators of
// different containers		// different containers
// used where the same		// used where the same
// container is		// container is
// expected		// expected
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines	int test() {
return x; // warn		return x; // warn
}		}
</pre></div><div class="separator"></div>		</pre></div><div class="separator"></div>
<div class="example"><pre>		<div class="example"><pre>
// C++		// C++
void test() {		void test() {
int a = 2;		int a = 2;

while (a > 1)		while (a > 1)
a--;		a--;

if (a > 1)		if (a > 1)
a++; // warn		a++; // warn
}		}
</pre></div><div class="separator"></div>		</pre></div><div class="separator"></div>
<div class="example"><pre>		<div class="example"><pre>
// Objective-C		// Objective-C
void test(id x) {		void test(id x) {
return;		return;
[x retain]; // warn		[x retain]; // warn
▲ Show 20 Lines • Show All 141 Lines • ▼ Show 20 Lines
<div class="example"><pre>		<div class="example"><pre>
NSString *reminderText =		NSString *reminderText =
NSLocalizedString(@"None", @"Indicates no reminders");		NSLocalizedString(@"None", @"Indicates no reminders");
if (reminderCount == 1) {		if (reminderCount == 1) {
// Warning: Plural cases are not supported across all languages.		// Warning: Plural cases are not supported across all languages.
// Use a .stringsdict file instead		// Use a .stringsdict file instead
reminderText =		reminderText =
NSLocalizedString(@"1 Reminder", @"Indicates single reminder");		NSLocalizedString(@"1 Reminder", @"Indicates single reminder");
} else if (reminderCount >= 2) {		} else if (reminderCount >= 2) {
// Warning: Plural cases are not supported across all languages.		// Warning: Plural cases are not supported across all languages.
// Use a .stringsdict file instead		// Use a .stringsdict file instead
reminderText =		reminderText =
[NSString stringWithFormat:		[NSString stringWithFormat:
NSLocalizedString(@"%@ Reminders", @"Indicates multiple reminders"),		NSLocalizedString(@"%@ Reminders", @"Indicates multiple reminders"),
reminderCount];		reminderCount];
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>
Show All 20 Lines
</pre></div><div class="separator"></div>		</pre></div><div class="separator"></div>
<div class="example"><pre>		<div class="example"><pre>
struct seven_words {		struct seven_words {
int c[7];		int c[7];
};		};

void test() {		void test() {
struct seven_words a, *p;		struct seven_words a, *p;
p = &a;		p = &a;
p[0] = a;		p[0] = a;
p[1] = a;		p[1] = a;
p[2] = a; // warn		p[2] = a; // warn
}		}
</pre></div><div class="separator"></div>		</pre></div><div class="separator"></div>
<div class="example"><pre>		<div class="example"><pre>
// note: requires unix.Malloc or		// note: requires unix.Malloc or
// alpha.unix.MallocWithAnnotations checks enabled.		// alpha.unix.MallocWithAnnotations checks enabled.
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	void test(int n) {
void p = malloc(n sizeof(int)); // warn		void p = malloc(n sizeof(int)); // warn
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>


<tr><td><a id="alpha.security.MmapWriteExec"><div class="namedescr expandable"><span class="name">		<tr><td><a id="alpha.security.MmapWriteExec"><div class="namedescr expandable"><span class="name">
alpha.security.MmapWriteExec</span><span class="lang">		alpha.security.MmapWriteExec</span><span class="lang">
(C)</span><div class="descr">		(C)</span><div class="descr">
Warn on <code>mmap()<code> calls that are both writable and executable.		Warn on <code>mmap()</code> calls that are both writable and executable.
</div></div></a></td>		</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
void test(int n) {		void test(int n) {
void *c = mmap(NULL, 32, PROT_READ \| PROT_WRITE \| PROT_EXEC,		void *c = mmap(NULL, 32, PROT_READ \| PROT_WRITE \| PROT_EXEC,
MAP_PRIVATE \| MAP_ANON, -1, 0);		MAP_PRIVATE \| MAP_ANON, -1, 0);
// warn: Both PROT_WRITE and PROT_EXEC flags are set. This can lead to		// warn: Both PROT_WRITE and PROT_EXEC flags are set. This can lead to
// exploitable memory regions, which could be overwritten with malicious		// exploitable memory regions, which could be overwritten with malicious
Show All 26 Lines
<tr><td><a id="alpha.security.taint.TaintPropagation"><div class="namedescr expandable"><span class="name">		<tr><td><a id="alpha.security.taint.TaintPropagation"><div class="namedescr expandable"><span class="name">
alpha.security.taint.TaintPropagation</span><span class="lang">		alpha.security.taint.TaintPropagation</span><span class="lang">
(C)</span><div class="descr">		(C)</span><div class="descr">
Generate taint information used by other checkers.</div></div></a></td>		Generate taint information used by other checkers.</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
void test() {		void test() {
char x = getchar(); // 'x' marked as tainted		char x = getchar(); // 'x' marked as tainted
system(&x); // warn: untrusted data is passed to a system call		system(&x); // warn: untrusted data is passed to a system call
}		}
</pre></div><div class="separator"></div>		</pre></div><div class="separator"></div>
<div class="example"><pre>		<div class="example"><pre>
// note: compiler internally checks if the second param to		// note: compiler internally checks if the second param to
// sprintf is a string literal or not.		// sprintf is a string literal or not.
// Use -Wno-format-security to suppress compiler warning.		// Use -Wno-format-security to suppress compiler warning.
void test() {		void test() {
char s[10], buf[10];		char s[10], buf[10];
fscanf(stdin, "%s", s); // 's' marked as tainted		fscanf(stdin, "%s", s); // 's' marked as tainted

sprintf(buf, s); // warn: untrusted data as a format string		sprintf(buf, s); // warn: untrusted data as a format string
}		}
</pre></div><div class="separator"></div>		</pre></div><div class="separator"></div>
<div class="example"><pre>		<div class="example"><pre>
void test() {		void test() {
size_t ts;		size_t ts;
scanf("%zd", &ts); // 'ts' marked as tainted		scanf("%zd", &ts); // 'ts' marked as tainted
int p = (int )malloc(ts * sizeof(int));		int p = (int )malloc(ts * sizeof(int));
// warn: untrusted data as buffer size		// warn: untrusted data as buffer size
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>

</tbody></table>		</tbody></table>

<!-- ============================= unix alpha ============================= -->		<!-- ============================= unix alpha ============================= -->
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines	void test() {
f(); // warn: no call of chdir("/") immediately after chroot		f(); // warn: no call of chdir("/") immediately after chroot
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>


<tr><td><a id="alpha.unix.PthreadLock"><div class="namedescr expandable"><span class="name">		<tr><td><a id="alpha.unix.PthreadLock"><div class="namedescr expandable"><span class="name">
alpha.unix.PthreadLock</span><span class="lang">		alpha.unix.PthreadLock</span><span class="lang">
(C)</span><div class="descr">		(C)</span><div class="descr">
Simple lock -> unlock checker; applies to:<div class=functions>		Simple lock -> unlock checker; applies to:<div class=functions>
pthread_mutex_lock<br>		pthread_mutex_lock<br>
pthread_rwlock_rdlock<br>		pthread_rwlock_rdlock<br>
pthread_rwlock_wrlock<br>		pthread_rwlock_wrlock<br>
lck_mtx_lock<br>		lck_mtx_lock<br>
lck_rw_lock_exclusive<br>		lck_rw_lock_exclusive<br>
lck_rw_lock_shared<br>		lck_rw_lock_shared<br>
pthread_mutex_trylock<br>		pthread_mutex_trylock<br>
pthread_rwlock_tryrdlock<br>		pthread_rwlock_tryrdlock<br>
pthread_rwlock_tryrwlock<br>		pthread_rwlock_tryrwlock<br>
lck_mtx_try_lock<br>		lck_mtx_try_lock<br>
lck_rw_try_lock_exclusive<br>		lck_rw_try_lock_exclusive<br>
lck_rw_try_lock_shared<br>		lck_rw_try_lock_shared<br>
pthread_mutex_unlock<br>		pthread_mutex_unlock<br>
pthread_rwlock_unlock<br>		pthread_rwlock_unlock<br>
lck_mtx_unlock<br>		lck_mtx_unlock<br>
lck_rw_done</div></div></div></a></td>		lck_rw_done</div></div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
pthread_mutex_t mtx;		pthread_mutex_t mtx;

void test() {		void test() {
pthread_mutex_lock(&mtx);		pthread_mutex_lock(&mtx);
pthread_mutex_lock(&mtx);		pthread_mutex_lock(&mtx);
// warn: this lock has already been acquired		// warn: this lock has already been acquired
}		}
</pre></div><div class="separator"></div>		</pre></div><div class="separator"></div>
<div class="example"><pre>		<div class="example"><pre>
lck_mtx_t lck1, lck2;		lck_mtx_t lck1, lck2;

void test() {		void test() {
lck_mtx_lock(&lck1);		lck_mtx_lock(&lck1);
lck_mtx_lock(&lck2);		lck_mtx_lock(&lck2);
lck_mtx_unlock(&lck1);		lck_mtx_unlock(&lck1);
// warn: this was not the most recently acquired lock		// warn: this was not the most recently acquired lock
}		}
</pre></div><div class="separator"></div>		</pre></div><div class="separator"></div>
<div class="example"><pre>		<div class="example"><pre>
lck_mtx_t lck1, lck2;		lck_mtx_t lck1, lck2;

void test() {		void test() {
if (lck_mtx_try_lock(&lck1) == 0)		if (lck_mtx_try_lock(&lck1) == 0)
return;		return;

lck_mtx_lock(&lck2);		lck_mtx_lock(&lck2);
lck_mtx_unlock(&lck1);		lck_mtx_unlock(&lck1);
// warn: this was not the most recently acquired lock		// warn: this was not the most recently acquired lock
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>


<tr><td><a id="alpha.unix.SimpleStream"><div class="namedescr expandable"><span class="name">		<tr><td><a id="alpha.unix.SimpleStream"><div class="namedescr expandable"><span class="name">
alpha.unix.SimpleStream</span><span class="lang">		alpha.unix.SimpleStream</span><span class="lang">
(C)</span><div class="descr">		(C)</span><div class="descr">
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>


<tr><td><a id="alpha.unix.cstring.NotNullTerminated"><div class="namedescr expandable"><span class="name">		<tr><td><a id="alpha.unix.cstring.NotNullTerminated"><div class="namedescr expandable"><span class="name">
alpha.unix.cstring.NotNullTerminated</span><span class="lang">		alpha.unix.cstring.NotNullTerminated</span><span class="lang">
(C)</span><div class="descr">		(C)</span><div class="descr">
Check for arguments which are not null-terminated strings; applies		Check for arguments which are not null-terminated strings; applies
to:<div class=functions>		to:<div class="functions">
strlen<br>		strlen<br>
strnlen<br>		strnlen<br>
strcpy<br>		strcpy<br>
strncpy<br>		strncpy<br>
strcat<br>		strcat<br>
strncat</div></div></div></td>		strncat</div></div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
void test() {		void test() {
int y = strlen((char *)&test); // warn		int y = strlen((char *)&test); // warn
}		}
</pre></div></div></a></td></tr>		</pre></div></div></td></tr>


<tr><td><a id="alpha.unix.cstring.OutOfBounds"><div class="namedescr expandable"><span class="name">		<tr><td><a id="alpha.unix.cstring.OutOfBounds"><div class="namedescr expandable"><span class="name">
alpha.unix.cstring.OutOfBounds</span><span class="lang">		alpha.unix.cstring.OutOfBounds</span><span class="lang">
(C)</span><div class="descr">		(C)</span><div class="descr">
Check for out-of-bounds access in string functions; applies		Check for out-of-bounds access in string functions; applies
to:<div class=functions>		to:<div class=functions>
strncopy<br>		strncopy<br>
Show All 20 Lines
alpha.nondeterminism.PointerIteration</span><span class="lang">		alpha.nondeterminism.PointerIteration</span><span class="lang">
(C++)</span><div class="descr">		(C++)</span><div class="descr">
Check for non-determinism caused by iterating unordered containers of pointers.</div></div></a></td>		Check for non-determinism caused by iterating unordered containers of pointers.</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
// C++		// C++
void test() {		void test() {
int a = 1, b = 2;		int a = 1, b = 2;
std::unordered_set<int *> UnorderedPtrSet = {&a, &b};		std::unordered_set<int *> UnorderedPtrSet = {&a, &b};

for (auto i : UnorderedPtrSet) // warn		for (auto i : UnorderedPtrSet) // warn
f(i);		f(i);
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>
<tr><td><a id="alpha.nondeterminism.PointerSorting"><div class="namedescr expandable"><span class="name">		<tr><td><a id="alpha.nondeterminism.PointerSorting"><div class="namedescr expandable"><span class="name">
alpha.nondeterminism.PointerSorting</span><span class="lang">		alpha.nondeterminism.PointerSorting</span><span class="lang">
(C++)</span><div class="descr">		(C++)</span><div class="descr">
Check for non-determinism caused by sorting of pointers.</div></div></a></td>		Check for non-determinism caused by sorting of pointers.</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
// C++		// C++
void test() {		void test() {
int a = 1, b = 2;		int a = 1, b = 2;
std::vector<int *> V = {&a, &b};		std::vector<int *> V = {&a, &b};
std::sort(V.begin(), V.end()); // warn		std::sort(V.begin(), V.end()); // warn
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>
</tbody></table>		</tbody></table>

</div> <!-- page -->		</div> <!-- page -->
</div> <!-- content -->		</div> <!-- content -->
</body>		</body>
</html>		</html>

clang/www/analyzer/available_checks.html

Show First 20 Lines • Show All 212 Lines • ▼ Show 20 Lines
// C++		// C++
class C {		class C {
public:		public:
int x;		int x;
};		};

void test() {		void test() {
C *pc = 0;		C *pc = 0;
int k = pc->x; // warn		int k = pc->x; // warn
}		}
</pre></div>		</pre></div>
<div class="example"><pre>		<div class="example"><pre>
// Objective-C		// Objective-C
@interface MyClass {		@interface MyClass {
@public		@public
int x;		int x;
}		}
▲ Show 20 Lines • Show All 253 Lines • ▼ Show 20 Lines
nullability.NullReturnedFromNonnull</span><span class="lang">		nullability.NullReturnedFromNonnull</span><span class="lang">
(ObjC)</span><div class="descr">		(ObjC)</span><div class="descr">
Warns when a null pointer is returned from a function that has		Warns when a null pointer is returned from a function that has
_Nonnull return type.</div></div></a></td>		_Nonnull return type.</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
- (nonnull id)firstChild {		- (nonnull id)firstChild {
id result = nil;		id result = nil;
if ([_children count] > 0)		if ([_children count] > 0)
result = _children[0];		result = _children[0];

// Warning: nil returned from a method that is expected		// Warning: nil returned from a method that is expected
// to return a non-null value		// to return a non-null value
return result;		return result;
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>

Show All 9 Lines	struct LinkedList {
struct LinkedList *next;		struct LinkedList *next;
};		};

struct LinkedList * _Nullable getNext(struct LinkedList *l);		struct LinkedList * _Nullable getNext(struct LinkedList *l);

void updateNextData(struct LinkedList *list, int newData) {		void updateNextData(struct LinkedList *list, int newData) {
struct LinkedList *next = getNext(list);		struct LinkedList *next = getNext(list);
// Warning: Nullable pointer is dereferenced		// Warning: Nullable pointer is dereferenced
next->data = 7;		next->data = 7;
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>


<tr><td><a id="nullability.NullablePassedToNonnull"><div class="namedescr expandable"><span class="name">		<tr><td><a id="nullability.NullablePassedToNonnull"><div class="namedescr expandable"><span class="name">
nullability.NullablePassedToNonnull</span><span class="lang">		nullability.NullablePassedToNonnull</span><span class="lang">
(ObjC)</span><div class="descr">		(ObjC)</span><div class="descr">
Warns when a nullable pointer is passed to a pointer which has a _Nonnull type.</div></div></a></td>		Warns when a nullable pointer is passed to a pointer which has a _Nonnull type.</div></div></a></td>
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines	<ul>
</li>		</li>
</ul></div></div></a></td>		</ul></div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
// With Pedantic and CheckPointeeInitialization set to true		// With Pedantic and CheckPointeeInitialization set to true

struct A {		struct A {
struct B {		struct B {
int x; // note: uninitialized field 'this->b.x'		int x; // note: uninitialized field 'this->b.x'
// note: uninitialized field 'this->bptr->x'		// note: uninitialized field 'this->bptr->x'
int y; // note: uninitialized field 'this->b.y'		int y; // note: uninitialized field 'this->b.y'
// note: uninitialized field 'this->bptr->y'		// note: uninitialized field 'this->bptr->y'
};		};
int *iptr; // note: uninitialized pointer 'this->iptr'		int *iptr; // note: uninitialized pointer 'this->iptr'
B b;		B b;
B *bptr;		B *bptr;
char *cptr; // note: uninitialized pointee 'this->cptr'		char *cptr; // note: uninitialized pointee 'this->cptr'

A (B bptr, char cptr) : bptr(bptr), cptr(cptr) {}		A (B bptr, char cptr) : bptr(bptr), cptr(cptr) {}
};		};

void f() {		void f() {
A::B b;		A::B b;
char c;		char c;
A a(&b, &c); // warning: 6 uninitialized fields		A a(&b, &c); // warning: 6 uninitialized fields
// after the constructor call		// after the constructor call
}		}
</pre></div><div class="separator"></div>		</pre></div><div class="separator"></div>
<div class="example"><pre>		<div class="example"><pre>
// With Pedantic set to false and		// With Pedantic set to false and
// CheckPointeeInitialization set to true		// CheckPointeeInitialization set to true
// (every field is uninitialized)		// (every field is uninitialized)

struct A {		struct A {
struct B {		struct B {
int x;		int x;
int y;		int y;
};		};
int *iptr;		int *iptr;
B b;		B b;
B *bptr;		B *bptr;
char *cptr;		char *cptr;

A (B bptr, char cptr) : bptr(bptr), cptr(cptr) {}		A (B bptr, char cptr) : bptr(bptr), cptr(cptr) {}
};		};

void f() {		void f() {
A::B b;		A::B b;
char c;		char c;
A a(&b, &c); // no warning		A a(&b, &c); // no warning
}		}
</pre></div><div class="separator"></div>		</pre></div><div class="separator"></div>
<div class="example"><pre>		<div class="example"><pre>
// With Pedantic and CheckPointeeInitialization set to false		// With Pedantic and CheckPointeeInitialization set to false
// (pointees are regarded as initialized)		// (pointees are regarded as initialized)

struct A {		struct A {
struct B {		struct B {
int x; // note: uninitialized field 'this->b.x'		int x; // note: uninitialized field 'this->b.x'
int y; // note: uninitialized field 'this->b.y'		int y; // note: uninitialized field 'this->b.y'
};		};
int *iptr; // note: uninitialized pointer 'this->iptr'		int *iptr; // note: uninitialized pointer 'this->iptr'
B b;		B b;
B *bptr;		B *bptr;
char *cptr;		char *cptr;

A (B bptr, char cptr) : bptr(bptr), cptr(cptr) {}		A (B bptr, char cptr) : bptr(bptr), cptr(cptr) {}
};		};

void f() {		void f() {
A::B b;		A::B b;
char c;		char c;
A a(&b, &c); // warning: 3 uninitialized fields		A a(&b, &c); // warning: 3 uninitialized fields
// after the constructor call		// after the constructor call
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>


<tbody>		<tbody>
<tr><td><a id="optin.cplusplus.VirtualCall"><div class="namedescr expandable"><span class="name">		<tr><td><a id="optin.cplusplus.VirtualCall"><div class="namedescr expandable"><span class="name">
optin.cplusplus.VirtualCall</span><span class="lang">		optin.cplusplus.VirtualCall</span><span class="lang">
Show All 25 Lines
optin.mpi.MPI-Checker</span><span class="lang">		optin.mpi.MPI-Checker</span><span class="lang">
(C)</span><div class="descr">		(C)</span><div class="descr">
Checks MPI code</div></div></a></td>		Checks MPI code</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
void test() {		void test() {
double buf = 0;		double buf = 0;
MPI_Request sendReq1;		MPI_Request sendReq1;
MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM,		MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM,
0, MPI_COMM_WORLD, &sendReq1);		0, MPI_COMM_WORLD, &sendReq1);
} // warn: request 'sendReq1' has no matching wait.		} // warn: request 'sendReq1' has no matching wait.
</pre></div><div class="separator"></div>		</pre></div><div class="separator"></div>
<div class="example"><pre>		<div class="example"><pre>
void test() {		void test() {
double buf = 0;		double buf = 0;
MPI_Request sendReq;		MPI_Request sendReq;
MPI_Isend(&buf, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &sendReq);		MPI_Isend(&buf, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &sendReq);
MPI_Irecv(&buf, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &sendReq); // warn		MPI_Irecv(&buf, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &sendReq); // warn
MPI_Isend(&buf, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &sendReq); // warn		MPI_Isend(&buf, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &sendReq); // warn
MPI_Wait(&sendReq, MPI_STATUS_IGNORE);		MPI_Wait(&sendReq, MPI_STATUS_IGNORE);
}		}
</pre></div><div class="separator"></div>		</pre></div><div class="separator"></div>
<div class="example"><pre>		<div class="example"><pre>
void missingNonBlocking() {		void missingNonBlocking() {
int rank = 0;		int rank = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);		MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Request sendReq1[10][10][10];		MPI_Request sendReq1[10][10][10];
MPI_Wait(&sendReq1[1][7][9], MPI_STATUS_IGNORE); // warn		MPI_Wait(&sendReq1[1][7][9], MPI_STATUS_IGNORE); // warn
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>


<tr><td><a id="optin.osx.cocoa.localizability.EmptyLocalizationContextChecker"><div class="namedescr expandable"><span class="name">		<tr><td><a id="optin.osx.cocoa.localizability.EmptyLocalizationContextChecker"><div class="namedescr expandable"><span class="name">
optin.osx.cocoa.localizability.EmptyLocalizationContextChecker</span><span class="lang">		optin.osx.cocoa.localizability.EmptyLocalizationContextChecker</span><span class="lang">
(ObjC)</span><div class="descr">		(ObjC)</span><div class="descr">
Check that NSLocalizedString macros include a comment for context.</div></div></a></td>		Check that NSLocalizedString macros include a comment for context.</div></div></a></td>
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
(C, C++, ObjC)</span><div class="descr">		(C, C++, ObjC)</span><div class="descr">
Check for erroneous conversions of objects representing numbers		Check for erroneous conversions of objects representing numbers
into numbers</div></div></a></td>		into numbers</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
NSNumber *photoCount = [albumDescriptor objectForKey:@"PhotoCount"];		NSNumber *photoCount = [albumDescriptor objectForKey:@"PhotoCount"];
// Warning: Comparing a pointer value of type 'NSNumber *'		// Warning: Comparing a pointer value of type 'NSNumber *'
// to a scalar integer value		// to a scalar integer value
if (photoCount > 0) {		if (photoCount > 0) {
[self displayPhotos];		[self displayPhotos];
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>


<tr><td><a id="osx.SecKeychainAPI"><div class="namedescr expandable"><span class="name">		<tr><td><a id="osx.SecKeychainAPI"><div class="namedescr expandable"><span class="name">
osx.SecKeychainAPI</span><span class="lang">		osx.SecKeychainAPI</span><span class="lang">
(C)</span><div class="descr">		(C)</span><div class="descr">
▲ Show 20 Lines • Show All 277 Lines • ▼ Show 20 Lines


<tr><td><a id="osx.cocoa.ObjCGenerics"><div class="namedescr expandable"><span class="name">		<tr><td><a id="osx.cocoa.ObjCGenerics"><div class="namedescr expandable"><span class="name">
osx.cocoa.ObjCGenerics</span><span class="lang">		osx.cocoa.ObjCGenerics</span><span class="lang">
(ObjC)</span><div class="descr">		(ObjC)</span><div class="descr">
Check for type errors when using Objective-C generics</div></div></a></td>		Check for type errors when using Objective-C generics</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
NSMutableArray<NSString > names = [NSMutableArray array];		NSMutableArray<NSString > names = [NSMutableArray array];
NSMutableArray *birthDates = names;		NSMutableArray *birthDates = names;

// Warning: Conversion from value of type 'NSDate *'		// Warning: Conversion from value of type 'NSDate *'
// to incompatible type 'NSString *'		// to incompatible type 'NSString *'
[birthDates addObject: [NSDate date]];		[birthDates addObject: [NSDate date]];
</pre></div></div></td></tr>		</pre></div></div></td></tr>


▲ Show 20 Lines • Show All 364 Lines • ▼ Show 20 Lines
Warn on uses of the <code>-[NSCoder decodeValueOfObjCType:at:]</code> method.		Warn on uses of the <code>-[NSCoder decodeValueOfObjCType:at:]</code> method.
The safe alternative is <code>-[NSCoder decodeValueOfObjCType:at:size:]</code>.</div></div></a></td>		The safe alternative is <code>-[NSCoder decodeValueOfObjCType:at:size:]</code>.</div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
void test(NSCoder *decoder) {		void test(NSCoder *decoder) {
// This would be a vulnerability on 64-bit platforms		// This would be a vulnerability on 64-bit platforms
// but not on 32-bit platforms.		// but not on 32-bit platforms.
NSUInteger x;		NSUInteger x;
[decoder decodeValueOfObjCType:"I" at:&x]; // warn		[decoder decodeValueOfObjCType:"I" at:&x]; // warn
}		}
</pre></div></div></td></tr>		</pre></div></div></td></tr>

</tbody></table>		</tbody></table>

<!-- =========================== unix =========================== -->		<!-- =========================== unix =========================== -->
<h3 id="unix_checkers">Unix Checkers</h3>		<h3 id="unix_checkers">Unix Checkers</h3>
<table class="checkers">		<table class="checkers">
<colgroup><col class="namedescr"><col class="example"></colgroup>		<colgroup><col class="namedescr"><col class="example"></colgroup>
<thead><tr><td>Name, Description</td><td>Example</td></tr></thead>		<thead><tr><td>Name, Description</td><td>Example</td></tr></thead>

<tbody>		<tbody>
<tr><td><a id="unix.API"><div class="namedescr expandable"><span class="name">		<tr><td><a id="unix.API"><div class="namedescr expandable"><span class="name">
unix.API</span><span class="lang">		unix.API</span><span class="lang">
(C)</span><div class="descr">		(C)</span><div class="descr">
Check calls to various UNIX/POSIX functions:<div class=functions>		Check calls to various UNIX/POSIX functions:<div class=functions>
open<br>		open<br>
pthread_once<br>		pthread_once<br>
calloc<br>		calloc<br>
malloc<br>		malloc<br>
realloc<br>		realloc<br>
alloca<br></a></td>		alloca<br></div></div></div></a></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
// Currently the check is performed for apple targets only.		// Currently the check is performed for apple targets only.
void test(const char *path) {		void test(const char *path) {
int fd = open(path, O_CREAT);		int fd = open(path, O_CREAT);
// warn: call to 'open' requires a third argument when the		// warn: call to 'open' requires a third argument when the
// 'O_CREAT' flag is set		// 'O_CREAT' flag is set
}		}
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines

clang/www/analyzer/checker_dev_manual.html

Show First 20 Lines • Show All 177 Lines • ▼ Show 20 Lines	<h2 id=analyzer>Static Analyzer Overview</h2>
is for. It is a <tt>MemRegion</tt> that has an associated symbol. Since the		is for. It is a <tt>MemRegion</tt> that has an associated symbol. Since the
symbol is unique and has a unique name; that symbol names the region.		symbol is unique and has a unique name; that symbol names the region.
</p>		</p>

<p>		<p>
Let's see how the analyzer processes the expressions in the following example:		Let's see how the analyzer processes the expressions in the following example:
</p>		</p>

<p>
<pre class="code_example">		<pre class="code_example">
int foo(int x) {		int foo(int x) {
int y = x * 2;		int y = x * 2;
int z = x;		int z = x;
...		...
}		}
</pre>		</pre>
</p>

<p>		<p>
Let's look at how <tt>x*2</tt> gets evaluated. When <tt>x</tt> is evaluated,		Let's look at how <tt>x*2</tt> gets evaluated. When <tt>x</tt> is evaluated,
we first construct an <tt>SVal</tt> that represents the lvalue of <tt>x</tt>, in		we first construct an <tt>SVal</tt> that represents the lvalue of <tt>x</tt>, in
this case it is an <tt>SVal</tt> that references the <tt>MemRegion</tt> for <tt>x</tt>.		this case it is an <tt>SVal</tt> that references the <tt>MemRegion</tt> for <tt>x</tt>.
Afterwards, when we do the lvalue-to-rvalue conversion, we get a new <tt>SVal</tt>,		Afterwards, when we do the lvalue-to-rvalue conversion, we get a new <tt>SVal</tt>,
which references the value <b>currently bound</b> to <tt>x</tt>. That value is		which references the value <b>currently bound</b> to <tt>x</tt>. That value is
symbolic; it's whatever <tt>x</tt> was bound to at the start of the function.		symbolic; it's whatever <tt>x</tt> was bound to at the start of the function.
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines	<h2 id=registration>Checker Registration</h2>
stream APIs, was registered with the analyzer.		stream APIs, was registered with the analyzer.
Similar steps should be followed for a new checker.		Similar steps should be followed for a new checker.
<ol>		<ol>
<li>A new checker implementation file, <tt>SimpleStreamChecker.cpp</tt>, was		<li>A new checker implementation file, <tt>SimpleStreamChecker.cpp</tt>, was
created in the directory <tt>lib/StaticAnalyzer/Checkers</tt>.		created in the directory <tt>lib/StaticAnalyzer/Checkers</tt>.
<li>The following registration code was added to the implementation file:		<li>The following registration code was added to the implementation file:
<pre class="code_example">		<pre class="code_example">
void ento::registerSimpleStreamChecker(CheckerManager &mgr) {		void ento::registerSimpleStreamChecker(CheckerManager &mgr) {
mgr.registerChecker<SimpleStreamChecker&gt();		mgr.registerChecker<SimpleStreamChecker>();
}		}
</pre>		</pre>
<li>A package was selected for the checker and the checker was defined in the		<li>A package was selected for the checker and the checker was defined in the
table of checkers at <tt>include/clang/StaticAnalyzer/Checkers/Checkers.td</tt>.		table of checkers at <tt>include/clang/StaticAnalyzer/Checkers/Checkers.td</tt>.
Since all checkers should first be developed as "alpha", and the SimpleStreamChecker		Since all checkers should first be developed as "alpha", and the SimpleStreamChecker
performs UNIX API checks, the correct package is "alpha.unix", and the following		performs UNIX API checks, the correct package is "alpha.unix", and the following
was added to the corresponding <tt>UnixAlpha</tt> section of <tt>Checkers.td</tt>:		was added to the corresponding <tt>UnixAlpha</tt> section of <tt>Checkers.td</tt>:
<pre class="code_example">		<pre class="code_example">
let ParentPackage = UnixAlpha in {		let ParentPackage = UnixAlpha in {
...		...
def SimpleStreamChecker : Checker<"SimpleStream">,		def SimpleStreamChecker : Checker<"SimpleStream">,
HelpText<"Check for misuses of stream APIs">,		HelpText<"Check for misuses of stream APIs">,
DescFile<"SimpleStreamChecker.cpp">;		DescFile<"SimpleStreamChecker.cpp">;
...		...
} // end "alpha.unix"		} // end "alpha.unix"
</pre>		</pre>

<li>The source code file was made visible to CMake by adding it to		<li>The source code file was made visible to CMake by adding it to
<tt>lib/StaticAnalyzer/Checkers/CMakeLists.txt</tt>.		<tt>lib/StaticAnalyzer/Checkers/CMakeLists.txt</tt>.

</ol>		</ol>
▲ Show 20 Lines • Show All 399 Lines • ▼ Show 20 Lines
<li>Use safe and convenient APIs!</li>		<li>Use safe and convenient APIs!</li>
<ul>		<ul>
<li>Always use <tt>CheckerContext::generateErrorNode</tt> and		<li>Always use <tt>CheckerContext::generateErrorNode</tt> and
<tt>CheckerContext::generateNonFatalErrorNode</tt> for emitting bug reports.		<tt>CheckerContext::generateNonFatalErrorNode</tt> for emitting bug reports.
Most importantly, never emit report against <tt>CheckerContext::getPredecessor</tt>.</li>		Most importantly, never emit report against <tt>CheckerContext::getPredecessor</tt>.</li>
<li>Prefer <tt>checkPreCall</tt> and <tt>checkPostCall</tt> to		<li>Prefer <tt>checkPreCall</tt> and <tt>checkPostCall</tt> to
<tt>checkPreStmt<CallExpr></tt> and <tt>checkPostStmt<CallExpr></tt>.</li>		<tt>checkPreStmt<CallExpr></tt> and <tt>checkPostStmt<CallExpr></tt>.</li>
<li>Use <tt>CallDescription</tt> to detect hardcoded API calls in the program.</li>		<li>Use <tt>CallDescription</tt> to detect hardcoded API calls in the program.</li>
<li>Simplify <tt>C.getState()->getSVal(E, C.getLocationContext())</tt> to <tt>C.getSVal(E)</tt>.</li>		<li>Simplify <tt>C.getState()->getSVal(E, C.getLocationContext())</tt> to <tt>C.getSVal(E)</tt>.</li>
</ul>		</ul>
<li>Common sources of crashes:</li>		<li>Common sources of crashes:</li>
<ul>		<ul>
<li><tt>CallEvent::getOriginExpr</tt> is nullable - for example, it returns null for an		<li><tt>CallEvent::getOriginExpr</tt> is nullable - for example, it returns null for an
automatic destructor of a variable. The same applies to some values generated while the		automatic destructor of a variable. The same applies to some values generated while the
call was modeled, eg. <tt>SymbolConjured::getStmt</tt> is nullable.</li>		call was modeled, eg. <tt>SymbolConjured::getStmt</tt> is nullable.</li>
<li><tt>CallEvent::getDecl</tt> is nullable - for example, it returns null for a		<li><tt>CallEvent::getDecl</tt> is nullable - for example, it returns null for a
call of symbolic function pointer.</li>		call of symbolic function pointer.</li>
Show All 14 Lines	<li>Is <tt>-analyzer-checker=core</tt> included in all test <tt>RUN:</tt> lines? It was never supported
crashes. You should do all your testing with the core checks enabled.</li>		crashes. You should do all your testing with the core checks enabled.</li>
</ul>		</ul>
</ul>		</ul>
<li>Patterns that you should most likely avoid even if they're not technically wrong:</li>		<li>Patterns that you should most likely avoid even if they're not technically wrong:</li>
<ul>		<ul>
<li><tt>BugReporterVisitor</tt> should most likely not match the AST of the current program point		<li><tt>BugReporterVisitor</tt> should most likely not match the AST of the current program point
to decide when to emit a note. It is much easier to determine that by observing changes in		to decide when to emit a note. It is much easier to determine that by observing changes in
the program state.</li>		the program state.</li>
<li>In <tt>State->getSVal(Region)</tt>, if <tt>Region</tt> is not known to be a <tt>TypedValueRegion</tt>		<li>In <tt>State->getSVal(Region)</tt>, if <tt>Region</tt> is not known to be a <tt>TypedValueRegion</tt>
and the optional type argument is not specified, the checker may accidentally try to dereference a		and the optional type argument is not specified, the checker may accidentally try to dereference a
void pointer.</li>		void pointer.</li>
<li>Checker logic should not depend on whether a certain value is a <tt>Loc</tt> or <tt>NonLoc</tt>.		<li>Checker logic should not depend on whether a certain value is a <tt>Loc</tt> or <tt>NonLoc</tt>.
It should be immediately obvious whether the <tt>SVal</tt> is a <tt>Loc</tt> or a		It should be immediately obvious whether the <tt>SVal</tt> is a <tt>Loc</tt> or a
<tt>NonLoc</tt> depending on the AST that is being checked. Checking whether a value		<tt>NonLoc</tt> depending on the AST that is being checked. Checking whether a value
is <tt>Loc</tt> or <tt>Unknown</tt>/<tt>Undefined</tt> or whether the value is		is <tt>Loc</tt> or <tt>Unknown</tt>/<tt>Undefined</tt> or whether the value is
<tt>NonLoc</tt> or <tt>Unknown</tt>/<tt>Undefined</tt> is totally fine.</li>		<tt>NonLoc</tt> or <tt>Unknown</tt>/<tt>Undefined</tt> is totally fine.</li>
<li>New symbols should not be constructed in the checker via direct calls to <tt>SymbolManager</tt>,		<li>New symbols should not be constructed in the checker via direct calls to <tt>SymbolManager</tt>,
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

clang/www/analyzer/codechecker.html

	Show All 17 Lines
	<h2>Basic Usage</h2>			<h2>Basic Usage</h2>

	<p>			<p>
	Install CodeChecker as described here: <a href="https://github.com/Ericsson/codechecker/#Install-guide"> CodeChecker Install Guide.</a>			Install CodeChecker as described here: <a href="https://github.com/Ericsson/codechecker/#Install-guide"> CodeChecker Install Guide.</a>
	</p>			</p>

	<p>			<p>
	Create a compilation database. If you use cmake then pass the <tt>-DCMAKE_EXPORT_COMPILE_COMMANDS=1</tt> parameter to cmake. Cmake will create a <tt>compile_commands.json</tt> file.			Create a compilation database. If you use cmake then pass the <tt>-DCMAKE_EXPORT_COMPILE_COMMANDS=1</tt> parameter to cmake. Cmake will create a <tt>compile_commands.json</tt> file.
	If you have a Makefile based or similar build system then you can log the build commands with the help of CodeChecker:			If you have a Makefile based or similar build system then you can log the build commands with the help of CodeChecker:</p>
	<pre class="code_example">			<pre class="code_example">
	make clean			make clean
	CodeChecker log -b "make" -o compile_commands.json			CodeChecker log -b "make" -o compile_commands.json
	</pre>			</pre>
	</p>

	<p>			<p>
	Analyze your project.			Analyze your project.</p>
	<pre class="code_example">			<pre class="code_example">
	CodeChecker analyze compile_commands.json -o ./reports			CodeChecker analyze compile_commands.json -o ./reports
	</pre>			</pre>
	</p>

	<p>			<p>
	View the analysis results.			View the analysis results.
	Print the detailed results in the command line:			Print the detailed results in the command line:</p>
	<pre class="code_example">			<pre class="code_example">
	CodeChecker parse --print-steps ./reports			CodeChecker parse --print-steps ./reports
	</pre>			</pre>
	Or view the detailed results in a browser:			<p>
				Or view the detailed results in a browser:</p>
	<pre class="code_example">			<pre class="code_example">
	CodeChecker parse ./reports -e html -o ./reports_html			CodeChecker parse ./reports -e html -o ./reports_html
	firefox ./reports_html/index.html			firefox ./reports_html/index.html
	</pre>			</pre>
	</p>

	<p>			<p>
	Optional: store the analysis results in a DB.			Optional: store the analysis results in a DB.</p>
	<pre class="code_example">			<pre class="code_example">
	mkdir ./ws			mkdir ./ws
	CodeChecker server -w ./ws -v 8555 &			CodeChecker server -w ./ws -v 8555 &
	CodeChecker store ./reports --name my-project --url http://localhost:8555/Default			CodeChecker store ./reports --name my-project --url http://localhost:8555/Default
	</pre>			</pre>
	</p>

	<p>			<p>
	Optional: manage (categorize, suppress) the results in your web browser:			Optional: manage (categorize, suppress) the results in your web browser:</p>
	<pre class="code_example">			<pre class="code_example">
	firefox http://localhost:8555/Default			firefox http://localhost:8555/Default
	</pre>			</pre>
	</p>

	<h2>Detailed Usage</h2>			<h2>Detailed Usage</h2>

	<p>			<p>
	For extended documentation please refer to the <a href="https://github.com/Ericsson/codechecker/blob/master/docs/usage.md">official site of CodeChecker</a>!			For extended documentation please refer to the <a href="https://github.com/Ericsson/codechecker/blob/master/docs/usage.md">official site of CodeChecker</a>!
	</p>			</p>

clang/www/analyzer/command-line.html

Show All 16 Lines

<p> Static Analyzer is by design a GUI tool. Its purpose is to find buggy execution		<p> Static Analyzer is by design a GUI tool. Its purpose is to find buggy execution
paths in the program, and such paths are very hard to comprehend by looking at		paths in the program, and such paths are very hard to comprehend by looking at
a non-interactive standard output. It is possible, however, to invoke the		a non-interactive standard output. It is possible, however, to invoke the
Static Analyzer from the command line in order to obtain analysis results, and		Static Analyzer from the command line in order to obtain analysis results, and
then later view them interactively in a graphical interface. The following		then later view them interactively in a graphical interface. The following
tools are used commonly to run the analyzer from the command line. Both tools		tools are used commonly to run the analyzer from the command line. Both tools
are wrapper scripts to drive the analysis and the underlying invocations of the		are wrapper scripts to drive the analysis and the underlying invocations of the
Clang compiler:		Clang compiler:</p>
<ol>		<ol>
<li><a href="scan-build.html">Scan-Build</a>		<li><a href="scan-build.html">Scan-Build</a>
is an old and simple command-line tool that emits static analyzer warnings as HTML files while compiling your project. You can view the analysis results in your web browser.		is an old and simple command-line tool that emits static analyzer warnings as HTML files while compiling your project. You can view the analysis results in your web browser.
</li>		</li>
<ul>		<ul>
<li>		<li>
Useful for individual developers who simply want to view static analysis results at their desk, or in a very simple collaborative environment.		Useful for individual developers who simply want to view static analysis results at their desk, or in a very simple collaborative environment.
</li>		</li>
Show All 15 Lines	<li>
Generally much more feature-rich than scan-build.		Generally much more feature-rich than scan-build.
</li>		</li>
<li>Supports incremental analysis: Results can be stored in a database, subsequent analysis runs can be compared to list the newly added defects.</li>		<li>Supports incremental analysis: Results can be stored in a database, subsequent analysis runs can be compared to list the newly added defects.</li>
<li><a href="https://clang.llvm.org/docs/analyzer/user-docs/CrossTranslationUnit.html">Cross Translation Unit (CTU) analysis</a> is supported fully on Linux via CodeChecker.</li>		<li><a href="https://clang.llvm.org/docs/analyzer/user-docs/CrossTranslationUnit.html">Cross Translation Unit (CTU) analysis</a> is supported fully on Linux via CodeChecker.</li>
<li>Can run clang-tidy checkers too.</li>		<li>Can run clang-tidy checkers too.</li>
<li>Open source, but out-of-tree, i.e. not part of the LLVM project.</li>		<li>Open source, but out-of-tree, i.e. not part of the LLVM project.</li>
</ul>		</ul>
</ol>		</ol>
</p>

<p>		<p>
</p>		</p>
<p>		<p>
</p>		</p>

</div>		</div>
</div>		</div>
</body>		</body>
</html>		</html>

clang/www/analyzer/faq.html

	Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
	void usePointer(int *b);			void usePointer(int *b);
	int foo(int *b) {			int foo(int *b) {
	usePointer(b);			usePointer(b);
	return *b;			return *b;
	}</pre>			}</pre>

	<h4 id="dead_store" class="faq">Q: How do I tell the static analyzer that I don't care about a specific dead store?</h4>			<h4 id="dead_store" class="faq">Q: How do I tell the static analyzer that I don't care about a specific dead store?</h4>

	<p>When the analyzer sees that a value stored into a variable is never used, it's going to produce a message similar to this one:			<p>When the analyzer sees that a value stored into a variable is never used, it's going to produce a message similar to this one:</p>
	<pre class="code_example">Value stored to 'x' is never read</pre>			<pre class="code_example">Value stored to 'x' is never read</pre>
	You can use the <tt>(void)x;</tt> idiom to acknowledge that there is a dead store in your code but you do not want it to be reported in the future.</p>			<p>You can use the <tt>(void)x;</tt> idiom to acknowledge that there is a dead store in your code but you do not want it to be reported in the future.</p>

	<h4 id="unused_ivar" class="faq">Q: How do I tell the static analyzer that I don't care about a specific unused instance variable in Objective C?</h4>			<h4 id="unused_ivar" class="faq">Q: How do I tell the static analyzer that I don't care about a specific unused instance variable in Objective C?</h4>

	<p>When the analyzer sees that a value stored into a variable is never used, it is going to produce a message similar to this one:			<p>When the analyzer sees that a value stored into a variable is never used, it is going to produce a message similar to this one:</p>
	<pre class="code_example">Instance variable 'commonName' in class 'HappyBird' is never used by the methods in its @implementation</pre>			<pre class="code_example">Instance variable 'commonName' in class 'HappyBird' is never used by the methods in its @implementation</pre>
	You can add <tt>__attribute__((unused))</tt> to the instance variable declaration to suppress the warning.</p>			<p>You can add <tt>__attribute__((unused))</tt> to the instance variable declaration to suppress the warning.</p>

	<h4 id="unlocalized_string" class="faq">Q: How do I tell the static analyzer that I don't care about a specific unlocalized string?</h4>			<h4 id="unlocalized_string" class="faq">Q: How do I tell the static analyzer that I don't care about a specific unlocalized string?</h4>

	<p>When the analyzer sees that an unlocalized string is passed to a method that will present that string to the user, it is going to produce a message similar to this one:			<p>When the analyzer sees that an unlocalized string is passed to a method that will present that string to the user, it is going to produce a message similar to this one:</p>
	<pre class="code_example">User-facing text should use localized string macro</pre>			<pre class="code_example">User-facing text should use localized string macro</pre>

	If your project deliberately uses unlocalized user-facing strings (for example, in a debugging UI that is never shown to users), you can suppress the analyzer warnings (and document your intent) with a function that just returns its input but is annotated to return a localized string:			<p>If your project deliberately uses unlocalized user-facing strings (for example, in a debugging UI that is never shown to users), you can suppress the analyzer warnings (and document your intent) with a function that just returns its input but is annotated to return a localized string:</p>
	<pre class="code_example">			<pre class="code_example">
	__attribute__((annotate("returns_localized_nsstring")))			__attribute__((annotate("returns_localized_nsstring")))
	static inline NSString LocalizationNotNeeded(NSString s) {			static inline NSString LocalizationNotNeeded(NSString s) {
	return s;			return s;
	}			}
	</pre>			</pre>

	You can then call this function when creating your debugging UI:			<p>You can then call this function when creating your debugging UI:</p>
	<pre class="code_example">			<pre class="code_example">
	[field setStringValue:LocalizationNotNeeded(@"Debug")];			[field setStringValue:LocalizationNotNeeded(@"Debug")];
	</pre>			</pre>

	Some projects may also find it useful to use NSLocalizedString but add "DNL" or "Do Not Localize" to the string contents as a convention:			<p>Some projects may also find it useful to use NSLocalizedString but add "DNL" or "Do Not Localize" to the string contents as a convention:</p>
	<pre class="code_example">			<pre class="code_example">
	UILabel *testLabel = [[UILabel alloc] init];			UILabel *testLabel = [[UILabel alloc] init];
	NSString *s = NSLocalizedString(@"Hello <Do Not Localize>", @"For debug purposes");			NSString *s = NSLocalizedString(@"Hello <Do Not Localize>", @"For debug purposes");
	[testLabel setText:s];			[testLabel setText:s];
	</pre>			</pre>
	</p>

	<h4 id="dealloc_mrr" class="faq">Q: How do I tell the analyzer that my instance variable does not need to be released in -dealloc under Manual Retain/Release?</h4>			<h4 id="dealloc_mrr" class="faq">Q: How do I tell the analyzer that my instance variable does not need to be released in -dealloc under Manual Retain/Release?</h4>

	<p>If your class only uses an instance variable for part of its lifetime, it may			<p>If your class only uses an instance variable for part of its lifetime, it may
	maintain an invariant guaranteeing that the instance variable is always released			maintain an invariant guaranteeing that the instance variable is always released
	before -dealloc. In this case, you can silence a warning about a missing release			before -dealloc. In this case, you can silence a warning about a missing release
	by either adding <tt>assert(_ivar == nil)</tt> or an explicit release			by either adding <tt>assert(_ivar == nil)</tt> or an explicit release
	<tt>[_ivar release]</tt> (which will be a no-op when the variable is nil) in			<tt>[_ivar release]</tt> (which will be a no-op when the variable is nil) in
	-dealloc. </p>			-dealloc. </p>

	<h4 id="decide_nullability" class="faq">Q: How do I decide whether a method's return type should be _Nullable or _Nonnull?</h4>			<h4 id="decide_nullability" class="faq">Q: How do I decide whether a method's return type should be _Nullable or _Nonnull?</h4>

	<p> Depending on the implementation of the method, this puts you in one of five situations:			<p> Depending on the implementation of the method, this puts you in one of five situations:</p>
	<ol>			<ol>
	<li>You actually never return nil.</li>			<li>You actually never return nil.</li>
	<li>You do return nil sometimes, and callers are supposed to handle that. This			<li>You do return nil sometimes, and callers are supposed to handle that. This
	includes cases where your method is documented to return nil given certain			includes cases where your method is documented to return nil given certain
	inputs.</li>			inputs.</li>
	<li>You return nil based on some external condition (such as an out-of-memory			<li>You return nil based on some external condition (such as an out-of-memory
	error), but the client can't do anything about it either.</li>			error), but the client can't do anything about it either.</li>
	<li>You return nil only when the caller passes input documented to be invalid.			<li>You return nil only when the caller passes input documented to be invalid.
	That means it's the client's fault.</li>			That means it's the client's fault.</li>
	<li>You return nil in some totally undocumented case.</li>			<li>You return nil in some totally undocumented case.</li>
	</ol>			</ol>
	</p>

	<p>In (1) you should annotate the method as returning a <tt>_Nonnull</tt>			<p>In (1) you should annotate the method as returning a <tt>_Nonnull</tt>
	object.</p>			object.</p>
	<p>In (2) the method should be marked <tt>_Nullable.</tt></p>			<p>In (2) the method should be marked <tt>_Nullable.</tt></p>
	<p>In (3) you should probably annotate the method <tt>_Nonnull</tt>. Why?			<p>In (3) you should probably annotate the method <tt>_Nonnull</tt>. Why?
	Because no callers will actually check for nil, given that they can't do			Because no callers will actually check for nil, given that they can't do
	anything about the situation and don't know what went wrong. At this point			anything about the situation and don't know what went wrong. At this point
	things have gone so poorly that there's basically no way to recover.</p>			things have gone so poorly that there's basically no way to recover.</p>
	Show All 14 Lines

	<h4 id="nullability_intentional_violation" class="faq">Q: How do I tell the analyzer that I am intentionally violating nullability?</h4>			<h4 id="nullability_intentional_violation" class="faq">Q: How do I tell the analyzer that I am intentionally violating nullability?</h4>

	<p>In some cases, it may make sense for methods to intentionally violate			<p>In some cases, it may make sense for methods to intentionally violate
	nullability. For example, your method may — for reasons of backward			nullability. For example, your method may — for reasons of backward
	compatibility — chose to return nil and log an error message in a method			compatibility — chose to return nil and log an error message in a method
	with a non-null return type when the client violated a documented precondition			with a non-null return type when the client violated a documented precondition
	rather than check the precondition with <tt>NSAssert()</tt>. In these cases, you			rather than check the precondition with <tt>NSAssert()</tt>. In these cases, you
	can suppress the analyzer warning with a cast:			can suppress the analyzer warning with a cast:</p>
	<pre class="code_example">			<pre class="code_example">
	return (id _Nonnull)nil;			return (id _Nonnull)nil;
	</pre>			</pre>
	Note that this cast does not affect code generation.			<p>Note that this cast does not affect code generation.</p>
	</p>

	<h4 id="use_assert" class="faq">Q: The analyzer assumes that a loop body is never entered. How can I tell it that the loop body will be entered at least once?</h4>			<h4 id="use_assert" class="faq">Q: The analyzer assumes that a loop body is never entered. How can I tell it that the loop body will be entered at least once?</h4>

	<img src="images/example_use_assert.png" alt="example use assert">			<img src="images/example_use_assert.png" alt="example use assert">

	<p> In the contrived example above, the analyzer has detected that the body of			<p> In the contrived example above, the analyzer has detected that the body of
	the loop is never entered for the case where <tt>length <= 0</tt>. In this			the loop is never entered for the case where <tt>length <= 0</tt>. In this
	particular example, you may know that the loop will always be entered because			particular example, you may know that the loop will always be entered because
	the input parameter <tt>length</tt> will be greater than zero in all calls to this			the input parameter <tt>length</tt> will be greater than zero in all calls to this
	function. You can teach the analyzer facts about your code as well as document			function. You can teach the analyzer facts about your code as well as document
	it by using assertions. By adding <tt>assert(length > 0)</tt> in the beginning			it by using assertions. By adding <tt>assert(length > 0)</tt> in the beginning
	of the function, you tell the analyzer that your code is never expecting a zero			of the function, you tell the analyzer that your code is never expecting a zero
	or a negative value, so it won't need to test the correctness of those paths.			or a negative value, so it won't need to test the correctness of those paths.
	</p>			</p>

	<pre class="code_example">			<pre class="code_example">
	int foo(int length) {			int foo(int length) {
	int x = 0;			int x = 0;
	<span class="code_highlight">assert(length > 0);</span>			<span class="code_highlight">assert(length > 0);</span>
	for (int i = 0; i < length; i++)			for (int i = 0; i < length; i++)
	x += 1;			x += 1;
	return length/x;			return length/x;
	}			}
	</pre>			</pre>

	<h4 id="suppress_issue" class="faq">Q: How can I suppress a specific analyzer warning?</h4>			<h4 id="suppress_issue" class="faq">Q: How can I suppress a specific analyzer warning?</h4>

	<p>There is currently no solid mechanism for suppressing an analyzer warning,			<p>There is currently no solid mechanism for suppressing an analyzer warning,
	although this is currently being investigated. When you encounter an analyzer			although this is currently being investigated. When you encounter an analyzer
	bug/false positive, check if it's one of the issues discussed above or if the			bug/false positive, check if it's one of the issues discussed above or if the
	analyzer <a href = "annotations.html#custom_assertions" >annotations</a> can			analyzer <a href = "annotations.html#custom_assertions" >annotations</a> can
	resolve the issue. Second, please <a href = "filing_bugs.html">report it</a> to			resolve the issue. Second, please <a href = "filing_bugs.html">report it</a> to
	help us improve user experience. As the last resort, consider using <tt>__clang_analyzer__</tt> macro			help us improve user experience. As the last resort, consider using <tt>__clang_analyzer__</tt> macro
	<a href = "faq.html#exclude_code" >described below</a>.</p>			<a href = "faq.html#exclude_code" >described below</a>.</p>

	<h4 id="exclude_code" class="faq">Q: How can I selectively exclude code the analyzer examines?</h4>			<h4 id="exclude_code" class="faq">Q: How can I selectively exclude code the analyzer examines?</h4>

	<p>When the static analyzer is using clang to parse source files, it implicitly			<p>When the static analyzer is using clang to parse source files, it implicitly
	defines the preprocessor macro <tt>__clang_analyzer__</tt>. One can use this			defines the preprocessor macro <tt>__clang_analyzer__</tt>. One can use this
	macro to selectively exclude code the analyzer examines. Here is an example:			macro to selectively exclude code the analyzer examines. Here is an example:</p>

	<pre class="code_example">			<pre class="code_example">
	#ifndef __clang_analyzer__			#ifndef __clang_analyzer__
	// Code not to be analyzed			// Code not to be analyzed
	#endif			#endif
	</pre>			</pre>

	This usage is discouraged because it makes the code dead to the analyzer from			<p>This usage is discouraged because it makes the code dead to the analyzer from
	now on. Instead, we prefer that users file bugs against the analyzer when it flags			now on. Instead, we prefer that users file bugs against the analyzer when it flags
	false positives.			false positives.
	</p>			</p>

	</div>			</div>
	</div>			</div>
	</body>			</body>
	</html>			</html>

clang/www/analyzer/implicit_checks.html

	Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
	(C)</span><div class="descr">			(C)</span><div class="descr">
	Evaluate compiler builtin functions (e.g., <code>alloca()</code>)</div></div></td>			Evaluate compiler builtin functions (e.g., <code>alloca()</code>)</div></div></td>
	<td><div class="exampleContainer expandable">			<td><div class="exampleContainer expandable">
	<div class="example"><pre>			<div class="example"><pre>
	void test(int x) {			void test(int x) {
	int p = (int )__builtin_alloca(8);			int p = (int )__builtin_alloca(8);
	// evaluates to AllocaRegion			// evaluates to AllocaRegion

	if(__builtin_expect(x > 10, 0)) // evaluates to 'x > 10'			if(__builtin_expect(x > 10, 0)) // evaluates to 'x > 10'
	x = 0;			x = 0;
	}			}
	</pre></div></div></td></tr>			</pre></div></div></td></tr>


	<tr><td><div class="namedescr expandable"><span class="name">			<tr><td><div class="namedescr expandable"><span class="name">
	core.builtin.NoReturnFunctions</span><span class="lang">			core.builtin.NoReturnFunctions</span><span class="lang">
	(C, ObjC)</span><div class="descr">			(C, ObjC)</span><div class="descr">
	▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

clang/www/analyzer/open_projects.html

Show All 13 Lines
<div id="content">		<div id="content">

<h1>Open Projects</h1>		<h1>Open Projects</h1>

<p>This page lists several projects that would boost analyzer's usability and		<p>This page lists several projects that would boost analyzer's usability and
power. Most of the projects listed here are infrastructure-related so this list		power. Most of the projects listed here are infrastructure-related so this list
is an addition to the <a href="potential_checkers.html">potential checkers		is an addition to the <a href="potential_checkers.html">potential checkers
list</a>. If you are interested in tackling one of these, please send an email		list</a>. If you are interested in tackling one of these, please send an email
to the <a href=https://lists.llvm.org/mailman/listinfo/cfe-dev>cfe-dev		to the <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev
mailing list</a> to notify other members of the community.</p>		mailing list</a> to notify other members of the community.</p>

<ul>		<ul>
<li>Release checkers from "alpha"		<li>Release checkers from "alpha"
<p>New checkers which were contributed to the analyzer,		<p>New checkers which were contributed to the analyzer,
but have not passed a rigorous evaluation process,		but have not passed a rigorous evaluation process,
are committed as "alpha checkers" (from "alpha version"),		are committed as "alpha checkers" (from "alpha version"),
and are not enabled by default.</p>		and are not enabled by default.</p>

<p>Ideally, only the checkers which are actively being worked on should be in		<p>Ideally, only the checkers which are actively being worked on should be in
"alpha",		"alpha",
but over the years the development of many of those has stalled.		but over the years the development of many of those has stalled.
Such checkers should either be improved		Such checkers should either be improved
up to a point where they can be enabled by default,		up to a point where they can be enabled by default,
or removed from the analyzer entirely.		or removed from the analyzer entirely.

<ul>		<ul>
<li><code>alpha.security.ArrayBound</code> and		<li><code>alpha.security.ArrayBound</code> and
<code>alpha.security.ArrayBoundV2</code>		<code>alpha.security.ArrayBoundV2</code>
<p>Array bounds checking is a desired feature,		<p>Array bounds checking is a desired feature,
but having an acceptable rate of false positives might not be possible		but having an acceptable rate of false positives might not be possible
without a proper		without a proper
<a href="https://en.wikipedia.org/wiki/Widening_(computer_science)">loop widening</a> support.		<a href="https://en.wikipedia.org/wiki/Widening_(computer_science)">loop widening</a> support.
Additionally, it might be more promising to perform index checking based on		Additionally, it might be more promising to perform index checking based on
<a href="https://en.wikipedia.org/wiki/Taint_checking">tainted</a> index values.		<a href="https://en.wikipedia.org/wiki/Taint_checking">tainted</a> index values.</p>
<p><i>(Difficulty: Medium)</i></p></p>		<p><i>(Difficulty: Medium)</i></p>
</li>		</li>

<li><code>alpha.unix.StreamChecker</code>		<li><code>alpha.unix.StreamChecker</code>
<p>A SimpleStreamChecker has been presented in the Building a Checker in 24		<p>A SimpleStreamChecker has been presented in the Building a Checker in 24
Hours talk		Hours talk
(<a href="https://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">slides</a>		(<a href="https://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">slides</a>
<a href="https://youtu.be/kdxlsP5QVPw">video</a>).</p>		<a href="https://youtu.be/kdxlsP5QVPw">video</a>).</p>

Show All 23 Lines	<li>Handle construction as part of aggregate initialization.
Moreover, if the aggregate contains		Moreover, if the aggregate contains
references, lifetime extension needs to be properly modeled.		references, lifetime extension needs to be properly modeled.

One can start untangling this problem by trying to replace the		One can start untangling this problem by trying to replace the
current ad-hoc <code><a href="https://clang.llvm.org/doxygen/classclang_1_1ParentMap.html">		current ad-hoc <code><a href="https://clang.llvm.org/doxygen/classclang_1_1ParentMap.html">
ParentMap</a></code> lookup in <a href="https://clang.llvm.org/doxygen/ExprEngineCXX_8cpp_source.html#l00430">		ParentMap</a></code> lookup in <a href="https://clang.llvm.org/doxygen/ExprEngineCXX_8cpp_source.html#l00430">
<code>CXXConstructExpr::CK_NonVirtualBase</code></a> branch of		<code>CXXConstructExpr::CK_NonVirtualBase</code></a> branch of
<code>ExprEngine::VisitCXXConstructExpr()</code>		<code>ExprEngine::VisitCXXConstructExpr()</code>
with proper support for the feature.		with proper support for the feature.</p>
<p><i>(Difficulty: Medium) </i></p></p>		<p><i>(Difficulty: Medium) </i></p>
</li>		</li>

<li>Handle array constructors.		<li>Handle array constructors.
<p>When an array of objects is allocated (say, using the		<p>When an array of objects is allocated (say, using the
<code>operator new[]</code> or defining a stack array),		<code>operator new[]</code> or defining a stack array),
constructors for all elements of the array are called.		constructors for all elements of the array are called.
We should model (potentially some of) such evaluations,		We should model (potentially some of) such evaluations,
and the same applies for destructors called from		and the same applies for destructors called from
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines	<li>Enhance the modeling of the standard library.
e.g. calling <code>.length()</code> on an empty		e.g. calling <code>.length()</code> on an empty
<code>std::string</code> always yields zero.		<code>std::string</code> always yields zero.
<p><i>(Difficulty: Medium)</i></p><p>		<p><i>(Difficulty: Medium)</i></p><p>
</li>		</li>

<li>Enhance CFG to model exception-handling.		<li>Enhance CFG to model exception-handling.
<p>Currently exceptions are treated as "black holes", and exception-handling		<p>Currently exceptions are treated as "black holes", and exception-handling
control structures are poorly modeled in order to be conservative.		control structures are poorly modeled in order to be conservative.
This could be improved for both C++ and Objective-C exceptions.		This could be improved for both C++ and Objective-C exceptions.</p>
<p><i>(Difficulty: Hard)</i></p></p>		<p><i>(Difficulty: Hard)</i></p>
</li>		</li>
</ul>		</ul>
</li>		</li>

<li>Core Analyzer Infrastructure		<li>Core Analyzer Infrastructure
<ul>		<ul>
<li>Handle unions.		<li>Handle unions.
<p>Currently in the analyzer the value of a union is always regarded as		<p>Currently in the analyzer the value of a union is always regarded as
an unknown.		an unknown.
This problem was		This problem was
previously <a href="https://lists.llvm.org/pipermail/cfe-dev/2017-March/052864.html">discussed</a>		previously <a href="https://lists.llvm.org/pipermail/cfe-dev/2017-March/052864.html">discussed</a>
on the mailing list, but no solution was implemented.		on the mailing list, but no solution was implemented.</p>
<p><i> (Difficulty: Medium) </i></p></p>		<p><i> (Difficulty: Medium) </i></p>
</li>		</li>

<li>Floating-point support.		<li>Floating-point support.
<p>Currently, the analyzer treats all floating-point values as unknown.		<p>Currently, the analyzer treats all floating-point values as unknown.
This project would involve adding a new <code>SVal</code> kind		This project would involve adding a new <code>SVal</code> kind
for constant floats, generalizing the constraint manager to handle floats,		for constant floats, generalizing the constraint manager to handle floats,
and auditing existing code to make sure it doesn't		and auditing existing code to make sure it doesn't
make incorrect assumptions (most notably, that <code>X == X</code>		make incorrect assumptions (most notably, that <code>X == X</code>
is always true, since it does not hold for <code>NaN</code>).		is always true, since it does not hold for <code>NaN</code>).</p>
<p><i> (Difficulty: Medium)</i></p></p>		<p><i> (Difficulty: Medium)</i></p>
</li>		</li>

<li>Improved loop execution modeling.		<li>Improved loop execution modeling.
<p>The analyzer simply unrolls each loop <tt>N</tt> times before		<p>The analyzer simply unrolls each loop <tt>N</tt> times before
dropping the path, for a fixed constant <tt>N</tt>.		dropping the path, for a fixed constant <tt>N</tt>.
However, that results in lost coverage in cases where the loop always		However, that results in lost coverage in cases where the loop always
executes more than <tt>N</tt> times.		executes more than <tt>N</tt> times.
A Google Summer Of Code		A Google Summer Of Code
<a href="https://summerofcode.withgoogle.com/archive/2017/projects/6071606019358720/">project</a>		<a href="https://summerofcode.withgoogle.com/archive/2017/projects/6071606019358720/">project</a>
was completed to make the loop bound parameterizable,		was completed to make the loop bound parameterizable,
but the <a href="https://en.wikipedia.org/wiki/Widening_(computer_science)">widening</a>		but the <a href="https://en.wikipedia.org/wiki/Widening_(computer_science)">widening</a>
problem still remains open.		problem still remains open.</p>
		<p><i> (Difficulty: Hard)</i></p>
<p><i> (Difficulty: Hard)</i></p></p>
</li>		</li>

<li>Basic function summarization support		<li>Basic function summarization support
<p>The analyzer performs inter-procedural analysis using		<p>The analyzer performs inter-procedural analysis using
either inlining or "conservative evaluation" (invalidating all data		either inlining or "conservative evaluation" (invalidating all data
passed to the function).		passed to the function).
Often, a very simple summary		Often, a very simple summary
(e.g. "this function is <a href="https://en.wikipedia.org/wiki/Pure_function">pure</a>") would be		(e.g. "this function is <a href="https://en.wikipedia.org/wiki/Pure_function">pure</a>") would be
enough to be a large improvement over conservative evaluation.		enough to be a large improvement over conservative evaluation.
Such summaries could be obtained either syntactically,		Such summaries could be obtained either syntactically,
or using a dataflow framework.		or using a dataflow framework.</p>
<p><i>(Difficulty: Hard)</i></p><p>		<p><i>(Difficulty: Hard)</i><p>
</li>		</li>

<li>Implement a dataflow flamework.		<li>Implement a dataflow flamework.
<p>The analyzer core		<p>The analyzer core
implements a <a href="https://en.wikipedia.org/wiki/Symbolic_execution">symbolic execution</a>		implements a <a href="https://en.wikipedia.org/wiki/Symbolic_execution">symbolic execution</a>
engine, which performs checks		engine, which performs checks
(use-after-free, uninitialized value read, etc.)		(use-after-free, uninitialized value read, etc.)
over a <em>single</em> program path.		over a <em>single</em> program path.
However, many useful properties		However, many useful properties
(dead code, check-after-use, etc.) require		(dead code, check-after-use, etc.) require
reasoning over <em>all</em> possible in a program.		reasoning over <em>all</em> possible in a program.
Such reasoning requires a		Such reasoning requires a
<a href="https://en.wikipedia.org/wiki/Data-flow_analysis">dataflow analysis</a> framework.		<a href="https://en.wikipedia.org/wiki/Data-flow_analysis">dataflow analysis</a> framework.
Clang already implements		Clang already implements
a few dataflow analyses (most notably, liveness),		a few dataflow analyses (most notably, liveness),
but they implemented in an ad-hoc fashion.		but they implemented in an ad-hoc fashion.
A proper framework would enable us writing many more useful checkers.		A proper framework would enable us writing many more useful checkers.</p>
<p><i> (Difficulty: Hard) </i></p></p>		<p><i> (Difficulty: Hard) </i></p>
</li>		</li>

<li>Track type information through casts more precisely.		<li>Track type information through casts more precisely.
<p>The <code>DynamicTypePropagation</code>		<p>The <code>DynamicTypePropagation</code>
checker is in charge of inferring a region's		checker is in charge of inferring a region's
dynamic type based on what operations the code is performing.		dynamic type based on what operations the code is performing.
Casts are a rich source of type information that the analyzer currently ignores.		Casts are a rich source of type information that the analyzer currently ignores.</p>
<p><i>(Difficulty: Medium)</i></p></p>		<p><i>(Difficulty: Medium)</i></p>
</li>		</li>

</ul>		</ul>
</li>		</li>

<li>Fixing miscellaneous bugs		<li>Fixing miscellaneous bugs
<p>Apart from the open projects listed above,		<p>Apart from the open projects listed above,
contributors are welcome to fix any of the outstanding		contributors are welcome to fix any of the outstanding
<a href="https://bugs.llvm.org/buglist.cgi?component=Static%20Analyzer&list_id=147756&product=clang&resolution=---">bugs</a>		<a href="https://bugs.llvm.org/buglist.cgi?component=Static%20Analyzer&list_id=147756&product=clang&resolution=---">bugs</a>
in the Bugzilla.		in the Bugzilla.</p>
<p><i>(Difficulty: Anything)</i></p></p>		<p><i>(Difficulty: Anything)</i></p>
</li>		</li>

</ul>		</ul>

</div>		</div>
</div>		</div>
</body>		</body>
</html>		</html>

clang/www/analyzer/potential_checkers.html

Show First 20 Lines • Show All 342 Lines • ▼ Show 20 Lines
Record that <code>errno</code> is non-zero when certain functions		Record that <code>errno</code> is non-zero when certain functions
fail.</div></div></td>		fail.</div></div></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
#include <stdlib.h>		#include <stdlib.h>

int readWrapper(int fd, int *count) {		int readWrapper(int fd, int *count) {
int lcount = read(fd, globalBuf, sizeof(globalBuf));		int lcount = read(fd, globalBuf, sizeof(globalBuf));
if (lcount < 0)		if (lcount < 0)
return errno;		return errno;
*count = lcount;		*count = lcount;
return 0;		return 0;
}		}

void use(int fd) {		void use(int fd) {
int count;		int count;
if (!readWrapper(fd, &count))		if (!readWrapper(fd, &count))
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Lines	public:
~A();		~A();
};		};

class B {};		class B {};

void test() {		void test() {
A *a = new A;		A *a = new A;
new(a) B;		new(a) B;
a->~A();		a->~A();
}		}
</pre></div>		</pre></div>
<div class="example"><pre>		<div class="example"><pre>
#include <new>		#include <new>

class A {		class A {
public:		public:
~A();		~A();
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines

class B {		class B {
public:		public:
~B();		~B();
};		};

void test() {		void test() {
B b;		B b;
new (&b) A;		new (&b) A;
} // warn		} // warn
</pre></div>		</pre></div>
<div class="example"><pre>		<div class="example"><pre>
#include <new>		#include <new>

class A {};		class A {};

class B {		class B {
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
public :		public :
int i;		int i;
C();		C();
};		};

void test() {		void test() {
const C cb;		const C cb;

C* cp = const_cast<C *>(&cb);		C* cp = const_cast<C *>(&cb);
cp->i = 1; // warn		cp->i = 1; // warn
}		}
</pre></div></div></td>		</pre></div></div></td>
<td class="aligned"></td></tr>		<td class="aligned"></td></tr>


<tr><td><div class="namedescr expandable"><span class="name">		<tr><td><div class="namedescr expandable"><span class="name">
undefbehavior.DeadDestructed</span><span class="lang">		undefbehavior.DeadDestructed</span><span class="lang">
▲ Show 20 Lines • Show All 497 Lines • ▼ Show 20 Lines
</pre></div></div></td>		</pre></div></div></td>
<td class="aligned"></td></tr>		<td class="aligned"></td></tr>


<tr><td><div class="namedescr expandable"><span class="name">		<tr><td><div class="namedescr expandable"><span class="name">
undefbehavior.ValarrayZeroLength</span><span class="lang">		undefbehavior.ValarrayZeroLength</span><span class="lang">
(C++)</span><div class="descr">		(C++)</span><div class="descr">
Undefined behavior: calling <code>sum()</code>/<code>min()</code>/<code>		Undefined behavior: calling <code>sum()</code>/<code>min()</code>/<code>
max()</code> methods of a zero length <code>valarray<code> the behavior is		max()</code> methods of a zero length <code>valarray</code> the behavior is
undefined.		undefined.
<p>Source: C++03 26.3.2.7p2, p3, p4; C++11 26.6.2.8p5, p6,		<p>Source: C++03 26.3.2.7p2, p3, p4; C++11 26.6.2.8p5, p6,
p7.</p></div></div></td>		p7.</p></div></div></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
#include <valarray>		#include <valarray>

void test(void) {		void test(void) {
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines

template <class T, class Traits = std::char_traits<T> >		template <class T, class Traits = std::char_traits<T> >
class my_stream2 : public std::basic_ios<T, Traits> {		class my_stream2 : public std::basic_ios<T, Traits> {
class my_streambuf		class my_streambuf
: public std::basic_streambuf<T, Traits> {		: public std::basic_streambuf<T, Traits> {
};		};
public:		public:
my_stream2() {		my_stream2() {
this->init(new my_streambuf);		this->init(new my_streambuf);
}		}
};		};

void test() {		void test() {
my_stream1<char> *p1 = new my_stream1<char>;		my_stream1<char> *p1 = new my_stream1<char>;
my_stream2<char> *p2 = new my_stream2<char>;		my_stream2<char> *p2 = new my_stream2<char>;
delete p1; // warn		delete p1; // warn
delete p2; // ok		delete p2; // ok
Show All 20 Lines

template <class T, class Traits = std::char_traits<T> >		template <class T, class Traits = std::char_traits<T> >
class my_stream2 : public std::basic_ios<T, Traits> {		class my_stream2 : public std::basic_ios<T, Traits> {
class my_streambuf		class my_streambuf
: public std::basic_streambuf<T, Traits> {		: public std::basic_streambuf<T, Traits> {
};		};
public:		public:
my_stream2() {		my_stream2() {
this->init(new my_streambuf);		this->init(new my_streambuf);
}		}
};		};

void test() {		void test() {
my_stream1<char> *p1 = new my_stream1<char>;		my_stream1<char> *p1 = new my_stream1<char>;
my_stream2<char> *p2 = new my_stream2<char>;		my_stream2<char> *p2 = new my_stream2<char>;
p1->narrow('a', 'b'); // warn		p1->narrow('a', 'b'); // warn
p2->narrow('a', 'b'); // ok		p2->narrow('a', 'b'); // ok
}		}
</pre></div></div></td>		</pre></div></div></td>
<td class="aligned"></td></tr>		<td class="aligned"></td></tr>


<tr><td><div class="namedescr expandable"><span class="name">		<tr><td><div class="namedescr expandable"><span class="name">
undefbehavior.MinusOnePosType</span><span class="lang">		undefbehavior.MinusOnePosType</span><span class="lang">
(C++)</span><div class="descr">		(C++)</span><div class="descr">
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
struct S {int i;};		struct S {int i;};

struct S* f();		struct S* f();

void test() {		void test() {
struct S *p = f();		struct S *p = f();
if (p->i && p) {}; // warn		if (p->i && p) {}; // warn
}		}
</pre></div></div></td>		</pre></div></div></td>
<td class="aligned"></td></tr>		<td class="aligned"></td></tr>


<tr><td><div class="namedescr expandable"><span class="name">		<tr><td><div class="namedescr expandable"><span class="name">
different.MultipleAccessors</span><span class="lang">		different.MultipleAccessors</span><span class="lang">
(C++)</span><div class="descr">		(C++)</span><div class="descr">
Identical accessor bodies. Possibly a misprint.</div></div></td>		Identical accessor bodies. Possibly a misprint.</div></div></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
class A {		class A {
int i;		int i;
int j;		int j;
public:		public:
int getI() { return i; }		int getI() { return i; }
int getJ() { return i; } // warn		int getJ() { return i; } // warn
};		};
</pre></div>		</pre></div>
<div class="example"><pre>		<div class="example"><pre>
class A {		class A {
int i;		int i;
int j;		int j;
public:		public:
void setI(int& ii) { i = ii; }		void setI(int& ii) { i = ii; }
void setJ(int& jj) { i = jj; } // warn		void setJ(int& jj) { i = jj; } // warn
};		};
</pre></div></div></td>		</pre></div></div></td>
<td class="aligned"></td></tr>		<td class="aligned"></td></tr>


<tr><td><div class="namedescr expandable"><span class="name">		<tr><td><div class="namedescr expandable"><span class="name">
different.AccessorsForPublic</span><span class="lang">		different.AccessorsForPublic</span><span class="lang">
(C++)</span><div class="descr">		(C++)</span><div class="descr">
Accessors exist for a public class field. Should this field really be		Accessors exist for a public class field. Should this field really be
public?</div></div></td>		public?</div></div></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
class A {		class A {
public:		public:
int i; // warn		int i; // warn
int getI() { return i; }		int getI() { return i; }
void setI(int& ii) { i = ii; }		void setI(int& ii) { i = ii; }
};		};
</pre></div></div></td>		</pre></div></div></td>
<td class="aligned"></td></tr>		<td class="aligned"></td></tr>


<tr><td><div class="namedescr expandable"><span class="name">		<tr><td><div class="namedescr expandable"><span class="name">
different.LibFuncResultUnised</span><span class="lang">		different.LibFuncResultUnised</span><span class="lang">
(C, C++)</span><div class="descr">		(C, C++)</span><div class="descr">
▲ Show 20 Lines • Show All 395 Lines • ▼ Show 20 Lines
<col class="namedescr"><col class="example"><col class="progress">		<col class="namedescr"><col class="example"><col class="progress">
<thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr></thead>		<thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr></thead>

<tr><td><div class="namedescr expandable"><span class="name">		<tr><td><div class="namedescr expandable"><span class="name">
WinAPI.CreateProcess</span><span class="lang">		WinAPI.CreateProcess</span><span class="lang">
(C)</span><div class="descr">		(C)</span><div class="descr">
<code>CreateProcess()</code>: if the first parameter <code><i>		<code>CreateProcess()</code>: if the first parameter <code><i>
lpApplicationName</i></code> is NULL then the executable name must be in the		lpApplicationName</i></code> is NULL then the executable name must be in the
white space-delimited string pointed to by <code><i>lpCommandLine</code></i>.		white space-delimited string pointed to by <code><i>lpCommandLine</i></code>.
If the executable or path name has a space in it, there is a risk that a		If the executable or path name has a space in it, there is a risk that a
different executable could be run because of the way the function parses		different executable could be run because of the way the function parses
spaces.		spaces.
<p>Source: <a href="https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessa#security-remarks">		<p>Source: <a href="https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessa#security-remarks">
MSDN: CreateProcess function, Security Remarks</a>.</p></div></div></td>		MSDN: CreateProcess function, Security Remarks</a>.</p></div></div></td>
<td><div class="exampleContainer expandable">		<td><div class="exampleContainer expandable">
<div class="example"><pre>		<div class="example"><pre>
#include <windows.h>		#include <windows.h>

void test() {		void test() {
STARTUPINFO si;		STARTUPINFO si;
PROCESS_INFORMATION pi;		PROCESS_INFORMATION pi;
CreateProcess(NULL, TEXT("C:\\Program Files\\App -L -S"),		CreateProcess(NULL, TEXT("C:\\Program Files\\App -L -S"),
NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);		NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
// warn		// warn
}		}
</pre></div></div></td>		</pre></div></div></td>
<td class="aligned"></td></tr>		<td class="aligned"></td></tr>


<tr><td><div class="namedescr expandable"><span class="name">		<tr><td><div class="namedescr expandable"><span class="name">
WinAPI.LoadLibrary</span><span class="lang">		WinAPI.LoadLibrary</span><span class="lang">
▲ Show 20 Lines • Show All 144 Lines • Show Last 20 Lines

clang/www/analyzer/release_notes.html

Show All 9 Lines
<body>		<body>

<div id="page">		<div id="page">
<!--#include virtual="menu.html.incl"-->		<!--#include virtual="menu.html.incl"-->
<div id="content">		<div id="content">

<h1>Release notes for <tt>checker-XXX</tt> builds</h1>		<h1>Release notes for <tt>checker-XXX</tt> builds</h1>
<h4 id="checker_279">checker-279</h4>		<h4 id="checker_279">checker-279</h4>
<p><b>built:</b> November 14, 2016</br>		<p><b>built:</b> November 14, 2016<br>
<b>download:</b> <a href="downloads/checker-279.tar.bz2">checker-279.tar.bz2</a></p>		<b>download:</b> <a href="downloads/checker-279.tar.bz2">checker-279.tar.bz2</a></p>
<p><b>highlights:</b></p>		<p><b>highlights:</b></p>
<ul>		<ul>
<li>The analyzer includes new checks for:		<li>The analyzer includes new checks for:
<ul>		<ul>
<li>Improper instance cleanup up in Objective-C -dealloc methods under manual retain/release.</li>		<li>Improper instance cleanup up in Objective-C -dealloc methods under manual retain/release.</li>
<li>Inadvertent comparisons of NSNumber, CFNumberRef, and other number object pointers against scalar values.</li>		<li>Inadvertent comparisons of NSNumber, CFNumberRef, and other number object pointers against scalar values.</li>
<li>Unsafe usage of dispatch_once_t predicates stored in Objective-C instance variables and other heap-allocated memory.</li>		<li>Unsafe usage of dispatch_once_t predicates stored in Objective-C instance variables and other heap-allocated memory.</li>
<li>Issues resulting from self-assignment in C++.</li>		<li>Issues resulting from self-assignment in C++.</li>
<li>Incorrect usage of MPI APIs in C and C++. This check can be enabled by passing the following command to scan-build: <br />		<li>Incorrect usage of MPI APIs in C and C++. This check can be enabled by passing the following command to scan-build: <br />
<tt>-enable-checker optin.mpi.MPI-Checker</tt></li>		<tt>-enable-checker optin.mpi.MPI-Checker</tt></li>
</ul>		</ul>
<li>The scan-build tool now supports a <tt>--force-analyze-debug-code flag</tt> that forces projects to analyze in debug mode. This flag leaves in assertions and so typically results in fewer false positives.</li>		<li>The scan-build tool now supports a <tt>--force-analyze-debug-code flag</tt> that forces projects to analyze in debug mode. This flag leaves in assertions and so typically results in fewer false positives.</li>
<li>Additional miscellaneous improvements.</li>		<li>Additional miscellaneous improvements.</li>
<li>Now requires macOS 10.8 or later.</li>		<li>Now requires macOS 10.8 or later.</li>
</ul>		</ul>

<h4 id="checker_278">checker-278</h4>		<h4 id="checker_278">checker-278</h4>
<p><b>built:</b> February 5, 2016</br>		<p><b>built:</b> February 5, 2016<br>
<b>download:</b> <a href="downloads/checker-278.tar.bz2">checker-278.tar.bz2</a></p>		<b>download:</b> <a href="downloads/checker-278.tar.bz2">checker-278.tar.bz2</a></p>
<p><b>highlights:</b></p>		<p><b>highlights:</b></p>
<ul>		<ul>
<li>Greatly improves analysis of C++ lambdas, including interprocedural analysis of lambda applications and reduced 'dead store'		<li>Greatly improves analysis of C++ lambdas, including interprocedural analysis of lambda applications and reduced 'dead store'
false positives for variables captured by reference.</li>		false positives for variables captured by reference.</li>
<li>The analyzer now checks for misuse of 'vfork()'. This check is enabled by default.</li>		<li>The analyzer now checks for misuse of 'vfork()'. This check is enabled by default.</li>
<li>The analyzer can now detect excessively-padded structs. This check can be enabled by passing the following		<li>The analyzer can now detect excessively-padded structs. This check can be enabled by passing the following
command to scan-build:<br />		command to scan-build:<br />
<tt>-enable-checker optin.performance.Padding</tt> </li>		<tt>-enable-checker optin.performance.Padding</tt> </li>
<li>The checks to detect misuse of <tt>_Nonnull</tt> are now enabled by default.</li>		<li>The checks to detect misuse of <tt>_Nonnull</tt> are now enabled by default.</li>
<li>The checks to detect misuse of Objective-C generics are now enabled by default.</li>		<li>The checks to detect misuse of Objective-C generics are now enabled by default.</li>
<li>Many miscellaneous improvements.</li>		<li>Many miscellaneous improvements.</li>
</ul>		</ul>

<h4 id="checker_277">checker-277</h4>		<h4 id="checker_277">checker-277</h4>
<p><b>built:</b> October 28, 2015</br>		<p><b>built:</b> October 28, 2015<br>
<b>download:</b> <a href="downloads/checker-277.tar.bz2">checker-277.tar.bz2</a></p>		<b>download:</b> <a href="downloads/checker-277.tar.bz2">checker-277.tar.bz2</a></p>
<p><b>highlights:</b></p>		<p><b>highlights:</b></p>
<ul>		<ul>
<li>Includes about 20 months of change to Clang itself.</li>		<li>Includes about 20 months of change to Clang itself.</li>
<li>New checker for C++ leaks is turned on by default.</li>		<li>New checker for C++ leaks is turned on by default.</li>
<li>Added various small checks and bug fixes.</li>		<li>Added various small checks and bug fixes.</li>
<li>Added experimental checkers for Objective-C:</li>		<li>Added experimental checkers for Objective-C:</li>
<ul>		<ul>
Show All 13 Lines	<tt>-enable-checker nullability.NullPassedToNonnull,nullability.NullReturnedFromNonnull</tt></li>
<li>New checks for misuse of Objective-C generics. These can be enabled with <tt>-enable-checker alpha.osx.cocoa.ObjCGenerics</tt>.</li>		<li>New checks for misuse of Objective-C generics. These can be enabled with <tt>-enable-checker alpha.osx.cocoa.ObjCGenerics</tt>.</li>
</ul>		</ul>
<li>Support for <tt>cf_returns_retained</tt> and <tt>cf_returns_not_retained</tt> attributes in out-parameters.</li>		<li>Support for <tt>cf_returns_retained</tt> and <tt>cf_returns_not_retained</tt> attributes in out-parameters.</li>
<li>The analyzer now creates one state for a range switch case instead of multiple, resulting in performance improvements.</li>		<li>The analyzer now creates one state for a range switch case instead of multiple, resulting in performance improvements.</li>
<li>Now requires OS X 10.7 or later.		<li>Now requires OS X 10.7 or later.
</ul>		</ul>

<h4 id="checker_276">checker-276</h4>		<h4 id="checker_276">checker-276</h4>
<p><b>built:</b> February 19, 2014</br>		<p><b>built:</b> February 19, 2014<br>
<b>download:</b> <a href="downloads/checker-276.tar.bz2">checker-276.tar.bz2</a></p>		<b>download:</b> <a href="downloads/checker-276.tar.bz2">checker-276.tar.bz2</a></p>
<p><b>highlights:</b></p>		<p><b>highlights:</b></p>
<ul>		<ul>
<li>Includes about 9 months of change to Clang itself (improved C++11/14 support, etc.)</li>		<li>Includes about 9 months of change to Clang itself (improved C++11/14 support, etc.)</li>
<li>More precise modeling of Objective-C properties, which enables the analyzer to find more bugs.</li>		<li>More precise modeling of Objective-C properties, which enables the analyzer to find more bugs.</li>
<li>Includes a new "missing call to <tt>super</tt>" warning, which looks for common pattern in iOS/OSX APIs that require chaining a call to a super class's implementation of a method.</li>		<li>Includes a new "missing call to <tt>super</tt>" warning, which looks for common pattern in iOS/OSX APIs that require chaining a call to a super class's implementation of a method.</li>
<li>Accepts <tt>-arch arm64</tt> (which may be passed by Xcode 5.0), but for the time being analyzes code in such cases as <tt>-arch armv7s</tt>.</li>		<li>Accepts <tt>-arch arm64</tt> (which may be passed by Xcode 5.0), but for the time being analyzes code in such cases as <tt>-arch armv7s</tt>.</li>
<li>Many sundry fixes, improvements to C++ support, etc.</li>		<li>Many sundry fixes, improvements to C++ support, etc.</li>
</ul>		</ul>

<h4 id="checker_275">checker-275</h4>		<h4 id="checker_275">checker-275</h4>
<p><b>built:</b> May 23, 2013</br>		<p><b>built:</b> May 23, 2013<br>
<b>download:</b> <a href="downloads/checker-275.tar.bz2">checker-275.tar.bz2</a></p>		<b>download:</b> <a href="downloads/checker-275.tar.bz2">checker-275.tar.bz2</a></p>
<p><b>highlights:</b></p>		<p><b>highlights:</b></p>
<ul>		<ul>
<li>Xcode: Includes a new arrow layout algorithm for issue presentation within Xcode. The goal is for interprocedural bug reports to look cleaner and less busy (and easier to read). Feedback appreciated.</li>		<li>Xcode: Includes a new arrow layout algorithm for issue presentation within Xcode. The goal is for interprocedural bug reports to look cleaner and less busy (and easier to read). Feedback appreciated.</li>
<li>Xcode: Bugs that occur within header code (e.g., C++) are now reported within the callers in the main source file. For example, if you misuse a C++ function declared in a header the primary diagnostic will be in the caller (in the main source file). The full expanded path, however, will show the bug in the header code as well. These kind of cross-file issues are currently only support by Xcode, not the HTML output.</li>		<li>Xcode: Bugs that occur within header code (e.g., C++) are now reported within the callers in the main source file. For example, if you misuse a C++ function declared in a header the primary diagnostic will be in the caller (in the main source file). The full expanded path, however, will show the bug in the header code as well. These kind of cross-file issues are currently only support by Xcode, not the HTML output.</li>
<li>This build is built with LLVM's Link-Time Optimization (LTO), which should make it slightly faster.</li>		<li>This build is built with LLVM's Link-Time Optimization (LTO), which should make it slightly faster.</li>
<li>LTO also reduces the download size (about 19% smaller than checker-274).</li>		<li>LTO also reduces the download size (about 19% smaller than checker-274).</li>
<li>Many sundry fixes.</li>		<li>Many sundry fixes.</li>
</ul>		</ul>

<h4 id="checker_274">checker-274</h4>		<h4 id="checker_274">checker-274</h4>
<p><b>built:</b> April 23, 2013</br>		<p><b>built:</b> April 23, 2013<br>
<b>download:</b> <a href="https://attache.apple.com/AttacheWeb/dl?id=ATCdb3165f4406a4589b5878a22494c3b79">checker-274.tar.bz2</a></p>		<b>download:</b> <a href="https://attache.apple.com/AttacheWeb/dl?id=ATCdb3165f4406a4589b5878a22494c3b79">checker-274.tar.bz2</a></p>
<p><b>highlights:</b></p>		<p><b>highlights:</b></p>
<ul>		<ul>
<li>Improved use-after-free and mismatched deallocator checking.</li>		<li>Improved use-after-free and mismatched deallocator checking.</li>
<li>Diagnostic polish.</li>		<li>Diagnostic polish.</li>
<li>Fixes crashes found in checker-273.</li>		<li>Fixes crashes found in checker-273.</li>
</ul>		</ul>

<h4 id="checker_273">checker-273</h4>		<h4 id="checker_273">checker-273</h4>
<p><b>built:</b> April 8, 2013</br>		<p><b>built:</b> April 8, 2013<br>
<b>download:</b> <a href="https://attache.apple.com/AttacheWeb/dl?id=ATCdefcc852a99546cfbaba2a960e07478e">checker-273.tar.bz2</a></p>		<b>download:</b> <a href="https://attache.apple.com/AttacheWeb/dl?id=ATCdefcc852a99546cfbaba2a960e07478e">checker-273.tar.bz2</a></p>
<p><b>highlights:</b></p>		<p><b>highlights:</b></p>
<ul>		<ul>
<li>Additional checks for misuse of Foundation collection APIs.		<li>Additional checks for misuse of Foundation collection APIs.
<li>New C++ checker for attempting to create a reference to null.</li>		<li>New C++ checker for attempting to create a reference to null.</li>
<li>New use-after-free checker for C++ 'delete'.</li>		<li>New use-after-free checker for C++ 'delete'.</li>
<li>New checker for simple cases of mismatched allocators and deallocators, e.g. "delete malloc(4);"</li>		<li>New checker for simple cases of mismatched allocators and deallocators, e.g. "delete malloc(4);"</li>
<li>Support for basic interprocedural analysis of C++ destructors.</li>		<li>Support for basic interprocedural analysis of C++ destructors.</li>
▲ Show 20 Lines • Show All 257 Lines • Show Last 20 Lines

clang/www/analyzer/scan-build.html

	Show First 20 Lines • Show All 186 Lines • ▼ Show 20 Lines

	<tr><td><b>-V</b></td><td>View analysis results in a web browser when the build			<tr><td><b>-V</b></td><td>View analysis results in a web browser when the build
	command completes.</td></tr>			command completes.</td></tr>

	<tr><td><b>--use-analyzer Xcode</b><br><i>or</i><br>			<tr><td><b>--use-analyzer Xcode</b><br><i>or</i><br>
	<b>--use-analyzer [path to clang]</b></td><td><tt>scan-build</tt> uses the			<b>--use-analyzer [path to clang]</b></td><td><tt>scan-build</tt> uses the
	'clang' executable relative to itself for static analysis. One can override this			'clang' executable relative to itself for static analysis. One can override this
	behavior with this option by using the 'clang' packaged with Xcode (on OS X) or			behavior with this option by using the 'clang' packaged with Xcode (on OS X) or
	from the PATH.</p></td></tr> </table>			from the PATH.</td></tr> </table>

	<p>A complete list of options can be obtained by running <tt>scan-build</tt>			<p>A complete list of options can be obtained by running <tt>scan-build</tt>
	with no arguments.</p>			with no arguments.</p>

	<h3 id="scanbuild_output">Output of scan-build</h3>			<h3 id="scanbuild_output">Output of scan-build</h3>

	<p>			<p>
	The output of scan-build is a set of HTML files, each one which represents a			The output of scan-build is a set of HTML files, each one which represents a
	▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

clang/www/c_dr_status.html

Show First 20 Lines • Show All 171 Lines • ▼ Show 20 Lines	<tr id="21">
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_021.html">21</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_021.html">21</a></td>
<td>C89</td>		<td>C89</td>
<td>What is the result of: printf("%#.4o", 345);?</td>		<td>What is the result of: printf("%#.4o", 345);?</td>
<td class="na" align="center">N/A</td>		<td class="na" align="center">N/A</td>
</tr>		</tr>
<tr id="22">		<tr id="22">
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_022.html">22</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_022.html">22</a></td>
<td>C89</td>		<td>C89</td>
<td>What is the result of: strtod("100ergs", &ptr);?</td>		<td>What is the result of: strtod("100ergs", &ptr);?</td>
<td class="na" align="center">N/A</td>		<td class="na" align="center">N/A</td>
</tr>		</tr>
<tr id="23">		<tr id="23">
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_023.html">23</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_023.html">23</a></td>
<td>NAD</td>		<td>NAD</td>
<td>what is the result of strtod("0.0e99999", &ptr);?</td>		<td>what is the result of strtod("0.0e99999", &ptr);?</td>
<td class="na" align="center">N/A</td>		<td class="na" align="center">N/A</td>
</tr>		</tr>
<tr id="24">		<tr id="24">
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_024.html">24</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_024.html">24</a></td>
<td>NAD</td>		<td>NAD</td>
<td>In subclause 7.10.1.4 The strtod function: What does '"C" locale' mean?</td>		<td>In subclause 7.10.1.4 The strtod function: What does '"C" locale' mean?</td>
<td class="na" align="center">N/A</td>		<td class="na" align="center">N/A</td>
</tr>		</tr>
▲ Show 20 Lines • Show All 550 Lines • ▼ Show 20 Lines	<tr id="115">
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_115.html">115</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_115.html">115</a></td>
<td>NAD</td>		<td>NAD</td>
<td>Member declarators as declarators</td>		<td>Member declarators as declarators</td>
<td class="full" align="center">Yes</td>		<td class="full" align="center">Yes</td>
</tr>		</tr>
<tr id="116">		<tr id="116">
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_116.html">116</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_116.html">116</a></td>
<td>NAD</td>		<td>NAD</td>
<td>Implicit unary & applied to register arrays</td>		<td>Implicit unary & applied to register arrays</td>
<td class="full" align="center">Yes</td>		<td class="full" align="center">Yes</td>
</tr>		</tr>
<tr id="117">		<tr id="117">
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_117.html">117</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_117.html">117</a></td>
<td>NAD</td>		<td>NAD</td>
<td>Abstract semantics, sequence points, and expression evaluation</td>		<td>Abstract semantics, sequence points, and expression evaluation</td>
<td class="full" align="center">Yes</td>		<td class="full" align="center">Yes</td>
</tr>		</tr>
▲ Show 20 Lines • Show All 612 Lines • ▼ Show 20 Lines	<tr id="240">
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_240.htm">240</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_240.htm">240</a></td>
<td>C99</td>		<td>C99</td>
<td>lrint, llrint, lround, llround, and ilogb descriptions are not consistent for unrepresentable results</td>		<td>lrint, llrint, lround, llround, and ilogb descriptions are not consistent for unrepresentable results</td>
<td class="na" align="center">N/A</td>		<td class="na" align="center">N/A</td>
</tr>		</tr>
<tr id="241">		<tr id="241">
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_241.htm">241</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_241.htm">241</a></td>
<td>C99</td>		<td>C99</td>
<td>Make the base standard and Annex F consistent for pow(0, <0)</td>		<td>Make the base standard and Annex F consistent for pow(0, <0)</td>
<td class="na" align="center">N/A</td>		<td class="na" align="center">N/A</td>
</tr>		</tr>
<tr id="242">		<tr id="242">
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_242.htm">242</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_242.htm">242</a></td>
<td>C99</td>		<td>C99</td>
<td>Make the base standard and Annex F consistent for logb(0)</td>		<td>Make the base standard and Annex F consistent for logb(0)</td>
<td class="na" align="center">N/A</td>		<td class="na" align="center">N/A</td>
</tr>		</tr>
▲ Show 20 Lines • Show All 236 Lines • ▼ Show 20 Lines	<tr id="281">
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_281.htm">281</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_281.htm">281</a></td>
<td>C99</td>		<td>C99</td>
<td>CLOCKS_PER_SEC should not be a constant expression</td>		<td>CLOCKS_PER_SEC should not be a constant expression</td>
<td class="na" align="center">N/A</td>		<td class="na" align="center">N/A</td>
</tr>		</tr>
<tr id="282">		<tr id="282">
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_282.htm">282</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_282.htm">282</a></td>
<td>C99</td>		<td>C99</td>
<td>Flexible array members & struct padding</td>		<td>Flexible array members & struct padding</td>
<td class="full" align="center">Yes</td>		<td class="full" align="center">Yes</td>
</tr>		</tr>
<tr id="283">		<tr id="283">
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_283.htm">283</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_283.htm">283</a></td>
<td>C99</td>		<td>C99</td>
<td>Accessing a non-current union member ("type punning")</td>		<td>Accessing a non-current union member ("type punning")</td>
<td class="unknown" align="center">Unknown</td>		<td class="unknown" align="center">Unknown</td>
</tr>		</tr>
▲ Show 20 Lines • Show All 1,043 Lines • Show Last 20 Lines

clang/www/c_status.html

Show First 20 Lines • Show All 921 Lines • ▼ Show 20 Lines	<tr>
<td class="none" align="center">No</td>		<td class="none" align="center">No</td>
</tr>		</tr>
<tr>		<tr>
<td>Numerically equal</td>		<td>Numerically equal</td>
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2716.htm">N2716</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2716.htm">N2716</a></td>
<td class="full" align="center">Yes</td>		<td class="full" align="center">Yes</td>
</tr>		</tr>
<tr>		<tr>
<td>char16_t & char32_t string literals shall be UTF-16 & UTF-32</td>		<td>char16_t & char32_t string literals shall be UTF-16 & UTF-32</td>
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2728.htm">N2728</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2728.htm">N2728</a></td>
<td class="full" align="center">Yes</td>		<td class="full" align="center">Yes</td>
</tr>		</tr>
<tr>		<tr>
<td>IEC 60559 binding</td>		<td>IEC 60559 binding</td>
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2749.pdf">N2749</a></td>		<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2749.pdf">N2749</a></td>
<td class="unknown" align="center">Unknown</td>		<td class="unknown" align="center">Unknown</td>
</tr>		</tr>
▲ Show 20 Lines • Show All 302 Lines • Show Last 20 Lines

clang/www/compatibility.html

Show First 20 Lines • Show All 206 Lines • ▼ Show 20 Lines
<p>Clang disallows jumps into the scope of a <tt>__block</tt>		<p>Clang disallows jumps into the scope of a <tt>__block</tt>
variable. Variables marked with <tt>__block</tt> require special		variable. Variables marked with <tt>__block</tt> require special
runtime initialization. A jump into the scope of a <tt>__block</tt>		runtime initialization. A jump into the scope of a <tt>__block</tt>
variable bypasses this initialization, leaving the variable's metadata		variable bypasses this initialization, leaving the variable's metadata
in an invalid state. Consider the following code fragment:</p>		in an invalid state. Consider the following code fragment:</p>

<pre>		<pre>
int fetch_object_state(struct MyObject *c) {		int fetch_object_state(struct MyObject *c) {
if (!c->active) goto error;		if (!c->active) goto error;

__block int result;		__block int result;
run_specially_somehow(^{ result = c->state; });		run_specially_somehow(^{ result = c->state; });
return result;		return result;

error:		error:
fprintf(stderr, "error while fetching object state");		fprintf(stderr, "error while fetching object state");
return -1;		return -1;
}		}
</pre>		</pre>

<p>GCC accepts this code, but it produces code that will usually crash		<p>GCC accepts this code, but it produces code that will usually crash
when <code>result</code> goes out of scope if the jump is taken. (It's		when <code>result</code> goes out of scope if the jump is taken. (It's
possible for this bug to go undetected because it often won't crash if		possible for this bug to go undetected because it often won't crash if
the stack is fresh, i.e. still zeroed.) Therefore, Clang rejects this		the stack is fresh, i.e. still zeroed.) Therefore, Clang rejects this
code with a hard error:</p>		code with a hard error:</p>

<pre>		<pre>
<b>t.c:3:5: <span class="error">error:</span> goto into protected scope</b>		<b>t.c:3:5: <span class="error">error:</span> goto into protected scope</b>
goto error;		goto error;
<span class="caret"> ^</span>		<span class="caret"> ^</span>
<b>t.c:5:15: <span class="note">note:</note></b> jump bypasses setup of __block variable		<b>t.c:5:15: <span class="note">note:</span></b> jump bypasses setup of __block variable
__block int result;		__block int result;
<span class="caret"> ^</span>		<span class="caret"> ^</span>
</pre>		</pre>

<p>The fix is to rewrite the code to not require jumping into a		<p>The fix is to rewrite the code to not require jumping into a
<tt>__block</tt> variable's scope, e.g. by limiting that scope:</p>		<tt>__block</tt> variable's scope, e.g. by limiting that scope:</p>

<pre>		<pre>
{		{
__block int result;		__block int result;
run_specially_somehow(^{ result = c->state; });		run_specially_somehow(^{ result = c->state; });
return result;		return result;
}		}
</pre>		</pre>

<!-- ======================================================================= -->		<!-- ======================================================================= -->
<h3 id="block-variable-initialization">Non-initialization of <tt>__block</tt>		<h3 id="block-variable-initialization">Non-initialization of <tt>__block</tt>
variables</h3>		variables</h3>
<!-- ======================================================================= -->		<!-- ======================================================================= -->
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
<tt>struct objc_selector</tt>, and <tt>struct objc_class</tt> in place of the types		<tt>struct objc_selector</tt>, and <tt>struct objc_class</tt> in place of the types
<tt>id</tt>, <tt>SEL</tt>, and <tt>Class</tt> respectively. Clang treats the		<tt>id</tt>, <tt>SEL</tt>, and <tt>Class</tt> respectively. Clang treats the
internal Objective-C structures as implementation detail and won't do implicit conversions:		internal Objective-C structures as implementation detail and won't do implicit conversions:

<pre>		<pre>
<b>t.mm:11:2: <span class="error">error:</span> no matching function for call to 'f'</b>		<b>t.mm:11:2: <span class="error">error:</span> no matching function for call to 'f'</b>
f((struct objc_object *)p);		f((struct objc_object *)p);
<span class="caret"> ^</span>		<span class="caret"> ^</span>
<b>t.mm:5:6: <span class="note">note:</note></b> candidate function not viable: no known conversion from 'struct objc_object *' to 'id' for 1st argument		<b>t.mm:5:6: <span class="note">note:</span></b> candidate function not viable: no known conversion from 'struct objc_object *' to 'id' for 1st argument
void f(id x);		void f(id x);
<span class="caret"> ^</span>		<span class="caret"> ^</span>
</pre>		</pre>

<p>Code should use types <tt>id</tt>, <tt>SEL</tt>, and <tt>Class</tt>		<p>Code should use types <tt>id</tt>, <tt>SEL</tt>, and <tt>Class</tt>
instead of the internal types.</p>		instead of the internal types.</p>

<!-- ======================================================================= -->		<!-- ======================================================================= -->
▲ Show 20 Lines • Show All 188 Lines • ▼ Show 20 Lines
Clang correctly rejects it with the following errors		Clang correctly rejects it with the following errors
(when <tt>Derived</tt> is eventually instantiated):		(when <tt>Derived</tt> is eventually instantiated):

<pre>		<pre>
<b>my_file.cpp:8:5: <span class="error">error:</span> use of undeclared identifier 'DoThis'</b>		<b>my_file.cpp:8:5: <span class="error">error:</span> use of undeclared identifier 'DoThis'</b>
DoThis(x);		DoThis(x);
<span class="caret"> ^</span>		<span class="caret"> ^</span>
this->		this->
<b>my_file.cpp:2:8: <span class="note">note:</note></b> must qualify identifier to find this declaration in dependent base class		<b>my_file.cpp:2:8: <span class="note">note:</span></b> must qualify identifier to find this declaration in dependent base class
void DoThis(T x) {}		void DoThis(T x) {}
<span class="caret"> ^</span>		<span class="caret"> ^</span>
<b>my_file.cpp:9:5: <span class="error">error:</span> use of undeclared identifier 'DoThat'</b>		<b>my_file.cpp:9:5: <span class="error">error:</span> use of undeclared identifier 'DoThat'</b>
DoThat(x);		DoThat(x);
<span class="caret"> ^</span>		<span class="caret"> ^</span>
this->		this->
<b>my_file.cpp:3:15: <span class="note">note:</note></b> must qualify identifier to find this declaration in dependent base class		<b>my_file.cpp:3:15: <span class="note">note:</span></b> must qualify identifier to find this declaration in dependent base class
static void DoThat(T x) {}		static void DoThat(T x) {}
</pre>		</pre>

Like we said <a href="#dep_lookup">above</a>, unqualified names like		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>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		<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.		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>		However, we can't look into the base class <tt>Base<T></tt>
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines	<pre>
template <class T> class Processor {		template <class T> class Processor {
...		...
void init();		void init();
...		...
};		};
...		...
template <class T> void process() {		template <class T> void process() {
Processor<T> processor;		Processor<T> processor;
processor.innit(); // <-- should be 'init()'		processor.innit(); // <-- should be 'init()'
...		...
}		}
</pre>		</pre>

Unfortunately, we can't flag this mistake as soon as we see it: inside		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		a template, we're not allowed to make assumptions about "dependent
types" like <tt>Processor<T></tt>. Suppose that later on in		types" like <tt>Processor<T></tt>. Suppose that later on in
this file the programmer adds an explicit specialization		this file the programmer adds an explicit specialization
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
</pre>		</pre>

<p>Clang produces the following error:</p>		<p>Clang produces the following error:</p>

<pre>		<pre>
<b>downcast.mm:6:3: <span class="error">error:</span> no matching function for call to 'f'</b>		<b>downcast.mm:6:3: <span class="error">error:</span> no matching function for call to 'f'</b>
f(p);		f(p);
<span class="caret"> ^</span>		<span class="caret"> ^</span>
<b>downcast.mm:4:6: <span class="note">note:</note></b> candidate function not viable: cannot convert from		<b>downcast.mm:4:6: <span class="note">note:</span></b> candidate function not viable: cannot convert from
superclass 'Base ' to subclass 'Derived ' for 1st argument		superclass 'Base ' to subclass 'Derived ' for 1st argument
void f(Derived *p);		void f(Derived *p);
<span class="caret"> ^</span>		<span class="caret"> ^</span>
</pre>		</pre>

<p>If the downcast is actually correct (e.g., because the code has		<p>If the downcast is actually correct (e.g., because the code has
already checked that the object has the appropriate type), add an		already checked that the object has the appropriate type), add an
explicit cast:</p>		explicit cast:</p>
Show All 35 Lines

clang/www/cxx_status.html

Show First 20 Lines • Show All 247 Lines • ▼ Show 20 Lines	<tr>
<td class="partial" align="center">		<td class="partial" align="center">
<details><summary>Partial</summary>		<details><summary>Partial</summary>
Clang provides a <tt>__reference_binds_to_temporary</tt> type trait		Clang provides a <tt>__reference_binds_to_temporary</tt> type trait
builtin, with which the library facility can be partially implemented.		builtin, with which the library facility can be partially implemented.
Both <tt>__reference_constructs_from_temporary</tt> and		Both <tt>__reference_constructs_from_temporary</tt> and
<tt>__reference_converts_from_temporary</tt> builtins should be		<tt>__reference_converts_from_temporary</tt> builtins should be
provided, following the normal cross-vendor convention to implement		provided, following the normal cross-vendor convention to implement
traits requiring compiler support directly.		traits requiring compiler support directly.
</details></td>		</details>
</td>		</td>
</tr>		</tr>
<!-- July 2022 papers -->		<!-- July 2022 papers -->
<tr>		<tr>
<td>The Equality Operator You Are Looking For</td>		<td>The Equality Operator You Are Looking For</td>
<td><a href="https://wg21.link/P2468R2">P2468R2</a></td>		<td><a href="https://wg21.link/P2468R2">P2468R2</a></td>
<td class="full" align="center">Clang 16</td>		<td class="full" align="center">Clang 16</td>
</tr>		</tr>
Show All 31 Lines	<tr>
<td>Relaxing some constexpr restrictions</td>		<td>Relaxing some constexpr restrictions</td>
<td><a href="https://wg21.link/P2448R2">P2448R2</a></td>		<td><a href="https://wg21.link/P2448R2">P2448R2</a></td>
<td class="partial" align="center">		<td class="partial" align="center">
<details><summary>Clang 17 (Partial)</summary>		<details><summary>Clang 17 (Partial)</summary>
We do not support outside of defaulted special memeber functions the change that constexpr functions no		We do not support outside of defaulted special memeber functions the change that constexpr functions no
longer have to be constexpr compatible but rather support a less restricted requirements for constexpr		longer have to be constexpr compatible but rather support a less restricted requirements for constexpr
functions. Which include allowing non-literal types as return values and parameters, allow calling of		functions. Which include allowing non-literal types as return values and parameters, allow calling of
non-constexpr functions and constructors.		non-constexpr functions and constructors.
</details></td>		</details>
</td>		</td>
</tr>		</tr>
<tr>		<tr>
<td>Using unknown pointers and references in constant expressions</td>		<td>Using unknown pointers and references in constant expressions</td>
<td><a href="https://wg21.link/P2280R4">P2280R4</a></td>		<td><a href="https://wg21.link/P2280R4">P2280R4</a></td>
<td class="none" align="center">No</td>		<td class="none" align="center">No</td>
</tr>		</tr>
<tr>		<tr>
▲ Show 20 Lines • Show All 880 Lines • ▼ Show 20 Lines	<tr>
<th>Language Feature</th>		<th>Language Feature</th>
<th>C++11 Proposal</th>		<th>C++11 Proposal</th>
<th>Available in Clang?</th>		<th>Available in Clang?</th>
</tr>		</tr>
<tr>		<tr>
<td rowspan="2">Rvalue references</td>		<td rowspan="2">Rvalue references</td>
<td><a href="https://wg21.link/n2118">N2118</a></td>		<td><a href="https://wg21.link/n2118">N2118</a></td>
<td class="full" align="center">Clang 2.9</td>		<td class="full" align="center">Clang 2.9</td>
		</tr>
<tr> <!-- from Kona 2019-->		<tr> <!-- from Kona 2019-->
<td><a href="https://wg21.link/p1825r0">P1825R0</a> (<a href="#dr">DR</a>)</td>		<td><a href="https://wg21.link/p1825r0">P1825R0</a> (<a href="#dr">DR</a>)</td>
<td class="full" align="center">Clang 13</td>		<td class="full" align="center">Clang 13</td>
</tr>		</tr>
</tr>
<tr>		<tr>
<td>    Rvalue references for <code>*this</code></td>		<td>    Rvalue references for <code>*this</code></td>
<td><a href="https://wg21.link/n2439">N2439</a></td>		<td><a href="https://wg21.link/n2439">N2439</a></td>
<td class="full" align="center">Clang 2.9</td>		<td class="full" align="center">Clang 2.9</td>
</tr>		</tr>
<tr>		<tr>
<td>Initialization of class objects by rvalues</td>		<td>Initialization of class objects by rvalues</td>
<td><a href="https://wg21.link/n1610">N1610</a></td>		<td><a href="https://wg21.link/n1610">N1610</a></td>
▲ Show 20 Lines • Show All 403 Lines • ▼ Show 20 Lines	<tr>
<th>Compiler flag</th>		<th>Compiler flag</th>
<th>Available in Clang?</th>		<th>Available in Clang?</th>
</tr>		</tr>
<tr id="sd6">		<tr id="sd6">
<td rowspan="7">SD-6: SG10 feature test recommendations</td>		<td rowspan="7">SD-6: SG10 feature test recommendations</td>
<td rowspan="7"><a href="https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations">SD-6</a></td>		<td rowspan="7"><a href="https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations">SD-6</a></td>
<td rowspan="7">N/A</td>		<td rowspan="7">N/A</td>
<td class="full" align="center">		<td class="full" align="center">
Clang 3.4 (<a href="https://wg21.link/n3745">N3745</a>)</br>		Clang 3.4 (<a href="https://wg21.link/n3745">N3745</a>)
</td>		</td>
</tr>		</tr>
<tr>		<tr>
<td class="full" align="center">		<td class="full" align="center">
Clang 3.6 (<a href="https://wg21.link/n4200">N4200</a>)</a>		Clang 3.6 (<a href="https://wg21.link/n4200">N4200</a>)
</td>		</td>
</tr>		</tr>
<tr>		<tr>
<td class="full" align="center">		<td class="full" align="center">
Clang 4 (<a href="https://wg21.link/p0096r3">P0096R3</a>)</a>		Clang 4 (<a href="https://wg21.link/p0096r3">P0096R3</a>)
</td>		</td>
</tr>		</tr>
<tr>		<tr>
<td class="full" align="center">		<td class="full" align="center">
Clang 5 (<a href="https://wg21.link/p0096r4">P0096R4</a>)</a>		Clang 5 (<a href="https://wg21.link/p0096r4">P0096R4</a>)
</td>		</td>
</tr>		</tr>
<tr>		<tr>
<td class="full" align="center">		<td class="full" align="center">
Clang 7 (<a href="https://wg21.link/p0096r5">P0096R5</a>)</a>		Clang 7 (<a href="https://wg21.link/p0096r5">P0096R5</a>)
</td>		</td>
</tr>		</tr>
<tr>		<tr>
<td class="full" align="center">		<td class="full" align="center">
Clang 9 (<a href="https://wg21.link/p1353r0">P1353R0</a>)		Clang 9 (<a href="https://wg21.link/p1353r0">P1353R0</a>)
</td>		</td>
</tr>		</tr>
<tr>		<tr>
<td class="full" align="center">		<td class="full" align="center">
Clang 10 (<a href="https://wg21.link/p1902r1">P1902R1</a>)</a>		Clang 10 (<a href="https://wg21.link/p1902r1">P1902R1</a>)
</td>		</td>
</tr>		</tr>
<!-- No compiler support is known to be needed for:		<!-- No compiler support is known to be needed for:
* Concurrency TS		* Concurrency TS
* Parallelism TS (v1, v2)		* Parallelism TS (v1, v2)
* Ranges TS		* Ranges TS
* Networking TS		* Networking TS
* File System TS		* File System TS
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

clang/www/diagnostics.html

Show First 20 Lines • Show All 334 Lines • ▼ Show 20 Lines	<pre>
$ <span class="cmd">gcc-4.9 t.cc</span>		$ <span class="cmd">gcc-4.9 t.cc</span>
t.cc:1:33: error: variable or field 'f' declared void		t.cc:1:33: error: variable or field 'f' declared void
template<class T> void f(T::type) { }		template<class T> void f(T::type) { }
^		^
t.cc: In function 'void g()':		t.cc: In function 'void g()':
t.cc:6:5: error: 'f' was not declared in this scope		t.cc:6:5: error: 'f' was not declared in this scope
f<A>(a);		f<A>(a);
^		^
t.cc:6:8: error: expected primary-expression before '>' token		t.cc:6:8: error: expected primary-expression before '>' token
f<A>(a);		f<A>(a);
^		^
$ <span class="cmd">clang t.cc</span>		$ <span class="cmd">clang t.cc</span>
<span class="loc">t.cc:1:26:</span> <span class="err">error:</span> <span class="msg">missing 'typename' prior to dependent type name 'T::type'</span>		<span class="loc">t.cc:1:26:</span> <span class="err">error:</span> <span class="msg">missing 'typename' prior to dependent type name 'T::type'</span>
<span class="snip" >template<class T> void f(T::type) { }</span>		<span class="snip" >template<class T> void f(T::type) { }</span>
<span class="point"> ^~~~~~~</span>		<span class="point"> ^~~~~~~</span>
<span class="point"> typename </span>		<span class="point"> typename </span>
<span class="loc">t.cc:6:5:</span> <span class="err">error:</span> <span class="msg">no matching function for call to 'f'</span>		<span class="loc">t.cc:6:5:</span> <span class="err">error:</span> <span class="msg">no matching function for call to 'f'</span>
Show All 15 Lines

compiler-rt/www/index.html

Show All 10 Lines

<body>		<body>
<!--#include virtual="menu.html.incl"-->		<!--#include virtual="menu.html.incl"-->
<div id="content">		<div id="content">
<!--*********************************************************************-->		<!--*********************************************************************-->
<h1>"compiler-rt" runtime libraries</h1>		<h1>"compiler-rt" runtime libraries</h1>
<!--*********************************************************************-->		<!--*********************************************************************-->

<p>The compiler-rt project consists of:		<p>The compiler-rt project consists of:</p>
<ul>		<ul>
<li>		<li>
<p><b>builtins</b> - a simple library that provides an implementation		<p><b>builtins</b> - a simple library that provides an implementation
of the low-level target-specific hooks required by code generation and		of the low-level target-specific hooks required by code generation and
other runtime components. For example, when compiling for a 32-bit target,		other runtime components. For example, when compiling for a 32-bit target,
converting a double to a 64-bit unsigned integer is compiling into a runtime		converting a double to a 64-bit unsigned integer is compiling into a runtime
call to the "__fixunsdfdi" function. The builtins library provides		call to the "__fixunsdfdi" function. The builtins library provides
optimized implementations of this and other low-level routines, either in		optimized implementations of this and other low-level routines, either in
Show All 19 Lines	<div id="content">
<li>		<li>
<b>profile</b> - library which is used to collect coverage information.		<b>profile</b> - library which is used to collect coverage information.
</li>		</li>
<li>		<li>
<b>BlocksRuntime</b> - a target-independent implementation of Apple "Blocks"		<b>BlocksRuntime</b> - a target-independent implementation of Apple "Blocks"
runtime interfaces.		runtime interfaces.
</li>		</li>
</ul>		</ul>
</p>

<p>All of the code in the compiler-rt project is <a		<p>All of the code in the compiler-rt project is <a
href="https://llvm.org/docs/DeveloperPolicy.html#copyright-license-and-patents">dual licensed</a>		href="https://llvm.org/docs/DeveloperPolicy.html#copyright-license-and-patents">dual licensed</a>
under the MIT license and the UIUC License (a BSD-like license).</p>		under the MIT license and the UIUC License (a BSD-like license).</p>

<!--=====================================================================-->		<!--=====================================================================-->
<h2 id="users">Clients</h2>		<h2 id="users">Clients</h2>
<!--=====================================================================-->		<!--=====================================================================-->
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

libclc/www/index.html

	<html>			<html>
	<head>			<head>
	<title>libclc</title>			<title>libclc</title>
	</head>			</head>
	<body>			<body>
	<h1>libclc</h1>			<h1>libclc</h1>
	<p>			<p>
	libclc is an open source, BSD/MIT dual licensed			libclc is an open source, BSD/MIT dual licensed
	implementation of the library requirements of the			implementation of the library requirements of the
	OpenCL C programming language, as specified by the <a			OpenCL C programming language, as specified by the <a
	href="https://www.khronos.org/registry/OpenCL/specs/opencl-1.1.pdf">OpenCL			href="https://www.khronos.org/registry/OpenCL/specs/opencl-1.1.pdf">OpenCL
	1.1 Specification</a>. The following sections of the specification			1.1 Specification</a>. The following sections of the specification
	impose library requirements:			impose library requirements:</p>
	<ul>			<ul>
	<li>6.1: Supported Data Types			<li>6.1: Supported Data Types
	<li>6.2.3: Explicit Conversions			<li>6.2.3: Explicit Conversions
	<li>6.2.4.2: Reinterpreting Types Using as_type() and as_typen()			<li>6.2.4.2: Reinterpreting Types Using as_type() and as_typen()
	<li>6.9: Preprocessor Directives and Macros			<li>6.9: Preprocessor Directives and Macros
	<li>6.11: Built-in Functions			<li>6.11: Built-in Functions
	<li>9.3: Double Precision Floating-Point			<li>9.3: Double Precision Floating-Point
	<li>9.4: 64-bit Atomics			<li>9.4: 64-bit Atomics
	<li>9.5: Writing to 3D image memory objects			<li>9.5: Writing to 3D image memory objects
	<li>9.6: Half Precision Floating-Point			<li>9.6: Half Precision Floating-Point
	</ul>			</ul>
	</p>

	<p>			<p>
	libclc is intended to be used with the <a href="https://clang.llvm.org/">Clang</a>			libclc is intended to be used with the <a href="https://clang.llvm.org/">Clang</a>
	compiler's OpenCL frontend.			compiler's OpenCL frontend.
	</p>			</p>

	<p>			<p>
	libclc is designed to be portable and extensible. To this end,			libclc is designed to be portable and extensible. To this end,
	Show All 20 Lines

llvm/test/tools/llvm-original-di-preservation/Inputs/expected-compressed.html

Show All 15 Lines	<html>
<tr>		<tr>
<th>File</th>		<th>File</th>
<th>LLVM Pass Name</th>		<th>LLVM Pass Name</th>
<th>LLVM IR Instruction</th>		<th>LLVM IR Instruction</th>
<th>Function Name</th>		<th>Function Name</th>
<th>Basic Block Name</th>		<th>Basic Block Name</th>
<th>Action</th>		<th>Action</th>
</tr>		</tr>
</tr>
<tr>		<tr>
<td>test.ll</td>		<td>test.ll</td>
<td>no-name</td>		<td>no-name</td>
<td>extractvalue</td>		<td>extractvalue</td>
<td>fn</td>		<td>fn</td>
<td>no-name</td>		<td>no-name</td>
<td>not-generate</td>		<td>not-generate</td>
</tr>		</tr>
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines	<tr>
<th>Number of bugs</th>		<th>Number of bugs</th>
</tr>		</tr>
<tr>		<tr>
<tr>		<tr>
<td colspan='2'> No bugs found </td>		<td colspan='2'> No bugs found </td>
</tr>		</tr>
</table>		</table>
</body>		</body>
</html>		</html>
No newline at end of file

llvm/test/tools/llvm-original-di-preservation/Inputs/expected-sample.html

Show All 15 Lines	<html>
<tr>		<tr>
<th>File</th>		<th>File</th>
<th>LLVM Pass Name</th>		<th>LLVM Pass Name</th>
<th>LLVM IR Instruction</th>		<th>LLVM IR Instruction</th>
<th>Function Name</th>		<th>Function Name</th>
<th>Basic Block Name</th>		<th>Basic Block Name</th>
<th>Action</th>		<th>Action</th>
</tr>		</tr>
</tr>
<tr>		<tr>
<td>test.ll</td>		<td>test.ll</td>
<td>no-name</td>		<td>no-name</td>
<td>extractvalue</td>		<td>extractvalue</td>
<td>fn</td>		<td>fn</td>
<td>no-name</td>		<td>no-name</td>
<td>not-generate</td>		<td>not-generate</td>
</tr>		</tr>
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines	<tr>
<th>Number of bugs</th>		<th>Number of bugs</th>
</tr>		</tr>
<tr>		<tr>
<tr>		<tr>
<td colspan='2'> No bugs found </td>		<td colspan='2'> No bugs found </td>
</tr>		</tr>
</table>		</table>
</body>		</body>
</html>		</html>
No newline at end of file

llvm/test/tools/llvm-original-di-preservation/Inputs/expected-skipped.html

Show All 15 Lines	<html>
<tr>		<tr>
<th>File</th>		<th>File</th>
<th>LLVM Pass Name</th>		<th>LLVM Pass Name</th>
<th>LLVM IR Instruction</th>		<th>LLVM IR Instruction</th>
<th>Function Name</th>		<th>Function Name</th>
<th>Basic Block Name</th>		<th>Basic Block Name</th>
<th>Action</th>		<th>Action</th>
</tr>		</tr>
</tr>
<tr>		<tr>
<td>wrstabs.c</td>		<td>wrstabs.c</td>
<td>Simplify the CFG</td>		<td>Simplify the CFG</td>
<td>br</td>		<td>br</td>
<td>stab_function_type</td>		<td>stab_function_type</td>
<td>if.end</td>		<td>if.end</td>
<td>drop</td>		<td>drop</td>
</tr>		</tr>
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines	<table>
<caption><b>Variable Location Bugs found by the Debugify</b></caption>		<caption><b>Variable Location Bugs found by the Debugify</b></caption>
<tr>		<tr>
<th>File</th>		<th>File</th>
<th>LLVM Pass Name</th>		<th>LLVM Pass Name</th>
<th>Variable</th>		<th>Variable</th>
<th>Function</th>		<th>Function</th>
<th>Action</th>		<th>Action</th>
</tr>		</tr>
</tr>
<tr>		<tr>
<td>debug.c</td>		<td>debug.c</td>
<td>Simplify the CFG</td>		<td>Simplify the CFG</td>
<td>pf1</td>		<td>pf1</td>
<td>debug_class_type_samep</td>		<td>debug_class_type_samep</td>
<td>drop</td>		<td>drop</td>
</tr>		</tr>
<tr>		<tr>
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines	</tr>
</tr>		</tr>
<tr>		<tr>
<td>Simplify the CFG</td>		<td>Simplify the CFG</td>
<td>9</td>		<td>9</td>
</tr>		</tr>
<tr>		<tr>
</table>		</table>
</body>		</body>
</html>		</html>
No newline at end of file

llvm/test/tools/opt-viewer/Outputs/basic/basic_or.h.html

	Show All 21 Lines
	}			}
	</script>			</script>
	</head>			</head>
	<body>			<body>
	<div class="centered">			<div class="centered">
	<table class="source">			<table class="source">
	<thead>			<thead>
	<tr>			<tr>
	<th style="width: 2%">Line</td>			<th style="width: 2%">Line</th>
	<th style="width: 3%">Hotness</td>			<th style="width: 3%">Hotness</th>
	<th style="width: 10%">Optimization</td>			<th style="width: 10%">Optimization</th>
	<th style="width: 70%">Source</td>			<th style="width: 70%">Source</th>
	<th style="width: 15%">Inline Context</td>			<th style="width: 15%">Inline Context</th>
	</tr>			</tr>
	</thead>			</thead>
	<tbody>			<tbody>

	<tr>			<tr>
	<td><a name="L1">1</a></td>			<td><a name="L1">1</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	Show All 20 Lines
	<td></td>			<td></td>
	<td><div class="highlight"><pre>#pragma clang loop vectorize(assume_safety)</pre></div></td>			<td><div class="highlight"><pre>#pragma clang loop vectorize(assume_safety)</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L5">5</a></td>			<td><a name="L5">5</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> for (i = 0; i < 1600; i++) {</pre></div></td>			<td><div class="highlight"><pre> for (i = 0; i < 1600; i++) {</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td class="column-entry-green">loop-vectorize</td>			<td class="column-entry-green">loop-vectorize</td>
	<td><pre style="display:inline"> </pre><span class="column-entry-yellow"> vectorized loop (vectorization width: 4, interleaved count: 2) </span></td>			<td><pre style="display:inline"> </pre><span class="column-entry-yellow"> vectorized loop (vectorization width: 4, interleaved count: 2) </span></td>
	<td class="column-entry-yellow">TestH</td>			<td class="column-entry-yellow">TestH</td>
	Show All 19 Lines
	<td></td>			<td></td>
	<td><div class="highlight"><pre></pre></div></td>			<td><div class="highlight"><pre></pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L9">9</a></td>			<td><a name="L9">9</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> for (i = 0; i < 16; i++) {</pre></div></td>			<td><div class="highlight"><pre> for (i = 0; i < 16; i++) {</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td class="column-entry-green">loop-unroll</td>			<td class="column-entry-green">loop-unroll</td>
	<td><pre style="display:inline"> </pre><span class="column-entry-yellow"> completely unrolled loop with 16 iterations </span></td>			<td><pre style="display:inline"> </pre><span class="column-entry-yellow"> completely unrolled loop with 16 iterations </span></td>
	<td class="column-entry-yellow">TestH</td>			<td class="column-entry-yellow">TestH</td>
	▲ Show 20 Lines • Show All 108 Lines • ▼ Show 20 Lines
	<td><a name="L17">17</a></td>			<td><a name="L17">17</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre></pre></div></td>			<td><div class="highlight"><pre></pre></div></td>
	</tr>			</tr>

	</tbody>			</tbody>
	</table>			</table>
				</div>
	</body>			</body>
	</html>			</html>

llvm/test/tools/opt-viewer/Outputs/basic/basic_or.c.html

	Show All 21 Lines
	}			}
	</script>			</script>
	</head>			</head>
	<body>			<body>
	<div class="centered">			<div class="centered">
	<table class="source">			<table class="source">
	<thead>			<thead>
	<tr>			<tr>
	<th style="width: 2%">Line</td>			<th style="width: 2%">Line</th>
	<th style="width: 3%">Hotness</td>			<th style="width: 3%">Hotness</th>
	<th style="width: 10%">Optimization</td>			<th style="width: 10%">Optimization</th>
	<th style="width: 70%">Source</td>			<th style="width: 70%">Source</th>
	<th style="width: 15%">Inline Context</td>			<th style="width: 15%">Inline Context</th>
	</tr>			</tr>
	</thead>			</thead>
	<tbody>			<tbody>

	<tr>			<tr>
	<td><a name="L1">1</a></td>			<td><a name="L1">1</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
	<td></td>			<td></td>
	<td><div class="highlight"><pre>#pragma clang loop vectorize(assume_safety)</pre></div></td>			<td><div class="highlight"><pre>#pragma clang loop vectorize(assume_safety)</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L10">10</a></td>			<td><a name="L10">10</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> for (i = 0; i < 1600; i++) {</pre></div></td>			<td><div class="highlight"><pre> for (i = 0; i < 1600; i++) {</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td class="column-entry-green">loop-vectorize</td>			<td class="column-entry-green">loop-vectorize</td>
	<td><pre style="display:inline"> </pre><span class="column-entry-yellow"> vectorized loop (vectorization width: 4, interleaved count: 2) </span></td>			<td><pre style="display:inline"> </pre><span class="column-entry-yellow"> vectorized loop (vectorization width: 4, interleaved count: 2) </span></td>
	<td class="column-entry-yellow">Test</td>			<td class="column-entry-yellow">Test</td>
	Show All 33 Lines
	<td></td>			<td></td>
	<td><div class="highlight"><pre></pre></div></td>			<td><div class="highlight"><pre></pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L14">14</a></td>			<td><a name="L14">14</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> for (i = 0; i < 16; i++) {</pre></div></td>			<td><div class="highlight"><pre> for (i = 0; i < 16; i++) {</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td class="column-entry-green">loop-unroll</td>			<td class="column-entry-green">loop-unroll</td>
	<td><pre style="display:inline"> </pre><span class="column-entry-yellow"> completely unrolled loop with 16 iterations </span></td>			<td><pre style="display:inline"> </pre><span class="column-entry-yellow"> completely unrolled loop with 16 iterations </span></td>
	<td class="column-entry-yellow">Test</td>			<td class="column-entry-yellow">Test</td>
	▲ Show 20 Lines • Show All 108 Lines • ▼ Show 20 Lines
	<td><a name="L22">22</a></td>			<td><a name="L22">22</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre></pre></div></td>			<td><div class="highlight"><pre></pre></div></td>
	</tr>			</tr>

	</tbody>			</tbody>
	</table>			</table>
				</div>
	</body>			</body>
	</html>			</html>

llvm/test/tools/opt-viewer/Outputs/basic/index.html

	Show First 20 Lines • Show All 149 Lines • ▼ Show 20 Lines
	<tr>			<tr>
	<td class="column-entry-1"><a href="basic_or.h.html#L15">basic/or.h:15:17</a></td>			<td class="column-entry-1"><a href="basic_or.h.html#L15">basic/or.h:15:17</a></td>
	<td class="column-entry-1"></td>			<td class="column-entry-1"></td>
	<td class="column-entry-1">TestH</td>			<td class="column-entry-1">TestH</td>
	<td class="column-entry-green">inline</td>			<td class="column-entry-green">inline</td>
	</tr>			</tr>

	</table>			</table>
				</div>
	</body>			</body>
	</html>			</html>

llvm/test/tools/opt-viewer/Outputs/filter/basic_or.h.html

	Show All 21 Lines
	}			}
	</script>			</script>
	</head>			</head>
	<body>			<body>
	<div class="centered">			<div class="centered">
	<table class="source">			<table class="source">
	<thead>			<thead>
	<tr>			<tr>
	<th style="width: 2%">Line</td>			<th style="width: 2%">Line</th>
	<th style="width: 3%">Hotness</td>			<th style="width: 3%">Hotness</th>
	<th style="width: 10%">Optimization</td>			<th style="width: 10%">Optimization</th>
	<th style="width: 70%">Source</td>			<th style="width: 70%">Source</th>
	<th style="width: 15%">Inline Context</td>			<th style="width: 15%">Inline Context</th>
	</tr>			</tr>
	</thead>			</thead>
	<tbody>			<tbody>

	<tr>			<tr>
	<td><a name="L1">1</a></td>			<td><a name="L1">1</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	Show All 20 Lines
	<td></td>			<td></td>
	<td><div class="highlight"><pre>#pragma clang loop vectorize(assume_safety)</pre></div></td>			<td><div class="highlight"><pre>#pragma clang loop vectorize(assume_safety)</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L5">5</a></td>			<td><a name="L5">5</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> for (i = 0; i < 1600; i++) {</pre></div></td>			<td><div class="highlight"><pre> for (i = 0; i < 1600; i++) {</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L6">6</a></td>			<td><a name="L6">6</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> res[i] = (p[i] == 0) ? res[i] : res[i] + d[i];</pre></div></td>			<td><div class="highlight"><pre> res[i] = (p[i] == 0) ? res[i] : res[i] + d[i];</pre></div></td>
	</tr>			</tr>
	Show All 11 Lines
	<td></td>			<td></td>
	<td><div class="highlight"><pre></pre></div></td>			<td><div class="highlight"><pre></pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L9">9</a></td>			<td><a name="L9">9</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> for (i = 0; i < 16; i++) {</pre></div></td>			<td><div class="highlight"><pre> for (i = 0; i < 16; i++) {</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L10">10</a></td>			<td><a name="L10">10</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> res[i] = (p[i] == 0) ? res[i] : res[i] + d[i];</pre></div></td>			<td><div class="highlight"><pre> res[i] = (p[i] == 0) ? res[i] : res[i] + d[i];</pre></div></td>
	</tr>			</tr>
	▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines
	<td><a name="L17">17</a></td>			<td><a name="L17">17</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre></pre></div></td>			<td><div class="highlight"><pre></pre></div></td>
	</tr>			</tr>

	</tbody>			</tbody>
	</table>			</table>
				</div>
	</body>			</body>
	</html>			</html>

llvm/test/tools/opt-viewer/Outputs/filter/basic_or.c.html

	Show All 21 Lines
	}			}
	</script>			</script>
	</head>			</head>
	<body>			<body>
	<div class="centered">			<div class="centered">
	<table class="source">			<table class="source">
	<thead>			<thead>
	<tr>			<tr>
	<th style="width: 2%">Line</td>			<th style="width: 2%">Line</th>
	<th style="width: 3%">Hotness</td>			<th style="width: 3%">Hotness</th>
	<th style="width: 10%">Optimization</td>			<th style="width: 10%">Optimization</th>
	<th style="width: 70%">Source</td>			<th style="width: 70%">Source</th>
	<th style="width: 15%">Inline Context</td>			<th style="width: 15%">Inline Context</th>
	</tr>			</tr>
	</thead>			</thead>
	<tbody>			<tbody>

	<tr>			<tr>
	<td><a name="L1">1</a></td>			<td><a name="L1">1</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
	<td></td>			<td></td>
	<td><div class="highlight"><pre>#pragma clang loop vectorize(assume_safety)</pre></div></td>			<td><div class="highlight"><pre>#pragma clang loop vectorize(assume_safety)</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L10">10</a></td>			<td><a name="L10">10</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> for (i = 0; i < 1600; i++) {</pre></div></td>			<td><div class="highlight"><pre> for (i = 0; i < 1600; i++) {</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L11">11</a></td>			<td><a name="L11">11</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> res[i] = (p[i] == 0) ? res[i] : res[i] + d[i];</pre></div></td>			<td><div class="highlight"><pre> res[i] = (p[i] == 0) ? res[i] : res[i] + d[i];</pre></div></td>
	</tr>			</tr>
	Show All 11 Lines
	<td></td>			<td></td>
	<td><div class="highlight"><pre></pre></div></td>			<td><div class="highlight"><pre></pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L14">14</a></td>			<td><a name="L14">14</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> for (i = 0; i < 16; i++) {</pre></div></td>			<td><div class="highlight"><pre> for (i = 0; i < 16; i++) {</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L15">15</a></td>			<td><a name="L15">15</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> res[i] = (p[i] == 0) ? res[i] : res[i] + d[i];</pre></div></td>			<td><div class="highlight"><pre> res[i] = (p[i] == 0) ? res[i] : res[i] + d[i];</pre></div></td>
	</tr>			</tr>
	▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines
	<td><a name="L22">22</a></td>			<td><a name="L22">22</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre></pre></div></td>			<td><div class="highlight"><pre></pre></div></td>
	</tr>			</tr>

	</tbody>			</tbody>
	</table>			</table>
				</div>
	</body>			</body>
	</html>			</html>

llvm/test/tools/opt-viewer/Outputs/filter/index.html

	Show First 20 Lines • Show All 114 Lines • ▼ Show 20 Lines
	<tr>			<tr>
	<td class="column-entry-0"><a href="basic_or.h.html#L15">basic/or.h:15:17</a></td>			<td class="column-entry-0"><a href="basic_or.h.html#L15">basic/or.h:15:17</a></td>
	<td class="column-entry-0"></td>			<td class="column-entry-0"></td>
	<td class="column-entry-0">TestH</td>			<td class="column-entry-0">TestH</td>
	<td class="column-entry-green">inline</td>			<td class="column-entry-green">inline</td>
	</tr>			</tr>

	</table>			</table>
				</div>
	</body>			</body>
	</html>			</html>

llvm/test/tools/opt-viewer/Outputs/suppress/index.html

	Show All 16 Lines
	<tr>			<tr>
	<td class="column-entry-0"><a href="s.swift.html#L12">s.swift:12:1</a></td>			<td class="column-entry-0"><a href="s.swift.html#L12">s.swift:12:1</a></td>
	<td class="column-entry-0"></td>			<td class="column-entry-0"></td>
	<td class="column-entry-0">main</td>			<td class="column-entry-0">main</td>
	<td class="column-entry-green">sil-inliner</td>			<td class="column-entry-green">sil-inliner</td>
	</tr>			</tr>

	</table>			</table>
				</div>
	</body>			</body>
	</html>			</html>

llvm/test/tools/opt-viewer/Outputs/suppress/s.swift.html

	Show All 21 Lines
	}			}
	</script>			</script>
	</head>			</head>
	<body>			<body>
	<div class="centered">			<div class="centered">
	<table class="source">			<table class="source">
	<thead>			<thead>
	<tr>			<tr>
	<th style="width: 2%">Line</td>			<th style="width: 2%">Line</th>
	<th style="width: 3%">Hotness</td>			<th style="width: 3%">Hotness</th>
	<th style="width: 10%">Optimization</td>			<th style="width: 10%">Optimization</th>
	<th style="width: 70%">Source</td>			<th style="width: 70%">Source</th>
	<th style="width: 15%">Inline Context</td>			<th style="width: 15%">Inline Context</th>
	</tr>			</tr>
	</thead>			</thead>
	<tbody>			<tbody>

	<tr>			<tr>
	<td><a name="L1">1</a></td>			<td><a name="L1">1</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	Show All 27 Lines
	<td></td>			<td></td>
	<td><div class="highlight"><pre>func f() {</pre></div></td>			<td><div class="highlight"><pre>func f() {</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L6">6</a></td>			<td><a name="L6">6</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> for i in 0..<4 {</pre></div></td>			<td><div class="highlight"><pre> for i in 0..<4 {</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L7">7</a></td>			<td><a name="L7">7</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> print(s[i])</pre></div></td>			<td><div class="highlight"><pre> print(s[i])</pre></div></td>
	</tr>			</tr>
	Show All 38 Lines
	<td></td>			<td></td>
	<td class="column-entry-green">sil-inliner</td>			<td class="column-entry-green">sil-inliner</td>
	<td><pre style="display:inline"></pre><span class="column-entry-yellow"> <a href="s.swift.html#L6">"s.f()"</a> inlined into "main" (cost = 20, benefit = 20) </span></td>			<td><pre style="display:inline"></pre><span class="column-entry-yellow"> <a href="s.swift.html#L6">"s.f()"</a> inlined into "main" (cost = 20, benefit = 20) </span></td>
	<td class="column-entry-yellow">main</td>			<td class="column-entry-yellow">main</td>
	</tr>			</tr>

	</tbody>			</tbody>
	</table>			</table>
				</div>
	</body>			</body>
	</html>			</html>

llvm/test/tools/opt-viewer/Outputs/unicode-function-name/index.html

	Show All 16 Lines
	<tr>			<tr>
	<td class="column-entry-0"><a href="s.swift.html#L12">s.swift:12:16</a></td>			<td class="column-entry-0"><a href="s.swift.html#L12">s.swift:12:16</a></td>
	<td class="column-entry-0"></td>			<td class="column-entry-0"></td>
	<td class="column-entry-0">main</td>			<td class="column-entry-0">main</td>
	<td class="column-entry-green">sil-inliner</td>			<td class="column-entry-green">sil-inliner</td>
	</tr>			</tr>

	</table>			</table>
				</div>
	</body>			</body>
	</html>			</html>

llvm/test/tools/opt-viewer/Outputs/unicode-function-name/s.swift.html

	Show All 21 Lines
	}			}
	</script>			</script>
	</head>			</head>
	<body>			<body>
	<div class="centered">			<div class="centered">
	<table class="source">			<table class="source">
	<thead>			<thead>
	<tr>			<tr>
	<th style="width: 2%">Line</td>			<th style="width: 2%">Line</th>
	<th style="width: 3%">Hotness</td>			<th style="width: 3%">Hotness</th>
	<th style="width: 10%">Optimization</td>			<th style="width: 10%">Optimization</th>
	<th style="width: 70%">Source</td>			<th style="width: 70%">Source</th>
	<th style="width: 15%">Inline Context</td>			<th style="width: 15%">Inline Context</th>
	</tr>			</tr>
	</thead>			</thead>
	<tbody>			<tbody>

	<tr>			<tr>
	<td><a name="L1">1</a></td>			<td><a name="L1">1</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre>infix operator •: AdditionPrecedence</pre></div></td>			<td><div class="highlight"><pre>infix operator •: AdditionPrecedence</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L2">2</a></td>			<td><a name="L2">2</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre></pre></div></td>			<td><div class="highlight"><pre></pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L3">3</a></td>			<td><a name="L3">3</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre>func • (a: Int, b: Int) -> Int {</pre></div></td>			<td><div class="highlight"><pre>func • (a: Int, b: Int) -> Int {</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L4">4</a></td>			<td><a name="L4">4</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> return a * b</pre></div></td>			<td><div class="highlight"><pre> return a * b</pre></div></td>
	</tr>			</tr>
	Show All 18 Lines
	<td></td>			<td></td>
	<td><div class="highlight"><pre>@inline(never)</pre></div></td>			<td><div class="highlight"><pre>@inline(never)</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L8">8</a></td>			<td><a name="L8">8</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre>func g(a: Int) -> Int{</pre></div></td>			<td><div class="highlight"><pre>func g(a: Int) -> Int{</pre></div></td>
	</tr>			</tr>

	<tr>			<tr>
	<td><a name="L9">9</a></td>			<td><a name="L9">9</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre> return a + 1</pre></div></td>			<td><div class="highlight"><pre> return a + 1</pre></div></td>
	</tr>			</tr>
	Show All 31 Lines
	<td><a name="L13">13</a></td>			<td><a name="L13">13</a></td>
	<td></td>			<td></td>
	<td></td>			<td></td>
	<td><div class="highlight"><pre></pre></div></td>			<td><div class="highlight"><pre></pre></div></td>
	</tr>			</tr>

	</tbody>			</tbody>
	</table>			</table>
				</div>
	</body>			</body>
	</html>			</html>

llvm/tools/opt-viewer/opt-viewer.py

Show First 20 Lines • Show All 213 Lines • ▼ Show 20 Lines	<tbody>""".format(
file=self.stream,		file=self.stream,
)		)
self.render_source_lines(self.source_stream, line_remarks)		self.render_source_lines(self.source_stream, line_remarks)

print(		print(
"""		"""
</tbody>		</tbody>
</table>		</table>
		</div>
</body>		</body>
</html>""",		</html>""",
file=self.stream,		file=self.stream,
)		)


class IndexRenderer:		class IndexRenderer:
def __init__(		def __init__(
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines	</tr>""",
max_entries = self.max_hottest_remarks_on_index		max_entries = self.max_hottest_remarks_on_index

for i, remark in enumerate(all_remarks[:max_entries]):		for i, remark in enumerate(all_remarks[:max_entries]):
if not suppress(remark):		if not suppress(remark):
self.render_entry(remark, i % 2)		self.render_entry(remark, i % 2)
print(		print(
"""		"""
</table>		</table>
		</div>
</body>		</body>
</html>""",		</html>""",
file=self.stream,		file=self.stream,
)		)


def _render_file(source_dir, output_dir, ctx, no_highlight, entry, filter_):		def _render_file(source_dir, output_dir, ctx, no_highlight, entry, filter_):
global context		global context
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

llvm/utils/llvm-original-di-preservation.py

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines	""".format(
]		]

for column in header_di_loc:		for column in header_di_loc:
table_di_loc += " <th>{0}</th>\n".format(column.strip())		table_di_loc += " <th>{0}</th>\n".format(column.strip())
table_di_loc += " </tr>\n"		table_di_loc += " </tr>\n"

at_least_one_bug_found = False		at_least_one_bug_found = False

		first_run = True

# Handle loction bugs.		# Handle loction bugs.
for file, per_file_bugs in di_location_bugs.items():		for file, per_file_bugs in di_location_bugs.items():
for llvm_pass, per_pass_bugs in per_file_bugs.items():		for llvm_pass, per_pass_bugs in per_file_bugs.items():
# No location bugs for the pass.		# No location bugs for the pass.
if len(per_pass_bugs) == 0:		if len(per_pass_bugs) == 0:
continue		continue
at_least_one_bug_found = True		at_least_one_bug_found = True
row = []		row = []
		if first_run:
		first_run = False
		else:
table_di_loc += " </tr>\n"		table_di_loc += " </tr>\n"
# Get the bugs info.		# Get the bugs info.
for x in per_pass_bugs:		for x in per_pass_bugs:
row.append(" <tr>\n")		row.append(" <tr>\n")
row.append(file)		row.append(file)
row.append(llvm_pass)		row.append(llvm_pass)
row.append(x.instr)		row.append(x.instr)
row.append(x.fn_name)		row.append(x.fn_name)
row.append(x.bb_name)		row.append(x.bb_name)
▲ Show 20 Lines • Show All 474 Lines • Show Last 20 Lines

polly/www/changelog.html

	Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
	<li>Compile-time reduction</li>			<li>Compile-time reduction</li>
	</ul>			</ul>

	<h2> Older releases</h2>			<h2> Older releases</h2>

	No changelog available. Please look at the <a			No changelog available. Please look at the <a
	href="https://repo.or.cz/w/polly-mirror.git">commit history</a>.			href="https://repo.or.cz/w/polly-mirror.git">commit history</a>.

	</html>			</div>
	</div>			</div>
	</body>			</body>
	</html>			</html>

polly/www/get_started.html

	Show All 26 Lines

	<pre>			<pre>
	git clone --depth 1 https://github.com/llvm/llvm-project.git			git clone --depth 1 https://github.com/llvm/llvm-project.git
	</pre>			</pre>

	<h3 id="build">Build Polly</h3>			<h3 id="build">Build Polly</h3>

	<pre>			<pre>
	mkdir build && cd build			mkdir build && cd build
	cmake '-DLLVM_ENABLE_PROJECTS=clang;polly' ../llvm			cmake '-DLLVM_ENABLE_PROJECTS=clang;polly' ../llvm
	cmake --build .			cmake --build .
	</pre>			</pre>

	You can also pass arguments to cmake to specify a particular generator (e.g. <code>-G Ninja</code>) or the build type (<code>-DCMAKE_BUILD_TYPE=Release</code>).			You can also pass arguments to cmake to specify a particular generator (e.g. <code>-G Ninja</code>) or the build type (<code>-DCMAKE_BUILD_TYPE=Release</code>).

	If you just want to play around with Polly, it is recommended to do a Release+Assert build by passing			If you just want to play around with Polly, it is recommended to do a Release+Assert build by passing
	<code>-DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=ON</code>.			<code>-DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=ON</code>.
	Show All 33 Lines

polly/www/index.html

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines	<td>
matrices, &oplus; and &otimes; operations are originating from the		matrices, &oplus; and &otimes; operations are originating from the
corresponding matrix semiring, and α and β are constants, and		corresponding matrix semiring, and α and β are constants, and
beta is not equal to zero. It allows to obtain the highly optimized form		beta is not equal to zero. It allows to obtain the highly optimized form
structured similar to the expert implementation of GEMM that can be found		structured similar to the expert implementation of GEMM that can be found
in GotoBLAS and its successors.		in GotoBLAS and its successors.
<h4>The performance evaluation of GEMM</h4>		<h4>The performance evaluation of GEMM</h4>
<img src="images/GEMM_double.png" /><br />		<img src="images/GEMM_double.png" /><br />
</td>		</td>
		</tr>
<tr><td><b>2017</b></td></tr>		<tr><td><b>2017</b></td></tr>
<tr><td width="120"><p>January</p></td>		<tr><td width="120"><p>January</p></td>
<td>		<td>
<a href="http://impact.gforge.inria.fr/impact2017">IMPACT 2017</a> program		<a href="http://impact.gforge.inria.fr/impact2017">IMPACT 2017</a> program
announced. Join IMPACT 2017 on January 23rd in Stockholm <a		announced. Join IMPACT 2017 on January 23rd in Stockholm <a
href="https://www.hipeac.net/2017/stockholm/">@HiPEAC'17</a>.		href="https://www.hipeac.net/2017/stockholm/">@HiPEAC'17</a>.
</td>		</td>
</tr>		</tr>
Show All 22 Lines	<td>
generation techniques used in Polly. This discussion gives not only an		generation techniques used in Polly. This discussion gives not only an
in-depth description of how we (re)generate an imperative AST from our		in-depth description of how we (re)generate an imperative AST from our
polyhedral based mathematical program description, but also gives		polyhedral based mathematical program description, but also gives
interesting insights about:		interesting insights about:
<ul>		<ul>
<li><b>Schedule trees:</b> A tree-based mathematical program description		<li><b>Schedule trees:</b> A tree-based mathematical program description
that enables us to perform loop transformations on an abstract level,		that enables us to perform loop transformations on an abstract level,
while issues like the generation of the correct loop structure and loop		while issues like the generation of the correct loop structure and loop
bounds will be taken care of by our AST generator.		bounds will be taken care of by our AST generator.</li>
<li><b>Polyhedral unrolling:</b> We discuss techniques that allow the		<li><b>Polyhedral unrolling:</b> We discuss techniques that allow the
unrolling of non-trivial loops in the context of parameteric loop bounds,		unrolling of non-trivial loops in the context of parameteric loop bounds,
complex tile shapes and conditionally executed statements. Such unrolling		complex tile shapes and conditionally executed statements. Such unrolling
support enables the generation of predicated code e.g. in the context of		support enables the generation of predicated code e.g. in the context of
GPGPU computing.		GPGPU computing.</li>
<li><b>Isolation for full/partial tile separation:</b> We discuss native		<li><b>Isolation for full/partial tile separation:</b> We discuss native
support for handling full/partial tile separation and -- in general --		support for handling full/partial tile separation and -- in general --
native support for isolation of boundary cases to enable smooth code		native support for isolation of boundary cases to enable smooth code
generation for core computations.		generation for core computations.</li>
<li><b>AST generation with modulo constraints:</b> We discuss how modulo		<li><b>AST generation with modulo constraints:</b> We discuss how modulo
mappings are lowered to efficient C/LLVM code.		mappings are lowered to efficient C/LLVM code.</li>
<li><b>User-defined constraint sets for run-time checks</b> We discuss how		<li><b>User-defined constraint sets for run-time checks</b> We discuss how
arbitrary sets of constraints can be used to automatically create run-time		arbitrary sets of constraints can be used to automatically create run-time
checks that ensure a set of constraints actually hold. This feature is		checks that ensure a set of constraints actually hold. This feature is
very useful to verify at run-time various assumptions that have been taken		very useful to verify at run-time various assumptions that have been taken
program optimization.		program optimization.</li>
</ul>		</ul>

<a href="https://www.grosser.es#pub-polyhedral-AST-generation">		<a href="https://www.grosser.es#pub-polyhedral-AST-generation">
<em>Polyhedral AST generation is more than scanning polyhedra</em></a><br />		<em>Polyhedral AST generation is more than scanning polyhedra</em></a><br />
Tobias Grosser, Sven Verdoolaege, Albert Cohen<br />		Tobias Grosser, Sven Verdoolaege, Albert Cohen<br />
ACM Transations on Programming Languages and Systems (TOPLAS), 37(4),		ACM Transations on Programming Languages and Systems (TOPLAS), 37(4),
July 2015		July 2015

▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines	<h4>Experimental support for the <b>new isl code generator</b></h4>
separation.<br />		separation.<br />
We also relicensed isl under the <b>MIT license</b>. This means, with the		We also relicensed isl under the <b>MIT license</b>. This means, with the
exception of GMP (LGPL), there is no other (L)GPL licensed software used in		exception of GMP (LGPL), there is no other (L)GPL licensed software used in
Polly. The		Polly. The
use of GMP is limited to a well defined interface. Replacing it with		use of GMP is limited to a well defined interface. Replacing it with
a BSD licensed replacement is a tractable engineering project we would		a BSD licensed replacement is a tractable engineering project we would
be very interested in. For more information about isl see the <a		be very interested in. For more information about isl see the <a
href="http://www.kotnet.org/~skimo/isl/manual.pdf">isl manual</a>.		href="http://www.kotnet.org/~skimo/isl/manual.pdf">isl manual</a>.
</p>
</td></tr>		</td></tr>
<tr><td width="120"><p>July</p></td>		<tr><td width="120"><p>July</p></td>
<td>		<td>
<p> Polly can now be directly linked to the <a		<p> Polly can now be directly linked to the <a
href="http://pluto-compiler.sourceforge.net/">Pluto optimizer</a>. We were		href="http://pluto-compiler.sourceforge.net/">Pluto optimizer</a>. We were
already able to perform Pluto-like optimizations with Polly, as a similar		already able to perform Pluto-like optimizations with Polly, as a similar
algorithm was added to isl half a year ago. However, being able to directly		algorithm was added to isl half a year ago. However, being able to directly
compare with the original implementation will not only bring in competition in		compare with the original implementation will not only bring in competition in
the optimizer field. It will also allow new experiments with a cutting edge		the optimizer field. It will also allow new experiments with a cutting edge
research tool.<br \>		research tool.<br \>
This support was on of the outcomes of the 1-day Polly workshop and the		This support was on of the outcomes of the 1-day Polly workshop and the
following week of joint work at IISC Bangalore and in cooperation with		following week of joint work at IISC Bangalore and in cooperation with
AMD India.		AMD India.
</td></tr>		</td></tr>
<td>
</td></tr>
<tr><td width="120"><p>February</p></td>		<tr><td width="120"><p>February</p></td>
<td>		<td>
<p>Polly is an official LLVM project, reachable at <a		<p>Polly is an official LLVM project, reachable at <a
href="https://polly.llvm.org">https://polly.llvm.org</a></p>		href="https://polly.llvm.org">https://polly.llvm.org</a></p>
</td></tr>		</td></tr>
<tr><td width="120"><p>January</p></td>		<tr><td width="120"><p>January</p></td>
<td>		<td>
<p>Improved support for the isl scheduling optimizer</p>		<p>Improved support for the isl scheduling optimizer</p>
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines	research tool.<br \>

<tr>		<tr>
<td><p>February</p></td>		<td><p>February</p></td>
<td><p>Translate a simple loop to Polly-IR and regenerate a loop structure		<td><p>Translate a simple loop to Polly-IR and regenerate a loop structure
with CLooG works. </p>		with CLooG works. </p>
<p>ISL and CLooG are integrated. </p></td>		<p>ISL and CLooG are integrated. </p></td>
</tr>		</tr>

</tr>

<tr>		<tr>
<td><p>January</p></td>		<td><p>January</p></td>
<td><p>The RegionInfo pass is finished. </p></td>		<td><p>The RegionInfo pass is finished. </p></td>
</tr>		</tr>

<tr><td><b><br>2009</b></td></tr>		<tr><td><b><br>2009</b></td></tr>
<tr>		<tr>
<td><p>End of the year</p></td>		<td><p>End of the year</p></td>
<td><p>Work on the infrastructure started. </p></td>		<td><p>Work on the infrastructure started. </p></td>
</tr>		</tr>
</table>		</table>
</ul>
</div>		</div>
</div>		</div>
</body>		</body>
</html>		</html>

polly/www/publications.html

Show First 20 Lines • Show All 177 Lines • ▼ Show 20 Lines	</p>
we hear about them.<br />		we hear about them.<br />
<h3>GPGPU</h3>		<h3>GPGPU</h3>
<ul>		<ul>
<li><em>Automatic C-to-CUDA Code Generation for Affine Programs</em>		<li><em>Automatic C-to-CUDA Code Generation for Affine Programs</em>
<br />		<br />
Muthu Manikandan Baskaran, J. Ramanujam and P. Sadayappan<br />		Muthu Manikandan Baskaran, J. Ramanujam and P. Sadayappan<br />
CC 2010		CC 2010
</li>		</li>
<li><em>Putting Automatic Polyhedral Compilation for GPGPU to Work<em>		<li><em>Putting Automatic Polyhedral Compilation for GPGPU to Work</em>
Soufiane Baghdadi, Armin Größlinger, and Albert Cohen. <br />		Soufiane Baghdadi, Armin Größlinger, and Albert Cohen. <br />
In Proc. of Compilers for Parallel Computers (CPC), 2010.		In Proc. of Compilers for Parallel Computers (CPC), 2010.
</li>		</li>
</ul>		</ul>
<h3>Vectorization</h3>		<h3>Vectorization</h3>
<ul>		<ul>
<li><em>Joint Scheduling and Layout Optimization to Enable Multi-Level		<li><em>Joint Scheduling and Layout Optimization to Enable Multi-Level
Vectorization</em>		Vectorization</em>
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

polly/www/todo.html

	Show All 18 Lines
	<li><a href="#phase3">Phase 3 - Improve Robustness, Interoperability and			<li><a href="#phase3">Phase 3 - Improve Robustness, Interoperability and
	Optimizations (ongoing)</a></li>			Optimizations (ongoing)</a></li>
	<li><a href="#llvm">Polly as a LLVM Project (Finished February 2012)</a></li>			<li><a href="#llvm">Polly as a LLVM Project (Finished February 2012)</a></li>
	<li><a href="#phase2">Phase 2 - First Optimizations and Enhanced User Experience (Finished			<li><a href="#phase2">Phase 2 - First Optimizations and Enhanced User Experience (Finished
	February 2012)</a></li>			February 2012)</a></li>
	<li><a href="#phase1">Phase 1 - Get Something Working (Finished October 2010)</a>			<li><a href="#phase1">Phase 1 - Get Something Working (Finished October 2010)</a>
	</li>			</li>
	</ul>			</ul>
	<h2> Individual Phases</h3>			<h2> Individual Phases</h2>

	<h3 id="phase4"> Phase 4</h3>			<h3 id="phase4"> Phase 4</h3>
	<table class="wikitable" cellpadding="2">			<table class="wikitable" cellpadding="2">
	<p> </p>			<p> </p>

	<tbody>			<tbody>
	<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Infrastructure </th></tr>			<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Infrastructure </th></tr>
	<tr style="background: rgb(239, 239, 239)">			<tr style="background: rgb(239, 239, 239)">
	<th width="400px"> Task </th>			<th width="400px"> Task </th>
	<th width="150px"> Status </th>			<th width="150px"> Status </th>
	<th> Owner </th>			<th> Owner </th>
	</tr>			</tr>
	<tr>			<tr>
	<th align="left"> Move to isl C++ bindings			<th align="left"> Move to isl C++ bindings
	</th><td align="center" class='open'> Open			</th><td align="center" class='open'> Open
	</td><td>			</td><td>
	</td>			</td>
	</tr>			</tr>
				<tr>
	<th align="left">     - Add isl C++ bindings generator to isl			<th align="left">     - Add isl C++ bindings generator to isl
	</th><td align="center" class='open'> Open			</th><td align="center" class='open'> Open
	</td><td>			</td><td>
	</td>			</td>
	</tr>			</tr>
	<tr>			<tr>
	<th align="left"> Add isl as an external library to Polly SVN			<th align="left"> Add isl as an external library to Polly SVN
	</th><td align="center" class='done'> Done			</th><td align="center" class='done'> Done
	</td><td>			</td><td>
	</td>			</td>
	</tr>			</tr>
	<tr>			<tr>
	<th align="left"> Compile-time: Speed up transformations			<th align="left"> Compile-time: Speed up transformations
	</th><td align="center">			</th><td align="center">
	</td><td>			</td><td>
	</td>			</td>
	</tr>			</tr>
				<tr>
	<th align="left">     - Optimize isl_int for small integers			<th align="left">     - Optimize isl_int for small integers
	</th><td align="center" class='done'> Done			</th><td align="center" class='done'> Done
	</td><td>			</td><td>
	</td>			</td>
	</tr>			</tr>
	<tr>			<tr>
	<th align="left"> Compile-time: Minimize SCoP detection time			<th align="left"> Compile-time: Minimize SCoP detection time
	</th><td align="center" class='open'> Open			</th><td align="center" class='open'> Open
	</td><td>			</td><td>
	</td>			</td>
	</tr>			</tr>
				<tr>
	<th align="left">     - Reconsider pass-ordering (move Polly later)			<th align="left">     - Reconsider pass-ordering (move Polly later)
	</th><td align="center" class='open'> Open			</th><td align="center" class='open'> Open
	</td><td>			</td><td>
	</td>			</td>
	</tr>			</tr>

	<tr><td colspan='4'> </td></tr>			<tr><td colspan='4'> </td></tr>
	<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Increase coverage			<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Increase coverage
	▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines
	</th><td class="open"> Open			</th><td class="open"> Open
	</td><td>			</td><td>
	</td></tr>			</td></tr>
	<tr>			<tr>
	<th align="left"> <a href="https://bugs.llvm.org/show_bug.cgi?id=12397">Model			<th align="left"> <a href="https://bugs.llvm.org/show_bug.cgi?id=12397">Model
	integer wrapping</a>			integer wrapping</a>
	</th><td align="center" class='done'> Done			</th><td align="center" class='done'> Done
	</td><td> Johannes			</td><td> Johannes
	</td></tr			</td></tr>

	<tr><td colspan='4'> </td></tr>			<tr><td colspan='4'> </td></tr>
	<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Optimize Julia			<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Optimize Julia
	code with Polly			code with Polly
	analysis </th></tr>			analysis </th></tr>
	<tr style="background: rgb(239, 239, 239)">			<tr style="background: rgb(239, 239, 239)">
	<th width="400px"> Task </th>			<th width="400px"> Task </th>
	<th width="150px"> Status </th>			<th width="150px"> Status </th>
	<th> Owner </th>			<th> Owner </th>
	</tr>			</tr>

				<tr>
	<th align="left">			<th align="left">
	Integrate Polly into Julia			Integrate Polly into Julia
	</th><td align="center" class='open'> Open			</th><td align="center" class='open'> Open
	</td><td>			</td><td>
	</td></tr>			</td></tr>
	<tr>			<tr>
	<th align="left">			<th align="left">
	Eliminate run-time bounds checks			Eliminate run-time bounds checks
	</th><td align="center" class='open'> Open			</th><td align="center" class='open'> Open
	</td><td>			</td><td>
	</td></tr>			</td></tr>
	<tr>			<tr>
	<th align="left">     - Reconsider unreachables in post-dominance tree			<th align="left">     - Reconsider unreachables in post-dominance tree
	</th><td align="center" class='open'> Open			</th><td align="center" class='open'> Open
	</td><td>			</td><td>
	</td></tr>			</td></tr>

				<tr>
	<th align="left">     - Actually eliminate statements			<th align="left">     - Actually eliminate statements
	</th><td align="center" class='done'> Done			</th><td align="center" class='done'> Done
	</td><td>			</td><td>
	</td></tr>			</td></tr>

	<tr><td colspan='4'> </td></tr>			<tr><td colspan='4'> </td></tr>
	<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Improved			<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Improved
	Optimizations in Polly			Optimizations in Polly
	</th></tr>			</th></tr>
	<tr style="background: rgb(239, 239, 239)">			<tr style="background: rgb(239, 239, 239)">
	<th width="400px"> Task </th>			<th width="400px"> Task </th>
	<th width="150px"> Status </th>			<th width="150px"> Status </th>
	<th> Owner </th>			<th> Owner </th>
	</tr>			</tr>

				<tr>
	<th align="left">			<th align="left">
	Multi-level tiling			Multi-level tiling
	</th><td align="center" class='open'> Open			</th><td align="center" class='open'> Open
	</td><td>			</td><td>
	</td></tr>			</td></tr>
	<tr>			<tr>
	<th align="left">			<th align="left">
	Register Tiling			Register Tiling
	</th><td align="center" class='open'> Open			</th><td align="center" class='open'> Open
	</td><td>			</td><td>
	</td></tr>			</td></tr>
	<tr>			<tr>
	<th align="left">			<th align="left">
	Full/partial tile separation for vectorization			Full/partial tile separation for vectorization
	</th><td align="center" class='done'> Done			</th><td align="center" class='done'> Done
	</td><td>			</td><td>
	</td></tr>			</td></tr>
				<tr>
	<th align="left">			<th align="left">
	Loop interchange after vectorization to maximize stride-one accesses			Loop interchange after vectorization to maximize stride-one accesses
	</th><td align="center" class='open'> Open			</th><td align="center" class='open'> Open
	</td><td>			</td><td>
	</td></tr>			</td></tr>
	</table>			</table>


	▲ Show 20 Lines • Show All 172 Lines • ▼ Show 20 Lines
	</td></tr>			</td></tr>
	<tr>			<tr>
	<th align="left">Buildbot that runs 'make polly-test'			<th align="left">Buildbot that runs 'make polly-test'
	</th><td class="done" align="center">			</th><td class="done" align="center">
	<a href="http://lab.llvm.org:8011/console">Buildbot</a>			<a href="http://lab.llvm.org:8011/console">Buildbot</a>
	</td>			</td>
	<td> Tobias, Andreas			<td> Tobias, Andreas
	</td></tr>			</td></tr>
	</th><td>			<td>

	</td></tr>			</td></tr>
	</tbody></table>			</tbody></table>
	<h3 id="phase2"> Phase 2 - First Optimizations and Enhanced User Experience (Finished			<h3 id="phase2"> Phase 2 - First Optimizations and Enhanced User Experience (Finished
	February 2012)</h3>			February 2012)</h3>
	<p>			<p>

	First optimizations to show the usefulness of Polly and enhance the user			First optimizations to show the usefulness of Polly and enhance the user
	▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
	<tbody>			<tbody>
	<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Front End</th></tr>			<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Front End</th></tr>
	<tr style="background: rgb(239, 239, 239)">			<tr style="background: rgb(239, 239, 239)">
	<th width="400px"> Task </th>			<th width="400px"> Task </th>
	<th width="150px"> Status </th>			<th width="150px"> Status </th>
	<th> Owner </th>			<th> Owner </th>
	</tr>			</tr>

				<tr>
	<th align="left"> Region detection			<th align="left"> Region detection
	</td><td class="done"> Done			</th><td class="done"> Done
	</td><td>Ether			</td><td>Ether
	</td></tr>			</td></tr>
	<tr>			<tr>
	<th align="left"> Access Functions			<th align="left"> Access Functions
	</td><td class="done"> Done			</th><td class="done"> Done
	</td><td>John, Ether			</td><td>John, Ether
	</td></tr>			</td></tr>
	<tr>			<tr>
	<th align="left"> Alias sets			<th align="left"> Alias sets
	</td><td class="done"> Done			</th><td class="done"> Done
	</td><td>Ether			</td><td>Ether
	</td></tr>			</td></tr>
	<tr>			<tr>
	<th align="left"> Scalar evolution to affine expression			<th align="left"> Scalar evolution to affine expression
	</td><td class="done"> Done			</th><td class="done"> Done

	</td><td>			</td><td>
	Ether			Ether
	</td></tr>			</td></tr>
	<tr>			<tr>
	<th align="left"> SCoP extraction			<th align="left"> SCoP extraction
	</td><td class="done"> Done			</th><td class="done"> Done
	</td><td>Tobias, Ether			</td><td>Tobias, Ether

	</td></tr>			</td></tr>
	<tr>			<tr>
	<th align="left"> SCoPs to polyhedral model			<th align="left"> SCoPs to polyhedral model
	</td><td class="done"> Done			</th><td class="done"> Done
	</td><td>Tobias, Ether			</td><td>Tobias, Ether
	</td></tr>			</td></tr>
	<tr><td colspan='4'> </td></tr>			<tr><td colspan='4'> </td></tr>
	<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Optimizer </th></tr>			<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Optimizer </th></tr>
	<tr style="background: rgb(239, 239, 239)">			<tr style="background: rgb(239, 239, 239)">
	<th width="400px"> Task </th>			<th width="400px"> Task </th>
	<th width="150px"> Status </th>			<th width="150px"> Status </th>
	<th> Owner </th>			<th> Owner </th>
	</tr>			</tr>
	<tr>			<tr>
	<th align="left"> Define polyhedral description			<th align="left"> Define polyhedral description
	</td><td class="done"> Done			</th><td class="done"> Done
	</td><td>Tobias			</td><td>Tobias

	</td></tr>			</td></tr>
	<tr><td colspan='4'> </td></tr>			<tr><td colspan='4'> </td></tr>
	<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Back End</th></tr>			<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Back End</th></tr>
	<tr style="background: rgb(239, 239, 239)">			<tr style="background: rgb(239, 239, 239)">
	<th width="400px"> Task </th>			<th width="400px"> Task </th>
	<th width="150px"> Status </th>			<th width="150px"> Status </th>
	<th> Owner </th>			<th> Owner </th>
	</tr>			</tr>
	<tr>			<tr>
	<th align="left"> Create LLVM-IR using CLooG			<th align="left"> Create LLVM-IR using CLooG
	</td><td class="done"> Done			</th><td class="done"> Done
	</td><td> Tobias			</td><td> Tobias

	</td></tr>			</td></tr>
	<tr><td colspan='4'> </td></tr>			<tr><td colspan='4'> </td></tr>
	<tr><th colspan="3" style="background: rgb(239, 239, 239);"> General</th></tr>			<tr><th colspan="3" style="background: rgb(239, 239, 239);"> General</th></tr>
	<tr style="background: rgb(239, 239, 239)">			<tr style="background: rgb(239, 239, 239)">
	<th width="400px"> Task </th>			<th width="400px"> Task </th>
	<th width="150px"> Status </th>			<th width="150px"> Status </th>
	<th> Owner </th>			<th> Owner </th>
	</tr>			</tr>
	<tr>			<tr>
	<th align="left"> Setup git repositories			<th align="left"> Setup git repositories

	</td><td class="done"> Done			</th><td class="done"> Done
	</td><td> Tobias			</td><td> Tobias
	</td></tr>			</td></tr>
	<tr>			<tr>
	<th align="left"> Add CLooG/isl to build system			<th align="left"> Add CLooG/isl to build system
	</td><td class="done"> Done			</th><td class="done"> Done
	</td><td> Tobias			</td><td> Tobias

	</td></tr>			</td></tr>

	</tbody></table>			</tbody></table>
	</div>			</div>
	</div>			</div>
	</body>			</body>
	</html>			</html>

This is an archive of the discontinued LLVM Phabricator instance.

[*]: fix syntax errors in HTML filesAbandonedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 524033

clang-tools-extra/docs/_templates/clangd_redirect.html

clang/docs/LibASTMatchersReference.html

clang/www/OpenProjects.html

clang/www/analyzer/alpha_checks.html

clang/www/analyzer/available_checks.html

clang/www/analyzer/checker_dev_manual.html

clang/www/analyzer/codechecker.html

clang/www/analyzer/command-line.html

clang/www/analyzer/faq.html

clang/www/analyzer/implicit_checks.html

clang/www/analyzer/open_projects.html

clang/www/analyzer/potential_checkers.html

clang/www/analyzer/release_notes.html

clang/www/analyzer/scan-build.html

clang/www/c_dr_status.html

clang/www/c_status.html

clang/www/compatibility.html

clang/www/cxx_status.html

clang/www/diagnostics.html

compiler-rt/www/index.html

libclc/www/index.html

llvm/test/tools/llvm-original-di-preservation/Inputs/expected-compressed.html

llvm/test/tools/llvm-original-di-preservation/Inputs/expected-sample.html

llvm/test/tools/llvm-original-di-preservation/Inputs/expected-skipped.html

llvm/test/tools/opt-viewer/Outputs/basic/basic_or.h.html

llvm/test/tools/opt-viewer/Outputs/basic/basic_or.c.html

llvm/test/tools/opt-viewer/Outputs/basic/index.html

llvm/test/tools/opt-viewer/Outputs/filter/basic_or.h.html

llvm/test/tools/opt-viewer/Outputs/filter/basic_or.c.html

llvm/test/tools/opt-viewer/Outputs/filter/index.html

llvm/test/tools/opt-viewer/Outputs/suppress/index.html

llvm/test/tools/opt-viewer/Outputs/suppress/s.swift.html

llvm/test/tools/opt-viewer/Outputs/unicode-function-name/index.html

llvm/test/tools/opt-viewer/Outputs/unicode-function-name/s.swift.html

llvm/tools/opt-viewer/opt-viewer.py

llvm/utils/llvm-original-di-preservation.py

polly/www/changelog.html

polly/www/get_started.html

polly/www/index.html

polly/www/publications.html

polly/www/todo.html

[*]: fix syntax errors in HTML files
AbandonedPublic