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/auto-obj-dtors-cfg-output.cpp

810 lines
21 KiB
C++
Raw Normal View History

Add -fcxx-exceptions to all tests that use C++ exceptions. llvm-svn: 126599
2011-02-28 08:40:07 +08:00
// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -analyze -analyzer-checker=debug.DumpCFG -cfg-add-implicit-dtors %s 2>&1 | FileCheck %s
Added: - Adding LocalScope for CompoundStmt, - Adding CFGAutomaticObjDtors for end of scope, return, goto, break, continue, - Regression tests for above cases. llvm-svn: 115252
2010-10-01 08:23:17 +08:00
// XPASS: *
class A {
public:
A() {}
~A() {}
operator int() const { return 1; }
};
extern const bool UV;
void test_const_ref() {
A a;
const A& b = a;
const A& c = A();
}
Added generation of destructors for constant size arrays. There's only one destructor call generated for each not empty array (at least for now this should be enough). llvm-svn: 117251
2010-10-25 15:00:40 +08:00
void test_array() {
A a[2];
A b[0];
}
Added: - Adding LocalScope for CompoundStmt, - Adding CFGAutomaticObjDtors for end of scope, return, goto, break, continue, - Regression tests for above cases. llvm-svn: 115252
2010-10-01 08:23:17 +08:00
void test_scope() {
A a;
{ A c;
A d;
}
A b;
}
void test_return() {
A a;
A b;
if (UV) return;
A c;
}
void test_goto() {
A a;
l0:
A b;
{ A a;
if (UV) goto l0;
if (UV) goto l1;
A b;
}
l1:
A c;
}
Added generating CFGAutomaticObjDtors for condition variable and implicit scopes in if statement. llvm-svn: 115256
2010-10-01 08:52:17 +08:00
void test_if_implicit_scope() {
A a;
if (A b = a)
A c;
else A c;
}
void test_if_jumps() {
A a;
if (A b = a) {
A c;
if (UV) return;
A d;
} else {
A c;
if (UV) return;
A d;
}
A e;
}
Added generating CFGAutomaticObjDtors for condition variable and implicit scopes in while and do statements. llvm-svn: 115262
2010-10-01 09:14:17 +08:00
void test_while_implicit_scope() {
A a;
while (A b = a)
A c;
}
void test_while_jumps() {
A a;
while (A b = a) {
A c;
if (UV) break;
if (UV) continue;
if (UV) return;
A d;
}
A e;
}
void test_do_implicit_scope() {
do A a;
while (UV);
}
void test_do_jumps() {
A a;
do {
A b;
if (UV) break;
if (UV) continue;
if (UV) return;
A c;
} while (UV);
A d;
}
dded generating CFGAutomaticObjDtors for condition variable and implicit scopes in switch statement. llvm-svn: 115264
2010-10-01 09:24:41 +08:00
void test_switch_implicit_scope() {
A a;
switch (A b = a)
A c;
}
void test_switch_jumps() {
A a;
switch (A b = a) {
case 0: {
A c;
if (UV) break;
if (UV) return;
A f;
}
case 1:
break;
}
A g;
}
Added generating CFGAutomaticObjDtors for init statement, condition variable and implicit scope in for statement. llvm-svn: 115265
2010-10-01 09:38:14 +08:00
void test_for_implicit_scope() {
for (A a; A b = a; )
A c;
}
void test_for_jumps() {
A a;
for (A b; A c = b; ) {
A d;
if (UV) break;
if (UV) continue;
if (UV) return;
A e;
}
A f;
}
Added generating CFGAutomaticObjDtors for exception variable in catch statement. llvm-svn: 115266
2010-10-01 09:46:52 +08:00
void test_catch_const_ref() {
try {
} catch (const A& e) {
}
}
void test_catch_copy() {
try {
} catch (A e) {
}
}
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: [ B2 (ENTRY) ]
Added generation of destructors for constant size arrays. There's only one destructor call generated for each not empty array (at least for now this should be enough). llvm-svn: 117251
2010-10-25 15:00:40 +08:00
// CHECK: Predecessors (0):
// CHECK: Successors (1): B1
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: [ B1 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a;
// CHECK: 3: const A &b = a;
// CHECK: 4: A()
// CHECK: 5: const A &c = A();
// CHECK: 6: [B1.5].~A() (Implicit destructor)
// CHECK: 7: [B1.2].~A() (Implicit destructor)
Added generation of destructors for constant size arrays. There's only one destructor call generated for each not empty array (at least for now this should be enough). llvm-svn: 117251
2010-10-25 15:00:40 +08:00
// CHECK: Predecessors (1): B2
// CHECK: Successors (1): B0
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: [ B0 (EXIT) ]
Added generation of destructors for constant size arrays. There's only one destructor call generated for each not empty array (at least for now this should be enough). llvm-svn: 117251
2010-10-25 15:00:40 +08:00
// CHECK: Predecessors (1): B1
// CHECK: Successors (0):
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: [ B2 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B1
// CHECK: [ B1 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a[2];
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 3:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 4: A b[0];
// CHECK: 5: [B1.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B2
// CHECK: Successors (1): B0
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (1): B1
// CHECK: Successors (0):
// CHECK: [ B2 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B1
// CHECK: [ B1 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a;
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 3:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 4: A c;
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 5:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 6: A d;
// CHECK: 7: [B1.6].~A() (Implicit destructor)
// CHECK: 8: [B1.4].~A() (Implicit destructor)
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 9:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 10: A b;
// CHECK: 11: [B1.10].~A() (Implicit destructor)
// CHECK: 12: [B1.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B2
// CHECK: Successors (1): B0
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (1): B1
// CHECK: Successors (0):
// CHECK: [ B4 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B3
// CHECK: [ B1 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A c;
// CHECK: 3: [B1.2].~A() (Implicit destructor)
// CHECK: 4: [B3.4].~A() (Implicit destructor)
// CHECK: 5: [B3.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B3
// CHECK: Successors (1): B0
// CHECK: [ B2 ]
// CHECK: 1: return;
// CHECK: 2: [B3.4].~A() (Implicit destructor)
// CHECK: 3: [B3.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B3
// CHECK: Successors (1): B0
// CHECK: [ B3 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a;
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 3:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 4: A b;
// CHECK: 5: UV
// CHECK: T: if [B3.5]
// CHECK: Predecessors (1): B4
// CHECK: Successors (2): B2 B1
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (2): B1 B2
// CHECK: Successors (0):
// CHECK: [ B8 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B7
// CHECK: [ B1 ]
// CHECK: l1:
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A c;
// CHECK: 3: [B1.2].~A() (Implicit destructor)
// CHECK: 4: [B6.2].~A() (Implicit destructor)
// CHECK: 5: [B7.2].~A() (Implicit destructor)
// CHECK: Predecessors (2): B2 B3
// CHECK: Successors (1): B0
// CHECK: [ B2 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A b;
// CHECK: 3: [B2.2].~A() (Implicit destructor)
// CHECK: 4: [B6.4].~A() (Implicit destructor)
// CHECK: Predecessors (1): B4
// CHECK: Successors (1): B1
// CHECK: [ B3 ]
// CHECK: 1: [B6.4].~A() (Implicit destructor)
// CHECK: T: goto l1;
// CHECK: Predecessors (1): B4
// CHECK: Successors (1): B1
// CHECK: [ B4 ]
// CHECK: 1: UV
// CHECK: T: if [B4.1]
// CHECK: Predecessors (1): B6
// CHECK: Successors (2): B3 B2
// CHECK: [ B5 ]
// CHECK: 1: [B6.4].~A() (Implicit destructor)
// CHECK: 2: [B6.2].~A() (Implicit destructor)
// CHECK: T: goto l0;
// CHECK: Predecessors (1): B6
// CHECK: Successors (1): B6
// CHECK: [ B6 ]
// CHECK: l0:
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A b;
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 3:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 4: A a;
// CHECK: 5: UV
// CHECK: T: if [B6.5]
// CHECK: Predecessors (2): B7 B5
// CHECK: Successors (2): B5 B4
// CHECK: [ B7 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a;
// CHECK: Predecessors (1): B8
// CHECK: Successors (1): B6
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (1): B1
// CHECK: Successors (0):
// CHECK: [ B5 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B4
// CHECK: [ B1 ]
// CHECK: 1: [B4.4].~A() (Implicit destructor)
// CHECK: 2: [B4.2].~A() (Implicit destructor)
// CHECK: Predecessors (2): B2 B3
// CHECK: Successors (1): B0
// CHECK: [ B2 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A c;
// CHECK: 3: [B2.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B4
// CHECK: Successors (1): B1
// CHECK: [ B3 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A c;
// CHECK: 3: [B3.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B4
// CHECK: Successors (1): B1
// CHECK: [ B4 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a;
// CHECK: 3: a
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 4: A b = a;
// CHECK: 5: b.operator int()
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 6: [B4.5]
// CHECK: T: if [B4.6]
// CHECK: Predecessors (1): B5
// CHECK: Successors (2): B3 B2
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (1): B1
// CHECK: Successors (0):
// CHECK: [ B9 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B8
// CHECK: [ B1 ]
// CHECK: 1: [B8.4].~A() (Implicit destructor)
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 2:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 3: A e;
// CHECK: 4: [B1.3].~A() (Implicit destructor)
// CHECK: 5: [B8.2].~A() (Implicit destructor)
// CHECK: Predecessors (2): B2 B5
// CHECK: Successors (1): B0
// CHECK: [ B2 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A d;
// CHECK: 3: [B2.2].~A() (Implicit destructor)
// CHECK: 4: [B4.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B4
// CHECK: Successors (1): B1
// CHECK: [ B3 ]
// CHECK: 1: return;
// CHECK: 2: [B4.2].~A() (Implicit destructor)
// CHECK: 3: [B8.4].~A() (Implicit destructor)
// CHECK: 4: [B8.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B4
// CHECK: Successors (1): B0
// CHECK: [ B4 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A c;
// CHECK: 3: UV
// CHECK: T: if [B4.3]
// CHECK: Predecessors (1): B8
// CHECK: Successors (2): B3 B2
// CHECK: [ B5 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A d;
// CHECK: 3: [B5.2].~A() (Implicit destructor)
// CHECK: 4: [B7.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B7
// CHECK: Successors (1): B1
// CHECK: [ B6 ]
// CHECK: 1: return;
// CHECK: 2: [B7.2].~A() (Implicit destructor)
// CHECK: 3: [B8.4].~A() (Implicit destructor)
// CHECK: 4: [B8.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B7
// CHECK: Successors (1): B0
// CHECK: [ B7 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A c;
// CHECK: 3: UV
// CHECK: T: if [B7.3]
// CHECK: Predecessors (1): B8
// CHECK: Successors (2): B6 B5
// CHECK: [ B8 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a;
// CHECK: 3: a
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 4: A b = a;
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 5: b.operator int()
// CHECK: 6: [B8.5]
// CHECK: T: if [B8.6]
// CHECK: Predecessors (1): B9
// CHECK: Successors (2): B7 B4
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (3): B1 B3 B6
// CHECK: Successors (0):
// CHECK: [ B6 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B5
// CHECK: [ B1 ]
// CHECK: 1: [B2.2].~A() (Implicit destructor)
// CHECK: 2: [B5.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B2
// CHECK: Successors (1): B0
// CHECK: [ B2 ]
// CHECK: 1: a
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 2: A b = a;
// CHECK: 3: b.operator int()
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 4: [B2.3]
// CHECK: T: while [B2.4]
// CHECK: Predecessors (2): B3 B5
// CHECK: Successors (2): B4 B1
// CHECK: [ B3 ]
// CHECK: Predecessors (1): B4
// CHECK: Successors (1): B2
// CHECK: [ B4 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A c;
// CHECK: 3: [B4.2].~A() (Implicit destructor)
// CHECK: 4: [B2.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B2
// CHECK: Successors (1): B3
// CHECK: [ B5 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a;
// CHECK: Predecessors (1): B6
// CHECK: Successors (1): B2
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (1): B1
// CHECK: Successors (0):
// CHECK: [ B12 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B11
// CHECK: [ B1 ]
// CHECK: 1: [B2.2].~A() (Implicit destructor)
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 2:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 3: A e;
// CHECK: 4: [B1.3].~A() (Implicit destructor)
// CHECK: 5: [B11.2].~A() (Implicit destructor)
// CHECK: Predecessors (2): B9 B2
// CHECK: Successors (1): B0
// CHECK: [ B2 ]
// CHECK: 1: a
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 2: A b = a;
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 3: b.operator int()
// CHECK: 4: [B2.3]
// CHECK: T: while [B2.4]
// CHECK: Predecessors (2): B3 B11
// CHECK: Successors (2): B10 B1
// CHECK: [ B3 ]
// CHECK: Predecessors (2): B4 B7
// CHECK: Successors (1): B2
// CHECK: [ B4 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A d;
// CHECK: 3: [B4.2].~A() (Implicit destructor)
// CHECK: 4: [B10.2].~A() (Implicit destructor)
// CHECK: 5: [B2.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B6
// CHECK: Successors (1): B3
// CHECK: [ B5 ]
// CHECK: 1: return;
// CHECK: 2: [B10.2].~A() (Implicit destructor)
// CHECK: 3: [B2.2].~A() (Implicit destructor)
// CHECK: 4: [B11.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B6
// CHECK: Successors (1): B0
// CHECK: [ B6 ]
// CHECK: 1: UV
// CHECK: T: if [B6.1]
// CHECK: Predecessors (1): B8
// CHECK: Successors (2): B5 B4
// CHECK: [ B7 ]
// CHECK: 1: [B10.2].~A() (Implicit destructor)
// CHECK: 2: [B2.2].~A() (Implicit destructor)
// CHECK: T: continue;
// CHECK: Predecessors (1): B8
// CHECK: Successors (1): B3
// CHECK: [ B8 ]
// CHECK: 1: UV
// CHECK: T: if [B8.1]
// CHECK: Predecessors (1): B10
// CHECK: Successors (2): B7 B6
// CHECK: [ B9 ]
// CHECK: 1: [B10.2].~A() (Implicit destructor)
// CHECK: T: break;
// CHECK: Predecessors (1): B10
// CHECK: Successors (1): B1
// CHECK: [ B10 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A c;
// CHECK: 3: UV
// CHECK: T: if [B10.3]
// CHECK: Predecessors (1): B2
// CHECK: Successors (2): B9 B8
// CHECK: [ B11 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a;
// CHECK: Predecessors (1): B12
// CHECK: Successors (1): B2
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (2): B1 B5
// CHECK: Successors (0):
// CHECK: [ B4 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B2
// CHECK: [ B1 ]
// CHECK: 1: UV
// CHECK: T: do ... while [B1.1]
// CHECK: Predecessors (1): B2
// CHECK: Successors (2): B3 B0
// CHECK: [ B2 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a;
// CHECK: 3: [B2.2].~A() (Implicit destructor)
// CHECK: Predecessors (2): B3 B4
// CHECK: Successors (1): B1
// CHECK: [ B3 ]
// CHECK: Predecessors (1): B1
// CHECK: Successors (1): B2
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (1): B1
// CHECK: Successors (0):
// CHECK: [ B12 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B11
// CHECK: [ B1 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A d;
// CHECK: 3: [B1.2].~A() (Implicit destructor)
// CHECK: 4: [B11.2].~A() (Implicit destructor)
// CHECK: Predecessors (2): B8 B2
// CHECK: Successors (1): B0
// CHECK: [ B2 ]
// CHECK: 1: UV
// CHECK: T: do ... while [B2.1]
// CHECK: Predecessors (2): B3 B6
// CHECK: Successors (2): B10 B1
// CHECK: [ B3 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A c;
// CHECK: 3: [B3.2].~A() (Implicit destructor)
// CHECK: 4: [B9.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B5
// CHECK: Successors (1): B2
// CHECK: [ B4 ]
// CHECK: 1: return;
// CHECK: 2: [B9.2].~A() (Implicit destructor)
// CHECK: 3: [B11.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B5
// CHECK: Successors (1): B0
// CHECK: [ B5 ]
// CHECK: 1: UV
// CHECK: T: if [B5.1]
// CHECK: Predecessors (1): B7
// CHECK: Successors (2): B4 B3
// CHECK: [ B6 ]
// CHECK: 1: [B9.2].~A() (Implicit destructor)
// CHECK: T: continue;
// CHECK: Predecessors (1): B7
// CHECK: Successors (1): B2
// CHECK: [ B7 ]
// CHECK: 1: UV
// CHECK: T: if [B7.1]
// CHECK: Predecessors (1): B9
// CHECK: Successors (2): B6 B5
// CHECK: [ B8 ]
// CHECK: 1: [B9.2].~A() (Implicit destructor)
// CHECK: T: break;
// CHECK: Predecessors (1): B9
// CHECK: Successors (1): B1
// CHECK: [ B9 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A b;
// CHECK: 3: UV
// CHECK: T: if [B9.3]
// CHECK: Predecessors (2): B10 B11
// CHECK: Successors (2): B8 B7
// CHECK: [ B10 ]
// CHECK: Predecessors (1): B2
// CHECK: Successors (1): B9
// CHECK: [ B11 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a;
// CHECK: Predecessors (1): B12
// CHECK: Successors (1): B9
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (2): B1 B4
// CHECK: Successors (0):
// CHECK: [ B4 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B2
// CHECK: [ B1 ]
// CHECK: 1: [B2.4].~A() (Implicit destructor)
// CHECK: 2: [B2.2].~A() (Implicit destructor)
// CHECK: Predecessors (2): B3 B2
// CHECK: Successors (1): B0
// CHECK: [ B2 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a;
// CHECK: 3: a
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 4: A b = a;
// CHECK: 5: b.operator int()
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: T: switch [B2.5]
// CHECK: Predecessors (1): B4
// CHECK: Successors (1): B1
// CHECK: [ B3 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A c;
// CHECK: 3: [B3.2].~A() (Implicit destructor)
// CHECK: Predecessors (0):
// CHECK: Successors (1): B1
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (1): B1
// CHECK: Successors (0):
// CHECK: [ B9 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B2
// CHECK: [ B1 ]
// CHECK: 1: [B2.4].~A() (Implicit destructor)
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 2:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 3: A g;
// CHECK: 4: [B1.3].~A() (Implicit destructor)
// CHECK: 5: [B2.2].~A() (Implicit destructor)
// CHECK: Predecessors (3): B3 B7 B2
// CHECK: Successors (1): B0
// CHECK: [ B2 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a;
// CHECK: 3: a
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 4: A b = a;
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 5: b.operator int()
// CHECK: T: switch [B2.5]
// CHECK: Predecessors (1): B9
// CHECK: Successors (3): B3 B8
// CHECK: B1
// CHECK: [ B3 ]
// CHECK: case 1:
// CHECK: T: break;
// CHECK: Predecessors (2): B2 B4
// CHECK: Successors (1): B1
// CHECK: [ B4 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A f;
// CHECK: 3: [B4.2].~A() (Implicit destructor)
// CHECK: 4: [B8.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B6
// CHECK: Successors (1): B3
// CHECK: [ B5 ]
// CHECK: 1: return;
// CHECK: 2: [B8.2].~A() (Implicit destructor)
// CHECK: 3: [B2.4].~A() (Implicit destructor)
// CHECK: 4: [B2.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B6
// CHECK: Successors (1): B0
// CHECK: [ B6 ]
// CHECK: 1: UV
// CHECK: T: if [B6.1]
// CHECK: Predecessors (1): B8
// CHECK: Successors (2): B5 B4
// CHECK: [ B7 ]
// CHECK: 1: [B8.2].~A() (Implicit destructor)
// CHECK: T: break;
// CHECK: Predecessors (1): B8
// CHECK: Successors (1): B1
// CHECK: [ B8 ]
// CHECK: case 0:
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A c;
// CHECK: 3: UV
// CHECK: T: if [B8.3]
// CHECK: Predecessors (1): B2
// CHECK: Successors (2): B7 B6
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (2): B1 B5
// CHECK: Successors (0):
// CHECK: [ B6 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B5
// CHECK: [ B1 ]
// CHECK: 1: [B2.2].~A() (Implicit destructor)
// CHECK: 2: [B5.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B2
// CHECK: Successors (1): B0
// CHECK: [ B2 ]
// CHECK: 1: a
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 2: A b = a;
// CHECK: 3: b.operator int()
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 4: [B2.3]
// CHECK: T: for (...; [B2.4]; )
// CHECK: Predecessors (2): B3 B5
// CHECK: Successors (2): B4 B1
// CHECK: [ B3 ]
// CHECK: 1: [B2.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B4
// CHECK: Successors (1): B2
// CHECK: [ B4 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A c;
// CHECK: 3: [B4.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B2
// CHECK: Successors (1): B3
// CHECK: [ B5 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a;
// CHECK: Predecessors (1): B6
// CHECK: Successors (1): B2
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (1): B1
// CHECK: Successors (0):
// CHECK: [ B12 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B11
// CHECK: [ B1 ]
// CHECK: 1: [B2.2].~A() (Implicit destructor)
// CHECK: 2: [B11.4].~A() (Implicit destructor)
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 3:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 4: A f;
// CHECK: 5: [B1.4].~A() (Implicit destructor)
// CHECK: 6: [B11.2].~A() (Implicit destructor)
// CHECK: Predecessors (2): B9 B2
// CHECK: Successors (1): B0
// CHECK: [ B2 ]
// CHECK: 1: b
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 2: A c = b;
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 3: c.operator int()
// CHECK: 4: [B2.3]
// CHECK: T: for (...; [B2.4]; )
// CHECK: Predecessors (2): B3 B11
// CHECK: Successors (2): B10 B1
// CHECK: [ B3 ]
// CHECK: 1: [B2.2].~A() (Implicit destructor)
// CHECK: Predecessors (2): B4 B7
// CHECK: Successors (1): B2
// CHECK: [ B4 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A e;
// CHECK: 3: [B4.2].~A() (Implicit destructor)
// CHECK: 4: [B10.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B6
// CHECK: Successors (1): B3
// CHECK: [ B5 ]
// CHECK: 1: return;
// CHECK: 2: [B10.2].~A() (Implicit destructor)
// CHECK: 3: [B2.2].~A() (Implicit destructor)
// CHECK: 4: [B11.4].~A() (Implicit destructor)
// CHECK: 5: [B11.2].~A() (Implicit destructor)
// CHECK: Predecessors (1): B6
// CHECK: Successors (1): B0
// CHECK: [ B6 ]
// CHECK: 1: UV
// CHECK: T: if [B6.1]
// CHECK: Predecessors (1): B8
// CHECK: Successors (2): B5 B4
// CHECK: [ B7 ]
// CHECK: 1: [B10.2].~A() (Implicit destructor)
// CHECK: T: continue;
// CHECK: Predecessors (1): B8
// CHECK: Successors (1): B3
// CHECK: [ B8 ]
// CHECK: 1: UV
// CHECK: T: if [B8.1]
// CHECK: Predecessors (1): B10
// CHECK: Successors (2): B7 B6
// CHECK: [ B9 ]
// CHECK: 1: [B10.2].~A() (Implicit destructor)
// CHECK: T: break;
// CHECK: Predecessors (1): B10
// CHECK: Successors (1): B1
// CHECK: [ B10 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A d;
// CHECK: 3: UV
// CHECK: T: if [B10.3]
// CHECK: Predecessors (1): B2
// CHECK: Successors (2): B9 B8
// CHECK: [ B11 ]
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 1:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 2: A a;
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00
// CHECK: 3:
Make all CXXConstructExpr's block-level expressions. This is required by method inlining. Temporarily fail a test case. llvm-svn: 117907
2010-11-01 14:46:05 +08:00
// CHECK: 4: A b;
// CHECK: Predecessors (1): B12
// CHECK: Successors (1): B2
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (2): B1 B5
// CHECK: Successors (0):
// CHECK: [ B3 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B0
// CHECK: [ B1 ]
// CHECK: T: try ...
// CHECK: Predecessors (0):
// CHECK: Successors (2): B2 B0
// CHECK: [ B2 ]
// CHECK: catch (const A &e):
// CHECK: Predecessors (1): B1
// CHECK: Successors (1): B0
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (3): B2 B1 B3
// CHECK: Successors (0):
// CHECK: [ B3 (ENTRY) ]
// CHECK: Predecessors (0):
// CHECK: Successors (1): B0
// CHECK: [ B1 ]
// CHECK: T: try ...
// CHECK: Predecessors (0):
// CHECK: Successors (2): B2 B0
// CHECK: [ B2 ]
// CHECK: catch (A e):
// CHECK: 1: .~A() (Implicit destructor)
// CHECK: Predecessors (1): B1
// CHECK: Successors (1): B0
// CHECK: [ B0 (EXIT) ]
// CHECK: Predecessors (3): B2 B1 B3
// CHECK: Successors (0):
Fix PR 9626 (duplicated self-init warnings under -Wuninitialized) with numerous CFG and UninitializedValues analysis changes: 1) Change the CFG to include the DeclStmt for conditional variables, instead of using the condition itself as a faux DeclStmt. 2) Update ExprEngine (the static analyzer) to understand (1), so not to regress. 3) Update UninitializedValues.cpp to initialize all tracked variables to Uninitialized at the start of the function/method. 4) Only use the SelfReferenceChecker (SemaDecl.cpp) on global variables, leaving the dataflow analysis to handle other cases. The combination of (1) and (3) allows the dataflow-based -Wuninitialized to find self-init problems when the initializer contained control-flow. llvm-svn: 128858
2011-04-05 07:29:12 +08:00