maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/Analysis/temp-obj-dtors-cfg-output.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1461 lines
50 KiB
C++
Raw Normal View History

Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// RUN: rm -f %t
Remove explicit cfg-temporary-dtors=true Summary: Remove explicit -analyzer-config cfg-temporary-dtors=true in analyzer tests, since this option defaults to true since r326461. Reviewers: NoQ Reviewed By: NoQ Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D46393 llvm-svn: 331520
2018-05-04 22:13:14 +08:00
// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=false -std=c++98 %s > %t 2>&1
[CFG] Provide construction contexts when constructors have cleanups. Now that we make it possible to query the CFG constructor element to find information about the construction site, possible cleanup work represented by ExprWithCleanups should not prevent us from providing this information. This allows us to have a correct construction context for variables initialized "by value" via elidable copy-constructors, such as 'i' in iterator i = vector.begin(); Differential Revision: https://reviews.llvm.org/D42719 llvm-svn: 324798
2018-02-10 10:46:14 +08:00
// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,CXX98,WARNINGS,CXX98-WARNINGS %s
Remove explicit cfg-temporary-dtors=true Summary: Remove explicit -analyzer-config cfg-temporary-dtors=true in analyzer tests, since this option defaults to true since r326461. Reviewers: NoQ Reviewed By: NoQ Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D46393 llvm-svn: 331520
2018-05-04 22:13:14 +08:00
// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=false -std=c++11 %s > %t 2>&1
[CFG] Provide construction contexts when constructors have cleanups. Now that we make it possible to query the CFG constructor element to find information about the construction site, possible cleanup work represented by ExprWithCleanups should not prevent us from providing this information. This allows us to have a correct construction context for variables initialized "by value" via elidable copy-constructors, such as 'i' in iterator i = vector.begin(); Differential Revision: https://reviews.llvm.org/D42719 llvm-svn: 324798
2018-02-10 10:46:14 +08:00
// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,CXX11,WARNINGS,CXX11-WARNINGS %s
Remove explicit cfg-temporary-dtors=true Summary: Remove explicit -analyzer-config cfg-temporary-dtors=true in analyzer tests, since this option defaults to true since r326461. Reviewers: NoQ Reviewed By: NoQ Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D46393 llvm-svn: 331520
2018-05-04 22:13:14 +08:00
// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=true -std=c++98 %s > %t 2>&1
[CFG] Provide construction contexts when constructors have cleanups. Now that we make it possible to query the CFG constructor element to find information about the construction site, possible cleanup work represented by ExprWithCleanups should not prevent us from providing this information. This allows us to have a correct construction context for variables initialized "by value" via elidable copy-constructors, such as 'i' in iterator i = vector.begin(); Differential Revision: https://reviews.llvm.org/D42719 llvm-svn: 324798
2018-02-10 10:46:14 +08:00
// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,CXX98,ANALYZER,CXX98-ANALYZER %s
Remove explicit cfg-temporary-dtors=true Summary: Remove explicit -analyzer-config cfg-temporary-dtors=true in analyzer tests, since this option defaults to true since r326461. Reviewers: NoQ Reviewed By: NoQ Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D46393 llvm-svn: 331520
2018-05-04 22:13:14 +08:00
// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=true -std=c++11 %s > %t 2>&1
[CFG] Provide construction contexts when constructors have cleanups. Now that we make it possible to query the CFG constructor element to find information about the construction site, possible cleanup work represented by ExprWithCleanups should not prevent us from providing this information. This allows us to have a correct construction context for variables initialized "by value" via elidable copy-constructors, such as 'i' in iterator i = vector.begin(); Differential Revision: https://reviews.llvm.org/D42719 llvm-svn: 324798
2018-02-10 10:46:14 +08:00
// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,CXX11,ANALYZER,CXX11-ANALYZER %s
// This file tests how we construct two different flavors of the Clang CFG -
// the CFG used by the Sema analysis-based warnings and the CFG used by the
// static analyzer. The difference in the behavior is checked via FileCheck
// prefixes (WARNINGS and ANALYZER respectively). When introducing new analyzer
// flags, no new run lines should be added - just these flags would go to the
// respective line depending on where is it turned on and where is it turned
// off. Feel free to add tests that test only one of the CFG flavors if you're
// not sure how the other flavor is supposed to work in your case.
// Additionally, different C++ standards are checked.
Added generating destructors for temporary objects. Two cases I know of, that are not handled properly: 1. For statement: const C& c = C(0) ?: C(1) destructors generated for condition will not differ from those generated for case without prolonged lifetime of temporary, 2. There will be no destructor for constant reference member bound to temporary at the exit from constructor. llvm-svn: 118158
2010-11-03 14:19:35 +08:00
class A {
public:
A() {}
~A() {}
static A make() { return A(); }
operator bool() { return false; }
operator int() { return 0; }
};
class B {
public:
B() {}
~B() {}
operator bool() { return true; }
operator int() { return 1; }
operator A() { return A(); }
};
void foo(int);
void foo(bool);
void foo(const A&);
void test_binary() {
int a = int(A()) + int(B());
foo(int(A()) + int(B()));
int b;
}
void test_and() {
bool a = A() && B();
foo(A() && B());
int b;
}
void test_or() {
bool a = A() || B();
foo(A() || B());
int b;
}
void test_cond() {
A a = B() ? A() : A(B());
if (B()) { foo(0); } else { foo(0); }
int b;
}
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
struct C {
C():b_(true) {}
~C() {}
operator bool() { return b_; }
bool b_;
};
struct D {
D():b_(true) {}
operator bool() { return b_; }
bool b_;
};
int test_cond_unnamed_custom_destructor() {
if (C()) { return 1; } else { return 0; }
}
int test_cond_named_custom_destructor() {
if (C c = C()) { return 1; } else { return 0; }
}
int test_cond_unnamed_auto_destructor() {
if (D()) { return 1; } else { return 0; }
}
int test_cond_named_auto_destructor() {
if (D d = D()) { return 1; } else { return 0; }
}
Added generating destructors for temporary objects. Two cases I know of, that are not handled properly: 1. For statement: const C& c = C(0) ?: C(1) destructors generated for condition will not differ from those generated for case without prolonged lifetime of temporary, 2. There will be no destructor for constant reference member bound to temporary at the exit from constructor. llvm-svn: 118158
2010-11-03 14:19:35 +08:00
void test_cond_cref() {
const A& a = B() ? A() : A(B());
foo(B() ? A() : A(B()));
int b;
}
void test_cond_implicit() {
A a = A() ?: A();
int b;
}
void test_cond_implicit_cref() {
const A& a = A() ?: A();
foo(A() ?: A());
int b;
}
void test_copy_init() {
A a = A();
int b;
}
void test_cref_init() {
const A& a = A();
foo(A());
int b;
}
void test_call_copy_init() {
A a = A::make();
int b;
}
void test_call_cref_init() {
const A& a = A::make();
foo(A::make());
int b;
}
void test_assign() {
int a;
a = A();
int b;
}
class TestCtorInits {
int a;
int b;
public:
TestCtorInits();
};
TestCtorInits::TestCtorInits()
: a(int(A()) + int(B()))
, b() {}
[analyzer] Add very limited support for temporary destructors This is an improved version of r186498. It enables ExprEngine to reason about temporary object destructors. However, these destructor calls are never inlined, since this feature is still broken. Still, this is sufficient to properly handle noreturn temporary destructors. Now, the analyzer correctly handles expressions like "a || A()", and executes the destructor of "A" only on the paths where "a" evaluted to false. Temporary destructor processing is still off by default and one has to explicitly request it by setting cfg-temporary-dtors=true. Reviewers: jordan_rose CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1259 llvm-svn: 189746
2013-09-02 17:09:15 +08:00
class NoReturn {
public:
~NoReturn() __attribute__((noreturn));
void f();
};
void test_noreturn1() {
int a;
NoReturn().f();
int b;
}
void test_noreturn2() {
int a;
NoReturn(), 47;
int b;
}
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
extern bool check(const NoReturn&);
// PR16664 and PR18159
int testConsistencyNestedSimple(bool value) {
if (value) {
if (!value || check(NoReturn())) {
return 1;
}
}
return 0;
}
// PR16664 and PR18159
int testConsistencyNestedComplex(bool value) {
if (value) {
if (!value || !value || check(NoReturn())) {
return 1;
}
}
return 0;
}
// PR16664 and PR18159
int testConsistencyNestedNormalReturn(bool value) {
if (value) {
if (!value || value || check(NoReturn())) {
return 1;
}
}
return 0;
}
[CFG] [analyzer] Don't add construction context to a return-by-reference call. Call expressions that return objects by an lvalue reference or an rvalue reference have a value type in the AST but wear an auxiliary flag of being an lvalue or an xvalue respectively. Use the helper method for obtaining the actual return type of the function. Fixes a crash. Differential Revision: https://reviews.llvm.org/D44273 llvm-svn: 327352
2018-03-13 07:52:36 +08:00
namespace pass_references_through {
class C {
public:
~C() {}
};
const C &foo1();
C &&foo2();
// In these examples the foo() expression has record type, not reference type.
// Don't try to figure out how to perform construction of the record here.
const C &bar1() { return foo1(); } // no-crash
C &&bar2() { return foo2(); } // no-crash
[CFG] [analyzer] Avoid modeling C++17 constructors that aren't fully supported. Not enough work has been done so far to ensure correctness of construction contexts in the CFG when C++17 copy elision is in effect, so for now we should drop construction contexts in the CFG and in the analyzer when they seem different from what we support anyway. This includes initializations with conditional operators and return values across multiple stack frames. Differential Revision: https://reviews.llvm.org/D44854 llvm-svn: 328893
2018-03-31 03:21:18 +08:00
const C &bar3(bool coin) {
return coin ? foo1() : foo1(); // no-crash
}
[CFG] [analyzer] Don't add construction context to a return-by-reference call. Call expressions that return objects by an lvalue reference or an rvalue reference have a value type in the AST but wear an auxiliary flag of being an lvalue or an xvalue respectively. Use the helper method for obtaining the actual return type of the function. Fixes a crash. Differential Revision: https://reviews.llvm.org/D44273 llvm-svn: 327352
2018-03-13 07:52:36 +08:00
} // end namespace pass_references_through
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: [B1 (ENTRY)]
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B1 (ENTRY)]
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
[CFG] [analyzer] Add construction contexts that explain pre-C++17 copy elision. Before C++17 copy elision was optional, even if the elidable copy/move constructor had arbitrary side effects. The elidable constructor is present in the AST, but marked as elidable. In these cases CFG now contains additional information that allows its clients to figure out if a temporary object is only being constructed so that to pass it to an elidable constructor. If so, it includes a reference to the elidable constructor's construction context, so that the client could elide the elidable constructor and construct the object directly at its final destination. Differential Revision: https://reviews.llvm.org/D47616 llvm-svn: 335795
2018-06-28 08:04:54 +08:00
// ANALYZER: 1: A() (CXXConstructExpr, [B1.2], [B1.4], [B1.5], class A)
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: 2: [B1.1] (BindTemporary)
// CHECK: 3: [B1.2] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 4: [B1.3]
[CFG] Provide construction contexts for return value constructors. When the current function returns a C++ object by value, CFG elements for constructors that construct the return values can now be queried to discover that they're indeed participating in construction of the respective return value at the respective return statement. Differential Revision: https://reviews.llvm.org/D42875 llvm-svn: 324952
2018-02-13 06:36:36 +08:00
// WARNINGS: 5: [B1.4] (CXXConstructExpr, class A)
// ANALYZER: 5: [B1.4] (CXXConstructExpr, [B1.7], class A)
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: 6: ~A() (Temporary object destructor)
// CHECK: 7: return [B1.5];
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
// CHECK: 1: false
// CHECK: 2: return [B1.1];
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
// CHECK: 1: 0
// CHECK: 2: return [B1.1];
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B1 (ENTRY)]
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B1 (ENTRY)]
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
// CHECK: 1: true
// CHECK: 2: return [B1.1];
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
// CHECK: 1: 1
// CHECK: 2: return [B1.1];
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
[CFG] [analyzer] Add construction contexts that explain pre-C++17 copy elision. Before C++17 copy elision was optional, even if the elidable copy/move constructor had arbitrary side effects. The elidable constructor is present in the AST, but marked as elidable. In these cases CFG now contains additional information that allows its clients to figure out if a temporary object is only being constructed so that to pass it to an elidable constructor. If so, it includes a reference to the elidable constructor's construction context, so that the client could elide the elidable constructor and construct the object directly at its final destination. Differential Revision: https://reviews.llvm.org/D47616 llvm-svn: 335795
2018-06-28 08:04:54 +08:00
// ANALYZER: 1: A() (CXXConstructExpr, [B1.2], [B1.4], [B1.5], class A)
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: 2: [B1.1] (BindTemporary)
// CHECK: 3: [B1.2] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 4: [B1.3]
[CFG] Provide construction contexts for return value constructors. When the current function returns a C++ object by value, CFG elements for constructors that construct the return values can now be queried to discover that they're indeed participating in construction of the respective return value at the respective return statement. Differential Revision: https://reviews.llvm.org/D42875 llvm-svn: 324952
2018-02-13 06:36:36 +08:00
// WARNINGS: 5: [B1.4] (CXXConstructExpr, class A)
// ANALYZER: 5: [B1.4] (CXXConstructExpr, [B1.7], class A)
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: 6: ~A() (Temporary object destructor)
// CHECK: 7: return [B1.5];
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 1: A() (CXXConstructExpr, [B1.2], [B1.3], class A)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 2: [B1.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B1.2]
// CHECK: 4: [B1.3].operator int
// CHECK: 5: [B1.3]
// CHECK: 6: [B1.5] (ImplicitCastExpr, UserDefinedConversion, int)
// CHECK: 7: int([B1.6]) (CXXFunctionalCastExpr, NoOp, int)
// WARNINGS: 8: B() (CXXConstructExpr, class B)
// ANALYZER: 8: B() (CXXConstructExpr, [B1.9], [B1.10], class B)
// CHECK: 9: [B1.8] (BindTemporary)
// CHECK: 10: [B1.9]
// CHECK: 11: [B1.10].operator int
// CHECK: 12: [B1.10]
// CHECK: 13: [B1.12] (ImplicitCastExpr, UserDefinedConversion, int)
// CHECK: 14: int([B1.13]) (CXXFunctionalCastExpr, NoOp, int)
// CHECK: 15: [B1.7] + [B1.14]
// CHECK: 16: int a = int(A()) + int(B());
// CHECK: 17: ~B() (Temporary object destructor)
// CHECK: 18: ~A() (Temporary object destructor)
// CHECK: 19: foo
// CHECK: 20: [B1.19] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(int))
// WARNINGS: 21: A() (CXXConstructExpr, class A)
// ANALYZER: 21: A() (CXXConstructExpr, [B1.22], [B1.23], class A)
// CHECK: 22: [B1.21] (BindTemporary)
// CHECK: 23: [B1.22]
// CHECK: 24: [B1.23].operator int
// CHECK: 25: [B1.23]
// CHECK: 26: [B1.25] (ImplicitCastExpr, UserDefinedConversion, int)
// CHECK: 27: int([B1.26]) (CXXFunctionalCastExpr, NoOp, int)
// WARNINGS: 28: B() (CXXConstructExpr, class B)
// ANALYZER: 28: B() (CXXConstructExpr, [B1.29], [B1.30], class B)
// CHECK: 29: [B1.28] (BindTemporary)
// CHECK: 30: [B1.29]
// CHECK: 31: [B1.30].operator int
// CHECK: 32: [B1.30]
// CHECK: 33: [B1.32] (ImplicitCastExpr, UserDefinedConversion, int)
// CHECK: 34: int([B1.33]) (CXXFunctionalCastExpr, NoOp, int)
// CHECK: 35: [B1.27] + [B1.34]
// CHECK: 36: [B1.20]([B1.35])
// CHECK: 37: ~B() (Temporary object destructor)
// CHECK: 38: ~A() (Temporary object destructor)
// CHECK: 39: int b;
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B10 (ENTRY)]
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Succs (1): B9
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B1]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: 2: int b;
// CHECK: Preds (2): B2 B3
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: ~B() (Temporary object destructor)
// CHECK: Preds (1): B3
// CHECK: Succs (1): B1
// CHECK: [B3]
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 1: [B5.9] && [B4.6]
Change subexpressions to be visited in the CFG from left-to-right. This is a more natural order of evaluation, and it is very important for visualization in the static analyzer. Within Xcode, the arrows will not jump from right to left, which looks very visually jarring. It also provides a more natural location for dataflow-based diagnostics. Along the way, we found a case in the analyzer diagnostics where we needed to indicate that a variable was "captured" by a block. -fsyntax-only timings on sqlite3.c show no visible performance change, although this is just one test case. Fixes <rdar://problem/13016513> llvm-svn: 174447
2013-02-06 06:00:19 +08:00
// CHECK: 2: [B5.3]([B3.1])
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: T: (Temp Dtor) [B4.2]
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Preds (2): B4 B5
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Succs (2): B2 B1
// CHECK: [B4]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: B() (CXXConstructExpr, class B)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 1: B() (CXXConstructExpr, [B4.2], [B4.3], class B)
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: 2: [B4.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B4.2]
// CHECK: 4: [B4.3].operator bool
// CHECK: 5: [B4.3]
// CHECK: 6: [B4.5] (ImplicitCastExpr, UserDefinedConversion, _Bool)
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Preds (1): B5
// CHECK: Succs (1): B3
// CHECK: [B5]
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 1: ~A() (Temporary object destructor)
Change subexpressions to be visited in the CFG from left-to-right. This is a more natural order of evaluation, and it is very important for visualization in the static analyzer. Within Xcode, the arrows will not jump from right to left, which looks very visually jarring. It also provides a more natural location for dataflow-based diagnostics. Along the way, we found a case in the analyzer diagnostics where we needed to indicate that a variable was "captured" by a block. -fsyntax-only timings on sqlite3.c show no visible performance change, although this is just one test case. Fixes <rdar://problem/13016513> llvm-svn: 174447
2013-02-06 06:00:19 +08:00
// CHECK: 2: foo
// CHECK: 3: [B5.2] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(_Bool))
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 4: A() (CXXConstructExpr, class A)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 4: A() (CXXConstructExpr, [B5.5], [B5.6], class A)
Change subexpressions to be visited in the CFG from left-to-right. This is a more natural order of evaluation, and it is very important for visualization in the static analyzer. Within Xcode, the arrows will not jump from right to left, which looks very visually jarring. It also provides a more natural location for dataflow-based diagnostics. Along the way, we found a case in the analyzer diagnostics where we needed to indicate that a variable was "captured" by a block. -fsyntax-only timings on sqlite3.c show no visible performance change, although this is just one test case. Fixes <rdar://problem/13016513> llvm-svn: 174447
2013-02-06 06:00:19 +08:00
// CHECK: 5: [B5.4] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 6: [B5.5]
// CHECK: 7: [B5.6].operator bool
// CHECK: 8: [B5.6]
// CHECK: 9: [B5.8] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CHECK: T: [B5.9] && ...
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (2): B6 B7
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Succs (2): B4 B3
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B6]
// CHECK: 1: ~B() (Temporary object destructor)
// CHECK: Preds (1): B7
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Succs (1): B5
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B7]
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 1: [B9.6] && [B8.6]
Reapply "Pretty Printer: Fix printing of conversion operator decls and calls." There were many additional tests that had the bad behavior baked in. llvm-svn: 202174
2014-02-26 02:03:55 +08:00
// CHECK: 2: bool a = A() && B();
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: T: (Temp Dtor) [B8.2]
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Preds (2): B8 B9
// CHECK: Succs (2): B6 B5
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B8]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: B() (CXXConstructExpr, class B)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 1: B() (CXXConstructExpr, [B8.2], [B8.3], class B)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 2: [B8.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B8.2]
// CHECK: 4: [B8.3].operator bool
// CHECK: 5: [B8.3]
// CHECK: 6: [B8.5] (ImplicitCastExpr, UserDefinedConversion, _Bool)
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Preds (1): B9
// CHECK: Succs (1): B7
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B9]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 1: A() (CXXConstructExpr, [B9.2], [B9.3], class A)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 2: [B9.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B9.2]
// CHECK: 4: [B9.3].operator bool
// CHECK: 5: [B9.3]
// CHECK: 6: [B9.5] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CHECK: T: [B9.6] && ...
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Preds (1): B10
// CHECK: Succs (2): B8 B7
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B10 (ENTRY)]
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Succs (1): B9
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B1]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: 2: int b;
// CHECK: Preds (2): B2 B3
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: ~B() (Temporary object destructor)
// CHECK: Preds (1): B3
// CHECK: Succs (1): B1
// CHECK: [B3]
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 1: [B5.9] || [B4.6]
Change subexpressions to be visited in the CFG from left-to-right. This is a more natural order of evaluation, and it is very important for visualization in the static analyzer. Within Xcode, the arrows will not jump from right to left, which looks very visually jarring. It also provides a more natural location for dataflow-based diagnostics. Along the way, we found a case in the analyzer diagnostics where we needed to indicate that a variable was "captured" by a block. -fsyntax-only timings on sqlite3.c show no visible performance change, although this is just one test case. Fixes <rdar://problem/13016513> llvm-svn: 174447
2013-02-06 06:00:19 +08:00
// CHECK: 2: [B5.3]([B3.1])
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: T: (Temp Dtor) [B4.2]
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Preds (2): B4 B5
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Succs (2): B2 B1
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B4]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: B() (CXXConstructExpr, class B)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 1: B() (CXXConstructExpr, [B4.2], [B4.3], class B)
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: 2: [B4.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B4.2]
// CHECK: 4: [B4.3].operator bool
// CHECK: 5: [B4.3]
// CHECK: 6: [B4.5] (ImplicitCastExpr, UserDefinedConversion, _Bool)
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Preds (1): B5
// CHECK: Succs (1): B3
// CHECK: [B5]
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 1: ~A() (Temporary object destructor)
Change subexpressions to be visited in the CFG from left-to-right. This is a more natural order of evaluation, and it is very important for visualization in the static analyzer. Within Xcode, the arrows will not jump from right to left, which looks very visually jarring. It also provides a more natural location for dataflow-based diagnostics. Along the way, we found a case in the analyzer diagnostics where we needed to indicate that a variable was "captured" by a block. -fsyntax-only timings on sqlite3.c show no visible performance change, although this is just one test case. Fixes <rdar://problem/13016513> llvm-svn: 174447
2013-02-06 06:00:19 +08:00
// CHECK: 2: foo
// CHECK: 3: [B5.2] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(_Bool))
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 4: A() (CXXConstructExpr, class A)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 4: A() (CXXConstructExpr, [B5.5], [B5.6], class A)
Change subexpressions to be visited in the CFG from left-to-right. This is a more natural order of evaluation, and it is very important for visualization in the static analyzer. Within Xcode, the arrows will not jump from right to left, which looks very visually jarring. It also provides a more natural location for dataflow-based diagnostics. Along the way, we found a case in the analyzer diagnostics where we needed to indicate that a variable was "captured" by a block. -fsyntax-only timings on sqlite3.c show no visible performance change, although this is just one test case. Fixes <rdar://problem/13016513> llvm-svn: 174447
2013-02-06 06:00:19 +08:00
// CHECK: 5: [B5.4] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 6: [B5.5]
// CHECK: 7: [B5.6].operator bool
// CHECK: 8: [B5.6]
// CHECK: 9: [B5.8] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CHECK: T: [B5.9] || ...
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (2): B6 B7
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Succs (2): B3 B4
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B6]
// CHECK: 1: ~B() (Temporary object destructor)
// CHECK: Preds (1): B7
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Succs (1): B5
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B7]
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 1: [B9.6] || [B8.6]
Reapply "Pretty Printer: Fix printing of conversion operator decls and calls." There were many additional tests that had the bad behavior baked in. llvm-svn: 202174
2014-02-26 02:03:55 +08:00
// CHECK: 2: bool a = A() || B();
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: T: (Temp Dtor) [B8.2]
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Preds (2): B8 B9
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Succs (2): B6 B5
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B8]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: B() (CXXConstructExpr, class B)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 1: B() (CXXConstructExpr, [B8.2], [B8.3], class B)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 2: [B8.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B8.2]
// CHECK: 4: [B8.3].operator bool
// CHECK: 5: [B8.3]
// CHECK: 6: [B8.5] (ImplicitCastExpr, UserDefinedConversion, _Bool)
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Preds (1): B9
// CHECK: Succs (1): B7
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B9]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 1: A() (CXXConstructExpr, [B9.2], [B9.3], class A)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 2: [B9.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B9.2]
// CHECK: 4: [B9.3].operator bool
// CHECK: 5: [B9.3]
// CHECK: 6: [B9.5] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CHECK: T: [B9.6] || ...
Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||' respectively. This eliminates some artifical control-flow from the CFG and results in a more compact CFG. Note that this patch only alters the branches 'while', 'if' and 'for'. This was complex enough for one patch. The remaining branches (e.g., do...while) can be handled in a separate patch, but they weren't immediately tackled because they were less important. It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement. I've tried to audit these changes, but it is also known that the destructor logic needs some refinement in the area of '||' and '&&' regardless (i.e., their are known bugs). llvm-svn: 160218
2012-07-14 13:04:10 +08:00
// CHECK: Preds (1): B10
// CHECK: Succs (2): B7 B8
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: [B11 (ENTRY)]
// CHECK: Succs (1): B10
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B1]
// CHECK: 1: int b;
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B7.5].~A() (Implicit destructor)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (2): B2 B3
// CHECK: Succs (1): B0
// CHECK: [B2]
Change subexpressions to be visited in the CFG from left-to-right. This is a more natural order of evaluation, and it is very important for visualization in the static analyzer. Within Xcode, the arrows will not jump from right to left, which looks very visually jarring. It also provides a more natural location for dataflow-based diagnostics. Along the way, we found a case in the analyzer diagnostics where we needed to indicate that a variable was "captured" by a block. -fsyntax-only timings on sqlite3.c show no visible performance change, although this is just one test case. Fixes <rdar://problem/13016513> llvm-svn: 174447
2013-02-06 06:00:19 +08:00
// CHECK: 1: foo
// CHECK: 2: [B2.1] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(int))
// CHECK: 3: 0
// CHECK: 4: [B2.2]([B2.3])
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (1): B4
// CHECK: Succs (1): B1
// CHECK: [B3]
Change subexpressions to be visited in the CFG from left-to-right. This is a more natural order of evaluation, and it is very important for visualization in the static analyzer. Within Xcode, the arrows will not jump from right to left, which looks very visually jarring. It also provides a more natural location for dataflow-based diagnostics. Along the way, we found a case in the analyzer diagnostics where we needed to indicate that a variable was "captured" by a block. -fsyntax-only timings on sqlite3.c show no visible performance change, although this is just one test case. Fixes <rdar://problem/13016513> llvm-svn: 174447
2013-02-06 06:00:19 +08:00
// CHECK: 1: foo
// CHECK: 2: [B3.1] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(int))
// CHECK: 3: 0
// CHECK: 4: [B3.2]([B3.3])
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (1): B4
// CHECK: Succs (1): B1
// CHECK: [B4]
// CHECK: 1: ~B() (Temporary object destructor)
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 2: B() (CXXConstructExpr, class B)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 2: B() (CXXConstructExpr, [B4.3], [B4.4], class B)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 3: [B4.2] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 4: [B4.3]
// CHECK: 5: [B4.4].operator bool
// CHECK: 6: [B4.4]
// CHECK: 7: [B4.6] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CHECK: 8: ~B() (Temporary object destructor)
// CHECK: T: if [B4.7]
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (2): B5 B6
// CHECK: Succs (2): B3 B2
// CHECK: [B5]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: 2: ~A() (Temporary object destructor)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B7
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Succs (1): B4
// CHECK: [B6]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: 2: ~A() (Temporary object destructor)
// CHECK: 3: ~A() (Temporary object destructor)
// CHECK: 4: ~B() (Temporary object destructor)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B7
// CHECK: Succs (1): B4
// CHECK: [B7]
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 1: [B10.6] ? [B8.6] : [B9.16]
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B7.1] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 3: [B7.2]
[CFG] Provide construction contexts when constructors have cleanups. Now that we make it possible to query the CFG constructor element to find information about the construction site, possible cleanup work represented by ExprWithCleanups should not prevent us from providing this information. This allows us to have a correct construction context for variables initialized "by value" via elidable copy-constructors, such as 'i' in iterator i = vector.begin(); Differential Revision: https://reviews.llvm.org/D42719 llvm-svn: 324798
2018-02-10 10:46:14 +08:00
// WARNINGS: 4: [B7.3] (CXXConstructExpr, class A)
// ANALYZER: 4: [B7.3] (CXXConstructExpr, [B7.5], class A)
Fix modelling of non-lifetime-extended temporary destructors in the analyzer. 1. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 214962
2014-08-06 20:45:51 +08:00
// CHECK: 5: A a = B() ? A() : A(B());
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: T: (Temp Dtor) [B9.2]
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (2): B8 B9
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Succs (2): B6 B5
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: [B8]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
[CFG] [analyzer] Add construction contexts that explain pre-C++17 copy elision. Before C++17 copy elision was optional, even if the elidable copy/move constructor had arbitrary side effects. The elidable constructor is present in the AST, but marked as elidable. In these cases CFG now contains additional information that allows its clients to figure out if a temporary object is only being constructed so that to pass it to an elidable constructor. If so, it includes a reference to the elidable constructor's construction context, so that the client could elide the elidable constructor and construct the object directly at its final destination. Differential Revision: https://reviews.llvm.org/D47616 llvm-svn: 335795
2018-06-28 08:04:54 +08:00
// ANALYZER: 1: A() (CXXConstructExpr, [B8.2], [B8.4], [B8.5], class A)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B8.1] (BindTemporary)
// CHECK: 3: [B8.2] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 4: [B8.3]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 5: [B8.4] (CXXConstructExpr, class A)
[CFG] [analyzer] Add construction contexts that explain pre-C++17 copy elision. Before C++17 copy elision was optional, even if the elidable copy/move constructor had arbitrary side effects. The elidable constructor is present in the AST, but marked as elidable. In these cases CFG now contains additional information that allows its clients to figure out if a temporary object is only being constructed so that to pass it to an elidable constructor. If so, it includes a reference to the elidable constructor's construction context, so that the client could elide the elidable constructor and construct the object directly at its final destination. Differential Revision: https://reviews.llvm.org/D47616 llvm-svn: 335795
2018-06-28 08:04:54 +08:00
// ANALYZER: 5: [B8.4] (CXXConstructExpr, [B8.6], [B7.3], [B7.4], class A)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 6: [B8.5] (BindTemporary)
// CHECK: Preds (1): B10
// CHECK: Succs (1): B7
// CHECK: [B9]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: B() (CXXConstructExpr, class B)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 1: B() (CXXConstructExpr, [B9.2], [B9.3], class B)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 2: [B9.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B9.2]
// CHECK: 4: [B9.3].operator A
// CHECK: 5: [B9.3]
// CHECK: 6: [B9.5] (ImplicitCastExpr, UserDefinedConversion, class A)
// CHECK: 7: [B9.6] (BindTemporary)
// CHECK: 8: [B9.7] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 9: [B9.8]
// WARNINGS: 10: [B9.9] (CXXConstructExpr, class A)
// ANALYZER: 10: [B9.9] (CXXConstructExpr, [B9.11], [B9.14], [B9.15], class A)
// CHECK: 11: [B9.10] (BindTemporary)
// CHECK: 12: A([B9.11]) (CXXFunctionalCastExpr, ConstructorConversion, class A)
// CHECK: 13: [B9.12] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 14: [B9.13]
// WARNINGS: 15: [B9.14] (CXXConstructExpr, class A)
// ANALYZER: 15: [B9.14] (CXXConstructExpr, [B9.16], [B7.3], [B7.4], class A)
// CHECK: 16: [B9.15] (BindTemporary)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B10
// CHECK: Succs (1): B7
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B10]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: B() (CXXConstructExpr, class B)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 1: B() (CXXConstructExpr, [B10.2], [B10.3], class B)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 2: [B10.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B10.2]
// CHECK: 4: [B10.3].operator bool
// CHECK: 5: [B10.3]
// CHECK: 6: [B10.5] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CHECK: T: [B10.6] ? ... : ...
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (1): B11
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Succs (2): B8 B9
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
// CHECK: 1: true
// CHECK: 2: b_([B1.1]) (Member initializer)
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B1 (ENTRY)]
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
// CHECK: 1: this
// CHECK: 2: [B1.1]->b_
// CHECK: 3: [B1.2] (ImplicitCastExpr, LValueToRValue, _Bool)
// CHECK: 4: return [B1.3];
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
// CHECK: 1: true
// CHECK: 2: b_([B1.1]) (Member initializer)
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
// CHECK: 1: this
// CHECK: 2: [B1.1]->b_
// CHECK: 3: [B1.2] (ImplicitCastExpr, LValueToRValue, _Bool)
// CHECK: 4: return [B1.3];
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B4 (ENTRY)]
// CHECK: Succs (1): B3
// CHECK: [B1]
// CHECK: 1: 0
// CHECK: 2: return [B1.1];
// CHECK: Preds (1): B3
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: 1
// CHECK: 2: return [B2.1];
// CHECK: Preds (1): B3
// CHECK: Succs (1): B0
// CHECK: [B3]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: C() (CXXConstructExpr, struct C)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 1: C() (CXXConstructExpr, [B3.2], [B3.3], struct C)
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: 2: [B3.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B3.2]
// CHECK: 4: [B3.3].operator bool
// CHECK: 5: [B3.3]
// CHECK: 6: [B3.5] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CHECK: 7: ~C() (Temporary object destructor)
// CHECK: T: if [B3.6]
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: Preds (1): B4
// CHECK: Succs (2): B2 B1
// CHECK: [B0 (EXIT)]
// CHECK: Preds (2): B1 B2
// CHECK: [B5 (ENTRY)]
// CHECK: Succs (1): B4
// CHECK: [B1]
Fix handling of condition variables in the face of temp dtors. The assignment needs to be before the destruction of the temporary. This patch calls out to addStmt, which invokes VisitDeclStmt, which has all the correct logic for handling temporaries. llvm-svn: 207985
2014-05-06 02:21:06 +08:00
// CHECK: 1: [B4.6].~C() (Implicit destructor)
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: 0
// CHECK: 2: return [B2.1];
Fix handling of condition variables in the face of temp dtors. The assignment needs to be before the destruction of the temporary. This patch calls out to addStmt, which invokes VisitDeclStmt, which has all the correct logic for handling temporaries. llvm-svn: 207985
2014-05-06 02:21:06 +08:00
// CHECK: 3: [B4.6].~C() (Implicit destructor)
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: Preds (1): B4
// CHECK: Succs (1): B0
// CHECK: [B3]
// CHECK: 1: 1
// CHECK: 2: return [B3.1];
Fix handling of condition variables in the face of temp dtors. The assignment needs to be before the destruction of the temporary. This patch calls out to addStmt, which invokes VisitDeclStmt, which has all the correct logic for handling temporaries. llvm-svn: 207985
2014-05-06 02:21:06 +08:00
// CHECK: 3: [B4.6].~C() (Implicit destructor)
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: Preds (1): B4
// CHECK: Succs (1): B0
// CHECK: [B4]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: C() (CXXConstructExpr, struct C)
[CFG] [analyzer] Add construction contexts that explain pre-C++17 copy elision. Before C++17 copy elision was optional, even if the elidable copy/move constructor had arbitrary side effects. The elidable constructor is present in the AST, but marked as elidable. In these cases CFG now contains additional information that allows its clients to figure out if a temporary object is only being constructed so that to pass it to an elidable constructor. If so, it includes a reference to the elidable constructor's construction context, so that the client could elide the elidable constructor and construct the object directly at its final destination. Differential Revision: https://reviews.llvm.org/D47616 llvm-svn: 335795
2018-06-28 08:04:54 +08:00
// ANALYZER: 1: C() (CXXConstructExpr, [B4.2], [B4.4], [B4.5], struct C)
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: 2: [B4.1] (BindTemporary)
// CHECK: 3: [B4.2] (ImplicitCastExpr, NoOp, const struct C)
// CHECK: 4: [B4.3]
[CFG] Provide construction contexts when constructors have cleanups. Now that we make it possible to query the CFG constructor element to find information about the construction site, possible cleanup work represented by ExprWithCleanups should not prevent us from providing this information. This allows us to have a correct construction context for variables initialized "by value" via elidable copy-constructors, such as 'i' in iterator i = vector.begin(); Differential Revision: https://reviews.llvm.org/D42719 llvm-svn: 324798
2018-02-10 10:46:14 +08:00
// WARNINGS: 5: [B4.4] (CXXConstructExpr, struct C)
// ANALYZER: 5: [B4.4] (CXXConstructExpr, [B4.6], struct C)
Fix handling of condition variables in the face of temp dtors. The assignment needs to be before the destruction of the temporary. This patch calls out to addStmt, which invokes VisitDeclStmt, which has all the correct logic for handling temporaries. llvm-svn: 207985
2014-05-06 02:21:06 +08:00
// CHECK: 6: C c = C();
// CHECK: 7: ~C() (Temporary object destructor)
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: 8: c
// CHECK: 9: [B4.8].operator bool
// CHECK: 10: [B4.8]
// CHECK: 11: [B4.10] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CHECK: T: if [B4.11]
// CHECK: Preds (1): B5
// CHECK: Succs (2): B3 B2
// CHECK: [B0 (EXIT)]
// CHECK: Preds (3): B1 B2 B3
// CHECK: [B4 (ENTRY)]
// CHECK: Succs (1): B3
// CHECK: [B1]
// CHECK: 1: 0
// CHECK: 2: return [B1.1];
// CHECK: Preds (1): B3
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: 1
// CHECK: 2: return [B2.1];
// CHECK: Preds (1): B3
// CHECK: Succs (1): B0
// CHECK: [B3]
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// WARNINGS: 1: D() (CXXConstructExpr, struct D)
// ANALYZER: 1: D() (CXXConstructExpr, [B3.2], struct D)
// CHECK: 2: [B3.1]
// CHECK: 3: [B3.2].operator bool
// CHECK: 4: [B3.2]
// CHECK: 5: [B3.4] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CHECK: T: if [B3.5]
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: Preds (1): B4
// CHECK: Succs (2): B2 B1
// CHECK: [B0 (EXIT)]
// CHECK: Preds (2): B1 B2
// CHECK: [B4 (ENTRY)]
// CHECK: Succs (1): B3
// CHECK: [B1]
// CHECK: 1: 0
// CHECK: 2: return [B1.1];
// CHECK: Preds (1): B3
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: 1
// CHECK: 2: return [B2.1];
// CHECK: Preds (1): B3
// CHECK: Succs (1): B0
// CHECK: [B3]
[CFG] Provide construction contexts for temporaries bound to const references. In order to bind a temporary to a const lvalue reference, a no-op cast is added to make the temporary itself const, and only then the reference is taken (materialized). Skip the no-op cast when looking for the construction context. Differential Revision: https://reviews.llvm.org/D43481 llvm-svn: 326016
2018-02-24 10:07:50 +08:00
// CXX98-WARNINGS: 1: D() (CXXConstructExpr, struct D)
[CFG] [analyzer] Add construction contexts that explain pre-C++17 copy elision. Before C++17 copy elision was optional, even if the elidable copy/move constructor had arbitrary side effects. The elidable constructor is present in the AST, but marked as elidable. In these cases CFG now contains additional information that allows its clients to figure out if a temporary object is only being constructed so that to pass it to an elidable constructor. If so, it includes a reference to the elidable constructor's construction context, so that the client could elide the elidable constructor and construct the object directly at its final destination. Differential Revision: https://reviews.llvm.org/D47616 llvm-svn: 335795
2018-06-28 08:04:54 +08:00
// CXX98-ANALYZER: 1: D() (CXXConstructExpr, [B3.3], [B3.4], struct D)
[Tests] Modified Lit Tests to be C++11 compatibile This 2nd patch should not change the test results, but it is useful if clang's default C++ language is ever changed from gnu++98. llvm-svn: 246183
2015-08-28 02:49:15 +08:00
// CXX98: 2: [B3.1] (ImplicitCastExpr, NoOp, const struct D)
// CXX98: 3: [B3.2]
[CFG] Provide construction contexts when constructors have cleanups. Now that we make it possible to query the CFG constructor element to find information about the construction site, possible cleanup work represented by ExprWithCleanups should not prevent us from providing this information. This allows us to have a correct construction context for variables initialized "by value" via elidable copy-constructors, such as 'i' in iterator i = vector.begin(); Differential Revision: https://reviews.llvm.org/D42719 llvm-svn: 324798
2018-02-10 10:46:14 +08:00
// CXX98-WARNINGS: 4: [B3.3] (CXXConstructExpr, struct D)
// CXX98-ANALYZER: 4: [B3.3] (CXXConstructExpr, [B3.5], struct D)
[Tests] Modified Lit Tests to be C++11 compatibile This 2nd patch should not change the test results, but it is useful if clang's default C++ language is ever changed from gnu++98. llvm-svn: 246183
2015-08-28 02:49:15 +08:00
// CXX98: 5: D d = D();
// CXX98: 6: d
// CXX98: 7: [B3.6].operator bool
// CXX98: 8: [B3.6]
// CXX98: 9: [B3.8] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CXX98: T: if [B3.9]
[CFG] Provide construction contexts for temporaries bound to const references. In order to bind a temporary to a const lvalue reference, a no-op cast is added to make the temporary itself const, and only then the reference is taken (materialized). Skip the no-op cast when looking for the construction context. Differential Revision: https://reviews.llvm.org/D43481 llvm-svn: 326016
2018-02-24 10:07:50 +08:00
// CXX11-WARNINGS: 1: D() (CXXConstructExpr, struct D)
[CFG] [analyzer] Add construction contexts that explain pre-C++17 copy elision. Before C++17 copy elision was optional, even if the elidable copy/move constructor had arbitrary side effects. The elidable constructor is present in the AST, but marked as elidable. In these cases CFG now contains additional information that allows its clients to figure out if a temporary object is only being constructed so that to pass it to an elidable constructor. If so, it includes a reference to the elidable constructor's construction context, so that the client could elide the elidable constructor and construct the object directly at its final destination. Differential Revision: https://reviews.llvm.org/D47616 llvm-svn: 335795
2018-06-28 08:04:54 +08:00
// CXX11-ANALYZER: 1: D() (CXXConstructExpr, [B3.2], [B3.3], struct D)
[Tests] Modified Lit Tests to be C++11 compatibile This 2nd patch should not change the test results, but it is useful if clang's default C++ language is ever changed from gnu++98. llvm-svn: 246183
2015-08-28 02:49:15 +08:00
// CXX11: 2: [B3.1]
[CFG] Provide construction contexts when constructors have cleanups. Now that we make it possible to query the CFG constructor element to find information about the construction site, possible cleanup work represented by ExprWithCleanups should not prevent us from providing this information. This allows us to have a correct construction context for variables initialized "by value" via elidable copy-constructors, such as 'i' in iterator i = vector.begin(); Differential Revision: https://reviews.llvm.org/D42719 llvm-svn: 324798
2018-02-10 10:46:14 +08:00
// CXX11-WARNINGS: 3: [B3.2] (CXXConstructExpr, struct D)
// CXX11-ANALYZER: 3: [B3.2] (CXXConstructExpr, [B3.4], struct D)
[Tests] Modified Lit Tests to be C++11 compatibile This 2nd patch should not change the test results, but it is useful if clang's default C++ language is ever changed from gnu++98. llvm-svn: 246183
2015-08-28 02:49:15 +08:00
// CXX11: 4: D d = D();
// CXX11: 5: d
// CXX11: 6: [B3.5].operator bool
// CXX11: 7: [B3.5]
// CXX11: 8: [B3.7] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CXX11: T: if [B3.8]
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: Preds (1): B4
// CHECK: Succs (2): B2 B1
// CHECK: [B0 (EXIT)]
// CHECK: Preds (2): B1 B2
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: [B14 (ENTRY)]
// CHECK: Succs (1): B13
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B1]
// CHECK: 1: ~B() (Temporary object destructor)
// CHECK: 2: int b;
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 3: [B10.4].~A() (Implicit destructor)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (2): B2 B3
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: 2: ~A() (Temporary object destructor)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B4
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Succs (1): B1
// CHECK: [B3]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: 2: ~A() (Temporary object destructor)
// CHECK: 3: ~A() (Temporary object destructor)
// CHECK: 4: ~B() (Temporary object destructor)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B4
// CHECK: Succs (1): B1
// CHECK: [B4]
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 1: [B7.9] ? [B5.6] : [B6.16]
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B4.1] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 3: [B4.2]
// CHECK: 4: [B7.3]([B4.3])
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: T: (Temp Dtor) [B6.2]
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (2): B5 B6
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Succs (2): B3 B2
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B5]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
[CFG] [analyzer] Add construction contexts that explain pre-C++17 copy elision. Before C++17 copy elision was optional, even if the elidable copy/move constructor had arbitrary side effects. The elidable constructor is present in the AST, but marked as elidable. In these cases CFG now contains additional information that allows its clients to figure out if a temporary object is only being constructed so that to pass it to an elidable constructor. If so, it includes a reference to the elidable constructor's construction context, so that the client could elide the elidable constructor and construct the object directly at its final destination. Differential Revision: https://reviews.llvm.org/D47616 llvm-svn: 335795
2018-06-28 08:04:54 +08:00
// ANALYZER: 1: A() (CXXConstructExpr, [B5.2], [B5.4], [B5.5], class A)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B5.1] (BindTemporary)
// CHECK: 3: [B5.2] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 4: [B5.3]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 5: [B5.4] (CXXConstructExpr, class A)
[CFG] Provide construction contexts for temporaries in conditional operators. When a lifetime-extended temporary is on a branch of a conditional operator, materialization of such temporary occurs after the condition is resolved. This change allows us to understand, by including the MaterializeTemporaryExpr in the construction context, the target for temporary materialization in such cases. Differential Revision: https://reviews.llvm.org/D43483 llvm-svn: 326019
2018-02-24 11:10:15 +08:00
// ANALYZER: 5: [B5.4] (CXXConstructExpr, [B5.6], [B4.3], class A)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 6: [B5.5] (BindTemporary)
// CHECK: Preds (1): B7
// CHECK: Succs (1): B4
// CHECK: [B6]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: B() (CXXConstructExpr, class B)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 1: B() (CXXConstructExpr, [B6.2], [B6.3], class B)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 2: [B6.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B6.2]
// CHECK: 4: [B6.3].operator A
// CHECK: 5: [B6.3]
// CHECK: 6: [B6.5] (ImplicitCastExpr, UserDefinedConversion, class A)
// CHECK: 7: [B6.6] (BindTemporary)
// CHECK: 8: [B6.7] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 9: [B6.8]
// WARNINGS: 10: [B6.9] (CXXConstructExpr, class A)
// ANALYZER: 10: [B6.9] (CXXConstructExpr, [B6.11], [B6.14], [B6.15], class A)
// CHECK: 11: [B6.10] (BindTemporary)
// CHECK: 12: A([B6.11]) (CXXFunctionalCastExpr, ConstructorConversion, class A)
// CHECK: 13: [B6.12] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 14: [B6.13]
// WARNINGS: 15: [B6.14] (CXXConstructExpr, class A)
// ANALYZER: 15: [B6.14] (CXXConstructExpr, [B6.16], [B4.3], class A)
// CHECK: 16: [B6.15] (BindTemporary)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B7
// CHECK: Succs (1): B4
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B7]
// CHECK: 1: ~B() (Temporary object destructor)
Change subexpressions to be visited in the CFG from left-to-right. This is a more natural order of evaluation, and it is very important for visualization in the static analyzer. Within Xcode, the arrows will not jump from right to left, which looks very visually jarring. It also provides a more natural location for dataflow-based diagnostics. Along the way, we found a case in the analyzer diagnostics where we needed to indicate that a variable was "captured" by a block. -fsyntax-only timings on sqlite3.c show no visible performance change, although this is just one test case. Fixes <rdar://problem/13016513> llvm-svn: 174447
2013-02-06 06:00:19 +08:00
// CHECK: 2: foo
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 3: [B7.2] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &))
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 4: B() (CXXConstructExpr, class B)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 4: B() (CXXConstructExpr, [B7.5], [B7.6], class B)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 5: [B7.4] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 6: [B7.5]
// CHECK: 7: [B7.6].operator bool
// CHECK: 8: [B7.6]
// CHECK: 9: [B7.8] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CHECK: T: [B7.9] ? ... : ...
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (2): B8 B9
// CHECK: Succs (2): B5 B6
// CHECK: [B8]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: Preds (1): B10
// CHECK: Succs (1): B7
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B9]
// CHECK: 1: ~A() (Temporary object destructor)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: ~A() (Temporary object destructor)
// CHECK: 3: ~B() (Temporary object destructor)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (1): B10
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Succs (1): B7
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B10]
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 1: [B13.6] ? [B11.6] : [B12.16]
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B10.1] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 3: [B10.2]
// CHECK: 4: const A &a = B() ? A() : A(B());
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: T: (Temp Dtor) [B12.2]
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (2): B11 B12
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Succs (2): B9 B8
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B11]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
[CFG] [analyzer] Add construction contexts that explain pre-C++17 copy elision. Before C++17 copy elision was optional, even if the elidable copy/move constructor had arbitrary side effects. The elidable constructor is present in the AST, but marked as elidable. In these cases CFG now contains additional information that allows its clients to figure out if a temporary object is only being constructed so that to pass it to an elidable constructor. If so, it includes a reference to the elidable constructor's construction context, so that the client could elide the elidable constructor and construct the object directly at its final destination. Differential Revision: https://reviews.llvm.org/D47616 llvm-svn: 335795
2018-06-28 08:04:54 +08:00
// ANALYZER: 1: A() (CXXConstructExpr, [B11.2], [B11.4], [B11.5], class A)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B11.1] (BindTemporary)
// CHECK: 3: [B11.2] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 4: [B11.3]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 5: [B11.4] (CXXConstructExpr, class A)
[CFG] [analyzer] Simplify lifetime-extended temporary construction contexts. When a temporary object is materialized and through that obtain lifetime that is longer than the duration of the full-expression, it does not require a temporary object destructor; it will be destroyed in a different manner. Therefore it's not necessary to include CXXBindTemporaryExpr into the construction context for such temporary in the CFG only to make clients throw it away. Differential Revision: https://reviews.llvm.org/D47667 llvm-svn: 335798
2018-06-28 08:18:52 +08:00
// ANALYZER: 5: [B11.4] (CXXConstructExpr, [B10.3], class A)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 6: [B11.5] (BindTemporary)
// CHECK: Preds (1): B13
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Succs (1): B10
// CHECK: [B12]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: B() (CXXConstructExpr, class B)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 1: B() (CXXConstructExpr, [B12.2], [B12.3], class B)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B12.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B12.2]
// CHECK: 4: [B12.3].operator A
// CHECK: 5: [B12.3]
// CHECK: 6: [B12.5] (ImplicitCastExpr, UserDefinedConversion, class A)
// CHECK: 7: [B12.6] (BindTemporary)
// CHECK: 8: [B12.7] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 9: [B12.8]
// WARNINGS: 10: [B12.9] (CXXConstructExpr, class A)
// ANALYZER: 10: [B12.9] (CXXConstructExpr, [B12.11], [B12.14], [B12.15], class A)
// CHECK: 11: [B12.10] (BindTemporary)
// CHECK: 12: A([B12.11]) (CXXFunctionalCastExpr, ConstructorConversion, class A)
// CHECK: 13: [B12.12] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 14: [B12.13]
// WARNINGS: 15: [B12.14] (CXXConstructExpr, class A)
// ANALYZER: 15: [B12.14] (CXXConstructExpr, [B10.3], class A)
// CHECK: 16: [B12.15] (BindTemporary)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B13
// CHECK: Succs (1): B10
// CHECK: [B13]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: B() (CXXConstructExpr, class B)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 1: B() (CXXConstructExpr, [B13.2], [B13.3], class B)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B13.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B13.2]
// CHECK: 4: [B13.3].operator bool
// CHECK: 5: [B13.3]
// CHECK: 6: [B13.5] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CHECK: T: [B13.6] ? ... : ...
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B14
// CHECK: Succs (2): B11 B12
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: [B8 (ENTRY)]
// CHECK: Succs (1): B7
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B1]
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: 1: int b;
// CHECK: 2: [B4.5].~A() (Implicit destructor)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (2): B2 B3
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: ~A() (Temporary object destructor)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B4
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Succs (1): B1
// CHECK: [B3]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: 2: ~A() (Temporary object destructor)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B4
// CHECK: Succs (1): B1
// CHECK: [B4]
PR35039: Materialize temporary objects before wrapping them in an OpaqueValueExpr in a GNU binary conditional expression. It's not meaningful for a non-materialized temporary object to be used as a common subexpression of multiple expressions. llvm-svn: 316836
2017-10-29 02:59:51 +08:00
// CXX98: 1: [B7.2] ?: [B6.6]
// CXX11: 1: [B7.3] ?: [B6.6]
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B4.1] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 3: [B4.2]
[CFG] Provide construction contexts when constructors have cleanups. Now that we make it possible to query the CFG constructor element to find information about the construction site, possible cleanup work represented by ExprWithCleanups should not prevent us from providing this information. This allows us to have a correct construction context for variables initialized "by value" via elidable copy-constructors, such as 'i' in iterator i = vector.begin(); Differential Revision: https://reviews.llvm.org/D42719 llvm-svn: 324798
2018-02-10 10:46:14 +08:00
// WARNINGS: 4: [B4.3] (CXXConstructExpr, class A)
// ANALYZER: 4: [B4.3] (CXXConstructExpr, [B4.5], class A)
Fix modelling of non-lifetime-extended temporary destructors in the analyzer. 1. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 214962
2014-08-06 20:45:51 +08:00
// CHECK: 5: A a = A() ?: A();
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: T: (Temp Dtor) [B6.2]
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (2): B5 B6
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Succs (2): B3 B2
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: [B5]
PR35039: Materialize temporary objects before wrapping them in an OpaqueValueExpr in a GNU binary conditional expression. It's not meaningful for a non-materialized temporary object to be used as a common subexpression of multiple expressions. llvm-svn: 316836
2017-10-29 02:59:51 +08:00
// CXX98: 1: [B7.2] (ImplicitCastExpr, NoOp, const class A)
// CXX98: 2: [B5.1]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS-CXX98: 3: [B5.2] (CXXConstructExpr, class A)
// ANALYZER-CXX98: 3: [B5.2] (CXXConstructExpr, [B5.4], class A)
PR35039: Materialize temporary objects before wrapping them in an OpaqueValueExpr in a GNU binary conditional expression. It's not meaningful for a non-materialized temporary object to be used as a common subexpression of multiple expressions. llvm-svn: 316836
2017-10-29 02:59:51 +08:00
// CXX98: 4: [B5.3] (BindTemporary)
// CXX11: 1: [B7.3] (ImplicitCastExpr, NoOp, const class A)
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS-CXX11: 2: [B5.1] (CXXConstructExpr, class A)
// ANALYZER-CXX11: 2: [B5.1] (CXXConstructExpr, [B5.3], class A)
PR35039: Materialize temporary objects before wrapping them in an OpaqueValueExpr in a GNU binary conditional expression. It's not meaningful for a non-materialized temporary object to be used as a common subexpression of multiple expressions. llvm-svn: 316836
2017-10-29 02:59:51 +08:00
// CXX11: 3: [B5.2] (BindTemporary)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B7
// CHECK: Succs (1): B4
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B6]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
[CFG] [analyzer] Add construction contexts that explain pre-C++17 copy elision. Before C++17 copy elision was optional, even if the elidable copy/move constructor had arbitrary side effects. The elidable constructor is present in the AST, but marked as elidable. In these cases CFG now contains additional information that allows its clients to figure out if a temporary object is only being constructed so that to pass it to an elidable constructor. If so, it includes a reference to the elidable constructor's construction context, so that the client could elide the elidable constructor and construct the object directly at its final destination. Differential Revision: https://reviews.llvm.org/D47616 llvm-svn: 335795
2018-06-28 08:04:54 +08:00
// ANALYZER: 1: A() (CXXConstructExpr, [B6.2], [B6.4], [B6.5], class A)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B6.1] (BindTemporary)
// CHECK: 3: [B6.2] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 4: [B6.3]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 5: [B6.4] (CXXConstructExpr, class A)
// ANALYZER: 5: [B6.4] (CXXConstructExpr, [B6.6], class A)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 6: [B6.5] (BindTemporary)
// CHECK: Preds (1): B7
// CHECK: Succs (1): B4
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B7]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
[CFG] Provide construction contexts for lifetime-extended temporaries. When constructing a temporary that is going to be lifetime-extended through a MaterializeTemporaryExpr later, CFG elements for the respective constructor can now be queried to obtain the reference to that MaterializeTemporaryExpr and therefore gain information about lifetime extension. This may produce multi-layered construction contexts when information about both temporary destruction and lifetime extension is available. Differential Revision: https://reviews.llvm.org/D43477 llvm-svn: 326014
2018-02-24 10:00:30 +08:00
// ANALYZER-CXX98: 1: A() (CXXConstructExpr, [B7.2], [B7.3], class A)
// ANALYZER-CXX11: 1: A() (CXXConstructExpr, [B7.2], class A)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 2: [B7.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B7.2]
// CHECK: 4: [B7.3].operator bool
// CHECK: 5: [B7.3]
// CHECK: 6: [B7.5] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CHECK: T: [B7.6] ? ... : ...
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (1): B8
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Succs (2): B5 B6
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: [B13 (ENTRY)]
// CHECK: Succs (1): B12
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B1]
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: 1: int b;
// CHECK: 2: [B9.4].~A() (Implicit destructor)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (2): B2 B3
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: ~A() (Temporary object destructor)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B4
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Succs (1): B1
// CHECK: [B3]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: 2: ~A() (Temporary object destructor)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B4
// CHECK: Succs (1): B1
// CHECK: [B4]
PR35039: Materialize temporary objects before wrapping them in an OpaqueValueExpr in a GNU binary conditional expression. It's not meaningful for a non-materialized temporary object to be used as a common subexpression of multiple expressions. llvm-svn: 316836
2017-10-29 02:59:51 +08:00
// CXX98: 1: [B7.4] ?: [B6.6]
// CXX11: 1: [B7.5] ?: [B6.6]
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B4.1] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 3: [B4.2]
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: 4: [B7.2]([B4.3])
// CHECK: T: (Temp Dtor) [B6.2]
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (2): B5 B6
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Succs (2): B3 B2
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B5]
PR35039: Materialize temporary objects before wrapping them in an OpaqueValueExpr in a GNU binary conditional expression. It's not meaningful for a non-materialized temporary object to be used as a common subexpression of multiple expressions. llvm-svn: 316836
2017-10-29 02:59:51 +08:00
// CXX98: 1: [B7.4] (ImplicitCastExpr, NoOp, const class A)
// CXX98: 2: [B5.1]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS-CXX98: 3: [B5.2] (CXXConstructExpr, class A)
// ANALYZER-CXX98: 3: [B5.2] (CXXConstructExpr, [B5.4], class A)
PR35039: Materialize temporary objects before wrapping them in an OpaqueValueExpr in a GNU binary conditional expression. It's not meaningful for a non-materialized temporary object to be used as a common subexpression of multiple expressions. llvm-svn: 316836
2017-10-29 02:59:51 +08:00
// CXX98: 4: [B5.3] (BindTemporary)
// CXX11: 1: [B7.5] (ImplicitCastExpr, NoOp, const class A)
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS-CXX11: 2: [B5.1] (CXXConstructExpr, class A)
// ANALYZER-CXX11: 2: [B5.1] (CXXConstructExpr, [B5.3], class A)
PR35039: Materialize temporary objects before wrapping them in an OpaqueValueExpr in a GNU binary conditional expression. It's not meaningful for a non-materialized temporary object to be used as a common subexpression of multiple expressions. llvm-svn: 316836
2017-10-29 02:59:51 +08:00
// CXX11: 3: [B5.2] (BindTemporary)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B7
// CHECK: Succs (1): B4
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B6]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
[CFG] [analyzer] Add construction contexts that explain pre-C++17 copy elision. Before C++17 copy elision was optional, even if the elidable copy/move constructor had arbitrary side effects. The elidable constructor is present in the AST, but marked as elidable. In these cases CFG now contains additional information that allows its clients to figure out if a temporary object is only being constructed so that to pass it to an elidable constructor. If so, it includes a reference to the elidable constructor's construction context, so that the client could elide the elidable constructor and construct the object directly at its final destination. Differential Revision: https://reviews.llvm.org/D47616 llvm-svn: 335795
2018-06-28 08:04:54 +08:00
// ANALYZER: 1: A() (CXXConstructExpr, [B6.2], [B6.4], [B6.5], class A)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B6.1] (BindTemporary)
// CHECK: 3: [B6.2] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 4: [B6.3]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 5: [B6.4] (CXXConstructExpr, class A)
// ANALYZER: 5: [B6.4] (CXXConstructExpr, [B6.6], class A)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 6: [B6.5] (BindTemporary)
// CHECK: Preds (1): B7
// CHECK: Succs (1): B4
// CHECK: [B7]
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: 1: foo
// CHECK: 2: [B7.1] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &))
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 3: A() (CXXConstructExpr, class A)
[CFG] Provide construction contexts for lifetime-extended temporaries. When constructing a temporary that is going to be lifetime-extended through a MaterializeTemporaryExpr later, CFG elements for the respective constructor can now be queried to obtain the reference to that MaterializeTemporaryExpr and therefore gain information about lifetime extension. This may produce multi-layered construction contexts when information about both temporary destruction and lifetime extension is available. Differential Revision: https://reviews.llvm.org/D43477 llvm-svn: 326014
2018-02-24 10:00:30 +08:00
// ANALYZER-CXX98: 3: A() (CXXConstructExpr, [B7.4], class A)
// ANALYZER-CXX11: 3: A() (CXXConstructExpr, class A)
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: 4: [B7.3] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 5: [B7.4]
// CHECK: 6: [B7.5].operator bool
// CHECK: 7: [B7.5]
// CHECK: 8: [B7.7] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CHECK: T: [B7.8] ? ... : ...
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Preds (2): B8 B9
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Succs (2): B5 B6
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B8]
Fix modelling of non-lifetime-extended temporary destructors in the analyzer. 1. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 214962
2014-08-06 20:45:51 +08:00
// CHECK: 1: ~A() (Temporary object destructor)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B9
// CHECK: Succs (1): B7
// CHECK: [B9]
PR35039: Materialize temporary objects before wrapping them in an OpaqueValueExpr in a GNU binary conditional expression. It's not meaningful for a non-materialized temporary object to be used as a common subexpression of multiple expressions. llvm-svn: 316836
2017-10-29 02:59:51 +08:00
// CXX98: 1: [B12.2] ?: [B11.6]
// CXX11: 1: [B12.3] ?: [B11.6]
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B9.1] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 3: [B9.2]
Fix modelling of non-lifetime-extended temporary destructors in the analyzer. 1. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 214962
2014-08-06 20:45:51 +08:00
// CHECK: 4: const A &a = A() ?: A();
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: T: (Temp Dtor) [B11.2]
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (2): B10 B11
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Succs (2): B8 B7
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: [B10]
PR35039: Materialize temporary objects before wrapping them in an OpaqueValueExpr in a GNU binary conditional expression. It's not meaningful for a non-materialized temporary object to be used as a common subexpression of multiple expressions. llvm-svn: 316836
2017-10-29 02:59:51 +08:00
// CXX98: 1: [B12.2] (ImplicitCastExpr, NoOp, const class A)
// CXX98: 2: [B10.1]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS-CXX98: 3: [B10.2] (CXXConstructExpr, class A)
// ANALYZER-CXX98: 3: [B10.2] (CXXConstructExpr, [B10.4], class A)
PR35039: Materialize temporary objects before wrapping them in an OpaqueValueExpr in a GNU binary conditional expression. It's not meaningful for a non-materialized temporary object to be used as a common subexpression of multiple expressions. llvm-svn: 316836
2017-10-29 02:59:51 +08:00
// CXX98: 4: [B10.3] (BindTemporary)
// CXX11: 1: [B12.3] (ImplicitCastExpr, NoOp, const class A)
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS-CXX11: 2: [B10.1] (CXXConstructExpr, class A)
// ANALYZER-CXX11: 2: [B10.1] (CXXConstructExpr, [B10.3], class A)
PR35039: Materialize temporary objects before wrapping them in an OpaqueValueExpr in a GNU binary conditional expression. It's not meaningful for a non-materialized temporary object to be used as a common subexpression of multiple expressions. llvm-svn: 316836
2017-10-29 02:59:51 +08:00
// CXX11: 3: [B10.2] (BindTemporary)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Preds (1): B12
// CHECK: Succs (1): B9
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B11]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS-CHECK: 1: A() (CXXConstructExpr, class A)
// ANALYZER-CHECK: 1: A() (CXXConstructExpr, [B11.2], class A)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 2: [B11.1] (BindTemporary)
// CHECK: 3: [B11.2] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 4: [B11.3]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 5: [B11.4] (CXXConstructExpr, class A)
// ANALYZER: 5: [B11.4] (CXXConstructExpr, [B11.6], class A)
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: 6: [B11.5] (BindTemporary)
// CHECK: Preds (1): B12
// CHECK: Succs (1): B9
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B12]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
[CFG] Provide construction contexts for lifetime-extended temporaries. When constructing a temporary that is going to be lifetime-extended through a MaterializeTemporaryExpr later, CFG elements for the respective constructor can now be queried to obtain the reference to that MaterializeTemporaryExpr and therefore gain information about lifetime extension. This may produce multi-layered construction contexts when information about both temporary destruction and lifetime extension is available. Differential Revision: https://reviews.llvm.org/D43477 llvm-svn: 326014
2018-02-24 10:00:30 +08:00
// ANALYZER-CXX98: 1: A() (CXXConstructExpr, [B12.2], [B12.3], class A)
// ANALYZER-CXX11: 1: A() (CXXConstructExpr, [B12.2], class A)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 2: [B12.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B12.2]
// CHECK: 4: [B12.3].operator bool
// CHECK: 5: [B12.3]
// CHECK: 6: [B12.5] (ImplicitCastExpr, UserDefinedConversion, _Bool)
// CHECK: T: [B12.6] ? ... : ...
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (1): B13
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer." This reverts commit r214962 because after the change the following code doesn't compile with -Wreturn-type -Werror. #include <cstdlib> class NoReturn { public: ~NoReturn() __attribute__((noreturn)) { exit(1); } }; int check() { true ? NoReturn() : NoReturn(); } llvm-svn: 214998
2014-08-07 06:01:54 +08:00
// CHECK: Succs (2): B10 B11
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
[CFG] [analyzer] Add construction contexts that explain pre-C++17 copy elision. Before C++17 copy elision was optional, even if the elidable copy/move constructor had arbitrary side effects. The elidable constructor is present in the AST, but marked as elidable. In these cases CFG now contains additional information that allows its clients to figure out if a temporary object is only being constructed so that to pass it to an elidable constructor. If so, it includes a reference to the elidable constructor's construction context, so that the client could elide the elidable constructor and construct the object directly at its final destination. Differential Revision: https://reviews.llvm.org/D47616 llvm-svn: 335795
2018-06-28 08:04:54 +08:00
// ANALYZER: 1: A() (CXXConstructExpr, [B1.2], [B1.4], [B1.5], class A)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 2: [B1.1] (BindTemporary)
// CHECK: 3: [B1.2] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 4: [B1.3]
[CFG] Provide construction contexts when constructors have cleanups. Now that we make it possible to query the CFG constructor element to find information about the construction site, possible cleanup work represented by ExprWithCleanups should not prevent us from providing this information. This allows us to have a correct construction context for variables initialized "by value" via elidable copy-constructors, such as 'i' in iterator i = vector.begin(); Differential Revision: https://reviews.llvm.org/D42719 llvm-svn: 324798
2018-02-10 10:46:14 +08:00
// WARNINGS: 5: [B1.4] (CXXConstructExpr, class A)
// ANALYZER: 5: [B1.4] (CXXConstructExpr, [B1.6], class A)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 6: A a = A();
// CHECK: 7: ~A() (Temporary object destructor)
// CHECK: 8: int b;
// CHECK: 9: [B1.6].~A() (Implicit destructor)
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
[CFG] [analyzer] Simplify lifetime-extended temporary construction contexts. When a temporary object is materialized and through that obtain lifetime that is longer than the duration of the full-expression, it does not require a temporary object destructor; it will be destroyed in a different manner. Therefore it's not necessary to include CXXBindTemporaryExpr into the construction context for such temporary in the CFG only to make clients throw it away. Differential Revision: https://reviews.llvm.org/D47667 llvm-svn: 335798
2018-06-28 08:18:52 +08:00
// ANALYZER: 1: A() (CXXConstructExpr, [B1.4], class A)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 2: [B1.1] (BindTemporary)
// CHECK: 3: [B1.2] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 4: [B1.3]
// CHECK: 5: const A &a = A();
Change subexpressions to be visited in the CFG from left-to-right. This is a more natural order of evaluation, and it is very important for visualization in the static analyzer. Within Xcode, the arrows will not jump from right to left, which looks very visually jarring. It also provides a more natural location for dataflow-based diagnostics. Along the way, we found a case in the analyzer diagnostics where we needed to indicate that a variable was "captured" by a block. -fsyntax-only timings on sqlite3.c show no visible performance change, although this is just one test case. Fixes <rdar://problem/13016513> llvm-svn: 174447
2013-02-06 06:00:19 +08:00
// CHECK: 6: foo
// CHECK: 7: [B1.6] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &))
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 8: A() (CXXConstructExpr, class A)
[CFG] Provide construction contexts for temporaries bound to const references. In order to bind a temporary to a const lvalue reference, a no-op cast is added to make the temporary itself const, and only then the reference is taken (materialized). Skip the no-op cast when looking for the construction context. Differential Revision: https://reviews.llvm.org/D43481 llvm-svn: 326016
2018-02-24 10:07:50 +08:00
// ANALYZER: 8: A() (CXXConstructExpr, [B1.9], [B1.11], class A)
Change subexpressions to be visited in the CFG from left-to-right. This is a more natural order of evaluation, and it is very important for visualization in the static analyzer. Within Xcode, the arrows will not jump from right to left, which looks very visually jarring. It also provides a more natural location for dataflow-based diagnostics. Along the way, we found a case in the analyzer diagnostics where we needed to indicate that a variable was "captured" by a block. -fsyntax-only timings on sqlite3.c show no visible performance change, although this is just one test case. Fixes <rdar://problem/13016513> llvm-svn: 174447
2013-02-06 06:00:19 +08:00
// CHECK: 9: [B1.8] (BindTemporary)
// CHECK: 10: [B1.9] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 11: [B1.10]
// CHECK: 12: [B1.7]([B1.11])
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 13: ~A() (Temporary object destructor)
// CHECK: 14: int b;
// CHECK: 15: [B1.5].~A() (Implicit destructor)
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
// CHECK: 1: A::make
// CHECK: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class A (*)(void))
[CFG] [analyzer] Add construction context to C++ return-by-value call elements. This patch adds a new CFGStmt sub-class, CFGCXXRecordTypedCall, which replaces the regular CFGStmt for the respective CallExpr whenever the CFG has additional information to provide regarding the lifetime of the returned value. This additional call site information is represented by a ConstructionContext (which was previously used for CFGConstructor elements) that provides references to CXXBindTemporaryExpr and MaterializeTemporaryExpr that surround the call. This corresponds to the common C++ calling convention solution of providing the target address for constructing the return value as an auxiliary implicit argument during function call. One of the use cases for such extra context at the call site would be to perform any sort of inter-procedural analysis over the CFG that involves functions returning objects by value. In this case the elidable constructor at the return site would construct the object explained by the context at the call site, and its lifetime would also be managed by the caller, not the callee. The extra context would also be useful for properly handling the return-value temporary at the call site, even if the callee is not being analyzed inter-procedurally. Differential Revision: https://reviews.llvm.org/D44120 llvm-svn: 327343
2018-03-13 07:12:40 +08:00
// WARNINGS: 3: [B1.2]()
[CFG] [analyzer] Add construction contexts that explain pre-C++17 copy elision. Before C++17 copy elision was optional, even if the elidable copy/move constructor had arbitrary side effects. The elidable constructor is present in the AST, but marked as elidable. In these cases CFG now contains additional information that allows its clients to figure out if a temporary object is only being constructed so that to pass it to an elidable constructor. If so, it includes a reference to the elidable constructor's construction context, so that the client could elide the elidable constructor and construct the object directly at its final destination. Differential Revision: https://reviews.llvm.org/D47616 llvm-svn: 335795
2018-06-28 08:04:54 +08:00
// ANALYZER: 3: [B1.2]() (CXXRecordTypedCall, [B1.4], [B1.6], [B1.7])
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 4: [B1.3] (BindTemporary)
// CHECK: 5: [B1.4] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 6: [B1.5]
[CFG] Provide construction contexts when constructors have cleanups. Now that we make it possible to query the CFG constructor element to find information about the construction site, possible cleanup work represented by ExprWithCleanups should not prevent us from providing this information. This allows us to have a correct construction context for variables initialized "by value" via elidable copy-constructors, such as 'i' in iterator i = vector.begin(); Differential Revision: https://reviews.llvm.org/D42719 llvm-svn: 324798
2018-02-10 10:46:14 +08:00
// WARNINGS: 7: [B1.6] (CXXConstructExpr, class A)
// ANALYZER: 7: [B1.6] (CXXConstructExpr, [B1.8], class A)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 8: A a = A::make();
// CHECK: 9: ~A() (Temporary object destructor)
// CHECK: 10: int b;
// CHECK: 11: [B1.8].~A() (Implicit destructor)
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
// CHECK: 1: A::make
// CHECK: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class A (*)(void))
[CFG] [analyzer] Add construction context to C++ return-by-value call elements. This patch adds a new CFGStmt sub-class, CFGCXXRecordTypedCall, which replaces the regular CFGStmt for the respective CallExpr whenever the CFG has additional information to provide regarding the lifetime of the returned value. This additional call site information is represented by a ConstructionContext (which was previously used for CFGConstructor elements) that provides references to CXXBindTemporaryExpr and MaterializeTemporaryExpr that surround the call. This corresponds to the common C++ calling convention solution of providing the target address for constructing the return value as an auxiliary implicit argument during function call. One of the use cases for such extra context at the call site would be to perform any sort of inter-procedural analysis over the CFG that involves functions returning objects by value. In this case the elidable constructor at the return site would construct the object explained by the context at the call site, and its lifetime would also be managed by the caller, not the callee. The extra context would also be useful for properly handling the return-value temporary at the call site, even if the callee is not being analyzed inter-procedurally. Differential Revision: https://reviews.llvm.org/D44120 llvm-svn: 327343
2018-03-13 07:12:40 +08:00
// WARNINGS: 3: [B1.2]()
[CFG] [analyzer] Simplify lifetime-extended temporary construction contexts. When a temporary object is materialized and through that obtain lifetime that is longer than the duration of the full-expression, it does not require a temporary object destructor; it will be destroyed in a different manner. Therefore it's not necessary to include CXXBindTemporaryExpr into the construction context for such temporary in the CFG only to make clients throw it away. Differential Revision: https://reviews.llvm.org/D47667 llvm-svn: 335798
2018-06-28 08:18:52 +08:00
// ANALYZER: 3: [B1.2]() (CXXRecordTypedCall, [B1.6])
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 4: [B1.3] (BindTemporary)
// CHECK: 5: [B1.4] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 6: [B1.5]
// CHECK: 7: const A &a = A::make();
Change subexpressions to be visited in the CFG from left-to-right. This is a more natural order of evaluation, and it is very important for visualization in the static analyzer. Within Xcode, the arrows will not jump from right to left, which looks very visually jarring. It also provides a more natural location for dataflow-based diagnostics. Along the way, we found a case in the analyzer diagnostics where we needed to indicate that a variable was "captured" by a block. -fsyntax-only timings on sqlite3.c show no visible performance change, although this is just one test case. Fixes <rdar://problem/13016513> llvm-svn: 174447
2013-02-06 06:00:19 +08:00
// CHECK: 8: foo
// CHECK: 9: [B1.8] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &))
// CHECK: 10: A::make
// CHECK: 11: [B1.10] (ImplicitCastExpr, FunctionToPointerDecay, class A (*)(void))
[CFG] [analyzer] Add construction context to C++ return-by-value call elements. This patch adds a new CFGStmt sub-class, CFGCXXRecordTypedCall, which replaces the regular CFGStmt for the respective CallExpr whenever the CFG has additional information to provide regarding the lifetime of the returned value. This additional call site information is represented by a ConstructionContext (which was previously used for CFGConstructor elements) that provides references to CXXBindTemporaryExpr and MaterializeTemporaryExpr that surround the call. This corresponds to the common C++ calling convention solution of providing the target address for constructing the return value as an auxiliary implicit argument during function call. One of the use cases for such extra context at the call site would be to perform any sort of inter-procedural analysis over the CFG that involves functions returning objects by value. In this case the elidable constructor at the return site would construct the object explained by the context at the call site, and its lifetime would also be managed by the caller, not the callee. The extra context would also be useful for properly handling the return-value temporary at the call site, even if the callee is not being analyzed inter-procedurally. Differential Revision: https://reviews.llvm.org/D44120 llvm-svn: 327343
2018-03-13 07:12:40 +08:00
// WARNINGS: 12: [B1.11]()
// ANALYZER: 12: [B1.11]() (CXXRecordTypedCall, [B1.13], [B1.15])
Change subexpressions to be visited in the CFG from left-to-right. This is a more natural order of evaluation, and it is very important for visualization in the static analyzer. Within Xcode, the arrows will not jump from right to left, which looks very visually jarring. It also provides a more natural location for dataflow-based diagnostics. Along the way, we found a case in the analyzer diagnostics where we needed to indicate that a variable was "captured" by a block. -fsyntax-only timings on sqlite3.c show no visible performance change, although this is just one test case. Fixes <rdar://problem/13016513> llvm-svn: 174447
2013-02-06 06:00:19 +08:00
// CHECK: 13: [B1.12] (BindTemporary)
// CHECK: 14: [B1.13] (ImplicitCastExpr, NoOp, const class A)
// CHECK: 15: [B1.14]
// CHECK: 16: [B1.9]([B1.15])
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 17: ~A() (Temporary object destructor)
// CHECK: 18: int b;
// CHECK: 19: [B1.7].~A() (Implicit destructor)
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
// CHECK: 1: int a;
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 2: A() (CXXConstructExpr, class A)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 2: A() (CXXConstructExpr, [B1.3], [B1.4], class A)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 3: [B1.2] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 4: [B1.3]
// CHECK: 5: [B1.4].operator int
// CHECK: 6: [B1.4]
// CHECK: 7: [B1.6] (ImplicitCastExpr, UserDefinedConversion, int)
// CHECK: 8: a
// CHECK: 9: [B1.8] = [B1.7]
// CHECK: 10: ~A() (Temporary object destructor)
// CHECK: 11: int b;
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 1: A() (CXXConstructExpr, class A)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// ANALYZER: 1: A() (CXXConstructExpr, [B1.2], [B1.3], class A)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: 2: [B1.1] (BindTemporary)
Add missing temporary materialization conversion on left-hand side of . in some member function calls. Specifically, when calling a conversion function, we would fail to create the AST node representing materialization of the class object. llvm-svn: 338135
2018-07-28 01:13:18 +08:00
// CHECK: 3: [B1.2]
// CHECK: 4: [B1.3].operator int
// CHECK: 5: [B1.3]
// CHECK: 6: [B1.5] (ImplicitCastExpr, UserDefinedConversion, int)
// CHECK: 7: int([B1.6]) (CXXFunctionalCastExpr, NoOp, int)
// WARNINGS: 8: B() (CXXConstructExpr, class B)
// ANALYZER: 8: B() (CXXConstructExpr, [B1.9], [B1.10], class B)
// CHECK: 9: [B1.8] (BindTemporary)
// CHECK: 10: [B1.9]
// CHECK: 11: [B1.10].operator int
// CHECK: 12: [B1.10]
// CHECK: 13: [B1.12] (ImplicitCastExpr, UserDefinedConversion, int)
// CHECK: 14: int([B1.13]) (CXXFunctionalCastExpr, NoOp, int)
// CHECK: 15: [B1.7] + [B1.14]
// CHECK: 16: a([B1.15]) (Member initializer)
// CHECK: 17: ~B() (Temporary object destructor)
// CHECK: 18: ~A() (Temporary object destructor)
[analyzer] Do not cache out on some shared implicit AST nodes Some AST nodes which stands for implicit initialization is shared. The analyzer will do the same evaluation on the same nodes resulting in the same state. The analyzer will "cache out", i.e. it thinks that it visited an already existing node in the exploded graph. This is not true in this case and we lose coverage. Since these nodes do not really require any processing from the analyzer we just omit them from the CFG. Differential Revision: https://reviews.llvm.org/D71371
2019-12-12 03:34:44 +08:00
// CHECK: 19: b(/*implicit*/(int)0) (Member initializer)
Add elidable CXXConstructExpr as block-level expr. It converts an lvalue to a rvalue, which is a useful step during AST evaluation. llvm-svn: 147918
2012-01-11 10:39:07 +08:00
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
[analyzer] Add very limited support for temporary destructors This is an improved version of r186498. It enables ExprEngine to reason about temporary object destructors. However, these destructor calls are never inlined, since this feature is still broken. Still, this is sufficient to properly handle noreturn temporary destructors. Now, the analyzer correctly handles expressions like "a || A()", and executes the destructor of "A" only on the paths where "a" evaluted to false. Temporary destructor processing is still off by default and one has to explicitly request it by setting cfg-temporary-dtors=true. Reviewers: jordan_rose CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1259 llvm-svn: 189746
2013-09-02 17:09:15 +08:00
// CHECK: [B3 (ENTRY)]
// CHECK: Succs (1): B2
// CHECK: [B1]
// CHECK: 1: int b;
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Preds (1): B2(Unreachable)
[analyzer] Add very limited support for temporary destructors This is an improved version of r186498. It enables ExprEngine to reason about temporary object destructors. However, these destructor calls are never inlined, since this feature is still broken. Still, this is sufficient to properly handle noreturn temporary destructors. Now, the analyzer correctly handles expressions like "a || A()", and executes the destructor of "A" only on the paths where "a" evaluted to false. Temporary destructor processing is still off by default and one has to explicitly request it by setting cfg-temporary-dtors=true. Reviewers: jordan_rose CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1259 llvm-svn: 189746
2013-09-02 17:09:15 +08:00
// CHECK: Succs (1): B0
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: [B2 (NORETURN)]
[analyzer] Add very limited support for temporary destructors This is an improved version of r186498. It enables ExprEngine to reason about temporary object destructors. However, these destructor calls are never inlined, since this feature is still broken. Still, this is sufficient to properly handle noreturn temporary destructors. Now, the analyzer correctly handles expressions like "a || A()", and executes the destructor of "A" only on the paths where "a" evaluted to false. Temporary destructor processing is still off by default and one has to explicitly request it by setting cfg-temporary-dtors=true. Reviewers: jordan_rose CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1259 llvm-svn: 189746
2013-09-02 17:09:15 +08:00
// CHECK: 1: int a;
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 2: NoReturn() (CXXConstructExpr, class NoReturn)
[CFG] Provide construction contexts for lifetime-extended temporaries. When constructing a temporary that is going to be lifetime-extended through a MaterializeTemporaryExpr later, CFG elements for the respective constructor can now be queried to obtain the reference to that MaterializeTemporaryExpr and therefore gain information about lifetime extension. This may produce multi-layered construction contexts when information about both temporary destruction and lifetime extension is available. Differential Revision: https://reviews.llvm.org/D43477 llvm-svn: 326014
2018-02-24 10:00:30 +08:00
// ANALYZER-CXX98: 2: NoReturn() (CXXConstructExpr, [B2.3], [B2.4], class NoReturn)
// ANALYZER-CXX11: 2: NoReturn() (CXXConstructExpr, [B2.3], class NoReturn)
[analyzer] Add very limited support for temporary destructors This is an improved version of r186498. It enables ExprEngine to reason about temporary object destructors. However, these destructor calls are never inlined, since this feature is still broken. Still, this is sufficient to properly handle noreturn temporary destructors. Now, the analyzer correctly handles expressions like "a || A()", and executes the destructor of "A" only on the paths where "a" evaluted to false. Temporary destructor processing is still off by default and one has to explicitly request it by setting cfg-temporary-dtors=true. Reviewers: jordan_rose CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1259 llvm-svn: 189746
2013-09-02 17:09:15 +08:00
// CHECK: 3: [B2.2] (BindTemporary)
DR616, and part of P0135R1: member access (or pointer-to-member access) on a temporary produces an xvalue, not a prvalue. Support this by materializing the temporary prior to performing the member access. llvm-svn: 288563
2016-12-03 09:14:32 +08:00
// CHECK: [[MEMBER:[45]]]: [B2.{{[34]}}].f
// CHECK: {{[56]}}: [B2.[[MEMBER]]]()
// CHECK: {{[67]}}: ~NoReturn() (Temporary object destructor)
[analyzer] Add very limited support for temporary destructors This is an improved version of r186498. It enables ExprEngine to reason about temporary object destructors. However, these destructor calls are never inlined, since this feature is still broken. Still, this is sufficient to properly handle noreturn temporary destructors. Now, the analyzer correctly handles expressions like "a || A()", and executes the destructor of "A" only on the paths where "a" evaluted to false. Temporary destructor processing is still off by default and one has to explicitly request it by setting cfg-temporary-dtors=true. Reviewers: jordan_rose CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1259 llvm-svn: 189746
2013-09-02 17:09:15 +08:00
// CHECK: Preds (1): B3
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (2): B1 B2
// CHECK: [B3 (ENTRY)]
// CHECK: Succs (1): B2
// CHECK: [B1]
// CHECK: 1: int b;
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Preds (1): B2(Unreachable)
[analyzer] Add very limited support for temporary destructors This is an improved version of r186498. It enables ExprEngine to reason about temporary object destructors. However, these destructor calls are never inlined, since this feature is still broken. Still, this is sufficient to properly handle noreturn temporary destructors. Now, the analyzer correctly handles expressions like "a || A()", and executes the destructor of "A" only on the paths where "a" evaluted to false. Temporary destructor processing is still off by default and one has to explicitly request it by setting cfg-temporary-dtors=true. Reviewers: jordan_rose CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1259 llvm-svn: 189746
2013-09-02 17:09:15 +08:00
// CHECK: Succs (1): B0
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: [B2 (NORETURN)]
[analyzer] Add very limited support for temporary destructors This is an improved version of r186498. It enables ExprEngine to reason about temporary object destructors. However, these destructor calls are never inlined, since this feature is still broken. Still, this is sufficient to properly handle noreturn temporary destructors. Now, the analyzer correctly handles expressions like "a || A()", and executes the destructor of "A" only on the paths where "a" evaluted to false. Temporary destructor processing is still off by default and one has to explicitly request it by setting cfg-temporary-dtors=true. Reviewers: jordan_rose CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1259 llvm-svn: 189746
2013-09-02 17:09:15 +08:00
// CHECK: 1: int a;
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 2: NoReturn() (CXXConstructExpr, class NoReturn)
// ANALYZER: 2: NoReturn() (CXXConstructExpr, [B2.3], class NoReturn)
[analyzer] Add very limited support for temporary destructors This is an improved version of r186498. It enables ExprEngine to reason about temporary object destructors. However, these destructor calls are never inlined, since this feature is still broken. Still, this is sufficient to properly handle noreturn temporary destructors. Now, the analyzer correctly handles expressions like "a || A()", and executes the destructor of "A" only on the paths where "a" evaluted to false. Temporary destructor processing is still off by default and one has to explicitly request it by setting cfg-temporary-dtors=true. Reviewers: jordan_rose CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1259 llvm-svn: 189746
2013-09-02 17:09:15 +08:00
// CHECK: 3: [B2.2] (BindTemporary)
// CHECK: 4: 47
// CHECK: 5: ... , [B2.4]
// CHECK: 6: ~NoReturn() (Temporary object destructor)
// CHECK: Preds (1): B3
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (2): B1 B2
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: [B9 (ENTRY)]
// CHECK: Succs (1): B8
// CHECK: [B1]
// CHECK: 1: 0
// CHECK: 2: return [B1.1];
// CHECK: Preds (2): B3 B8
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: 1
// CHECK: 2: return [B2.1];
// CHECK: Preds (1): B3
// CHECK: Succs (1): B0
// CHECK: [B3]
// CHECK: T: if [B5.1]
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Preds (2): B4(Unreachable) B5
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: Succs (2): B2 B1
// CHECK: [B4 (NORETURN)]
// CHECK: 1: ~NoReturn() (Temporary object destructor)
// CHECK: Preds (1): B5
// CHECK: Succs (1): B0
// CHECK: [B5]
// CHECK: 1: [B7.3] || [B6.7]
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: T: (Temp Dtor) [B6.4]
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: Preds (2): B6 B7
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Succs (2): B4 B3
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: [B6]
// CHECK: 1: check
// CHECK: 2: [B6.1] (ImplicitCastExpr, FunctionToPointerDecay, _Bool (*)(const class NoReturn &))
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 3: NoReturn() (CXXConstructExpr, class NoReturn)
[CFG] Provide construction contexts for temporaries bound to const references. In order to bind a temporary to a const lvalue reference, a no-op cast is added to make the temporary itself const, and only then the reference is taken (materialized). Skip the no-op cast when looking for the construction context. Differential Revision: https://reviews.llvm.org/D43481 llvm-svn: 326016
2018-02-24 10:07:50 +08:00
// ANALYZER: 3: NoReturn() (CXXConstructExpr, [B6.4], [B6.6], class NoReturn)
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: 4: [B6.3] (BindTemporary)
// CHECK: 5: [B6.4] (ImplicitCastExpr, NoOp, const class NoReturn)
// CHECK: 6: [B6.5]
// CHECK: 7: [B6.2]([B6.6])
// CHECK: Preds (1): B7
// CHECK: Succs (1): B5
// CHECK: [B7]
// CHECK: 1: value
// CHECK: 2: [B7.1] (ImplicitCastExpr, LValueToRValue, _Bool)
// CHECK: 3: ![B7.2]
// CHECK: T: [B7.3] || ...
// CHECK: Preds (1): B8
// CHECK: Succs (2): B5 B6
// CHECK: [B8]
// CHECK: 1: value
// CHECK: 2: [B8.1] (ImplicitCastExpr, LValueToRValue, _Bool)
// CHECK: T: if [B8.2]
// CHECK: Preds (1): B9
// CHECK: Succs (2): B7 B1
// CHECK: [B0 (EXIT)]
// CHECK: Preds (3): B1 B2 B4
// CHECK: [B10 (ENTRY)]
// CHECK: Succs (1): B9
// CHECK: [B1]
// CHECK: 1: 0
// CHECK: 2: return [B1.1];
// CHECK: Preds (2): B3 B9
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: 1
// CHECK: 2: return [B2.1];
// CHECK: Preds (1): B3
// CHECK: Succs (1): B0
// CHECK: [B3]
// CHECK: T: if [B5.1]
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Preds (2): B4(Unreachable) B5
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: Succs (2): B2 B1
// CHECK: [B4 (NORETURN)]
// CHECK: 1: ~NoReturn() (Temporary object destructor)
// CHECK: Preds (1): B5
// CHECK: Succs (1): B0
// CHECK: [B5]
// CHECK: 1: [B8.3] || [B7.3] || [B6.7]
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: T: (Temp Dtor) [B6.4]
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: Preds (3): B6 B7 B8
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Succs (2): B4 B3
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: [B6]
// CHECK: 1: check
// CHECK: 2: [B6.1] (ImplicitCastExpr, FunctionToPointerDecay, _Bool (*)(const class NoReturn &))
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 3: NoReturn() (CXXConstructExpr, class NoReturn)
[CFG] Provide construction contexts for temporaries bound to const references. In order to bind a temporary to a const lvalue reference, a no-op cast is added to make the temporary itself const, and only then the reference is taken (materialized). Skip the no-op cast when looking for the construction context. Differential Revision: https://reviews.llvm.org/D43481 llvm-svn: 326016
2018-02-24 10:07:50 +08:00
// ANALYZER: 3: NoReturn() (CXXConstructExpr, [B6.4], [B6.6], class NoReturn)
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: 4: [B6.3] (BindTemporary)
// CHECK: 5: [B6.4] (ImplicitCastExpr, NoOp, const class NoReturn)
// CHECK: 6: [B6.5]
// CHECK: 7: [B6.2]([B6.6])
// CHECK: Preds (1): B7
// CHECK: Succs (1): B5
// CHECK: [B7]
// CHECK: 1: value
// CHECK: 2: [B7.1] (ImplicitCastExpr, LValueToRValue, _Bool)
// CHECK: 3: ![B7.2]
// CHECK: T: [B8.3] || [B7.3] || ...
// CHECK: Preds (1): B8
// CHECK: Succs (2): B5 B6
// CHECK: [B8]
// CHECK: 1: value
// CHECK: 2: [B8.1] (ImplicitCastExpr, LValueToRValue, _Bool)
// CHECK: 3: ![B8.2]
// CHECK: T: [B8.3] || ...
// CHECK: Preds (1): B9
// CHECK: Succs (2): B5 B7
// CHECK: [B9]
// CHECK: 1: value
// CHECK: 2: [B9.1] (ImplicitCastExpr, LValueToRValue, _Bool)
// CHECK: T: if [B9.2]
// CHECK: Preds (1): B10
// CHECK: Succs (2): B8 B1
// CHECK: [B0 (EXIT)]
// CHECK: Preds (3): B1 B2 B4
// CHECK: [B10 (ENTRY)]
// CHECK: Succs (1): B9
// CHECK: [B1]
// CHECK: 1: 0
// CHECK: 2: return [B1.1];
// CHECK: Preds (2): B3 B9
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: 1
// CHECK: 2: return [B2.1];
// CHECK: Preds (1): B3
// CHECK: Succs (1): B0
// CHECK: [B3]
// CHECK: T: if [B5.1]
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Preds (2): B4(Unreachable) B5
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: Succs (2): B2 B1
// CHECK: [B4 (NORETURN)]
// CHECK: 1: ~NoReturn() (Temporary object destructor)
// CHECK: Preds (1): B5
// CHECK: Succs (1): B0
// CHECK: [B5]
// CHECK: 1: [B8.3] || [B7.2] || [B6.7]
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: T: (Temp Dtor) [B6.4]
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: Preds (3): B6 B7 B8
Re-applying r214962. Changes to the original patch: - model the CFG for temporary destructors in conditional operators so that the destructors of the true and false branch are always exclusive. This is necessary because we must not have impossible paths for the path based analysis to work. - add multiple regression tests with ternary operators Original description: Fix modelling of non-lifetime-extended temporary destructors in the analyzer. Changes to the CFG: When creating the CFG for temporary destructors, we create a structure that mirrors the branch structure of the conditionally executed temporary constructors in a full expression. The branches we create use a CXXBindTemporaryExpr as terminator which corresponds to the temporary constructor which must have been executed to enter the destruction branch. 2. Changes to the Analyzer: When we visit a CXXBindTemporaryExpr we mark the CXXBindTemporaryExpr as executed in the state; when we reach a branch that contains the corresponding CXXBindTemporaryExpr as terminator, we branch out depending on whether the corresponding CXXBindTemporaryExpr was marked as executed. llvm-svn: 215096
2014-08-07 18:42:17 +08:00
// CHECK: Succs (2): B4 B3
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: [B6]
// CHECK: 1: check
// CHECK: 2: [B6.1] (ImplicitCastExpr, FunctionToPointerDecay, _Bool (*)(const class NoReturn &))
[CFG] Provide construction contexts for temproary objects. Constructors of C++ temporary objects that have destructors now can be queried to discover that they're indeed constructing temporary objects. The respective CXXBindTemporaryExpr, which is also repsonsible for destroying the temporary at the end of full-expression, is now available at the construction site in the CFG. This is all the context we need to provide for temporary objects that are not lifetime extended. For lifetime-extended temporaries, more context is necessary. Differential Revision: https://reviews.llvm.org/D43056 llvm-svn: 325210
2018-02-15 11:13:36 +08:00
// WARNINGS: 3: NoReturn() (CXXConstructExpr, class NoReturn)
[CFG] Provide construction contexts for temporaries bound to const references. In order to bind a temporary to a const lvalue reference, a no-op cast is added to make the temporary itself const, and only then the reference is taken (materialized). Skip the no-op cast when looking for the construction context. Differential Revision: https://reviews.llvm.org/D43481 llvm-svn: 326016
2018-02-24 10:07:50 +08:00
// ANALYZER: 3: NoReturn() (CXXConstructExpr, [B6.4], [B6.6], class NoReturn)
[analyzer] Fix a CFG printing bug. Also, add several destructor-related tests. Most of them don't work yet, but it's good to have them recorded. Patch by Alex McCarthy! llvm-svn: 205326
2014-04-02 00:39:33 +08:00
// CHECK: 4: [B6.3] (BindTemporary)
// CHECK: 5: [B6.4] (ImplicitCastExpr, NoOp, const class NoReturn)
// CHECK: 6: [B6.5]
// CHECK: 7: [B6.2]([B6.6])
// CHECK: Preds (1): B7
// CHECK: Succs (1): B5
// CHECK: [B7]
// CHECK: 1: value
// CHECK: 2: [B7.1] (ImplicitCastExpr, LValueToRValue, _Bool)
// CHECK: T: [B8.3] || [B7.2] || ...
// CHECK: Preds (1): B8
// CHECK: Succs (2): B5 B6
// CHECK: [B8]
// CHECK: 1: value
// CHECK: 2: [B8.1] (ImplicitCastExpr, LValueToRValue, _Bool)
// CHECK: 3: ![B8.2]
// CHECK: T: [B8.3] || ...
// CHECK: Preds (1): B9
// CHECK: Succs (2): B5 B7
// CHECK: [B9]
// CHECK: 1: value
// CHECK: 2: [B9.1] (ImplicitCastExpr, LValueToRValue, _Bool)
// CHECK: T: if [B9.2]
// CHECK: Preds (1): B10
// CHECK: Succs (2): B8 B1
// CHECK: [B0 (EXIT)]
// CHECK: Preds (3): B1 B2 B4
[CFG] [analyzer] Don't add construction context to a return-by-reference call. Call expressions that return objects by an lvalue reference or an rvalue reference have a value type in the AST but wear an auxiliary flag of being an lvalue or an xvalue respectively. Use the helper method for obtaining the actual return type of the function. Fixes a crash. Differential Revision: https://reviews.llvm.org/D44273 llvm-svn: 327352
2018-03-13 07:52:36 +08:00
// CHECK: [B1 (ENTRY)]
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
// CHECK: 1: foo1
// CHECK: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, const class pass_references_through::C &(*)(void))
// CHECK: 3: [B1.2]()
// CHECK: 4: return [B1.3];
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
// CHECK: 1: foo2
// CHECK: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class pass_references_through::C &&(*)(void))
// CHECK: 3: [B1.2]()
// CHECK: 4: return [B1.3];
// CHECK: Preds (1): B2
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1