diff options
Diffstat (limited to 'test/Analysis')
211 files changed, 17274 insertions, 4111 deletions
diff --git a/test/Analysis/Checkers/RunLoopAutoreleaseLeakChecker.m b/test/Analysis/Checkers/RunLoopAutoreleaseLeakChecker.m new file mode 100644 index 000000000000..4dde40e210a0 --- /dev/null +++ b/test/Analysis/Checkers/RunLoopAutoreleaseLeakChecker.m @@ -0,0 +1,104 @@ +// UNSUPPORTED: system-windows +// RUN: %clang_analyze_cc1 -fobjc-arc -analyzer-checker=core,osx.cocoa.RunLoopAutoreleaseLeak %s -triple x86_64-darwin -verify +// RUN: %clang_analyze_cc1 -DEXTRA=1 -DAP1=1 -fobjc-arc -analyzer-checker=core,osx.cocoa.RunLoopAutoreleaseLeak %s -triple x86_64-darwin -verify +// RUN: %clang_analyze_cc1 -DEXTRA=1 -DAP2=1 -fobjc-arc -analyzer-checker=core,osx.cocoa.RunLoopAutoreleaseLeak %s -triple x86_64-darwin -verify +// RUN: %clang_analyze_cc1 -DEXTRA=1 -DAP3=1 -fobjc-arc -analyzer-checker=core,osx.cocoa.RunLoopAutoreleaseLeak %s -triple x86_64-darwin -verify +// RUN: %clang_analyze_cc1 -DEXTRA=1 -DAP4=1 -fobjc-arc -analyzer-checker=core,osx.cocoa.RunLoopAutoreleaseLeak %s -triple x86_64-darwin -verify + +#include "../Inputs/system-header-simulator-for-objc-dealloc.h" + +#ifndef EXTRA + +void just_runloop() { // No warning: no statements in between + @autoreleasepool { + [[NSRunLoop mainRunLoop] run]; // no-warning + } +} + +void just_xpcmain() { // No warning: no statements in between + @autoreleasepool { + xpc_main(); // no-warning + } +} + +void runloop_init_before() { // Warning: object created before the loop. + @autoreleasepool { + NSObject *object = [[NSObject alloc] init]; // expected-warning{{Temporary objects allocated in the autorelease pool followed by the launch of main run loop may never get released; consider moving them to a separate autorelease pool}} + (void) object; + [[NSRunLoop mainRunLoop] run]; + } +} + +void xpcmain_init_before() { // Warning: object created before the loop. + @autoreleasepool { + NSObject *object = [[NSObject alloc] init]; // expected-warning{{Temporary objects allocated in the autorelease pool followed by the launch of xpc_main may never get released; consider moving them to a separate autorelease pool}} + (void) object; + xpc_main(); + } +} + +void runloop_init_before_two_objects() { // Warning: object created before the loop. + @autoreleasepool { + NSObject *object = [[NSObject alloc] init]; // expected-warning{{Temporary objects allocated in the autorelease pool followed by the launch of main run loop may never get released; consider moving them to a separate autorelease pool}} + NSObject *object2 = [[NSObject alloc] init]; // no-warning, warning on the first one is enough. + (void) object; + (void) object2; + [[NSRunLoop mainRunLoop] run]; + } +} + +void runloop_no_autoreleasepool() { + NSObject *object = [[NSObject alloc] init]; // no-warning + (void)object; + [[NSRunLoop mainRunLoop] run]; +} + +void runloop_init_after() { // No warning: objects created after the loop + @autoreleasepool { + [[NSRunLoop mainRunLoop] run]; + NSObject *object = [[NSObject alloc] init]; // no-warning + (void) object; + } +} + +#endif + +#ifdef AP1 +int main() { + NSObject *object = [[NSObject alloc] init]; // expected-warning{{Temporary objects allocated in the autorelease pool of last resort followed by the launch of main run loop may never get released; consider moving them to a separate autorelease pool}} + (void) object; + [[NSRunLoop mainRunLoop] run]; + return 0; +} +#endif + +#ifdef AP2 +// expected-no-diagnostics +int main() { + NSObject *object = [[NSObject alloc] init]; // no-warning + (void) object; + @autoreleasepool { + [[NSRunLoop mainRunLoop] run]; + } + return 0; +} +#endif + +#ifdef AP3 +// expected-no-diagnostics +int main() { + [[NSRunLoop mainRunLoop] run]; + NSObject *object = [[NSObject alloc] init]; // no-warning + (void) object; + return 0; +} +#endif + +#ifdef AP4 +int main() { + NSObject *object = [[NSObject alloc] init]; // expected-warning{{Temporary objects allocated in the autorelease pool of last resort followed by the launch of xpc_main may never get released; consider moving them to a separate autorelease pool}} + (void) object; + xpc_main(); + return 0; +} +#endif diff --git a/test/Analysis/Inputs/ctu-chain.cpp b/test/Analysis/Inputs/ctu-chain.cpp new file mode 100644 index 000000000000..2314dde1df0d --- /dev/null +++ b/test/Analysis/Inputs/ctu-chain.cpp @@ -0,0 +1,20 @@ +int h_chain(int x) { + return x * 2; +} + +namespace chns { +int chf3(int x); + +int chf2(int x) { + return chf3(x); +} + +class chcls { +public: + int chf4(int x); +}; + +int chcls::chf4(int x) { + return x * 3; +} +} diff --git a/test/Analysis/Inputs/ctu-other.cpp b/test/Analysis/Inputs/ctu-other.cpp new file mode 100644 index 000000000000..8cad861578b4 --- /dev/null +++ b/test/Analysis/Inputs/ctu-other.cpp @@ -0,0 +1,77 @@ +#include "../ctu-hdr.h" + +int callback_to_main(int x); +int f(int x) { + return x - 1; +} + +int g(int x) { + return callback_to_main(x) + 1; +} + +int h_chain(int); + +int h(int x) { + return 2 * h_chain(x); +} + +namespace myns { +int fns(int x) { + return x + 7; +} + +namespace embed_ns { +int fens(int x) { + return x - 3; +} +} + +class embed_cls { +public: + int fecl(int x) { + return x - 7; + } +}; +} + +class mycls { +public: + int fcl(int x) { + return x + 5; + } + static int fscl(int x) { + return x + 6; + } + + class embed_cls2 { + public: + int fecl2(int x) { + return x - 11; + } + }; +}; + +namespace chns { +int chf2(int x); + +class chcls { +public: + int chf4(int x); +}; + +int chf3(int x) { + return chcls().chf4(x); +} + +int chf1(int x) { + return chf2(x); +} +} + +typedef struct { int n; } Anonymous; +int fun_using_anon_struct(int n) { Anonymous anon; anon.n = n; return anon.n; } + +int other_macro_diag(int x) { + MACRODIAG(); + return x; +} diff --git a/test/Analysis/Inputs/externalFnMap.txt b/test/Analysis/Inputs/externalFnMap.txt new file mode 100644 index 000000000000..5461685dc62b --- /dev/null +++ b/test/Analysis/Inputs/externalFnMap.txt @@ -0,0 +1,15 @@ +c:@N@chns@F@chf1#I# ctu-other.cpp.ast +c:@N@myns@N@embed_ns@F@fens#I# ctu-other.cpp.ast +c:@F@g#I# ctu-other.cpp.ast +c:@S@mycls@F@fscl#I#S ctu-other.cpp.ast +c:@S@mycls@F@fcl#I# ctu-other.cpp.ast +c:@N@myns@S@embed_cls@F@fecl#I# ctu-other.cpp.ast +c:@S@mycls@S@embed_cls2@F@fecl2#I# ctu-other.cpp.ast +c:@F@f#I# ctu-other.cpp.ast +c:@N@myns@F@fns#I# ctu-other.cpp.ast +c:@F@h#I# ctu-other.cpp.ast +c:@F@h_chain#I# ctu-chain.cpp.ast +c:@N@chns@S@chcls@F@chf4#I# ctu-chain.cpp.ast +c:@N@chns@F@chf2#I# ctu-chain.cpp.ast +c:@F@fun_using_anon_struct#I# ctu-other.cpp.ast +c:@F@other_macro_diag#I# ctu-other.cpp.ast diff --git a/test/Analysis/Inputs/system-header-simulator-cxx.h b/test/Analysis/Inputs/system-header-simulator-cxx.h index 809b768d71e0..5d7e553ed5f4 100644 --- a/test/Analysis/Inputs/system-header-simulator-cxx.h +++ b/test/Analysis/Inputs/system-header-simulator-cxx.h @@ -252,6 +252,12 @@ namespace std { return size_t(_finish - _start); } + void clear(); + + void push_back(const T &value); + void push_back(T &&value); + void pop_back(); + T &operator[](size_t n) { return _start[n]; } @@ -295,6 +301,8 @@ namespace std { list& operator=(list &&other); list& operator=(std::initializer_list<T> ilist); + void clear(); + iterator begin() { return iterator(_start); } const_iterator begin() const { return const_iterator(_start); } const_iterator cbegin() const { return const_iterator(_start); } @@ -330,6 +338,16 @@ namespace std { return size_t(_finish - _start); } + void clear(); + + void push_back(const T &value); + void push_back(T &&value); + void pop_back(); + + void push_front(const T &value); + void push_front(T &&value); + void pop_front(); + T &operator[](size_t n) { return _start[n]; } @@ -369,6 +387,12 @@ namespace std { forward_list(forward_list &&other); ~forward_list(); + void clear(); + + void push_front(const T &value); + void push_front(T &&value); + void pop_front(); + iterator begin() { return iterator(_start); } const_iterator begin() const { return const_iterator(_start); } const_iterator cbegin() const { return const_iterator(_start); } @@ -584,10 +608,21 @@ namespace std { } +#ifdef TEST_INLINABLE_ALLOCATORS +namespace std { + void *malloc(size_t); + void free(void *); +} +void* operator new(std::size_t size, const std::nothrow_t&) throw() { return std::malloc(size); } +void* operator new[](std::size_t size, const std::nothrow_t&) throw() { return std::malloc(size); } +void operator delete(void* ptr, const std::nothrow_t&) throw() { std::free(ptr); } +void operator delete[](void* ptr, const std::nothrow_t&) throw() { std::free(ptr); } +#else void* operator new(std::size_t, const std::nothrow_t&) throw(); void* operator new[](std::size_t, const std::nothrow_t&) throw(); void operator delete(void*, const std::nothrow_t&) throw(); void operator delete[](void*, const std::nothrow_t&) throw(); +#endif void* operator new (std::size_t size, void* ptr) throw() { return ptr; }; void* operator new[] (std::size_t size, void* ptr) throw() { return ptr; }; diff --git a/test/Analysis/Inputs/system-header-simulator-for-cxx-uninitialized-object.h b/test/Analysis/Inputs/system-header-simulator-for-cxx-uninitialized-object.h new file mode 100644 index 000000000000..2397824fc965 --- /dev/null +++ b/test/Analysis/Inputs/system-header-simulator-for-cxx-uninitialized-object.h @@ -0,0 +1,18 @@ +// Like the compiler, the static analyzer treats some functions differently if +// they come from a system header -- for example, it is assumed that system +// functions do not arbitrarily free() their parameters, and that some bugs +// found in system headers cannot be fixed by the user and should be +// suppressed. + +#pragma clang system_header + +struct RecordInSystemHeader { + int a; + int b; +}; + +template <class T> +struct ContainerInSystemHeader { + T &t; + ContainerInSystemHeader(T& t) : t(t) {} +}; diff --git a/test/Analysis/Inputs/system-header-simulator-for-nullability-cxx.h b/test/Analysis/Inputs/system-header-simulator-for-nullability-cxx.h new file mode 100644 index 000000000000..fe620c9ff197 --- /dev/null +++ b/test/Analysis/Inputs/system-header-simulator-for-nullability-cxx.h @@ -0,0 +1,9 @@ +#pragma clang system_header + +struct S { + ~S(){} +}; + +void foo() { + S s; +} diff --git a/test/Analysis/Inputs/system-header-simulator-for-nullability.h b/test/Analysis/Inputs/system-header-simulator-for-nullability.h index 8d49f323bc1d..751057dd450e 100644 --- a/test/Analysis/Inputs/system-header-simulator-for-nullability.h +++ b/test/Analysis/Inputs/system-header-simulator-for-nullability.h @@ -32,6 +32,10 @@ NSObject<NSObject> @interface NSString : NSObject<NSCopying> - (BOOL)isEqualToString : (NSString *)aString; - (NSString *)stringByAppendingString:(NSString *)aString; +- (nullable NSString *)nullableStringByAppendingString:(NSString *)aString; ++ (NSString * _Nonnull) generateString; ++ (NSString *) generateImplicitlyNonnullString; ++ (NSString * _Nullable) generatePossiblyNullString; @end void NSSystemFunctionTakingNonnull(NSString *s); @@ -40,4 +44,11 @@ void NSSystemFunctionTakingNonnull(NSString *s); - (void) takesNonnull:(NSString *)s; @end +NSString* _Nullable getPossiblyNullString(); +NSString* _Nonnull getString(); + +@protocol MyProtocol +- (NSString * _Nonnull) getString; +@end + NS_ASSUME_NONNULL_END diff --git a/test/Analysis/Inputs/system-header-simulator-for-objc-dealloc.h b/test/Analysis/Inputs/system-header-simulator-for-objc-dealloc.h index 231c0bf5640e..f1343e30a754 100644 --- a/test/Analysis/Inputs/system-header-simulator-for-objc-dealloc.h +++ b/test/Analysis/Inputs/system-header-simulator-for-objc-dealloc.h @@ -18,6 +18,8 @@ typedef signed char BOOL; @interface NSRunLoop : NSObject + (NSRunLoop *)currentRunLoop; ++ (NSRunLoop *)mainRunLoop; +- (void) run; - (void)cancelPerformSelectorsWithTarget:(id)target; @end @@ -33,3 +35,5 @@ void _Block_release(const void *aBlock); @interface CIFilter : NSObject @end + +extern void xpc_main(void); diff --git a/test/Analysis/Inputs/system-header-simulator.h b/test/Analysis/Inputs/system-header-simulator.h index 2e6f1e7d4a96..8542387d4277 100644 --- a/test/Analysis/Inputs/system-header-simulator.h +++ b/test/Analysis/Inputs/system-header-simulator.h @@ -32,6 +32,7 @@ typedef __typeof(sizeof(int)) size_t; size_t strlen(const char *); char *strcpy(char *restrict, const char *restrict); +char *strncpy(char *dst, const char *src, size_t n); void *memcpy(void *dst, const void *src, size_t n); typedef unsigned long __darwin_pthread_key_t; @@ -109,4 +110,6 @@ void _Exit(int status) __attribute__ ((__noreturn__)); #ifndef NULL #define __DARWIN_NULL 0 #define NULL __DARWIN_NULL -#endif
\ No newline at end of file +#endif + +#define offsetof(t, d) __builtin_offsetof(t, d)
\ No newline at end of file diff --git a/test/Analysis/MismatchedDeallocator-checker-test.mm b/test/Analysis/MismatchedDeallocator-checker-test.mm index b80f7df233dd..013d677e515c 100644 --- a/test/Analysis/MismatchedDeallocator-checker-test.mm +++ b/test/Analysis/MismatchedDeallocator-checker-test.mm @@ -1,4 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.MismatchedDeallocator -fblocks -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.MismatchedDeallocator -fblocks -DTEST_INLINABLE_ALLOCATORS -verify %s #include "Inputs/system-header-simulator-objc.h" #include "Inputs/system-header-simulator-cxx.h" diff --git a/test/Analysis/MismatchedDeallocator-path-notes.cpp b/test/Analysis/MismatchedDeallocator-path-notes.cpp index 1354386fc8b7..4e4ffc42423e 100644 --- a/test/Analysis/MismatchedDeallocator-path-notes.cpp +++ b/test/Analysis/MismatchedDeallocator-path-notes.cpp @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.MismatchedDeallocator -analyzer-output=text -verify %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.MismatchedDeallocator -analyzer-output=plist -analyzer-config path-diagnostics-alternate=false %s -o %t.plist +// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.MismatchedDeallocator -analyzer-output=plist %s -o %t.plist // RUN: FileCheck --input-file=%t.plist %s void changePointee(int *p); @@ -131,40 +131,6 @@ void test() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>7</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>7</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>7</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>7</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -243,6 +209,40 @@ void test() { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>13</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> diff --git a/test/Analysis/MisusedMovedObject.cpp b/test/Analysis/MisusedMovedObject.cpp index 132a65de104e..07d52c8236da 100644 --- a/test/Analysis/MisusedMovedObject.cpp +++ b/test/Analysis/MisusedMovedObject.cpp @@ -1,4 +1,5 @@ -// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.cplusplus.MisusedMovedObject -std=c++11 -verify -analyzer-output=text %s +// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.cplusplus.MisusedMovedObject -std=c++11 -verify -analyzer-output=text -analyzer-config exploration_strategy=unexplored_first_queue %s +// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.cplusplus.MisusedMovedObject -std=c++11 -analyzer-config exploration_strategy=dfs -verify -analyzer-output=text -DDFS=1 %s namespace std { @@ -474,12 +475,16 @@ void differentBranchesTest(int i) { // A variation on the theme above. { A a; +#ifdef DFS a.foo() > 0 ? a.foo() : A(std::move(a)).foo(); // expected-note {{Assuming the condition is false}} expected-note {{'?' condition is false}} +#else + a.foo() > 0 ? a.foo() : A(std::move(a)).foo(); // expected-note {{Assuming the condition is true}} expected-note {{'?' condition is true}} +#endif } // Same thing, but with a switch statement. { A a, b; - switch (i) { // expected-note {{Control jumps to 'case 1:' at line 483}} + switch (i) { // expected-note {{Control jumps to 'case 1:'}} case 1: b = std::move(a); // no-warning break; // expected-note {{Execution jumps to the end of the function}} @@ -491,7 +496,7 @@ void differentBranchesTest(int i) { // However, if there's a fallthrough, we do warn. { A a, b; - switch (i) { // expected-note {{Control jumps to 'case 1:' at line 495}} + switch (i) { // expected-note {{Control jumps to 'case 1:'}} case 1: b = std::move(a); // expected-note {{'a' became 'moved-from' here}} case 2: diff --git a/test/Analysis/NewDelete-atomics.cpp b/test/Analysis/NewDelete-atomics.cpp new file mode 100644 index 000000000000..54fce17ea7bd --- /dev/null +++ b/test/Analysis/NewDelete-atomics.cpp @@ -0,0 +1,78 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete -std=c++11 -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDeleteLeaks -DLEAKS -std=c++11 -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete -std=c++11 -DTEST_INLINABLE_ALLOCATORS -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDeleteLeaks -DLEAKS -std=c++11 -DTEST_INLINABLE_ALLOCATORS -verify %s +// RUN: %clang_analyze_cc1 -analyzer-inline-max-stack-depth 2 -analyzer-config ipa-always-inline-size=2 -analyzer-checker=core,cplusplus.NewDelete -std=c++11 -verify %s +// RUN: %clang_analyze_cc1 -analyzer-inline-max-stack-depth 2 -analyzer-config ipa-always-inline-size=2 -analyzer-checker=core,cplusplus.NewDeleteLeaks -DLEAKS -std=c++11 -verify %s +// RUN: %clang_analyze_cc1 -analyzer-inline-max-stack-depth 2 -analyzer-config ipa-always-inline-size=2 -analyzer-checker=core,cplusplus.NewDelete -std=c++11 -DTEST_INLINABLE_ALLOCATORS -verify %s +// RUN: %clang_analyze_cc1 -analyzer-inline-max-stack-depth 2 -analyzer-config ipa-always-inline-size=2 -analyzer-checker=core,cplusplus.NewDeleteLeaks -DLEAKS -std=c++11 -DTEST_INLINABLE_ALLOCATORS -verify %s + +// expected-no-diagnostics + +#include "Inputs/system-header-simulator-cxx.h" + +typedef enum memory_order { + memory_order_relaxed = __ATOMIC_RELAXED, + memory_order_consume = __ATOMIC_CONSUME, + memory_order_acquire = __ATOMIC_ACQUIRE, + memory_order_release = __ATOMIC_RELEASE, + memory_order_acq_rel = __ATOMIC_ACQ_REL, + memory_order_seq_cst = __ATOMIC_SEQ_CST +} memory_order; + +class Obj { + int RefCnt; + +public: + int incRef() { + return __c11_atomic_fetch_add((volatile _Atomic(int) *)&RefCnt, 1, + memory_order_relaxed); + } + + int decRef() { + return __c11_atomic_fetch_sub((volatile _Atomic(int) *)&RefCnt, 1, + memory_order_relaxed); + } + + void foo(); +}; + +class IntrusivePtr { + Obj *Ptr; + +public: + IntrusivePtr(Obj *Ptr) : Ptr(Ptr) { + Ptr->incRef(); + } + + IntrusivePtr(const IntrusivePtr &Other) : Ptr(Other.Ptr) { + Ptr->incRef(); + } + + ~IntrusivePtr() { + // We should not take the path on which the object is deleted. + if (Ptr->decRef() == 1) + delete Ptr; + } + + Obj *getPtr() const { return Ptr; } // no-warning +}; + +void testDestroyLocalRefPtr() { + IntrusivePtr p1(new Obj()); + { + IntrusivePtr p2(p1); + } + + // p1 still maintains ownership. The object is not deleted. + p1.getPtr()->foo(); // no-warning +} + +void testDestroySymbolicRefPtr(const IntrusivePtr &p1) { + { + IntrusivePtr p2(p1); + } + + // p1 still maintains ownership. The object is not deleted. + p1.getPtr()->foo(); // no-warning +} diff --git a/test/Analysis/NewDelete-checker-test.cpp b/test/Analysis/NewDelete-checker-test.cpp index 66e837572bb0..620237cd6ede 100644 --- a/test/Analysis/NewDelete-checker-test.cpp +++ b/test/Analysis/NewDelete-checker-test.cpp @@ -1,5 +1,12 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete -std=c++11 -fblocks -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDeleteLeaks -DLEAKS -std=c++11 -fblocks -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete -std=c++11 -fblocks -analyzer-config c++-allocator-inlining=true -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDeleteLeaks -DLEAKS -std=c++11 -fblocks -analyzer-config c++-allocator-inlining=true -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete -std=c++11 -fblocks -DTEST_INLINABLE_ALLOCATORS -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDeleteLeaks -DLEAKS -std=c++11 -fblocks -DTEST_INLINABLE_ALLOCATORS -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete -std=c++11 -fblocks -analyzer-config c++-allocator-inlining=true -DTEST_INLINABLE_ALLOCATORS -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDeleteLeaks -DLEAKS -std=c++11 -fblocks -analyzer-config c++-allocator-inlining=true -DTEST_INLINABLE_ALLOCATORS -verify %s + #include "Inputs/system-header-simulator-cxx.h" typedef __typeof__(sizeof(int)) size_t; @@ -45,14 +52,18 @@ void testGlobalNoThrowPlacementOpNewBeforeOverload() { void *p = operator new(0, std::nothrow); } #ifdef LEAKS -// expected-warning@-2{{Potential leak of memory pointed to by 'p'}} +#ifndef TEST_INLINABLE_ALLOCATORS +// expected-warning@-3{{Potential leak of memory pointed to by 'p'}} +#endif #endif void testGlobalNoThrowPlacementExprNewBeforeOverload() { int *p = new(std::nothrow) int; } #ifdef LEAKS -// expected-warning@-2{{Potential leak of memory pointed to by 'p'}} +#ifndef TEST_INLINABLE_ALLOCATORS +// expected-warning@-3{{Potential leak of memory pointed to by 'p'}} +#endif #endif //----- Standard pointer placement operators @@ -186,7 +197,10 @@ void testExprDeleteArrArg() { void testAllocDeallocNames() { int *p = new(std::nothrow) int[1]; - delete[] (++p); // expected-warning{{Argument to 'delete[]' is offset by 4 bytes from the start of memory allocated by 'new[]'}} + delete[] (++p); +#ifndef TEST_INLINABLE_ALLOCATORS + // expected-warning@-2{{Argument to 'delete[]' is offset by 4 bytes from the start of memory allocated by 'new[]'}} +#endif } //-------------------------------- diff --git a/test/Analysis/NewDelete-custom.cpp b/test/Analysis/NewDelete-custom.cpp index f06ff4a858e5..f5a2952699ff 100644 --- a/test/Analysis/NewDelete-custom.cpp +++ b/test/Analysis/NewDelete-custom.cpp @@ -1,8 +1,10 @@ -// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,unix.Malloc -std=c++11 -fblocks -verify %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,unix.Malloc -std=c++11 -DLEAKS -fblocks -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,unix.Malloc -std=c++11 -analyzer-config c++-allocator-inlining=false -fblocks -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,unix.Malloc -std=c++11 -analyzer-config c++-allocator-inlining=false -DLEAKS=1 -fblocks -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,unix.Malloc -std=c++11 -DALLOCATOR_INLINING=1 -fblocks -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,unix.Malloc -std=c++11 -DLEAKS=1 -DALLOCATOR_INLINING=1 -fblocks -verify %s #include "Inputs/system-header-simulator-cxx.h" -#ifndef LEAKS +#if !(LEAKS && !ALLOCATOR_INLINING) // expected-no-diagnostics #endif @@ -11,7 +13,7 @@ void *allocator(std::size_t size); void *operator new[](std::size_t size) throw() { return allocator(size); } void *operator new(std::size_t size) throw() { return allocator(size); } -void *operator new(std::size_t size, std::nothrow_t& nothrow) throw() { return allocator(size); } +void *operator new(std::size_t size, const std::nothrow_t ¬hrow) throw() { return allocator(size); } void *operator new(std::size_t, double d); class C { @@ -26,7 +28,7 @@ void testNewMethod() { C *c3 = ::new C; } -#ifdef LEAKS +#if LEAKS && !ALLOCATOR_INLINING // expected-warning@-2{{Potential leak of memory pointed to by 'c3'}} #endif @@ -37,7 +39,7 @@ void testOpNewArray() { void testNewExprArray() { int *p = new int[0]; } -#ifdef LEAKS +#if LEAKS && !ALLOCATOR_INLINING // expected-warning@-2{{Potential leak of memory pointed to by 'p'}} #endif @@ -50,30 +52,27 @@ void testOpNew() { void testNewExpr() { int *p = new int; } -#ifdef LEAKS +#if LEAKS && !ALLOCATOR_INLINING // expected-warning@-2{{Potential leak of memory pointed to by 'p'}} #endif //----- Custom NoThrow placement operators void testOpNewNoThrow() { - void *p = operator new(0, std::nothrow); + void *p = operator new(0, std::nothrow); // call is inlined, no warn } -#ifdef LEAKS -// expected-warning@-2{{Potential leak of memory pointed to by 'p'}} -#endif void testNewExprNoThrow() { int *p = new(std::nothrow) int; } -#ifdef LEAKS +#if LEAKS && !ALLOCATOR_INLINING // expected-warning@-2{{Potential leak of memory pointed to by 'p'}} #endif //----- Custom placement operators void testOpNewPlacement() { void *p = operator new(0, 0.1); // no warn -} +} void testNewExprPlacement() { int *p = new(0.1) int; // no warn diff --git a/test/Analysis/NewDelete-intersections.mm b/test/Analysis/NewDelete-intersections.mm index aa52c7902888..b3707858f00c 100644 --- a/test/Analysis/NewDelete-intersections.mm +++ b/test/Analysis/NewDelete-intersections.mm @@ -1,5 +1,7 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete -std=c++11 -fblocks -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks -std=c++11 -DLEAKS -fblocks -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete -std=c++11 -fblocks -DTEST_INLINABLE_ALLOCATORS -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks -std=c++11 -DLEAKS -fblocks -DTEST_INLINABLE_ALLOCATORS -verify %s #include "Inputs/system-header-simulator-cxx.h" #include "Inputs/system-header-simulator-objc.h" diff --git a/test/Analysis/NewDelete-path-notes.cpp b/test/Analysis/NewDelete-path-notes.cpp index ac760ca60eb4..48c402d25c60 100644 --- a/test/Analysis/NewDelete-path-notes.cpp +++ b/test/Analysis/NewDelete-path-notes.cpp @@ -1,5 +1,6 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.NewDelete,unix.Malloc -analyzer-output=text -verify %s -// RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.NewDelete,unix.Malloc -analyzer-output=plist -analyzer-config path-diagnostics-alternate=false %s -o %t.plist +// RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.NewDelete,unix.Malloc -analyzer-output=text -analyzer-config c++-allocator-inlining=true -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.NewDelete,unix.Malloc -analyzer-output=plist %s -o %t.plist // RUN: FileCheck --input-file=%t.plist %s void test() { @@ -33,44 +34,10 @@ void test(Odd *odd) { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>14</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> +// CHECK-NEXT: <key>line</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -78,12 +45,12 @@ void test(Odd *odd) { // CHECK-NEXT: <array> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> +// CHECK-NEXT: <key>line</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> +// CHECK-NEXT: <key>line</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -103,25 +70,25 @@ void test(Odd *odd) { // CHECK-NEXT: <key>start</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>line</key><integer>7</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>14</integer> +// CHECK-NEXT: <key>line</key><integer>7</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>8</integer> +// CHECK-NEXT: <key>line</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>8</integer> +// CHECK-NEXT: <key>line</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -137,12 +104,12 @@ void test(Odd *odd) { // CHECK-NEXT: <key>start</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>8</integer> +// CHECK-NEXT: <key>line</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>8</integer> +// CHECK-NEXT: <key>line</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -150,12 +117,12 @@ void test(Odd *odd) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>line</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>line</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -167,7 +134,7 @@ void test(Odd *odd) { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>line</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -175,12 +142,12 @@ void test(Odd *odd) { // CHECK-NEXT: <array> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>line</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>line</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -200,12 +167,12 @@ void test(Odd *odd) { // CHECK-NEXT: <key>start</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>line</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>line</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -213,12 +180,12 @@ void test(Odd *odd) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>13</integer> +// CHECK-NEXT: <key>line</key><integer>14</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>13</integer> +// CHECK-NEXT: <key>line</key><integer>14</integer> // CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -230,7 +197,7 @@ void test(Odd *odd) { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>13</integer> +// CHECK-NEXT: <key>line</key><integer>14</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -238,12 +205,12 @@ void test(Odd *odd) { // CHECK-NEXT: <array> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>13</integer> +// CHECK-NEXT: <key>line</key><integer>14</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>13</integer> +// CHECK-NEXT: <key>line</key><integer>14</integer> // CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -267,7 +234,7 @@ void test(Odd *odd) { // CHECK-NEXT: <key>issue_hash_function_offset</key><string>8</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>13</integer> +// CHECK-NEXT: <key>line</key><integer>14</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -279,7 +246,7 @@ void test(Odd *odd) { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>line</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>2</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -287,12 +254,12 @@ void test(Odd *odd) { // CHECK-NEXT: <array> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>line</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>2</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>line</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -308,7 +275,7 @@ void test(Odd *odd) { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>18</integer> +// CHECK-NEXT: <key>line</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>2</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -326,12 +293,12 @@ void test(Odd *odd) { // CHECK-NEXT: <key>start</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>18</integer> +// CHECK-NEXT: <key>line</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>2</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>18</integer> +// CHECK-NEXT: <key>line</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -339,12 +306,12 @@ void test(Odd *odd) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>line</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>line</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -356,7 +323,7 @@ void test(Odd *odd) { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>line</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -364,12 +331,12 @@ void test(Odd *odd) { // CHECK-NEXT: <array> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>line</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>line</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>13</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -385,7 +352,7 @@ void test(Odd *odd) { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>line</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>2</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -393,12 +360,12 @@ void test(Odd *odd) { // CHECK-NEXT: <array> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>line</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>2</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>line</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -418,12 +385,12 @@ void test(Odd *odd) { // CHECK-NEXT: <key>start</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>line</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>2</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>line</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -431,12 +398,12 @@ void test(Odd *odd) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>26</integer> +// CHECK-NEXT: <key>line</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>2</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>26</integer> +// CHECK-NEXT: <key>line</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -448,7 +415,7 @@ void test(Odd *odd) { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>26</integer> +// CHECK-NEXT: <key>line</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>2</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -456,12 +423,12 @@ void test(Odd *odd) { // CHECK-NEXT: <array> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>26</integer> +// CHECK-NEXT: <key>line</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>2</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>26</integer> +// CHECK-NEXT: <key>line</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -485,7 +452,7 @@ void test(Odd *odd) { // CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>26</integer> +// CHECK-NEXT: <key>line</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>2</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> diff --git a/test/Analysis/NewDeleteLeaks-PR19102.cpp b/test/Analysis/NewDeleteLeaks-PR19102.cpp index 502db6122f5c..625b2d4b7af4 100644 --- a/test/Analysis/NewDeleteLeaks-PR19102.cpp +++ b/test/Analysis/NewDeleteLeaks-PR19102.cpp @@ -1,4 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDeleteLeaks -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDeleteLeaks -analyzer-config c++-allocator-inlining=true -verify %s class A0 {}; diff --git a/test/Analysis/PR24184.cpp b/test/Analysis/PR24184.cpp index 1280334d4d6a..bfc5ae6ea56b 100644 --- a/test/Analysis/PR24184.cpp +++ b/test/Analysis/PR24184.cpp @@ -1,3 +1,4 @@ +// UNSUPPORTED: z3 // RUN: %clang_analyze_cc1 -w -analyzer-eagerly-assume -fcxx-exceptions -analyzer-checker=core -analyzer-checker=alpha.core.PointerArithm,alpha.core.CastToStruct -analyzer-max-loop 64 -verify %s // RUN: %clang_analyze_cc1 -w -analyzer-checker=core -analyzer-checker=cplusplus -fcxx-exceptions -analyzer-checker alpha.core.PointerArithm,alpha.core.CastToStruct -analyzer-max-loop 63 -verify %s diff --git a/test/Analysis/PR37855.c b/test/Analysis/PR37855.c new file mode 100644 index 000000000000..0779796531fd --- /dev/null +++ b/test/Analysis/PR37855.c @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -analyze -analyzer-eagerly-assume -analyzer-checker=core -w -DNO_CROSSCHECK -verify %s +// RUN: %clang_cc1 -analyze -analyzer-eagerly-assume -analyzer-checker=core -w -analyzer-config crosscheck-with-z3=true -verify %s +// REQUIRES: z3 + +typedef struct o p; +struct o { + struct { + } s; +}; + +void q(*r, p2) { r < p2; } + +void k(l, node) { + struct { + p *node; + } * n, *nodep, path[sizeof(void)]; + path->node = l; + for (n = path; node != l;) { + q(node, n->node); + nodep = n; + } + if (nodep) // expected-warning {{Branch condition evaluates to a garbage value}} + n[1].node->s; +} diff --git a/test/Analysis/PR38208.c b/test/Analysis/PR38208.c new file mode 100644 index 000000000000..fb0a5a15eac6 --- /dev/null +++ b/test/Analysis/PR38208.c @@ -0,0 +1,43 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core -verify %s + +// expected-no-diagnostics + +int foo(int a, int b) { + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + a += b; b -= a; + return a + b; +} diff --git a/test/Analysis/_Bool-increment-decrement.c b/test/Analysis/_Bool-increment-decrement.c new file mode 100644 index 000000000000..477b6ed43830 --- /dev/null +++ b/test/Analysis/_Bool-increment-decrement.c @@ -0,0 +1,140 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.ExprInspection -verify -std=c99 -Dbool=_Bool -Dtrue=1 -Dfalse=0 %s +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.ExprInspection -verify -std=c11 -Dbool=_Bool -Dtrue=1 -Dfalse=0 %s +extern void clang_analyzer_eval(bool); + +void test__Bool_value() { + { + bool b = true; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = false; + clang_analyzer_eval(b == 0); // expected-warning{{TRUE}} + } + + { + bool b = -10; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = 10; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = 10; + b++; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = 0; + b++; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } +} + +void test__Bool_increment() { + { + bool b = true; + b++; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = false; + b++; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = true; + ++b; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = false; + ++b; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = 0; + ++b; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = 10; + ++b; + ++b; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = -10; + ++b; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = -1; + ++b; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } +} + +void test__Bool_decrement() { + { + bool b = true; + b--; + clang_analyzer_eval(b == 0); // expected-warning{{TRUE}} + } + + { + bool b = false; + b--; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = true; + --b; + clang_analyzer_eval(b == 0); // expected-warning{{TRUE}} + } + + { + bool b = false; + --b; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = 0; + --b; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = 10; + --b; + clang_analyzer_eval(b == 0); // expected-warning{{TRUE}} + --b; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = -10; + --b; + clang_analyzer_eval(b == 0); // expected-warning{{TRUE}} + } + + { + bool b = 1; + --b; + clang_analyzer_eval(b == 0); // expected-warning{{TRUE}} + } +} diff --git a/test/Analysis/analyzeOneFunction.m b/test/Analysis/analyzeOneFunction.m index a77abe1246b8..80f34ad525e2 100644 --- a/test/Analysis/analyzeOneFunction.m +++ b/test/Analysis/analyzeOneFunction.m @@ -38,7 +38,7 @@ typedef struct _NSZone NSZone; -(id)myMethod { Test1 *cell = [[[Test1 alloc] init] autorelease]; - NSString *string1 = [[NSString alloc] initWithFormat:@"test %f", 0.0]; // No warning: this function is not analized. + NSString *string1 = [[NSString alloc] initWithFormat:@"test %f", 0.0]; // No warning: this function is not analyzed. cell.text = string1; return cell; diff --git a/test/Analysis/analyzer-config.c b/test/Analysis/analyzer-config.c index 4daea898ecd0..c09800f44b63 100644 --- a/test/Analysis/analyzer-config.c +++ b/test/Analysis/analyzer-config.c @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 %s -o /dev/null -analyzer-checker=core,osx.cocoa,debug.ConfigDumper -analyzer-max-loop 34 > %t 2>&1 -// RUN: FileCheck --input-file=%t %s +// RUN: FileCheck --input-file=%t %s --match-full-lines void bar() {} void foo() { @@ -15,20 +15,24 @@ void foo() { // CHECK-NEXT: cfg-implicit-dtors = true // CHECK-NEXT: cfg-lifetime = false // CHECK-NEXT: cfg-loopexit = false -// CHECK-NEXT: cfg-temporary-dtors = false +// CHECK-NEXT: cfg-rich-constructors = true +// CHECK-NEXT: cfg-scopes = false +// CHECK-NEXT: cfg-temporary-dtors = true +// CHECK-NEXT: elide-constructors = true +// CHECK-NEXT: exploration_strategy = unexplored_first_queue // CHECK-NEXT: faux-bodies = true // CHECK-NEXT: graph-trim-interval = 1000 // CHECK-NEXT: inline-lambdas = true // CHECK-NEXT: ipa = dynamic-bifurcate // CHECK-NEXT: ipa-always-inline-size = 3 -// CHECK-NEXT: leak-diagnostics-reference-allocation = false // CHECK-NEXT: max-inlinable-size = 100 // CHECK-NEXT: max-nodes = 225000 // CHECK-NEXT: max-times-inline-large = 32 // CHECK-NEXT: min-cfg-size-treat-functions-as-large = 14 // CHECK-NEXT: mode = deep // CHECK-NEXT: region-store-small-struct-limit = 2 +// CHECK-NEXT: serialize-stats = false // CHECK-NEXT: unroll-loops = false // CHECK-NEXT: widen-loops = false // CHECK-NEXT: [stats] -// CHECK-NEXT: num-entries = 19 +// CHECK-NEXT: num-entries = 23 diff --git a/test/Analysis/analyzer-config.cpp b/test/Analysis/analyzer-config.cpp index a08e85e53e48..e87045448d3a 100644 --- a/test/Analysis/analyzer-config.cpp +++ b/test/Analysis/analyzer-config.cpp @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 %s -o /dev/null -analyzer-checker=core,osx.cocoa,debug.ConfigDumper -analyzer-max-loop 34 > %t 2>&1 -// RUN: FileCheck --input-file=%t %s +// RUN: FileCheck --input-file=%t %s --match-full-lines void bar() {} void foo() { @@ -12,7 +12,9 @@ void foo() { class Foo { public: - void bar() {} + ~Foo() {} + void baz() { Foo(); } + void bar() { const Foo &f = Foo(); } void foo() { bar(); } }; @@ -21,25 +23,31 @@ public: // CHECK-NEXT: c++-inlining = destructors // CHECK-NEXT: c++-shared_ptr-inlining = false // CHECK-NEXT: c++-stdlib-inlining = true +// CHECK-NEXT: c++-temp-dtor-inlining = true // CHECK-NEXT: c++-template-inlining = true // CHECK-NEXT: cfg-conditional-static-initializers = true // CHECK-NEXT: cfg-implicit-dtors = true // CHECK-NEXT: cfg-lifetime = false // CHECK-NEXT: cfg-loopexit = false -// CHECK-NEXT: cfg-temporary-dtors = false +// CHECK-NEXT: cfg-rich-constructors = true +// CHECK-NEXT: cfg-scopes = false +// CHECK-NEXT: cfg-temporary-dtors = true +// CHECK-NEXT: elide-constructors = true +// CHECK-NEXT: experimental-enable-naive-ctu-analysis = false +// CHECK-NEXT: exploration_strategy = unexplored_first_queue // CHECK-NEXT: faux-bodies = true // CHECK-NEXT: graph-trim-interval = 1000 // CHECK-NEXT: inline-lambdas = true // CHECK-NEXT: ipa = dynamic-bifurcate // CHECK-NEXT: ipa-always-inline-size = 3 -// CHECK-NEXT: leak-diagnostics-reference-allocation = false // CHECK-NEXT: max-inlinable-size = 100 // CHECK-NEXT: max-nodes = 225000 // CHECK-NEXT: max-times-inline-large = 32 // CHECK-NEXT: min-cfg-size-treat-functions-as-large = 14 // CHECK-NEXT: mode = deep // CHECK-NEXT: region-store-small-struct-limit = 2 +// CHECK-NEXT: serialize-stats = false // CHECK-NEXT: unroll-loops = false // CHECK-NEXT: widen-loops = false // CHECK-NEXT: [stats] -// CHECK-NEXT: num-entries = 24 +// CHECK-NEXT: num-entries = 30 diff --git a/test/Analysis/analyzer-stats.c b/test/Analysis/analyzer-stats.c index 5a40d196bb1f..b58e862f6c65 100644 --- a/test/Analysis/analyzer-stats.c +++ b/test/Analysis/analyzer-stats.c @@ -1,4 +1,4 @@ -// RUN: %clang_analyze_cc1 -analyzer-checker=core,deadcode.DeadStores,debug.Stats -verify -Wno-unreachable-code -analyzer-opt-analyze-nested-blocks %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,deadcode.DeadStores,debug.Stats -verify -Wno-unreachable-code -analyzer-opt-analyze-nested-blocks -analyzer-max-loop 4 %s int foo(); @@ -12,3 +12,19 @@ int test() { // expected-warning-re{{test -> Total CFGBlocks: {{[0-9]+}} | Unrea a /= 4; return a; } + + +int sink() // expected-warning-re{{sink -> Total CFGBlocks: {{[0-9]+}} | Unreachable CFGBlocks: 1 | Exhausted Block: yes | Empty WorkList: yes}} +{ + for (int i = 0; i < 10; ++i) // expected-warning {{(sink): The analyzer generated a sink at this point}} + ++i; + + return 0; +} + +int emptyConditionLoop() // expected-warning-re{{emptyConditionLoop -> Total CFGBlocks: {{[0-9]+}} | Unreachable CFGBlocks: 0 | Exhausted Block: yes | Empty WorkList: yes}} +{ + int num = 1; + for (;;) + num++; +} diff --git a/test/Analysis/auto-obj-dtors-cfg-output.cpp b/test/Analysis/auto-obj-dtors-cfg-output.cpp index cc47c92360a5..7e678a1ec78d 100644 --- a/test/Analysis/auto-obj-dtors-cfg-output.cpp +++ b/test/Analysis/auto-obj-dtors-cfg-output.cpp @@ -1,8 +1,25 @@ -// RUN: %clang_analyze_cc1 -fcxx-exceptions -fexceptions -analyzer-checker=debug.DumpCFG %s > %t 2>&1 -// RUN: FileCheck --input-file=%t %s +// RUN: %clang_analyze_cc1 -std=c++98 -fcxx-exceptions -fexceptions -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=false %s > %t 2>&1 +// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,CXX98,WARNINGS,CXX98-WARNINGS %s +// RUN: %clang_analyze_cc1 -std=c++98 -fcxx-exceptions -fexceptions -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=true %s > %t 2>&1 +// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,CXX98,ANALYZER,CXX98-ANALYZER %s +// RUN: %clang_analyze_cc1 -std=c++11 -fcxx-exceptions -fexceptions -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=false %s > %t 2>&1 +// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,CXX11,WARNINGS,CXX11-WARNINGS %s +// RUN: %clang_analyze_cc1 -std=c++11 -fcxx-exceptions -fexceptions -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=true %s > %t 2>&1 +// 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. class A { public: + int x; + // CHECK: [B1 (ENTRY)] // CHECK-NEXT: Succs (1): B0 // CHECK: [B0 (EXIT)] @@ -32,12 +49,14 @@ extern const bool UV; // CHECK: [B2 (ENTRY)] // CHECK-NEXT: Succs (1): B1 // CHECK: [B1] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B1.2], class A) // CHECK-NEXT: 2: A a; // CHECK-NEXT: 3: a // CHECK-NEXT: 4: [B1.3] (ImplicitCastExpr, NoOp, const class A) // CHECK-NEXT: 5: const A &b = a; -// CHECK-NEXT: 6: A() (CXXConstructExpr, class A) +// WARNINGS-NEXT: 6: A() (CXXConstructExpr, class A) +// ANALYZER-NEXT: 6: A() (CXXConstructExpr, [B1.9], class A) // CHECK-NEXT: 7: [B1.6] (BindTemporary) // CHECK-NEXT: 8: [B1.7] (ImplicitCastExpr, NoOp, const class A) // CHECK-NEXT: 9: [B1.8] @@ -57,9 +76,292 @@ void test_const_ref() { // CHECK: [B2 (ENTRY)] // CHECK-NEXT: Succs (1): B1 // CHECK: [B1] -// CHECK-NEXT: 1: (CXXConstructExpr, class A [2]) +// WARNINGS-NEXT: 1: A() (CXXConstructExpr, class A) +// CXX98-ANALYZER-NEXT: 1: A() (CXXConstructExpr, [B1.2], class A) +// CXX11-ANALYZER-NEXT: 1: A() (CXXConstructExpr, [B1.3], class A) +// CHECK-NEXT: 2: [B1.1] (BindTemporary) +// CXX98-NEXT: 3: [B1.2].x +// CXX98-NEXT: 4: [B1.3] +// CXX98-NEXT: 5: const int &x = A().x; +// CXX98-NEXT: 6: [B1.5].~A() (Implicit destructor) +// CXX11-NEXT: 3: [B1.2] +// CXX11-NEXT: 4: [B1.3].x +// CXX11-NEXT: 5: [B1.4] (ImplicitCastExpr, NoOp, const int) +// CXX11-NEXT: 6: const int &x = A().x; +// CXX11-NEXT: 7: [B1.6].~A() (Implicit destructor) +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_const_ref_to_field() { + const int &x = A().x; +} + +// CHECK: [B2 (ENTRY)] +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B1] +// WARNINGS-NEXT: 1: A() (CXXConstructExpr, class A) +// CXX98-ANALYZER-NEXT: 1: A() (CXXConstructExpr, [B1.2], class A) +// CXX11-ANALYZER-NEXT: 1: A() (CXXConstructExpr, [B1.3], class A) +// CHECK-NEXT: 2: [B1.1] (BindTemporary) +// CXX98-NEXT: 3: A::x +// CXX98-NEXT: 4: &[B1.3] +// CXX98-NEXT: 5: [B1.2] .* [B1.4] +// CXX98-NEXT: 6: [B1.5] +// CXX98-NEXT: 7: const int &x = A() .* &A::x; +// CXX98-NEXT: 8: [B1.7].~A() (Implicit destructor) +// CXX11-NEXT: 3: [B1.2] +// CXX11-NEXT: 4: A::x +// CXX11-NEXT: 5: &[B1.4] +// CXX11-NEXT: 6: [B1.3] .* [B1.5] +// CXX11-NEXT: 7: [B1.6] (ImplicitCastExpr, NoOp, const int) +// CXX11-NEXT: 8: const int &x = A() .* &A::x; +// CXX11-NEXT: 9: [B1.8].~A() (Implicit destructor) +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_pointer_to_member() { + const int &x = A().*&A::x; +} + +// FIXME: There should be automatic destructors at the end of scope. +// CHECK: [B2 (ENTRY)] +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B1] +// WARNINGS-NEXT: 1: A() (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: A() (CXXConstructExpr, [B1.4], class A) +// CHECK-NEXT: 2: [B1.1] (BindTemporary) +// CHECK-NEXT: 3: [B1.2] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 4: [B1.3] +// CHECK-NEXT: 5: {[B1.4]} +// CHECK-NEXT: 6: B b = {A()}; +// WARNINGS-NEXT: 7: A() (CXXConstructExpr, class A) +// ANALYZER-NEXT: 7: A() (CXXConstructExpr, [B1.10], class A) +// CHECK-NEXT: 8: [B1.7] (BindTemporary) +// CHECK-NEXT: 9: [B1.8] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 10: [B1.9] +// CHECK-NEXT: 11: {[B1.10]} +// WARNINGS-NEXT: 12: A() (CXXConstructExpr, class A) +// ANALYZER-NEXT: 12: A() (CXXConstructExpr, [B1.15], class A) +// CHECK-NEXT: 13: [B1.12] (BindTemporary) +// CHECK-NEXT: 14: [B1.13] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 15: [B1.14] +// CHECK-NEXT: 16: {[B1.15]} +// CHECK-NEXT: 17: {[B1.10], [B1.15]} +// CHECK-NEXT: 18: B bb[2] = {A(), A()}; +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_aggregate_lifetime_extension() { + struct B { + const A &x; + }; + + B b = {A()}; + B bb[2] = {A(), A()}; +} + +// In C++98 such class 'C' will not be an aggregate. +#if __cplusplus >= 201103L +// FIXME: There should be automatic destructors at the end of the scope. +// CXX11: [B2 (ENTRY)] +// CXX11-NEXT: Succs (1): B1 +// CXX11: [B1] +// CXX11-WARNINGS-NEXT: 1: A() (CXXConstructExpr, class A) +// CXX11-ANALYZER-NEXT: 1: A() (CXXConstructExpr, [B1.2], [B1.4], class A) +// CXX11-NEXT: 2: [B1.1] (BindTemporary) +// CXX11-NEXT: 3: [B1.2] (ImplicitCastExpr, NoOp, const class A) +// CXX11-NEXT: 4: [B1.3] +// CXX11-NEXT: 5: [B1.4] (CXXConstructExpr, const class A) +// CXX11-WARNINGS-NEXT: 6: A() (CXXConstructExpr, class A) +// CXX11-ANALYZER-NEXT: 6: A() (CXXConstructExpr, [B1.7], [B1.9], class A) +// CXX11-NEXT: 7: [B1.6] (BindTemporary) +// CXX11-NEXT: 8: [B1.7] (ImplicitCastExpr, NoOp, const class A) +// CXX11-NEXT: 9: [B1.8] +// CXX11-NEXT: 10: [B1.9] (CXXConstructExpr, const class A) +// FIXME: Why does it look as if the initializer list consumes uncopied objects? +// CXX11-NEXT: 11: {[B1.2], [B1.7]} +// CXX11-NEXT: 12: [B1.11] (BindTemporary) +// CXX11-NEXT: 13: [B1.12] +// CXX11-NEXT: 14: {[B1.13]} +// Double curly braces trigger regexps, escape as per FileCheck manual. +// CXX11-NEXT: 15: C c = {{[{][{]}}A(), A(){{[}][}]}}; +// CXX11-NEXT: 16: ~A() (Temporary object destructor) +// CXX11-NEXT: 17: ~A() (Temporary object destructor) +// CXX11-WARNINGS-NEXT: 18: A() (CXXConstructExpr, class A) +// CXX11-ANALYZER-NEXT: 18: A() (CXXConstructExpr, [B1.19], [B1.21], class A) +// CXX11-NEXT: 19: [B1.18] (BindTemporary) +// CXX11-NEXT: 20: [B1.19] (ImplicitCastExpr, NoOp, const class A) +// CXX11-NEXT: 21: [B1.20] +// CXX11-NEXT: 22: [B1.21] (CXXConstructExpr, const class A) +// CXX11-WARNINGS-NEXT: 23: A() (CXXConstructExpr, class A) +// CXX11-ANALYZER-NEXT: 23: A() (CXXConstructExpr, [B1.24], [B1.26], class A) +// CXX11-NEXT: 24: [B1.23] (BindTemporary) +// CXX11-NEXT: 25: [B1.24] (ImplicitCastExpr, NoOp, const class A) +// CXX11-NEXT: 26: [B1.25] +// CXX11-NEXT: 27: [B1.26] (CXXConstructExpr, const class A) +// FIXME: Why does it look as if the initializer list consumes uncopied objects? +// CXX11-NEXT: 28: {[B1.19], [B1.24]} +// CXX11-NEXT: 29: [B1.28] (BindTemporary) +// CXX11-NEXT: 30: [B1.29] +// CXX11-NEXT: 31: {[B1.30]} +// CXX11-WARNINGS-NEXT: 32: A() (CXXConstructExpr, class A) +// CXX11-ANALYZER-NEXT: 32: A() (CXXConstructExpr, [B1.33], [B1.35], class A) +// CXX11-NEXT: 33: [B1.32] (BindTemporary) +// CXX11-NEXT: 34: [B1.33] (ImplicitCastExpr, NoOp, const class A) +// CXX11-NEXT: 35: [B1.34] +// CXX11-NEXT: 36: [B1.35] (CXXConstructExpr, const class A) +// CXX11-WARNINGS-NEXT: 37: A() (CXXConstructExpr, class A) +// CXX11-ANALYZER-NEXT: 37: A() (CXXConstructExpr, [B1.38], [B1.40], class A) +// CXX11-NEXT: 38: [B1.37] (BindTemporary) +// CXX11-NEXT: 39: [B1.38] (ImplicitCastExpr, NoOp, const class A) +// CXX11-NEXT: 40: [B1.39] +// CXX11-NEXT: 41: [B1.40] (CXXConstructExpr, const class A) +// FIXME: Why does it look as if the initializer list consumes uncopied objects? +// CXX11-NEXT: 42: {[B1.33], [B1.38]} +// CXX11-NEXT: 43: [B1.42] (BindTemporary) +// CXX11-NEXT: 44: [B1.43] +// CXX11-NEXT: 45: {[B1.44]} +// Double curly braces trigger regexps, escape as per FileCheck manual. +// CXX11-NEXT: 46: {{[{][{]}}[B1.30]}, {[B1.44]{{[}][}]}} +// Double curly braces trigger regexps, escape as per FileCheck manual. +// CXX11-NEXT: 47: C cc[2] = {{[{][{][{]}}A(), A(){{[}][}]}}, {{[{][{]}}A(), A(){{[}][}][}]}}; +// CXX11-NEXT: 48: ~A() (Temporary object destructor) +// CXX11-NEXT: 49: ~A() (Temporary object destructor) +// CXX11-NEXT: 50: ~A() (Temporary object destructor) +// CXX11-NEXT: 51: ~A() (Temporary object destructor) +// CXX11-NEXT: Preds (1): B2 +// CXX11-NEXT: Succs (1): B0 +// CXX11: [B0 (EXIT)] +// CXX11-NEXT: Preds (1): B1 +void test_aggregate_array_lifetime_extension() { + struct C { + const A (&z)[2]; + }; + + // Until C++17 there are elidable copies here, so there should be 9 temporary + // destructors of A()s. There are no destructors of 'c' and 'cc' because this + // aggregate has no destructor. Instead, arrays are lifetime-extended, + // and copies of A()s within them need to be destroyed via automatic + // destructors. + C c = {{A(), A()}}; + C cc[2] = {{{A(), A()}}, {{A(), A()}}}; +} +#endif + +// CHECK: [B2 (ENTRY)] +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B1] +// WARNINGS-NEXT: 1: A() (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: A() (CXXConstructExpr, [B1.2], [B1.4], class A) +// CHECK-NEXT: 2: [B1.1] (BindTemporary) +// CHECK-NEXT: 3: [B1.2] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 4: [B1.3] +// CHECK-NEXT: 5: [B1.4] (CXXConstructExpr, class A) +// WARNINGS-NEXT: 6: A() (CXXConstructExpr, class A) +// ANALYZER-NEXT: 6: A() (CXXConstructExpr, [B1.7], [B1.9], class A) +// CHECK-NEXT: 7: [B1.6] (BindTemporary) +// CHECK-NEXT: 8: [B1.7] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 9: [B1.8] +// CHECK-NEXT: 10: [B1.9] (CXXConstructExpr, class A) +// WARNINGS-NEXT: 11: A() (CXXConstructExpr, class A) +// ANALYZER-NEXT: 11: A() (CXXConstructExpr, [B1.12], [B1.14], class A) +// CHECK-NEXT: 12: [B1.11] (BindTemporary) +// CHECK-NEXT: 13: [B1.12] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 14: [B1.13] +// CHECK-NEXT: 15: [B1.14] (CXXConstructExpr, class A) +// FIXME: Why does it look as if the initializer list consumes uncopied objects? +// CHECK-NEXT: 16: {[B1.7], [B1.12]} +// FIXME: Why does it look as if the initializer list consumes uncopied objects? +// CHECK-NEXT: 17: {[B1.2], {[B1.7], [B1.12]}} +// CHECK-NEXT: 18: D d = {A(), {A(), A()}}; +// CHECK-NEXT: 19: ~A() (Temporary object destructor) +// CHECK-NEXT: 20: ~A() (Temporary object destructor) +// CHECK-NEXT: 21: ~A() (Temporary object destructor) +// WARNINGS-NEXT: 22: A() (CXXConstructExpr, class A) +// ANALYZER-NEXT: 22: A() (CXXConstructExpr, [B1.23], [B1.25], class A) +// CHECK-NEXT: 23: [B1.22] (BindTemporary) +// CHECK-NEXT: 24: [B1.23] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 25: [B1.24] +// CHECK-NEXT: 26: [B1.25] (CXXConstructExpr, class A) +// WARNINGS-NEXT: 27: A() (CXXConstructExpr, class A) +// ANALYZER-NEXT: 27: A() (CXXConstructExpr, [B1.28], [B1.30], class A) +// CHECK-NEXT: 28: [B1.27] (BindTemporary) +// CHECK-NEXT: 29: [B1.28] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 30: [B1.29] +// CHECK-NEXT: 31: [B1.30] (CXXConstructExpr, class A) +// WARNINGS-NEXT: 32: A() (CXXConstructExpr, class A) +// ANALYZER-NEXT: 32: A() (CXXConstructExpr, [B1.33], [B1.35], class A) +// CHECK-NEXT: 33: [B1.32] (BindTemporary) +// CHECK-NEXT: 34: [B1.33] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 35: [B1.34] +// CHECK-NEXT: 36: [B1.35] (CXXConstructExpr, class A) +// FIXME: Why does it look as if the initializer list consumes uncopied objects? +// CHECK-NEXT: 37: {[B1.28], [B1.33]} +// FIXME: Why does it look as if the initializer list consumes uncopied objects? +// CHECK-NEXT: 38: {[B1.23], {[B1.28], [B1.33]}} +// WARNINGS-NEXT: 39: A() (CXXConstructExpr, class A) +// ANALYZER-NEXT: 39: A() (CXXConstructExpr, [B1.40], [B1.42], class A) +// CHECK-NEXT: 40: [B1.39] (BindTemporary) +// CHECK-NEXT: 41: [B1.40] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 42: [B1.41] +// CHECK-NEXT: 43: [B1.42] (CXXConstructExpr, class A) +// WARNINGS-NEXT: 44: A() (CXXConstructExpr, class A) +// ANALYZER-NEXT: 44: A() (CXXConstructExpr, [B1.45], [B1.47], class A) +// CHECK-NEXT: 45: [B1.44] (BindTemporary) +// CHECK-NEXT: 46: [B1.45] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 47: [B1.46] +// CHECK-NEXT: 48: [B1.47] (CXXConstructExpr, class A) +// WARNINGS-NEXT: 49: A() (CXXConstructExpr, class A) +// ANALYZER-NEXT: 49: A() (CXXConstructExpr, [B1.50], [B1.52], class A) +// CHECK-NEXT: 50: [B1.49] (BindTemporary) +// CHECK-NEXT: 51: [B1.50] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 52: [B1.51] +// CHECK-NEXT: 53: [B1.52] (CXXConstructExpr, class A) +// FIXME: Why does it look as if the initializer list consumes uncopied objects? +// CHECK-NEXT: 54: {[B1.45], [B1.50]} +// FIXME: Why does it look as if the initializer list consumes uncopied objects? +// CHECK-NEXT: 55: {[B1.40], {[B1.45], [B1.50]}} +// Double curly braces trigger regexps, escape as per FileCheck manual. +// CHECK-NEXT: 56: {{[{][{]}}[B1.23], {[B1.28], [B1.33]{{[}][}]}}, {[B1.40], {[B1.45], [B1.50]{{[}][}][}]}} +// Double curly braces trigger regexps, escape as per FileCheck manual. +// CHECK-NEXT: 57: D dd[2] = {{[{][{]}}A(), {A(), A(){{[}][}]}}, {A(), {A(), A(){{[}][}][}]}}; +// CHECK-NEXT: 58: ~A() (Temporary object destructor) +// CHECK-NEXT: 59: ~A() (Temporary object destructor) +// CHECK-NEXT: 60: ~A() (Temporary object destructor) +// CHECK-NEXT: 61: ~A() (Temporary object destructor) +// CHECK-NEXT: 62: ~A() (Temporary object destructor) +// CHECK-NEXT: 63: ~A() (Temporary object destructor) +// CHECK-NEXT: 64: [B1.57].~D() (Implicit destructor) +// CHECK-NEXT: 65: [B1.18].~D() (Implicit destructor) +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_aggregate_with_nontrivial_own_destructor() { + struct D { + A y; + A w[2]; + }; + + // Until C++17 there are elidable copies here, so there should be 9 temporary + // destructors of A()s. Destructors of 'd' and 'dd' should implicitly + // take care of the copies, so there should not be automatic destructors + // for copies of A()s. + D d = {A(), {A(), A()}}; + D dd[2] = {{A(), {A(), A()}}, {A(), {A(), A()}}}; +} + +// CHECK: [B2 (ENTRY)] +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B1] +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A [2]) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B1.2], class A [2]) // CHECK-NEXT: 2: A a[2]; -// CHECK-NEXT: 3: (CXXConstructExpr, class A [0]) +// WARNINGS-NEXT: 3: (CXXConstructExpr, class A [0]) +// ANALYZER-NEXT: 3: (CXXConstructExpr, [B1.4], class A [0]) // CHECK-NEXT: 4: A b[0]; // CHECK-NEXT: 5: [B1.2].~A() (Implicit destructor) // CHECK-NEXT: Preds (1): B2 @@ -74,15 +376,19 @@ void test_array() { // CHECK: [B2 (ENTRY)] // CHECK-NEXT: Succs (1): B1 // CHECK: [B1] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B1.2], class A) // CHECK-NEXT: 2: A a; -// CHECK-NEXT: 3: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 3: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 3: (CXXConstructExpr, [B1.4], class A) // CHECK-NEXT: 4: A c; -// CHECK-NEXT: 5: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 5: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 5: (CXXConstructExpr, [B1.6], class A) // CHECK-NEXT: 6: A d; // CHECK-NEXT: 7: [B1.6].~A() (Implicit destructor) // CHECK-NEXT: 8: [B1.4].~A() (Implicit destructor) -// CHECK-NEXT: 9: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 9: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 9: (CXXConstructExpr, [B1.10], class A) // CHECK: 10: A b; // CHECK: 11: [B1.10].~A() (Implicit destructor) // CHECK: 12: [B1.2].~A() (Implicit destructor) @@ -101,7 +407,8 @@ void test_scope() { // CHECK: [B4 (ENTRY)] // CHECK-NEXT: Succs (1): B3 // CHECK: [B1] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B1.2], class A) // CHECK-NEXT: 2: A c; // CHECK-NEXT: 3: [B1.2].~A() (Implicit destructor) // CHECK-NEXT: 4: [B3.4].~A() (Implicit destructor) @@ -115,9 +422,11 @@ void test_scope() { // CHECK-NEXT: Preds (1): B3 // CHECK-NEXT: Succs (1): B0 // CHECK: [B3] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B3.2], class A) // CHECK-NEXT: 2: A a; -// CHECK-NEXT: 3: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 3: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 3: (CXXConstructExpr, [B3.4], class A) // CHECK-NEXT: 4: A b; // CHECK-NEXT: 5: UV // CHECK-NEXT: 6: [B3.5] (ImplicitCastExpr, LValueToRValue, _Bool) @@ -137,7 +446,8 @@ void test_return() { // CHECK-NEXT: Succs (1): B7 // CHECK: [B1] // CHECK: l1: -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B1.2], class A) // CHECK-NEXT: 2: A c; // CHECK-NEXT: 3: [B1.2].~A() (Implicit destructor) // CHECK-NEXT: 4: [B6.2].~A() (Implicit destructor) @@ -145,7 +455,8 @@ void test_return() { // CHECK-NEXT: Preds (2): B2 B3 // CHECK-NEXT: Succs (1): B0 // CHECK: [B2] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B2.2], class A) // CHECK-NEXT: 2: A b; // CHECK-NEXT: 3: [B2.2].~A() (Implicit destructor) // CHECK-NEXT: 4: [B6.4].~A() (Implicit destructor) @@ -170,9 +481,11 @@ void test_return() { // CHECK-NEXT: Succs (1): B6 // CHECK: [B6] // CHECK: l0: -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B6.2], class A) // CHECK-NEXT: 2: A b; -// CHECK-NEXT: 3: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 3: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 3: (CXXConstructExpr, [B6.4], class A) // CHECK-NEXT: 4: A a; // CHECK-NEXT: 5: UV // CHECK-NEXT: 6: [B6.5] (ImplicitCastExpr, LValueToRValue, _Bool) @@ -180,7 +493,8 @@ void test_return() { // CHECK-NEXT: Preds (2): B7 B5 // CHECK-NEXT: Succs (2): B5 B4 // CHECK: [B7] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B7.2], class A) // CHECK-NEXT: 2: A a; // CHECK-NEXT: Preds (1): B8 // CHECK-NEXT: Succs (1): B6 @@ -207,23 +521,27 @@ l1: // CHECK-NEXT: Preds (2): B2 B3 // CHECK-NEXT: Succs (1): B0 // CHECK: [B2] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B2.2], class A) // CHECK-NEXT: 2: A c; // CHECK-NEXT: 3: [B2.2].~A() (Implicit destructor) // CHECK-NEXT: Preds (1): B4 // CHECK-NEXT: Succs (1): B1 // CHECK: [B3] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B3.2], class A) // CHECK-NEXT: 2: A c; // CHECK-NEXT: 3: [B3.2].~A() (Implicit destructor) // CHECK-NEXT: Preds (1): B4 // CHECK-NEXT: Succs (1): B1 // CHECK: [B4] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B4.2], class A) // CHECK-NEXT: 2: A a; // CHECK-NEXT: 3: a // CHECK-NEXT: 4: [B4.3] (ImplicitCastExpr, NoOp, const class A) -// CHECK-NEXT: 5: [B4.4] (CXXConstructExpr, class A) +// WARNINGS-NEXT: 5: [B4.4] (CXXConstructExpr, class A) +// ANALYZER-NEXT: 5: [B4.4] (CXXConstructExpr, [B4.6], class A) // CHECK-NEXT: 6: A b = a; // CHECK-NEXT: 7: b // CHECK-NEXT: 8: [B4.7] (ImplicitCastExpr, NoOp, const class A) @@ -247,14 +565,16 @@ void test_if_implicit_scope() { // CHECK-NEXT: Succs (1): B8 // CHECK: [B1] // CHECK-NEXT: 1: [B8.6].~A() (Implicit destructor) -// CHECK-NEXT: 2: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 2: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 2: (CXXConstructExpr, [B1.3], class A) // CHECK-NEXT: 3: A e; // CHECK-NEXT: 4: [B1.3].~A() (Implicit destructor) // CHECK-NEXT: 5: [B8.2].~A() (Implicit destructor) // CHECK-NEXT: Preds (2): B2 B5 // CHECK-NEXT: Succs (1): B0 // CHECK: [B2] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B2.2], class A) // CHECK-NEXT: 2: A d; // CHECK-NEXT: 3: [B2.2].~A() (Implicit destructor) // CHECK-NEXT: 4: [B4.2].~A() (Implicit destructor) @@ -268,7 +588,8 @@ void test_if_implicit_scope() { // CHECK-NEXT: Preds (1): B4 // CHECK-NEXT: Succs (1): B0 // CHECK: [B4] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B4.2], class A) // CHECK-NEXT: 2: A c; // CHECK-NEXT: 3: UV // CHECK-NEXT: 4: [B4.3] (ImplicitCastExpr, LValueToRValue, _Bool) @@ -276,7 +597,8 @@ void test_if_implicit_scope() { // CHECK-NEXT: Preds (1): B8 // CHECK-NEXT: Succs (2): B3 B2 // CHECK: [B5] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B5.2], class A) // CHECK-NEXT: 2: A d; // CHECK-NEXT: 3: [B5.2].~A() (Implicit destructor) // CHECK-NEXT: 4: [B7.2].~A() (Implicit destructor) @@ -290,7 +612,8 @@ void test_if_implicit_scope() { // CHECK-NEXT: Preds (1): B7 // CHECK-NEXT: Succs (1): B0 // CHECK: [B7] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B7.2], class A) // CHECK-NEXT: 2: A c; // CHECK-NEXT: 3: UV // CHECK-NEXT: 4: [B7.3] (ImplicitCastExpr, LValueToRValue, _Bool) @@ -298,11 +621,13 @@ void test_if_implicit_scope() { // CHECK-NEXT: Preds (1): B8 // CHECK-NEXT: Succs (2): B6 B5 // CHECK: [B8] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B8.2], class A) // CHECK-NEXT: 2: A a; // CHECK-NEXT: 3: a // CHECK-NEXT: 4: [B8.3] (ImplicitCastExpr, NoOp, const class A) -// CHECK-NEXT: 5: [B8.4] (CXXConstructExpr, class A) +// WARNINGS-NEXT: 5: [B8.4] (CXXConstructExpr, class A) +// ANALYZER-NEXT: 5: [B8.4] (CXXConstructExpr, [B8.6], class A) // CHECK-NEXT: 6: A b = a; // CHECK-NEXT: 7: b // CHECK-NEXT: 8: [B8.7] (ImplicitCastExpr, NoOp, const class A) @@ -340,7 +665,8 @@ void test_if_jumps() { // CHECK-NEXT: Preds (1): B3 // CHECK-NEXT: Succs (1): B4 // CHECK: [B3] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B3.2], class A) // CHECK-NEXT: 2: A c; // CHECK-NEXT: 3: [B3.2].~A() (Implicit destructor) // CHECK-NEXT: 4: [B4.4].~A() (Implicit destructor) @@ -349,7 +675,8 @@ void test_if_jumps() { // CHECK: [B4] // CHECK-NEXT: 1: a // CHECK-NEXT: 2: [B4.1] (ImplicitCastExpr, NoOp, const class A) -// CHECK-NEXT: 3: [B4.2] (CXXConstructExpr, class A) +// WARNINGS-NEXT: 3: [B4.2] (CXXConstructExpr, class A) +// ANALYZER-NEXT: 3: [B4.2] (CXXConstructExpr, [B4.4], class A) // CHECK-NEXT: 4: A b = a; // CHECK-NEXT: 5: b // CHECK-NEXT: 6: [B4.5] (ImplicitCastExpr, NoOp, const class A) @@ -361,7 +688,8 @@ void test_if_jumps() { // CHECK-NEXT: Preds (2): B2 B5 // CHECK-NEXT: Succs (2): B3 B1 // CHECK: [B5] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B5.2], class A) // CHECK-NEXT: 2: A a; // CHECK-NEXT: Preds (1): B6 // CHECK-NEXT: Succs (1): B4 @@ -377,7 +705,8 @@ void test_while_implicit_scope() { // CHECK-NEXT: Succs (1): B11 // CHECK: [B1] // CHECK-NEXT: 1: [B10.4].~A() (Implicit destructor) -// CHECK-NEXT: 2: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 2: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 2: (CXXConstructExpr, [B1.3], class A) // CHECK-NEXT: 3: A e; // CHECK-NEXT: 4: [B1.3].~A() (Implicit destructor) // CHECK-NEXT: 5: [B11.2].~A() (Implicit destructor) @@ -387,7 +716,8 @@ void test_while_implicit_scope() { // CHECK-NEXT: Preds (2): B3 B6 // CHECK-NEXT: Succs (1): B10 // CHECK: [B3] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B3.2], class A) // CHECK-NEXT: 2: A d; // CHECK-NEXT: 3: [B3.2].~A() (Implicit destructor) // CHECK-NEXT: 4: [B9.2].~A() (Implicit destructor) @@ -425,7 +755,8 @@ void test_while_implicit_scope() { // CHECK: Preds (1): B9 // CHECK-NEXT: Succs (1): B1 // CHECK: [B9] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B9.2], class A) // CHECK-NEXT: 2: A c; // CHECK-NEXT: 3: UV // CHECK-NEXT: 4: [B9.3] (ImplicitCastExpr, LValueToRValue, _Bool) @@ -435,7 +766,8 @@ void test_while_implicit_scope() { // CHECK: [B10] // CHECK-NEXT: 1: a // CHECK-NEXT: 2: [B10.1] (ImplicitCastExpr, NoOp, const class A) -// CHECK-NEXT: 3: [B10.2] (CXXConstructExpr, class A) +// WARNINGS-NEXT: 3: [B10.2] (CXXConstructExpr, class A) +// ANALYZER-NEXT: 3: [B10.2] (CXXConstructExpr, [B10.4], class A) // CHECK-NEXT: 4: A b = a; // CHECK-NEXT: 5: b // CHECK-NEXT: 6: [B10.5] (ImplicitCastExpr, NoOp, const class A) @@ -447,7 +779,8 @@ void test_while_implicit_scope() { // CHECK-NEXT: Preds (2): B2 B11 // CHECK-NEXT: Succs (2): B9 B1 // CHECK: [B11] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B11.2], class A) // CHECK-NEXT: 2: A a; // CHECK-NEXT: Preds (1): B12 // CHECK-NEXT: Succs (1): B10 @@ -474,7 +807,8 @@ void test_while_jumps() { // CHECK-NEXT: Preds (1): B2 // CHECK-NEXT: Succs (2): B3 B0 // CHECK: [B2] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B2.2], class A) // CHECK-NEXT: 2: A a; // CHECK-NEXT: 3: [B2.2].~A() (Implicit destructor) // CHECK-NEXT: Preds (2): B3 B4 @@ -492,7 +826,8 @@ void test_do_implicit_scope() { // CHECK: [B12 (ENTRY)] // CHECK-NEXT: Succs (1): B11 // CHECK: [B1] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B1.2], class A) // CHECK-NEXT: 2: A d; // CHECK-NEXT: 3: [B1.2].~A() (Implicit destructor) // CHECK-NEXT: 4: [B11.2].~A() (Implicit destructor) @@ -505,7 +840,8 @@ void test_do_implicit_scope() { // CHECK-NEXT: Preds (2): B3 B6 // CHECK-NEXT: Succs (2): B10 B1 // CHECK: [B3] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B3.2], class A) // CHECK-NEXT: 2: A c; // CHECK-NEXT: 3: [B3.2].~A() (Implicit destructor) // CHECK-NEXT: 4: [B9.2].~A() (Implicit destructor) @@ -540,7 +876,8 @@ void test_do_implicit_scope() { // CHECK: Preds (1): B9 // CHECK-NEXT: Succs (1): B1 // CHECK: [B9] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B9.2], class A) // CHECK-NEXT: 2: A b; // CHECK-NEXT: 3: UV // CHECK-NEXT: 4: [B9.3] (ImplicitCastExpr, LValueToRValue, _Bool) @@ -551,7 +888,8 @@ void test_do_implicit_scope() { // CHECK-NEXT: Preds (1): B2 // CHECK-NEXT: Succs (1): B9 // CHECK: [B11] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B11.2], class A) // CHECK-NEXT: 2: A a; // CHECK-NEXT: Preds (1): B12 // CHECK-NEXT: Succs (1): B9 @@ -577,7 +915,8 @@ void test_do_jumps() { // CHECK-NEXT: Preds (2): B3 B2 // CHECK-NEXT: Succs (1): B0 // CHECK: [B2] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B2.2], class A) // CHECK-NEXT: 2: A a; // CHECK-NEXT: 3: a // CHECK-NEXT: 4: [B2.3] (ImplicitCastExpr, NoOp, const class A) @@ -592,7 +931,8 @@ void test_do_jumps() { // CHECK-NEXT: Preds (1): B4 // CHECK-NEXT: Succs (1): B1 // CHECK: [B3] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B3.2], class A) // CHECK-NEXT: 2: A c; // CHECK-NEXT: 3: [B3.2].~A() (Implicit destructor) // CHECK-NEXT: Succs (1): B1 @@ -608,14 +948,16 @@ void test_switch_implicit_scope() { // CHECK-NEXT: Succs (1): B2 // CHECK: [B1] // CHECK-NEXT: 1: [B2.6].~A() (Implicit destructor) -// CHECK-NEXT: 2: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 2: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 2: (CXXConstructExpr, [B1.3], class A) // CHECK-NEXT: 3: A g; // CHECK-NEXT: 4: [B1.3].~A() (Implicit destructor) // CHECK-NEXT: 5: [B2.2].~A() (Implicit destructor) // CHECK-NEXT: Preds (3): B3 B7 B2 // CHECK-NEXT: Succs (1): B0 // CHECK: [B2] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B2.2], class A) // CHECK-NEXT: 2: A a; // CHECK-NEXT: 3: a // CHECK-NEXT: 4: [B2.3] (ImplicitCastExpr, NoOp, const class A) @@ -635,7 +977,8 @@ void test_switch_implicit_scope() { // CHECK: Preds (2): B2 B4 // CHECK-NEXT: Succs (1): B1 // CHECK: [B4] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B4.2], class A) // CHECK-NEXT: 2: A f; // CHECK-NEXT: 3: [B4.2].~A() (Implicit destructor) // CHECK-NEXT: 4: [B8.2].~A() (Implicit destructor) @@ -661,7 +1004,8 @@ void test_switch_implicit_scope() { // CHECK-NEXT: Succs (1): B1 // CHECK: [B8] // CHECK: case 0: -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B8.2], class A) // CHECK-NEXT: 2: A c; // CHECK-NEXT: 3: UV // CHECK-NEXT: 4: [B8.3] (ImplicitCastExpr, LValueToRValue, _Bool) @@ -696,7 +1040,8 @@ void test_switch_jumps() { // CHECK-NEXT: Preds (1): B3 // CHECK-NEXT: Succs (1): B4 // CHECK: [B3] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B3.2], class A) // CHECK-NEXT: 2: A c; // CHECK-NEXT: 3: [B3.2].~A() (Implicit destructor) // CHECK-NEXT: 4: [B4.4].~A() (Implicit destructor) @@ -705,7 +1050,8 @@ void test_switch_jumps() { // CHECK: [B4] // CHECK-NEXT: 1: a // CHECK-NEXT: 2: [B4.1] (ImplicitCastExpr, NoOp, const class A) -// CHECK-NEXT: 3: [B4.2] (CXXConstructExpr, class A) +// WARNINGS-NEXT: 3: [B4.2] (CXXConstructExpr, class A) +// ANALYZER-NEXT: 3: [B4.2] (CXXConstructExpr, [B4.4], class A) // CHECK-NEXT: 4: A b = a; // CHECK-NEXT: 5: b // CHECK-NEXT: 6: [B4.5] (ImplicitCastExpr, NoOp, const class A) @@ -717,7 +1063,8 @@ void test_switch_jumps() { // CHECK-NEXT: Preds (2): B2 B5 // CHECK-NEXT: Succs (2): B3 B1 // CHECK: [B5] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B5.2], class A) // CHECK-NEXT: 2: A a; // CHECK-NEXT: Preds (1): B6 // CHECK-NEXT: Succs (1): B4 @@ -733,7 +1080,8 @@ void test_for_implicit_scope() { // CHECK: [B1] // CHECK-NEXT: 1: [B10.4].~A() (Implicit destructor) // CHECK-NEXT: 2: [B11.4].~A() (Implicit destructor) -// CHECK-NEXT: 3: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 3: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 3: (CXXConstructExpr, [B1.4], class A) // CHECK-NEXT: 4: A f; // CHECK-NEXT: 5: [B1.4].~A() (Implicit destructor) // CHECK-NEXT: 6: [B11.2].~A() (Implicit destructor) @@ -743,7 +1091,8 @@ void test_for_implicit_scope() { // CHECK-NEXT: Preds (2): B3 B6 // CHECK-NEXT: Succs (1): B10 // CHECK: [B3] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B3.2], class A) // CHECK-NEXT: 2: A e; // CHECK-NEXT: 3: [B3.2].~A() (Implicit destructor) // CHECK-NEXT: 4: [B9.2].~A() (Implicit destructor) @@ -781,7 +1130,8 @@ void test_for_implicit_scope() { // CHECK: Preds (1): B9 // CHECK-NEXT: Succs (1): B1 // CHECK: [B9] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B9.2], class A) // CHECK-NEXT: 2: A d; // CHECK-NEXT: 3: UV // CHECK-NEXT: 4: [B9.3] (ImplicitCastExpr, LValueToRValue, _Bool) @@ -791,7 +1141,8 @@ void test_for_implicit_scope() { // CHECK: [B10] // CHECK-NEXT: 1: b // CHECK-NEXT: 2: [B10.1] (ImplicitCastExpr, NoOp, const class A) -// CHECK-NEXT: 3: [B10.2] (CXXConstructExpr, class A) +// WARNINGS-NEXT: 3: [B10.2] (CXXConstructExpr, class A) +// ANALYZER-NEXT: 3: [B10.2] (CXXConstructExpr, [B10.4], class A) // CHECK-NEXT: 4: A c = b; // CHECK-NEXT: 5: c // CHECK-NEXT: 6: [B10.5] (ImplicitCastExpr, NoOp, const class A) @@ -803,9 +1154,11 @@ void test_for_implicit_scope() { // CHECK-NEXT: Preds (2): B2 B11 // CHECK-NEXT: Succs (2): B9 B1 // CHECK: [B11] -// CHECK-NEXT: 1: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 1: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 1: (CXXConstructExpr, [B11.2], class A) // CHECK-NEXT: 2: A a; -// CHECK-NEXT: 3: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 3: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 3: (CXXConstructExpr, [B11.4], class A) // CHECK-NEXT: 4: A b; // CHECK-NEXT: Preds (1): B12 // CHECK-NEXT: Succs (1): B10 diff --git a/test/Analysis/autoreleasewritechecker_test.m b/test/Analysis/autoreleasewritechecker_test.m new file mode 100644 index 000000000000..b3d34b9b11fa --- /dev/null +++ b/test/Analysis/autoreleasewritechecker_test.m @@ -0,0 +1,281 @@ +// UNSUPPORTED: system-windows +// RUN: %clang_analyze_cc1 -DARC -fobjc-arc -analyzer-checker=core,osx.cocoa.AutoreleaseWrite %s -triple x86_64-darwin -fblocks -verify +// RUN: %clang_analyze_cc1 -DNOARC -analyzer-checker=core,osx.cocoa.AutoreleaseWrite %s -fblocks -triple x86_64-darwin -verify + + +typedef signed char BOOL; +#define YES ((BOOL)1) +@protocol NSObject - (BOOL)isEqual:(id)object; @end +@interface NSObject <NSObject> {} ++(id)alloc; +-(id)init; +-(id)autorelease; +-(id)copy; +-(id)retain; +@end +typedef int NSZone; +typedef int NSCoder; +typedef unsigned long NSUInteger; + +@protocol NSCopying - (id)copyWithZone:(NSZone *)zone; @end +@protocol NSCoding - (void)encodeWithCoder:(NSCoder *)aCoder; @end +@interface NSError : NSObject <NSCopying, NSCoding> {} ++ (id)errorWithDomain:(int)domain; +@end + +typedef int dispatch_semaphore_t; +typedef void (^block_t)(); + +typedef enum { + NSEnumerationConcurrent = (1UL << 0), + NSEnumerationReverse = (1UL << 1) +} NSEnumerationOptions; + +@interface NSArray +- (void)enumerateObjectsUsingBlock:(block_t)block; +@end + +@interface NSSet +- (void)objectsPassingTest:(block_t)block; +@end + +@interface NSDictionary +- (void)enumerateKeysAndObjectsUsingBlock:(block_t)block; +@end + +@interface NSIndexSet +- (void)indexesPassingTest:(block_t)block; +- (NSUInteger)indexWithOptions:(NSEnumerationOptions)opts + passingTest:(BOOL (^)(NSUInteger idx, BOOL *stop))predicate; +@end + +typedef int group_t; +typedef struct dispatch_queue_s *dispatch_queue_t; +typedef void (^dispatch_block_t)(void); +extern dispatch_queue_t queue; + +void dispatch_group_async(dispatch_queue_t queue, + group_t group, + dispatch_block_t block); +void dispatch_async(dispatch_queue_t queue, dispatch_block_t block); +dispatch_semaphore_t dispatch_semaphore_create(int); + +void dispatch_semaphore_wait(dispatch_semaphore_t, int); +void dispatch_semaphore_signal(dispatch_semaphore_t); + +// No warnings without ARC. +#ifdef NOARC + +// expected-no-diagnostics +BOOL writeToErrorWithIterator(NSError ** error, NSArray *a) { + [a enumerateObjectsUsingBlock:^{ + *error = [NSError errorWithDomain:1]; // no-warning + }]; + return 0; +} +#endif + +#ifdef ARC +@interface I : NSObject +- (BOOL) writeToStrongErrorInBlock:(NSError *__strong *)error; +- (BOOL) writeToErrorInBlock:(NSError *__autoreleasing *)error; +- (BOOL) writeToLocalErrorInBlock:(NSError **)error; +- (BOOL) writeToErrorInBlockMultipleTimes:(NSError *__autoreleasing *)error; +- (BOOL) writeToError:(NSError *__autoreleasing *)error; +- (BOOL) writeToErrorWithDispatchGroup:(NSError *__autoreleasing *)error; +@end + +@implementation I + +- (BOOL) writeToErrorInBlock:(NSError *__autoreleasing *)error { + dispatch_semaphore_t sem = dispatch_semaphore_create(0l); + dispatch_async(queue, ^{ + if (error) { + *error = [NSError errorWithDomain:1]; // expected-warning{{Write to autoreleasing out parameter inside autorelease pool that may exit before method returns; consider writing first to a strong local variable declared outside of the block}} + } + dispatch_semaphore_signal(sem); + }); + + dispatch_semaphore_wait(sem, 100); + return 0; +} + +- (BOOL) writeToErrorWithDispatchGroup:(NSError *__autoreleasing *)error { + dispatch_semaphore_t sem = dispatch_semaphore_create(0l); + dispatch_group_async(queue, 0, ^{ + if (error) { + *error = [NSError errorWithDomain:1]; // expected-warning{{Write to autoreleasing out parameter inside autorelease pool that may exit before method returns; consider writing first to a strong local variable declared outside of the block}} + } + dispatch_semaphore_signal(sem); + }); + + dispatch_semaphore_wait(sem, 100); + return 0; +} + +- (BOOL) writeToLocalErrorInBlock:(NSError *__autoreleasing *)error { + dispatch_semaphore_t sem = dispatch_semaphore_create(0l); + dispatch_async(queue, ^{ + NSError* error2; + NSError*__strong* error3 = &error2; + if (error) { + *error3 = [NSError errorWithDomain:1]; // no-warning + } + dispatch_semaphore_signal(sem); + }); + + dispatch_semaphore_wait(sem, 100); + return 0; +} + +- (BOOL) writeToStrongErrorInBlock:(NSError *__strong *)error { + dispatch_semaphore_t sem = dispatch_semaphore_create(0l); + dispatch_async(queue, ^{ + if (error) { + *error = [NSError errorWithDomain:2]; // no-warning + } + dispatch_semaphore_signal(sem); + }); + + dispatch_semaphore_wait(sem, 100); + return 0; +} + +- (BOOL) writeToErrorInBlockMultipleTimes:(NSError *__autoreleasing *)error { + dispatch_semaphore_t sem = dispatch_semaphore_create(0l); + dispatch_async(queue, ^{ + if (error) { + *error = [NSError errorWithDomain:1]; // expected-warning{{Write to autoreleasing out parameter inside autorelease pool that may exit before method returns; consider writing first to a strong local variable declared outside of the block}} + } + dispatch_semaphore_signal(sem); + }); + dispatch_async(queue, ^{ + if (error) { + *error = [NSError errorWithDomain:1]; // expected-warning{{Write to autoreleasing out parameter inside autorelease pool that may exit before method returns; consider writing first to a strong local variable declared outside of the block}} + *error = [NSError errorWithDomain:1]; // expected-warning{{Write to autoreleasing out parameter inside autorelease pool that may exit before method returns; consider writing first to a strong local variable declared outside of the block}} + } + dispatch_semaphore_signal(sem); + }); + *error = [NSError errorWithDomain:1]; // no-warning + + dispatch_semaphore_wait(sem, 100); + return 0; +} + +- (BOOL) writeToError:(NSError *__autoreleasing *)error { + *error = [NSError errorWithDomain:1]; // no-warning + return 0; +} +@end + +BOOL writeToErrorInBlockFromCFunc(NSError *__autoreleasing* error) { + dispatch_semaphore_t sem = dispatch_semaphore_create(0l); + dispatch_async(queue, ^{ + if (error) { + *error = [NSError errorWithDomain:1]; // expected-warning{{Write to autoreleasing out parameter inside autorelease pool that may exit before function returns; consider writing first to a strong local variable declared outside of the block}} + } + dispatch_semaphore_signal(sem); + }); + + dispatch_semaphore_wait(sem, 100); + return 0; +} + +BOOL writeToErrorNoWarning(NSError *__autoreleasing* error) { + *error = [NSError errorWithDomain:1]; // no-warning + return 0; +} + +BOOL writeToErrorWithIterator(NSError *__autoreleasing* error, NSArray *a, NSSet *s, NSDictionary *d, NSIndexSet *i) { [a enumerateObjectsUsingBlock:^{ + *error = [NSError errorWithDomain:1]; // expected-warning{{Write to autoreleasing out parameter inside autorelease pool that may exit before function returns; consider writing first to a strong local variable declared outside of the block}} + }]; + [d enumerateKeysAndObjectsUsingBlock:^{ + *error = [NSError errorWithDomain:1]; // expected-warning{{Write to autoreleasing out parameter inside autorelease pool that may exit before function returns; consider writing first to a strong local variable declared outside of the block}} + }]; + [s objectsPassingTest:^{ + *error = [NSError errorWithDomain:1]; // expected-warning{{Write to autoreleasing out parameter inside autorelease pool that may exit before function returns; consider writing first to a strong local variable declared outside of the block}} + }]; + [i indexesPassingTest:^{ + *error = [NSError errorWithDomain:1]; // expected-warning{{Write to autoreleasing out parameter inside autorelease pool that may exit before function returns; consider writing first to a strong local variable declared outside of the block}} + }]; + [i indexWithOptions: NSEnumerationReverse passingTest:^(NSUInteger idx, BOOL *stop) { + *error = [NSError errorWithDomain:1]; // expected-warning{{Write to autoreleasing out parameter inside autorelease pool that may exit before function returns; consider writing first to a strong local variable declared outside of the block}} + return YES; + }]; + return 0; +} + +void writeIntoError(NSError **error) { + *error = [NSError errorWithDomain:1]; +} + +extern void readError(NSError *error); + +void writeToErrorWithIteratorNonnull(NSError *__autoreleasing* _Nonnull error, NSDictionary *a) { + [a enumerateKeysAndObjectsUsingBlock:^{ + *error = [NSError errorWithDomain:1]; // expected-warning{{Write to autoreleasing out parameter}} + }]; +} + + +void escapeErrorFromIterator(NSError *__autoreleasing* _Nonnull error, NSDictionary *a) { + [a enumerateKeysAndObjectsUsingBlock:^{ + writeIntoError(error); // expected-warning{{Capture of autoreleasing out parameter}} + }]; +} + +void noWarningOnRead(NSError *__autoreleasing* error, NSDictionary *a) { + [a enumerateKeysAndObjectsUsingBlock:^{ + NSError* local = *error; // no-warning + }]; +} + +void noWarningOnEscapeRead(NSError *__autoreleasing* error, NSDictionary *a) { + [a enumerateKeysAndObjectsUsingBlock:^{ + readError(*error); // no-warning + }]; +} + +@interface ErrorCapture +- (void) captureErrorOut:(NSError**) error; +- (void) captureError:(NSError*) error; +@end + +void escapeErrorFromIteratorMethod(NSError *__autoreleasing* _Nonnull error, + NSDictionary *a, + ErrorCapture *capturer) { + [a enumerateKeysAndObjectsUsingBlock:^{ + [capturer captureErrorOut:error]; // expected-warning{{Capture of autoreleasing out parameter}} + }]; +} + +void noWarningOnEscapeReadMethod(NSError *__autoreleasing* error, + NSDictionary *a, + ErrorCapture *capturer) { + [a enumerateKeysAndObjectsUsingBlock:^{ + [capturer captureError:*error]; // no-warning + }]; +} + +void multipleErrors(NSError *__autoreleasing* error, NSDictionary *a) { + [a enumerateKeysAndObjectsUsingBlock:^{ + writeIntoError(error); // expected-warning{{Capture of autoreleasing out parameter}} + *error = [NSError errorWithDomain:1]; // expected-warning{{Write to autoreleasing out parameter}} + writeIntoError(error); // expected-warning{{Capture of autoreleasing out parameter}} + }]; +} + +typedef void (^errBlock)(NSError *__autoreleasing *error); + +extern void expectError(errBlock); + +void captureAutoreleasingVarFromBlock(NSDictionary *dict) { + expectError(^(NSError *__autoreleasing *err) { + [dict enumerateKeysAndObjectsUsingBlock:^{ + writeIntoError(err); // expected-warning{{Capture of autoreleasing out parameter 'err'}} + }]; + }); +} + +#endif + diff --git a/test/Analysis/bitwise-ops.c b/test/Analysis/bitwise-ops.c index fe546580be3d..fcd3d7dbc7cf 100644 --- a/test/Analysis/bitwise-ops.c +++ b/test/Analysis/bitwise-ops.c @@ -8,9 +8,8 @@ void testPersistentConstraints(int x, int y) { CHECK(x); // expected-warning{{TRUE}} CHECK(x & 1); // expected-warning{{TRUE}} - // False positives due to SValBuilder giving up on certain kinds of exprs. - CHECK(1 - x); // expected-warning{{UNKNOWN}} - CHECK(x & y); // expected-warning{{UNKNOWN}} + CHECK(1 - x); // expected-warning{{TRUE}} + CHECK(x & y); // expected-warning{{TRUE}} } int testConstantShifts_PR18073(int which) { @@ -51,3 +50,9 @@ int testNegativeLeftShift(int a) { } return 0; } + +int testUnrepresentableLeftShift(int a) { + if (a == 8) + return a << 30; // expected-warning{{The result of the left shift is undefined due to shifting '8' by '30', which is unrepresentable in the unsigned version of the return type 'int'}} + return 0; +} diff --git a/test/Analysis/blocks.mm b/test/Analysis/blocks.mm index 6cff9b47f169..8a3f1708514e 100644 --- a/test/Analysis/blocks.mm +++ b/test/Analysis/blocks.mm @@ -1,6 +1,17 @@ // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core -fblocks -analyzer-opt-analyze-nested-blocks -verify -x objective-c++ %s -// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,debug.DumpCFG -fblocks -analyzer-opt-analyze-nested-blocks %s > %t 2>&1 -// RUN: FileCheck --input-file=%t %s +// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,debug.DumpCFG -fblocks -analyzer-opt-analyze-nested-blocks -analyzer-config cfg-rich-constructors=false %s > %t 2>&1 +// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,WARNINGS %s +// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,debug.DumpCFG -fblocks -analyzer-opt-analyze-nested-blocks -analyzer-config cfg-rich-constructors=true %s > %t 2>&1 +// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,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. // expected-no-diagnostics @@ -64,7 +75,8 @@ void testBlockWithCaptureByReference() { // CHECK: [B1] // CHECK-NEXT: 1: 5 -// CHECK-NEXT: 2: [B1.1] (CXXConstructExpr, struct StructWithCopyConstructor) +// WARNINGS-NEXT: 2: [B1.1] (CXXConstructExpr, struct StructWithCopyConstructor) +// ANALYZER-NEXT: 2: [B1.1] (CXXConstructExpr, [B1.3], struct StructWithCopyConstructor) // CHECK-NEXT: 3: StructWithCopyConstructor s(5) __attribute__((blocks("byref"))); // CHECK-NEXT: 4: ^{ } // CHECK-NEXT: 5: (void)([B1.4]) (CStyleCastExpr, ToVoid, void) diff --git a/test/Analysis/bool-increment.cpp b/test/Analysis/bool-increment.cpp new file mode 100644 index 000000000000..93002d3b61ec --- /dev/null +++ b/test/Analysis/bool-increment.cpp @@ -0,0 +1,84 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.ExprInspection -verify -std=c++98 -Wno-deprecated %s +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.ExprInspection -verify -std=c++11 -Wno-deprecated %s +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.ExprInspection -verify -std=c++14 -Wno-deprecated %s + +extern void clang_analyzer_eval(bool); + +void test_bool_value() { + { + bool b = true; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = false; + clang_analyzer_eval(b == 0); // expected-warning{{TRUE}} + } + + { + bool b = -10; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = 10; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = 10; + b++; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } + + { + bool b = 0; + b++; + clang_analyzer_eval(b == 1); // expected-warning{{TRUE}} + } +} + +void test_bool_increment() { + { + bool b = true; + b++; + clang_analyzer_eval(b); // expected-warning{{TRUE}} + } + + { + bool b = false; + b++; + clang_analyzer_eval(b); // expected-warning{{TRUE}} + } + + { + bool b = true; + ++b; + clang_analyzer_eval(b); // expected-warning{{TRUE}} + } + + { + bool b = false; + ++b; + clang_analyzer_eval(b); // expected-warning{{TRUE}} + } + + { + bool b = 0; + ++b; + clang_analyzer_eval(b); // expected-warning{{TRUE}} + } + + { + bool b = 10; + ++b; + ++b; + clang_analyzer_eval(b); // expected-warning{{TRUE}} + } + + { + bool b = -10; + ++b; + clang_analyzer_eval(b); // expected-warning{{TRUE}} + } +} diff --git a/test/Analysis/bsd-string.c b/test/Analysis/bsd-string.c new file mode 100644 index 000000000000..bca42ca89643 --- /dev/null +++ b/test/Analysis/bsd-string.c @@ -0,0 +1,45 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.cstring.NullArg,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify %s + +#define NULL ((void *)0) + +typedef __typeof(sizeof(int)) size_t; +size_t strlcpy(char *dst, const char *src, size_t n); +size_t strlcat(char *dst, const char *src, size_t n); +void clang_analyzer_eval(int); + +void f1() { + char overlap[] = "123456789"; + strlcpy(overlap, overlap + 1, 3); // expected-warning{{Arguments must not be overlapping buffers}} +} + +void f2() { + char buf[5]; + strlcpy(buf, "abcd", sizeof(buf)); // expected-no-warning + strlcat(buf, "efgh", sizeof(buf)); // expected-warning{{Size argument is greater than the free space in the destination buffer}} +} + +void f3() { + char dst[2]; + const char *src = "abdef"; + strlcpy(dst, src, 5); // expected-warning{{Size argument is greater than the length of the destination buffer}} +} + +void f4() { + strlcpy(NULL, "abcdef", 6); // expected-warning{{Null pointer argument in call to string copy function}} +} + +void f5() { + strlcat(NULL, "abcdef", 6); // expected-warning{{Null pointer argument in call to string copy function}} +} + +void f6() { + char buf[8]; + strlcpy(buf, "abc", 3); + size_t len = strlcat(buf, "defg", 4); + clang_analyzer_eval(len == 7); // expected-warning{{TRUE}} +} + +int f7() { + char buf[8]; + return strlcpy(buf, "1234567", 0); // no-crash +} diff --git a/test/Analysis/bstring.c b/test/Analysis/bstring.c index a671d9ee8d4e..89a77cdff866 100644 --- a/test/Analysis/bstring.c +++ b/test/Analysis/bstring.c @@ -474,3 +474,12 @@ char radar_11125445_memcopythenlogfirstbyte(const char *input, size_t length) { free(bytes); return x; } + +struct S { + char f; +}; + +void nocrash_on_locint_offset(void *addr, void* from, struct S s) { + int iAdd = (int) addr; + memcpy(((void *) &(s.f)), from, iAdd); +} diff --git a/test/Analysis/bstring.cpp b/test/Analysis/bstring.cpp index fea76cc082fa..19978f913cb1 100644 --- a/test/Analysis/bstring.cpp +++ b/test/Analysis/bstring.cpp @@ -1,7 +1,8 @@ -// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify %s -// RUN: %clang_analyze_cc1 -DUSE_BUILTINS -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify %s -// RUN: %clang_analyze_cc1 -DVARIANT -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify %s -// RUN: %clang_analyze_cc1 -DUSE_BUILTINS -DVARIANT -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify %s +// RUN: %clang_analyze_cc1 -DUSE_BUILTINS -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify %s +// RUN: %clang_analyze_cc1 -DVARIANT -analyzer-checker=core,unix.cstring,alpha.unix.cstring,unix.Malloc,debug.ExprInspection -analyzer-store=region -verify %s +// RUN: %clang_analyze_cc1 -DUSE_BUILTINS -DVARIANT -analyzer-checker=core,unix.cstring,alpha.unix.cstring,unix.Malloc,debug.ExprInspection -analyzer-store=region -verify %s +// RUN: %clang_analyze_cc1 -DSUPPRESS_OUT_OF_BOUND -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring.BufferOverlap,alpha.unix.cstring.NotNullTerminated,debug.ExprInspection -analyzer-store=region -verify %s #include "Inputs/system-header-simulator-cxx.h" #include "Inputs/system-header-simulator-for-malloc.h" @@ -77,3 +78,118 @@ class b { unsigned *f; }; } + +void *memset(void *dest, int ch, std::size_t count); +namespace memset_non_pod { +class Base { +public: + int b_mem; + Base() : b_mem(1) {} +}; + +class Derived : public Base { +public: + int d_mem; + Derived() : d_mem(2) {} +}; + +void memset1_inheritance() { + Derived d; + memset(&d, 0, sizeof(Derived)); + clang_analyzer_eval(d.b_mem == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(d.d_mem == 0); // expected-warning{{TRUE}} +} + +#ifdef SUPPRESS_OUT_OF_BOUND +void memset2_inheritance_field() { + Derived d; + memset(&d.d_mem, 0, sizeof(Derived)); + clang_analyzer_eval(d.b_mem == 0); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(d.d_mem == 0); // expected-warning{{UNKNOWN}} +} + +void memset3_inheritance_field() { + Derived d; + memset(&d.b_mem, 0, sizeof(Derived)); + clang_analyzer_eval(d.b_mem == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(d.d_mem == 0); // expected-warning{{TRUE}} +} +#endif + +void memset4_array_nonpod_object() { + Derived array[10]; + clang_analyzer_eval(array[1].b_mem == 1); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(array[1].d_mem == 2); // expected-warning{{UNKNOWN}} + memset(&array[1], 0, sizeof(Derived)); + clang_analyzer_eval(array[1].b_mem == 0); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(array[1].d_mem == 0); // expected-warning{{UNKNOWN}} +} + +void memset5_array_nonpod_object() { + Derived array[10]; + clang_analyzer_eval(array[1].b_mem == 1); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(array[1].d_mem == 2); // expected-warning{{UNKNOWN}} + memset(array, 0, sizeof(array)); + clang_analyzer_eval(array[1].b_mem == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(array[1].d_mem == 0); // expected-warning{{TRUE}} +} + +void memset6_new_array_nonpod_object() { + Derived *array = new Derived[10]; + clang_analyzer_eval(array[2].b_mem == 1); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(array[2].d_mem == 2); // expected-warning{{UNKNOWN}} + memset(array, 0, 10 * sizeof(Derived)); + clang_analyzer_eval(array[2].b_mem == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(array[2].d_mem == 0); // expected-warning{{TRUE}} + delete[] array; +} + +void memset7_placement_new() { + Derived *d = new Derived(); + clang_analyzer_eval(d->b_mem == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(d->d_mem == 2); // expected-warning{{TRUE}} + + memset(d, 0, sizeof(Derived)); + clang_analyzer_eval(d->b_mem == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(d->d_mem == 0); // expected-warning{{TRUE}} + + Derived *d1 = new (d) Derived(); + clang_analyzer_eval(d1->b_mem == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(d1->d_mem == 2); // expected-warning{{TRUE}} + + memset(d1, 0, sizeof(Derived)); + clang_analyzer_eval(d->b_mem == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(d->d_mem == 0); // expected-warning{{TRUE}} +} + +class BaseVirtual { +public: + int b_mem; + virtual int get() { return 1; } +}; + +class DerivedVirtual : public BaseVirtual { +public: + int d_mem; +}; + +#ifdef SUPPRESS_OUT_OF_BOUND +void memset8_virtual_inheritance_field() { + DerivedVirtual d; + memset(&d.b_mem, 0, sizeof(Derived)); + clang_analyzer_eval(d.b_mem == 0); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(d.d_mem == 0); // expected-warning{{UNKNOWN}} +} +#endif +} // namespace memset_non_pod + +#ifdef SUPPRESS_OUT_OF_BOUND +void memset1_new_array() { + int *array = new int[10]; + memset(array, 0, 10 * sizeof(int)); + clang_analyzer_eval(array[2] == 0); // expected-warning{{TRUE}} + memset(array + 1, 'a', 10 * sizeof(9)); + clang_analyzer_eval(array[2] == 0); // expected-warning{{UNKNOWN}} + delete[] array; +} +#endif diff --git a/test/Analysis/builtin-functions.cpp b/test/Analysis/builtin-functions.cpp index 2c1950251145..19984963b4fa 100644 --- a/test/Analysis/builtin-functions.cpp +++ b/test/Analysis/builtin-functions.cpp @@ -64,3 +64,20 @@ void g(int i) { // We give up the analysis on this path. } } + +void test_constant_p() { + int i = 1; + const int j = 2; + constexpr int k = 3; + clang_analyzer_eval(__builtin_constant_p(42) == 1); // expected-warning {{TRUE}} + clang_analyzer_eval(__builtin_constant_p(i) == 0); // expected-warning {{TRUE}} + clang_analyzer_eval(__builtin_constant_p(j) == 1); // expected-warning {{TRUE}} + clang_analyzer_eval(__builtin_constant_p(k) == 1); // expected-warning {{TRUE}} + clang_analyzer_eval(__builtin_constant_p(i + 42) == 0); // expected-warning {{TRUE}} + clang_analyzer_eval(__builtin_constant_p(j + 42) == 1); // expected-warning {{TRUE}} + clang_analyzer_eval(__builtin_constant_p(k + 42) == 1); // expected-warning {{TRUE}} + clang_analyzer_eval(__builtin_constant_p(" ") == 1); // expected-warning {{TRUE}} + clang_analyzer_eval(__builtin_constant_p(test_constant_p) == 0); // expected-warning {{TRUE}} + clang_analyzer_eval(__builtin_constant_p(k - 3) == 0); // expected-warning {{FALSE}} + clang_analyzer_eval(__builtin_constant_p(k - 3) == 1); // expected-warning {{TRUE}} +} diff --git a/test/Analysis/call_once.cpp b/test/Analysis/call_once.cpp index db9e5cc7ca16..344de8090787 100644 --- a/test/Analysis/call_once.cpp +++ b/test/Analysis/call_once.cpp @@ -1,16 +1,34 @@ -// RUN: %clang_analyze_cc1 -std=c++11 -fblocks -analyzer-checker=core,debug.ExprInspection -verify %s -// RUN: %clang_analyze_cc1 -std=c++11 -fblocks -analyzer-checker=core,debug.ExprInspection -DEMULATE_LIBSTDCPP -verify %s +// RUN: %clang_analyze_cc1 -std=c++11 -fblocks -analyzer-checker=core,debug.ExprInspection -verify %s -o %t.report +// RUN: %clang_analyze_cc1 -std=c++11 -fblocks -analyzer-checker=core,debug.ExprInspection -DEMULATE_LIBSTDCPP -verify %s -o %t.report // We do NOT model libcxx03 implementation, but the analyzer should still // not crash. -// RUN: %clang_analyze_cc1 -std=c++11 -fblocks -analyzer-checker=core,debug.ExprInspection -DEMULATE_LIBCXX03 -verify %s -// RUN: %clang_analyze_cc1 -std=c++11 -fblocks -analyzer-checker=core,debug.ExprInspection -DEMULATE_LIBCXX03 -DEMULATE_LIBSTDCPP -verify %s +// RUN: %clang_analyze_cc1 -std=c++11 -fblocks -analyzer-checker=core,debug.ExprInspection -DEMULATE_LIBCXX03 -verify %s -o %t.report +// RUN: %clang_analyze_cc1 -std=c++11 -fblocks -analyzer-checker=core,debug.ExprInspection -DEMULATE_LIBCXX03 -DEMULATE_LIBSTDCPP -verify %s -o %t.report +// RUN: rm -rf %t.report void clang_analyzer_eval(bool); -// Faking std::std::call_once implementation. +// Faking std::call_once implementation. namespace std { +// Fake std::function implementation. +template <typename> +class function; +class function_base { + public: + long field; +}; +template <typename R, typename... P> +class function<R(P...)> : function_base { + public: + R operator()(P...) const { + + // Read from a super-class necessary to reproduce a crash. + bool a = field; + } +}; + #ifndef EMULATE_LIBSTDCPP typedef struct once_flag_s { unsigned long __state_ = 0; @@ -359,3 +377,38 @@ void test_implicit_funcptr() { clang_analyzer_eval(x == 42); // expected-warning{{TRUE}} #endif } + +int param_passed(int *x) { + return *x; // no-warning, as std::function is not working yet. +} + +void callback_taking_func_ok(std::function<void(int*)> &innerCallback) { + innerCallback(nullptr); +} + +// The provided callback expects an std::function, but instead a pointer +// to a C++ function is provided. +void callback_with_implicit_cast_ok() { + std::once_flag flag; + call_once(flag, callback_taking_func_ok, ¶m_passed); +} + +void callback_taking_func(std::function<void()> &innerCallback) { + innerCallback(); +} + +// The provided callback expects an std::function, but instead a C function +// name is provided, and C++ implicitly auto-constructs a pointer from it. +void callback_with_implicit_cast() { + std::once_flag flag; + call_once(flag, callback_taking_func, callback_with_implicit_cast); +} + +std::once_flag another_once_flag; +typedef void (*my_callback_t)(int *); +my_callback_t callback; +int global_int; + +void rdar40270582() { + call_once(another_once_flag, callback, &global_int); +} diff --git a/test/Analysis/casts.c b/test/Analysis/casts.c index 24bba8a30a00..eccb67812a02 100644 --- a/test/Analysis/casts.c +++ b/test/Analysis/casts.c @@ -149,3 +149,29 @@ void multiDimensionalArrayPointerCasts() { clang_analyzer_eval(*((char *)y1) == *((char *) y3)); // expected-warning{{TRUE}} } + +void *getVoidPtr(); + +void testCastVoidPtrToIntPtrThroughIntTypedAssignment() { + int *x; + (*((int *)(&x))) = (int)getVoidPtr(); + *x = 1; // no-crash +} + +void testCastUIntPtrToIntPtrThroughIntTypedAssignment() { + unsigned u; + int *x; + (*((int *)(&x))) = (int)&u; + *x = 1; + clang_analyzer_eval(u == 1); // expected-warning{{TRUE}} +} + +void testCastVoidPtrToIntPtrThroughUIntTypedAssignment() { + int *x; + (*((int *)(&x))) = (int)(unsigned *)getVoidPtr(); + *x = 1; // no-crash +} + +void testLocNonLocSymbolAssume(int a, int *b) { + if ((int)b < a) {} // no-crash +} diff --git a/test/Analysis/casts.cpp b/test/Analysis/casts.cpp index f96f19b0ac33..757eb6da6623 100644 --- a/test/Analysis/casts.cpp +++ b/test/Analysis/casts.cpp @@ -21,3 +21,23 @@ void intAsBoolAsSwitchCondition(int c) { break; } } + +int *&castToIntPtrLValueRef(char *p) { + return (int *&)*(int *)p; +} +bool testCastToIntPtrLValueRef(char *p, int *s) { + return castToIntPtrLValueRef(p) != s; // no-crash +} + +int *&&castToIntPtrRValueRef(char *p) { + return (int *&&)*(int *)p; +} +bool testCastToIntPtrRValueRef(char *p, int *s) { + return castToIntPtrRValueRef(p) != s; // no-crash +} + +bool retrievePointerFromBoolean(int *p) { + bool q; + *reinterpret_cast<int **>(&q) = p; + return q; +} diff --git a/test/Analysis/cfg-rich-constructors.cpp b/test/Analysis/cfg-rich-constructors.cpp new file mode 100644 index 000000000000..6780cf1a7be9 --- /dev/null +++ b/test/Analysis/cfg-rich-constructors.cpp @@ -0,0 +1,906 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -triple x86_64-apple-darwin12 -std=c++11 -w %s > %t 2>&1 +// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,CXX11,ELIDE,CXX11-ELIDE %s +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -triple x86_64-apple-darwin12 -std=c++17 -w %s > %t 2>&1 +// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,CXX17,ELIDE,CXX17-ELIDE %s +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -triple x86_64-apple-darwin12 -std=c++11 -w -analyzer-config elide-constructors=false %s > %t 2>&1 +// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,CXX11,NOELIDE,CXX11-NOELIDE %s +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -triple x86_64-apple-darwin12 -std=c++17 -w -analyzer-config elide-constructors=false %s > %t 2>&1 +// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,CXX17,NOELIDE,CXX17-NOELIDE %s + +class C { +public: + C(); + C(C *); + C(int, int); + + static C get(); + operator bool() const; +}; + +typedef __typeof(sizeof(int)) size_t; +void *operator new(size_t size, void *placement); + +namespace operator_new { + +// CHECK: void operatorNewWithConstructor() +// CHECK: 1: CFGNewAllocator(C *) +// CHECK-NEXT: 2: (CXXConstructExpr, [B1.3], class C) +// CHECK-NEXT: 3: new C([B1.2]) +void operatorNewWithConstructor() { + new C(); +} + +// CHECK: void operatorNewWithConstructorWithOperatorNewWithContstructor() +// CHECK: 1: CFGNewAllocator(C *) +// CHECK-NEXT: 2: CFGNewAllocator(C *) +// CHECK-NEXT: 3: (CXXConstructExpr, [B1.4], class C) +// CHECK-NEXT: 4: new C([B1.3]) +// CHECK-NEXT: 5: [B1.4] (CXXConstructExpr, [B1.6], class C) +// CHECK-NEXT: 6: new C([B1.5]) +void operatorNewWithConstructorWithOperatorNewWithContstructor() { + new C(new C()); +} + +// CHECK: void operatorPlacementNewWithConstructorWithinPlacementArgument() +// CHECK: 1: CFGNewAllocator(C *) +// CHECK-NEXT: 2: (CXXConstructExpr, [B1.3], class C) +// CHECK-NEXT: 3: new C([B1.2]) +// CHECK-NEXT: 4: [B1.3] (ImplicitCastExpr, BitCast, void *) +// CHECK-NEXT: 5: CFGNewAllocator(C *) +// CHECK-NEXT: 6: (CXXConstructExpr, [B1.7], class C) +// CHECK-NEXT: 7: new ([B1.4]) C([B1.6]) +void operatorPlacementNewWithConstructorWithinPlacementArgument() { + new (new C()) C(); +} + +} // namespace operator_new + +namespace decl_stmt { + +// CHECK: void simpleVariable() +// CHECK: 1: (CXXConstructExpr, [B1.2], class C) +// CHECK-NEXT: 2: C c; +void simpleVariable() { + C c; +} + +// CHECK: void simpleVariableWithBraces() +// CHECK: 1: {} (CXXConstructExpr, [B1.2], class C) +// CHECK-NEXT: 2: C c{}; +void simpleVariableWithBraces() { + C c{}; +} + +// CHECK: void simpleVariableWithConstructorArgument() +// CHECK: 1: 0 +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, NullToPointer, class C *) +// CHECK-NEXT: 3: [B1.2] (CXXConstructExpr, [B1.4], class C) +// CHECK-NEXT: 4: C c(0); +void simpleVariableWithConstructorArgument() { + C c(0); +} + +// CHECK: void simpleVariableWithOperatorNewInConstructorArgument() +// CHECK: 1: CFGNewAllocator(C *) +// CHECK-NEXT: 2: (CXXConstructExpr, [B1.3], class C) +// CHECK-NEXT: 3: new C([B1.2]) +// CHECK-NEXT: 4: [B1.3] (CXXConstructExpr, [B1.5], class C) +// CHECK-NEXT: 5: C c(new C()); +void simpleVariableWithOperatorNewInConstructorArgument() { + C c(new C()); +} + +// CHECK: void simpleVariableWithOperatorNewInBraces() +// CHECK: 1: CFGNewAllocator(C *) +// CHECK-NEXT: 2: (CXXConstructExpr, [B1.3], class C) +// CHECK-NEXT: 3: new C([B1.2]) +// CHECK-NEXT: 4: {[B1.3]} (CXXConstructExpr, [B1.5], class C) +// CHECK-NEXT: 5: C c{new C()}; +void simpleVariableWithOperatorNewInBraces() { + C c{new C()}; +} + +// CHECK: void simpleVariableInitializedByValue() +// CHECK: 1: C::get +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class C (*)(void)) +// CXX11-ELIDE-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.4], [B1.5]) +// CXX11-NOELIDE-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.4]) +// CXX11-NEXT: 4: [B1.3] +// CXX11-NEXT: 5: [B1.4] (CXXConstructExpr, [B1.6], class C) +// CXX11-NEXT: 6: C c = C::get(); +// CXX17-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.4]) +// CXX17-NEXT: 4: C c = C::get(); +void simpleVariableInitializedByValue() { + C c = C::get(); +} + +// FIXME: Find construction contexts for both branches in C++17. +// Note that once it gets detected, the test for the get() branch would not +// fail, because FileCheck allows partial matches. +// CHECK: void simpleVariableWithTernaryOperator(bool coin) +// CHECK: [B1] +// CXX11-NEXT: 1: [B4.2] ? [B2.5] : [B3.6] +// CXX11-NEXT: 2: [B1.1] +// CXX11-NEXT: 3: [B1.2] (CXXConstructExpr, [B1.4], class C) +// CXX11-NEXT: 4: C c = coin ? C::get() : C(0); +// CXX17-NEXT: 1: [B4.2] ? [B2.3] : [B3.4] +// CXX17-NEXT: 2: C c = coin ? C::get() : C(0); +// CHECK: [B2] +// CHECK-NEXT: 1: C::get +// CHECK-NEXT: 2: [B2.1] (ImplicitCastExpr, FunctionToPointerDecay, class C (*)(void)) +// CXX11-ELIDE-NEXT: 3: [B2.2]() (CXXRecordTypedCall, [B2.4], [B2.5]) +// CXX11-NOELIDE-NEXT: 3: [B2.2]() (CXXRecordTypedCall, [B2.4]) +// CXX11-NEXT: 4: [B2.3] +// CXX11-ELIDE-NEXT: 5: [B2.4] (CXXConstructExpr, [B1.2], [B1.3], class C) +// CXX11-NOELIDE-NEXT: 5: [B2.4] (CXXConstructExpr, [B1.2], class C) +// CXX17-NEXT: 3: [B2.2]() +// CHECK: [B3] +// CHECK-NEXT: 1: 0 +// CHECK-NEXT: 2: [B3.1] (ImplicitCastExpr, NullToPointer, class C *) +// CXX11-ELIDE-NEXT: 3: [B3.2] (CXXConstructExpr, [B3.5], [B3.6], class C) +// CXX11-NOELIDE-NEXT: 3: [B3.2] (CXXConstructExpr, [B3.5], class C) +// CXX11-NEXT: 4: C([B3.3]) (CXXFunctionalCastExpr, ConstructorConversion, class C) +// CXX11-NEXT: 5: [B3.4] +// CXX11-ELIDE-NEXT: 6: [B3.5] (CXXConstructExpr, [B1.2], [B1.3], class C) +// CXX11-NOELIDE-NEXT: 6: [B3.5] (CXXConstructExpr, [B1.2], class C) +// CXX17-NEXT: 3: [B3.2] (CXXConstructExpr, class C) +// CXX17-NEXT: 4: C([B3.3]) (CXXFunctionalCastExpr, ConstructorConversion, class C) +// CHECK: [B4] +// CHECK-NEXT: 1: coin +// CHECK-NEXT: 2: [B4.1] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: [B4.2] ? ... : ... +void simpleVariableWithTernaryOperator(bool coin) { + C c = coin ? C::get() : C(0); +} + +// CHECK: void simpleVariableWithElidableCopy() +// CHECK: 1: 0 +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, NullToPointer, class C *) +// CXX11-ELIDE-NEXT: 3: [B1.2] (CXXConstructExpr, [B1.5], [B1.6], class C) +// CXX11-NOELIDE-NEXT: 3: [B1.2] (CXXConstructExpr, [B1.5], class C) +// CXX17-NEXT: 3: [B1.2] (CXXConstructExpr, [B1.5], class C) +// CHECK-NEXT: 4: C([B1.3]) (CXXFunctionalCastExpr, ConstructorConversion, class C) +// CXX11-NEXT: 5: [B1.4] +// CXX11-NEXT: 6: [B1.5] (CXXConstructExpr, [B1.7], class C) +// CXX11-NEXT: 7: C c = C(0); +// CXX17-NEXT: 5: C c = C(0); +void simpleVariableWithElidableCopy() { + C c = C(0); +} + +// CHECK: void referenceVariableWithConstructor() +// CHECK: 1: 0 +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, NullToPointer, class C *) +// CHECK-NEXT: 3: [B1.2] (CXXConstructExpr, [B1.4], const class C) +// CHECK-NEXT: 4: [B1.3] +// CHECK-NEXT: 5: const C &c(0); +void referenceVariableWithConstructor() { + const C &c(0); +} + +// CHECK: void referenceVariableWithInitializer() +// CHECK: 1: C() (CXXConstructExpr, [B1.3], class C) +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, NoOp, const class C) +// CHECK-NEXT: 3: [B1.2] +// CHECK-NEXT: 4: const C &c = C(); +void referenceVariableWithInitializer() { + const C &c = C(); +} + +// CHECK: void referenceVariableWithTernaryOperator(bool coin) +// CHECK: [B1] +// CXX11-NEXT: 1: [B4.2] ? [B2.5] : [B3.6] +// CXX17-NEXT: 1: [B4.2] ? [B2.3] : [B3.4] +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, NoOp, const class C) +// CHECK-NEXT: 3: [B1.2] +// CHECK-NEXT: 4: const C &c = coin ? C::get() : C(0); +// CHECK: [B2] +// CHECK-NEXT: 1: C::get +// CHECK-NEXT: 2: [B2.1] (ImplicitCastExpr, FunctionToPointerDecay, class C (*)(void)) +// CXX11-ELIDE-NEXT: 3: [B2.2]() (CXXRecordTypedCall, [B2.4], [B2.5]) +// CXX11-NOELIDE-NEXT: 3: [B2.2]() (CXXRecordTypedCall, [B2.4]) +// CXX11-NEXT: 4: [B2.3] +// CXX11-NEXT: 5: [B2.4] (CXXConstructExpr, [B1.3], class C) +// CXX17-NEXT: 3: [B2.2]() (CXXRecordTypedCall, [B1.3]) +// CHECK: [B3] +// CHECK-NEXT: 1: 0 +// CHECK-NEXT: 2: [B3.1] (ImplicitCastExpr, NullToPointer, class C *) +// CXX11-ELIDE-NEXT: 3: [B3.2] (CXXConstructExpr, [B3.5], [B3.6], class C) +// CXX11-NOELIDE-NEXT: 3: [B3.2] (CXXConstructExpr, [B3.5], class C) +// CXX11-NEXT: 4: C([B3.3]) (CXXFunctionalCastExpr, ConstructorConversion, class C) +// CXX11-NEXT: 5: [B3.4] +// CXX11-NEXT: 6: [B3.5] (CXXConstructExpr, [B1.3], class C) +// CXX17-NEXT: 3: [B3.2] (CXXConstructExpr, [B1.3], class C) +// CXX17-NEXT: 4: C([B3.3]) (CXXFunctionalCastExpr, ConstructorConversion, class C) +// CHECK: [B4] +// CHECK-NEXT: 1: coin +// CHECK-NEXT: 2: [B4.1] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: [B4.2] ? ... : ... +void referenceVariableWithTernaryOperator(bool coin) { + const C &c = coin ? C::get() : C(0); +} + +} // end namespace decl_stmt + +namespace ctor_initializers { + +class D: public C { + C c1; + +public: + +// CHECK: D() +// CHECK: 1: (CXXConstructExpr, C() (Base initializer), class C) +// CHECK-NEXT: 2: C([B1.1]) (Base initializer) +// CHECK-NEXT: 3: CFGNewAllocator(C *) +// CHECK-NEXT: 4: (CXXConstructExpr, [B1.5], class C) +// CHECK-NEXT: 5: new C([B1.4]) +// CHECK-NEXT: 6: [B1.5] (CXXConstructExpr, c1([B1.5]) (Member initializer), class C) +// CHECK-NEXT: 7: c1([B1.6]) (Member initializer) + D(): C(), c1(new C()) {} + +// CHECK: D(int) +// CHECK: 1: (CXXConstructExpr, D() (Delegating initializer), class ctor_initializers::D) +// CHECK-NEXT: 2: D([B1.1]) (Delegating initializer) + D(int): D() {} + +// FIXME: Why is CXXRecordTypedCall not present in C++17? Note that once it gets +// detected the test would not fail, because FileCheck allows partial matches. +// CHECK: D(double) +// CHECK: 1: C::get +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class C (*)(void)) +// CHECK-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.4]) +// CHECK-NEXT: 4: [B1.3] +// CHECK-NEXT: 5: [B1.4] (CXXConstructExpr, C([B1.4]) (Base initializer), class C) +// CHECK-NEXT: 6: C([B1.5]) (Base initializer) +// CHECK-NEXT: 7: CFGNewAllocator(C *) +// CHECK-NEXT: 8: C::get +// CHECK-NEXT: 9: [B1.8] (ImplicitCastExpr, FunctionToPointerDecay, class C (*)(void)) +// CXX11-ELIDE-NEXT: 10: [B1.9]() (CXXRecordTypedCall, [B1.11], [B1.12]) +// CXX11-NOELIDE-NEXT: 10: [B1.9]() (CXXRecordTypedCall, [B1.11]) +// CXX11-NEXT: 11: [B1.10] +// CXX11-NEXT: 12: [B1.11] (CXXConstructExpr, [B1.13], class C) +// CXX11-NEXT: 13: new C([B1.12]) +// CXX11-NEXT: 14: [B1.13] (CXXConstructExpr, c1([B1.13]) (Member initializer), class C) +// CXX11-NEXT: 15: c1([B1.14]) (Member initializer) +// CXX17-NEXT: 10: [B1.9]() +// CXX17-NEXT: 11: new C([B1.10]) +// CXX17-NEXT: 12: [B1.11] (CXXConstructExpr, c1([B1.11]) (Member initializer), class C) +// CXX17-NEXT: 13: c1([B1.12]) (Member initializer) + D(double): C(C::get()), c1(new C(C::get())) {} +}; + +// Let's see if initializers work well for fields with destructors. +class E { +public: + static E get(); + ~E(); +}; + +class F { + E e; + +public: +// FIXME: There should be no temporary destructor in C++17. +// CHECK: F() +// CHECK: 1: E::get +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class ctor_initializers::E (*)( +// CXX11-ELIDE-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.4], [B1.6], [B1.7]) +// CXX11-NOELIDE-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.4], [B1.6]) +// CXX11-NEXT: 4: [B1.3] (BindTemporary) +// CXX11-NEXT: 5: [B1.4] (ImplicitCastExpr, NoOp, const class ctor_initializers::E) +// CXX11-NEXT: 6: [B1.5] +// CXX11-NEXT: 7: [B1.6] (CXXConstructExpr, e([B1.6]) (Member initializer), class ctor_initializers +// CXX11-NEXT: 8: e([B1.7]) (Member initializer) +// CXX11-NEXT: 9: ~ctor_initializers::E() (Temporary object destructor) +// CXX17-NEXT: 3: [B1.2]() (CXXRecordTypedCall, e([B1.4]) (Member initializer), [B1.4]) +// CXX17-NEXT: 4: [B1.3] (BindTemporary) +// CXX17-NEXT: 5: e([B1.4]) (Member initializer) +// CXX17-NEXT: 6: ~ctor_initializers::E() (Temporary object destructor) + F(): e(E::get()) {} +}; +} // end namespace ctor_initializers + +namespace return_stmt_without_dtor { + +// CHECK: C returnVariable() +// CHECK: 1: (CXXConstructExpr, [B1.2], class C) +// CHECK-NEXT: 2: C c; +// CHECK-NEXT: 3: c +// CHECK-NEXT: 4: [B1.3] (ImplicitCastExpr, NoOp, class C) +// CHECK-NEXT: 5: [B1.4] (CXXConstructExpr, [B1.6], class C) +// CHECK-NEXT: 6: return [B1.5]; +C returnVariable() { + C c; + return c; +} + +// CHECK: C returnEmptyBraces() +// CHECK: 1: {} (CXXConstructExpr, [B1.2], class C) +// CHECK-NEXT: 2: return [B1.1]; +C returnEmptyBraces() { + return {}; +} + +// CHECK: C returnBracesWithOperatorNew() +// CHECK: 1: CFGNewAllocator(C *) +// CHECK-NEXT: 2: (CXXConstructExpr, [B1.3], class C) +// CHECK-NEXT: 3: new C([B1.2]) +// CHECK-NEXT: 4: {[B1.3]} (CXXConstructExpr, [B1.5], class C) +// CHECK-NEXT: 5: return [B1.4]; +C returnBracesWithOperatorNew() { + return {new C()}; +} + +// CHECK: C returnBracesWithMultipleItems() +// CHECK: 1: 123 +// CHECK-NEXT: 2: 456 +// CHECK-NEXT: 3: {[B1.1], [B1.2]} (CXXConstructExpr, [B1.4], class C) +// CHECK-NEXT: 4: return [B1.3]; +C returnBracesWithMultipleItems() { + return {123, 456}; +} + +// CHECK: C returnTemporary() +// CXX11-ELIDE: 1: C() (CXXConstructExpr, [B1.2], [B1.3], class C) +// CXX11-NOELIDE: 1: C() (CXXConstructExpr, [B1.2], class C) +// CXX11-NEXT: 2: [B1.1] +// CXX11-NEXT: 3: [B1.2] (CXXConstructExpr, [B1.4], class C) +// CXX11-NEXT: 4: return [B1.3]; +// CXX17: 1: C() (CXXConstructExpr, [B1.2], class C) +// CXX17-NEXT: 2: return [B1.1]; +C returnTemporary() { + return C(); +} + +// CHECK: C returnTemporaryWithArgument() +// CHECK: 1: nullptr +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, NullToPointer, class C *) +// CXX11-ELIDE-NEXT: 3: [B1.2] (CXXConstructExpr, [B1.5], [B1.6], class C) +// CXX11-NOELIDE-NEXT: 3: [B1.2] (CXXConstructExpr, [B1.5], class C) +// CXX17-NEXT: 3: [B1.2] (CXXConstructExpr, [B1.5], class C) +// CHECK-NEXT: 4: C([B1.3]) (CXXFunctionalCastExpr, ConstructorConversion, class C) +// CXX11-NEXT: 5: [B1.4] +// CXX11-NEXT: 6: [B1.5] (CXXConstructExpr, [B1.7], class C) +// CXX11-NEXT: 7: return [B1.6]; +// CXX17-NEXT: 5: return [B1.4]; + +C returnTemporaryWithArgument() { + return C(nullptr); +} + +// CHECK: C returnTemporaryConstructedByFunction() +// CHECK: 1: C::get +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class C (*)(void)) +// CXX11-ELIDE-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.4], [B1.5]) +// CXX11-NOELIDE-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.4]) +// CXX11-NEXT: 4: [B1.3] +// CXX11-NEXT: 5: [B1.4] (CXXConstructExpr, [B1.6], class C) +// CXX11-NEXT: 6: return [B1.5]; +// CXX17-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.4]) +// CXX17-NEXT: 4: return [B1.3]; +C returnTemporaryConstructedByFunction() { + return C::get(); +} + +// CHECK: C returnChainOfCopies() +// CHECK: 1: C::get +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class C (*)(void)) +// CXX11-ELIDE-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.4], [B1.5]) +// CXX11-NOELIDE-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.4]) +// CXX11-NEXT: 4: [B1.3] +// CXX11-ELIDE-NEXT: 5: [B1.4] (CXXConstructExpr, [B1.7], [B1.8], class C) +// CXX11-NOELIDE-NEXT: 5: [B1.4] (CXXConstructExpr, [B1.7], class C) +// CXX11-NEXT: 6: C([B1.5]) (CXXFunctionalCastExpr, ConstructorConversion, class C) +// CXX11-NEXT: 7: [B1.6] +// CXX11-NEXT: 8: [B1.7] (CXXConstructExpr, [B1.9], class C) +// CXX11-NEXT: 9: return [B1.8]; +// CXX17-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.5]) +// CXX17-NEXT: 4: C([B1.3]) (CXXFunctionalCastExpr, NoOp, class C) +// CXX17-NEXT: 5: return [B1.4]; +C returnChainOfCopies() { + return C(C::get()); +} + +} // end namespace return_stmt_without_dtor + +namespace return_stmt_with_dtor { + +class D { +public: + D(); + ~D(); +}; + +// FIXME: There should be no temporary destructor in C++17. +// CHECK: return_stmt_with_dtor::D returnTemporary() +// CXX11-ELIDE: 1: return_stmt_with_dtor::D() (CXXConstructExpr, [B1.2], [B1.4], [B1.5], class return_stmt_with_dtor::D) +// CXX11-NOELIDE: 1: return_stmt_with_dtor::D() (CXXConstructExpr, [B1.2], [B1.4], class return_stmt_with_dtor::D) +// CXX11-NEXT: 2: [B1.1] (BindTemporary) +// CXX11-NEXT: 3: [B1.2] (ImplicitCastExpr, NoOp, const class return_stmt_with_dtor::D) +// CXX11-NEXT: 4: [B1.3] +// CXX11-NEXT: 5: [B1.4] (CXXConstructExpr, [B1.7], class return_stmt_with_dtor::D) +// CXX11-NEXT: 6: ~return_stmt_with_dtor::D() (Temporary object destructor) +// CXX11-NEXT: 7: return [B1.5]; +// CXX17: 1: return_stmt_with_dtor::D() (CXXConstructExpr, [B1.4], [B1.2], class return_stmt_w +// CXX17-NEXT: 2: [B1.1] (BindTemporary) +// CXX17-NEXT: 3: ~return_stmt_with_dtor::D() (Temporary object destructor) +// CXX17-NEXT: 4: return [B1.2]; +D returnTemporary() { + return D(); +} + +// FIXME: There should be no temporary destructor in C++17. +// CHECK: void returnByValueIntoVariable() +// CHECK: 1: returnTemporary +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class return_stmt_with_dtor::D (*)(void)) +// CXX11-ELIDE-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.4], [B1.6], [B1.7]) +// CXX11-NOELIDE-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.4], [B1.6]) +// CXX11-NEXT: 4: [B1.3] (BindTemporary) +// CXX11-NEXT: 5: [B1.4] (ImplicitCastExpr, NoOp, const class return_stmt_with_dtor::D) +// CXX11-NEXT: 6: [B1.5] +// CXX11-NEXT: 7: [B1.6] (CXXConstructExpr, [B1.8], class return_stmt_with_dtor::D) +// CXX11-NEXT: 8: return_stmt_with_dtor::D d = returnTemporary(); +// CXX11-NEXT: 9: ~return_stmt_with_dtor::D() (Temporary object destructor) +// CXX11-NEXT: 10: [B1.8].~D() (Implicit destructor) +// CXX17-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.5], [B1.4]) +// CXX17-NEXT: 4: [B1.3] (BindTemporary) +// CXX17-NEXT: 5: return_stmt_with_dtor::D d = returnTemporary(); +// CXX17-NEXT: 6: ~return_stmt_with_dtor::D() (Temporary object destructor) +// CXX17-NEXT: 7: [B1.5].~D() (Implicit destructor) +void returnByValueIntoVariable() { + D d = returnTemporary(); +} + +} // end namespace return_stmt_with_dtor + +namespace temporary_object_expr_without_dtors { + +// TODO: Should provide construction context for the constructor, +// even if there is no specific trigger statement here. +// CHECK: void simpleTemporary() +// CHECK 1: C() (CXXConstructExpr, class C) +void simpleTemporary() { + C(); +} + +// CHECK: void temporaryInCondition() +// CHECK: 1: C() (CXXConstructExpr, [B2.2], class C) +// CHECK-NEXT: 2: [B2.1] +// CHECK-NEXT: 3: [B2.2] (ImplicitCastExpr, NoOp, const class C) +// CHECK-NEXT: 4: [B2.3].operator bool +// CHECK-NEXT: 5: [B2.3] +// CHECK-NEXT: 6: [B2.5] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CHECK-NEXT: T: if [B2.6] +void temporaryInCondition() { + if (C()); +} + +// CHECK: void temporaryInConditionVariable() +// CXX11-ELIDE: 1: C() (CXXConstructExpr, [B2.2], [B2.3], class C) +// CXX11-NOELIDE: 1: C() (CXXConstructExpr, [B2.2], class C) +// CXX11-NEXT: 2: [B2.1] +// CXX11-NEXT: 3: [B2.2] (CXXConstructExpr, [B2.4], class C) +// CXX11-NEXT: 4: C c = C(); +// CXX11-NEXT: 5: c +// CXX11-NEXT: 6: [B2.5] (ImplicitCastExpr, NoOp, const class C) +// CXX11-NEXT: 7: [B2.6].operator bool +// CXX11-NEXT: 8: [B2.6] +// CXX11-NEXT: 9: [B2.8] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CXX11-NEXT: T: if [B2.9] +// CXX17: 1: C() (CXXConstructExpr, [B2.2], class C) +// CXX17-NEXT: 2: C c = C(); +// CXX17-NEXT: 3: c +// CXX17-NEXT: 4: [B2.3] (ImplicitCastExpr, NoOp, const class C) +// CXX17-NEXT: 5: [B2.4].operator bool +// CXX17-NEXT: 6: [B2.4] +// CXX17-NEXT: 7: [B2.6] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CXX17-NEXT: T: if [B2.7] +void temporaryInConditionVariable() { + if (C c = C()); +} + + +// CHECK: void temporaryInForLoopConditionVariable() +// CHECK: [B2] +// CXX11-ELIDE-NEXT: 1: C() (CXXConstructExpr, [B2.2], [B2.3], class C) +// CXX11-NOELIDE-NEXT: 1: C() (CXXConstructExpr, [B2.2], class C) +// CXX11-NEXT: 2: [B2.1] +// CXX11-NEXT: 3: [B2.2] (CXXConstructExpr, [B2.4], class C) +// CXX11-NEXT: 4: C c2 = C(); +// CXX11-NEXT: 5: c2 +// CXX11-NEXT: 6: [B2.5] (ImplicitCastExpr, NoOp, const class C) +// CXX11-NEXT: 7: [B2.6].operator bool +// CXX11-NEXT: 8: [B2.6] +// CXX11-NEXT: 9: [B2.8] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CXX11-NEXT: T: for (...; [B2.9]; ) +// CXX17-NEXT: 1: C() (CXXConstructExpr, [B2.2], class C) +// CXX17-NEXT: 2: C c2 = C(); +// CXX17-NEXT: 3: c2 +// CXX17-NEXT: 4: [B2.3] (ImplicitCastExpr, NoOp, const class C) +// CXX17-NEXT: 5: [B2.4].operator bool +// CXX17-NEXT: 6: [B2.4] +// CXX17-NEXT: 7: [B2.6] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CXX17-NEXT: T: for (...; [B2.7]; ) +// CHECK: [B3] +// CXX11-ELIDE-NEXT: 1: C() (CXXConstructExpr, [B3.2], [B3.3], class C) +// CXX11-NOELIDE-NEXT: 1: C() (CXXConstructExpr, [B3.2], class C) +// CXX11-NEXT: 2: [B3.1] +// CXX11-NEXT: 3: [B3.2] (CXXConstructExpr, [B3.4], class C) +// CXX11-NEXT: 4: C c1 = C(); +// CXX17-NEXT: 1: C() (CXXConstructExpr, [B3.2], class C) +// CXX17-NEXT: 2: C c1 = C(); +void temporaryInForLoopConditionVariable() { + for (C c1 = C(); C c2 = C(); ); +} + + +// CHECK: void temporaryInWhileLoopConditionVariable() +// CXX11-ELIDE: 1: C() (CXXConstructExpr, [B2.2], [B2.3], class C) +// CXX11-NOELIDE: 1: C() (CXXConstructExpr, [B2.2], class C) +// CXX11-NEXT: 2: [B2.1] +// CXX11-NEXT: 3: [B2.2] (CXXConstructExpr, [B2.4], class C) +// CXX11-NEXT: 4: C c = C(); +// CXX11-NEXT: 5: c +// CXX11-NEXT: 6: [B2.5] (ImplicitCastExpr, NoOp, const class C) +// CXX11-NEXT: 7: [B2.6].operator bool +// CXX11-NEXT: 8: [B2.6] +// CXX11-NEXT: 9: [B2.8] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CXX11-NEXT: T: while [B2.9] +// CXX17: 1: C() (CXXConstructExpr, [B2.2], class C) +// CXX17-NEXT: 2: C c = C(); +// CXX17-NEXT: 3: c +// CXX17-NEXT: 4: [B2.3] (ImplicitCastExpr, NoOp, const class C) +// CXX17-NEXT: 5: [B2.4].operator bool +// CXX17-NEXT: 6: [B2.4] +// CXX17-NEXT: 7: [B2.6] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CXX17-NEXT: T: while [B2.7] +void temporaryInWhileLoopConditionVariable() { + while (C c = C()); +} + +} // end namespace temporary_object_expr_without_dtors + +namespace temporary_object_expr_with_dtors { + +class D { +public: + D(); + D(int); + ~D(); + + static D get(); + + operator bool() const; +}; + +// CHECK: void simpleTemporary() +// CHECK: 1: temporary_object_expr_with_dtors::D() (CXXConstructExpr, [B1.2], class temporary_object_expr_with_dtors::D) +// CHECK-NEXT: 2: [B1.1] (BindTemporary) +// CHECK-NEXT: 3: ~temporary_object_expr_with_dtors::D() (Temporary object destructor) +void simpleTemporary() { + D(); +} + +// CHECK: void temporaryInCondition() +// CHECK: 1: temporary_object_expr_with_dtors::D() (CXXConstructExpr, [B2.2], [B2.3], class temporary_object_expr_with_dtors::D) +// CHECK-NEXT: 2: [B2.1] (BindTemporary) +// CHECK-NEXT: 3: [B2.2] +// CHECK-NEXT: 4: [B2.3] (ImplicitCastExpr, NoOp, const class temporary_object_expr_with_dtors::D) +// CHECK-NEXT: 5: [B2.4].operator bool +// CHECK-NEXT: 6: [B2.4] +// CHECK-NEXT: 7: [B2.6] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CHECK-NEXT: 8: ~temporary_object_expr_with_dtors::D() (Temporary object destructor) +// CHECK-NEXT: T: if [B2.7] +void temporaryInCondition() { + if (D()); +} + +// CHECK: void referenceVariableWithConstructor() +// CHECK: 1: 0 +// CHECK-NEXT: 2: [B1.1] (CXXConstructExpr, [B1.4], const class temporary_object_expr_with_dtors::D) +// CHECK-NEXT: 3: [B1.2] (BindTemporary) +// CHECK-NEXT: 4: [B1.3] +// CHECK-NEXT: 5: const temporary_object_expr_with_dtors::D &d(0); +// CHECK-NEXT: 6: [B1.5].~D() (Implicit destructor) +void referenceVariableWithConstructor() { + const D &d(0); +} + +// CHECK: void referenceVariableWithInitializer() +// CHECK: 1: temporary_object_expr_with_dtors::D() (CXXConstructExpr, [B1.4], class temporary_object_expr_with_dtors::D) +// CHECK-NEXT: 2: [B1.1] (BindTemporary) +// CHECK-NEXT: 3: [B1.2] (ImplicitCastExpr, NoOp, const class temporary_object_expr_with_dtors::D) +// CHECK-NEXT: 4: [B1.3] +// CHECK-NEXT: 5: const temporary_object_expr_with_dtors::D &d = temporary_object_expr_with_dtors::D(); +// CHECK-NEXT: 6: [B1.5].~D() (Implicit destructor) +void referenceVariableWithInitializer() { + const D &d = D(); +} + +// CHECK: void referenceVariableWithTernaryOperator(bool coin) +// CXX11: [B1] +// CXX11-NEXT: 1: [B4.4].~D() (Implicit destructor) +// CXX11: [B2] +// CXX11-NEXT: 1: ~temporary_object_expr_with_dtors::D() (Temporary object destructor) +// CXX11: [B3] +// CXX11-NEXT: 1: ~temporary_object_expr_with_dtors::D() (Temporary object destructor) +// CXX11: [B4] +// CXX11-NEXT: 1: [B7.2] ? [B5.8] : [B6.8] +// CXX11-NEXT: 2: [B4.1] (ImplicitCastExpr, NoOp, const class temporary_object_expr_with_dtors::D) +// CXX11-NEXT: 3: [B4.2] +// CXX11-NEXT: 4: const temporary_object_expr_with_dtors::D &d = coin ? D::get() : temporary_object_expr_with_dtors::D(0); +// CXX11-NEXT: T: (Temp Dtor) [B6.3] +// CXX11: [B5] +// CXX11-NEXT: 1: D::get +// CXX11-NEXT: 2: [B5.1] (ImplicitCastExpr, FunctionToPointerDecay, class temporary_object_expr_with_dtors::D (*)(void)) +// CXX11-ELIDE-NEXT: 3: [B5.2]() (CXXRecordTypedCall, [B5.4], [B5.6], [B5.7]) +// CXX11-NOELIDE-NEXT: 3: [B5.2]() (CXXRecordTypedCall, [B5.4], [B5.6]) +// CXX11-NEXT: 4: [B5.3] (BindTemporary) +// CXX11-NEXT: 5: [B5.4] (ImplicitCastExpr, NoOp, const class temporary_object_expr_with_dtors::D) +// CXX11-NEXT: 6: [B5.5] +// CXX11-NEXT: 7: [B5.6] (CXXConstructExpr, [B4.3], class temporary_object_expr_with_dtors::D) +// CXX11-NEXT: 8: [B5.7] (BindTemporary) +// CXX11: [B6] +// CXX11-NEXT: 1: 0 +// CXX11-ELIDE-NEXT: 2: [B6.1] (CXXConstructExpr, [B6.3], [B6.6], [B6.7], class temporary_object_expr_with_dtors::D) +// CXX11-NOELIDE-NEXT: 2: [B6.1] (CXXConstructExpr, [B6.3], [B6.6], class temporary_object_expr_with_dtors::D) +// CXX11-NEXT: 3: [B6.2] (BindTemporary) +// CXX11-NEXT: 4: temporary_object_expr_with_dtors::D([B6.3]) (CXXFunctionalCastExpr, ConstructorConversion, class temporary_object_expr_with_dtors::D) +// CXX11-NEXT: 5: [B6.4] (ImplicitCastExpr, NoOp, const class temporary_object_expr_with_dtors::D) +// CXX11-NEXT: 6: [B6.5] +// CXX11-NEXT: 7: [B6.6] (CXXConstructExpr, [B4.3], class temporary_object_expr_with_dtors::D) +// CXX11-NEXT: 8: [B6.7] (BindTemporary) +// CXX11: [B7] +// CXX11-NEXT: 1: coin +// CXX11-NEXT: 2: [B7.1] (ImplicitCastExpr, LValueToRValue, _Bool) +// CXX11-NEXT: T: [B7.2] ? ... : ... +// CXX17: [B1] +// CXX17-NEXT: 1: [B4.2] ? [B2.4] : [B3.4] +// CXX17-NEXT: 2: [B1.1] (ImplicitCastExpr, NoOp, const class temporary_object_expr_with_dtors::D) +// CXX17-NEXT: 3: [B1.2] +// CXX17-NEXT: 4: const temporary_object_expr_with_dtors::D &d = coin ? D::get() : temporary_object_expr_with_dtors::D(0); +// CXX17-NEXT: 5: [B1.4].~D() (Implicit destructor) +// CXX17: [B2] +// CXX17-NEXT: 1: D::get +// CXX17-NEXT: 2: [B2.1] (ImplicitCastExpr, FunctionToPointerDecay, class temporary_object_expr_with_dtors::D (*)(void)) +// CXX17-NEXT: 3: [B2.2]() (CXXRecordTypedCall, [B1.3]) +// CXX17-NEXT: 4: [B2.3] (BindTemporary) +// CXX17: [B3] +// CXX17-NEXT: 1: 0 +// CXX17-NEXT: 2: [B3.1] (CXXConstructExpr, [B1.3], class temporary_object_expr_with_dtors::D) +// CXX17-NEXT: 3: [B3.2] (BindTemporary) +// CXX17-NEXT: 4: temporary_object_expr_with_dtors::D([B3.3]) (CXXFunctionalCastExpr, ConstructorConversion, class temporary_object_expr_with_dtors::D) +// CXX17: [B4] +// CXX17-NEXT: 1: coin +// CXX17-NEXT: 2: [B4.1] (ImplicitCastExpr, LValueToRValue, _Bool) +// CXX17-NEXT: T: [B4.2] ? ... : ... +void referenceVariableWithTernaryOperator(bool coin) { + const D &d = coin ? D::get() : D(0); +} + +// CHECK: void referenceWithFunctionalCast() +// CHECK: 1: 1 +// CHECK-NEXT: 2: [B1.1] (CXXConstructExpr, [B1.5], class temporary_object_expr_with_dtors::D) +// CHECK-NEXT: 3: [B1.2] (BindTemporary) +// CHECK-NEXT: 4: temporary_object_expr_with_dtors::D([B1.3]) (CXXFunctionalCastExpr, ConstructorCon +// CHECK-NEXT: 5: [B1.4] +// CHECK-NEXT: 6: temporary_object_expr_with_dtors::D &&d = temporary_object_expr_with_dtors::D(1); +// CHECK-NEXT: 7: [B1.6].~D() (Implicit destructor) +void referenceWithFunctionalCast() { + D &&d = D(1); +} + +// Test the condition constructor, we don't care about branch constructors here. +// CHECK: void constructorInTernaryCondition() +// CXX11: 1: 1 +// CXX11-NEXT: 2: [B7.1] (CXXConstructExpr, [B7.3], [B7.5], class temporary_object_expr_with_dtors::D) +// CXX11-NEXT: 3: [B7.2] (BindTemporary) +// CXX11-NEXT: 4: temporary_object_expr_with_dtors::D([B7.3]) (CXXFunctionalCastExpr, ConstructorConversion, class temporary_object_expr_with_dtors::D) +// CXX11-NEXT: 5: [B7.4] +// CXX11-NEXT: 6: [B7.5] (ImplicitCastExpr, NoOp, const class temporary_object_expr_with_dtors::D) +// CXX11-NEXT: 7: [B7.6].operator bool +// CXX11-NEXT: 8: [B7.6] +// CXX11-NEXT: 9: [B7.8] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CXX11-NEXT: T: [B7.9] ? ... : ... +// CXX17: 1: 1 +// CXX17-NEXT: 2: [B4.1] (CXXConstructExpr, [B4.3], [B4.5], class temporary_object_expr_with_dtors::D) +// CXX17-NEXT: 3: [B4.2] (BindTemporary) +// CXX17-NEXT: 4: temporary_object_expr_with_dtors::D([B4.3]) (CXXFunctionalCastExpr, ConstructorConversion, class temporary_object_expr_with_dtors::D) +// CXX17-NEXT: 5: [B4.4] +// CXX17-NEXT: 6: [B4.5] (ImplicitCastExpr, NoOp, const class temporary_object_expr_with_dtors::D) +// CXX17-NEXT: 7: [B4.6].operator bool +// CXX17-NEXT: 8: [B4.6] +// CXX17-NEXT: 9: [B4.8] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CXX17-NEXT: T: [B4.9] ? ... : ... +void constructorInTernaryCondition() { + const D &d = D(1) ? D(2) : D(3); +} + +} // end namespace temporary_object_expr_with_dtors + +namespace implicit_constructor_conversion { + +class A {}; +A get(); + +class B { +public: + B(const A &); + ~B() {} +}; + +// CHECK: void implicitConstructionConversionFromTemporary() +// CHECK: 1: implicit_constructor_conversion::A() (CXXConstructExpr, [B1.3], class implicit_constructor_conversion::A) +// CXX11-NEXT: 2: [B1.1] (ImplicitCastExpr, NoOp, const class implicit_constructor_conversion::A) +// CXX11-NEXT: 3: [B1.2] +// CXX11-ELIDE-NEXT: 4: [B1.3] (CXXConstructExpr, [B1.6], [B1.8], [B1.9], class implicit_constructor_conversion::B) +// CXX11-NOELIDE-NEXT: 4: [B1.3] (CXXConstructExpr, [B1.6], [B1.8], class implicit_constructor_conversion::B) +// CXX11-NEXT: 5: [B1.4] (ImplicitCastExpr, ConstructorConversion, class implicit_constructor_conversion::B) +// CXX11-NEXT: 6: [B1.5] (BindTemporary) +// CXX11-NEXT: 7: [B1.6] (ImplicitCastExpr, NoOp, const class implicit_constructor_conversion::B) +// CXX11-NEXT: 8: [B1.7] +// CXX11-NEXT: 9: [B1.8] (CXXConstructExpr, [B1.10], class implicit_constructor_conversion::B) +// CXX11-NEXT: 10: implicit_constructor_conversion::B b = implicit_constructor_conversion::A(); +// CXX11-NEXT: 11: ~implicit_constructor_conversion::B() (Temporary object destructor) +// CXX11-NEXT: 12: [B1.10].~B() (Implicit destructor) +// CXX17-NEXT: 2: [B1.1] (ImplicitCastExpr, NoOp, const class implicit_constructor_conversion::A) +// CXX17-NEXT: 3: [B1.2] +// CXX17-NEXT: 4: [B1.3] (CXXConstructExpr, [B1.6], class implicit_constructor_conversion::B) +// CXX17-NEXT: 5: [B1.4] (ImplicitCastExpr, ConstructorConversion, class implicit_constructor_conversion::B) +// CXX17-NEXT: 6: implicit_constructor_conversion::B b = implicit_constructor_conversion::A(); +// CXX17-NEXT: 7: [B1.6].~B() (Implicit destructor) +void implicitConstructionConversionFromTemporary() { + B b = A(); +} + +// CHECK: void implicitConstructionConversionFromFunctionValue() +// CHECK: 1: get +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class implicit_constructor_conversion::A (*)(void)) +// CHECK-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.5]) +// CHECK-NEXT: 4: [B1.3] (ImplicitCastExpr, NoOp, const class implicit_constructor_conversion::A) +// CHECK-NEXT: 5: [B1.4] +// CXX11-ELIDE-NEXT: 6: [B1.5] (CXXConstructExpr, [B1.8], [B1.10], [B1.11], class implicit_constructor_conversion::B) +// CXX11-NOELIDE-NEXT: 6: [B1.5] (CXXConstructExpr, [B1.8], [B1.10], class implicit_constructor_conversion::B) +// CXX11-NEXT: 7: [B1.6] (ImplicitCastExpr, ConstructorConversion, class implicit_constructor_conversion::B) +// CXX11-NEXT: 8: [B1.7] (BindTemporary) +// CXX11-NEXT: 9: [B1.8] (ImplicitCastExpr, NoOp, const class implicit_constructor_conversion::B) +// CXX11-NEXT: 10: [B1.9] +// CXX11-NEXT: 11: [B1.10] (CXXConstructExpr, [B1.12], class implicit_constructor_conversion::B) +// CXX11-NEXT: 12: implicit_constructor_conversion::B b = get(); +// CXX11-NEXT: 13: ~implicit_constructor_conversion::B() (Temporary object destructor) +// CXX11-NEXT: 14: [B1.12].~B() (Implicit destructor) +// CXX17-NEXT: 6: [B1.5] (CXXConstructExpr, [B1.8], class implicit_constructor_conversion::B) +// CXX17-NEXT: 7: [B1.6] (ImplicitCastExpr, ConstructorConversion, class implicit_constructor_conversion::B) +// CXX17-NEXT: 8: implicit_constructor_conversion::B b = get(); +// CXX17-NEXT: 9: [B1.8].~B() (Implicit destructor) +void implicitConstructionConversionFromFunctionValue() { + B b = get(); +} + +// CHECK: void implicitConstructionConversionFromTemporaryWithLifetimeExtension() +// CHECK: 1: implicit_constructor_conversion::A() (CXXConstructExpr, [B1.3], class implicit_constructor_conversion::A) +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, NoOp, const class implicit_constructor_conversion::A) +// CHECK-NEXT: 3: [B1.2] +// CHECK-NEXT: 4: [B1.3] (CXXConstructExpr, [B1.7], class implicit_constructor_conversion::B) +// CHECK-NEXT: 5: [B1.4] (ImplicitCastExpr, ConstructorConversion, class implicit_constructor_conversion::B) +// CHECK-NEXT: 6: [B1.5] (ImplicitCastExpr, NoOp, const class implicit_constructor_conversion::B) +// CHECK-NEXT: 7: [B1.6] +// CHECK-NEXT: 8: const implicit_constructor_conversion::B &b = implicit_constructor_conversion::A(); +// CHECK-NEXT: 9: [B1.8].~B() (Implicit destructor) +void implicitConstructionConversionFromTemporaryWithLifetimeExtension() { + const B &b = A(); +} + +// CHECK: void implicitConstructionConversionFromFunctionValueWithLifetimeExtension() +// CHECK: 1: get +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class implicit_constructor_conver +// CHECK-NEXT: 3: [B1.2]() (CXXRecordTypedCall, [B1.5]) +// CHECK-NEXT: 4: [B1.3] (ImplicitCastExpr, NoOp, const class implicit_constructor_conversion::A) +// CHECK-NEXT: 5: [B1.4] +// CHECK-NEXT: 6: [B1.5] (CXXConstructExpr, [B1.9], class implicit_constructor_conversion::B) +// CHECK-NEXT: 7: [B1.6] (ImplicitCastExpr, ConstructorConversion, class implicit_constructor_convers +// CHECK-NEXT: 8: [B1.7] (ImplicitCastExpr, NoOp, const class implicit_constructor_conversion::B) +// CHECK-NEXT: 9: [B1.8] +// CHECK-NEXT: 10: const implicit_constructor_conversion::B &b = get(); +// CHECK-NEXT: 11: [B1.10].~B() (Implicit destructor) +void implicitConstructionConversionFromFunctionValueWithLifetimeExtension() { + const B &b = get(); // no-crash +} + +} // end namespace implicit_constructor_conversion + +namespace argument_constructors { +class D { +public: + D(); + ~D(); +}; + +void useC(C c); +void useCByReference(const C &c); +void useD(D d); +void useDByReference(const D &d); + +// FIXME: Find construction context for the argument. +// CHECK: void passArgument() +// CHECK: 1: useC +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(class C)) +// CXX11-NEXT: 3: C() (CXXConstructExpr, [B1.4], class C) +// CXX11-NEXT: 4: [B1.3] +// CXX11-NEXT: 5: [B1.4] (CXXConstructExpr, class C) +// CXX11-NEXT: 6: [B1.2]([B1.5]) +// CXX17-NEXT: 3: C() (CXXConstructExpr, class C) +// CXX17-NEXT: 4: [B1.2]([B1.3]) +void passArgument() { + useC(C()); +} + +// CHECK: void passArgumentByReference() +// CHECK: 1: useCByReference +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class C &)) +// CHECK-NEXT: 3: C() (CXXConstructExpr, [B1.5], class C) +// CHECK-NEXT: 4: [B1.3] (ImplicitCastExpr, NoOp, const class C) +// CHECK-NEXT: 5: [B1.4] +// CHECK-NEXT: 6: [B1.2]([B1.5]) +void passArgumentByReference() { + useCByReference(C()); +} + +// FIXME: Find construction context for the argument. +// CHECK: void passArgumentWithDestructor() +// CHECK: 1: useD +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(class argument_constructors::D)) +// CXX11-NEXT: 3: argument_constructors::D() (CXXConstructExpr, [B1.4], [B1.6], class argument_constructors::D) +// CXX11-NEXT: 4: [B1.3] (BindTemporary) +// CXX11-NEXT: 5: [B1.4] (ImplicitCastExpr, NoOp, const class argument_constructors::D) +// CXX11-NEXT: 6: [B1.5] +// CXX11-NEXT: 7: [B1.6] (CXXConstructExpr, class argument_constructors::D) +// CXX11-NEXT: 8: [B1.7] (BindTemporary) +// CXX11-NEXT: 9: [B1.2]([B1.8]) +// CXX11-NEXT: 10: ~argument_constructors::D() (Temporary object destructor) +// CXX11-NEXT: 11: ~argument_constructors::D() (Temporary object destructor) +// CXX17-NEXT: 3: argument_constructors::D() (CXXConstructExpr, class argument_constructors::D) +// CXX17-NEXT: 4: [B1.3] (BindTemporary) +// CXX17-NEXT: 5: [B1.2]([B1.4]) +// CXX17-NEXT: 6: ~argument_constructors::D() (Temporary object destructor) +void passArgumentWithDestructor() { + useD(D()); +} + +// CHECK: void passArgumentWithDestructorByReference() +// CHECK: 1: useDByReference +// CHECK-NEXT: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class argumen +// CHECK-NEXT: 3: argument_constructors::D() (CXXConstructExpr, [B1.4], [B1.6], class argument_c +// CHECK-NEXT: 4: [B1.3] (BindTemporary) +// CHECK-NEXT: 5: [B1.4] (ImplicitCastExpr, NoOp, const class argument_constructors::D) +// CHECK-NEXT: 6: [B1.5] +// CHECK-NEXT: 7: [B1.2]([B1.6]) +// CHECK-NEXT: 8: ~argument_constructors::D() (Temporary object destructor) +void passArgumentWithDestructorByReference() { + useDByReference(D()); +} +} // end namespace argument_constructors + +namespace copy_elision_with_extra_arguments { +class C { +public: + C(); + C(const C &c, int x = 0); +}; + +// CHECK: void testCopyElisionWhenCopyConstructorHasExtraArguments() +// CHECK: [B1] +// CXX11-ELIDE-NEXT: 1: copy_elision_with_extra_arguments::C() (CXXConstructExpr, [B1.3], [B1.5], class copy_elision_with_extra_arguments::C) +// CXX11-NOELIDE-NEXT: 1: copy_elision_with_extra_arguments::C() (CXXConstructExpr, [B1.3], class copy_elision_with_extra_arguments::C) +// CXX11-NEXT: 2: [B1.1] (ImplicitCastExpr, NoOp, const class copy_elision_with_extra_arguments::C) +// CXX11-NEXT: 3: [B1.2] +// CXX11-NEXT: 4: +// CXX11-NEXT: 5: [B1.3] (CXXConstructExpr, [B1.6], class copy_elision_with_extra_arguments::C) +// CXX11-NEXT: 6: copy_elision_with_extra_arguments::C c = copy_elision_with_extra_arguments::C(); +// CXX17-NEXT: 1: copy_elision_with_extra_arguments::C() (CXXConstructExpr, [B1.2], class copy_elision_with_extra_arguments::C) +// CXX17-NEXT: 2: copy_elision_with_extra_arguments::C c = copy_elision_with_extra_arguments::C(); +void testCopyElisionWhenCopyConstructorHasExtraArguments() { + C c = C(); +} +} // namespace copy_elision_with_extra_arguments diff --git a/test/Analysis/cfg.cpp b/test/Analysis/cfg.cpp index 208277343cdc..85c5be5a9819 100644 --- a/test/Analysis/cfg.cpp +++ b/test/Analysis/cfg.cpp @@ -1,5 +1,16 @@ -// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -triple x86_64-apple-darwin12 -analyzer-config cfg-temporary-dtors=true -std=c++11 %s > %t 2>&1 -// RUN: FileCheck --input-file=%t %s +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -triple x86_64-apple-darwin12 -std=c++11 -analyzer-config cfg-rich-constructors=false %s > %t 2>&1 +// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,WARNINGS %s +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -triple x86_64-apple-darwin12 -std=c++11 -analyzer-config cfg-rich-constructors=true %s > %t 2>&1 +// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,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. // CHECK-LABEL: void checkWrap(int i) // CHECK: ENTRY @@ -48,11 +59,14 @@ void checkWrap(int i) { // CHECK-NEXT: 5: int l; // CHECK-NEXT: 6: 2 // CHECK-NEXT: 7: int m = 2; -// CHECK-NEXT: CXXConstructExpr +// WARNINGS-NEXT: (CXXConstructExpr, struct standalone) +// ANALYZER-NEXT: (CXXConstructExpr, [B1.9], struct standalone) // CHECK-NEXT: 9: struct standalone myStandalone; -// CHECK-NEXT: CXXConstructExpr +// WARNINGS-NEXT: (CXXConstructExpr, struct (anonymous struct at {{.*}})) +// ANALYZER-NEXT: (CXXConstructExpr, [B1.11], struct (anonymous struct at {{.*}})) // CHECK-NEXT: 11: struct (anonymous struct at {{.*}}) myAnon; -// CHECK-NEXT: CXXConstructExpr +// WARNINGS-NEXT: (CXXConstructExpr, struct named) +// ANALYZER-NEXT: (CXXConstructExpr, [B1.13], struct named) // CHECK-NEXT: 13: struct named myNamed; // CHECK-NEXT: Preds (1): B2 // CHECK-NEXT: Succs (1): B0 @@ -116,7 +130,8 @@ public: // CHECK-NEXT: Succs (1): B1 // CHECK: [B1] // CHECK-NEXT: 1: CFGNewAllocator(A *) -// CHECK-NEXT: 2: (CXXConstructExpr, class A) +// WARNINGS-NEXT: 2: (CXXConstructExpr, class A) +// ANALYZER-NEXT: 2: (CXXConstructExpr, [B1.3], class A) // CHECK-NEXT: 3: new A([B1.2]) // CHECK-NEXT: 4: A *a = new A(); // CHECK-NEXT: 5: a @@ -138,7 +153,8 @@ void test_deletedtor() { // CHECK: [B1] // CHECK-NEXT: 1: 5 // CHECK-NEXT: 2: CFGNewAllocator(A *) -// CHECK-NEXT: 3: (CXXConstructExpr, class A [5]) +// WARNINGS-NEXT: 3: (CXXConstructExpr, class A [5]) +// ANALYZER-NEXT: 3: (CXXConstructExpr, [B1.4], class A [5]) // CHECK-NEXT: 4: new A {{\[\[}}B1.1]] // CHECK-NEXT: 5: A *a = new A [5]; // CHECK-NEXT: 6: a @@ -331,7 +347,8 @@ int test_enum_with_extension_default(enum MyEnum value) { // CHECK-NEXT: 3: [B1.2] (ImplicitCastExpr, ArrayToPointerDecay, int *) // CHECK-NEXT: 4: [B1.3] (ImplicitCastExpr, BitCast, void *) // CHECK-NEXT: 5: CFGNewAllocator(MyClass *) -// CHECK-NEXT: 6: (CXXConstructExpr, class MyClass) +// WARNINGS-NEXT: 6: (CXXConstructExpr, class MyClass) +// ANALYZER-NEXT: 6: (CXXConstructExpr, [B1.7], class MyClass) // CHECK-NEXT: 7: new ([B1.4]) MyClass([B1.6]) // CHECK-NEXT: 8: MyClass *obj = new (buffer) MyClass(); // CHECK-NEXT: Preds (1): B2 @@ -363,7 +380,8 @@ void test_placement_new() { // CHECK-NEXT: 4: [B1.3] (ImplicitCastExpr, BitCast, void *) // CHECK-NEXT: 5: 5 // CHECK-NEXT: 6: CFGNewAllocator(MyClass *) -// CHECK-NEXT: 7: (CXXConstructExpr, class MyClass [5]) +// WARNINGS-NEXT: 7: (CXXConstructExpr, class MyClass [5]) +// ANALYZER-NEXT: 7: (CXXConstructExpr, [B1.8], class MyClass [5]) // CHECK-NEXT: 8: new ([B1.4]) MyClass {{\[\[}}B1.5]] // CHECK-NEXT: 9: MyClass *obj = new (buffer) MyClass [5]; // CHECK-NEXT: Preds (1): B2 diff --git a/test/Analysis/conditional-path-notes.c b/test/Analysis/conditional-path-notes.c index d842b7fc6eef..8fc27be391be 100644 --- a/test/Analysis/conditional-path-notes.c +++ b/test/Analysis/conditional-path-notes.c @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 %s -analyzer-checker=core.NullDereference -analyzer-output=text -verify -// RUN: %clang_analyze_cc1 %s -analyzer-checker=core.NullDereference -analyzer-output=plist -analyzer-config path-diagnostics-alternate=false -o %t +// RUN: %clang_analyze_cc1 %s -analyzer-checker=core.NullDereference -analyzer-output=plist -o %t // RUN: FileCheck --input-file=%t %s void testCondOp(int *p) { @@ -78,6 +78,7 @@ void testDiagnosableBranchLogical(int a, int b) { void testNonDiagnosableBranchArithmetic(int a, int b) { if (a - b) { // expected-note@-1 {{Taking true branch}} + // expected-note@-2 {{Assuming the condition is true}} *(volatile int *)0 = 1; // expected-warning{{Dereference of null pointer}} // expected-note@-1 {{Dereference of null pointer}} } @@ -270,6 +271,40 @@ void testNonDiagnosableBranchArithmetic(int a, int b) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>10</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>10</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -416,6 +451,40 @@ void testNonDiagnosableBranchArithmetic(int a, int b) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -770,108 +839,6 @@ void testNonDiagnosableBranchArithmetic(int a, int b) { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -922,6 +889,40 @@ void testNonDiagnosableBranchArithmetic(int a, int b) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>44</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>44</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>44</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>44</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>44</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1068,6 +1069,40 @@ void testNonDiagnosableBranchArithmetic(int a, int b) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>53</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>53</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>53</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>53</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>53</integer> // CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1573,12 +1608,75 @@ void testNonDiagnosableBranchArithmetic(int a, int b) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>81</integer> +// CHECK-NEXT: <key>line</key><integer>79</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>79</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>79</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>79</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>79</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Assuming the condition is true</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Assuming the condition is true</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>79</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>79</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>82</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>81</integer> +// CHECK-NEXT: <key>line</key><integer>82</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1594,12 +1692,12 @@ void testNonDiagnosableBranchArithmetic(int a, int b) { // CHECK-NEXT: <key>start</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>81</integer> +// CHECK-NEXT: <key>line</key><integer>82</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>81</integer> +// CHECK-NEXT: <key>line</key><integer>82</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1607,12 +1705,12 @@ void testNonDiagnosableBranchArithmetic(int a, int b) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>81</integer> +// CHECK-NEXT: <key>line</key><integer>82</integer> // CHECK-NEXT: <key>col</key><integer>24</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>81</integer> +// CHECK-NEXT: <key>line</key><integer>82</integer> // CHECK-NEXT: <key>col</key><integer>24</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1624,7 +1722,7 @@ void testNonDiagnosableBranchArithmetic(int a, int b) { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>81</integer> +// CHECK-NEXT: <key>line</key><integer>82</integer> // CHECK-NEXT: <key>col</key><integer>24</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1632,12 +1730,12 @@ void testNonDiagnosableBranchArithmetic(int a, int b) { // CHECK-NEXT: <array> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>81</integer> +// CHECK-NEXT: <key>line</key><integer>82</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>81</integer> +// CHECK-NEXT: <key>line</key><integer>82</integer> // CHECK-NEXT: <key>col</key><integer>26</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1658,10 +1756,10 @@ void testNonDiagnosableBranchArithmetic(int a, int b) { // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>f56671e5f67c73abef619b56f7c29fa4</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context</key><string>testNonDiagnosableBranchArithmetic</string> -// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> +// CHECK-NEXT: <key>issue_hash_function_offset</key><string>4</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>81</integer> +// CHECK-NEXT: <key>line</key><integer>82</integer> // CHECK-NEXT: <key>col</key><integer>24</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> diff --git a/test/Analysis/const-method-call.cpp b/test/Analysis/const-method-call.cpp index 17df2a016b89..a5a38929c22f 100644 --- a/test/Analysis/const-method-call.cpp +++ b/test/Analysis/const-method-call.cpp @@ -6,6 +6,14 @@ struct A { int x; void foo() const; void bar(); + + void testImplicitThisSyntax() { + x = 3; + foo(); + clang_analyzer_eval(x == 3); // expected-warning{{TRUE}} + bar(); + clang_analyzer_eval(x == 3); // expected-warning{{UNKNOWN}} + } }; struct B { @@ -108,6 +116,22 @@ void checkThatContainedConstMethodDoesNotInvalidateObjects() { clang_analyzer_eval(t.in.x == 2); // expected-warning{{TRUE}} } +void checkPointerTypedThisExpression(A *a) { + a->x = 3; + a->foo(); + clang_analyzer_eval(a->x == 3); // expected-warning{{TRUE}} + a->bar(); + clang_analyzer_eval(a->x == 3); // expected-warning{{UNKNOWN}} +} + +void checkReferenceTypedThisExpression(A &a) { + a.x = 3; + a.foo(); + clang_analyzer_eval(a.x == 3); // expected-warning{{TRUE}} + a.bar(); + clang_analyzer_eval(a.x == 3); // expected-warning{{UNKNOWN}} +} + // --- Versions of the above tests where the const method is inherited --- // struct B1 { diff --git a/test/Analysis/constant-folding.c b/test/Analysis/constant-folding.c index 8189868be2ec..e21d629e9a41 100644 --- a/test/Analysis/constant-folding.c +++ b/test/Analysis/constant-folding.c @@ -108,7 +108,11 @@ void testBitwiseRules(unsigned int a, int b) { clang_analyzer_eval((b | -2) == 0); // expected-warning{{FALSE}} clang_analyzer_eval((b | 10) == 0); // expected-warning{{FALSE}} clang_analyzer_eval((b | 0) == 0); // expected-warning{{UNKNOWN}} +#ifdef ANALYZER_CM_Z3 + clang_analyzer_eval((b | -2) >= 0); // expected-warning{{FALSE}} +#else clang_analyzer_eval((b | -2) >= 0); // expected-warning{{UNKNOWN}} +#endif // Check that dynamically computed constants also work. int constant = 1 << 3; diff --git a/test/Analysis/constraint_manager_negate_difference.c b/test/Analysis/constraint_manager_negate_difference.c new file mode 100644 index 000000000000..2236c1693b90 --- /dev/null +++ b/test/Analysis/constraint_manager_negate_difference.c @@ -0,0 +1,98 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.ExprInspection,core.builtin -analyzer-config aggressive-binary-operation-simplification=true -verify %s + +void clang_analyzer_eval(int); + +void exit(int); + +#define UINT_MAX (~0U) +#define INT_MAX (UINT_MAX & (UINT_MAX >> 1)) +#define INT_MIN (UINT_MAX & ~(UINT_MAX >> 1)) + +extern void __assert_fail (__const char *__assertion, __const char *__file, + unsigned int __line, __const char *__function) + __attribute__ ((__noreturn__)); +#define assert(expr) \ + ((expr) ? (void)(0) : __assert_fail (#expr, __FILE__, __LINE__, __func__)) + +void assert_in_range(int x) { + assert(x <= ((int)INT_MAX / 4)); + assert(x >= -(((int)INT_MAX) / 4)); +} + +void assert_in_wide_range(int x) { + assert(x <= ((int)INT_MAX / 2)); + assert(x >= -(((int)INT_MAX) / 2)); +} + +void assert_in_range_2(int m, int n) { + assert_in_range(m); + assert_in_range(n); +} + +void equal(int m, int n) { + assert_in_range_2(m, n); + if (m != n) + return; + assert_in_wide_range(m - n); + clang_analyzer_eval(n == m); // expected-warning{{TRUE}} +} + +void non_equal(int m, int n) { + assert_in_range_2(m, n); + if (m == n) + return; + assert_in_wide_range(m - n); + clang_analyzer_eval(n != m); // expected-warning{{TRUE}} +} + +void less_or_equal(int m, int n) { + assert_in_range_2(m, n); + if (m < n) + return; + assert_in_wide_range(m - n); + clang_analyzer_eval(n <= m); // expected-warning{{TRUE}} +} + +void less(int m, int n) { + assert_in_range_2(m, n); + if (m <= n) + return; + assert_in_wide_range(m - n); + clang_analyzer_eval(n < m); // expected-warning{{TRUE}} +} + +void greater_or_equal(int m, int n) { + assert_in_range_2(m, n); + if (m > n) + return; + assert_in_wide_range(m - n); + clang_analyzer_eval(n >= m); // expected-warning{{TRUE}} +} + +void greater(int m, int n) { + assert_in_range_2(m, n); + if (m >= n) + return; + assert_in_wide_range(m - n); + clang_analyzer_eval(n > m); // expected-warning{{TRUE}} +} + +void negate_positive_range(int m, int n) { + if (m - n <= 0) + return; + clang_analyzer_eval(n - m < 0); // expected-warning{{TRUE}} + clang_analyzer_eval(n - m > INT_MIN); // expected-warning{{TRUE}} + clang_analyzer_eval(n - m == INT_MIN); // expected-warning{{FALSE}} +} + +void negate_int_min(int m, int n) { + if (m - n != INT_MIN) + return; + clang_analyzer_eval(n - m == INT_MIN); // expected-warning{{TRUE}} +} + +void negate_mixed(int m, int n) { + if (m -n > INT_MIN && m - n <= 0) + return; + clang_analyzer_eval(n - m <= 0); // expected-warning{{TRUE}} +} diff --git a/test/Analysis/copypaste/macro-complexity.cpp b/test/Analysis/copypaste/macro-complexity.cpp index 70d3f0c74820..656f91189b4f 100644 --- a/test/Analysis/copypaste/macro-complexity.cpp +++ b/test/Analysis/copypaste/macro-complexity.cpp @@ -1,7 +1,7 @@ // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=alpha.clone.CloneChecker -analyzer-config alpha.clone.CloneChecker:MinimumCloneComplexity=10 -verify %s // Tests that the complexity value of a macro expansion is about the same as -// the complexity value of a normal function call and the the macro body doesn't +// the complexity value of a normal function call and the macro body doesn't // influence the complexity. See the CloneSignature class in CloneDetection.h // for more information about complexity values of clones. @@ -20,7 +20,7 @@ int manualMacroClone(int a, int b) { // expected-note{{Similar code here}} } // Now we actually use the macro to generate the same AST as above. They -// shouldn't be reported because the macros only slighly increase the complexity +// shouldn't be reported because the macros only slightly increase the complexity // value and the resulting code will never pass the MinimumCloneComplexity // constraint. diff --git a/test/Analysis/copypaste/plist-diagnostics.cpp b/test/Analysis/copypaste/plist-diagnostics.cpp index c138c6f1f92a..38237b03c95f 100644 --- a/test/Analysis/copypaste/plist-diagnostics.cpp +++ b/test/Analysis/copypaste/plist-diagnostics.cpp @@ -17,12 +17,39 @@ int maxClone(int a, int b) { // expected-note{{Similar code here}} return b; } -// FIXME: This plist output doesn't include the extra note on line 13. -// It should be updated once the format for extra notes in plists is defined. - // CHECK: <key>diagnostics</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>notes</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>13</integer> +// CHECK-NEXT: <key>col</key><integer>28</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>13</integer> +// CHECK-NEXT: <key>col</key><integer>28</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>18</integer> +// CHECK-NEXT: <key>col</key><integer>1</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Similar code here</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Similar code here</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> diff --git a/test/Analysis/crash-trace.c b/test/Analysis/crash-trace.c index b79dd02e6b43..ef1763ef97a5 100644 --- a/test/Analysis/crash-trace.c +++ b/test/Analysis/crash-trace.c @@ -18,6 +18,6 @@ void test() { // CHECK: 0. Program arguments: {{.*}}clang // CHECK-NEXT: 1. <eof> parser at end of file // CHECK-NEXT: 2. While analyzing stack: -// CHECK-NEXT: #0 void inlined() -// CHECK-NEXT: #1 void test() +// CHECK-NEXT: #0 Calling inlined at line 15 +// CHECK-NEXT: #1 Calling test // CHECK-NEXT: 3. {{.*}}crash-trace.c:{{[0-9]+}}:3: Error evaluating statement diff --git a/test/Analysis/cstring-plist.c b/test/Analysis/cstring-plist.c new file mode 100644 index 000000000000..19d0e46fd366 --- /dev/null +++ b/test/Analysis/cstring-plist.c @@ -0,0 +1,22 @@ +// RUN: rm -f %t +// RUN: %clang_analyze_cc1 -fblocks -analyzer-checker=core,unix.Malloc,unix.cstring.NullArg -analyzer-disable-checker=alpha.unix.cstring.OutOfBounds -analyzer-output=plist -analyzer-config path-diagnostics-alternate=false -o %t %s +// RUN: FileCheck -input-file %t %s + +typedef __typeof(sizeof(int)) size_t; +void *malloc(size_t); +void free(void *); +char *strncpy(char *restrict s1, const char *restrict s2, size_t n); + + + +void cstringchecker_bounds_nocrash() { + char *p = malloc(2); + strncpy(p, "AAA", sizeof("AAA")); // we don't expect warning as the checker is disabled + free(p); +} + +// CHECK: <key>diagnostics</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </plist> diff --git a/test/Analysis/cstring-syntax.c b/test/Analysis/cstring-syntax.c index 313ac5449540..fe1253bedba3 100644 --- a/test/Analysis/cstring-syntax.c +++ b/test/Analysis/cstring-syntax.c @@ -1,8 +1,12 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=unix.cstring.BadSizeArg -analyzer-store=region -Wno-strncat-size -Wno-strlcpy-strlcat-size -Wno-sizeof-array-argument -Wno-sizeof-pointer-memaccess -verify %s +// RUN: %clang_analyze_cc1 -triple armv7-a15-linux -analyzer-checker=unix.cstring.BadSizeArg -analyzer-store=region -Wno-strncat-size -Wno-strlcpy-strlcat-size -Wno-sizeof-array-argument -Wno-sizeof-pointer-memaccess -verify %s +// RUN: %clang_analyze_cc1 -triple aarch64_be-none-linux-gnu -analyzer-checker=unix.cstring.BadSizeArg -analyzer-store=region -Wno-strncat-size -Wno-strlcpy-strlcat-size -Wno-sizeof-array-argument -Wno-sizeof-pointer-memaccess -verify %s +// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -analyzer-checker=unix.cstring.BadSizeArg -analyzer-store=region -Wno-strncat-size -Wno-strlcpy-strlcat-size -Wno-sizeof-array-argument -Wno-sizeof-pointer-memaccess -verify %s typedef __SIZE_TYPE__ size_t; char *strncat(char *, const char *, size_t); size_t strlen (const char *s); +size_t strlcpy(char *, const char *, size_t); void testStrncat(const char *src) { char dest[10]; @@ -13,3 +17,19 @@ void testStrncat(const char *src) { // Should not crash when sizeof has a type argument. strncat(dest, "AAAAAAAAAAAAAAAAAAAAAAAAAAA", sizeof(char)); } + +void testStrlcpy(const char *src) { + char dest[10]; + size_t destlen = sizeof(dest); + size_t srclen = sizeof(src); + size_t badlen = 20; + size_t ulen; + strlcpy(dest, src, sizeof(dest)); + strlcpy(dest, src, destlen); + strlcpy(dest, src, 10); + strlcpy(dest, src, 20); // expected-warning {{The third argument is larger than the size of the input buffer. Replace with the value 'sizeof(dest)` or lower}} + strlcpy(dest, src, badlen); // expected-warning {{The third argument is larger than the size of the input buffer. Replace with the value 'sizeof(dest)` or lower}} + strlcpy(dest, src, ulen); + strlcpy(dest + 5, src, 5); + strlcpy(dest + 5, src, 10); // expected-warning {{The third argument is larger than the size of the input buffer.}} +} diff --git a/test/Analysis/ctor.mm b/test/Analysis/ctor.mm index e903263431fc..751cdb944dc7 100644 --- a/test/Analysis/ctor.mm +++ b/test/Analysis/ctor.mm @@ -1,4 +1,7 @@ -// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -fobjc-arc -analyzer-config c++-inlining=constructors -Wno-null-dereference -std=c++11 -verify %s +// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -DI386 -analyzer-checker=core,debug.ExprInspection -fobjc-arc -analyzer-config c++-inlining=constructors -Wno-null-dereference -std=c++11 -verify %s +// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -DI386 -analyzer-checker=core,debug.ExprInspection -fobjc-arc -analyzer-config c++-inlining=constructors -Wno-null-dereference -std=c++11 -verify -DTEST_INLINABLE_ALLOCATORS %s +// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin12 -analyzer-checker=core,debug.ExprInspection -fobjc-arc -analyzer-config c++-inlining=constructors -Wno-null-dereference -std=c++11 -verify %s +// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin12 -analyzer-checker=core,debug.ExprInspection -fobjc-arc -analyzer-config c++-inlining=constructors -Wno-null-dereference -std=c++11 -verify -DTEST_INLINABLE_ALLOCATORS %s #include "Inputs/system-header-simulator-cxx.h" @@ -572,10 +575,9 @@ namespace ZeroInitialization { } void testNew() { - // FIXME: Pending proper implementation of constructors for 'new'. raw_pair *pp = new raw_pair(); - clang_analyzer_eval(pp->p1 == 0); // expected-warning{{UNKNOWN}} - clang_analyzer_eval(pp->p2 == 0); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(pp->p1 == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(pp->p2 == 0); // expected-warning{{TRUE}} } void testArrayNew() { @@ -638,12 +640,15 @@ namespace ZeroInitialization { class Empty { public: - Empty(); + static int glob; + Empty(); // No body. + Empty(int x); // Body below. }; class PairContainer : public Empty { - raw_pair p; public: + raw_pair p; + int q; PairContainer() : Empty(), p() { // This previously caused a crash because the empty base class looked // like an initialization of 'p'. @@ -651,8 +656,52 @@ namespace ZeroInitialization { PairContainer(int) : Empty(), p() { // Test inlining something else here. } + PairContainer(double): Empty(1), p() { + clang_analyzer_eval(p.p1 == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(p.p2 == 0); // expected-warning{{TRUE}} + + clang_analyzer_eval(q == 1); // expected-warning{{TRUE}} + + // This one's indeed UNKNOWN. Definitely not TRUE. + clang_analyzer_eval(p.p2 == glob); // expected-warning{{UNKNOWN}} + } }; + Empty::Empty(int x) { + static_cast<PairContainer *>(this)->p.p1 = x; + static_cast<PairContainer *>(this)->q = x; + // Our static member will store the old garbage values of fields that aren't + // yet initialized. It's not certainly garbage though (i.e. the constructor + // could have been called on an initialized piece of memory), so no + // uninitialized value warning here, and it should be a symbol, not + // undefined value, for later comparison. + glob = static_cast<PairContainer *>(this)->p.p2; + } + + class Empty2 { + public: + static int glob_p1, glob_p2; + Empty2(); // Body below. + }; + + class PairDoubleEmptyContainer: public Empty, public Empty2 { + public: + raw_pair p; + PairDoubleEmptyContainer(): Empty(), Empty2(), p() { + clang_analyzer_eval(p.p1 == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(p.p2 == 0); // expected-warning{{TRUE}} + + // This is indeed UNKNOWN. + clang_analyzer_eval(p.p1 == glob_p1); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(p.p2 == glob_p2); // expected-warning{{UNKNOWN}} + } + }; + + Empty2::Empty2() { + glob_p1 = static_cast<PairDoubleEmptyContainer *>(this)->p.p1; + glob_p2 = static_cast<PairDoubleEmptyContainer *>(this)->p.p2; + } + class PairContainerContainer { int padding; PairContainer pc; @@ -679,8 +728,7 @@ namespace InitializerList { void testDynamic() { List *list = new List{1, 2}; - // FIXME: When we handle constructors with 'new', this will be TRUE. - clang_analyzer_eval(list->usedInitializerList); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(list->usedInitializerList); // expected-warning{{TRUE}} } } @@ -730,3 +778,87 @@ namespace NoCrashOnEmptyBaseOptimization { S s; } } + +namespace EmptyBaseAssign { +struct B1 {}; +struct B2 { int x; }; +struct D: public B1, public B2 { +const D &operator=(const D &d) { + *((B2 *)this) = d; + *((B1 *)this) = d; + return *this; +} +}; + +void test() { + D d1; + d1.x = 1; + D d2; + d2 = d1; + clang_analyzer_eval(d2.x == 1); // expected-warning{{TRUE}} +} +} + +namespace vbase_zero_init { +class A { + virtual void foo(); +}; + +class B { + virtual void bar(); +public: + static int glob_y, glob_z, glob_w; + int x; + B(); // Body below. +}; + +class C : virtual public A { +public: + int y; +}; + +class D : public B, public C { +public: + // 'z', unlike 'w', resides in an area that would have been within padding of + // base class 'C' if it wasn't part of 'D', but only on 64-bit systems. + int z, w; + // Initialization order: A(), B(), C(). + D() : A(), C() { + clang_analyzer_eval(x == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(y == 0); // expected-warning{{TRUE}} +#ifdef I386 + clang_analyzer_eval(z == 3); // expected-warning{{TRUE}} +#else + // FIXME: Should be TRUE. Initialized in B(). + clang_analyzer_eval(z == 3); // expected-warning{{UNKNOWN}} +#endif + clang_analyzer_eval(w == 4); // expected-warning{{TRUE}} + + // FIXME: Should be UNKNOWN. Changed in B() since glob_y was assigned. + clang_analyzer_eval(y == glob_y); // expected-warning{{TRUE}} + +#ifdef I386 + clang_analyzer_eval(z == glob_z); // expected-warning{{UNKNOWN}} +#else + // FIXME: Should be UNKNOWN. Changed in B() since glob_z was assigned. + clang_analyzer_eval(z == glob_z); // expected-warning{{TRUE}} +#endif + + clang_analyzer_eval(w == glob_w); // expected-warning{{UNKNOWN}} + } // no-crash +}; + +B::B() : x(1) { + // Our static members will store the old garbage values of fields that aren't + // yet initialized. These aren't certainly garbage though (i.e. the + // constructor could have been called on an initialized piece of memory), + // so no uninitialized value warning here, and these should be symbols, not + // undefined values, for later comparison. + glob_y = static_cast<D *>(this)->y; + glob_z = static_cast<D *>(this)->z; + glob_w = static_cast<D *>(this)->w; + static_cast<D *>(this)->y = 2; + static_cast<D *>(this)->z = 3; + static_cast<D *>(this)->w = 4; +} +} diff --git a/test/Analysis/ctu-hdr.h b/test/Analysis/ctu-hdr.h new file mode 100644 index 000000000000..5a1e694d0686 --- /dev/null +++ b/test/Analysis/ctu-hdr.h @@ -0,0 +1,3 @@ +#define MACRODIAG() clang_analyzer_warnIfReached() + +void clang_analyzer_warnIfReached(); diff --git a/test/Analysis/ctu-main.cpp b/test/Analysis/ctu-main.cpp new file mode 100644 index 000000000000..33da84962cef --- /dev/null +++ b/test/Analysis/ctu-main.cpp @@ -0,0 +1,68 @@ +// RUN: mkdir -p %T/ctudir +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -emit-pch -o %T/ctudir/ctu-other.cpp.ast %S/Inputs/ctu-other.cpp +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -emit-pch -o %T/ctudir/ctu-chain.cpp.ast %S/Inputs/ctu-chain.cpp +// RUN: cp %S/Inputs/externalFnMap.txt %T/ctudir/ +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fsyntax-only -analyze -analyzer-checker=core,debug.ExprInspection -analyzer-config experimental-enable-naive-ctu-analysis=true -analyzer-config ctu-dir=%T/ctudir -verify %s + +#include "ctu-hdr.h" + +void clang_analyzer_eval(int); + +int f(int); +int g(int); +int h(int); + +int callback_to_main(int x) { return x + 1; } + +namespace myns { +int fns(int x); + +namespace embed_ns { +int fens(int x); +} + +class embed_cls { +public: + int fecl(int x); +}; +} + +class mycls { +public: + int fcl(int x); + static int fscl(int x); + + class embed_cls2 { + public: + int fecl2(int x); + }; +}; + +namespace chns { +int chf1(int x); +} + +int fun_using_anon_struct(int); +int other_macro_diag(int); + +int main() { + clang_analyzer_eval(f(3) == 2); // expected-warning{{TRUE}} + clang_analyzer_eval(f(4) == 3); // expected-warning{{TRUE}} + clang_analyzer_eval(f(5) == 3); // expected-warning{{FALSE}} + clang_analyzer_eval(g(4) == 6); // expected-warning{{TRUE}} + clang_analyzer_eval(h(2) == 8); // expected-warning{{TRUE}} + + clang_analyzer_eval(myns::fns(2) == 9); // expected-warning{{TRUE}} + clang_analyzer_eval(myns::embed_ns::fens(2) == -1); // expected-warning{{TRUE}} + clang_analyzer_eval(mycls().fcl(1) == 6); // expected-warning{{TRUE}} + clang_analyzer_eval(mycls::fscl(1) == 7); // expected-warning{{TRUE}} + clang_analyzer_eval(myns::embed_cls().fecl(1) == -6); // expected-warning{{TRUE}} + clang_analyzer_eval(mycls::embed_cls2().fecl2(0) == -11); // expected-warning{{TRUE}} + + clang_analyzer_eval(chns::chf1(4) == 12); // expected-warning{{TRUE}} + clang_analyzer_eval(fun_using_anon_struct(8) == 8); // expected-warning{{TRUE}} + + clang_analyzer_eval(other_macro_diag(1) == 1); // expected-warning{{TRUE}} + // expected-warning@Inputs/ctu-other.cpp:75{{REACHABLE}} + MACRODIAG(); // expected-warning{{REACHABLE}} +} diff --git a/test/Analysis/cxx-for-range.cpp b/test/Analysis/cxx-for-range.cpp index bf3cfbff1231..d1a689b62cdb 100644 --- a/test/Analysis/cxx-for-range.cpp +++ b/test/Analysis/cxx-for-range.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core -analyzer-config path-diagnostics-alternate=true -analyzer-output=plist-multi-file -o %t.plist -verify %s +// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core -analyzer-output=plist-multi-file -o %t.plist -verify %s // RUN: FileCheck --input-file=%t.plist %s extern void work(); diff --git a/test/Analysis/cxx-uninitialized-object-inheritance.cpp b/test/Analysis/cxx-uninitialized-object-inheritance.cpp new file mode 100644 index 000000000000..3b048b759e13 --- /dev/null +++ b/test/Analysis/cxx-uninitialized-object-inheritance.cpp @@ -0,0 +1,775 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.cplusplus.UninitializedObject -analyzer-config alpha.cplusplus.UninitializedObject:Pedantic=true -std=c++11 -verify %s + +//===----------------------------------------------------------------------===// +// Non-polymorphic inheritance tests +//===----------------------------------------------------------------------===// + +class NonPolymorphicLeft1 { + int x; + +protected: + int y; + +public: + NonPolymorphicLeft1() = default; + NonPolymorphicLeft1(int) : x(1) {} +}; + +class NonPolymorphicInheritanceTest1 : public NonPolymorphicLeft1 { + int z; + +public: + NonPolymorphicInheritanceTest1() + : NonPolymorphicLeft1(int{}) { + y = 2; + z = 3; + // All good! + } +}; + +void fNonPolymorphicInheritanceTest1() { + NonPolymorphicInheritanceTest1(); +} + +class NonPolymorphicBaseClass2 { + int x; // expected-note{{uninitialized field 'this->x'}} +protected: + int y; + +public: + NonPolymorphicBaseClass2() = default; + NonPolymorphicBaseClass2(int) : x(4) {} +}; + +class NonPolymorphicInheritanceTest2 : public NonPolymorphicBaseClass2 { + int z; + +public: + NonPolymorphicInheritanceTest2() { + y = 5; + z = 6; // expected-warning{{1 uninitialized field}} + } +}; + +void fNonPolymorphicInheritanceTest2() { + NonPolymorphicInheritanceTest2(); +} + +class NonPolymorphicBaseClass3 { + int x; + +protected: + int y; // expected-note{{uninitialized field 'this->y'}} +public: + NonPolymorphicBaseClass3() = default; + NonPolymorphicBaseClass3(int) : x(7) {} +}; + +class NonPolymorphicInheritanceTest3 : public NonPolymorphicBaseClass3 { + int z; + +public: + NonPolymorphicInheritanceTest3() + : NonPolymorphicBaseClass3(int{}) { + z = 8; // expected-warning{{1 uninitialized field}} + } +}; + +void fNonPolymorphicInheritanceTest3() { + NonPolymorphicInheritanceTest3(); +} + +class NonPolymorphicBaseClass4 { + int x; + +protected: + int y; + +public: + NonPolymorphicBaseClass4() = default; + NonPolymorphicBaseClass4(int) : x(9) {} +}; + +class NonPolymorphicInheritanceTest4 : public NonPolymorphicBaseClass4 { + int z; // expected-note{{uninitialized field 'this->z'}} + +public: + NonPolymorphicInheritanceTest4() + : NonPolymorphicBaseClass4(int{}) { + y = 10; // expected-warning{{1 uninitialized field}} + } +}; + +void fNonPolymorphicInheritanceTest4() { + NonPolymorphicInheritanceTest4(); +} + +//===----------------------------------------------------------------------===// +// Polymorphic inheritance tests +//===----------------------------------------------------------------------===// + +class PolymorphicLeft1 { + int x; + +protected: + int y; + +public: + virtual ~PolymorphicLeft1() = default; + PolymorphicLeft1() = default; + PolymorphicLeft1(int) : x(11) {} +}; + +class PolymorphicInheritanceTest1 : public PolymorphicLeft1 { + int z; + +public: + PolymorphicInheritanceTest1() + : PolymorphicLeft1(int{}) { + y = 12; + z = 13; + // All good! + } +}; + +void fPolymorphicInheritanceTest1() { + PolymorphicInheritanceTest1(); +} + +class PolymorphicRight1 { + int x; // expected-note{{uninitialized field 'this->x'}} +protected: + int y; + +public: + virtual ~PolymorphicRight1() = default; + PolymorphicRight1() = default; + PolymorphicRight1(int) : x(14) {} +}; + +class PolymorphicInheritanceTest2 : public PolymorphicRight1 { + int z; + +public: + PolymorphicInheritanceTest2() { + y = 15; + z = 16; // expected-warning{{1 uninitialized field}} + } +}; + +void fPolymorphicInheritanceTest2() { + PolymorphicInheritanceTest2(); +} + +class PolymorphicBaseClass3 { + int x; + +protected: + int y; // expected-note{{uninitialized field 'this->y'}} +public: + virtual ~PolymorphicBaseClass3() = default; + PolymorphicBaseClass3() = default; + PolymorphicBaseClass3(int) : x(17) {} +}; + +class PolymorphicInheritanceTest3 : public PolymorphicBaseClass3 { + int z; + +public: + PolymorphicInheritanceTest3() + : PolymorphicBaseClass3(int{}) { + z = 18; // expected-warning{{1 uninitialized field}} + } +}; + +void fPolymorphicInheritanceTest3() { + PolymorphicInheritanceTest3(); +} + +class PolymorphicBaseClass4 { + int x; + +protected: + int y; + +public: + virtual ~PolymorphicBaseClass4() = default; + PolymorphicBaseClass4() = default; + PolymorphicBaseClass4(int) : x(19) {} +}; + +class PolymorphicInheritanceTest4 : public PolymorphicBaseClass4 { + int z; // expected-note{{uninitialized field 'this->z'}} + +public: + PolymorphicInheritanceTest4() + : PolymorphicBaseClass4(int{}) { + y = 20; // expected-warning{{1 uninitialized field}} + } +}; + +void fPolymorphicInheritanceTest4() { + PolymorphicInheritanceTest4(); +} + +//===----------------------------------------------------------------------===// +// Virtual inheritance tests +//===----------------------------------------------------------------------===// + +class VirtualPolymorphicLeft1 { + int x; + +protected: + int y; + +public: + virtual ~VirtualPolymorphicLeft1() = default; + VirtualPolymorphicLeft1() = default; + VirtualPolymorphicLeft1(int) : x(21) {} +}; + +class VirtualInheritanceTest1 : virtual public VirtualPolymorphicLeft1 { + int z; + +public: + VirtualInheritanceTest1() + : VirtualPolymorphicLeft1(int()) { + y = 22; + z = 23; + // All good! + } +}; + +void fVirtualInheritanceTest1() { + VirtualInheritanceTest1(); +} + +class VirtualPolymorphicRight1 { + int x; // expected-note{{uninitialized field 'this->x'}} +protected: + int y; + +public: + virtual ~VirtualPolymorphicRight1() = default; + VirtualPolymorphicRight1() = default; + VirtualPolymorphicRight1(int) : x(24) {} +}; + +class VirtualInheritanceTest2 : virtual public VirtualPolymorphicRight1 { + int z; + +public: + VirtualInheritanceTest2() { + y = 25; + z = 26; // expected-warning{{1 uninitialized field}} + } +}; + +void fVirtualInheritanceTest2() { + VirtualInheritanceTest2(); +} + +class VirtualPolymorphicBaseClass3 { + int x; + +protected: + int y; // expected-note{{uninitialized field 'this->y'}} +public: + virtual ~VirtualPolymorphicBaseClass3() = default; + VirtualPolymorphicBaseClass3() = default; + VirtualPolymorphicBaseClass3(int) : x(27) {} +}; + +class VirtualInheritanceTest3 : virtual public VirtualPolymorphicBaseClass3 { + int z; + +public: + VirtualInheritanceTest3() + : VirtualPolymorphicBaseClass3(int{}) { + z = 28; // expected-warning{{1 uninitialized field}} + } +}; + +void fVirtualInheritanceTest3() { + VirtualInheritanceTest3(); +} + +//===----------------------------------------------------------------------===// +// Multiple inheritance tests +//===----------------------------------------------------------------------===// + +/* + Left Right + \ / + \ / + \ / + MultipleInheritanceTest +*/ + +struct Left1 { + int x; + Left1() = default; + Left1(int) : x(29) {} +}; +struct Right1 { + int y; + Right1() = default; + Right1(int) : y(30) {} +}; + +class MultipleInheritanceTest1 : public Left1, public Right1 { + int z; + +public: + MultipleInheritanceTest1() + : Left1(int{}), + Right1(char{}) { + z = 31; + // All good! + } + + MultipleInheritanceTest1(int) + : Left1(int{}) { + y = 32; + z = 33; + // All good! + } + + MultipleInheritanceTest1(int, int) + : Right1(char{}) { + x = 34; + z = 35; + // All good! + } +}; + +void fMultipleInheritanceTest1() { + MultipleInheritanceTest1(); + MultipleInheritanceTest1(int()); + MultipleInheritanceTest1(int(), int()); +} + +struct Left2 { + int x; + Left2() = default; + Left2(int) : x(36) {} +}; +struct Right2 { + int y; // expected-note{{uninitialized field 'this->y'}} + Right2() = default; + Right2(int) : y(37) {} +}; + +class MultipleInheritanceTest2 : public Left2, public Right2 { + int z; + +public: + MultipleInheritanceTest2() + : Left2(int{}) { + z = 38; // expected-warning{{1 uninitialized field}} + } +}; + +void fMultipleInheritanceTest2() { + MultipleInheritanceTest2(); +} + +struct Left3 { + int x; // expected-note{{uninitialized field 'this->x'}} + Left3() = default; + Left3(int) : x(39) {} +}; +struct Right3 { + int y; + Right3() = default; + Right3(int) : y(40) {} +}; + +class MultipleInheritanceTest3 : public Left3, public Right3 { + int z; + +public: + MultipleInheritanceTest3() + : Right3(char{}) { + z = 41; // expected-warning{{1 uninitialized field}} + } +}; + +void fMultipleInheritanceTest3() { + MultipleInheritanceTest3(); +} + +struct Left4 { + int x; + Left4() = default; + Left4(int) : x(42) {} +}; +struct Right4 { + int y; + Right4() = default; + Right4(int) : y(43) {} +}; + +class MultipleInheritanceTest4 : public Left4, public Right4 { + int z; // expected-note{{uninitialized field 'this->z'}} + +public: + MultipleInheritanceTest4() + : Left4(int{}), + Right4(char{}) { // expected-warning{{1 uninitialized field}} + } +}; + +void fMultipleInheritanceTest4() { + MultipleInheritanceTest4(); +} + +struct Left5 { + int x; + Left5() = default; + Left5(int) : x(44) {} +}; +struct Right5 { + int y; // expected-note{{uninitialized field 'this->y'}} + Right5() = default; + Right5(int) : y(45) {} +}; + +class MultipleInheritanceTest5 : public Left5, public Right5 { + int z; // expected-note{{uninitialized field 'this->z'}} + +public: + MultipleInheritanceTest5() // expected-warning{{2 uninitialized fields}} + : Left5(int{}) { + } +}; + +void fMultipleInheritanceTest5() { + MultipleInheritanceTest5(); +} + +//===----------------------------------------------------------------------===// +// Non-virtual diamond inheritance tests +//===----------------------------------------------------------------------===// + +/* + NonVirtualBase NonVirtualBase + | | + | | + | | + First Second + \ / + \ / + \ / + NonVirtualDiamondInheritanceTest +*/ + +struct NonVirtualBase1 { + int x; + NonVirtualBase1() = default; + NonVirtualBase1(int) : x(46) {} +}; +struct First1 : public NonVirtualBase1 { + First1() = default; + First1(int) : NonVirtualBase1(int{}) {} +}; +struct Second1 : public NonVirtualBase1 { + Second1() = default; + Second1(int) : NonVirtualBase1(int{}) {} +}; + +class NonVirtualDiamondInheritanceTest1 : public First1, public Second1 { + int z; + +public: + NonVirtualDiamondInheritanceTest1() + : First1(int{}), + Second1(int{}) { + z = 47; + // All good! + } + + NonVirtualDiamondInheritanceTest1(int) + : First1(int{}) { + Second1::x = 48; + z = 49; + // All good! + } + + NonVirtualDiamondInheritanceTest1(int, int) + : Second1(int{}) { + First1::x = 50; + z = 51; + // All good! + } +}; + +void fNonVirtualDiamondInheritanceTest1() { + NonVirtualDiamondInheritanceTest1(); + NonVirtualDiamondInheritanceTest1(int()); + NonVirtualDiamondInheritanceTest1(int(), int()); +} + +struct NonVirtualBase2 { + int x; // expected-note{{uninitialized field 'this->x'}} + NonVirtualBase2() = default; + NonVirtualBase2(int) : x(52) {} +}; +struct First2 : public NonVirtualBase2 { + First2() = default; + First2(int) : NonVirtualBase2(int{}) {} +}; +struct Second2 : public NonVirtualBase2 { + Second2() = default; + Second2(int) : NonVirtualBase2(int{}) {} +}; + +class NonVirtualDiamondInheritanceTest2 : public First2, public Second2 { + int z; + +public: + NonVirtualDiamondInheritanceTest2() + : First2(int{}) { + z = 53; // expected-warning{{1 uninitialized field}} + } +}; + +void fNonVirtualDiamondInheritanceTest2() { + NonVirtualDiamondInheritanceTest2(); +} + +struct NonVirtualBase3 { + int x; // expected-note{{uninitialized field 'this->x'}} + NonVirtualBase3() = default; + NonVirtualBase3(int) : x(54) {} +}; +struct First3 : public NonVirtualBase3 { + First3() = default; + First3(int) : NonVirtualBase3(int{}) {} +}; +struct Second3 : public NonVirtualBase3 { + Second3() = default; + Second3(int) : NonVirtualBase3(int{}) {} +}; + +class NonVirtualDiamondInheritanceTest3 : public First3, public Second3 { + int z; + +public: + NonVirtualDiamondInheritanceTest3() + : Second3(int{}) { + z = 55; // expected-warning{{1 uninitialized field}} + } +}; + +void fNonVirtualDiamondInheritanceTest3() { + NonVirtualDiamondInheritanceTest3(); +} + +struct NonVirtualBase4 { + int x; // expected-note{{uninitialized field 'this->x'}} + // expected-note@-1{{uninitialized field 'this->x'}} + NonVirtualBase4() = default; + NonVirtualBase4(int) : x(56) {} +}; +struct First4 : public NonVirtualBase4 { + First4() = default; + First4(int) : NonVirtualBase4(int{}) {} +}; +struct Second4 : public NonVirtualBase4 { + Second4() = default; + Second4(int) : NonVirtualBase4(int{}) {} +}; + +class NonVirtualDiamondInheritanceTest4 : public First4, public Second4 { + int z; + +public: + NonVirtualDiamondInheritanceTest4() { + z = 57; // expected-warning{{2 uninitialized fields}} + } +}; + +void fNonVirtualDiamondInheritanceTest4() { + NonVirtualDiamondInheritanceTest4(); +} + +struct NonVirtualBase5 { + int x; + NonVirtualBase5() = default; + NonVirtualBase5(int) : x(58) {} +}; +struct First5 : public NonVirtualBase5 { + First5() = default; + First5(int) : NonVirtualBase5(int{}) {} +}; +struct Second5 : public NonVirtualBase5 { + Second5() = default; + Second5(int) : NonVirtualBase5(int{}) {} +}; + +class NonVirtualDiamondInheritanceTest5 : public First5, public Second5 { + int z; // expected-note{{uninitialized field 'this->z'}} + +public: + NonVirtualDiamondInheritanceTest5() + : First5(int{}), + Second5(int{}) { // expected-warning{{1 uninitialized field}} + } +}; + +void fNonVirtualDiamondInheritanceTest5() { + NonVirtualDiamondInheritanceTest5(); +} + +struct NonVirtualBase6 { + int x; // expected-note{{uninitialized field 'this->x'}} + NonVirtualBase6() = default; + NonVirtualBase6(int) : x(59) {} +}; +struct First6 : public NonVirtualBase6 { + First6() = default; + First6(int) : NonVirtualBase6(int{}) {} +}; +struct Second6 : public NonVirtualBase6 { + Second6() = default; + Second6(int) : NonVirtualBase6(int{}) {} +}; + +class NonVirtualDiamondInheritanceTest6 : public First6, public Second6 { + int z; // expected-note{{uninitialized field 'this->z'}} + +public: + NonVirtualDiamondInheritanceTest6() // expected-warning{{2 uninitialized fields}} + : First6(int{}) { + // 'z' and 'Second::x' unintialized + } +}; + +void fNonVirtualDiamondInheritanceTest6() { + NonVirtualDiamondInheritanceTest6(); +} + +//===----------------------------------------------------------------------===// +// Virtual diamond inheritance tests +//===----------------------------------------------------------------------===// + +/* + VirtualBase + / \ + / \ + / \ + VirtualFirst VirtualSecond + \ / + \ / + \ / + VirtualDiamondInheritanceTest +*/ + +struct VirtualBase1 { + int x; + VirtualBase1() = default; + VirtualBase1(int) : x(60) {} +}; +struct VirtualFirst1 : virtual public VirtualBase1 { + VirtualFirst1() = default; + VirtualFirst1(int) : VirtualBase1(int{}) {} + VirtualFirst1(int, int) { x = 61; } +}; +struct VirtualSecond1 : virtual public VirtualBase1 { + VirtualSecond1() = default; + VirtualSecond1(int) : VirtualBase1(int{}) {} + VirtualSecond1(int, int) { x = 62; } +}; + +class VirtualDiamondInheritanceTest1 : public VirtualFirst1, public VirtualSecond1 { + +public: + VirtualDiamondInheritanceTest1() { + x = 0; + // All good! + } + + VirtualDiamondInheritanceTest1(int) + : VirtualFirst1(int{}, int{}), + VirtualSecond1(int{}, int{}) { + // All good! + } + + VirtualDiamondInheritanceTest1(int, int) + : VirtualFirst1(int{}, int{}) { + // All good! + } +}; + +void fVirtualDiamondInheritanceTest1() { + VirtualDiamondInheritanceTest1(); + VirtualDiamondInheritanceTest1(int()); + VirtualDiamondInheritanceTest1(int(), int()); +} + +struct VirtualBase2 { + int x; // expected-note{{uninitialized field 'this->x'}} + VirtualBase2() = default; + VirtualBase2(int) : x(63) {} +}; +struct VirtualFirst2 : virtual public VirtualBase2 { + VirtualFirst2() = default; + VirtualFirst2(int) : VirtualBase2(int{}) {} + VirtualFirst2(int, int) { x = 64; } +}; +struct VirtualSecond2 : virtual public VirtualBase2 { + VirtualSecond2() = default; + VirtualSecond2(int) : VirtualBase2(int{}) {} + VirtualSecond2(int, int) { x = 65; } +}; + +class VirtualDiamondInheritanceTest2 : public VirtualFirst2, public VirtualSecond2 { + +public: + VirtualDiamondInheritanceTest2() // expected-warning{{1 uninitialized field}} + : VirtualFirst2(int{}) { + // From the N4659 C++ Standard Working Draft: + // + // (15.6.2.7) + // [...] A 'mem-initializer' where the 'mem-initializer-id' denotes a + // virtual base class is ignored during execution of a constructor of any + // class that is not the most derived class. + // + // This means that Left1::x will not be initialized, because in both + // VirtualFirst::VirtualFirst(int) and VirtualSecond::VirtualSecond(int) + // the constructor delegation to Left1::Left1(int) will be + // ignored. + } +}; + +void fVirtualDiamondInheritanceTest2() { + VirtualDiamondInheritanceTest2(); +} + +struct VirtualBase3 { + int x; // expected-note{{uninitialized field 'this->x'}} + VirtualBase3() = default; + VirtualBase3(int) : x(66) {} +}; +struct VirtualFirst3 : virtual public VirtualBase3 { + VirtualFirst3() = default; + VirtualFirst3(int) : VirtualBase3(int{}) {} + VirtualFirst3(int, int) { x = 67; } +}; +struct VirtualSecond3 : virtual public VirtualBase3 { + VirtualSecond3() = default; + VirtualSecond3(int) : VirtualBase3(int{}) {} + VirtualSecond3(int, int) { x = 68; } +}; + +class VirtualDiamondInheritanceTest3 : public VirtualFirst3, public VirtualSecond3 { + +public: + VirtualDiamondInheritanceTest3() // expected-warning{{1 uninitialized field}} + : VirtualFirst3(int{}) {} +}; + +void fVirtualDiamondInheritanceTest3() { + VirtualDiamondInheritanceTest3(); +} diff --git a/test/Analysis/cxx-uninitialized-object-notes-as-warnings.cpp b/test/Analysis/cxx-uninitialized-object-notes-as-warnings.cpp new file mode 100644 index 000000000000..a49507a1aa5d --- /dev/null +++ b/test/Analysis/cxx-uninitialized-object-notes-as-warnings.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.cplusplus.UninitializedObject -analyzer-config alpha.cplusplus.UninitializedObject:NotesAsWarnings=true -std=c++11 -verify %s + +class NotesAsWarningsTest { + int a; + int b; + int dontGetFilteredByNonPedanticMode = 0; + +public: + NotesAsWarningsTest() {} // expected-warning{{uninitialized field 'this->a'}} + // expected-warning@-1{{uninitialized field 'this->b'}} +}; + +void fNotesAsWarningsTest() { + NotesAsWarningsTest(); +} diff --git a/test/Analysis/cxx-uninitialized-object-ptr-ref.cpp b/test/Analysis/cxx-uninitialized-object-ptr-ref.cpp new file mode 100644 index 000000000000..1507098c5e75 --- /dev/null +++ b/test/Analysis/cxx-uninitialized-object-ptr-ref.cpp @@ -0,0 +1,695 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.cplusplus.UninitializedObject -analyzer-config alpha.cplusplus.UninitializedObject:Pedantic=true -std=c++11 -DPEDANTIC -verify %s + +// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.cplusplus.UninitializedObject -std=c++11 -verify %s + +//===----------------------------------------------------------------------===// +// Concrete location tests. +//===----------------------------------------------------------------------===// + +struct ConcreteIntLocTest { + int *ptr; + + ConcreteIntLocTest() : ptr(reinterpret_cast<int *>(0xDEADBEEF)) {} +}; + +void fConcreteIntLocTest() { + ConcreteIntLocTest(); +} + +//===----------------------------------------------------------------------===// +// Null pointer tests. +//===----------------------------------------------------------------------===// + +class NullPtrTest { + struct RecordType { + int x; + int y; + }; + + float *fptr = nullptr; + int *ptr; + RecordType *recPtr; + +public: + NullPtrTest() : ptr(nullptr), recPtr(nullptr) { + // All good! + } +}; + +void fNullPtrTest() { + NullPtrTest(); +} + +//===----------------------------------------------------------------------===// +// Heap pointer tests. +//===----------------------------------------------------------------------===// + +class HeapPointerTest1 { + struct RecordType { + // TODO: we'd expect the note: {{uninitialized field 'this->recPtr->y'}} + int x; // no-note + // TODO: we'd expect the note: {{uninitialized field 'this->recPtr->y'}} + int y; // no-note + }; + // TODO: we'd expect the note: {{uninitialized pointee 'this->fptr'}} + float *fptr = new float; // no-note + // TODO: we'd expect the note: {{uninitialized pointee 'this->ptr'}} + int *ptr; // no-note + RecordType *recPtr; + +public: + // TODO: we'd expect the warning: {{4 uninitialized fields}} + HeapPointerTest1() : ptr(new int), recPtr(new RecordType) { // no-note + } +}; + +void fHeapPointerTest1() { + HeapPointerTest1(); +} + +class HeapPointerTest2 { + struct RecordType { + int x; + int y; + }; + + float *fptr = new float(); // initializes to 0 + int *ptr; + RecordType *recPtr; + +public: + HeapPointerTest2() : ptr(new int{25}), recPtr(new RecordType{26, 27}) { + // All good! + } +}; + +void fHeapPointerTest2() { + HeapPointerTest2(); +} + +//===----------------------------------------------------------------------===// +// Stack pointer tests. +//===----------------------------------------------------------------------===// + +class StackPointerTest1 { +public: + struct RecordType { + int x; + int y; + }; + +private: + int *ptr; + RecordType *recPtr; + +public: + StackPointerTest1(int *_ptr, StackPointerTest1::RecordType *_recPtr) : ptr(_ptr), recPtr(_recPtr) { + // All good! + } +}; + +void fStackPointerTest1() { + int ok_a = 28; + StackPointerTest1::RecordType ok_rec{29, 30}; + StackPointerTest1(&ok_a, &ok_rec); // 'a', 'rec.x', 'rec.y' uninitialized +} + +#ifdef PEDANTIC +class StackPointerTest2 { +public: + struct RecordType { + int x; // expected-note{{uninitialized field 'this->recPtr->x'}} + int y; // expected-note{{uninitialized field 'this->recPtr->y'}} + }; + +private: + int *ptr; // expected-note{{uninitialized pointee 'this->ptr'}} + RecordType *recPtr; + +public: + StackPointerTest2(int *_ptr, RecordType *_recPtr) : ptr(_ptr), recPtr(_recPtr) { // expected-warning{{3 uninitialized fields}} + } +}; + +void fStackPointerTest2() { + int a; + StackPointerTest2::RecordType rec; + StackPointerTest2(&a, &rec); // 'a', 'rec.x', 'rec.y' uninitialized +} +#else +class StackPointerTest2 { +public: + struct RecordType { + int x; + int y; + }; + +private: + int *ptr; + RecordType *recPtr; + +public: + StackPointerTest2(int *_ptr, RecordType *_recPtr) : ptr(_ptr), recPtr(_recPtr) { + } +}; + +void fStackPointerTest2() { + int a; + StackPointerTest2::RecordType rec; + StackPointerTest2(&a, &rec); // 'a', 'rec.x', 'rec.y' uninitialized +} +#endif // PEDANTIC + +class UninitPointerTest { + struct RecordType { + int x; + int y; + }; + + int *ptr; // expected-note{{uninitialized pointer 'this->ptr'}} + RecordType *recPtr; + +public: + UninitPointerTest() : recPtr(new RecordType{13, 13}) { // expected-warning{{1 uninitialized field}} + } +}; + +void fUninitPointerTest() { + UninitPointerTest(); +} + +struct CharPointerTest { + const char *str; + int dontGetFilteredByNonPedanticMode = 0; + + CharPointerTest() : str("") {} +}; + +void fCharPointerTest() { + CharPointerTest(); +} + +struct CyclicPointerTest { + int *ptr; + CyclicPointerTest() : ptr(reinterpret_cast<int*>(&ptr)) {} +}; + +void fCyclicPointerTest() { + CyclicPointerTest(); +} + +//===----------------------------------------------------------------------===// +// Void pointer tests. +//===----------------------------------------------------------------------===// + +// Void pointer tests are mainly no-crash tests. + +void *malloc(int size); + +class VoidPointerTest1 { + void *vptr; + +public: + VoidPointerTest1(void *vptr, char) : vptr(vptr) { + // All good! + } +}; + +void fVoidPointerTest1() { + void *vptr = malloc(sizeof(int)); + VoidPointerTest1(vptr, char()); +} + +class VoidPointerTest2 { + void **vpptr; + +public: + VoidPointerTest2(void **vpptr, char) : vpptr(vpptr) { + // All good! + } +}; + +void fVoidPointerTest2() { + void *vptr = malloc(sizeof(int)); + VoidPointerTest2(&vptr, char()); +} + +class VoidPointerRRefTest1 { + void *&&vptrrref; // expected-note {{here}} + +public: + VoidPointerRRefTest1(void *vptr, char) : vptrrref(static_cast<void *&&>(vptr)) { // expected-warning {{binding reference member 'vptrrref' to stack allocated parameter 'vptr'}} + // All good! + } +}; + +void fVoidPointerRRefTest1() { + void *vptr = malloc(sizeof(int)); + VoidPointerRRefTest1(vptr, char()); +} + +class VoidPointerRRefTest2 { + void **&&vpptrrref; // expected-note {{here}} + +public: + VoidPointerRRefTest2(void **vptr, char) : vpptrrref(static_cast<void **&&>(vptr)) { // expected-warning {{binding reference member 'vpptrrref' to stack allocated parameter 'vptr'}} + // All good! + } +}; + +void fVoidPointerRRefTest2() { + void *vptr = malloc(sizeof(int)); + VoidPointerRRefTest2(&vptr, char()); +} + +class VoidPointerLRefTest { + void *&vptrrref; // expected-note {{here}} + +public: + VoidPointerLRefTest(void *vptr, char) : vptrrref(static_cast<void *&>(vptr)) { // expected-warning {{binding reference member 'vptrrref' to stack allocated parameter 'vptr'}} + // All good! + } +}; + +void fVoidPointerLRefTest() { + void *vptr = malloc(sizeof(int)); + VoidPointerLRefTest(vptr, char()); +} + +struct CyclicVoidPointerTest { + void *vptr; // no-crash + + CyclicVoidPointerTest() : vptr(&vptr) {} + +}; + +void fCyclicVoidPointerTest() { + CyclicVoidPointerTest(); +} + +//===----------------------------------------------------------------------===// +// Multipointer tests. +//===----------------------------------------------------------------------===// + +#ifdef PEDANTIC +class MultiPointerTest1 { +public: + struct RecordType { + int x; + int y; + }; + +private: + RecordType **mptr; // expected-note{{uninitialized pointee 'this->mptr'}} + +public: + MultiPointerTest1(RecordType **p, int) : mptr(p) { // expected-warning{{1 uninitialized field}} + } +}; + +void fMultiPointerTest1() { + MultiPointerTest1::RecordType *p1; + MultiPointerTest1::RecordType **mptr = &p1; + MultiPointerTest1(mptr, int()); // '*mptr' uninitialized +} +#else +class MultiPointerTest1 { +public: + struct RecordType { + int x; + int y; + }; + +private: + RecordType **mptr; + +public: + MultiPointerTest1(RecordType **p, int) : mptr(p) {} +}; + +void fMultiPointerTest1() { + MultiPointerTest1::RecordType *p1; + MultiPointerTest1::RecordType **mptr = &p1; + MultiPointerTest1(mptr, int()); // '*mptr' uninitialized +} +#endif // PEDANTIC + +#ifdef PEDANTIC +class MultiPointerTest2 { +public: + struct RecordType { + int x; // expected-note{{uninitialized field 'this->mptr->x'}} + int y; // expected-note{{uninitialized field 'this->mptr->y'}} + }; + +private: + RecordType **mptr; + +public: + MultiPointerTest2(RecordType **p, int) : mptr(p) { // expected-warning{{2 uninitialized fields}} + } +}; + +void fMultiPointerTest2() { + MultiPointerTest2::RecordType i; + MultiPointerTest2::RecordType *p1 = &i; + MultiPointerTest2::RecordType **mptr = &p1; + MultiPointerTest2(mptr, int()); // '**mptr' uninitialized +} +#else +class MultiPointerTest2 { +public: + struct RecordType { + int x; + int y; + }; + +private: + RecordType **mptr; + +public: + MultiPointerTest2(RecordType **p, int) : mptr(p) { + } +}; + +void fMultiPointerTest2() { + MultiPointerTest2::RecordType i; + MultiPointerTest2::RecordType *p1 = &i; + MultiPointerTest2::RecordType **mptr = &p1; + MultiPointerTest2(mptr, int()); // '**mptr' uninitialized +} +#endif // PEDANTIC + +class MultiPointerTest3 { +public: + struct RecordType { + int x; + int y; + }; + +private: + RecordType **mptr; + +public: + MultiPointerTest3(RecordType **p, int) : mptr(p) { + // All good! + } +}; + +void fMultiPointerTest3() { + MultiPointerTest3::RecordType i{31, 32}; + MultiPointerTest3::RecordType *p1 = &i; + MultiPointerTest3::RecordType **mptr = &p1; + MultiPointerTest3(mptr, int()); // '**mptr' uninitialized +} + +//===----------------------------------------------------------------------===// +// Member pointer tests. +//===----------------------------------------------------------------------===// + +struct UsefulFunctions { + int a, b; + + void print() {} + void dump() {} +}; + +#ifdef PEDANTIC +struct PointerToMemberFunctionTest1 { + void (UsefulFunctions::*f)(void); // expected-note{{uninitialized field 'this->f'}} + PointerToMemberFunctionTest1() {} +}; + +void fPointerToMemberFunctionTest1() { + PointerToMemberFunctionTest1(); // expected-warning{{1 uninitialized field}} +} + +struct PointerToMemberFunctionTest2 { + void (UsefulFunctions::*f)(void); + PointerToMemberFunctionTest2(void (UsefulFunctions::*f)(void)) : f(f) { + // All good! + } +}; + +void fPointerToMemberFunctionTest2() { + void (UsefulFunctions::*f)(void) = &UsefulFunctions::print; + PointerToMemberFunctionTest2 a(f); +} + +struct MultiPointerToMemberFunctionTest1 { + void (UsefulFunctions::**f)(void); // expected-note{{uninitialized pointer 'this->f'}} + MultiPointerToMemberFunctionTest1() {} +}; + +void fMultiPointerToMemberFunctionTest1() { + MultiPointerToMemberFunctionTest1(); // expected-warning{{1 uninitialized field}} +} + +struct MultiPointerToMemberFunctionTest2 { + void (UsefulFunctions::**f)(void); + MultiPointerToMemberFunctionTest2(void (UsefulFunctions::**f)(void)) : f(f) { + // All good! + } +}; + +void fMultiPointerToMemberFunctionTest2() { + void (UsefulFunctions::*f)(void) = &UsefulFunctions::print; + MultiPointerToMemberFunctionTest2 a(&f); +} + +struct PointerToMemberDataTest1 { + int UsefulFunctions::*d; // expected-note{{uninitialized field 'this->d'}} + PointerToMemberDataTest1() {} +}; + +void fPointerToMemberDataTest1() { + PointerToMemberDataTest1(); // expected-warning{{1 uninitialized field}} +} + +struct PointerToMemberDataTest2 { + int UsefulFunctions::*d; + PointerToMemberDataTest2(int UsefulFunctions::*d) : d(d) { + // All good! + } +}; + +void fPointerToMemberDataTest2() { + int UsefulFunctions::*d = &UsefulFunctions::a; + PointerToMemberDataTest2 a(d); +} + +struct MultiPointerToMemberDataTest1 { + int UsefulFunctions::**d; // expected-note{{uninitialized pointer 'this->d'}} + MultiPointerToMemberDataTest1() {} +}; + +void fMultiPointerToMemberDataTest1() { + MultiPointerToMemberDataTest1(); // expected-warning{{1 uninitialized field}} +} + +struct MultiPointerToMemberDataTest2 { + int UsefulFunctions::**d; + MultiPointerToMemberDataTest2(int UsefulFunctions::**d) : d(d) { + // All good! + } +}; + +void fMultiPointerToMemberDataTest2() { + int UsefulFunctions::*d = &UsefulFunctions::a; + MultiPointerToMemberDataTest2 a(&d); +} +#endif // PEDANTIC + +//===----------------------------------------------------------------------===// +// Tests for list-like records. +//===----------------------------------------------------------------------===// + +class ListTest1 { +public: + struct Node { + Node *next = nullptr; // no crash + int i; + }; + +private: + Node *head = nullptr; + +public: + ListTest1() { + // All good! + } +}; + +void fListTest1() { + ListTest1(); +} + +class ListTest2 { +public: + struct Node { + Node *next = nullptr; + int i; // expected-note{{uninitialized field 'this->head->i'}} + }; + +private: + Node *head = nullptr; + +public: + ListTest2(Node *node, int) : head(node) { // expected-warning{{1 uninitialized field}} + } +}; + +void fListTest2() { + ListTest2::Node n; + ListTest2(&n, int()); +} + +class CyclicList { +public: + struct Node { + Node *next = nullptr; + int i; // expected-note{{uninitialized field 'this->head->i'}} + }; + +private: + Node *head = nullptr; + +public: + CyclicList(Node *node, int) : head(node) { // expected-warning{{1 uninitialized field}} + } +}; + +void fCyclicList() { + /* + n3 + / \ + this -- n1 -- n2 + */ + + CyclicList::Node n1; + CyclicList::Node n2; + n2.next = &n1; + n2.i = 50; + CyclicList::Node n3; + n3.next = &n2; + n3.i = 50; + n1.next = &n3; + // note that n1.i is uninitialized + CyclicList(&n1, int()); +} + +//===----------------------------------------------------------------------===// +// Tests for classes containing references. +//===----------------------------------------------------------------------===// + +class ReferenceTest1 { +public: + struct RecordType { + int x; + int y; + }; + +private: + RecordType &lref; + RecordType &&rref; + +public: + ReferenceTest1(RecordType &lref, RecordType &rref) : lref(lref), rref(static_cast<RecordType &&>(rref)) { + // All good! + } +}; + +void fReferenceTest1() { + ReferenceTest1::RecordType d{33, 34}; + ReferenceTest1(d, d); +} + +#ifdef PEDANTIC +class ReferenceTest2 { +public: + struct RecordType { + int x; // expected-note{{uninitialized field 'this->lref.x'}} + int y; // expected-note{{uninitialized field 'this->lref.y'}} + }; + +private: + RecordType &lref; + RecordType &&rref; + +public: + ReferenceTest2(RecordType &lref, RecordType &rref) + : lref(lref), rref(static_cast<RecordType &&>(rref)) { // expected-warning{{2 uninitialized fields}} + } +}; + +void fReferenceTest2() { + ReferenceTest2::RecordType c; + ReferenceTest2(c, c); +} +#else +class ReferenceTest2 { +public: + struct RecordType { + int x; + int y; + }; + +private: + RecordType &lref; + RecordType &&rref; + +public: + ReferenceTest2(RecordType &lref, RecordType &rref) + : lref(lref), rref(static_cast<RecordType &&>(rref)) { + } +}; + +void fReferenceTest2() { + ReferenceTest2::RecordType c; + ReferenceTest2(c, c); +} +#endif // PEDANTIC + +class ReferenceTest3 { +public: + struct RecordType { + int x; // expected-note{{uninitialized field 'this->lref.x'}} + int y; // expected-note{{uninitialized field 'this->lref.y'}} + }; + +private: + RecordType &lref; + RecordType &&rref; + +public: + ReferenceTest3(RecordType &lref, RecordType &rref) + : lref(lref), rref(static_cast<RecordType &&>(rref)) { // expected-warning{{2 uninitialized fields}} + } +}; + +void fReferenceTest3() { + ReferenceTest3::RecordType c, d{35, 36}; + ReferenceTest3(c, d); +} + +class ReferenceTest4 { +public: + struct RecordType { + int x; // expected-note{{uninitialized field 'this->rref.x'}} + int y; // expected-note{{uninitialized field 'this->rref.y'}} + }; + +private: + RecordType &lref; + RecordType &&rref; + +public: + ReferenceTest4(RecordType &lref, RecordType &rref) + : lref(lref), rref(static_cast<RecordType &&>(rref)) { // expected-warning{{2 uninitialized fields}} + } +}; + +void fReferenceTest5() { + ReferenceTest4::RecordType c, d{37, 38}; + ReferenceTest4(d, c); +} diff --git a/test/Analysis/cxx-uninitialized-object.cpp b/test/Analysis/cxx-uninitialized-object.cpp new file mode 100644 index 000000000000..39d4a7f80183 --- /dev/null +++ b/test/Analysis/cxx-uninitialized-object.cpp @@ -0,0 +1,1103 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.cplusplus.UninitializedObject -analyzer-config alpha.cplusplus.UninitializedObject:Pedantic=true -std=c++11 -DPEDANTIC -verify %s + +// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.cplusplus.UninitializedObject -std=c++11 -verify %s + +//===----------------------------------------------------------------------===// +// Default constructor test. +//===----------------------------------------------------------------------===// + +class CompilerGeneratedConstructorTest { + int a, b, c, d, e, f, g, h, i, j; + +public: + CompilerGeneratedConstructorTest() = default; +}; + +void fCompilerGeneratedConstructorTest() { + CompilerGeneratedConstructorTest(); +} + +#ifdef PEDANTIC +class DefaultConstructorTest { + int a; // expected-note{{uninitialized field 'this->a'}} + +public: + DefaultConstructorTest(); +}; + +DefaultConstructorTest::DefaultConstructorTest() = default; + +void fDefaultConstructorTest() { + DefaultConstructorTest(); // expected-warning{{1 uninitialized field}} +} +#else +class DefaultConstructorTest { + int a; + +public: + DefaultConstructorTest(); +}; + +DefaultConstructorTest::DefaultConstructorTest() = default; + +void fDefaultConstructorTest() { + DefaultConstructorTest(); +} +#endif // PEDANTIC + +//===----------------------------------------------------------------------===// +// Initializer list test. +//===----------------------------------------------------------------------===// + +class InitListTest1 { + int a; + int b; + +public: + InitListTest1() + : a(1), + b(2) { + // All good! + } +}; + +void fInitListTest1() { + InitListTest1(); +} + +class InitListTest2 { + int a; + int b; // expected-note{{uninitialized field 'this->b'}} + +public: + InitListTest2() + : a(3) {} // expected-warning{{1 uninitialized field}} +}; + +void fInitListTest2() { + InitListTest2(); +} + +class InitListTest3 { + int a; // expected-note{{uninitialized field 'this->a'}} + int b; + +public: + InitListTest3() + : b(4) {} // expected-warning{{1 uninitialized field}} +}; + +void fInitListTest3() { + InitListTest3(); +} + +//===----------------------------------------------------------------------===// +// Constructor body test. +//===----------------------------------------------------------------------===// + +class CtorBodyTest1 { + int a, b; + +public: + CtorBodyTest1() { + a = 5; + b = 6; + // All good! + } +}; + +void fCtorBodyTest1() { + CtorBodyTest1(); +} + +class CtorBodyTest2 { + int a; + int b; // expected-note{{uninitialized field 'this->b'}} + +public: + CtorBodyTest2() { + a = 7; // expected-warning{{1 uninitialized field}} + } +}; + +void fCtorBodyTest2() { + CtorBodyTest2(); +} + +class CtorBodyTest3 { + int a; // expected-note{{uninitialized field 'this->a'}} + int b; + +public: + CtorBodyTest3() { + b = 8; // expected-warning{{1 uninitialized field}} + } +}; + +void fCtorBodyTest3() { + CtorBodyTest3(); +} + +#ifdef PEDANTIC +class CtorBodyTest4 { + int a; // expected-note{{uninitialized field 'this->a'}} + int b; // expected-note{{uninitialized field 'this->b'}} + +public: + CtorBodyTest4() {} +}; + +void fCtorBodyTest4() { + CtorBodyTest4(); // expected-warning{{2 uninitialized fields}} +} +#else +class CtorBodyTest4 { + int a; + int b; + +public: + CtorBodyTest4() {} +}; + +void fCtorBodyTest4() { + CtorBodyTest4(); +} +#endif + +//===----------------------------------------------------------------------===// +// Constructor delegation test. +//===----------------------------------------------------------------------===// + +class CtorDelegationTest1 { + int a; + int b; + +public: + CtorDelegationTest1(int) + : a(9) { + // leaves 'b' unintialized, but we'll never check this function + } + + CtorDelegationTest1() + : CtorDelegationTest1(int{}) { // Initializing 'a' + b = 10; + // All good! + } +}; + +void fCtorDelegationTest1() { + CtorDelegationTest1(); +} + +class CtorDelegationTest2 { + int a; // expected-note{{uninitialized field 'this->a'}} + int b; + +public: + CtorDelegationTest2(int) + : b(11) { + // leaves 'a' unintialized, but we'll never check this function + } + + CtorDelegationTest2() + : CtorDelegationTest2(int{}) { // expected-warning{{1 uninitialized field}} + } +}; + +void fCtorDelegationTest2() { + CtorDelegationTest2(); +} + +//===----------------------------------------------------------------------===// +// Tests for classes containing records. +//===----------------------------------------------------------------------===// + +class ContainsRecordTest1 { + struct RecordType { + int x; + int y; + } rec; + int c, d; + +public: + ContainsRecordTest1() + : rec({12, 13}), + c(14), + d(15) { + // All good! + } +}; + +void fContainsRecordTest1() { + ContainsRecordTest1(); +} + +class ContainsRecordTest2 { + struct RecordType { + int x; + int y; // expected-note{{uninitialized field 'this->rec.y'}} + } rec; + int c, d; + +public: + ContainsRecordTest2() + : c(16), + d(17) { + rec.x = 18; // expected-warning{{1 uninitialized field}} + } +}; + +void fContainsRecordTest2() { + ContainsRecordTest2(); +} + +class ContainsRecordTest3 { + struct RecordType { + int x; // expected-note{{uninitialized field 'this->rec.x'}} + int y; // expected-note{{uninitialized field 'this->rec.y'}} + } rec; + int c, d; + +public: + ContainsRecordTest3() + : c(19), + d(20) { // expected-warning{{2 uninitialized fields}} + } +}; + +void fContainsRecordTest3() { + ContainsRecordTest3(); +} + +class ContainsRecordTest4 { + struct RecordType { + int x; // expected-note{{uninitialized field 'this->rec.x'}} + int y; // expected-note{{uninitialized field 'this->rec.y'}} + } rec; + int c, d; // expected-note{{uninitialized field 'this->d'}} + +public: + ContainsRecordTest4() + : c(19) { // expected-warning{{3 uninitialized fields}} + } +}; + +void fContainsRecordTest4() { + ContainsRecordTest4(); +} + +//===----------------------------------------------------------------------===// +// Tests for template classes. +//===----------------------------------------------------------------------===// + +template <class T> +class IntTemplateClassTest1 { + T t; + int b; + +public: + IntTemplateClassTest1(T i) { + b = 21; + t = i; + // All good! + } +}; + +void fIntTemplateClassTest1() { + IntTemplateClassTest1<int>(22); +} + +template <class T> +class IntTemplateClassTest2 { + T t; // expected-note{{uninitialized field 'this->t'}} + int b; + +public: + IntTemplateClassTest2() { + b = 23; // expected-warning{{1 uninitialized field}} + } +}; + +void fIntTemplateClassTest2() { + IntTemplateClassTest2<int>(); +} + +struct Record { + int x; // expected-note{{uninitialized field 'this->t.x'}} + int y; // expected-note{{uninitialized field 'this->t.y'}} +}; + +template <class T> +class RecordTemplateClassTest { + T t; + int b; + +public: + RecordTemplateClassTest() { + b = 24; // expected-warning{{2 uninitialized fields}} + } +}; + +void fRecordTemplateClassTest() { + RecordTemplateClassTest<Record>(); +} + +//===----------------------------------------------------------------------===// +// Tests involving functions with unknown implementations. +//===----------------------------------------------------------------------===// + +template <class T> +void mayInitialize(T &); + +template <class T> +void wontInitialize(const T &); + +class PassingToUnknownFunctionTest1 { + int a, b; + +public: + PassingToUnknownFunctionTest1() { + mayInitialize(a); + mayInitialize(b); + // All good! + } + + PassingToUnknownFunctionTest1(int) { + mayInitialize(a); + // All good! + } + + PassingToUnknownFunctionTest1(int, int) { + mayInitialize(*this); + // All good! + } +}; + +void fPassingToUnknownFunctionTest1() { + PassingToUnknownFunctionTest1(); + PassingToUnknownFunctionTest1(int()); + PassingToUnknownFunctionTest1(int(), int()); +} + +class PassingToUnknownFunctionTest2 { + int a; // expected-note{{uninitialized field 'this->a'}} + int b; + +public: + PassingToUnknownFunctionTest2() { + wontInitialize(a); + b = 4; // expected-warning{{1 uninitialized field}} + } +}; + +void fPassingToUnknownFunctionTest2() { + PassingToUnknownFunctionTest2(); +} + +//===----------------------------------------------------------------------===// +// Tests for classes containing unions. +//===----------------------------------------------------------------------===// + +// FIXME: As of writing this checker, there is no good support for union types +// in the Static Analyzer. Here is non-exhaustive list of cases. +// Note that the rules for unions are different in C and C++. +// http://lists.llvm.org/pipermail/cfe-dev/2017-March/052910.html + +class ContainsSimpleUnionTest1 { + union SimpleUnion { + float uf; + int ui; + char uc; + } u; + +public: + ContainsSimpleUnionTest1() { + u.uf = 3.14; + // All good! + } +}; + +void fContainsSimpleUnionTest1() { + ContainsSimpleUnionTest1(); +} + +class ContainsSimpleUnionTest2 { + union SimpleUnion { + float uf; + int ui; + char uc; + // TODO: we'd expect the note: {{uninitialized field 'this->u'}} + } u; // no-note + +public: + ContainsSimpleUnionTest2() {} +}; + +void fContainsSimpleUnionTest2() { + // TODO: we'd expect the warning: {{1 uninitialized field}} + ContainsSimpleUnionTest2(); // no-warning +} + +class UnionPointerTest1 { +public: + union SimpleUnion { + float uf; + int ui; + char uc; + }; + +private: + SimpleUnion *uptr; + +public: + UnionPointerTest1(SimpleUnion *uptr, int) : uptr(uptr) { + // All good! + } +}; + +void fUnionPointerTest1() { + UnionPointerTest1::SimpleUnion u; + u.uf = 41; + UnionPointerTest1(&u, int()); +} + +class UnionPointerTest2 { +public: + union SimpleUnion { + float uf; + int ui; + char uc; + }; + +private: + // TODO: we'd expect the note: {{uninitialized field 'this->uptr'}} + SimpleUnion *uptr; // no-note + +public: + UnionPointerTest2(SimpleUnion *uptr, char) : uptr(uptr) {} +}; + +void fUnionPointerTest2() { + UnionPointerTest2::SimpleUnion u; + // TODO: we'd expect the warning: {{1 uninitialized field}} + UnionPointerTest2(&u, int()); // no-warning +} + +class ContainsUnionWithRecordTest1 { + union UnionWithRecord { + struct RecordType { + int x; + int y; + } us; + double ud; + long ul; + + UnionWithRecord(){}; + } u; + +public: + ContainsUnionWithRecordTest1() { + u.ud = 3.14; + // All good! + } +}; + +void fContainsUnionWithRecordTest1() { + ContainsUnionWithRecordTest1(); +} + +class ContainsUnionWithRecordTest2 { + union UnionWithRecord { + struct RecordType { + int x; + int y; + } us; + double ud; + long ul; + + UnionWithRecord(){}; + } u; + +public: + ContainsUnionWithRecordTest2() { + u.us = UnionWithRecord::RecordType{42, 43}; + // All good! + } +}; + +void fContainsUnionWithRecordTest2() { + ContainsUnionWithRecordTest1(); +} + +class ContainsUnionWithRecordTest3 { + union UnionWithRecord { + struct RecordType { + int x; + int y; + } us; + double ud; + long ul; + + UnionWithRecord(){}; + // TODO: we'd expect the note: {{uninitialized field 'this->u'}} + } u; // no-note + +public: + ContainsUnionWithRecordTest3() { + UnionWithRecord::RecordType rec; + rec.x = 44; + // TODO: we'd expect the warning: {{1 uninitialized field}} + u.us = rec; // no-warning + } +}; + +void fContainsUnionWithRecordTest3() { + ContainsUnionWithRecordTest3(); +} + +class ContainsUnionWithSimpleUnionTest1 { + union UnionWithSimpleUnion { + union SimpleUnion { + float uf; + int ui; + char uc; + } usu; + long ul; + unsigned uu; + } u; + +public: + ContainsUnionWithSimpleUnionTest1() { + u.usu.ui = 5; + // All good! + } +}; + +void fContainsUnionWithSimpleUnionTest1() { + ContainsUnionWithSimpleUnionTest1(); +} + +class ContainsUnionWithSimpleUnionTest2 { + union UnionWithSimpleUnion { + union SimpleUnion { + float uf; + int ui; + char uc; + } usu; + long ul; + unsigned uu; + // TODO: we'd expect the note: {{uninitialized field 'this->u'}} + } u; // no-note + +public: + ContainsUnionWithSimpleUnionTest2() {} +}; + +void fContainsUnionWithSimpleUnionTest2() { + // TODO: we'd expect the warning: {{1 uninitialized field}} + ContainsUnionWithSimpleUnionTest2(); // no-warning +} + +//===----------------------------------------------------------------------===// +// Zero initialization tests. +//===----------------------------------------------------------------------===// + +struct GlobalVariableTest { + int i; + + GlobalVariableTest() {} +}; + +GlobalVariableTest gvt; // no-warning + +//===----------------------------------------------------------------------===// +// Copy and move constructor tests. +//===----------------------------------------------------------------------===// + +template <class T> +void funcToSquelchCompilerWarnings(const T &t); + +#ifdef PEDANTIC +struct CopyConstructorTest { + int i; // expected-note{{uninitialized field 'this->i'}} + + CopyConstructorTest() : i(1337) {} + CopyConstructorTest(const CopyConstructorTest &other) {} +}; + +void fCopyConstructorTest() { + CopyConstructorTest cct; + CopyConstructorTest copy = cct; // expected-warning{{1 uninitialized field}} + funcToSquelchCompilerWarnings(copy); +} +#else +struct CopyConstructorTest { + int i; + + CopyConstructorTest() : i(1337) {} + CopyConstructorTest(const CopyConstructorTest &other) {} +}; + +void fCopyConstructorTest() { + CopyConstructorTest cct; + CopyConstructorTest copy = cct; + funcToSquelchCompilerWarnings(copy); +} +#endif // PEDANTIC + +struct MoveConstructorTest { + // TODO: we'd expect the note: {{uninitialized field 'this->i'}} + int i; // no-note + + MoveConstructorTest() : i(1337) {} + MoveConstructorTest(const CopyConstructorTest &other) = delete; + MoveConstructorTest(const CopyConstructorTest &&other) {} +}; + +void fMoveConstructorTest() { + MoveConstructorTest cct; + // TODO: we'd expect the warning: {{1 uninitialized field}} + MoveConstructorTest copy(static_cast<MoveConstructorTest &&>(cct)); // no-warning + funcToSquelchCompilerWarnings(copy); +} + +//===----------------------------------------------------------------------===// +// Array tests. +//===----------------------------------------------------------------------===// + +struct IntArrayTest { + int arr[256]; + + IntArrayTest() { + // All good! + } +}; + +void fIntArrayTest() { + IntArrayTest(); +} + +struct RecordTypeArrayTest { + struct RecordType { + int x, y; + } arr[256]; + + RecordTypeArrayTest() { + // All good! + } +}; + +void fRecordTypeArrayTest() { + RecordTypeArrayTest(); +} + +template <class T> +class CharArrayPointerTest { + T *t; // no-crash + +public: + CharArrayPointerTest(T *t, int) : t(t) {} +}; + +void fCharArrayPointerTest() { + char str[16] = "012345678912345"; + CharArrayPointerTest<char[16]>(&str, int()); +} + +//===----------------------------------------------------------------------===// +// Memset tests. +//===----------------------------------------------------------------------===// + +struct MemsetTest1 { + int a, b, c; + + MemsetTest1() { + __builtin_memset(this, 0, sizeof(decltype(*this))); + } +}; + +void fMemsetTest1() { + MemsetTest1(); +} + +struct MemsetTest2 { + int a; + + MemsetTest2() { + __builtin_memset(&a, 0, sizeof(int)); + } +}; + +void fMemsetTest2() { + MemsetTest2(); +} + +//===----------------------------------------------------------------------===// +// Lambda tests. +//===----------------------------------------------------------------------===// + +template <class Callable> +struct LambdaThisTest { + Callable functor; + + LambdaThisTest(const Callable &functor, int) : functor(functor) { + // All good! + } +}; + +struct HasCapturableThis { + void fLambdaThisTest() { + auto isEven = [this](int a) { return a % 2 == 0; }; // no-crash + LambdaThisTest<decltype(isEven)>(isEven, int()); + } +}; + +template <class Callable> +struct LambdaTest1 { + Callable functor; + + LambdaTest1(const Callable &functor, int) : functor(functor) { + // All good! + } +}; + +void fLambdaTest1() { + auto isEven = [](int a) { return a % 2 == 0; }; + LambdaTest1<decltype(isEven)>(isEven, int()); +} + +#ifdef PEDANTIC +template <class Callable> +struct LambdaTest2 { + Callable functor; + + LambdaTest2(const Callable &functor, int) : functor(functor) {} // expected-warning{{1 uninitialized field}} +}; + +void fLambdaTest2() { + int b; + auto equals = [&b](int a) { return a == b; }; // expected-note{{uninitialized field 'this->functor.b'}} + LambdaTest2<decltype(equals)>(equals, int()); +} +#else +template <class Callable> +struct LambdaTest2 { + Callable functor; + + LambdaTest2(const Callable &functor, int) : functor(functor) {} +}; + +void fLambdaTest2() { + int b; + auto equals = [&b](int a) { return a == b; }; + LambdaTest2<decltype(equals)>(equals, int()); +} +#endif //PEDANTIC + +#ifdef PEDANTIC +namespace LT3Detail { + +struct RecordType { + int x; // expected-note{{uninitialized field 'this->functor.rec1.x'}} + int y; // expected-note{{uninitialized field 'this->functor.rec1.y'}} +}; + +} // namespace LT3Detail +template <class Callable> +struct LambdaTest3 { + Callable functor; + + LambdaTest3(const Callable &functor, int) : functor(functor) {} // expected-warning{{2 uninitialized fields}} +}; + +void fLambdaTest3() { + LT3Detail::RecordType rec1; + auto equals = [&rec1](LT3Detail::RecordType rec2) { + return rec1.x == rec2.x; + }; + LambdaTest3<decltype(equals)>(equals, int()); +} +#else +namespace LT3Detail { + +struct RecordType { + int x; + int y; +}; + +} // namespace LT3Detail +template <class Callable> +struct LambdaTest3 { + Callable functor; + + LambdaTest3(const Callable &functor, int) : functor(functor) {} +}; + +void fLambdaTest3() { + LT3Detail::RecordType rec1; + auto equals = [&rec1](LT3Detail::RecordType rec2) { + return rec1.x == rec2.x; + }; + LambdaTest3<decltype(equals)>(equals, int()); +} +#endif //PEDANTIC + +template <class Callable> +struct MultipleLambdaCapturesTest1 { + Callable functor; + int dontGetFilteredByNonPedanticMode = 0; + + MultipleLambdaCapturesTest1(const Callable &functor, int) : functor(functor) {} // expected-warning{{2 uninitialized field}} +}; + +void fMultipleLambdaCapturesTest1() { + int b1, b2 = 3, b3; + auto equals = [&b1, &b2, &b3](int a) { return a == b1 == b2 == b3; }; // expected-note{{uninitialized field 'this->functor.b1'}} + // expected-note@-1{{uninitialized field 'this->functor.b3'}} + MultipleLambdaCapturesTest1<decltype(equals)>(equals, int()); +} + +template <class Callable> +struct MultipleLambdaCapturesTest2 { + Callable functor; + int dontGetFilteredByNonPedanticMode = 0; + + MultipleLambdaCapturesTest2(const Callable &functor, int) : functor(functor) {} // expected-warning{{1 uninitialized field}} +}; + +void fMultipleLambdaCapturesTest2() { + int b1, b2 = 3, b3; + auto equals = [b1, &b2, &b3](int a) { return a == b1 == b2 == b3; }; // expected-note{{uninitialized field 'this->functor.b3'}} + MultipleLambdaCapturesTest2<decltype(equals)>(equals, int()); +} + +//===----------------------------------------------------------------------===// +// System header tests. +//===----------------------------------------------------------------------===// + +#include "Inputs/system-header-simulator-for-cxx-uninitialized-object.h" + +struct SystemHeaderTest1 { + RecordInSystemHeader rec; // defined in the system header simulator + + SystemHeaderTest1() { + // All good! + } +}; + +void fSystemHeaderTest1() { + SystemHeaderTest1(); +} + +#ifdef PEDANTIC +struct SystemHeaderTest2 { + struct RecordType { + int x; // expected-note{{uninitialized field 'this->container.t.x}} + int y; // expected-note{{uninitialized field 'this->container.t.y}} + }; + ContainerInSystemHeader<RecordType> container; + + SystemHeaderTest2(RecordType &rec, int) : container(rec) {} // expected-warning{{2 uninitialized fields}} +}; + +void fSystemHeaderTest2() { + SystemHeaderTest2::RecordType rec; + SystemHeaderTest2(rec, int()); +} +#else +struct SystemHeaderTest2 { + struct RecordType { + int x; + int y; + }; + ContainerInSystemHeader<RecordType> container; + + SystemHeaderTest2(RecordType &rec, int) : container(rec) {} +}; + +void fSystemHeaderTest2() { + SystemHeaderTest2::RecordType rec; + SystemHeaderTest2(rec, int()); +} +#endif //PEDANTIC + +//===----------------------------------------------------------------------===// +// Incomplete type tests. +//===----------------------------------------------------------------------===// + +struct IncompleteTypeTest1 { + struct RecordType; + // no-crash + RecordType *recptr; // expected-note{{uninitialized pointer 'this->recptr}} + int dontGetFilteredByNonPedanticMode = 0; + + IncompleteTypeTest1() {} // expected-warning{{1 uninitialized field}} +}; + +void fIncompleteTypeTest1() { + IncompleteTypeTest1(); +} + +struct IncompleteTypeTest2 { + struct RecordType; + RecordType *recptr; // no-crash + int dontGetFilteredByNonPedanticMode = 0; + + RecordType *recordTypeFactory(); + + IncompleteTypeTest2() : recptr(recordTypeFactory()) {} +}; + +void fIncompleteTypeTest2() { + IncompleteTypeTest2(); +} + +struct IncompleteTypeTest3 { + struct RecordType; + RecordType &recref; // no-crash + int dontGetFilteredByNonPedanticMode = 0; + + RecordType &recordTypeFactory(); + + IncompleteTypeTest3() : recref(recordTypeFactory()) {} +}; + +void fIncompleteTypeTest3() { + IncompleteTypeTest3(); +} + +//===----------------------------------------------------------------------===// +// Builtin type or enumeration type related tests. +//===----------------------------------------------------------------------===// + +struct IntegralTypeTest { + int a; // expected-note{{uninitialized field 'this->a'}} + int dontGetFilteredByNonPedanticMode = 0; + + IntegralTypeTest() {} // expected-warning{{1 uninitialized field}} +}; + +void fIntegralTypeTest() { + IntegralTypeTest(); +} + +struct FloatingTypeTest { + float a; // expected-note{{uninitialized field 'this->a'}} + int dontGetFilteredByNonPedanticMode = 0; + + FloatingTypeTest() {} // expected-warning{{1 uninitialized field}} +}; + +void fFloatingTypeTest() { + FloatingTypeTest(); +} + +struct NullptrTypeTypeTest { + decltype(nullptr) a; // expected-note{{uninitialized field 'this->a'}} + int dontGetFilteredByNonPedanticMode = 0; + + NullptrTypeTypeTest() {} // expected-warning{{1 uninitialized field}} +}; + +void fNullptrTypeTypeTest() { + NullptrTypeTypeTest(); +} + +struct EnumTest { + enum Enum { + A, + B + } enum1; // expected-note{{uninitialized field 'this->enum1'}} + enum class Enum2 { + A, + B + } enum2; // expected-note{{uninitialized field 'this->enum2'}} + int dontGetFilteredByNonPedanticMode = 0; + + EnumTest() {} // expected-warning{{2 uninitialized fields}} +}; + +void fEnumTest() { + EnumTest(); +} + +//===----------------------------------------------------------------------===// +// Tests for constructor calls within another cunstructor, without the two +// records being in any relation. +//===----------------------------------------------------------------------===// + +void halt() __attribute__((__noreturn__)); +void assert(int b) { + if (!b) + halt(); +} + +// While a singleton would make more sense as a static variable, that would zero +// initialize all of its fields, hence the not too practical implementation. +struct Singleton { + // TODO: we'd expect the note: {{uninitialized field 'this->i'}} + int i; // no-note + + Singleton() { + assert(!isInstantiated); + // TODO: we'd expect the warning: {{1 uninitialized field}} + isInstantiated = true; // no-warning + } + + ~Singleton() { + isInstantiated = false; + } + + static bool isInstantiated; +}; + +bool Singleton::isInstantiated = false; + +struct SingletonTest { + int dontGetFilteredByNonPedanticMode = 0; + + SingletonTest() { + Singleton(); + } +}; + +void fSingletonTest() { + SingletonTest(); +} + +//===----------------------------------------------------------------------===// +// C++11 member initializer tests. +//===----------------------------------------------------------------------===// + +struct CXX11MemberInitTest1 { + int a = 3; + int b; + CXX11MemberInitTest1() : b(2) { + // All good! + } +}; + +void fCXX11MemberInitTest1() { + CXX11MemberInitTest1(); +} + +struct CXX11MemberInitTest2 { + struct RecordType { + // TODO: we'd expect the note: {{uninitialized field 'this->rec.a'}} + int a; // no-note + // TODO: we'd expect the note: {{uninitialized field 'this->rec.b'}} + int b; // no-note + + RecordType(int) {} + }; + + RecordType rec = RecordType(int()); + int dontGetFilteredByNonPedanticMode = 0; + + CXX11MemberInitTest2() {} +}; + +void fCXX11MemberInitTest2() { + // TODO: we'd expect the warning: {{2 uninitializeds field}} + CXX11MemberInitTest2(); // no-warning +} diff --git a/test/Analysis/cxx17-mandatory-elision.cpp b/test/Analysis/cxx17-mandatory-elision.cpp new file mode 100644 index 000000000000..cf77912ea6c4 --- /dev/null +++ b/test/Analysis/cxx17-mandatory-elision.cpp @@ -0,0 +1,304 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -std=c++11 -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -std=c++17 -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -std=c++11 -analyzer-config elide-constructors=false -DNO_ELIDE_FLAG -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -std=c++17 -analyzer-config elide-constructors=false -DNO_ELIDE_FLAG -verify %s + +// Copy elision always occurs in C++17, otherwise it's under +// an on-by-default flag. +#if __cplusplus >= 201703L + #define ELIDE 1 +#else + #ifndef NO_ELIDE_FLAG + #define ELIDE 1 + #endif +#endif + +void clang_analyzer_eval(bool); + +namespace variable_functional_cast_crash { + +struct A { + A(int) {} +}; + +void foo() { + A a = A(0); +} + +struct B { + A a; + B(): a(A(0)) {} +}; + +} // namespace variable_functional_cast_crash + + +namespace ctor_initializer { + +struct S { + int x, y, z; +}; + +struct T { + S s; + int w; + T(int w): s(), w(w) {} +}; + +class C { + T t; +public: + C() : t(T(4)) { + S s = {1, 2, 3}; + t.s = s; + // FIXME: Should be TRUE regardless of copy elision. + clang_analyzer_eval(t.w == 4); +#ifdef ELIDE + // expected-warning@-2{{TRUE}} +#else + // expected-warning@-4{{UNKNOWN}} +#endif + } +}; + + +struct A { + int x; + A(): x(0) {} + ~A() {} +}; + +struct B { + A a; + B() : a(A()) {} +}; + +void foo() { + B b; + clang_analyzer_eval(b.a.x == 0); // expected-warning{{TRUE}} +} + +} // namespace ctor_initializer + + +namespace elision_on_ternary_op_branches { +class C1 { + int x; +public: + C1(int x): x(x) {} + int getX() const { return x; } + ~C1(); +}; + +class C2 { + int x; + int y; +public: + C2(int x, int y): x(x), y(y) {} + int getX() const { return x; } + int getY() const { return y; } + ~C2(); +}; + +void foo(int coin) { + C1 c1 = coin ? C1(1) : C1(2); + if (coin) { + clang_analyzer_eval(c1.getX() == 1); // expected-warning{{TRUE}} + } else { + clang_analyzer_eval(c1.getX() == 2); // expected-warning{{TRUE}} + } + C2 c2 = coin ? C2(3, 4) : C2(5, 6); + if (coin) { + clang_analyzer_eval(c2.getX() == 3); // expected-warning{{TRUE}} + clang_analyzer_eval(c2.getY() == 4); // expected-warning{{TRUE}} + } else { + clang_analyzer_eval(c2.getX() == 5); // expected-warning{{TRUE}} + clang_analyzer_eval(c2.getY() == 6); // expected-warning{{TRUE}} + } +} +} // namespace elision_on_ternary_op_branches + + +namespace address_vector_tests { + +template <typename T> struct AddressVector { + T *buf[10]; + int len; + + AddressVector() : len(0) {} + + void push(T *t) { + buf[len] = t; + ++len; + } +}; + +class ClassWithoutDestructor { + AddressVector<ClassWithoutDestructor> &v; + +public: + ClassWithoutDestructor(AddressVector<ClassWithoutDestructor> &v) : v(v) { + v.push(this); + } + + ClassWithoutDestructor(ClassWithoutDestructor &&c) : v(c.v) { v.push(this); } + ClassWithoutDestructor(const ClassWithoutDestructor &c) : v(c.v) { + v.push(this); + } +}; + +ClassWithoutDestructor make1(AddressVector<ClassWithoutDestructor> &v) { + return ClassWithoutDestructor(v); +} +ClassWithoutDestructor make2(AddressVector<ClassWithoutDestructor> &v) { + return make1(v); +} +ClassWithoutDestructor make3(AddressVector<ClassWithoutDestructor> &v) { + return make2(v); +} + +void testMultipleReturns() { + AddressVector<ClassWithoutDestructor> v; + ClassWithoutDestructor c = make3(v); + +#if ELIDE + clang_analyzer_eval(v.len == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[0] == &c); // expected-warning{{TRUE}} +#else + clang_analyzer_eval(v.len == 5); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[0] != v.buf[1]); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[1] != v.buf[2]); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[2] != v.buf[3]); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[3] != v.buf[4]); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[4] == &c); // expected-warning{{TRUE}} +#endif +} + +class ClassWithDestructor { + AddressVector<ClassWithDestructor> &v; + +public: + ClassWithDestructor(AddressVector<ClassWithDestructor> &v) : v(v) { + v.push(this); + } + + ClassWithDestructor(ClassWithDestructor &&c) : v(c.v) { v.push(this); } + ClassWithDestructor(const ClassWithDestructor &c) : v(c.v) { + v.push(this); + } + + ~ClassWithDestructor() { v.push(this); } +}; + +void testVariable() { + AddressVector<ClassWithDestructor> v; + { + ClassWithDestructor c = ClassWithDestructor(v); + // Check if the last destructor is an automatic destructor. + // A temporary destructor would have fired by now. +#if ELIDE + clang_analyzer_eval(v.len == 1); // expected-warning{{TRUE}} +#else + clang_analyzer_eval(v.len == 3); // expected-warning{{TRUE}} +#endif + } +#if ELIDE + // 0. Construct the variable. + // 1. Destroy the variable. + clang_analyzer_eval(v.len == 2); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[0] == v.buf[1]); // expected-warning{{TRUE}} +#else + // 0. Construct the temporary. + // 1. Construct the variable. + // 2. Destroy the temporary. + // 3. Destroy the variable. + clang_analyzer_eval(v.len == 4); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[0] == v.buf[2]); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[1] == v.buf[3]); // expected-warning{{TRUE}} +#endif +} + +struct TestCtorInitializer { + ClassWithDestructor c; + TestCtorInitializer(AddressVector<ClassWithDestructor> &v) + : c(ClassWithDestructor(v)) {} +}; + +void testCtorInitializer() { + AddressVector<ClassWithDestructor> v; + { + TestCtorInitializer t(v); + // Check if the last destructor is an automatic destructor. + // A temporary destructor would have fired by now. +#if ELIDE + clang_analyzer_eval(v.len == 1); // expected-warning{{TRUE}} +#else + clang_analyzer_eval(v.len == 3); // expected-warning{{TRUE}} +#endif + } +#if ELIDE + // 0. Construct the member variable. + // 1. Destroy the member variable. + clang_analyzer_eval(v.len == 2); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[0] == v.buf[1]); // expected-warning{{TRUE}} +#else + // 0. Construct the temporary. + // 1. Construct the member variable. + // 2. Destroy the temporary. + // 3. Destroy the member variable. + clang_analyzer_eval(v.len == 4); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[0] == v.buf[2]); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[1] == v.buf[3]); // expected-warning{{TRUE}} +#endif +} + + +ClassWithDestructor make1(AddressVector<ClassWithDestructor> &v) { + return ClassWithDestructor(v); +} +ClassWithDestructor make2(AddressVector<ClassWithDestructor> &v) { + return make1(v); +} +ClassWithDestructor make3(AddressVector<ClassWithDestructor> &v) { + return make2(v); +} + +void testMultipleReturnsWithDestructors() { + AddressVector<ClassWithDestructor> v; + { + ClassWithDestructor c = make3(v); + // Check if the last destructor is an automatic destructor. + // A temporary destructor would have fired by now. +#if ELIDE + clang_analyzer_eval(v.len == 1); // expected-warning{{TRUE}} +#else + clang_analyzer_eval(v.len == 9); // expected-warning{{TRUE}} +#endif + } + +#if ELIDE + // 0. Construct the variable. Yes, constructor in make1() constructs + // the variable 'c'. + // 1. Destroy the variable. + clang_analyzer_eval(v.len == 2); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[0] == v.buf[1]); // expected-warning{{TRUE}} +#else + // 0. Construct the temporary in make1(). + // 1. Construct the temporary in make2(). + // 2. Destroy the temporary in make1(). + // 3. Construct the temporary in make3(). + // 4. Destroy the temporary in make2(). + // 5. Construct the temporary here. + // 6. Destroy the temporary in make3(). + // 7. Construct the variable. + // 8. Destroy the temporary here. + // 9. Destroy the variable. + clang_analyzer_eval(v.len == 10); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[0] == v.buf[2]); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[1] == v.buf[4]); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[3] == v.buf[6]); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[5] == v.buf[8]); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[7] == v.buf[9]); // expected-warning{{TRUE}} +#endif +} +} // namespace address_vector_tests diff --git a/test/Analysis/cxxnewexpr-callback-inline.cpp b/test/Analysis/cxxnewexpr-callback-inline.cpp new file mode 100644 index 000000000000..c823de85821d --- /dev/null +++ b/test/Analysis/cxxnewexpr-callback-inline.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.AnalysisOrder -analyzer-config c++-allocator-inlining=true,debug.AnalysisOrder:PreStmtCXXNewExpr=true,debug.AnalysisOrder:PostStmtCXXNewExpr=true,debug.AnalysisOrder:PreCall=true,debug.AnalysisOrder:PostCall=true,debug.AnalysisOrder:NewAllocator=true %s 2>&1 | FileCheck %s + +#include "Inputs/system-header-simulator-cxx.h" + +namespace std { + void *malloc(size_t); +} + +void *operator new(size_t size) { return std::malloc(size); } + +struct S { + S() {} +}; + +void foo(); + +void test() { + S *s = new S(); + foo(); +} + +// CHECK: PreCall (operator new) +// CHECK-NEXT: PreCall (std::malloc) +// CHECK-NEXT: PostCall (std::malloc) +// CHECK-NEXT: PostCall (operator new) +// CHECK-NEXT: NewAllocator +// CHECK-NEXT: PreCall (S::S) +// CHECK-NEXT: PostCall (S::S) +// CHECK-NEXT: PreStmt<CXXNewExpr> +// CHECK-NEXT: PostStmt<CXXNewExpr> +// CHECK-NEXT: PreCall (foo) +// CHECK-NEXT: PostCall (foo) diff --git a/test/Analysis/cxxnewexpr-callback-noinline.cpp b/test/Analysis/cxxnewexpr-callback-noinline.cpp new file mode 100644 index 000000000000..87edeac3fd58 --- /dev/null +++ b/test/Analysis/cxxnewexpr-callback-noinline.cpp @@ -0,0 +1,29 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.AnalysisOrder -analyzer-config c++-allocator-inlining=false,debug.AnalysisOrder:PreStmtCXXNewExpr=true,debug.AnalysisOrder:PostStmtCXXNewExpr=true,debug.AnalysisOrder:PreCall=true,debug.AnalysisOrder:PostCall=true,debug.AnalysisOrder:NewAllocator=true %s 2>&1 | FileCheck %s + +#include "Inputs/system-header-simulator-cxx.h" + +namespace std { + void *malloc(size_t); +} + +void *operator new(size_t size) { return std::malloc(size); } + +struct S { + S() {} +}; + +void foo(); + +void test() { + S *s = new S(); + foo(); +} + +// CHECK: PreCall (S::S) +// CHECK-NEXT: PostCall (S::S) +// CHECK-NEXT: PreStmt<CXXNewExpr> +// CHECK-NEXT: PostStmt<CXXNewExpr> +// CHECK-NEXT: PreCall (foo) +// CHECK-NEXT: PostCall (foo) +// CHECK-NEXT: PreCall (std::malloc) +// CHECK-NEXT: PostCall (std::malloc) diff --git a/test/Analysis/dead-stores.c b/test/Analysis/dead-stores.c index 05bc64af7a37..84217a286a55 100644 --- a/test/Analysis/dead-stores.c +++ b/test/Analysis/dead-stores.c @@ -525,7 +525,7 @@ void rdar8405222() { rdar8405222_aux(i); } -// Look through chains of assignements, e.g.: int x = y = 0, when employing +// Look through chains of assignments, e.g.: int x = y = 0, when employing // silencing heuristics. int radar11185138_foo() { int x, y; diff --git a/test/Analysis/diagnostics/deref-track-symbolic-region.c b/test/Analysis/diagnostics/deref-track-symbolic-region.c index 179e736ee18b..48c659f2b8e6 100644 --- a/test/Analysis/diagnostics/deref-track-symbolic-region.c +++ b/test/Analysis/diagnostics/deref-track-symbolic-region.c @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=text -verify %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file -analyzer-config path-diagnostics-alternate=false %s -o %t.plist +// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file %s -o %t.plist // RUN: FileCheck --input-file=%t.plist %s struct S { diff --git a/test/Analysis/diagnostics/explicit-suppression.cpp b/test/Analysis/diagnostics/explicit-suppression.cpp index 96d2b4a7d095..092591836baa 100644 --- a/test/Analysis/diagnostics/explicit-suppression.cpp +++ b/test/Analysis/diagnostics/explicit-suppression.cpp @@ -19,6 +19,6 @@ class C { void testCopyNull(C *I, C *E) { std::copy(I, E, (C *)0); #ifndef SUPPRESSED - // expected-warning@../Inputs/system-header-simulator-cxx.h:490 {{Called C++ object pointer is null}} + // expected-warning@../Inputs/system-header-simulator-cxx.h:514 {{Called C++ object pointer is null}} #endif } diff --git a/test/Analysis/diagnostics/implicit-cxx-std-suppression.cpp b/test/Analysis/diagnostics/implicit-cxx-std-suppression.cpp index 197fad5d0b7d..35f8798c81ae 100644 --- a/test/Analysis/diagnostics/implicit-cxx-std-suppression.cpp +++ b/test/Analysis/diagnostics/implicit-cxx-std-suppression.cpp @@ -1,5 +1,7 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDelete,debug.ExprInspection -analyzer-config c++-container-inlining=true -analyzer-config c++-stdlib-inlining=false -std=c++11 -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDelete,debug.ExprInspection -analyzer-config c++-container-inlining=true -analyzer-config c++-stdlib-inlining=true -std=c++11 -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDelete,debug.ExprInspection -analyzer-config c++-container-inlining=true -analyzer-config c++-stdlib-inlining=false -std=c++11 -DTEST_INLINABLE_ALLOCATORS -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDelete,debug.ExprInspection -analyzer-config c++-container-inlining=true -analyzer-config c++-stdlib-inlining=true -std=c++11 -DTEST_INLINABLE_ALLOCATORS -verify %s // expected-no-diagnostics diff --git a/test/Analysis/diagnostics/macro-null-return-suppression.cpp b/test/Analysis/diagnostics/macro-null-return-suppression.cpp new file mode 100644 index 000000000000..a2928f15c1e3 --- /dev/null +++ b/test/Analysis/diagnostics/macro-null-return-suppression.cpp @@ -0,0 +1,68 @@ +// RUN: %clang_analyze_cc1 -x c -analyzer-checker=core -analyzer-output=text -verify %s + +#define NULL 0 + +int test_noparammacro() { + int *x = NULL; // expected-note{{'x' initialized to a null pointer value}} + return *x; // expected-warning{{Dereference of null pointer (loaded from variable 'x')}} + // expected-note@-1{{Dereference of null pointer (loaded from variable 'x')}} +} + +#define DYN_CAST(X) (X ? (char*)X : 0) +#define GENERATE_NUMBER(X) (0) + +char test_assignment(int *param) { + char *param2; + param2 = DYN_CAST(param); + return *param2; +} + +char test_declaration(int *param) { + char *param2 = DYN_CAST(param); + return *param2; +} + +int coin(); + +int test_multi_decl(int *paramA, int *paramB) { + char *param1 = DYN_CAST(paramA), *param2 = DYN_CAST(paramB); + if (coin()) + return *param1; + return *param2; +} + +int testDivision(int a) { + int divider = GENERATE_NUMBER(2); // expected-note{{'divider' initialized to 0}} + return 1/divider; // expected-warning{{Division by zero}} + // expected-note@-1{{Division by zero}} +} + +// Warning should not be suppressed if it happens in the same macro. +#define DEREF_IN_MACRO(X) int fn() {int *p = 0; return *p; } + +DEREF_IN_MACRO(0) // expected-warning{{Dereference of null pointer}} + // expected-note@-1{{'p' initialized to a null}} + // expected-note@-2{{Dereference of null pointer}} + +// Warning should not be suppressed if the null returned by the macro +// is not related to the warning. +#define RETURN_NULL() (0) +extern int* returnFreshPointer(); +int noSuppressMacroUnrelated() { + int *x = RETURN_NULL(); + x = returnFreshPointer(); // expected-note{{Value assigned to 'x'}} + if (x) {} // expected-note{{Taking false branch}} + // expected-note@-1{{Assuming 'x' is null}} + return *x; // expected-warning{{Dereference of null pointer}} + // expected-note@-1{{Dereference}} +} + +// Value haven't changed by the assignment, but the null pointer +// did not come from the macro. +int noSuppressMacroUnrelatedOtherReason() { + int *x = RETURN_NULL(); + x = returnFreshPointer(); + x = 0; // expected-note{{Null pointer value stored to 'x'}} + return *x; // expected-warning{{Dereference of null pointer}} + // expected-note@-1{{Dereference}} +} diff --git a/test/Analysis/diagnostics/no-store-func-path-notes.c b/test/Analysis/diagnostics/no-store-func-path-notes.c new file mode 100644 index 000000000000..a444ab60261b --- /dev/null +++ b/test/Analysis/diagnostics/no-store-func-path-notes.c @@ -0,0 +1,226 @@ +// RUN: %clang_analyze_cc1 -x c -analyzer-checker=core -analyzer-output=text -verify %s + +typedef __typeof(sizeof(int)) size_t; +void *memset(void *__s, int __c, size_t __n); + +int initializer1(int *p, int x) { + if (x) { // expected-note{{Taking false branch}} + *p = 1; + return 0; + } else { + return 1; // expected-note {{Returning without writing to '*p'}} + } +} + +int param_not_initialized_by_func() { + int p; // expected-note {{'p' declared without an initial value}} + int out = initializer1(&p, 0); // expected-note{{Calling 'initializer1'}} + // expected-note@-1{{Returning from 'initializer1'}} + return p; // expected-note{{Undefined or garbage value returned to caller}} + // expected-warning@-1{{Undefined or garbage value returned to caller}} +} + +int param_initialized_properly() { + int p; + int out = initializer1(&p, 1); + return p; //no-warning +} + +static int global; + +int initializer2(int **p, int x) { + if (x) { // expected-note{{Taking false branch}} + *p = &global; + return 0; + } else { + return 1; // expected-note {{Returning without writing to '*p'}} + } +} + +int param_not_written_into_by_func() { + int *p = 0; // expected-note{{'p' initialized to a null pointer value}} + int out = initializer2(&p, 0); // expected-note{{Calling 'initializer2'}} + // expected-note@-1{{Returning from 'initializer2'}} + return *p; // expected-warning{{Dereference of null pointer (loaded from variable 'p')}} + // expected-note@-1{{Dereference of null pointer (loaded from variable 'p')}} +} + +void initializer3(int *p, int param) { + if (param) // expected-note{{Taking false branch}} + *p = 0; +} // expected-note{{Returning without writing to '*p'}} + +int param_written_into_by_void_func() { + int p; // expected-note{{'p' declared without an initial value}} + initializer3(&p, 0); // expected-note{{Calling 'initializer3'}} + // expected-note@-1{{Returning from 'initializer3'}} + return p; // expected-warning{{Undefined or garbage value returned to caller}} + // expected-note@-1{{Undefined or garbage value returned to caller}} +} + +void initializer4(int *p, int param) { + if (param) // expected-note{{Taking false branch}} + *p = 0; +} // expected-note{{Returning without writing to '*p'}} + +void initializer5(int *p, int param) { + if (!param) // expected-note{{Taking false branch}} + *p = 0; +} // expected-note{{Returning without writing to '*p'}} + +int multi_init_tries_func() { + int p; // expected-note{{'p' declared without an initial value}} + initializer4(&p, 0); // expected-note{{Calling 'initializer4'}} + // expected-note@-1{{Returning from 'initializer4'}} + initializer5(&p, 1); // expected-note{{Calling 'initializer5'}} + // expected-note@-1{{Returning from 'initializer5'}} + return p; // expected-warning{{Undefined or garbage value returned to caller}} + // expected-note@-1{{Undefined or garbage value returned to caller}} +} + +int initializer6(const int *p) { + return 0; +} + +int no_msg_on_const() { + int p; // expected-note{{'p' declared without an initial value}} + initializer6(&p); + return p; // expected-warning{{Undefined or garbage value returned to caller}} + // expected-note@-1{{Undefined or garbage value returned to caller}} +} + +typedef struct { + int x; +} S; + +int initializer7(S *s, int param) { + if (param) { // expected-note{{Taking false branch}} + s->x = 0; + return 0; + } + return 1; // expected-note{{Returning without writing to 's->x'}} +} + +int initialize_struct_field() { + S local; + initializer7(&local, 0); // expected-note{{Calling 'initializer7'}} + // expected-note@-1{{Returning from 'initializer7'}} + return local.x; // expected-warning{{Undefined or garbage value returned to caller}} + // expected-note@-1{{Undefined or garbage value returned to caller}} +} + +void nullwriter(int **p) { + *p = 0; // expected-note{{Null pointer value stored to 'p'}} +} // no extra note + +int usage() { + int x = 0; + int *p = &x; + nullwriter(&p); // expected-note{{Calling 'nullwriter'}} + // expected-note@-1{{Returning from 'nullwriter'}} + return *p; // expected-warning{{Dereference of null pointer (loaded from variable 'p')}} + // expected-note@-1{{Dereference of null pointer (loaded from variable 'p')}} +} + +typedef struct { + int x; + int y; +} A; + +void partial_initializer(A *a) { + a->x = 0; +} // expected-note{{Returning without writing to 'a->y'}} + +int use_partial_initializer() { + A a; + partial_initializer(&a); // expected-note{{Calling 'partial_initializer'}} + // expected-note@-1{{Returning from 'partial_initializer'}} + return a.y; // expected-warning{{Undefined or garbage value returned to caller}} + // expected-note@-1{{Undefined or garbage value returned to caller}} +} + +typedef struct { + int x; + int y; +} B; + +typedef struct { + B b; +} C; + +void partial_nested_initializer(C *c) { + c->b.x = 0; +} // expected-note{{Returning without writing to 'c->b.y'}} + +int use_partial_nested_initializer() { + B localB; + C localC; + localC.b = localB; + partial_nested_initializer(&localC); // expected-note{{Calling 'partial_nested_initializer'}} + // expected-note@-1{{Returning from 'partial_nested_initializer'}} + return localC.b.y; // expected-warning{{Undefined or garbage value returned to caller}} + // expected-note@-1{{Undefined or garbage value returned to caller}} +} + +void test_subregion_assignment(C* c) { + B b; + c->b = b; +} + +int use_subregion_assignment() { + C c; + test_subregion_assignment(&c); // expected-note{{Calling 'test_subregion_assignment'}} + // expected-note@-1{{Returning from 'test_subregion_assignment'}} + return c.b.x; // expected-warning{{Undefined or garbage value returned to caller}} + // expected-note@-1{{Undefined or garbage value returned to caller}} +} + +int confusing_signature(int *); +int confusing_signature(int *p) { + return 0; // expected-note{{Returning without writing to '*p'}} +} + +int use_confusing_signature() { + int a; // expected-note {{'a' declared without an initial value}} + confusing_signature(&a); // expected-note{{Calling 'confusing_signature'}} + // expected-note@-1{{Returning from 'confusing_signature'}} + return a; // expected-note{{Undefined or garbage value returned to caller}} + // expected-warning@-1{{Undefined or garbage value returned to caller}} +} + +int coin(); + +int multiindirection(int **p) { + if (coin()) // expected-note{{Assuming the condition is true}} + // expected-note@-1{{Taking true branch}} + return 1; // expected-note{{Returning without writing to '**p'}} + *(*p) = 0; + return 0; +} + +int usemultiindirection() { + int a; // expected-note {{'a' declared without an initial value}} + int *b = &a; + multiindirection(&b); // expected-note{{Calling 'multiindirection'}} + // expected-note@-1{{Returning from 'multiindirection'}} + return a; // expected-note{{Undefined or garbage value returned to caller}} + // expected-warning@-1{{Undefined or garbage value returned to caller}} +} + +int indirectingstruct(S** s) { + if (coin()) // expected-note{{Assuming the condition is true}} + // expected-note@-1{{Taking true branch}} + return 1; // expected-note{{Returning without writing to '(*s)->x'}} + + (*s)->x = 0; + return 0; +} + +int useindirectingstruct() { + S s; + S* p = &s; + indirectingstruct(&p); //expected-note{{Calling 'indirectingstruct'}} + //expected-note@-1{{Returning from 'indirectingstruct'}} + return s.x; // expected-warning{{Undefined or garbage value returned to caller}} + // expected-note@-1{{Undefined or garbage value returned to caller}} +} diff --git a/test/Analysis/diagnostics/no-store-func-path-notes.cpp b/test/Analysis/diagnostics/no-store-func-path-notes.cpp new file mode 100644 index 000000000000..17ec96ae5b75 --- /dev/null +++ b/test/Analysis/diagnostics/no-store-func-path-notes.cpp @@ -0,0 +1,177 @@ +// RUN: %clang_analyze_cc1 -x c++ -analyzer-checker=core -analyzer-output=text -verify %s + +int initializer1(int &p, int x) { + if (x) { // expected-note{{Taking false branch}} + p = 1; + return 0; + } else { + return 1; // expected-note {{Returning without writing to 'p'}} + } +} + +int param_not_initialized_by_func() { + int p; // expected-note {{'p' declared without an initial value}} + int out = initializer1(p, 0); // expected-note{{Calling 'initializer1'}} + // expected-note@-1{{Returning from 'initializer1'}} + return p; // expected-note{{Undefined or garbage value returned to caller}} + // expected-warning@-1{{Undefined or garbage value returned to caller}} +} + +struct S { + int initialize(int *p, int param) { + if (param) { //expected-note{{Taking false branch}} + *p = 1; + return 1; + } + return 0; // expected-note{{Returning without writing to '*p'}} + } +}; + +int use(S *s) { + int p; //expected-note{{'p' declared without an initial value}} + s->initialize(&p, 0); //expected-note{{Calling 'S::initialize'}} + //expected-note@-1{{Returning from 'S::initialize'}} + return p; // expected-warning{{Undefined or garbage value returned to caller}} + // expected-note@-1{{Undefined or garbage value returned to caller}} +} + +int initializer2(const int &p) { + return 0; +} + +int no_msg_const_ref() { + int p; //expected-note{{'p' declared without an initial value}} + initializer2(p); + return p; // expected-warning{{Undefined or garbage value returned to caller}} + // expected-note@-1{{Undefined or garbage value returned to caller}} +} + +void nested() {} +void init_in_nested_func(int **x) { + *x = 0; // expected-note{{Null pointer value stored to 'y'}} + nested(); +} // no-note + +int call_init_nested() { + int x = 0; + int *y = &x; + init_in_nested_func(&y); // expected-note{{Calling 'init_in_nested_func'}} + // expected-note@-1{{Returning from 'init_in_nested_func'}} + return *y; //expected-warning{{Dereference of null pointer (loaded from variable 'y')}} + //expected-note@-1{{Dereference of null pointer (loaded from variable 'y')}} +} + +struct A { + int x; + int y; +}; + +void partial_init_by_reference(A &a) { + a.x = 0; +} // expected-note {{Returning without writing to 'a.y'}} + +int use_partial_init_by_reference() { + A a; + partial_init_by_reference(a); // expected-note{{Calling 'partial_init_by_reference'}} + // expected-note@-1{{Returning from 'partial_init_by_reference'}} + return a.y; // expected-warning{{Undefined or garbage value returned to caller}} + // expected-note@-1{{Undefined or garbage value returned to caller}} +} + +struct B : A { +}; + +void partially_init_inherited_struct(B *b) { + b->x = 0; +} // expected-note{{Returning without writing to 'b->y'}} + +int use_partially_init_inherited_struct() { + B b; + partially_init_inherited_struct(&b); // expected-note{{Calling 'partially_init_inherited_struct'}} + // expected-note@-1{{Returning from 'partially_init_inherited_struct'}} + return b.y; // expected-warning{{Undefined or garbage value returned to caller}} + // expected-note@-1{{Undefined or garbage value returned to caller}} +} + +struct C { + int x; + int y; + C(int pX, int pY) : x(pX) {} // expected-note{{Returning without writing to 'this->y'}} + + C(int pX, int pY, bool Flag) { + x = pX; + if (Flag) // expected-note{{Assuming 'Flag' is not equal to 0}} + // expected-note@-1{{Taking true branch}} + return; // expected-note{{Returning without writing to 'this->y'}} + y = pY; + } +}; + +int use_constructor() { + C c(0, 0); // expected-note{{Calling constructor for 'C'}} + // expected-note@-1{{Returning from constructor for 'C'}} + return c.y; // expected-note{{Undefined or garbage value returned to caller}} + // expected-warning@-1{{Undefined or garbage value returned to caller}} +} + +int coin(); + +int use_other_constructor() { + C c(0, 0, coin()); // expected-note{{Calling constructor for 'C'}} + // expected-note@-1{{Returning from constructor for 'C'}} + return c.y; // expected-note{{Undefined or garbage value returned to caller}} + // expected-warning@-1{{Undefined or garbage value returned to caller}} +} + +struct D { + void initialize(int *); +}; + +void D::initialize(int *p) { + +} // expected-note{{Returning without writing to '*p'}} + +int use_d_initializer(D* d) { + int p; // expected-note {{'p' declared without an initial value}} + d->initialize(&p); // expected-note{{Calling 'D::initialize'}} + // expected-note@-1{{Returning from 'D::initialize'}} + return p; // expected-note{{Undefined or garbage value returned to caller}} + // expected-warning@-1{{Undefined or garbage value returned to caller}} +} + +struct S2 { + int x; +}; + +int pointerreference(S2* &s) { + if (coin()) // expected-note{{Assuming the condition is true}} + // expected-note@-1{{Taking true branch}} + return 1; // expected-note{{Returning without writing to 's->x'}} + + s->x = 0; + return 0; +} + +int usepointerreference() { + S2 s; + S2* p = &s; + pointerreference(p); //expected-note{{Calling 'pointerreference'}} + //expected-note@-1{{Returning from 'pointerreference'}} + return s.x; // expected-warning{{Undefined or garbage value returned to caller}} + // expected-note@-1{{Undefined or garbage value returned to caller}} +} + +void *has_no_argument_and_returns_null(void) { + return 0; +} + +void rdar40335545() { + int local; // expected-note{{}} + void (*takes_int_ptr_argument)(int *) = (void (*)(int*))has_no_argument_and_returns_null; + + takes_int_ptr_argument(&local); // no-crash + + int useLocal = local; //expected-warning{{}} + //expected-note@-1{{}} + (void)useLocal; +} diff --git a/test/Analysis/diagnostics/no-store-func-path-notes.m b/test/Analysis/diagnostics/no-store-func-path-notes.m new file mode 100644 index 000000000000..51d1515e860a --- /dev/null +++ b/test/Analysis/diagnostics/no-store-func-path-notes.m @@ -0,0 +1,77 @@ +// RUN: %clang_analyze_cc1 -x objective-c -analyzer-checker=core,nullability -analyzer-output=text -Wno-objc-root-class -fblocks -verify %s + +#include "../Inputs/system-header-simulator-for-nullability.h" + +extern int coin(); + +@interface I : NSObject +- (int)initVar:(int *)var param:(int)param; +@end + +@implementation I +- (int)initVar:(int *)var param:(int)param { + if (param) { // expected-note{{Taking false branch}} + *var = 1; + return 0; + } + return 1; // expected-note{{Returning without writing to '*var'}} +} +@end + +int foo(I *i) { + int x; //expected-note{{'x' declared without an initial value}} + int out = [i initVar:&x param:0]; //expected-note{{Calling 'initVar:param:'}} + //expected-note@-1{{Returning from 'initVar:param:'}} + if (out) // expected-note{{Taking true branch}} + return x; //expected-warning{{Undefined or garbage value returned to caller}} + //expected-note@-1{{Undefined or garbage value returned to caller}} + return 0; +} + +int initializer1(int *p, int x) { + if (x) { // expected-note{{Taking false branch}} + *p = 1; + return 0; + } else { + return 1; // expected-note {{Returning without writing to '*p'}} + } +} + +int initFromBlock() { + __block int z; + ^{ // expected-note {{Calling anonymous block}} + int p; // expected-note{{'p' declared without an initial value}} + initializer1(&p, 0); // expected-note{{Calling 'initializer1'}} + // expected-note@-1{{Returning from 'initializer1'}} + z = p; // expected-warning{{Assigned value is garbage or undefined}} + // expected-note@-1{{Assigned value is garbage or undefined}} + }(); + return z; +} + +extern void expectNonNull(NSString * _Nonnull a); + +@interface A : NSObject +- (void) func; +- (void) initAMaybe; +@end + +@implementation A { + NSString * a; +} + +- (void) initAMaybe { + if (coin()) // expected-note{{Assuming the condition is false}} + // expected-note@-1{{Taking false branch}} + a = @"string"; +} // expected-note{{Returning without writing to 'self->a'}} + +- (void) func { + a = nil; // expected-note{{nil object reference stored to 'a'}} + [self initAMaybe]; // expected-note{{Calling 'initAMaybe'}} + // expected-note@-1{{Returning from 'initAMaybe'}} + expectNonNull(a); // expected-warning{{nil passed to a callee that requires a non-null 1st parameter}} + // expected-note@-1{{nil passed to a callee that requires a non-null 1st parameter}} +} + +@end diff --git a/test/Analysis/diagnostics/plist-multi-file.c b/test/Analysis/diagnostics/plist-multi-file.c new file mode 100644 index 000000000000..ff68d4850862 --- /dev/null +++ b/test/Analysis/diagnostics/plist-multi-file.c @@ -0,0 +1,205 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-html -o %t.plist -verify %s +// RUN: FileCheck --input-file=%t.plist %s + +#include "plist-multi-file.h" + +void bar() { + foo(0); +} + +// CHECK: <key>diagnostics</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>path</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>7</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>7</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>7</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Passing null pointer value via 1st parameter 'ptr'</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Passing null pointer value via 1st parameter 'ptr'</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>7</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>7</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>7</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Calling 'foo'</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Calling 'foo'</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>1</integer> +// CHECK-NEXT: <key>col</key><integer>1</integer> +// CHECK-NEXT: <key>file</key><integer>1</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>depth</key><integer>1</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Entered call from 'bar'</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Entered call from 'bar'</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>1</integer> +// CHECK-NEXT: <key>col</key><integer>1</integer> +// CHECK-NEXT: <key>file</key><integer>1</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>1</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>file</key><integer>1</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>2</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>1</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>2</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>1</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>2</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>1</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>2</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>1</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>2</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> +// CHECK-NEXT: <key>file</key><integer>1</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>2</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> +// CHECK-NEXT: <key>file</key><integer>1</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>2</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> +// CHECK-NEXT: <key>file</key><integer>1</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>2</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>file</key><integer>1</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>2</integer> +// CHECK-NEXT: <key>col</key><integer>6</integer> +// CHECK-NEXT: <key>file</key><integer>1</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>1</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Dereference of null pointer (loaded from variable 'ptr')</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Dereference of null pointer (loaded from variable 'ptr')</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>description</key><string>Dereference of null pointer (loaded from variable 'ptr')</string> +// CHECK-NEXT: <key>category</key><string>Logic error</string> +// CHECK-NEXT: <key>type</key><string>Dereference of null pointer</string> +// CHECK-NEXT: <key>check_name</key><string>core.NullDereference</string> +// CHECK-NEXT: <!-- This hash is experimental and going to change! --> +// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>2058c95994cab381890af28e7bf354bf</string> +// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> +// CHECK-NEXT: <key>issue_context</key><string>foo</string> +// CHECK-NEXT: <key>issue_hash_function_offset</key><string>1</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>2</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> +// CHECK-NEXT: <key>file</key><integer>1</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>HTMLDiagnostics_files</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <string>report-{{([0-9a-f]{6})}}.html</string> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> diff --git a/test/Analysis/diagnostics/plist-multi-file.h b/test/Analysis/diagnostics/plist-multi-file.h new file mode 100644 index 000000000000..c0674f9dfcf0 --- /dev/null +++ b/test/Analysis/diagnostics/plist-multi-file.h @@ -0,0 +1,3 @@ +void foo(int *ptr) { + *ptr = 1; // expected-warning{{Dereference of null pointer (loaded from variable 'ptr')}} +} diff --git a/test/Analysis/diagnostics/report-issues-within-main-file.cpp b/test/Analysis/diagnostics/report-issues-within-main-file.cpp index e1dccc8e3204..18795d25bd85 100644 --- a/test/Analysis/diagnostics/report-issues-within-main-file.cpp +++ b/test/Analysis/diagnostics/report-issues-within-main-file.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix -analyzer-output=plist-multi-file -analyzer-config report-in-main-source-file=true -analyzer-config path-diagnostics-alternate=false %s -o %t.plist +// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix -analyzer-output=plist-multi-file -analyzer-config report-in-main-source-file=true %s -o %t.plist // RUN: FileCheck --input-file=%t.plist %s #include "Inputs/include/report-issues-within-main-file.h" @@ -77,6 +77,40 @@ void callInMacroArg() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>49</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>49</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>51</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>51</integer> +// CHECK-NEXT: <key>col</key><integer>23</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -343,6 +377,40 @@ void callInMacroArg() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>56</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>56</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>58</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>58</integer> +// CHECK-NEXT: <key>col</key><integer>23</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -532,6 +600,40 @@ void callInMacroArg() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>67</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>67</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>69</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>69</integer> +// CHECK-NEXT: <key>col</key><integer>18</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -721,40 +823,6 @@ void callInMacroArg() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -792,46 +860,12 @@ void callInMacroArg() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>6</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1542,40 +1576,6 @@ void callInMacroArg() { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>43</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>43</integer> -// CHECK-NEXT: <key>col</key><integer>14</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>43</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>43</integer> -// CHECK-NEXT: <key>col</key><integer>14</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>44</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> diff --git a/test/Analysis/diagnostics/undef-value-caller.c b/test/Analysis/diagnostics/undef-value-caller.c index 4f273bd9a72d..60a885afe292 100644 --- a/test/Analysis/diagnostics/undef-value-caller.c +++ b/test/Analysis/diagnostics/undef-value-caller.c @@ -1,4 +1,4 @@ -// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist -analyzer-config path-diagnostics-alternate=false -o %t %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist -o %t %s // RUN: FileCheck --input-file %t %s #include "undef-value-callee.h" @@ -66,40 +66,6 @@ int test_calling_unimportant_callee(int argc, char *argv[]) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>10</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>10</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>10</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>10</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> diff --git a/test/Analysis/diagnostics/undef-value-param.c b/test/Analysis/diagnostics/undef-value-param.c index 837b0419ef20..99e31d2e6c55 100644 --- a/test/Analysis/diagnostics/undef-value-param.c +++ b/test/Analysis/diagnostics/undef-value-param.c @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=text -verify %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file -analyzer-config path-diagnostics-alternate=false %s -o %t.plist +// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file %s -o %t.plist // RUN: FileCheck --input-file=%t.plist %s void foo_irrelevant(int c) { @@ -12,7 +12,7 @@ void foo(int c, int *x) { if (c) //expected-note@-1{{Assuming 'c' is not equal to 0}} //expected-note@-2{{Taking true branch}} - return; + return; // expected-note{{Returning without writing to '*x'}} *x = 5; } @@ -51,7 +51,7 @@ void initStruct(int x, struct WithFields *X) { if (x <= 0) //expected-note {{Taking true branch}} //expected-note@-1 {{Assuming 'x' is <= 0}} - return; + return; //expected-note{{Returning without writing to 'X->f1'}} X->f1 = getValidPtr(); } double testPassingParentRegionStruct(int x) { @@ -293,12 +293,94 @@ double testPassingParentRegionStruct(int x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>15</integer> -// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>15</integer> -// CHECK-NEXT: <key>col</key><integer>14</integer> +// CHECK-NEXT: <key>col</key><integer>17</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>17</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>17</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>depth</key><integer>1</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Returning without writing to '*x'</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Returning without writing to '*x'</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>17</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>17</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1043,6 +1125,88 @@ double testPassingParentRegionStruct(int x) { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>54</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>54</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>54</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>54</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>54</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>depth</key><integer>1</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Returning without writing to 'X->f1'</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Returning without writing to 'X->f1'</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>54</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>54</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>54</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>54</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> diff --git a/test/Analysis/diagnostics/undef-value-param.m b/test/Analysis/diagnostics/undef-value-param.m index f8212e0b9df3..69bc9b991da6 100644 --- a/test/Analysis/diagnostics/undef-value-param.m +++ b/test/Analysis/diagnostics/undef-value-param.m @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,osx -analyzer-output=text -verify %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx -analyzer-output=plist-multi-file -analyzer-config path-diagnostics-alternate=false %s -o %t.plist +// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx -analyzer-output=plist-multi-file %s -o %t.plist // RUN: FileCheck --input-file=%t.plist %s typedef signed char BOOL; @@ -69,7 +69,7 @@ static void CreateRefUndef(SCDynamicStoreRef *storeRef, unsigned x) { //expected-note@-1{{Assuming 'err' is not equal to 0}} //expected-note@-2{{Taking true branch}} CFRelease(ref); - return; + return; // expected-note{{Returning without writing to '*storeRef'}} } *storeRef = ref; } @@ -831,6 +831,122 @@ static void CreateRefUndef(SCDynamicStoreRef *storeRef, unsigned x) { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>71</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>71</integer> +// CHECK-NEXT: <key>col</key><integer>13</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>72</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>72</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>72</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>72</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>72</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>72</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>72</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>depth</key><integer>1</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Returning without writing to '*storeRef'</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Returning without writing to '*storeRef'</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>72</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>72</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>72</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>72</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> diff --git a/test/Analysis/dtor-cxx11.cpp b/test/Analysis/dtor-cxx11.cpp index 76d5e6c5065d..33e13e99bd3b 100644 --- a/test/Analysis/dtor-cxx11.cpp +++ b/test/Analysis/dtor-cxx11.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config cfg-temporary-dtors=true -Wno-null-dereference -verify %s +// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -Wno-null-dereference -verify %s // expected-no-diagnostics #include "Inputs/system-header-simulator-cxx.h" diff --git a/test/Analysis/dtor.cpp b/test/Analysis/dtor.cpp index bc74130b2fdf..c31bbe774b81 100644 --- a/test/Analysis/dtor.cpp +++ b/test/Analysis/dtor.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection,cplusplus -analyzer-config c++-inlining=destructors,cfg-temporary-dtors=true -Wno-null-dereference -Wno-inaccessible-base -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection,cplusplus -analyzer-config c++-inlining=destructors -Wno-null-dereference -Wno-inaccessible-base -verify %s void clang_analyzer_eval(bool); void clang_analyzer_checkInlined(bool); diff --git a/test/Analysis/dynamic_type_check.m b/test/Analysis/dynamic_type_check.m index 3dc9465cfedf..6753892e1d52 100644 --- a/test/Analysis/dynamic_type_check.m +++ b/test/Analysis/dynamic_type_check.m @@ -36,7 +36,7 @@ void testTypeCheck(NSString* str) { void testForwardDeclarations(NSString* str) { id obj = str; - // Do not warn, since no information is available wether MyType is a sub or + // Do not warn, since no information is available whether MyType is a sub or // super class of any other type. MyType *num = obj; // no warning (void)num; diff --git a/test/Analysis/edges-new.mm b/test/Analysis/edges-new.mm index f310f1bfa12e..3e9615b94b6c 100644 --- a/test/Analysis/edges-new.mm +++ b/test/Analysis/edges-new.mm @@ -1,4 +1,4 @@ -// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,deadcode.DeadStores,osx.cocoa.RetainCount,unix.Malloc,unix.MismatchedDeallocator -analyzer-eagerly-assume -analyzer-config path-diagnostics-alternate=true -analyzer-output=plist -o %t -w %s +// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,deadcode.DeadStores,osx.cocoa.RetainCount,unix.Malloc,unix.MismatchedDeallocator -analyzer-eagerly-assume -analyzer-output=plist -o %t -w %s // RUN: FileCheck --input-file %t %s //===----------------------------------------------------------------------===// diff --git a/test/Analysis/explain-svals.cpp b/test/Analysis/explain-svals.cpp index d4b56a348252..c1b5200eb8e9 100644 --- a/test/Analysis/explain-svals.cpp +++ b/test/Analysis/explain-svals.cpp @@ -69,7 +69,7 @@ void test_4(int x, int y) { static int stat; clang_analyzer_explain(x + 1); // expected-warning-re{{{{^\(argument 'x'\) \+ 1$}}}} clang_analyzer_explain(1 + y); // expected-warning-re{{{{^\(argument 'y'\) \+ 1$}}}} - clang_analyzer_explain(x + y); // expected-warning-re{{{{^unknown value$}}}} + clang_analyzer_explain(x + y); // expected-warning-re{{{{^\(argument 'x'\) \+ \(argument 'y'\)$}}}} clang_analyzer_explain(z); // expected-warning-re{{{{^undefined value$}}}} clang_analyzer_explain(&z); // expected-warning-re{{{{^pointer to local variable 'z'$}}}} clang_analyzer_explain(stat); // expected-warning-re{{{{^signed 32-bit integer '0'$}}}} @@ -94,5 +94,5 @@ public: void test_6() { clang_analyzer_explain(conjure_S()); // expected-warning-re{{{{^lazily frozen compound value of temporary object constructed at statement 'conjure_S\(\)'$}}}} - clang_analyzer_explain(conjure_S().z); // expected-warning-re{{{{^value derived from \(symbol of type 'struct S' conjured at statement 'conjure_S\(\)'\) for field 'z' of temporary object constructed at statement 'conjure_S\(\)'$}}}} + clang_analyzer_explain(conjure_S().z); // expected-warning-re{{{{^value derived from \(symbol of type 'int' conjured at statement 'conjure_S\(\)'\) for field 'z' of temporary object constructed at statement 'conjure_S\(\)'$}}}} } diff --git a/test/Analysis/exploration_order/noexprcrash.c b/test/Analysis/exploration_order/noexprcrash.c new file mode 100644 index 000000000000..75c2f0e6798a --- /dev/null +++ b/test/Analysis/exploration_order/noexprcrash.c @@ -0,0 +1,17 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify -analyzer-config exploration_strategy=unexplored_first %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify -analyzer-config exploration_strategy=dfs %s + +extern void clang_analyzer_eval(int); + +typedef struct { char a; } b; +int c(b* input) { + int x = (input->a ?: input) ? 1 : 0; // expected-warning{{pointer/integer type mismatch}} + if (input->a) { + // FIXME: The value should actually be "TRUE", + // but is incorrect due to a bug. + clang_analyzer_eval(x); // expected-warning{{FALSE}} + } else { + clang_analyzer_eval(x); // expected-warning{{TRUE}} + } + return x; +} diff --git a/test/Analysis/exploration_order/prefer_unexplored.cpp b/test/Analysis/exploration_order/prefer_unexplored.cpp new file mode 100644 index 000000000000..29e763357727 --- /dev/null +++ b/test/Analysis/exploration_order/prefer_unexplored.cpp @@ -0,0 +1,43 @@ +// RUN: %clang_analyze_cc1 -w -analyzer-checker=core -analyzer-config exploration_strategy=unexplored_first -analyzer-output=text -verify %s +// RUN: %clang_analyze_cc1 -w -analyzer-checker=core -analyzer-config exploration_strategy=unexplored_first_queue -analyzer-output=text -verify %s + +extern int coin(); + +int foo() { + int *x = 0; // expected-note {{'x' initialized to a null pointer value}} + while (coin()) { // expected-note{{Loop condition is true}} + if (coin()) // expected-note {{Taking true branch}} + // expected-note@-1 {{Assuming the condition is true}} + return *x; // expected-warning{{Dereference of null pointer (loaded from variable 'x')}} + // expected-note@-1{{Dereference of null pointer (loaded from variable 'x')}} + } + return 0; +} + +void bar() { + while(coin()) + if (coin()) + foo(); +} + +int foo2() { + int *x = 0; // expected-note {{'x' initialized to a null pointer value}} + while (coin()) { // expected-note{{Loop condition is true}} + if (coin()) // expected-note {{Taking false branch}} + // expected-note@-1 {{Assuming the condition is false}} + return false; + else + return *x; // expected-warning{{Dereference of null pointer (loaded from variable 'x')}} + // expected-note@-1{{Dereference of null pointer (loaded from variable 'x')}} + } + return 0; +} + +void bar2() { + while(coin()) // expected-note{{Loop condition is true}} + if (coin()) // expected-note {{Assuming the condition is false}} + // expected-note@-1 {{Taking false branch}} + return; + else + foo(); // expected-note{{Calling 'foo'}} +} diff --git a/test/Analysis/expr-inspection.c b/test/Analysis/expr-inspection.c index ec0e682b6536..841954288932 100644 --- a/test/Analysis/expr-inspection.c +++ b/test/Analysis/expr-inspection.c @@ -18,6 +18,8 @@ void foo(int x) { // CHECK: Store (direct and default bindings) // CHECK-NEXT: (y,0,direct) : 1 S32b -// CHECK: Expressions: +// CHECK: Expressions by stack frame: +// CHECK-NEXT: #0 Calling foo // CHECK-NEXT: clang_analyzer_printState : &code{clang_analyzer_printState} -// CHECK-NEXT: {{(Ranges are empty.)|(Constraints:[[:space:]]*$)}} + +// CHECK: {{(Ranges are empty.)|(Constraints:[[:space:]]*$)}} diff --git a/test/Analysis/gcdantipatternchecker_test.m b/test/Analysis/gcdantipatternchecker_test.m new file mode 100644 index 000000000000..24ffe8975dd9 --- /dev/null +++ b/test/Analysis/gcdantipatternchecker_test.m @@ -0,0 +1,345 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,optin.performance.GCDAntipattern %s -fblocks -verify +typedef signed char BOOL; +@protocol NSObject - (BOOL)isEqual:(id)object; @end +@interface NSObject <NSObject> {} ++(id)alloc; +-(id)init; +-(id)autorelease; +-(id)copy; +-(id)retain; +@end + +typedef int dispatch_semaphore_t; +typedef int dispatch_group_t; +typedef void (^block_t)(); + +dispatch_semaphore_t dispatch_semaphore_create(int); +dispatch_group_t dispatch_group_create(); +void dispatch_group_enter(dispatch_group_t); +void dispatch_group_leave(dispatch_group_t); +void dispatch_group_wait(dispatch_group_t, int); + + +void dispatch_semaphore_wait(dispatch_semaphore_t, int); +void dispatch_semaphore_signal(dispatch_semaphore_t); + +void func(void (^)(void)); +void func_w_typedef(block_t); + +int coin(); + +void use_semaphor_antipattern() { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + + func(^{ + dispatch_semaphore_signal(sema); + }); + dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a callback using a semaphore}} +} + +// It's OK to use pattern in tests. +// We simply match the containing function name against ^test. +void test_no_warning() { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + + func(^{ + dispatch_semaphore_signal(sema); + }); + dispatch_semaphore_wait(sema, 100); +} + +void use_semaphor_antipattern_multiple_times() { + dispatch_semaphore_t sema1 = dispatch_semaphore_create(0); + + func(^{ + dispatch_semaphore_signal(sema1); + }); + dispatch_semaphore_wait(sema1, 100); // expected-warning{{Waiting on a callback using a semaphore}} + + dispatch_semaphore_t sema2 = dispatch_semaphore_create(0); + + func(^{ + dispatch_semaphore_signal(sema2); + }); + dispatch_semaphore_wait(sema2, 100); // expected-warning{{Waiting on a callback using a semaphore}} +} + +void use_semaphor_antipattern_multiple_wait() { + dispatch_semaphore_t sema1 = dispatch_semaphore_create(0); + + func(^{ + dispatch_semaphore_signal(sema1); + }); + // FIXME: multiple waits on same semaphor should not raise a warning. + dispatch_semaphore_wait(sema1, 100); // expected-warning{{Waiting on a callback using a semaphore}} + dispatch_semaphore_wait(sema1, 100); // expected-warning{{Waiting on a callback using a semaphore}} +} + +void warn_incorrect_order() { + // FIXME: ASTMatchers do not allow ordered matching, so would match even + // if out of order. + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + + dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a callback}} + func(^{ + dispatch_semaphore_signal(sema); + }); +} + +void warn_w_typedef() { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + + func_w_typedef(^{ + dispatch_semaphore_signal(sema); + }); + dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a callback using a semaphore}} +} + +void warn_nested_ast() { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + + if (coin()) { + func(^{ + dispatch_semaphore_signal(sema); + }); + } else { + func(^{ + dispatch_semaphore_signal(sema); + }); + } + dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a callback using a semaphore}} +} + +void use_semaphore_assignment() { + dispatch_semaphore_t sema; + sema = dispatch_semaphore_create(0); + + func(^{ + dispatch_semaphore_signal(sema); + }); + dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a callback using a semaphore}} +} + +void use_semaphore_assignment_init() { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + sema = dispatch_semaphore_create(1); + + func(^{ + dispatch_semaphore_signal(sema); + }); + dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a callback using a semaphore}} +} + +void differentsemaphoreok() { + dispatch_semaphore_t sema1 = dispatch_semaphore_create(0); + dispatch_semaphore_t sema2 = dispatch_semaphore_create(0); + + func(^{ + dispatch_semaphore_signal(sema1); + }); + dispatch_semaphore_wait(sema2, 100); // no-warning +} + +void nosignalok() { + dispatch_semaphore_t sema1 = dispatch_semaphore_create(0); + dispatch_semaphore_wait(sema1, 100); +} + +void nowaitok() { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + func(^{ + dispatch_semaphore_signal(sema); + }); +} + +void noblockok() { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + dispatch_semaphore_signal(sema); + dispatch_semaphore_wait(sema, 100); +} + +void storedblockok() { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + block_t b = ^{ + dispatch_semaphore_signal(sema); + }; + dispatch_semaphore_wait(sema, 100); +} + +void passed_semaphore_ok(dispatch_semaphore_t sema) { + func(^{ + dispatch_semaphore_signal(sema); + }); + dispatch_semaphore_wait(sema, 100); +} + +void warn_with_cast() { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + + func(^{ + dispatch_semaphore_signal((int)sema); + }); + dispatch_semaphore_wait((int)sema, 100); // expected-warning{{Waiting on a callback using a semaphore}} +} + +@interface MyInterface1 : NSObject +-(void)use_method_warn; +-(void) pass_block_as_second_param_warn; +-(void)use_objc_callback_warn; +-(void) use_dispatch_group; +-(void)testNoWarn; +-(void)acceptBlock:(block_t)callback; +-(void)flag:(int)flag acceptBlock:(block_t)callback; +@end + +@implementation MyInterface1 + +-(void)use_method_warn { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + + func(^{ + dispatch_semaphore_signal(sema); + }); + dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a callback}} +} + +-(void) pass_block_as_second_param_warn { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + + [self flag:1 acceptBlock:^{ + dispatch_semaphore_signal(sema); + }]; + dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a callback}} +} + +-(void)testNoWarn { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + + func(^{ + dispatch_semaphore_signal(sema); + }); + dispatch_semaphore_wait(sema, 100); +} + +-(void)acceptBlock:(block_t) callback { + callback(); +} + +-(void)flag:(int)flag acceptBlock:(block_t)callback { + callback(); +} + +-(void)use_objc_callback_warn { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + + [self acceptBlock:^{ + dispatch_semaphore_signal(sema); + }]; + dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a callback}} +} + +-(void)use_dispatch_group { + dispatch_group_t group = dispatch_group_create(); + dispatch_group_enter(group); + [self acceptBlock:^{ + dispatch_group_leave(group); + }]; + dispatch_group_wait(group, 100); // expected-warning{{Waiting on a callback using a group}} + +} + +void use_objc_and_c_callback(MyInterface1 *t) { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + + func(^{ + dispatch_semaphore_signal(sema); + }); + dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a callback using a semaphore}} + + dispatch_semaphore_t sema1 = dispatch_semaphore_create(0); + + [t acceptBlock:^{ + dispatch_semaphore_signal(sema1); + }]; + dispatch_semaphore_wait(sema1, 100); // expected-warning{{Waiting on a callback}} +} +@end + +// No warnings: class name contains "test" +@interface Test1 : NSObject +-(void)use_method_warn; +@end + +@implementation Test1 +-(void)use_method_warn { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + + func(^{ + dispatch_semaphore_signal(sema); + }); + dispatch_semaphore_wait(sema, 100); +} +@end + + +// No warnings: class name contains "mock" +@interface Mock1 : NSObject +-(void)use_method_warn; +@end + +@implementation Mock1 +-(void)use_method_warn { + dispatch_semaphore_t sema = dispatch_semaphore_create(0); + + func(^{ + dispatch_semaphore_signal(sema); + }); + dispatch_semaphore_wait(sema, 100); +} +@end + +void dispatch_group_wait_func(MyInterface1 *M) { + dispatch_group_t group = dispatch_group_create(); + dispatch_group_enter(group); + + func(^{ + dispatch_group_leave(group); + }); + dispatch_group_wait(group, 100); // expected-warning{{Waiting on a callback using a group}} +} + + +void dispatch_group_wait_cfunc(MyInterface1 *M) { + dispatch_group_t group = dispatch_group_create(); + dispatch_group_enter(group); + [M acceptBlock:^{ + dispatch_group_leave(group); + }]; + dispatch_group_wait(group, 100); // expected-warning{{Waiting on a callback using a group}} +} + +void dispatch_group_and_semaphore_use(MyInterface1 *M) { + dispatch_group_t group = dispatch_group_create(); + dispatch_group_enter(group); + [M acceptBlock:^{ + dispatch_group_leave(group); + }]; + dispatch_group_wait(group, 100); // expected-warning{{Waiting on a callback using a group}} + + dispatch_semaphore_t sema1 = dispatch_semaphore_create(0); + + [M acceptBlock:^{ + dispatch_semaphore_signal(sema1); + }]; + dispatch_semaphore_wait(sema1, 100); // expected-warning{{Waiting on a callback using a semaphore}} +} + +void no_warn_on_nonzero_semaphore(MyInterface1 *M) { + dispatch_semaphore_t sema1 = dispatch_semaphore_create(1); + + [M acceptBlock:^{ + dispatch_semaphore_signal(sema1); + }]; + dispatch_semaphore_wait(sema1, 100); // no-warning +} + diff --git a/test/Analysis/globals.cpp b/test/Analysis/globals.cpp new file mode 100644 index 000000000000..5bbb241bdcf3 --- /dev/null +++ b/test/Analysis/globals.cpp @@ -0,0 +1,111 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core -verify %s + + +static const unsigned long long scull = 0; +void static_int() +{ + *(int*)scull = 0; // expected-warning{{Dereference of null pointer}} +} + +const unsigned long long cull = 0; +void const_int() +{ + *(int*)cull = 0; // expected-warning{{Dereference of null pointer}} +} + +static int * const spc = 0; +void static_ptr() +{ + *spc = 0; // expected-warning{{Dereference of null pointer}} +} + +int * const pc = 0; +void const_ptr() +{ + *pc = 0; // expected-warning{{Dereference of null pointer}} +} + +const unsigned long long cull_nonnull = 4; +void nonnull_int() +{ + *(int*)(cull_nonnull - 4) = 0; // expected-warning{{Dereference of null pointer}} +} + +int * const pc_nonnull = (int*)sizeof(int); +void nonnull_ptr() +{ + *(pc_nonnull - 1) = 0; // expected-warning{{Dereference of null pointer}} +} + +int * const constcast = const_cast<int * const>((int*)sizeof(int)); +void cast1() +{ + *(constcast - 1) = 0; // expected-warning{{Dereference of null pointer}} +} + +int * const recast = reinterpret_cast<int*>(sizeof(int)); +void cast2() +{ + *(recast - 1) = 0; // expected-warning{{Dereference of null pointer}} +} + +int * const staticcast = static_cast<int * const>((int*)sizeof(int)); +void cast3() +{ + *(staticcast - 1) = 0; // expected-warning{{Dereference of null pointer}} +} + +struct Foo { int a; }; +Foo * const dyncast = dynamic_cast<Foo * const>((Foo*)sizeof(Foo)); +void cast4() +{ + // Do not handle dynamic_cast for now, because it may change the pointer value. + (dyncast - 1)->a = 0; // no-warning +} + +typedef int * const intptrconst; +int * const funccast = intptrconst(sizeof(int)); +void cast5() +{ + *(funccast - 1) = 0; // expected-warning{{Dereference of null pointer}} +} + +struct S1 +{ + int * p; +}; +const S1 s1 = { + .p = (int*)sizeof(int) +}; +void conststruct() +{ + *(s1.p - 1) = 0; // expected-warning{{Dereference of null pointer}} +} + +struct S2 +{ + int * const p; +}; +S2 s2 = { + .p = (int*)sizeof(int) +}; +void constfield() +{ + *(s2.p - 1) = 0; // expected-warning{{Dereference of null pointer}} +} + +int * const parr[1] = { (int*)sizeof(int) }; +void constarr() +{ + *(parr[0] - 1) = 0; // expected-warning{{Dereference of null pointer}} +} + +struct S3 +{ + int * p = (int*)sizeof(int); +}; +void recordinit() +{ + S3 s3; + *(s3.p - 1) = 0; // expected-warning{{Dereference of null pointer}} +} diff --git a/test/Analysis/gtest.cpp b/test/Analysis/gtest.cpp index 98f415eea456..e68303d5492a 100644 --- a/test/Analysis/gtest.cpp +++ b/test/Analysis/gtest.cpp @@ -1,6 +1,5 @@ //RUN: %clang_analyze_cc1 -cc1 -std=c++11 -analyzer-checker=core,apiModeling.google.GTest,debug.ExprInspection -analyzer-eagerly-assume %s -verify //RUN: %clang_analyze_cc1 -cc1 -std=c++11 -analyzer-checker=core,apiModeling.google.GTest,debug.ExprInspection -analyzer-eagerly-assume -DGTEST_VERSION_1_8_AND_LATER=1 %s -verify -//RUN: %clang_analyze_cc1 -cc1 -std=c++11 -analyzer-checker=core,apiModeling.google.GTest,debug.ExprInspection -analyzer-eagerly-assume -analyzer-config cfg-temporary-dtors=true %s -verify void clang_analyzer_eval(int); void clang_analyzer_warnIfReached(); @@ -155,13 +154,11 @@ void testConstrainState(int p) { void testAssertSymbolicPtr(const bool *b) { ASSERT_TRUE(*b); // no-crash - // FIXME: Our solver doesn't handle this well yet. - clang_analyzer_eval(*b); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(*b); // expected-warning{{TRUE}} } void testAssertSymbolicRef(const bool &b) { ASSERT_TRUE(b); // no-crash - // FIXME: Our solver doesn't handle this well yet. - clang_analyzer_eval(b); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(b); // expected-warning{{TRUE}} } diff --git a/test/Analysis/hangs.c b/test/Analysis/hangs.c new file mode 100644 index 000000000000..b109bcb52fdb --- /dev/null +++ b/test/Analysis/hangs.c @@ -0,0 +1,30 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker core -verify %s + +// expected-no-diagnostics + +// Stuff that used to hang. + +int g(); + +int f(int y) { + return y + g(); +} + +int produce_a_very_large_symbol(int x) { + return f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f( + f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(x)))))))))))))))))))))))))))))))); +} + +void produce_an_exponentially_exploding_symbol(int x, int y) { + x += y; y += x + g(); + x += y; y += x + g(); + x += y; y += x + g(); + x += y; y += x + g(); + x += y; y += x + g(); + x += y; y += x + g(); + x += y; y += x + g(); + x += y; y += x + g(); + x += y; y += x + g(); + x += y; y += x + g(); + x += y; y += x + g(); +} diff --git a/test/Analysis/html_diagnostics/relevant_lines/goto.c b/test/Analysis/html_diagnostics/relevant_lines/goto.c new file mode 100644 index 000000000000..fc90f1334f07 --- /dev/null +++ b/test/Analysis/html_diagnostics/relevant_lines/goto.c @@ -0,0 +1,13 @@ +int goto_test(int input) { + int *p = 0; + if (input) + goto mylabel; + return 0; +mylabel: + return *p; +} + +// RUN: rm -rf %t.output +// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output %s +// RUN: cat %t.output/* | FileCheck %s --match-full-lines +// CHECK: var relevant_lines = {"1": {"1": 1, "2": 1, "3": 1, "4": 1, "6": 1, "7": 1}}; diff --git a/test/Analysis/html_diagnostics/relevant_lines/header.h b/test/Analysis/html_diagnostics/relevant_lines/header.h new file mode 100644 index 000000000000..579b66a1cb31 --- /dev/null +++ b/test/Analysis/html_diagnostics/relevant_lines/header.h @@ -0,0 +1,12 @@ +#define deref(X) (*X) + +char helper( + char *out, + int doDereference) { + if (doDereference) { + return deref(out); + } else { + return 'x'; + } + return 'c'; +} diff --git a/test/Analysis/html_diagnostics/relevant_lines/macros_same_file.c b/test/Analysis/html_diagnostics/relevant_lines/macros_same_file.c new file mode 100644 index 000000000000..5b3556526add --- /dev/null +++ b/test/Analysis/html_diagnostics/relevant_lines/macros_same_file.c @@ -0,0 +1,15 @@ +#define deref(X) (*X) + +int f(int coin) { + if (coin) { + int *x = 0; + return deref(x); + } else { + return 0; + } +} + +// RUN: rm -rf %t.output +// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output %s +// RUN: cat %t.output/* | FileCheck %s --match-full-lines +// CHECK: var relevant_lines = {"1": {"3": 1, "4": 1, "5": 1, "6": 1}}; diff --git a/test/Analysis/html_diagnostics/relevant_lines/multifile.c b/test/Analysis/html_diagnostics/relevant_lines/multifile.c new file mode 100644 index 000000000000..3abffd609b5b --- /dev/null +++ b/test/Analysis/html_diagnostics/relevant_lines/multifile.c @@ -0,0 +1,14 @@ +#include "header.h" + +int f(int coin) { + char *p = 0; + if (coin) { + return helper(p, coin); + } + return 0; +} + +// RUN: rm -rf %t.output +// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output %s +// RUN: cat %t.output/* | FileCheck %s --match-full-lines +// CHECK: var relevant_lines = {"1": {"3": 1, "4": 1, "5": 1, "6": 1}, "3": {"3": 1, "4": 1, "5": 1, "6": 1, "7": 1}}; diff --git a/test/Analysis/html_diagnostics/relevant_lines/multiline_func_def.c b/test/Analysis/html_diagnostics/relevant_lines/multiline_func_def.c new file mode 100644 index 000000000000..35158a46868c --- /dev/null +++ b/test/Analysis/html_diagnostics/relevant_lines/multiline_func_def.c @@ -0,0 +1,16 @@ +int f( + int coin, + int paramA, + int paramB) { + if (coin) { + int *x = 0; + return *x; + } else { + return 0; + } +} + +// RUN: rm -rf %t.output +// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output %s +// RUN: cat %t.output/* | FileCheck %s --match-full-lines +// CHECK: var relevant_lines = {"1": {"1": 1, "2": 1, "3": 1, "4": 1, "5": 1, "6": 1, "7": 1}}; diff --git a/test/Analysis/html_diagnostics/relevant_lines/notexecutedlines.c b/test/Analysis/html_diagnostics/relevant_lines/notexecutedlines.c new file mode 100644 index 000000000000..3c723aa93349 --- /dev/null +++ b/test/Analysis/html_diagnostics/relevant_lines/notexecutedlines.c @@ -0,0 +1,12 @@ +int f() { + int zzz = 200; + zzz += 100; + return 0; +} + +// Show line with the warning even if it wasn't executed (e.g. warning given +// by path-insensitive analysis). +// RUN: rm -rf %t.output +// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core,deadcode -analyzer-output html -o %t.output %s +// RUN: cat %t.output/* | FileCheck %s --match-full-lines +// CHECK: var relevant_lines = {"1": {"3": 1}}; diff --git a/test/Analysis/html_diagnostics/relevant_lines/objcmethods.m b/test/Analysis/html_diagnostics/relevant_lines/objcmethods.m new file mode 100644 index 000000000000..41a4c1d2e097 --- /dev/null +++ b/test/Analysis/html_diagnostics/relevant_lines/objcmethods.m @@ -0,0 +1,19 @@ +@interface I +- (int)func; +@end + +@implementation I +- (int)func:(int *)param { + return *param; +} +@end + +void foo(I *i) { + int *x = 0; + [i func:x]; +} + +// RUN: rm -rf %t.output +// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output -Wno-objc-root-class %s +// RUN: cat %t.output/* | FileCheck %s +// CHECK: var relevant_lines = {"1": {"6": 1, "7": 1, "11": 1, "12": 1, "13": 1}}; diff --git a/test/Analysis/html_diagnostics/relevant_lines/simple_conditional.c b/test/Analysis/html_diagnostics/relevant_lines/simple_conditional.c new file mode 100644 index 000000000000..769859dea5ef --- /dev/null +++ b/test/Analysis/html_diagnostics/relevant_lines/simple_conditional.c @@ -0,0 +1,13 @@ +int f(int coin) { + if (coin) { + int *x = 0; + return *x; + } else { + return 0; + } +} + +// RUN: rm -rf %t.output +// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output %s +// RUN: cat %t.output/* | FileCheck %s --match-full-lines +// CHECK: var relevant_lines = {"1": {"1": 1, "2": 1, "3": 1, "4": 1}}; diff --git a/test/Analysis/html_diagnostics/relevant_lines/switch.c b/test/Analysis/html_diagnostics/relevant_lines/switch.c new file mode 100644 index 000000000000..e9032cdece9d --- /dev/null +++ b/test/Analysis/html_diagnostics/relevant_lines/switch.c @@ -0,0 +1,20 @@ +enum E { + A, B, C +}; + +int f(enum E input) { + int *x = 0; + switch (input) { + case A: + return 1; + case B: + return 0; + case C: + return *x; + } +} + +// RUN: rm -rf %t.output +// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output %s +// RUN: cat %t.output/* | FileCheck %s --match-full-lines +// CHECK: var relevant_lines = {"1": {"5": 1, "6": 1, "7": 1, "12": 1, "13": 1}}; diff --git a/test/Analysis/html_diagnostics/relevant_lines/switch_default.c b/test/Analysis/html_diagnostics/relevant_lines/switch_default.c new file mode 100644 index 000000000000..b14e3f9fa8fd --- /dev/null +++ b/test/Analysis/html_diagnostics/relevant_lines/switch_default.c @@ -0,0 +1,20 @@ +enum E { + A, B, C +}; + +int f(enum E input) { + int *x = 0; + switch (input) { + case A: + return 1; + case B: + return 0; + default: + return *x; + } +} + +// RUN: rm -rf %t.output +// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output %s +// RUN: cat %t.output/* | FileCheck %s --match-full-lines +// CHECK: var relevant_lines = {"1": {"5": 1, "6": 1, "7": 1, "12": 1, "13": 1}}; diff --git a/test/Analysis/html_diagnostics/relevant_lines/unused_header.c b/test/Analysis/html_diagnostics/relevant_lines/unused_header.c new file mode 100644 index 000000000000..4b77c651eddd --- /dev/null +++ b/test/Analysis/html_diagnostics/relevant_lines/unused_header.c @@ -0,0 +1,19 @@ +#include "header.h" + +int f(int coin) { + if (coin) { + int *x = 0; + return *x; + } else { + return 0; + } +} + +int v(int coin) { + return coin; +} + +// RUN: rm -rf %t.output +// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output %s +// RUN: cat %t.output/* | FileCheck %s --match-full-lines +// CHECK: var relevant_lines = {"1": {"3": 1, "4": 1, "5": 1, "6": 1}}; diff --git a/test/Analysis/implicit-ctor-undef-value.cpp b/test/Analysis/implicit-ctor-undef-value.cpp new file mode 100644 index 000000000000..87824c0533a0 --- /dev/null +++ b/test/Analysis/implicit-ctor-undef-value.cpp @@ -0,0 +1,75 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=text -verify %s + +namespace implicit_constructor { +struct S { +public: + S() {} + S(const S &) {} +}; + +// Warning is in a weird position because the body of the constructor is +// missing. Specify which field is being assigned. +class C { // expected-warning{{Value assigned to field 'y' in implicit constructor is garbage or undefined}} + // expected-note@-1{{Value assigned to field 'y' in implicit constructor is garbage or undefined}} + int x, y; + S s; + +public: + C(): x(0) {} +}; + +void test() { + C c1; + C c2(c1); // expected-note{{Calling implicit copy constructor for 'C'}} +} +} // end namespace implicit_constructor + + +namespace explicit_constructor { +class C { + int x, y; + +public: + C(): x(0) {} + // It is not necessary to specify which field is being assigned to. + C(const C &c): + x(c.x), + y(c.y) // expected-warning{{Assigned value is garbage or undefined}} + // expected-note@-1{{Assigned value is garbage or undefined}} + {} +}; + +void test() { + C c1; + C c2(c1); // expected-note{{Calling copy constructor for 'C'}} +} +} // end namespace explicit_constructor + + +namespace base_class_constructor { +struct S { +public: + S() {} + S(const S &) {} +}; + +class C { // expected-warning{{Value assigned to field 'y' in implicit constructor is garbage or undefined}} + // expected-note@-1{{Value assigned to field 'y' in implicit constructor is garbage or undefined}} + int x, y; + S s; + +public: + C(): x(0) {} +}; + +class D: public C { +public: + D(): C() {} +}; + +void test() { + D d1; + D d2(d1); // expected-note {{Calling implicit copy constructor for 'D'}} + // expected-note@-1{{Calling implicit copy constructor for 'C'}} +} +} // end namespace base_class_constructor diff --git a/test/Analysis/index-type.c b/test/Analysis/index-type.c index b86913b996f6..123dcd65bd7c 100644 --- a/test/Analysis/index-type.c +++ b/test/Analysis/index-type.c @@ -1,5 +1,5 @@ -// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,alpha.security.ArrayBoundV2 -verify %s -// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -analyzer-checker=core,alpha.security.ArrayBoundV2 -DM32 -verify %s +// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,alpha.security.ArrayBoundV2 -Wno-implicit-function-declaration -verify %s +// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -analyzer-checker=core,alpha.security.ArrayBoundV2 -Wno-implicit-function-declaration -DM32 -verify %s // expected-no-diagnostics #define UINT_MAX (~0u) @@ -36,4 +36,23 @@ void testIndexTooBig64() { *ptr = 42; // no-warning } +#define SIZE 4294967296 + +static unsigned size; +static void * addr; +static unsigned buf[SIZE]; + +void testOutOfBounds() { + // Not out of bounds. + buf[SIZE-1] = 1; // no-warning +} + +void testOutOfBoundsCopy1() { + memcpy(buf, addr, size); // no-warning +} + +void testOutOfBoundsCopy2() { + memcpy(addr, buf, size); // no-warning +} + #endif diff --git a/test/Analysis/initialization.c b/test/Analysis/initialization.c new file mode 100644 index 000000000000..c1d6361f1245 --- /dev/null +++ b/test/Analysis/initialization.c @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-checker=core.builtin,debug.ExprInspection -verify %s + +void clang_analyzer_eval(int); + +void initbug() { + const union { float a; } u = {}; + (void)u.a; // no-crash +} + +int const parr[2] = {1}; +void constarr() { + int i = 2; + clang_analyzer_eval(parr[i]); // expected-warning{{UNDEFINED}} + i = 1; + clang_analyzer_eval(parr[i] == 0); // expected-warning{{TRUE}} + i = -1; + clang_analyzer_eval(parr[i]); // expected-warning{{UNDEFINED}} +} + +struct SM { + int a; + int b; +}; +const struct SM sm = {.a = 1}; +void multinit() { + clang_analyzer_eval(sm.a == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(sm.b == 0); // expected-warning{{TRUE}} +} diff --git a/test/Analysis/initialization.cpp b/test/Analysis/initialization.cpp new file mode 100644 index 000000000000..db765930b6e5 --- /dev/null +++ b/test/Analysis/initialization.cpp @@ -0,0 +1,20 @@ +// RUN: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-checker=core.builtin,debug.ExprInspection -verify %s + +void clang_analyzer_eval(int); + +struct S { + int a = 3; +}; +S const sarr[2] = {}; +void definit() { + int i = 1; + // FIXME: Should recognize that it is 3. + clang_analyzer_eval(sarr[i].a); // expected-warning{{UNKNOWN}} +} + +int const arr[2][2] = {}; +void arr2init() { + int i = 1; + // FIXME: Should recognize that it is 0. + clang_analyzer_eval(arr[i][0]); // expected-warning{{UNKNOWN}} +} diff --git a/test/Analysis/initializer.cpp b/test/Analysis/initializer.cpp index 55f0a8950287..0cb68c4a9780 100644 --- a/test/Analysis/initializer.cpp +++ b/test/Analysis/initializer.cpp @@ -1,5 +1,7 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDeleteLeaks,debug.ExprInspection -analyzer-config c++-inlining=constructors -std=c++11 -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDeleteLeaks,debug.ExprInspection -analyzer-config c++-inlining=constructors -std=c++17 -DCPLUSPLUS17 -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDeleteLeaks,debug.ExprInspection -analyzer-config c++-inlining=constructors -std=c++11 -DTEST_INLINABLE_ALLOCATORS -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDeleteLeaks,debug.ExprInspection -analyzer-config c++-inlining=constructors -std=c++17 -DCPLUSPLUS17 -DTEST_INLINABLE_ALLOCATORS -verify %s void clang_analyzer_eval(bool); @@ -176,29 +178,6 @@ namespace ReferenceInitialization { const MyStruct &myStruct(OtherStruct(5)); myStruct.method(); // no-warning } - - struct HasMyStruct { - const MyStruct &ms; // expected-note {{reference member declared here}} - const MyStruct &msWithCleanups; // expected-note {{reference member declared here}} - - // clang's Sema issues a warning when binding a reference member to a - // temporary value. - HasMyStruct() : ms(5), msWithCleanups(OtherStruct(5)) { - // expected-warning@-1 {{binding reference member 'ms' to a temporary value}} - // expected-warning@-2 {{binding reference member 'msWithCleanups' to a temporary value}} - - // At this point the members are not garbage so we should not expect an - // analyzer warning here even though binding a reference member - // to a member is a terrible idea. - ms.method(); // no-warning - msWithCleanups.method(); // no-warning - } - }; - - void referenceInitializeField() { - HasMyStruct hms; - } - }; namespace PR31592 { diff --git a/test/Analysis/initializers-cfg-output.cpp b/test/Analysis/initializers-cfg-output.cpp index ccf4db519d79..8d1039ddf34e 100644 --- a/test/Analysis/initializers-cfg-output.cpp +++ b/test/Analysis/initializers-cfg-output.cpp @@ -1,4 +1,14 @@ -// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=debug.DumpCFG %s 2>&1 | FileCheck %s +// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=false %s 2>&1 | FileCheck -check-prefixes=CHECK,WARNINGS %s +// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=true %s 2>&1 | FileCheck -check-prefixes=CHECK,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. class A { public: @@ -53,20 +63,25 @@ class TestDelegating { // CHECK: [B2 (ENTRY)] // CHECK: Succs (1): B1 // CHECK: [B1] -// CHECK: 1: (CXXConstructExpr, class A) +// WARNINGS: 1: (CXXConstructExpr, class A) +// ANALYZER: 1: (CXXConstructExpr, A() (Base initializer), class A) // CHECK: 2: A([B1.1]) (Base initializer) -// CHECK: 3: (CXXConstructExpr, class C) +// WARNINGS: 3: (CXXConstructExpr, class C) +// ANALYZER: 3: (CXXConstructExpr, C() (Base initializer), class C) // CHECK: 4: C([B1.3]) (Base initializer) -// CHECK: 5: (CXXConstructExpr, class B) +// WARNINGS: 5: (CXXConstructExpr, class B) +// ANALYZER: 5: (CXXConstructExpr, B() (Base initializer), class B) // CHECK: 6: B([B1.5]) (Base initializer) -// CHECK: 7: (CXXConstructExpr, class A) +// WARNINGS: 7: (CXXConstructExpr, class A) +// ANALYZER: 7: (CXXConstructExpr, A() (Base initializer), class A) // CHECK: 8: A([B1.7]) (Base initializer) // CHECK: 9: /*implicit*/(int)0 // CHECK: 10: i([B1.9]) (Member initializer) // CHECK: 11: this // CHECK: 12: [B1.11]->i // CHECK: 13: r([B1.12]) (Member initializer) -// CHECK: 14: (CXXConstructExpr, class A) +// WARNINGS: 14: (CXXConstructExpr, class A) +// ANALYZER: 14: (CXXConstructExpr, [B1.15], class A) // CHECK: 15: A a; // CHECK: Preds (1): B2 // CHECK: Succs (1): B0 @@ -107,7 +122,8 @@ class TestDelegating { // CHECK: [B1] // CHECK: 1: 2 // CHECK: 2: 3 -// CHECK: 3: [B1.1], [B1.2] (CXXConstructExpr, class TestDelegating) +// WARNINGS: 3: [B1.1], [B1.2] (CXXConstructExpr, class TestDelegating) +// ANALYZER: 3: [B1.1], [B1.2] (CXXConstructExpr, TestDelegating([B1.1], [B1.2]) (Delegating initializer), class TestDelegating) // CHECK: 4: TestDelegating([B1.3]) (Delegating initializer) // CHECK: Preds (1): B2 // CHECK: Succs (1): B0 diff --git a/test/Analysis/inline-plist.c b/test/Analysis/inline-plist.c index 441bb48b1055..457fb266420f 100644 --- a/test/Analysis/inline-plist.c +++ b/test/Analysis/inline-plist.c @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 %s -analyzer-checker=core.NullDereference,core.DivideZero -fblocks -analyzer-output=text -analyzer-config suppress-null-return-paths=false -verify %s -// RUN: %clang_analyze_cc1 %s -analyzer-checker=core.NullDereference,core.DivideZero -fblocks -analyzer-output=plist -analyzer-config suppress-null-return-paths=false -analyzer-config path-diagnostics-alternate=false -o %t +// RUN: %clang_analyze_cc1 %s -analyzer-checker=core.NullDereference,core.DivideZero -fblocks -analyzer-output=plist -analyzer-config suppress-null-return-paths=false -o %t // RUN: FileCheck -input-file %t %s // <rdar://problem/10967815> @@ -210,40 +210,6 @@ void test_block_arg() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>18</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>18</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>18</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>18</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -306,40 +272,6 @@ void test_block_arg() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>27</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>27</integer> -// CHECK-NEXT: <key>col</key><integer>9</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>27</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>27</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -660,40 +592,6 @@ void test_block_arg() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>47</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>47</integer> -// CHECK-NEXT: <key>col</key><integer>16</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>47</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>47</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1419,6 +1317,40 @@ void test_block_arg() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>70</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>70</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>70</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>70</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>70</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1671,6 +1603,40 @@ void test_block_arg() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>78</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>78</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>78</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>78</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>78</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1923,6 +1889,40 @@ void test_block_arg() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>86</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>86</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>86</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>86</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>86</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> diff --git a/test/Analysis/inline-unique-reports.c b/test/Analysis/inline-unique-reports.c index f827f88deb1d..0044d14e5224 100644 --- a/test/Analysis/inline-unique-reports.c +++ b/test/Analysis/inline-unique-reports.c @@ -1,4 +1,4 @@ -// RUN: %clang_analyze_cc1 %s -analyzer-checker=core.NullDereference -analyzer-output=plist -analyzer-config path-diagnostics-alternate=false -o %t > /dev/null 2>&1 +// RUN: %clang_analyze_cc1 %s -analyzer-checker=core.NullDereference -analyzer-output=plist -o %t > /dev/null 2>&1 // RUN: FileCheck -input-file %t %s static inline bug(int *p) { @@ -85,40 +85,6 @@ void test_bug_2() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>15</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>15</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>15</integer> -// CHECK-NEXT: <key>col</key><integer>7</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>15</integer> -// CHECK-NEXT: <key>col</key><integer>7</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> diff --git a/test/Analysis/inline.cpp b/test/Analysis/inline.cpp index 76eee5beffac..c362fc93090b 100644 --- a/test/Analysis/inline.cpp +++ b/test/Analysis/inline.cpp @@ -315,17 +315,13 @@ namespace OperatorNew { int value; IntWrapper(int input) : value(input) { - // We don't want this constructor to be inlined unless we can actually - // use the proper region for operator new. - // See PR12014 and <rdar://problem/12180598>. - clang_analyzer_checkInlined(false); // no-warning + clang_analyzer_checkInlined(true); // expected-warning{{TRUE}} } }; void test() { IntWrapper *obj = new IntWrapper(42); - // should be TRUE - clang_analyzer_eval(obj->value == 42); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(obj->value == 42); // expected-warning{{TRUE}} delete obj; } @@ -335,8 +331,9 @@ namespace OperatorNew { clang_analyzer_eval(alias == obj); // expected-warning{{TRUE}} - // should be TRUE - clang_analyzer_eval(obj->value == 42); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(obj->value == 42); // expected-warning{{TRUE}} + // Because malloc() was never free()d: + // expected-warning@-2{{Potential leak of memory pointed to by 'alias'}} } } diff --git a/test/Analysis/inlining/containers.cpp b/test/Analysis/inlining/containers.cpp index 16e006b345f2..ffa3b511344a 100644 --- a/test/Analysis/inlining/containers.cpp +++ b/test/Analysis/inlining/containers.cpp @@ -1,5 +1,7 @@ // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config c++-inlining=destructors -analyzer-config c++-container-inlining=false -verify %s // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config c++-inlining=destructors -analyzer-config c++-container-inlining=true -DINLINE=1 -verify %s +// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config c++-inlining=destructors -analyzer-config c++-container-inlining=false -DTEST_INLINABLE_ALLOCATORS -verify %s +// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config c++-inlining=destructors -analyzer-config c++-container-inlining=true -DTEST_INLINABLE_ALLOCATORS -DINLINE=1 -verify %s #ifndef HEADER diff --git a/test/Analysis/inlining/eager-reclamation-path-notes.c b/test/Analysis/inlining/eager-reclamation-path-notes.c index 7c0f0ec8f52e..a31ab9ed0ad9 100644 --- a/test/Analysis/inlining/eager-reclamation-path-notes.c +++ b/test/Analysis/inlining/eager-reclamation-path-notes.c @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=text -analyzer-config graph-trim-interval=5 -verify %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file -analyzer-config graph-trim-interval=5 -analyzer-config path-diagnostics-alternate=false %s -o %t.plist +// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file -analyzer-config graph-trim-interval=5 %s -o %t.plist // RUN: FileCheck --input-file=%t.plist %s void use(int *ptr, int val) { @@ -99,46 +99,12 @@ void testChainedCalls() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>21</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>21</integer> -// CHECK-NEXT: <key>col</key><integer>16</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>21</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>21</integer> -// CHECK-NEXT: <key>col</key><integer>16</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>21</integer> -// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>21</integer> -// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -398,40 +364,6 @@ void testChainedCalls() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>13</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>41</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -538,74 +470,6 @@ void testChainedCalls() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>33</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>33</integer> -// CHECK-NEXT: <key>col</key><integer>6</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>33</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>33</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>33</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>33</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>33</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>33</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> diff --git a/test/Analysis/inlining/eager-reclamation-path-notes.cpp b/test/Analysis/inlining/eager-reclamation-path-notes.cpp index f77a19f9965f..9a9b01c3bdd4 100644 --- a/test/Analysis/inlining/eager-reclamation-path-notes.cpp +++ b/test/Analysis/inlining/eager-reclamation-path-notes.cpp @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=text -analyzer-config graph-trim-interval=5 -analyzer-config suppress-null-return-paths=false -verify %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file -analyzer-config graph-trim-interval=5 -analyzer-config suppress-null-return-paths=false -analyzer-config path-diagnostics-alternate=false %s -o %t.plist +// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file -analyzer-config graph-trim-interval=5 -analyzer-config suppress-null-return-paths=false %s -o %t.plist // RUN: FileCheck --input-file=%t.plist %s typedef struct { diff --git a/test/Analysis/inlining/false-positive-suppression.c b/test/Analysis/inlining/false-positive-suppression.c index 4931695ef127..4d472e0861e0 100644 --- a/test/Analysis/inlining/false-positive-suppression.c +++ b/test/Analysis/inlining/false-positive-suppression.c @@ -111,14 +111,12 @@ void testInlineCheckInNestedMacro(int *p) { *p = 1; // no-warning } -// If there is a check in a macro that is not function-like, don't treat -// it like a function so don't suppress. #define NON_FUNCTION_MACRO_WITH_CHECK ( ((p) != 0) ? *p : 17) void testNonFunctionMacro(int *p) { int i = NON_FUNCTION_MACRO_WITH_CHECK ; (void)i; - *p = 1; // expected-warning {{Dereference of null pointer (loaded from variable 'p')}} + *p = 1; // no-warning } @@ -163,6 +161,7 @@ void testNestedDisjunctiveMacro2(int *p, int *q) { } + // Here the check is entirely in non-macro code even though the code itself // is a macro argument. #define MACRO_DO_IT(a) (a) @@ -171,6 +170,15 @@ void testErrorInArgument(int *p) { (void)i; } +// No warning should be emitted if dereference is performed from a different +// macro. +#define MACRO_CHECK(a) if (a) {} +#define MACRO_DEREF(a) (*a) +int testDifferentMacro(int *p) { + MACRO_CHECK(p); + return MACRO_DEREF(p); // no-warning +} + // -------------------------- // "Suppression suppression" // -------------------------- diff --git a/test/Analysis/inlining/inline-defensive-checks.c b/test/Analysis/inlining/inline-defensive-checks.c index ca61395fc0d4..d290cf25f42f 100644 --- a/test/Analysis/inlining/inline-defensive-checks.c +++ b/test/Analysis/inlining/inline-defensive-checks.c @@ -159,8 +159,7 @@ void idcTrackZeroValueThroughUnaryPointerOperatorsWithOffset1(struct S *s) { void idcTrackZeroValueThroughUnaryPointerOperatorsWithOffset2(struct S *s) { idc(s); int *x = &(s->f2) - 1; - // FIXME: Should not warn. - *x = 7; // expected-warning{{Dereference of null pointer}} + *x = 7; // no-warning } void idcTrackZeroValueThroughUnaryPointerOperatorsWithAssignment(struct S *s) { diff --git a/test/Analysis/inlining/inline-defensive-checks.cpp b/test/Analysis/inlining/inline-defensive-checks.cpp index eaae8d2ae28f..6fb0e1cd70b0 100644 --- a/test/Analysis/inlining/inline-defensive-checks.cpp +++ b/test/Analysis/inlining/inline-defensive-checks.cpp @@ -84,3 +84,20 @@ void testRefToField(Bar *b) { int &x = b->x; // no-warning x = 5; } + +namespace get_deref_expr_with_cleanups { +struct S { +~S(); +}; +S *conjure(); +// The argument won't be used, but it'll cause cleanups +// to appear around the call site. +S *get_conjured(S _) { + S *s = conjure(); + if (s) {} + return s; +} +void test_conjured() { + S &s = *get_conjured(S()); // no-warning +} +} // namespace get_deref_expr_with_cleanups diff --git a/test/Analysis/inlining/path-notes.c b/test/Analysis/inlining/path-notes.c index 95adee30a9af..15441d4a3ccd 100644 --- a/test/Analysis/inlining/path-notes.c +++ b/test/Analysis/inlining/path-notes.c @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=text -analyzer-config suppress-null-return-paths=false -verify %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file -analyzer-config suppress-null-return-paths=false -analyzer-config path-diagnostics-alternate=false %s -o %t.plist +// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file -analyzer-config suppress-null-return-paths=false %s -o %t.plist // RUN: FileCheck --input-file=%t.plist %s void zero(int **p) { @@ -140,6 +140,22 @@ void test4(int **p) { // expected-note@-1 {{Dereference of null pointer}} } +void boringCallee() { +} + +void interestingCallee(int *x) { + *x = 0; // expected-note{{The value 0 is assigned to 'x'}} + boringCallee(); // no-note +} + +int testBoringCalleeOfInterestingCallee() { + int x; + interestingCallee(&x); // expected-note{{Calling 'interestingCallee'}} + // expected-note@-1{{Returning from 'interestingCallee'}} + return 1 / x; // expected-warning{{Division by zero}} + // expected-note@-1{{Division by zero}} +} + // CHECK: <key>diagnostics</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> @@ -302,6 +318,40 @@ void test4(int **p) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>14</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>14</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>14</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>14</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>14</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1030,40 +1080,6 @@ void test4(int **p) { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>65</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>65</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>65</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>65</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1270,12 +1286,12 @@ void test4(int **p) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>65</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>65</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1577,40 +1593,6 @@ void test4(int **p) { // CHECK-NEXT: <string>Returning from 'getZero'</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>72</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>72</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>72</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>72</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1976,6 +1958,40 @@ void test4(int **p) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>83</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>83</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>83</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>83</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>83</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -2354,6 +2370,40 @@ void test4(int **p) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>92</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>92</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>92</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>92</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -2677,6 +2727,40 @@ void test4(int **p) { // CHECK-NEXT: <string>Passing null pointer value via 1st parameter 'p'</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>103</integer> +// CHECK-NEXT: <key>col</key><integer>14</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>103</integer> +// CHECK-NEXT: <key>col</key><integer>20</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>103</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>103</integer> +// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -3139,6 +3223,40 @@ void test4(int **p) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>132</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>132</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>132</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>132</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>132</integer> // CHECK-NEXT: <key>col</key><integer>24</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -3377,4 +3495,290 @@ void test4(int **p) { // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>path</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>152</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>152</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>153</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>153</integer> +// CHECK-NEXT: <key>col</key><integer>19</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>153</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>153</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>153</integer> +// CHECK-NEXT: <key>col</key><integer>23</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Calling 'interestingCallee'</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Calling 'interestingCallee'</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>146</integer> +// CHECK-NEXT: <key>col</key><integer>1</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>depth</key><integer>1</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Entered call from 'testBoringCalleeOfInterestingCallee'</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Entered call from 'testBoringCalleeOfInterestingCallee'</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>146</integer> +// CHECK-NEXT: <key>col</key><integer>1</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>146</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>147</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>147</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>147</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>147</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>147</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>1</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>The value 0 is assigned to 'x'</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>The value 0 is assigned to 'x'</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>147</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>147</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>148</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>148</integer> +// CHECK-NEXT: <key>col</key><integer>14</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>153</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>153</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>153</integer> +// CHECK-NEXT: <key>col</key><integer>23</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Returning from 'interestingCallee'</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Returning from 'interestingCallee'</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>153</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>153</integer> +// CHECK-NEXT: <key>col</key><integer>19</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>155</integer> +// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>155</integer> +// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>155</integer> +// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>155</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>155</integer> +// CHECK-NEXT: <key>col</key><integer>14</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Division by zero</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Division by zero</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>description</key><string>Division by zero</string> +// CHECK-NEXT: <key>category</key><string>Logic error</string> +// CHECK-NEXT: <key>type</key><string>Division by zero</string> +// CHECK-NEXT: <key>check_name</key><string>core.DivideZero</string> +// CHECK-NEXT: <!-- This hash is experimental and going to change! --> +// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>fcd480c0f73d071bac6f908387893e26</string> +// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> +// CHECK-NEXT: <key>issue_context</key><string>testBoringCalleeOfInterestingCallee</string> +// CHECK-NEXT: <key>issue_hash_function_offset</key><string>4</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>155</integer> +// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </dict> // CHECK-NEXT: </array> diff --git a/test/Analysis/inlining/path-notes.cpp b/test/Analysis/inlining/path-notes.cpp index 4d0b899e7cf7..e475399f605f 100644 --- a/test/Analysis/inlining/path-notes.cpp +++ b/test/Analysis/inlining/path-notes.cpp @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=text -analyzer-config c++-inlining=destructors -std=c++11 -verify -Wno-tautological-undefined-compare %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file -analyzer-config c++-inlining=destructors -std=c++11 -analyzer-config path-diagnostics-alternate=false %s -o %t.plist -Wno-tautological-undefined-compare +// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file -analyzer-config c++-inlining=destructors -std=c++11 %s -o %t.plist -Wno-tautological-undefined-compare // RUN: FileCheck --input-file=%t.plist %s class Foo { @@ -324,40 +324,6 @@ namespace PR17746 { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>31</integer> -// CHECK-NEXT: <key>col</key><integer>7</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>31</integer> -// CHECK-NEXT: <key>col</key><integer>7</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>31</integer> -// CHECK-NEXT: <key>col</key><integer>7</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>31</integer> -// CHECK-NEXT: <key>col</key><integer>7</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>32</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -560,40 +526,6 @@ namespace PR17746 { // CHECK-NEXT: <string>Passing null pointer value via 1st parameter 'p'</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>24</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>24</integer> -// CHECK-NEXT: <key>col</key><integer>19</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>24</integer> -// CHECK-NEXT: <key>col</key><integer>9</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>24</integer> -// CHECK-NEXT: <key>col</key><integer>9</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -671,40 +603,6 @@ namespace PR17746 { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>13</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>13</integer> -// CHECK-NEXT: <key>col</key><integer>7</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>13</integer> -// CHECK-NEXT: <key>col</key><integer>9</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>13</integer> -// CHECK-NEXT: <key>col</key><integer>9</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -901,40 +799,6 @@ namespace PR17746 { // CHECK-NEXT: <key>start</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>38</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>38</integer> -// CHECK-NEXT: <key>col</key><integer>7</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>44</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>44</integer> -// CHECK-NEXT: <key>col</key><integer>13</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>44</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -962,40 +826,6 @@ namespace PR17746 { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>46</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>46</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>46</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>46</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1235,6 +1065,40 @@ namespace PR17746 { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>112</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>112</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>112</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>112</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>112</integer> // CHECK-NEXT: <key>col</key><integer>13</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1277,6 +1141,40 @@ namespace PR17746 { // CHECK-NEXT: <string>Calling implicit default constructor for 'Wrapper'</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1485,6 +1383,40 @@ namespace PR17746 { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>120</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>120</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>120</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>120</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>col</key><integer>13</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1527,6 +1459,40 @@ namespace PR17746 { // CHECK-NEXT: <string>Calling implicit copy constructor for 'Wrapper'</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1735,12 +1701,12 @@ namespace PR17746 { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>128</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>128</integer> -// CHECK-NEXT: <key>col</key><integer>25</integer> +// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1756,12 +1722,12 @@ namespace PR17746 { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>128</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>128</integer> -// CHECK-NEXT: <key>col</key><integer>25</integer> +// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1811,6 +1777,40 @@ namespace PR17746 { // CHECK-NEXT: <string>Calling defaulted move constructor for 'MovableWrapper'</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>102</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>102</integer> +// CHECK-NEXT: <key>col</key><integer>18</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>102</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>102</integer> +// CHECK-NEXT: <key>col</key><integer>18</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1989,40 +1989,6 @@ namespace PR17746 { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>133</integer> -// CHECK-NEXT: <key>col</key><integer>13</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>133</integer> -// CHECK-NEXT: <key>col</key><integer>13</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>133</integer> -// CHECK-NEXT: <key>col</key><integer>13</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>133</integer> -// CHECK-NEXT: <key>col</key><integer>13</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>134</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -2129,6 +2095,40 @@ namespace PR17746 { // CHECK-NEXT: <string>Calling implicit copy assignment operator for 'Wrapper'</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -2309,40 +2309,6 @@ namespace PR17746 { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>142</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>142</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>142</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>142</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>143</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -2407,12 +2373,12 @@ namespace PR17746 { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>145</integer> -// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>145</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -2663,40 +2629,6 @@ namespace PR17746 { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>150</integer> -// CHECK-NEXT: <key>col</key><integer>13</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>150</integer> -// CHECK-NEXT: <key>col</key><integer>13</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>150</integer> -// CHECK-NEXT: <key>col</key><integer>13</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>150</integer> -// CHECK-NEXT: <key>col</key><integer>13</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>151</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -2788,6 +2720,40 @@ namespace PR17746 { // CHECK-NEXT: <string>Calling implicit destructor for 'Wrapper'</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>93</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -3770,40 +3736,6 @@ namespace PR17746 { // CHECK-NEXT: <string>Passing null pointer value via 1st parameter 'p'</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>205</integer> -// CHECK-NEXT: <key>col</key><integer>23</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>205</integer> -// CHECK-NEXT: <key>col</key><integer>23</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>205</integer> -// CHECK-NEXT: <key>col</key><integer>21</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>205</integer> -// CHECK-NEXT: <key>col</key><integer>21</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -3950,6 +3882,40 @@ namespace PR17746 { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>197</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>197</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>197</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>197</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>197</integer> // CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -4269,6 +4235,40 @@ namespace PR17746 { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>221</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>221</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>221</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>221</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>221</integer> // CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -4561,6 +4561,40 @@ namespace PR17746 { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>243</integer> +// CHECK-NEXT: <key>col</key><integer>2</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>243</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>243</integer> +// CHECK-NEXT: <key>col</key><integer>2</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>243</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>243</integer> // CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -4959,40 +4993,6 @@ namespace PR17746 { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>269</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>269</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>269</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>269</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>269</integer> // CHECK-NEXT: <key>col</key><integer>13</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> diff --git a/test/Analysis/inlining/path-notes.m b/test/Analysis/inlining/path-notes.m index 5bfd41d95a75..a372dab6bb4d 100644 --- a/test/Analysis/inlining/path-notes.m +++ b/test/Analysis/inlining/path-notes.m @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.NilArg,osx.cocoa.RetainCount -analyzer-output=text -analyzer-config suppress-null-return-paths=false -fblocks -verify %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.NilArg,osx.cocoa.RetainCount -analyzer-output=plist-multi-file -analyzer-config suppress-null-return-paths=false -analyzer-config path-diagnostics-alternate=false -fblocks %s -o %t.plist +// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.NilArg,osx.cocoa.RetainCount -analyzer-output=plist-multi-file -analyzer-config suppress-null-return-paths=false -fblocks %s -o %t.plist // RUN: FileCheck --input-file=%t.plist %s typedef struct dispatch_queue_s *dispatch_queue_t; @@ -362,40 +362,6 @@ void testNullDereferenceInDispatch() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>73</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>73</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>73</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>73</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -425,40 +391,6 @@ void testNullDereferenceInDispatch() { // CHECK-NEXT: <string>'p' not called because the receiver is nil</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>73</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>73</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>73</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>73</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -525,12 +457,12 @@ void testNullDereferenceInDispatch() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>79</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>79</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1513,6 +1445,35 @@ void testNullDereferenceInDispatch() { // CHECK-NEXT: <string>'getPtr' not called because the receiver is nil</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>152</integer> +// CHECK-NEXT: <key>col</key><integer>25</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>152</integer> +// CHECK-NEXT: <key>col</key><integer>25</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>152</integer> +// CHECK-NEXT: <key>col</key><integer>35</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Passing null pointer value via 1st parameter 'x'</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Passing null pointer value via 1st parameter 'x'</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <array> @@ -1521,12 +1482,12 @@ void testNullDereferenceInDispatch() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>152</integer> -// CHECK-NEXT: <key>col</key><integer>26</integer> +// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>152</integer> -// CHECK-NEXT: <key>col</key><integer>26</integer> +// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1534,12 +1495,12 @@ void testNullDereferenceInDispatch() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>152</integer> -// CHECK-NEXT: <key>col</key><integer>25</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>152</integer> -// CHECK-NEXT: <key>col</key><integer>25</integer> +// CHECK-NEXT: <key>col</key><integer>23</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1551,35 +1512,6 @@ void testNullDereferenceInDispatch() { // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>152</integer> -// CHECK-NEXT: <key>col</key><integer>25</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <key>ranges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>152</integer> -// CHECK-NEXT: <key>col</key><integer>25</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>152</integer> -// CHECK-NEXT: <key>col</key><integer>35</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>depth</key><integer>0</integer> -// CHECK-NEXT: <key>extended_message</key> -// CHECK-NEXT: <string>Passing null pointer value via 1st parameter 'x'</string> -// CHECK-NEXT: <key>message</key> -// CHECK-NEXT: <string>Passing null pointer value via 1st parameter 'x'</string> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>event</string> -// CHECK-NEXT: <key>location</key> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>152</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1936,40 +1868,6 @@ void testNullDereferenceInDispatch() { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>168</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>168</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>168</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>168</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>170</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -2047,40 +1945,6 @@ void testNullDereferenceInDispatch() { // CHECK-NEXT: <string>Method returns an instance of NSObject with a +1 retain count</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -2130,81 +1994,6 @@ void testNullDereferenceInDispatch() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>event</string> -// CHECK-NEXT: <key>location</key> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <key>ranges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>60</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>47</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>depth</key><integer>0</integer> -// CHECK-NEXT: <key>extended_message</key> -// CHECK-NEXT: <string>Object autoreleased</string> -// CHECK-NEXT: <key>message</key> -// CHECK-NEXT: <string>Object autoreleased</string> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> // CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -2217,13 +2006,13 @@ void testNullDereferenceInDispatch() { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>175</integer> +// CHECK-NEXT: <key>line</key><integer>170</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>175</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>line</key><integer>170</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -2238,13 +2027,13 @@ void testNullDereferenceInDispatch() { // CHECK-NEXT: <key>start</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>175</integer> +// CHECK-NEXT: <key>line</key><integer>170</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>175</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>line</key><integer>170</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> diff --git a/test/Analysis/inlining/temp-dtors-path-notes.cpp b/test/Analysis/inlining/temp-dtors-path-notes.cpp new file mode 100644 index 000000000000..40b26b5c91ae --- /dev/null +++ b/test/Analysis/inlining/temp-dtors-path-notes.cpp @@ -0,0 +1,59 @@ +// RUN: %clang_analyze_cc1 -analyze -analyzer-checker core -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -analyzer-output=text -verify %s + +namespace test_simple_temporary { +class C { + int x; + +public: + C(int x): x(x) {} // expected-note{{The value 0 is assigned to field 'x'}} + ~C() { x = 1 / x; } // expected-warning{{Division by zero}} + // expected-note@-1{{Division by zero}} +}; + +void test() { + C(0); // expected-note {{Passing the value 0 via 1st parameter 'x'}} + // expected-note@-1{{Calling constructor for 'C'}} + // expected-note@-2{{Returning from constructor for 'C'}} + // expected-note@-3{{Calling '~C'}} +} +} // end namespace test_simple_temporary + +namespace test_lifetime_extended_temporary { +class C { + int x; + +public: + C(int x): x(x) {} // expected-note{{The value 0 is assigned to field 'x'}} + void nop() const {} + ~C() { x = 1 / x; } // expected-warning{{Division by zero}} + // expected-note@-1{{Division by zero}} +}; + +void test(int coin) { + // We'd divide by zero in the automatic destructor for variable 'c'. + const C &c = coin ? C(1) : C(0); // expected-note {{Assuming 'coin' is 0}} + // expected-note@-1{{'?' condition is false}} + // expected-note@-2{{Passing the value 0 via 1st parameter 'x'}} + // expected-note@-3{{Calling constructor for 'C'}} + // expected-note@-4{{Returning from constructor for 'C'}} + c.nop(); +} // expected-note{{Calling '~C'}} +} // end namespace test_lifetime_extended_temporary + +namespace test_bug_after_dtor { +int glob; + +class C { +public: + C() { glob += 1; } + ~C() { glob -= 2; } // expected-note{{The value 0 is assigned to 'glob'}} +}; + +void test() { + glob = 1; + C(); // expected-note {{Calling '~C'}} + // expected-note@-1{{Returning from '~C'}} + glob = 1 / glob; // expected-warning{{Division by zero}} + // expected-note@-1{{Division by zero}} +} +} // end namespace test_bug_after_dtor diff --git a/test/Analysis/inner-pointer.cpp b/test/Analysis/inner-pointer.cpp new file mode 100644 index 000000000000..db9bf43109b2 --- /dev/null +++ b/test/Analysis/inner-pointer.cpp @@ -0,0 +1,291 @@ +//RUN: %clang_analyze_cc1 -analyzer-checker=alpha.cplusplus.InnerPointer %s -analyzer-output=text -verify + +namespace std { + +typedef int size_type; + +template <typename CharT> +class basic_string { +public: + basic_string(); + basic_string(const CharT *s); + + ~basic_string(); + void clear(); + + basic_string &operator=(const basic_string &str); + basic_string &operator+=(const basic_string &str); + + const CharT *c_str() const; + const CharT *data() const; + CharT *data(); + + basic_string &append(size_type count, CharT ch); + basic_string &assign(size_type count, CharT ch); + basic_string &erase(size_type index, size_type count); + basic_string &insert(size_type index, size_type count, CharT ch); + basic_string &replace(size_type pos, size_type count, const basic_string &str); + void pop_back(); + void push_back(CharT ch); + void reserve(size_type new_cap); + void resize(size_type count); + void shrink_to_fit(); + void swap(basic_string &other); +}; + +typedef basic_string<char> string; +typedef basic_string<wchar_t> wstring; +typedef basic_string<char16_t> u16string; +typedef basic_string<char32_t> u32string; + +} // end namespace std + +void consume(const char *) {} +void consume(const wchar_t *) {} +void consume(const char16_t *) {} +void consume(const char32_t *) {} + +void deref_after_scope_char(bool cond) { + const char *c, *d; + { + std::string s; + c = s.c_str(); // expected-note {{Dangling inner pointer obtained here}} + d = s.data(); // expected-note {{Dangling inner pointer obtained here}} + } // expected-note {{Inner pointer invalidated by call to destructor}} + // expected-note@-1 {{Inner pointer invalidated by call to destructor}} + std::string s; + const char *c2 = s.c_str(); + if (cond) { + // expected-note@-1 {{Assuming 'cond' is not equal to 0}} + // expected-note@-2 {{Taking true branch}} + // expected-note@-3 {{Assuming 'cond' is 0}} + // expected-note@-4 {{Taking false branch}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} + } else { + consume(d); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} + } +} + +void deref_after_scope_char_data_non_const() { + char *c; + { + std::string s; + c = s.data(); // expected-note {{Dangling inner pointer obtained here}} + } // expected-note {{Inner pointer invalidated by call to destructor}} + std::string s; + char *c2 = s.data(); + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_scope_wchar_t(bool cond) { + const wchar_t *c, *d; + { + std::wstring s; + c = s.c_str(); // expected-note {{Dangling inner pointer obtained here}} + d = s.data(); // expected-note {{Dangling inner pointer obtained here}} + } // expected-note {{Inner pointer invalidated by call to destructor}} + // expected-note@-1 {{Inner pointer invalidated by call to destructor}} + std::wstring s; + const wchar_t *c2 = s.c_str(); + if (cond) { + // expected-note@-1 {{Assuming 'cond' is not equal to 0}} + // expected-note@-2 {{Taking true branch}} + // expected-note@-3 {{Assuming 'cond' is 0}} + // expected-note@-4 {{Taking false branch}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} + } else { + consume(d); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} + } +} + +void deref_after_scope_char16_t_cstr() { + const char16_t *c16; + { + std::u16string s16; + c16 = s16.c_str(); // expected-note {{Dangling inner pointer obtained here}} + } // expected-note {{Inner pointer invalidated by call to destructor}} + std::u16string s16; + const char16_t *c16_2 = s16.c_str(); + consume(c16); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_scope_char32_t_data() { + const char32_t *c32; + { + std::u32string s32; + c32 = s32.data(); // expected-note {{Dangling inner pointer obtained here}} + } // expected-note {{Inner pointer invalidated by call to destructor}} + std::u32string s32; + const char32_t *c32_2 = s32.data(); + consume(c32); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void multiple_symbols(bool cond) { + const char *c1, *d1; + { + std::string s1; + c1 = s1.c_str(); // expected-note {{Dangling inner pointer obtained here}} + d1 = s1.data(); // expected-note {{Dangling inner pointer obtained here}} + const char *local = s1.c_str(); + consume(local); // no-warning + } // expected-note {{Inner pointer invalidated by call to destructor}} + // expected-note@-1 {{Inner pointer invalidated by call to destructor}} + std::string s2; + const char *c2 = s2.c_str(); + if (cond) { + // expected-note@-1 {{Assuming 'cond' is not equal to 0}} + // expected-note@-2 {{Taking true branch}} + // expected-note@-3 {{Assuming 'cond' is 0}} + // expected-note@-4 {{Taking false branch}} + consume(c1); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} + } else { + consume(d1); // expected-warning {{Use of memory after it is freed}} + } // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_equals() { + const char *c; + std::string s = "hello"; + c = s.c_str(); // expected-note {{Dangling inner pointer obtained here}} + s = "world"; // expected-note {{Inner pointer invalidated by call to 'operator='}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_plus_equals() { + const char *c; + std::string s = "hello"; + c = s.data(); // expected-note {{Dangling inner pointer obtained here}} + s += " world"; // expected-note {{Inner pointer invalidated by call to 'operator+='}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_clear() { + const char *c; + std::string s; + c = s.c_str(); // expected-note {{Dangling inner pointer obtained here}} + s.clear(); // expected-note {{Inner pointer invalidated by call to 'clear'}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_append() { + const char *c; + std::string s = "hello"; + c = s.c_str(); // expected-note {{Dangling inner pointer obtained here}} + s.append(2, 'x'); // expected-note {{Inner pointer invalidated by call to 'append'}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_assign() { + const char *c; + std::string s; + c = s.data(); // expected-note {{Dangling inner pointer obtained here}} + s.assign(4, 'a'); // expected-note {{Inner pointer invalidated by call to 'assign'}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_erase() { + const char *c; + std::string s = "hello"; + c = s.c_str(); // expected-note {{Dangling inner pointer obtained here}} + s.erase(0, 2); // expected-note {{Inner pointer invalidated by call to 'erase'}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_insert() { + const char *c; + std::string s = "ello"; + c = s.c_str(); // expected-note {{Dangling inner pointer obtained here}} + s.insert(0, 1, 'h'); // expected-note {{Inner pointer invalidated by call to 'insert'}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_replace() { + const char *c; + std::string s = "hello world"; + c = s.c_str(); // expected-note {{Dangling inner pointer obtained here}} + s.replace(6, 5, "string"); // expected-note {{Inner pointer invalidated by call to 'replace'}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_pop_back() { + const char *c; + std::string s; + c = s.c_str(); // expected-note {{Dangling inner pointer obtained here}} + s.pop_back(); // expected-note {{Inner pointer invalidated by call to 'pop_back'}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_push_back() { + const char *c; + std::string s; + c = s.data(); // expected-note {{Dangling inner pointer obtained here}} + s.push_back('c'); // expected-note {{Inner pointer invalidated by call to 'push_back'}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_reserve() { + const char *c; + std::string s; + c = s.c_str(); // expected-note {{Dangling inner pointer obtained here}} + s.reserve(5); // expected-note {{Inner pointer invalidated by call to 'reserve'}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_resize() { + const char *c; + std::string s; + c = s.data(); // expected-note {{Dangling inner pointer obtained here}} + s.resize(5); // expected-note {{Inner pointer invalidated by call to 'resize'}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_shrink_to_fit() { + const char *c; + std::string s; + c = s.data(); // expected-note {{Dangling inner pointer obtained here}} + s.shrink_to_fit(); // expected-note {{Inner pointer invalidated by call to 'shrink_to_fit'}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_swap() { + const char *c; + std::string s1, s2; + c = s1.data(); // expected-note {{Dangling inner pointer obtained here}} + s1.swap(s2); // expected-note {{Inner pointer invalidated by call to 'swap'}} + consume(c); // expected-warning {{Use of memory after it is freed}} + // expected-note@-1 {{Use of memory after it is freed}} +} + +void deref_after_scope_ok(bool cond) { + const char *c, *d; + std::string s; + { + c = s.c_str(); + d = s.data(); + } + if (cond) + consume(c); // no-warning + else + consume(d); // no-warning +} diff --git a/test/Analysis/iterator-range.cpp b/test/Analysis/iterator-range.cpp index 79b45188ab5d..8a4ba29b0cd7 100644 --- a/test/Analysis/iterator-range.cpp +++ b/test/Analysis/iterator-range.cpp @@ -1,5 +1,5 @@ -// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorRange -analyzer-eagerly-assume -analyzer-config c++-container-inlining=false %s -verify -// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorRange -analyzer-eagerly-assume -analyzer-config c++-container-inlining=true -DINLINE=1 %s -verify +// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorRange -analyzer-eagerly-assume -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=false %s -verify +// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorRange -analyzer-eagerly-assume -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=true -DINLINE=1 %s -verify #include "Inputs/system-header-simulator-cxx.h" @@ -13,7 +13,110 @@ void simple_good_end(const std::vector<int> &v) { } } +void simple_good_end_negated(const std::vector<int> &v) { + auto i = v.end(); + if (!(i == v.end())) { + clang_analyzer_warnIfReached(); + *i; // no-warning + } +} + void simple_bad_end(const std::vector<int> &v) { auto i = v.end(); *i; // expected-warning{{Iterator accessed outside of its range}} } + +void simple_good_begin(const std::vector<int> &v) { + auto i = v.begin(); + if (i != v.begin()) { + clang_analyzer_warnIfReached(); + *--i; // no-warning + } +} + +void simple_good_begin_negated(const std::vector<int> &v) { + auto i = v.begin(); + if (!(i == v.begin())) { + clang_analyzer_warnIfReached(); + *--i; // no-warning + } +} + +void simple_bad_begin(const std::vector<int> &v) { + auto i = v.begin(); + *--i; // expected-warning{{Iterator accessed outside of its range}} +} + +void copy(const std::vector<int> &v) { + auto i1 = v.end(); + auto i2 = i1; + *i2; // expected-warning{{Iterator accessed outside of its range}} +} + +void decrease(const std::vector<int> &v) { + auto i = v.end(); + --i; + *i; // no-warning +} + +void copy_and_decrease1(const std::vector<int> &v) { + auto i1 = v.end(); + auto i2 = i1; + --i1; + *i1; // no-warning +} + +void copy_and_decrease2(const std::vector<int> &v) { + auto i1 = v.end(); + auto i2 = i1; + --i1; + *i2; // expected-warning{{Iterator accessed outside of its range}} +} + +void copy_and_increase1(const std::vector<int> &v) { + auto i1 = v.begin(); + auto i2 = i1; + ++i1; + if (i1 == v.end()) + *i2; // no-warning +} + +void copy_and_increase2(const std::vector<int> &v) { + auto i1 = v.begin(); + auto i2 = i1; + ++i1; + if (i2 == v.end()) + *i2; // expected-warning{{Iterator accessed outside of its range}} +} + +void copy_and_increase3(const std::vector<int> &v) { + auto i1 = v.begin(); + auto i2 = i1; + ++i1; + if (v.end() == i2) + *i2; // expected-warning{{Iterator accessed outside of its range}} +} + +void tricky(std::vector<int> &V, int e) { + const auto first = V.begin(); + const auto comp1 = (first != V.end()), comp2 = (first == V.end()); + if (comp1) + *first; +} + +void loop(std::vector<int> &V, int e) { + auto start = V.begin(); + while (true) { + auto item = std::find(start, V.end(), e); + if (item == V.end()) + break; + *item; // no-warning + start = ++item; // no-warning + } +} + +void bad_move(std::list<int> &L1, std::list<int> &L2) { + auto i0 = --L2.cend(); + L1 = std::move(L2); + *++i0; // expected-warning{{Iterator accessed outside of its range}} +} diff --git a/test/Analysis/lambda-notes.cpp b/test/Analysis/lambda-notes.cpp index 7abff35df124..d4318284df01 100644 --- a/test/Analysis/lambda-notes.cpp +++ b/test/Analysis/lambda-notes.cpp @@ -69,7 +69,7 @@ void diagnosticFromLambda() { // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>12</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> diff --git a/test/Analysis/lambdas.cpp b/test/Analysis/lambdas.cpp index 38a2e3a84fb1..320ba2aabc22 100644 --- a/test/Analysis/lambdas.cpp +++ b/test/Analysis/lambdas.cpp @@ -348,6 +348,23 @@ void testCapturedConstExprFloat() { lambda(); } + +static int b = 0; + +int f() { + b = 0; + auto &bm = b; + [&] { + bm++; + bm++; + }(); + if (bm != 2) { + int *y = 0; + return *y; // no-warning + } + return 0; +} + // CHECK: [B2 (ENTRY)] // CHECK: Succs (1): B1 // CHECK: [B1] diff --git a/test/Analysis/lifetime-cfg-output.cpp b/test/Analysis/lifetime-cfg-output.cpp index 1e6f56df6a47..dc2849db1b63 100644 --- a/test/Analysis/lifetime-cfg-output.cpp +++ b/test/Analysis/lifetime-cfg-output.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -analyze -analyzer-checker=debug.DumpCFG -analyzer-config cfg-lifetime=true -analyzer-config cfg-implicit-dtors=false %s > %t 2>&1 +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -analyze -analyzer-checker=debug.DumpCFG -analyzer-config cfg-lifetime=true,cfg-temporary-dtors=false,cfg-rich-constructors=false -analyzer-config cfg-implicit-dtors=false %s > %t 2>&1 // RUN: FileCheck --input-file=%t %s extern bool UV; diff --git a/test/Analysis/lifetime-extension.cpp b/test/Analysis/lifetime-extension.cpp index 5e3c5dde0a8b..4337632b31c8 100644 --- a/test/Analysis/lifetime-extension.cpp +++ b/test/Analysis/lifetime-extension.cpp @@ -1,6 +1,14 @@ -// RUN: %clang_analyze_cc1 -Wno-unused -std=c++11 -analyzer-checker=debug.ExprInspection -verify %s +// RUN: %clang_analyze_cc1 -Wno-unused -std=c++11 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=false -verify %s +// RUN: %clang_analyze_cc1 -Wno-unused -std=c++11 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -DTEMPORARIES -verify %s +// RUN: %clang_analyze_cc1 -Wno-unused -std=c++17 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -DTEMPORARIES %s +// RUN: %clang_analyze_cc1 -Wno-unused -std=c++11 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=false -DMOVES -verify %s +// RUN: %clang_analyze_cc1 -Wno-unused -std=c++11 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -DTEMPORARIES -DMOVES -verify %s +// RUN: %clang_analyze_cc1 -Wno-unused -std=c++17 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -DTEMPORARIES -DMOVES %s + +// Note: The C++17 run-lines don't -verify yet - it is a no-crash test. void clang_analyzer_eval(bool); +void clang_analyzer_checkInlined(bool); namespace pr17001_call_wrong_destructor { bool x; @@ -38,9 +46,289 @@ void f() { const int &y = A().j[1]; // no-crash const int &z = (A().j[1], A().j[0]); // no-crash - // FIXME: All of these should be TRUE, but constructors aren't inlined. - clang_analyzer_eval(x == 1); // expected-warning{{UNKNOWN}} - clang_analyzer_eval(y == 3); // expected-warning{{UNKNOWN}} - clang_analyzer_eval(z == 2); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(x == 1); + clang_analyzer_eval(y == 3); + clang_analyzer_eval(z == 2); +#ifdef TEMPORARIES + // expected-warning@-4{{TRUE}} + // expected-warning@-4{{TRUE}} + // expected-warning@-4{{TRUE}} +#else + // expected-warning@-8{{UNKNOWN}} + // expected-warning@-8{{UNKNOWN}} + // expected-warning@-8{{UNKNOWN}} +#endif } } // end namespace pr19539_crash_on_destroying_an_integer + +namespace maintain_original_object_address_on_lifetime_extension { +class C { + C **after, **before; + +public: + bool x; + + C(bool x, C **after, C **before) : x(x), after(after), before(before) { + *before = this; + } + + // Don't track copies in our tests. + C(const C &c) : x(c.x), after(nullptr), before(nullptr) {} + + ~C() { if (after) *after = this; } + + operator bool() const { return x; } + + static C make(C **after, C **before) { return C(false, after, before); } +}; + +void f1() { + C *after, *before; + { + const C &c = C(true, &after, &before); + } + clang_analyzer_eval(after == before); +#ifdef TEMPORARIES + // expected-warning@-2{{TRUE}} +#else + // expected-warning@-4{{UNKNOWN}} +#endif +} + +void f2() { + C *after, *before; + { + C c = C(1, &after, &before); + } + clang_analyzer_eval(after == before); // expected-warning{{TRUE}} +} + +void f3(bool coin) { + C *after, *before; + { + const C &c = coin ? C(true, &after, &before) : C(false, &after, &before); + } + clang_analyzer_eval(after == before); +#ifdef TEMPORARIES + // expected-warning@-2{{TRUE}} +#else + // expected-warning@-4{{UNKNOWN}} +#endif +} + +void f4(bool coin) { + C *after, *before; + { + // no-crash + const C &c = C(coin, &after, &before) ?: C(false, &after, &before); + } + // FIXME: Add support for lifetime extension through binary conditional + // operator. Ideally also add support for the binary conditional operator in + // C++. Because for now it calls the constructor for the condition twice. + if (coin) { + // FIXME: Should not warn. + clang_analyzer_eval(after == before); +#ifdef TEMPORARIES + // expected-warning@-2{{The left operand of '==' is a garbage value}} +#else + // expected-warning@-4{{UNKNOWN}} +#endif + } else { + // FIXME: Should be TRUE. + clang_analyzer_eval(after == before); +#ifdef TEMPORARIES + // expected-warning@-2{{FALSE}} +#else + // expected-warning@-4{{UNKNOWN}} +#endif + } +} + +void f5() { + C *after, *before; + { + const bool &x = C(true, &after, &before).x; // no-crash + } + clang_analyzer_eval(after == before); +#ifdef TEMPORARIES + // expected-warning@-2{{TRUE}} +#else + // expected-warning@-4{{UNKNOWN}} +#endif +} + +struct A { // A is an aggregate. + const C &c; +}; + +void f6() { + C *after, *before; + { + A a{C(true, &after, &before)}; + } + // FIXME: Should be TRUE. Should not warn about garbage value. + clang_analyzer_eval(after == before); // expected-warning{{UNKNOWN}} +} + +void f7() { + C *after, *before; + { + A a = {C(true, &after, &before)}; + } + // FIXME: Should be TRUE. Should not warn about garbage value. + clang_analyzer_eval(after == before); // expected-warning{{UNKNOWN}} +} + +void f8() { + C *after, *before; + { + A a[2] = {C(false, nullptr, nullptr), C(true, &after, &before)}; + } + // FIXME: Should be TRUE. Should not warn about garbage value. + clang_analyzer_eval(after == before); // expected-warning{{UNKNOWN}} +} +} // end namespace maintain_original_object_address_on_lifetime_extension + +namespace maintain_original_object_address_on_move { +class C { + int *x; + +public: + C() : x(nullptr) {} + C(int *x) : x(x) {} + C(const C &c) = delete; + C(C &&c) : x(c.x) { c.x = nullptr; } + C &operator=(C &&c) { + x = c.x; + c.x = nullptr; + return *this; + } + ~C() { + // This was triggering the division by zero warning in f1() and f2(): + // Because move-elision materialization was incorrectly causing the object + // to be relocated from one address to another before move, but destructor + // was operating on the old address, it was still thinking that 'x' is set. + if (x) + *x = 0; + } +}; + +void f1() { + int x = 1; + // &x is replaced with nullptr in move-constructor before the temporary dies. + C c = C(&x); + // Hence x was not set to 0 yet. + 1 / x; // no-warning +} +void f2() { + int x = 1; + C c; + // &x is replaced with nullptr in move-assignment before the temporary dies. + c = C(&x); + // Hence x was not set to 0 yet. + 1 / x; // no-warning +} +} // end namespace maintain_original_object_address_on_move + +namespace maintain_address_of_copies { +class C; + +struct AddressVector { + C *buf[10]; + int len; + + AddressVector() : len(0) {} + + void push(C *c) { + buf[len] = c; + ++len; + } +}; + +class C { + AddressVector &v; + +public: + C(AddressVector &v) : v(v) { v.push(this); } + ~C() { v.push(this); } + +#ifdef MOVES + C(C &&c) : v(c.v) { v.push(this); } +#endif + + // Note how return-statements prefer move-constructors when available. + C(const C &c) : v(c.v) { +#ifdef MOVES + clang_analyzer_checkInlined(false); // no-warning +#else + v.push(this); +#endif + } // no-warning + + static C make(AddressVector &v) { return C(v); } +}; + +void f1() { + AddressVector v; + { + C c = C(v); + } + // 0. Construct variable 'c' (copy/move elided). + // 1. Destroy variable 'c'. + clang_analyzer_eval(v.len == 2); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[0] == v.buf[1]); // expected-warning{{TRUE}} +} + +void f2() { + AddressVector v; + { + const C &c = C::make(v); + } + // 0. Construct the return value of make() (copy/move elided) and + // lifetime-extend it directly via reference 'c', + // 1. Destroy the temporary lifetime-extended by 'c'. + clang_analyzer_eval(v.len == 2); + clang_analyzer_eval(v.buf[0] == v.buf[1]); +#ifdef TEMPORARIES + // expected-warning@-3{{TRUE}} + // expected-warning@-3{{TRUE}} +#else + // expected-warning@-6{{UNKNOWN}} + // expected-warning@-6{{UNKNOWN}} +#endif +} + +void f3() { + AddressVector v; + { + C &&c = C::make(v); + } + // 0. Construct the return value of make() (copy/move elided) and + // lifetime-extend it directly via reference 'c', + // 1. Destroy the temporary lifetime-extended by 'c'. + clang_analyzer_eval(v.len == 2); + clang_analyzer_eval(v.buf[0] == v.buf[1]); +#ifdef TEMPORARIES + // expected-warning@-3{{TRUE}} + // expected-warning@-3{{TRUE}} +#else + // expected-warning@-6{{UNKNOWN}} + // expected-warning@-6{{UNKNOWN}} +#endif +} + +C doubleMake(AddressVector &v) { + return C::make(v); +} + +void f4() { + AddressVector v; + { + C c = doubleMake(v); + } + // 0. Construct variable 'c' (all copies/moves elided), + // 1. Destroy variable 'c'. + clang_analyzer_eval(v.len == 2); // expected-warning{{TRUE}} + clang_analyzer_eval(v.buf[0] == v.buf[1]); // expected-warning{{TRUE}} +} +} // end namespace maintain_address_of_copies diff --git a/test/Analysis/live-bindings-test.cpp b/test/Analysis/live-bindings-test.cpp new file mode 100644 index 000000000000..afbb1b399fcd --- /dev/null +++ b/test/Analysis/live-bindings-test.cpp @@ -0,0 +1,124 @@ +// RUN: %clang_analyze_cc1 -std=c++17 -analyzer-checker=core,deadcode -verify %s + +typedef unsigned long size_t; + +// Machinery required for custom structured bindings decomposition. +namespace std { +template <class T> class tuple_size; +template <class T> + constexpr size_t tuple_size_v = tuple_size<T>::value; +template <size_t I, class T> class tuple_element; + +template<class T, T v> +struct integral_constant { + static constexpr T value = v; + typedef T value_type; + typedef integral_constant type; + constexpr operator value_type() const noexcept { return value; } +}; +} + +struct S { + int a; + double b; + S(int a, double b) : a(a), b(b) {}; +}; + +S GetNumbers(); + +int used_binding() { + const auto [a, b] = GetNumbers(); // no-warning + return a + b; +} + +void no_warning_on_copy(S s) { + // Copy constructor might have side effects. + const auto [a, b] = s; // no-warning +} + + +int unused_binding_ignored() { + const auto [a, b] = GetNumbers(); // expected-warning{{Value stored to '[a, b]' during its initialization is never read}} + return 0; +} + +int unused_binding_liveness_required() { + auto [a2, b2] = GetNumbers(); // expected-warning{{Value stored to '[a2, b2]' during its initialization is never read}} + a2 = 10; + b2 = 20; + return a2 + b2; +} + +int kill_one_binding() { + auto [a, b] = GetNumbers(); // no-warning + a = 100; + return a + b; + +} + +int kill_one_binding2() { + auto [a, b] = GetNumbers(); // expected-warning{{Value stored to '[a, b]' during its initialization is never read}} + a = 100; + return a; +} + +void use_const_reference_bindings() { + const auto &[a, b] = GetNumbers(); // no-warning +} + +void use_reference_bindings() { + S s(0, 0); + auto &[a, b] = s; // no-warning + a = 200; +} + +int read_through_pointer() { + auto [a, b] = GetNumbers(); // no-warning + int *z = &a; + return *z; +} + +auto [globalA, globalB] = GetNumbers(); // no-warning, globals +auto [globalC, globalD] = GetNumbers(); // no-warning, globals + +void use_globals() { + globalA = 300; // no-warning + globalB = 200; +} + +struct Mytuple { + int a; + int b; + + template <size_t N> + int get() const { + if constexpr (N == 0) return a; + else if constexpr (N == 1) return b; + } +}; + +namespace std { + template<> + struct tuple_size<Mytuple> + : std::integral_constant<size_t, 2> {}; + + template<size_t N> + struct tuple_element<N, Mytuple> { + using type = int; + }; +} + +void no_warning_on_tuple_types_copy(Mytuple t) { + auto [a, b] = t; // no-warning +} + +Mytuple getMytuple(); + +void deconstruct_tuple_types_warning() { + auto [a, b] = getMytuple(); // expected-warning{{Value stored to '[a, b]' during its initialization is never read}} +} + +int deconstruct_tuple_types_no_warning() { + auto [a, b] = getMytuple(); // no-warning + return a + b; +} diff --git a/test/Analysis/localization.m b/test/Analysis/localization.m index 3a6a0d707373..a9fd2445eb15 100644 --- a/test/Analysis/localization.m +++ b/test/Analysis/localization.m @@ -118,14 +118,14 @@ NSString *KHLocalizedString(NSString* key, NSString* comment) { - (NSString *)test1:(int)plural { if (plural) { - return MCLocalizedString(@"TYPE_PLURAL"); // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} + return MCLocalizedString(@"TYPE_PLURAL"); // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}} } return MCLocalizedString(@"TYPE"); } - (NSString *)test2:(int)numOfReminders { if (numOfReminders > 0) { - return [NSString stringWithFormat:@"%@, %@", @"Test", (numOfReminders != 1) ? [NSString stringWithFormat:NSLocalizedString(@"%@ Reminders", @"Plural count of reminders"), numOfReminders] : [NSString stringWithFormat:NSLocalizedString(@"1 reminder", @"One reminder")]]; // expected-warning 2 {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note 2 {{Plural}} + return [NSString stringWithFormat:@"%@, %@", @"Test", (numOfReminders != 1) ? [NSString stringWithFormat:NSLocalizedString(@"%@ Reminders", @"Plural count of reminders"), numOfReminders] : [NSString stringWithFormat:NSLocalizedString(@"1 reminder", @"One reminder")]]; // expected-warning 2 {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note 2 {{Plural}} } return nil; } @@ -134,18 +134,18 @@ NSString *KHLocalizedString(NSString* key, NSString* comment) { NSString *count; if (self.unreadArticlesCount > 1) { - count = [count stringByAppendingFormat:@"%@", KHLocalizedString(@"New Stories", @"Plural count for new stories")]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} + count = [count stringByAppendingFormat:@"%@", KHLocalizedString(@"New Stories", @"Plural count for new stories")]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}} } else { - count = [count stringByAppendingFormat:@"%@", KHLocalizedString(@"New Story", @"One new story")]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} + count = [count stringByAppendingFormat:@"%@", KHLocalizedString(@"New Story", @"One new story")]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}} } } - (NSString *)test4:(int)count { if ( count == 1 ) { - return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} + return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}} } else { - return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} + return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}} } } @@ -153,9 +153,9 @@ NSString *KHLocalizedString(NSString* key, NSString* comment) { int test = count == 1; if (test) { - return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} + return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}} } else { - return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} + return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}} } } @@ -169,7 +169,7 @@ NSString *KHLocalizedString(NSString* key, NSString* comment) { if (someOtherVariable) return KHLocalizedString(@"OK",nil); // no-warning } else { - return KHLocalizedString(@"value.plural",nil); // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} + return KHLocalizedString(@"value.plural",nil); // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}} } return nil; } diff --git a/test/Analysis/loop-unrolling.cpp b/test/Analysis/loop-unrolling.cpp index 844d1f18ea57..b7375df38b69 100644 --- a/test/Analysis/loop-unrolling.cpp +++ b/test/Analysis/loop-unrolling.cpp @@ -1,4 +1,5 @@ -// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config unroll-loops=true,cfg-loopexit=true -verify -std=c++11 %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config unroll-loops=true,cfg-loopexit=true -verify -std=c++11 -analyzer-config exploration_strategy=unexplored_first_queue %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config unroll-loops=true,cfg-loopexit=true,exploration_strategy=dfs -verify -std=c++11 -DDFS=1 %s void clang_analyzer_numTimesReached(); void clang_analyzer_warnIfReached(); @@ -35,6 +36,29 @@ int simple_unroll2() { return 0; } +int simple_unroll3_unsigned() { + int a[9]; + int k = 42; + for (unsigned i = 0; i < 9; i++) { + clang_analyzer_numTimesReached(); // expected-warning {{9}} + a[i] = 42; + } + int b = 22 / (k - 42); // expected-warning {{Division by zero}} + return 0; +} + +int simple_unroll4_unsigned() { + int a[9]; + int k = 42; + unsigned i; + for (i = (0); i < 9; i++) { + clang_analyzer_numTimesReached(); // expected-warning {{9}} + a[i] = 42; + } + int b = 22 / (k - 42); // expected-warning {{Division by zero}} + return 0; +} + int simple_no_unroll1() { int a[9]; int k = 42; @@ -98,13 +122,101 @@ int simple_no_unroll5() { return 0; } +int no_unroll_assignment() { + for (int i = 0; i < 9; i++) { + i = i + 1; + clang_analyzer_numTimesReached(); // expected-warning {{4}} + } + return 0; +} + +int no_unroll_assignment2() { + for (int i = 0; i < 9; i++) { + i *= 2; + clang_analyzer_numTimesReached(); // expected-warning {{4}} + } + return 0; +} + +int no_unroll_assignment3() { + for (int i = 128; i > 0; i--) { + i /= 2; + clang_analyzer_numTimesReached(); // expected-warning {{4}} + } + return 0; +} + +int no_unroll_assignment4() { + for (int i = 0; i < 9; i++) { + i -= 2; + clang_analyzer_numTimesReached(); // expected-warning {{4}} + } + return 0; +} + +int no_unroll_assignment5() { + for (int i = 0; i < 9; i++) { + i += 1; + clang_analyzer_numTimesReached(); // expected-warning {{4}} + } + return 0; +} + +int no_unroll_assignment6() { + for (int i = 128; i > 0; i--) { + i >>= 1; + clang_analyzer_numTimesReached(); // expected-warning {{4}} + } + return 0; +} + +int no_unroll_assignment7() { + for (int i = 0; i < 512; i++) { + i <<= 1; + clang_analyzer_numTimesReached(); // expected-warning {{4}} + } + return 0; +} + +int no_unroll_assignment8() { + for (int i = 0; i < 9; i++) { + i %= 8; + clang_analyzer_numTimesReached(); // expected-warning {{4}} + } + return 0; +} + +int no_unroll_assignment9() { + for (int i = 0; i < 9; i++) { + i &= 31; + clang_analyzer_numTimesReached(); // expected-warning {{4}} + } + return 0; +} + +int no_unroll_assignment10() { + for (int i = 0; i < 9; i++) { + i |= 2; + clang_analyzer_numTimesReached(); // expected-warning {{4}} + } + return 0; +} + +int no_unroll_assignment11() { + for (int i = 0; i < 9; i++) { + i ^= 2; + clang_analyzer_numTimesReached(); // expected-warning {{4}} + } + return 0; +} + int make_new_branches_loop_cached() { for (int i = 0; i < 8; i++) { clang_analyzer_numTimesReached(); // expected-warning {{4}} - if(getNum()){ - (void) i; // Since this Stmt does not change the State the analyzer - // won't make a new execution path but reuse the earlier nodes. - } + if (getNum()) { + (void)i; // Since this Stmt does not change the State the analyzer + // won't make a new execution path but reuse the earlier nodes. + } } clang_analyzer_warnIfReached(); // no-warning return 0; @@ -114,7 +226,7 @@ int make_new_branches_loop_uncached() { int l = 2; for (int i = 0; i < 8; i++) { clang_analyzer_numTimesReached(); // expected-warning {{10}} - if(getNum()){ + if (getNum()) { ++l; } } @@ -126,7 +238,7 @@ int make_new_branches_loop_uncached2() { int l = 2; for (int i = 0; i < 8; i++) { clang_analyzer_numTimesReached(); // expected-warning {{10}} - if(getNum()){ + if (getNum()) { ++l; } (void)&i; // This ensures that the loop won't be unrolled. @@ -184,7 +296,7 @@ int nested_outer_unrolled() { for (j = 0; j < 9; ++j) { clang_analyzer_numTimesReached(); // expected-warning {{4}} a[j] = 22; - (void) &j; // ensures that the inner loop won't be unrolled + (void)&j; // ensures that the inner loop won't be unrolled } a[i] = 42; } @@ -234,7 +346,11 @@ int simple_known_bound_loop() { int simple_unknown_bound_loop() { for (int i = 2; i < getNum(); i++) { +#ifdef DFS clang_analyzer_numTimesReached(); // expected-warning {{10}} +#else + clang_analyzer_numTimesReached(); // expected-warning {{13}} +#endif } return 0; } @@ -252,7 +368,11 @@ int nested_inlined_unroll1() { int nested_inlined_no_unroll1() { int k; for (int i = 0; i < 9; i++) { +#ifdef ANALYZER_CM_Z3 + clang_analyzer_numTimesReached(); // expected-warning {{13}} +#else clang_analyzer_numTimesReached(); // expected-warning {{15}} +#endif k = simple_unknown_bound_loop(); // reevaluation without inlining, splits the state as well } int a = 22 / k; // no-warning @@ -263,8 +383,8 @@ int recursion_unroll1(bool b) { int k = 2; for (int i = 0; i < 5; i++) { clang_analyzer_numTimesReached(); // expected-warning {{13}} - if(i == 0 && b) // Splits the state in the first iteration but the recursion - // call will be unrolled anyway since the condition is known there. + if (i == 0 && b) // Splits the state in the first iteration but the recursion + // call will be unrolled anyway since the condition is known there. recursion_unroll1(false); clang_analyzer_numTimesReached(); // expected-warning {{14}} } @@ -276,7 +396,7 @@ int recursion_unroll2(bool b) { int k = 0; for (int i = 0; i < 5; i++) { clang_analyzer_numTimesReached(); // expected-warning {{9}} - if(i == 0 && b) + if (i == 0 && b) recursion_unroll2(false); clang_analyzer_numTimesReached(); // expected-warning {{9}} } @@ -302,7 +422,7 @@ int recursion_unroll4(bool b) { int k = 2; for (int i = 0; i < 5; i++) { clang_analyzer_numTimesReached(); // expected-warning {{13}} - if(i == 0 && b) { + if (i == 0 && b) { recursion_unroll4(false); continue; } diff --git a/test/Analysis/loop-widening-preserve-reference-type.cpp b/test/Analysis/loop-widening-preserve-reference-type.cpp new file mode 100644 index 000000000000..b5746d1fe767 --- /dev/null +++ b/test/Analysis/loop-widening-preserve-reference-type.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-max-loop 4 -analyzer-config widen-loops=true -verify %s + +void clang_analyzer_eval(int); + +struct A { + ~A() {} +}; +struct B : public A {}; + +void invalid_type_region_access() { + const A &x = B(); + for (int i = 0; i < 10; ++i) { } + clang_analyzer_eval(&x != 0); // expected-warning{{TRUE}} +} // expected-warning@-1{{reference cannot be bound to dereferenced null pointer in well-defined C++ code; comparison may be assumed to always evaluate to true}} diff --git a/test/Analysis/loop-widening.c b/test/Analysis/loop-widening.c index de17951d180f..3378893b3257 100644 --- a/test/Analysis/loop-widening.c +++ b/test/Analysis/loop-widening.c @@ -1,4 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-max-loop 4 -analyzer-config widen-loops=true -verify %s +// RUN: %clang_analyze_cc1 -DTEST_NULL_TERM -analyzer-checker=core,unix.Malloc,debug.ExprInspection,alpha.cplusplus.IteratorRange -analyzer-max-loop 4 -analyzer-config widen-loops=true -verify %s void clang_analyzer_eval(int); void clang_analyzer_warnIfReached(); @@ -188,3 +189,16 @@ void nested_loop_inner_widen() { } clang_analyzer_eval(i >= 2); // expected-warning {{TRUE}} } + +#ifdef TEST_NULL_TERM +void null_terminator_loop_widen(int *a) { + int c; + // Loop widening will call 'invalidateRegions()' and 'invalidateRegions()' + // will construct the SymbolConjured with null Stmt because of the null + // terminator statement. Accessing the null Stmt will cause a crash. + for (;;) { + c = *a; // no-crash + a++; + } +} +#endif diff --git a/test/Analysis/malloc-custom.c b/test/Analysis/malloc-custom.c index f33b150de678..053d0ee31ca8 100644 --- a/test/Analysis/malloc-custom.c +++ b/test/Analysis/malloc-custom.c @@ -1,6 +1,6 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -Wno-incompatible-library-redeclaration -verify %s -// Various tests to make the the analyzer is robust against custom +// Various tests to make the analyzer is robust against custom // redeclarations of memory routines. // // You wouldn't expect to see much of this in normal code, but, for example, diff --git a/test/Analysis/malloc-fnptr-plist.c b/test/Analysis/malloc-fnptr-plist.c new file mode 100644 index 000000000000..6490eeb1cc03 --- /dev/null +++ b/test/Analysis/malloc-fnptr-plist.c @@ -0,0 +1,11 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker core,unix.Malloc -analyzer-output=plist -o %t.plist -verify %s +// RUN: FileCheck --input-file=%t.plist %s + +void free(void *); +void (*fnptr)(int); +void foo() { + free((void *)fnptr); // expected-warning{{Argument to free() is a function pointer}} +} + +// Make sure the bug category is correct. +// CHECK: <key>category</key><string>Memory error</string> diff --git a/test/Analysis/malloc-plist.c b/test/Analysis/malloc-plist.c index 513bf7766706..1f2870863cc7 100644 --- a/test/Analysis/malloc-plist.c +++ b/test/Analysis/malloc-plist.c @@ -1,5 +1,5 @@ // RUN: rm -f %t -// RUN: %clang_analyze_cc1 -fblocks -analyzer-checker=core,unix.Malloc -analyzer-output=plist -analyzer-config path-diagnostics-alternate=false -o %t %s +// RUN: %clang_analyze_cc1 -fblocks -analyzer-checker=core,unix.Malloc -analyzer-output=plist -verify -o %t %s // RUN: FileCheck -input-file %t %s typedef __typeof(sizeof(int)) size_t; @@ -19,8 +19,8 @@ void diagnosticTest(int in) { void myArrayAllocation() { int **A; A = malloc(2*sizeof(int*)); - A[0] = 0;// expected-warning {{leak}} -} + A[0] = 0; +}//expected-warning{{Potential leak}} void reallocDiagnostics() { char * buf = malloc(100); @@ -44,7 +44,7 @@ void *wrapper() { void test_wrapper() { void *buf = wrapper(); (void) buf; -} +}//expected-warning{{Potential leak}} // Test what happens when the same call frees and allocated memory. // Also tests the stack hint for parameters, when they are passed directly or via pointer. @@ -60,7 +60,7 @@ void my_malloc_and_free(void **x) { void *test_double_action_call() { void *buf; my_malloc_and_free(&buf); - return buf; + return buf; //expected-warning{{Use of memory after it is freed}} } // Test stack hint for 'reallocation failed'. @@ -75,7 +75,7 @@ char *my_realloc(char *buf) { void reallocIntra() { char *buf = (char *)malloc(100); buf = my_realloc(buf); - free(buf); + free(buf);//expected-warning{{Potential leak}} } // Test stack hint when returning a result. @@ -85,7 +85,7 @@ static char *malloc_wrapper_ret() { void use_ret() { char *v; v = malloc_wrapper_ret(); -} +}//expected-warning{{Potential leak}} // Passing a block as a parameter to an inlined call for which we generate // a stack hint message caused crashes. @@ -99,7 +99,7 @@ void call_myfree_takingblock() { int *p = malloc(sizeof(int)); myfree_takingblock(some_block, p); - *p = 3; + *p = 3;//expected-warning{{Use of memory after it is freed}} } // Test that we refer to the last symbol used in the leak diagnostic. @@ -112,13 +112,13 @@ void LeakedSymbol(int in) { m = p; p = 0; (*m)++; - in++; + in++;//expected-warning{{Potential leak}} } // Tests that exercise running remove dead bindings at Call exit. static void function_with_leak1() { char *x = (char*)malloc(12); -} +} //expected-warning{{Potential leak}} void use_function_with_leak1() { function_with_leak1(); int y = 0; @@ -126,7 +126,7 @@ void use_function_with_leak1() { static void function_with_leak2() { char *x = (char*)malloc(12); - int m = 0; + int m = 0; //expected-warning{{Potential leak}} } void use_function_with_leak2() { function_with_leak2(); @@ -136,7 +136,7 @@ static void function_with_leak3(int y) { char *x = (char*)malloc(12); if (y) y++; -} +}//expected-warning{{Potential leak}} void use_function_with_leak3(int y) { function_with_leak3(y); } @@ -146,7 +146,7 @@ static void function_with_leak4(int y) { if (y) y++; else - y--; + y--;//expected-warning{{Potential leak}} } void use_function_with_leak4(int y) { function_with_leak4(y); @@ -157,7 +157,7 @@ int anotherFunction5() { } static int function_with_leak5() { char *x = (char*)malloc(12); - return anotherFunction5(); + return anotherFunction5();//expected-warning{{Potential leak}} } void use_function_with_leak5() { function_with_leak5(); @@ -168,7 +168,7 @@ void anotherFunction6(int m) { } static void function_with_leak6() { char *x = (char*)malloc(12); - anotherFunction6(3); + anotherFunction6(3);//expected-warning{{Potential leak}} } void use_function_with_leak6() { function_with_leak6(); @@ -184,7 +184,7 @@ static char *function_with_leak7() { } void use_function_with_leak7() { function_with_leak7(); -} +}//expected-warning{{Potential memory leak}} // Test that we do not print the name of a variable not visible from where // the issue is reported. @@ -194,7 +194,7 @@ int *my_malloc() { } void testOnlyRefferToVisibleVariables() { my_malloc(); -} // expected-warning {{Potential leak of memory}} +} // expected-warning{{Potential memory leak}} struct PointerWrapper{ int*p; @@ -205,8 +205,8 @@ int *my_malloc_into_struct() { return w.p; } void testMyMalloc() { - my_malloc_into_struct(); // expected-warning {{Potential leak of memory}} -} + my_malloc_into_struct(); +} // expected-warning{{Potential memory leak}} // CHECK: <key>diagnostics</key> // CHECK-NEXT: <array> @@ -311,40 +311,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>12</integer> -// CHECK-NEXT: <key>col</key><integer>9</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>12</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>12</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>12</integer> -// CHECK-NEXT: <key>col</key><integer>23</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -382,12 +348,46 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>12</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>12</integer> -// CHECK-NEXT: <key>col</key><integer>23</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>14</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>14</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>14</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>14</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -476,40 +476,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>21</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>21</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>21</integer> -// CHECK-NEXT: <key>col</key><integer>9</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>21</integer> -// CHECK-NEXT: <key>col</key><integer>14</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -547,12 +513,46 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>21</integer> -// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>21</integer> -// CHECK-NEXT: <key>col</key><integer>14</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -607,40 +607,6 @@ void testMyMalloc() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>26</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>26</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>26</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>26</integer> -// CHECK-NEXT: <key>col</key><integer>23</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -678,12 +644,12 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>26</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>26</integer> -// CHECK-NEXT: <key>col</key><integer>23</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -704,40 +670,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>28</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>28</integer> -// CHECK-NEXT: <key>col</key><integer>7</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>28</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>28</integer> -// CHECK-NEXT: <key>col</key><integer>24</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -775,12 +707,12 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>28</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>28</integer> -// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1106,40 +1038,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>37</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>37</integer> -// CHECK-NEXT: <key>col</key><integer>6</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>37</integer> -// CHECK-NEXT: <key>col</key><integer>13</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>37</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1177,12 +1075,12 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>37</integer> -// CHECK-NEXT: <key>col</key><integer>13</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>37</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> +// CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1349,6 +1247,74 @@ void testMyMalloc() { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>45</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>45</integer> +// CHECK-NEXT: <key>col</key><integer>6</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>45</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>45</integer> +// CHECK-NEXT: <key>col</key><integer>6</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>46</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>46</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>46</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>46</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>47</integer> // CHECK-NEXT: <key>col</key><integer>1</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -1508,40 +1474,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>55</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>55</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>55</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>55</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1579,12 +1511,12 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>55</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>55</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1983,40 +1915,6 @@ void testMyMalloc() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>76</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>76</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>76</integer> -// CHECK-NEXT: <key>col</key><integer>25</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>76</integer> -// CHECK-NEXT: <key>col</key><integer>30</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -2054,12 +1952,46 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>76</integer> -// CHECK-NEXT: <key>col</key><integer>25</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>76</integer> -// CHECK-NEXT: <key>col</key><integer>30</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>77</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>77</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>77</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>77</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -2191,40 +2123,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>69</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>69</integer> -// CHECK-NEXT: <key>col</key><integer>7</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>69</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>69</integer> -// CHECK-NEXT: <key>col</key><integer>24</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -2262,12 +2160,12 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>69</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>69</integer> -// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -2497,6 +2395,40 @@ void testMyMalloc() { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>77</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>77</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>77</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>77</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>78</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -2566,6 +2498,40 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>87</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>87</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>87</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>87</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>87</integer> // CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -2656,40 +2622,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>83</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>83</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>83</integer> -// CHECK-NEXT: <key>col</key><integer>19</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>83</integer> -// CHECK-NEXT: <key>col</key><integer>24</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -2768,6 +2700,40 @@ void testMyMalloc() { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>87</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>87</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>87</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>87</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>88</integer> // CHECK-NEXT: <key>col</key><integer>1</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -2850,40 +2816,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>100</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>100</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>100</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>100</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -2921,12 +2853,12 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>100</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>100</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -3103,6 +3035,40 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>102</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>102</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>102</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>102</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>102</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -3199,40 +3165,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>109</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>109</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>109</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>109</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -3270,12 +3202,12 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>109</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>109</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -3407,40 +3339,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>120</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>120</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>120</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>120</integer> -// CHECK-NEXT: <key>col</key><integer>27</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -3478,12 +3376,12 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>120</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>120</integer> -// CHECK-NEXT: <key>col</key><integer>27</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -3615,40 +3513,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>128</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>128</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>128</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>128</integer> -// CHECK-NEXT: <key>col</key><integer>27</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -3686,12 +3550,12 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>128</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>128</integer> -// CHECK-NEXT: <key>col</key><integer>27</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -3823,40 +3687,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>136</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>136</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>136</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>136</integer> -// CHECK-NEXT: <key>col</key><integer>27</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -3894,12 +3724,12 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>136</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>136</integer> -// CHECK-NEXT: <key>col</key><integer>27</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -4128,40 +3958,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>145</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>145</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>145</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>145</integer> -// CHECK-NEXT: <key>col</key><integer>27</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -4199,12 +3995,12 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>145</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>145</integer> -// CHECK-NEXT: <key>col</key><integer>27</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -4433,40 +4229,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>159</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>159</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>159</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>159</integer> -// CHECK-NEXT: <key>col</key><integer>27</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -4504,12 +4266,46 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>159</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>159</integer> -// CHECK-NEXT: <key>col</key><integer>27</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>160</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>160</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>160</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>160</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -4641,40 +4437,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>27</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -4712,12 +4474,12 @@ void testMyMalloc() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>27</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -4849,40 +4611,6 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>183</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>183</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>183</integer> -// CHECK-NEXT: <key>col</key><integer>19</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>183</integer> -// CHECK-NEXT: <key>col</key><integer>24</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -5086,6 +4814,35 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>192</integer> +// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>192</integer> +// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>192</integer> +// CHECK-NEXT: <key>col</key><integer>21</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>1</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Memory is allocated</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Memory is allocated</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <array> @@ -5106,13 +4863,13 @@ void testMyMalloc() { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>192</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> +// CHECK-NEXT: <key>line</key><integer>193</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>192</integer> -// CHECK-NEXT: <key>col</key><integer>17</integer> +// CHECK-NEXT: <key>line</key><integer>193</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -5123,35 +4880,6 @@ void testMyMalloc() { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>192</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <key>ranges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>192</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>192</integer> -// CHECK-NEXT: <key>col</key><integer>21</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>depth</key><integer>1</integer> -// CHECK-NEXT: <key>extended_message</key> -// CHECK-NEXT: <string>Memory is allocated</string> -// CHECK-NEXT: <key>message</key> -// CHECK-NEXT: <string>Memory is allocated</string> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>event</string> -// CHECK-NEXT: <key>location</key> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>196</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -5357,6 +5085,35 @@ void testMyMalloc() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>204</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>204</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>204</integer> +// CHECK-NEXT: <key>col</key><integer>18</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>1</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Memory is allocated</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Memory is allocated</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <array> @@ -5377,13 +5134,13 @@ void testMyMalloc() { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>204</integer> -// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>line</key><integer>205</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>204</integer> -// CHECK-NEXT: <key>col</key><integer>14</integer> +// CHECK-NEXT: <key>line</key><integer>205</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -5394,35 +5151,6 @@ void testMyMalloc() { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>204</integer> -// CHECK-NEXT: <key>col</key><integer>9</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <key>ranges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>204</integer> -// CHECK-NEXT: <key>col</key><integer>9</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>204</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>depth</key><integer>1</integer> -// CHECK-NEXT: <key>extended_message</key> -// CHECK-NEXT: <string>Memory is allocated</string> -// CHECK-NEXT: <key>message</key> -// CHECK-NEXT: <string>Memory is allocated</string> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>event</string> -// CHECK-NEXT: <key>location</key> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>208</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -5514,5 +5242,3 @@ void testMyMalloc() { // CHECK-NEXT: </dict> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </plist> diff --git a/test/Analysis/malloc.c b/test/Analysis/malloc.c index 4c364ebd9a2f..3e86c29a55a5 100644 --- a/test/Analysis/malloc.c +++ b/test/Analysis/malloc.c @@ -375,7 +375,7 @@ void CheckUseZeroReallocatedPathWarn(_Bool b) { // or inter-procedural analysis, this is a conservative answer. int *f3() { static int *p = 0; - p = malloc(12); + p = malloc(12); return p; // no-warning } @@ -384,7 +384,7 @@ int *f3() { // functions or inter-procedural analysis, this is a conservative answer. static int *p_f4 = 0; int *f4() { - p_f4 = malloc(12); + p_f4 = malloc(12); return p_f4; // no-warning } @@ -1232,7 +1232,7 @@ void radar10978247(int myValueSize) { if (myValueSize <= sizeof(stackBuffer)) buffer = stackBuffer; - else + else buffer = malloc(myValueSize); // do stuff with the buffer @@ -1246,7 +1246,7 @@ void radar10978247_positive(int myValueSize) { if (myValueSize <= sizeof(stackBuffer)) buffer = stackBuffer; - else + else buffer = malloc(myValueSize); // do stuff with the buffer @@ -1254,7 +1254,7 @@ void radar10978247_positive(int myValueSize) { return; else return; // expected-warning {{leak}} -} +} // <rdar://problem/11269741> Previously this triggered a false positive // because malloc() is known to return uninitialized memory and the binding // of 'o' to 'p->n' was not getting propertly handled. Now we report a leak. @@ -1698,7 +1698,7 @@ void testReallocEscaped(void **memory) { void *smallocNoWarn(size_t size) { if (size == 0) { return malloc(1); // this branch is never called - } + } else { return malloc(size); } @@ -1720,13 +1720,6 @@ void *smallocWarn(size_t size) { } } -char *dupstrWarn(const char *s) { - const int len = strlen(s); - char *p = (char*) smallocWarn(len + 1); - strcpy(p, s); // expected-warning{{String copy function overflows destination buffer}} - return p; -} - int *radar15580979() { int *data = (int *)malloc(32); int *p = data ?: (int*)malloc(32); // no warning @@ -1784,6 +1777,18 @@ void freeFunctionPtr() { free((void *)fnptr); // expected-warning {{Argument to free() is a function pointer}} } +void allocateSomeMemory(void *offendingParameter, void **ptr) { + *ptr = malloc(1); +} + +void testNoCrashOnOffendingParameter() { + // "extern" is necessary to avoid unrelated warnings + // on passing uninitialized value. + extern void *offendingParameter; + void* ptr; + allocateSomeMemory(offendingParameter, &ptr); +} // expected-warning {{Potential leak of memory pointed to by 'ptr'}} + // ---------------------------------------------------------------------------- // False negatives. diff --git a/test/Analysis/malloc.cpp b/test/Analysis/malloc.cpp index c323754bb467..b93c73e591cd 100644 --- a/test/Analysis/malloc.cpp +++ b/test/Analysis/malloc.cpp @@ -1,5 +1,7 @@ // RUN: %clang_analyze_cc1 -w -analyzer-checker=core,alpha.deadcode.UnreachableCode,alpha.core.CastSize,unix.Malloc,cplusplus.NewDelete -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -triple i386-unknown-linux-gnu -w -analyzer-checker=core,alpha.deadcode.UnreachableCode,alpha.core.CastSize,unix.Malloc,cplusplus.NewDelete -analyzer-store=region -verify %s +// RUN: %clang_analyze_cc1 -w -analyzer-checker=core,alpha.deadcode.UnreachableCode,alpha.core.CastSize,unix.Malloc,cplusplus.NewDelete -analyzer-store=region -DTEST_INLINABLE_ALLOCATORS -verify %s +// RUN: %clang_analyze_cc1 -triple i386-unknown-linux-gnu -w -analyzer-checker=core,alpha.deadcode.UnreachableCode,alpha.core.CastSize,unix.Malloc,cplusplus.NewDelete -analyzer-store=region -DTEST_INLINABLE_ALLOCATORS -verify %s #include "Inputs/system-header-simulator-cxx.h" diff --git a/test/Analysis/malloc.mm b/test/Analysis/malloc.mm index e3daa858be87..d7bfbf3f34f3 100644 --- a/test/Analysis/malloc.mm +++ b/test/Analysis/malloc.mm @@ -320,3 +320,13 @@ void test12365078_check_positive() { NSString *string = [[NSString alloc] initWithCharactersNoCopy:characters length:12 freeWhenDone:1]; if (string) free(characters); // expected-warning{{Attempt to free non-owned memory}} } + +void *test_reinterpret_cast_to_block() { + // Used to leak because the pointer was disappearing + // during the reinterpret_cast. + using BlockPtrTy = void (^)(); + struct Block {}; + Block* block = static_cast<Block*>(malloc(sizeof(Block))); + BlockPtrTy blockPtr = reinterpret_cast<BlockPtrTy>(block); // no-warning + return blockPtr; +} diff --git a/test/Analysis/method-call-path-notes.cpp b/test/Analysis/method-call-path-notes.cpp index e6253d4f89c3..7c93c99bfd8c 100644 --- a/test/Analysis/method-call-path-notes.cpp +++ b/test/Analysis/method-call-path-notes.cpp @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=text -verify %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file -analyzer-config path-diagnostics-alternate=false %s -o %t.plist +// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file %s -o %t.plist // RUN: FileCheck --input-file=%t.plist %s // Test warning about null or uninitialized pointer values used as instance member diff --git a/test/Analysis/misc-ps-region-store.m b/test/Analysis/misc-ps-region-store.m index 9bd207326350..1ef100563126 100644 --- a/test/Analysis/misc-ps-region-store.m +++ b/test/Analysis/misc-ps-region-store.m @@ -1109,7 +1109,7 @@ void pr8015_C() { } // Tests that we correctly handle that 'number' is perfectly constrained -// after 'if (nunber == 0)', allowing us to resolve that +// after 'if (number == 0)', allowing us to resolve that // numbers[number] == numbers[0]. void pr8015_D_FIXME() { int number = pr8015_A(); diff --git a/test/Analysis/missing-bind-temporary.cpp b/test/Analysis/missing-bind-temporary.cpp new file mode 100644 index 000000000000..6071f5b5fae1 --- /dev/null +++ b/test/Analysis/missing-bind-temporary.cpp @@ -0,0 +1,130 @@ +// RUN: %clang_analyze_cc1 -triple x86_64-unknown-linux -analyzer-checker=debug.DumpCFG -std=c++14 %s > %t 2>&1 +// RUN: FileCheck --input-file=%t %s +// RUN: %clang_analyze_cc1 -triple x86_64-unknown-linux -analyzer-checker=core,debug.ExprInspection -std=c++14 -verify %s + +void clang_analyzer_eval(bool); + +int global; + +namespace variant_0 { +// This variant of the code works correctly. Function foo() is not a template +// function. Note that there are two destructors within foo(). + +class A { +public: + ~A() { ++global; } +}; + +class B { + A a; +}; + +// CHECK: void foo(int) +// CHECK: [B1] +// CHECK-NEXT: 1: (CXXConstructExpr, [B1.2], class variant_0::B) +// CHECK-NEXT: 2: variant_0::B i; +// CHECK-NEXT: 3: operator= +// CHECK-NEXT: 4: [B1.3] (ImplicitCastExpr, FunctionToPointerDecay, class variant_0::B &(*)(class variant_0::B &&) noexcept) +// CHECK-NEXT: 5: i +// CHECK-NEXT: 6: {} (CXXConstructExpr, [B1.7], [B1.8], class variant_0::B) +// CHECK-NEXT: 7: [B1.6] (BindTemporary) +// CHECK-NEXT: 8: [B1.7] +// CHECK-NEXT: 9: [B1.5] = [B1.8] (OperatorCall) +// CHECK-NEXT: 10: ~variant_0::B() (Temporary object destructor) +// CHECK-NEXT: 11: [B1.2].~B() (Implicit destructor) +void foo(int) { + B i; + i = {}; +} + +void bar() { + global = 0; + foo(1); + clang_analyzer_eval(global == 2); // expected-warning{{TRUE}} +} + +} // end namespace variant_0 + +namespace variant_1 { +// Suddenly, if we turn foo() into a template, we are missing a +// CXXBindTemporaryExpr in the AST, and therefore we're missing a +// temporary destructor in the CFG. + +class A { +public: + ~A() { ++global; } +}; + +class B { + A a; +}; + +// FIXME: Find the construction context for {} and enforce the temporary +// destructor. +// CHECK: template<> void foo<int>(int) +// CHECK: [B1] +// CHECK-NEXT: 1: (CXXConstructExpr, [B1.2], class variant_1::B) +// CHECK-NEXT: 2: variant_1::B i; +// CHECK-NEXT: 3: operator= +// CHECK-NEXT: 4: [B1.3] (ImplicitCastExpr, FunctionToPointerDecay, class variant_1::B &(*)(class variant_1::B &&) noexcept) +// CHECK-NEXT: 5: i +// CHECK-NEXT: 6: {} (CXXConstructExpr, class variant_1::B) +// CHECK-NEXT: 7: [B1.6] +// CHECK-NEXT: 8: [B1.5] = [B1.7] (OperatorCall) +// CHECK-NEXT: 9: [B1.2].~B() (Implicit destructor) +template <typename T> void foo(T) { + B i; + i = {}; +} + +void bar() { + global = 0; + foo(1); + // FIXME: Should be TRUE, i.e. we should call (and inline) two destructors. + clang_analyzer_eval(global == 2); // expected-warning{{UNKNOWN}} +} + +} // end namespace variant_1 + +namespace variant_2 { +// Making field 'a' in class 'B' public turns the class into an aggregate. +// In this case there is no constructor at {} - only an aggregate +// initialization. Aggregate initialization is unsupported for now. + +class A { +public: + ~A() { ++global; } +}; + +class B { +public: + A a; +}; + +// CHECK: template<> void foo<int>(int) +// CHECK: [B1] +// CHECK-NEXT: 1: (CXXConstructExpr, [B1.2], class variant_2::B) +// CHECK-NEXT: 2: variant_2::B i; +// CHECK-NEXT: 3: operator= +// CHECK-NEXT: 4: [B1.3] (ImplicitCastExpr, FunctionToPointerDecay, class variant_2::B &(*)(class variant_2::B &&) noexcept) +// CHECK-NEXT: 5: i +// CHECK-NEXT: 6: {} +// CHECK-NEXT: 7: {} +// CHECK-NEXT: 8: [B1.7] (BindTemporary) +// CHECK-NEXT: 9: [B1.8] +// CHECK-NEXT: 10: [B1.5] = [B1.9] (OperatorCall) +// CHECK-NEXT: 11: ~variant_2::B() (Temporary object destructor) +// CHECK-NEXT: 12: [B1.2].~B() (Implicit destructor) +template <typename T> void foo(T) { + B i; + i = {}; +} + +void bar() { + global = 0; + foo(1); + // FIXME: Should be TRUE, i.e. we should call (and inline) two destructors. + clang_analyzer_eval(global == 2); // expected-warning{{UNKNOWN}} +} + +} // end namespace variant_2 diff --git a/test/Analysis/mmap-writeexec.c b/test/Analysis/mmap-writeexec.c new file mode 100644 index 000000000000..2ebc96110342 --- /dev/null +++ b/test/Analysis/mmap-writeexec.c @@ -0,0 +1,44 @@ +// RUN: %clang_analyze_cc1 -triple i686-unknown-linux -analyzer-checker=alpha.security.MmapWriteExec -analyzer-config alpha.security.MmapWriteExec:MmapProtExec=1 -analyzer-config alpha.security.MmapWriteExec:MmapProtRead=4 -DUSE_ALTERNATIVE_PROT_EXEC_DEFINITION -verify %s +// RUN: %clang_analyze_cc1 -triple x86_64-unknown-apple-darwin10 -analyzer-checker=alpha.security.MmapWriteExec -verify %s + +#define PROT_WRITE 0x02 +#ifndef USE_ALTERNATIVE_PROT_EXEC_DEFINITION +#define PROT_EXEC 0x04 +#define PROT_READ 0x01 +#else +#define PROT_EXEC 0x01 +#define PROT_READ 0x04 +#endif +#define MAP_PRIVATE 0x0002 +#define MAP_ANON 0x1000 +#define MAP_FIXED 0x0010 +#define NULL ((void *)0) + +typedef __typeof(sizeof(int)) size_t; +void *mmap(void *, size_t, int, int, int, long); +int mprotect(void *, size_t, int); + +void f1() +{ + void *a = mmap(NULL, 16, PROT_READ | PROT_EXEC, MAP_PRIVATE | MAP_ANON, -1, 0); // no-warning + void *b = mmap(a, 16, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED | MAP_ANON, -1, 0); // no-warning + void *c = mmap(NULL, 32, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANON, -1, 0); // expected-warning{{Both PROT_WRITE and PROT_EXEC flags are set. This can lead to exploitable memory regions, which could be overwritten with malicious code}} + (void)a; + (void)b; + (void)c; +} + +void f2() +{ + void *(*callm)(void *, size_t, int, int, int, long); + callm = mmap; + int prot = PROT_WRITE | PROT_EXEC; + (void)callm(NULL, 1024, prot, MAP_PRIVATE | MAP_ANON, -1, 0); // expected-warning{{Both PROT_WRITE and PROT_EXEC flags are set. This can lead to exploitable memory regions, which could be overwritten with malicious code}} +} + +void f3() +{ + void *p = mmap(NULL, 1024, PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); // no-warning + int m = mprotect(p, 1024, PROT_WRITE | PROT_EXEC); // expected-warning{{Both PROT_WRITE and PROT_EXEC flags are set. This can lead to exploitable memory regions, which could be overwritten with malicious code}} + (void)m; +} diff --git a/test/Analysis/new-ctor-conservative.cpp b/test/Analysis/new-ctor-conservative.cpp new file mode 100644 index 000000000000..b82df9abf1e2 --- /dev/null +++ b/test/Analysis/new-ctor-conservative.cpp @@ -0,0 +1,46 @@ +// RUN: %clang_analyze_cc1 -w -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-allocator-inlining=true -std=c++11 -verify %s + +void clang_analyzer_eval(bool); +void clang_analyzer_warnIfReached(); + +struct S { + int x; + S() : x(1) {} + ~S() {} +}; + +void checkConstructorInlining() { + S *s = new S; + clang_analyzer_eval(s->x == 1); // expected-warning{{TRUE}} +} + +void checkNewPOD() { + int *i = new int; + clang_analyzer_eval(*i == 0); // expected-warning{{UNKNOWN}} + int *j = new int(); + clang_analyzer_eval(*j == 0); // expected-warning{{TRUE}} + int *k = new int(5); + clang_analyzer_eval(*k == 5); // expected-warning{{TRUE}} +} + +void checkNewArray() { + S *s = new S[10]; + // FIXME: Should be true once we inline array constructors. + clang_analyzer_eval(s[0].x == 1); // expected-warning{{UNKNOWN}} +} + +struct NullS { + NullS() { + if (this) {} + } + NullS(int x) { + if (!this) { + clang_analyzer_warnIfReached(); // no-warning + } + } +}; + +void checkNullThis() { + NullS *nulls = new NullS(); // no-crash + NullS *nulls2 = new NullS(0); +} diff --git a/test/Analysis/new-ctor-inlined.cpp b/test/Analysis/new-ctor-inlined.cpp new file mode 100644 index 000000000000..1506bf27f353 --- /dev/null +++ b/test/Analysis/new-ctor-inlined.cpp @@ -0,0 +1,55 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-allocator-inlining=true -std=c++11 -verify %s + +void clang_analyzer_eval(bool); + +typedef __typeof__(sizeof(int)) size_t; + +void *conjure(); +void exit(int); + +void *operator new(size_t size) throw() { + void *x = conjure(); + if (x == 0) + exit(1); + return x; +} + +struct S { + int x; + S() : x(1) {} + ~S() {} +}; + +void checkNewAndConstructorInlining() { + S *s = new S; + // Check that the symbol for 's' is not dying. + clang_analyzer_eval(s != 0); // expected-warning{{TRUE}} + // Check that bindings are correct (and also not dying). + clang_analyzer_eval(s->x == 1); // expected-warning{{TRUE}} +} + +struct Sp { + Sp *p; + Sp(Sp *p): p(p) {} + ~Sp() {} +}; + +void checkNestedNew() { + Sp *p = new Sp(new Sp(0)); + clang_analyzer_eval(p->p->p == 0); // expected-warning{{TRUE}} +} + +void checkNewPOD() { + int *i = new int; + clang_analyzer_eval(*i == 0); // expected-warning{{UNKNOWN}} + int *j = new int(); + clang_analyzer_eval(*j == 0); // expected-warning{{TRUE}} + int *k = new int(5); + clang_analyzer_eval(*k == 5); // expected-warning{{TRUE}} +} + +void checkTrivialCopy() { + S s; + S *t = new S(s); // no-crash + clang_analyzer_eval(t->x == 1); // expected-warning{{TRUE}} +} diff --git a/test/Analysis/new-ctor-malloc.cpp b/test/Analysis/new-ctor-malloc.cpp new file mode 100644 index 000000000000..74b1e21a5c97 --- /dev/null +++ b/test/Analysis/new-ctor-malloc.cpp @@ -0,0 +1,21 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection,unix.Malloc -analyzer-config c++-allocator-inlining=true -analyzer-output=text -std=c++11 -verify %s + +void clang_analyzer_eval(bool); + +typedef __typeof__(sizeof(int)) size_t; + +void *malloc(size_t size); + +void *operator new(size_t size) throw() { + void *x = malloc(size); // expected-note {{Memory is allocated}} + if (!x) // expected-note {{Assuming 'x' is non-null}} + // expected-note@-1 {{Taking false branch}} + return nullptr; + return x; +} + +void checkNewAndConstructorInlining() { + int *s = new int; // expected-note {{Calling 'operator new'}} + // expected-note@-1{{Returning from 'operator new'}} +} // expected-warning {{Potential leak of memory pointed to by 's'}} + // expected-note@-1 {{Potential leak of memory pointed to by 's'}} diff --git a/test/Analysis/new-ctor-null-throw.cpp b/test/Analysis/new-ctor-null-throw.cpp new file mode 100644 index 000000000000..cdaf01d8de67 --- /dev/null +++ b/test/Analysis/new-ctor-null-throw.cpp @@ -0,0 +1,26 @@ +// RUN: %clang_analyze_cc1 -w -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-allocator-inlining=true -std=c++11 -verify %s + +void clang_analyzer_eval(bool); + +typedef __typeof__(sizeof(int)) size_t; + + +// These are ill-formed. One cannot return nullptr from a throwing version of an +// operator new. +void *operator new(size_t size) { + return nullptr; +} +void *operator new[](size_t size) { + return nullptr; +} + +struct S { + int x; + S() : x(1) {} + ~S() {} +}; + +void testArrays() { + S *s = new S[10]; // no-crash + s[0].x = 2; // expected-warning{{Dereference of null pointer}} +} diff --git a/test/Analysis/new-ctor-null.cpp b/test/Analysis/new-ctor-null.cpp new file mode 100644 index 000000000000..ac2a39a02840 --- /dev/null +++ b/test/Analysis/new-ctor-null.cpp @@ -0,0 +1,36 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-allocator-inlining=true -std=c++11 -verify %s + +void clang_analyzer_eval(bool); +void clang_analyzer_warnIfReached(); + +typedef __typeof__(sizeof(int)) size_t; + +void *operator new(size_t size) throw() { + return nullptr; +} +void *operator new[](size_t size) throw() { + return nullptr; +} + +struct S { + int x; + S() : x(1) { + // FIXME: Constructor should not be called with null this, even if it was + // returned by operator new(). + clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}} + } + ~S() {} +}; + +void testArrays() { + S *s = new S[10]; // no-crash + s[0].x = 2; // expected-warning{{Dereference of null pointer}} +} + +int global; +void testInvalidationOnConstructionIntoNull() { + global = 0; + S *s = new S(); + // FIXME: Should be FALSE - we should not invalidate globals. + clang_analyzer_eval(global); // expected-warning{{UNKNOWN}} +} diff --git a/test/Analysis/new-ctor-recursive.cpp b/test/Analysis/new-ctor-recursive.cpp new file mode 100644 index 000000000000..e0c654bc74ab --- /dev/null +++ b/test/Analysis/new-ctor-recursive.cpp @@ -0,0 +1,118 @@ +// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,debug.ExprInspection -analyzer-config c++-allocator-inlining=true -std=c++11 -verify %s + +void clang_analyzer_eval(bool); +void clang_analyzer_dump(int); + +typedef __typeof__(sizeof(int)) size_t; + +void *conjure(); +void exit(int); + +struct S; + +S *global_s; + +// Recursive operator kinda placement new. +void *operator new(size_t size, S *place); + +enum class ConstructionKind : char { + Garbage, + Recursive +}; + +struct S { +public: + int x; + S(): x(1) {} + S(int y): x(y) {} + + S(ConstructionKind k) { + switch (k) { + case ConstructionKind::Recursive: { // Call one more operator new 'r'ecursively. + S *s = new (nullptr) S(5); + x = s->x + 1; + global_s = s; + return; + } + case ConstructionKind::Garbage: { + // Leaves garbage in 'x'. + } + } + } + ~S() {} +}; + +// Do not try this at home! +void *operator new(size_t size, S *place) { + if (!place) + return new S(); + return place; +} + +void testThatCharConstructorIndeedYieldsGarbage() { + S *s = new S(ConstructionKind::Garbage); + clang_analyzer_eval(s->x == 0); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(s->x == 1); // expected-warning{{UNKNOWN}} + // FIXME: This should warn, but MallocChecker doesn't default-bind regions + // returned by standard operator new to garbage. + s->x += 1; // no-warning + delete s; +} + + +void testChainedOperatorNew() { + S *s; + // * Evaluate standard new. + // * Evaluate constructor S(3). + // * Bind value for standard new. + // * Evaluate our custom new. + // * Evaluate constructor S(Garbage). + // * Bind value for our custom new. + s = new (new S(3)) S(ConstructionKind::Garbage); + clang_analyzer_eval(s->x == 3); // expected-warning{{TRUE}} + // expected-warning@+9{{Potential leak of memory pointed to by 's'}} + + // * Evaluate standard new. + // * Evaluate constructor S(Garbage). + // * Bind value for standard new. + // * Evaluate our custom new. + // * Evaluate constructor S(4). + // * Bind value for our custom new. + s = new (new S(ConstructionKind::Garbage)) S(4); + clang_analyzer_eval(s->x == 4); // expected-warning{{TRUE}} + delete s; + + // -> Enter our custom new (nullptr). + // * Evaluate standard new. + // * Inline constructor S(). + // * Bind value for standard new. + // <- Exit our custom new (nullptr). + // * Evaluate constructor S(Garbage). + // * Bind value for our custom new. + s = new (nullptr) S(ConstructionKind::Garbage); + clang_analyzer_eval(s->x == 1); // expected-warning{{TRUE}} + delete s; + + // -> Enter our custom new (nullptr). + // * Evaluate standard new. + // * Inline constructor S(). + // * Bind value for standard new. + // <- Exit our custom new (nullptr). + // -> Enter constructor S(Recursive). + // -> Enter our custom new (nullptr). + // * Evaluate standard new. + // * Inline constructor S(). + // * Bind value for standard new. + // <- Exit our custom new (nullptr). + // * Evaluate constructor S(5). + // * Bind value for our custom new (nullptr). + // * Assign that value to global_s. + // <- Exit constructor S(Recursive). + // * Bind value for our custom new (nullptr). + global_s = nullptr; + s = new (nullptr) S(ConstructionKind::Recursive); + clang_analyzer_eval(global_s); // expected-warning{{TRUE}} + clang_analyzer_eval(global_s->x == 5); // expected-warning{{TRUE}} + clang_analyzer_eval(s->x == 6); // expected-warning{{TRUE}} + delete s; +} diff --git a/test/Analysis/new-ctor-symbolic.cpp b/test/Analysis/new-ctor-symbolic.cpp new file mode 100644 index 000000000000..8bef2ed2402c --- /dev/null +++ b/test/Analysis/new-ctor-symbolic.cpp @@ -0,0 +1,33 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-allocator-inlining=true -std=c++11 -verify %s + +void clang_analyzer_eval(bool); +void clang_analyzer_warnOnDeadSymbol(int); + +typedef __typeof__(sizeof(int)) size_t; + +int conjure(); +void exit(int); + +struct S { + S() {} + ~S() {} + + static S buffer[1000]; + + // This operator allocates stuff within the buffer. Additionally, it never + // places anything at the beginning of the buffer. + void *operator new(size_t size) { + int i = conjure(); + if (i == 0) + exit(1); + // Let's see if the symbol dies before new-expression is evaluated. + // It shouldn't. + clang_analyzer_warnOnDeadSymbol(i); + return buffer + i; + } +}; + +void testIndexLiveness() { + S *s = new S(); + clang_analyzer_eval(s == S::buffer); // expected-warning{{FALSE}} +} // expected-warning{{SYMBOL DEAD}} diff --git a/test/Analysis/new-dynamic-types.cpp b/test/Analysis/new-dynamic-types.cpp new file mode 100644 index 000000000000..e0a460e3928e --- /dev/null +++ b/test/Analysis/new-dynamic-types.cpp @@ -0,0 +1,28 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core -std=c++11 -verify %s + +// expected-no-diagnostics + +typedef __typeof(sizeof(int)) size_t; + +void *operator new(size_t size, void *ptr); + +struct B { + virtual void foo(); +}; + +struct D : public B { + virtual void foo() override {} +}; + +void test_ub() { + // FIXME: Potentially warn because this code is pretty weird. + B b; + new (&b) D; + b.foo(); // no-crash +} + +void test_non_ub() { + char c[sizeof(D)]; // Should be enough storage. + new (c) D; + ((B *)c)->foo(); // no-crash +} diff --git a/test/Analysis/new.cpp b/test/Analysis/new.cpp index 6cfcb1d92719..31f763266c38 100644 --- a/test/Analysis/new.cpp +++ b/test/Analysis/new.cpp @@ -1,4 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-store region -std=c++11 -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-store region -std=c++11 -DTEST_INLINABLE_ALLOCATORS -verify %s #include "Inputs/system-header-simulator-cxx.h" void clang_analyzer_eval(bool); @@ -34,7 +35,7 @@ void *testPlacementNew() { void *y = new (x) int; clang_analyzer_eval(x == y); // expected-warning{{TRUE}}; - clang_analyzer_eval(*x == 1); // expected-warning{{UNKNOWN}}; + clang_analyzer_eval(*x == 1); // expected-warning{{TRUE}}; return y; } @@ -137,7 +138,7 @@ void testNewDeleteNoWarn() { // unix.Malloc does not know about operators new/delete. void testDeleteMallocked() { int *x = (int *)malloc(sizeof(int)); - delete x; // FIXME: Shoud detect pointer escape and keep silent after 'delete' is modeled properly. + delete x; // FIXME: Should detect pointer escape and keep silent after 'delete' is modeled properly. } // expected-warning{{Potential leak of memory pointed to by 'x'}} void testDeleteOpAfterFree() { @@ -200,8 +201,7 @@ int testNoInitializationPlacement() { int n; new (&n) int; - // Should warn that n is uninitialized. - if (n) { // no-warning + if (n) { // expected-warning{{Branch condition evaluates to a garbage value}} return 0; } return 1; @@ -274,6 +274,24 @@ void test_var_delete() { clang_analyzer_eval(true); // expected-warning{{TRUE}} } +void test_array_delete() { + class C { + public: + ~C() {} + }; + + auto c1 = new C[2][3]; + delete[] c1; // no-crash // no-warning + + C c2[4]; + // FIXME: Should warn. + delete[] &c2; // no-crash + + C c3[7][6]; + // FIXME: Should warn. + delete[] &c3; // no-crash +} + void testDeleteNull() { NoReturnDtor *foo = 0; delete foo; // should not call destructor, checked below @@ -311,7 +329,7 @@ void testArrayNull() { void testArrayDestr() { NoReturnDtor *p = new NoReturnDtor[2]; delete[] p; // Calls the base destructor which aborts, checked below - //TODO: clang_analyzer_eval should not be called + //TODO: clang_analyzer_eval should not be called clang_analyzer_eval(true); // expected-warning{{TRUE}} } diff --git a/test/Analysis/nonnullparamchecker-crash.cpp b/test/Analysis/nonnullparamchecker-crash.cpp new file mode 100644 index 000000000000..76480f4d92f2 --- /dev/null +++ b/test/Analysis/nonnullparamchecker-crash.cpp @@ -0,0 +1,11 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core -std=c++11 -verify %s +class C {}; + +// expected-no-diagnostics +void f(C i) { + auto lambda = [&] { f(i); }; + typedef decltype(lambda) T; + T* blah = new T(lambda); + (*blah)(); + delete blah; +} diff --git a/test/Analysis/novoidtypecrash.c b/test/Analysis/novoidtypecrash.c new file mode 100644 index 000000000000..c04cfca29b4f --- /dev/null +++ b/test/Analysis/novoidtypecrash.c @@ -0,0 +1,8 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core %s +a; +b(void **c) { // no-crash + *c = a; + int *d; + b(&d); + *d; +} diff --git a/test/Analysis/null-deref-path-notes.c b/test/Analysis/null-deref-path-notes.c index a1477a6226a7..c73f64066b28 100644 --- a/test/Analysis/null-deref-path-notes.c +++ b/test/Analysis/null-deref-path-notes.c @@ -1,4 +1,4 @@ -// RUN: %clang_analyze_cc1 -w -x c -analyzer-checker=core -analyzer-output=text -verify %s +// RUN: %clang_analyze_cc1 -w -x c -analyzer-checker=core,unix -analyzer-output=text -verify %s // Avoid the crash when finding the expression for tracking the origins // of the null pointer for path notes. @@ -7,3 +7,46 @@ void pr34373() { (a + 0)[0]; // expected-warning{{Array access results in a null pointer dereference}} // expected-note@-1{{Array access results in a null pointer dereference}} } + +typedef __typeof(sizeof(int)) size_t; +void *memcpy(void *dest, const void *src, unsigned long count); + +void f1(char *source) { + char *destination = 0; // expected-note{{'destination' initialized to a null pointer value}} + memcpy(destination + 0, source, 10); // expected-warning{{Null pointer argument in call to memory copy function}} + // expected-note@-1{{Null pointer argument in call to memory copy function}} +} + +void f2(char *source) { + char *destination = 0; // expected-note{{'destination' initialized to a null pointer value}} + memcpy(destination - 0, source, 10); // expected-warning{{Null pointer argument in call to memory copy function}} + // expected-note@-1{{Null pointer argument in call to memory copy function}} +} + +void f3(char *source) { + char *destination = 0; // expected-note{{'destination' initialized to a null pointer value}} + destination = destination + 0; // expected-note{{Null pointer value stored to 'destination'}} + memcpy(destination, source, 10); // expected-warning{{Null pointer argument in call to memory copy function}} + // expected-note@-1{{Null pointer argument in call to memory copy function}} +} + +void f4(char *source) { + char *destination = 0; // expected-note{{'destination' initialized to a null pointer value}} + destination = destination - 0; // expected-note{{Null pointer value stored to 'destination'}} + memcpy(destination, source, 10); // expected-warning{{Null pointer argument in call to memory copy function}} + // expected-note@-1{{Null pointer argument in call to memory copy function}} +} + +void f5(char *source) { + char *destination1 = 0; // expected-note{{'destination1' initialized to a null pointer value}} + char *destination2 = destination1 + 0; // expected-note{{'destination2' initialized to a null pointer value}} + memcpy(destination2, source, 10); // expected-warning{{Null pointer argument in call to memory copy function}} + // expected-note@-1{{Null pointer argument in call to memory copy function}} +} + +void f6(char *source) { + char *destination1 = 0; // expected-note{{'destination1' initialized to a null pointer value}} + char *destination2 = destination1 - 0; // expected-note{{'destination2' initialized to a null pointer value}} + memcpy(destination2, source, 10); // expected-warning{{Null pointer argument in call to memory copy function}} + // expected-note@-1{{Null pointer argument in call to memory copy function}} +} diff --git a/test/Analysis/null-deref-path-notes.m b/test/Analysis/null-deref-path-notes.m index 39cf9c79f311..4a68d8f6fbae 100644 --- a/test/Analysis/null-deref-path-notes.m +++ b/test/Analysis/null-deref-path-notes.m @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-store=region -analyzer-output=text -fblocks -verify -Wno-objc-root-class %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-store=region -analyzer-output=plist-multi-file -analyzer-config path-diagnostics-alternate=false -fblocks -Wno-objc-root-class %s -o %t +// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-store=region -analyzer-output=plist-multi-file -fblocks -Wno-objc-root-class %s -o %t // RUN: FileCheck --input-file=%t %s @interface Root { diff --git a/test/Analysis/null-deref-ps-region.c b/test/Analysis/null-deref-ps-region.c index c46ca6c52ae3..f5e6956ff723 100644 --- a/test/Analysis/null-deref-ps-region.c +++ b/test/Analysis/null-deref-ps-region.c @@ -22,7 +22,7 @@ void f14(int *a) { void foo() { int *x = malloc(sizeof(int)); memset(x, 0, sizeof(int)); - int n = 1 / *x; // FIXME: no-warning + int n = 1 / *x; // expected-warning {{Division by zero}} free(x); } diff --git a/test/Analysis/nullability-notes.m b/test/Analysis/nullability-notes.m index c93aa02c4200..8b6e1b02b642 100644 --- a/test/Analysis/nullability-notes.m +++ b/test/Analysis/nullability-notes.m @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -fblocks -analyzer-checker=core,nullability.NullPassedToNonnull,nullability.NullReturnedFromNonnull,nullability.NullablePassedToNonnull,nullability.NullableReturnedFromNonnull,nullability.NullableDereferenced -analyzer-output=text -verify %s -// RUN: %clang_analyze_cc1 -fblocks -analyzer-checker=core,nullability.NullPassedToNonnull,nullability.NullReturnedFromNonnull,nullability.NullablePassedToNonnull,nullability.NullableReturnedFromNonnull,nullability.NullableDereferenced -analyzer-output=plist -analyzer-config path-diagnostics-alternate=true -o %t.plist %s +// RUN: %clang_analyze_cc1 -fblocks -analyzer-checker=core,nullability.NullPassedToNonnull,nullability.NullReturnedFromNonnull,nullability.NullablePassedToNonnull,nullability.NullableReturnedFromNonnull,nullability.NullableDereferenced -analyzer-output=plist -o %t.plist %s // RUN: FileCheck --input-file=%t.plist %s #include "Inputs/system-header-simulator-for-nullability.h" diff --git a/test/Analysis/nullability.mm b/test/Analysis/nullability.mm index ddfede53b59d..2278efff3e99 100644 --- a/test/Analysis/nullability.mm +++ b/test/Analysis/nullability.mm @@ -418,7 +418,7 @@ Dummy *_Nonnull testDefensiveInlineChecks(Dummy * p) { @end @implementation SubClassWithInitializers -// Note: Because this is overridding +// Note: Because this is overriding // -[ClassWithInitializers initWithNonnullReturnAndSelfCheckingIdiom], // the return type of this method becomes implicitly id _Nonnull. - (id)initWithNonnullReturnAndSelfCheckingIdiom { diff --git a/test/Analysis/number-object-conversion.mm b/test/Analysis/number-object-conversion.mm new file mode 100644 index 000000000000..32628b2e8f20 --- /dev/null +++ b/test/Analysis/number-object-conversion.mm @@ -0,0 +1,13 @@ +// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -fblocks -fobjc-arc -w -analyzer-checker=osx.NumberObjectConversion -analyzer-config osx.NumberObjectConversion:Pedantic=true %s -verify + +#include "Inputs/system-header-simulator-objc.h" + +NSNumber* generateNumber(); + +// expected-no-diagnostics +int test_initialization_in_ifstmt() { // Don't warn on initialization in guard. + if (NSNumber* number = generateNumber()) { // no-warning + return 0; + } + return 1; +} diff --git a/test/Analysis/objc-arc.m b/test/Analysis/objc-arc.m index 4b446abc906f..687d63e24ee5 100644 --- a/test/Analysis/objc-arc.m +++ b/test/Analysis/objc-arc.m @@ -1,4 +1,4 @@ -// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,osx.cocoa.RetainCount,deadcode -verify -fblocks -analyzer-opt-analyze-nested-blocks -fobjc-arc -analyzer-config path-diagnostics-alternate=true -analyzer-output=plist-multi-file -o %t.plist %s +// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,osx.cocoa.RetainCount,deadcode -verify -fblocks -analyzer-opt-analyze-nested-blocks -fobjc-arc -analyzer-output=plist-multi-file -o %t.plist %s // RUN: FileCheck --input-file=%t.plist %s typedef signed char BOOL; diff --git a/test/Analysis/objc-for.m b/test/Analysis/objc-for.m index f191e86cc4e4..b59a5c2cf177 100644 --- a/test/Analysis/objc-for.m +++ b/test/Analysis/objc-for.m @@ -32,6 +32,7 @@ typedef unsigned long NSUInteger; @interface NSDictionary (SomeCategory) - (void)categoryMethodOnNSDictionary; +- (id) allKeys; @end @interface NSMutableDictionary : NSDictionary @@ -343,3 +344,10 @@ void boxedArrayEscape(NSMutableArray *array) { for (id key in array) clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}} } + +int not_reachable_on_iteration_through_nil() { + NSDictionary* d = nil; + for (NSString* s in [d allKeys]) + clang_analyzer_warnIfReached(); // no-warning + return 0; +} diff --git a/test/Analysis/objc-properties.m b/test/Analysis/objc-properties.m index 88a19a13c514..7f2ef52a9141 100644 --- a/test/Analysis/objc-properties.m +++ b/test/Analysis/objc-properties.m @@ -17,7 +17,7 @@ typedef signed char BOOL; id _nonSynth; } - @property (assign, nonatomic) MyClass* A; // explicitely synthesized, not implemented, non-default ivar name + @property (assign, nonatomic) MyClass* A; // explicitly synthesized, not implemented, non-default ivar name @property (assign) MyClass* X; // automatically synthesized, not implemented diff --git a/test/Analysis/objc-radar17039661.m b/test/Analysis/objc-radar17039661.m index bfb8ef02306b..0d2ddbfc3060 100644 --- a/test/Analysis/objc-radar17039661.m +++ b/test/Analysis/objc-radar17039661.m @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.RetainCount -fblocks -verify %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.RetainCount -fblocks -analyzer-output=plist-multi-file -analyzer-config path-diagnostics-alternate=false %s -o %t +// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.RetainCount -fblocks -analyzer-output=plist-multi-file %s -o %t // RUN: FileCheck --input-file=%t %s @class NSString; typedef long NSInteger; @@ -86,6 +86,40 @@ void runTest() { // CHECK: <array> // CHECK: <dict> // CHECK: <key>line</key><integer>49</integer> +// CHECK: <key>col</key><integer>3</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: <dict> +// CHECK: <key>line</key><integer>49</integer> +// CHECK: <key>col</key><integer>6</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: </array> +// CHECK: </dict> +// CHECK: </array> +// CHECK: </dict> +// CHECK: <dict> +// CHECK: <key>kind</key><string>control</string> +// CHECK: <key>edges</key> +// CHECK: <array> +// CHECK: <dict> +// CHECK: <key>start</key> +// CHECK: <array> +// CHECK: <dict> +// CHECK: <key>line</key><integer>49</integer> +// CHECK: <key>col</key><integer>3</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: <dict> +// CHECK: <key>line</key><integer>49</integer> +// CHECK: <key>col</key><integer>6</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: </array> +// CHECK: <key>end</key> +// CHECK: <array> +// CHECK: <dict> +// CHECK: <key>line</key><integer>49</integer> // CHECK: <key>col</key><integer>26</integer> // CHECK: <key>file</key><integer>0</integer> // CHECK: </dict> @@ -461,40 +495,6 @@ void runTest() { // CHECK: </array> // CHECK: </dict> // CHECK: <dict> -// CHECK: <key>kind</key><string>control</string> -// CHECK: <key>edges</key> -// CHECK: <array> -// CHECK: <dict> -// CHECK: <key>start</key> -// CHECK: <array> -// CHECK: <dict> -// CHECK: <key>line</key><integer>33</integer> -// CHECK: <key>col</key><integer>7</integer> -// CHECK: <key>file</key><integer>0</integer> -// CHECK: </dict> -// CHECK: <dict> -// CHECK: <key>line</key><integer>33</integer> -// CHECK: <key>col</key><integer>14</integer> -// CHECK: <key>file</key><integer>0</integer> -// CHECK: </dict> -// CHECK: </array> -// CHECK: <key>end</key> -// CHECK: <array> -// CHECK: <dict> -// CHECK: <key>line</key><integer>33</integer> -// CHECK: <key>col</key><integer>30</integer> -// CHECK: <key>file</key><integer>0</integer> -// CHECK: </dict> -// CHECK: <dict> -// CHECK: <key>line</key><integer>33</integer> -// CHECK: <key>col</key><integer>30</integer> -// CHECK: <key>file</key><integer>0</integer> -// CHECK: </dict> -// CHECK: </array> -// CHECK: </dict> -// CHECK: </array> -// CHECK: </dict> -// CHECK: <dict> // CHECK: <key>kind</key><string>event</string> // CHECK: <key>location</key> // CHECK: <dict> @@ -532,12 +532,46 @@ void runTest() { // CHECK: <array> // CHECK: <dict> // CHECK: <key>line</key><integer>33</integer> -// CHECK: <key>col</key><integer>30</integer> +// CHECK: <key>col</key><integer>7</integer> // CHECK: <key>file</key><integer>0</integer> // CHECK: </dict> // CHECK: <dict> // CHECK: <key>line</key><integer>33</integer> -// CHECK: <key>col</key><integer>30</integer> +// CHECK: <key>col</key><integer>14</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: </array> +// CHECK: <key>end</key> +// CHECK: <array> +// CHECK: <dict> +// CHECK: <key>line</key><integer>35</integer> +// CHECK: <key>col</key><integer>7</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: <dict> +// CHECK: <key>line</key><integer>35</integer> +// CHECK: <key>col</key><integer>14</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: </array> +// CHECK: </dict> +// CHECK: </array> +// CHECK: </dict> +// CHECK: <dict> +// CHECK: <key>kind</key><string>control</string> +// CHECK: <key>edges</key> +// CHECK: <array> +// CHECK: <dict> +// CHECK: <key>start</key> +// CHECK: <array> +// CHECK: <dict> +// CHECK: <key>line</key><integer>35</integer> +// CHECK: <key>col</key><integer>7</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: <dict> +// CHECK: <key>line</key><integer>35</integer> +// CHECK: <key>col</key><integer>14</integer> // CHECK: <key>file</key><integer>0</integer> // CHECK: </dict> // CHECK: </array> @@ -635,40 +669,6 @@ void runTest() { // CHECK: </array> // CHECK: </dict> // CHECK: <dict> -// CHECK: <key>kind</key><string>control</string> -// CHECK: <key>edges</key> -// CHECK: <array> -// CHECK: <dict> -// CHECK: <key>start</key> -// CHECK: <array> -// CHECK: <dict> -// CHECK: <key>line</key><integer>50</integer> -// CHECK: <key>col</key><integer>5</integer> -// CHECK: <key>file</key><integer>0</integer> -// CHECK: </dict> -// CHECK: <dict> -// CHECK: <key>line</key><integer>50</integer> -// CHECK: <key>col</key><integer>17</integer> -// CHECK: <key>file</key><integer>0</integer> -// CHECK: </dict> -// CHECK: </array> -// CHECK: <key>end</key> -// CHECK: <array> -// CHECK: <dict> -// CHECK: <key>line</key><integer>50</integer> -// CHECK: <key>col</key><integer>21</integer> -// CHECK: <key>file</key><integer>0</integer> -// CHECK: </dict> -// CHECK: <dict> -// CHECK: <key>line</key><integer>50</integer> -// CHECK: <key>col</key><integer>21</integer> -// CHECK: <key>file</key><integer>0</integer> -// CHECK: </dict> -// CHECK: </array> -// CHECK: </dict> -// CHECK: </array> -// CHECK: </dict> -// CHECK: <dict> // CHECK: <key>kind</key><string>event</string> // CHECK: <key>location</key> // CHECK: <dict> @@ -710,6 +710,40 @@ void runTest() { // CHECK: <string>Reference count incremented. The object now has a +1 retain count</string> // CHECK: </dict> // CHECK: <dict> +// CHECK: <key>kind</key><string>control</string> +// CHECK: <key>edges</key> +// CHECK: <array> +// CHECK: <dict> +// CHECK: <key>start</key> +// CHECK: <array> +// CHECK: <dict> +// CHECK: <key>line</key><integer>50</integer> +// CHECK: <key>col</key><integer>5</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: <dict> +// CHECK: <key>line</key><integer>50</integer> +// CHECK: <key>col</key><integer>17</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: </array> +// CHECK: <key>end</key> +// CHECK: <array> +// CHECK: <dict> +// CHECK: <key>line</key><integer>52</integer> +// CHECK: <key>col</key><integer>5</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: <dict> +// CHECK: <key>line</key><integer>52</integer> +// CHECK: <key>col</key><integer>10</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: </array> +// CHECK: </dict> +// CHECK: </array> +// CHECK: </dict> +// CHECK: <dict> // CHECK: <key>kind</key><string>event</string> // CHECK: <key>location</key> // CHECK: <dict> @@ -759,6 +793,40 @@ void runTest() { // CHECK: <key>end</key> // CHECK: <array> // CHECK: <dict> +// CHECK: <key>line</key><integer>35</integer> +// CHECK: <key>col</key><integer>7</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: <dict> +// CHECK: <key>line</key><integer>35</integer> +// CHECK: <key>col</key><integer>14</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: </array> +// CHECK: </dict> +// CHECK: </array> +// CHECK: </dict> +// CHECK: <dict> +// CHECK: <key>kind</key><string>control</string> +// CHECK: <key>edges</key> +// CHECK: <array> +// CHECK: <dict> +// CHECK: <key>start</key> +// CHECK: <array> +// CHECK: <dict> +// CHECK: <key>line</key><integer>35</integer> +// CHECK: <key>col</key><integer>7</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: <dict> +// CHECK: <key>line</key><integer>35</integer> +// CHECK: <key>col</key><integer>14</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: </array> +// CHECK: <key>end</key> +// CHECK: <array> +// CHECK: <dict> // CHECK: <key>line</key><integer>37</integer> // CHECK: <key>col</key><integer>7</integer> // CHECK: <key>file</key><integer>0</integer> @@ -1065,6 +1133,40 @@ void runTest() { // CHECK: <array> // CHECK: <dict> // CHECK: <key>line</key><integer>35</integer> +// CHECK: <key>col</key><integer>7</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: <dict> +// CHECK: <key>line</key><integer>35</integer> +// CHECK: <key>col</key><integer>14</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: </array> +// CHECK: </dict> +// CHECK: </array> +// CHECK: </dict> +// CHECK: <dict> +// CHECK: <key>kind</key><string>control</string> +// CHECK: <key>edges</key> +// CHECK: <array> +// CHECK: <dict> +// CHECK: <key>start</key> +// CHECK: <array> +// CHECK: <dict> +// CHECK: <key>line</key><integer>35</integer> +// CHECK: <key>col</key><integer>7</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: <dict> +// CHECK: <key>line</key><integer>35</integer> +// CHECK: <key>col</key><integer>14</integer> +// CHECK: <key>file</key><integer>0</integer> +// CHECK: </dict> +// CHECK: </array> +// CHECK: <key>end</key> +// CHECK: <array> +// CHECK: <dict> +// CHECK: <key>line</key><integer>35</integer> // CHECK: <key>col</key><integer>33</integer> // CHECK: <key>file</key><integer>0</integer> // CHECK: </dict> @@ -1229,5 +1331,3 @@ void runTest() { // CHECK: </dict> // CHECK: </dict> // CHECK: </array> -// CHECK:</dict> -// CHECK:</plist> diff --git a/test/Analysis/objc/direct-ivar-assignment-in-annotated-functions.m b/test/Analysis/objc/direct-ivar-assignment-in-annotated-functions.m index 1603a57fea40..782fcecd43f9 100644 --- a/test/Analysis/objc/direct-ivar-assignment-in-annotated-functions.m +++ b/test/Analysis/objc/direct-ivar-assignment-in-annotated-functions.m @@ -26,7 +26,7 @@ typedef signed char BOOL; MyClass* _NotA __attribute__((annotate("objc_allow_direct_instance_variable_assignment"))); } - @property (assign, nonatomic) MyClass* A; // explicitely synthesized, not implemented, non-default ivar name + @property (assign, nonatomic) MyClass* A; // explicitly synthesized, not implemented, non-default ivar name @property (assign) MyClass* X; // automatically synthesized, not implemented diff --git a/test/Analysis/offsetofexpr-callback.c b/test/Analysis/offsetofexpr-callback.c new file mode 100644 index 000000000000..0fcb90797d2b --- /dev/null +++ b/test/Analysis/offsetofexpr-callback.c @@ -0,0 +1,13 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.AnalysisOrder -analyzer-config debug.AnalysisOrder:PreStmtOffsetOfExpr=true,debug.AnalysisOrder:PostStmtOffsetOfExpr=true %s 2>&1 | FileCheck %s +#include "Inputs/system-header-simulator.h" + +struct S { + char c; +}; + +void test() { + offsetof(struct S, c); +} + +// CHECK: PreStmt<OffsetOfExpr> +// CHECK-NEXT: PostStmt<OffsetOfExpr>
\ No newline at end of file diff --git a/test/Analysis/plist-diagnostics-template-function.cpp b/test/Analysis/plist-diagnostics-template-function.cpp new file mode 100644 index 000000000000..1f44a789cc92 --- /dev/null +++ b/test/Analysis/plist-diagnostics-template-function.cpp @@ -0,0 +1,41 @@ +// RUN: %clang_analyze_cc1 -analyzer-output=plist -o %t.plist -std=c++11 -analyzer-checker=core %s +// RUN: FileCheck --input-file=%t.plist %s + +bool ret(); + +template <class T> +void f(int i) { + if (ret()) + i = i / (i - 5); +} + +template <> +void f<int>(int i) { + if (ret()) + i = i / (i - 5); +} + +template <int N = 0> +void defaultTemplateParameterFunction(int i) { + if (ret()) + int a = 10 / i; +} + +template <typename... Args> +void variadicTemplateFunction(int i) { + if (ret()) + int a = 10 / i; +} + +int main() { + f<int>(5); + f<float>(5); + defaultTemplateParameterFunction<>(0); + variadicTemplateFunction<char, float, double, int *>(0); +} + +// CHECK: <string>Calling 'f<float>'</string> +// CHECK: <string>Calling 'f<int>'</string> +// CHECK: <string>Calling 'defaultTemplateParameterFunction<0>'</string> +// CHECK: <string>Calling 'variadicTemplateFunction<char, float, double, int *>'</string> + diff --git a/test/Analysis/plist-diagnostics-template-record.cpp b/test/Analysis/plist-diagnostics-template-record.cpp new file mode 100644 index 000000000000..ffd6d0308836 --- /dev/null +++ b/test/Analysis/plist-diagnostics-template-record.cpp @@ -0,0 +1,42 @@ +// RUN: %clang_analyze_cc1 -analyzer-output=plist -o %t.plist -std=c++11 -analyzer-checker=core %s +// RUN: FileCheck --input-file=%t.plist %s + +bool ret(); + +template <class A, class B, class C, int N> +struct DivByZero { + int i; + DivByZero(bool b) { + if (ret()) + i = 50 / (b - 1); + } +}; + +template <class B, class C, int N> +struct DivByZero<char, B, C, N> { + int i; + DivByZero(bool b) { + if (ret()) + i = 50 / (b - 1); + } +}; + +template <typename... Args> +struct DivByZeroVariadic { + int i; + DivByZeroVariadic(bool b) { + if (ret()) + i = 50 / (b - 1); + } +}; + +int main() { + DivByZero<int, float, double, 0> a(1); + DivByZero<char, float, double, 0> a2(1); + DivByZeroVariadic<char, float, double, decltype(nullptr)> a3(1); +} + +// CHECK: <string>Calling constructor for 'DivByZero<int, float, double, 0>'</string> +// CHECK: <string>Calling constructor for 'DivByZero<char, float, double, 0>'</string> +// CHECK: <string>Calling constructor for 'DivByZeroVariadic<char, float, double, nullptr_t>'</string> + diff --git a/test/Analysis/plist-macros.cpp b/test/Analysis/plist-macros.cpp index 18d3ce11e67e..4f7d3a254574 100644 --- a/test/Analysis/plist-macros.cpp +++ b/test/Analysis/plist-macros.cpp @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix -analyzer-eagerly-assume -verify %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix -analyzer-eagerly-assume -analyzer-output=plist-multi-file -analyzer-config path-diagnostics-alternate=ture %s -o %t.plist +// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix -analyzer-eagerly-assume -analyzer-output=plist-multi-file %s -o %t.plist // RUN: FileCheck --input-file=%t.plist %s @@ -65,6 +65,7 @@ if (y) \ ; int useMultiNote(int *p, int y) {; y++; + if (p) {} multiNoteMacro return *p; // expected-warning {{Dereference of null pointer}} @@ -636,6 +637,69 @@ void test2(int *p) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>36</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>36</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>36</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>36</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>36</integer> +// CHECK-NEXT: <key>col</key><integer>25</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Assuming the condition is true</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Assuming the condition is true</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>36</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>36</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>37</integer> // CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -1216,7 +1280,41 @@ void test2(int *p) { // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>68</integer> -// CHECK-NEXT: <key>col</key><integer>16</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>68</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>68</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>68</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>68</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1228,7 +1326,7 @@ void test2(int *p) { // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>68</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <key>ranges</key> @@ -1236,12 +1334,12 @@ void test2(int *p) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>68</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>68</integer> -// CHECK-NEXT: <key>col</key><integer>16</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1253,10 +1351,44 @@ void test2(int *p) { // CHECK-NEXT: <string>Assuming 'p' is null</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>68</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>68</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>69</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>69</integer> +// CHECK-NEXT: <key>col</key><integer>16</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>68</integer> +// CHECK-NEXT: <key>line</key><integer>69</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1264,12 +1396,12 @@ void test2(int *p) { // CHECK-NEXT: <array> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>68</integer> +// CHECK-NEXT: <key>line</key><integer>69</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>68</integer> +// CHECK-NEXT: <key>line</key><integer>69</integer> // CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1289,12 +1421,12 @@ void test2(int *p) { // CHECK-NEXT: <key>start</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>68</integer> +// CHECK-NEXT: <key>line</key><integer>69</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>68</integer> +// CHECK-NEXT: <key>line</key><integer>69</integer> // CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1302,12 +1434,12 @@ void test2(int *p) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>70</integer> +// CHECK-NEXT: <key>line</key><integer>71</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>70</integer> +// CHECK-NEXT: <key>line</key><integer>71</integer> // CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1323,12 +1455,12 @@ void test2(int *p) { // CHECK-NEXT: <key>start</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>70</integer> +// CHECK-NEXT: <key>line</key><integer>71</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>70</integer> +// CHECK-NEXT: <key>line</key><integer>71</integer> // CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1336,12 +1468,12 @@ void test2(int *p) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>70</integer> +// CHECK-NEXT: <key>line</key><integer>71</integer> // CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>70</integer> +// CHECK-NEXT: <key>line</key><integer>71</integer> // CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1353,7 +1485,7 @@ void test2(int *p) { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>70</integer> +// CHECK-NEXT: <key>line</key><integer>71</integer> // CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1361,12 +1493,12 @@ void test2(int *p) { // CHECK-NEXT: <array> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>70</integer> +// CHECK-NEXT: <key>line</key><integer>71</integer> // CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>70</integer> +// CHECK-NEXT: <key>line</key><integer>71</integer> // CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1387,10 +1519,10 @@ void test2(int *p) { // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>41f58f9549aa1867e461a7996a8d335c</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context</key><string>useMultiNote</string> -// CHECK-NEXT: <key>issue_hash_function_offset</key><string>4</string> +// CHECK-NEXT: <key>issue_hash_function_offset</key><string>5</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>70</integer> +// CHECK-NEXT: <key>line</key><integer>71</integer> // CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1402,7 +1534,7 @@ void test2(int *p) { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>82</integer> +// CHECK-NEXT: <key>line</key><integer>83</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1410,12 +1542,12 @@ void test2(int *p) { // CHECK-NEXT: <array> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>82</integer> +// CHECK-NEXT: <key>line</key><integer>83</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>82</integer> +// CHECK-NEXT: <key>line</key><integer>83</integer> // CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1431,7 +1563,7 @@ void test2(int *p) { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>82</integer> +// CHECK-NEXT: <key>line</key><integer>83</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1439,12 +1571,12 @@ void test2(int *p) { // CHECK-NEXT: <array> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>82</integer> +// CHECK-NEXT: <key>line</key><integer>83</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>82</integer> +// CHECK-NEXT: <key>line</key><integer>83</integer> // CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1460,7 +1592,7 @@ void test2(int *p) { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>75</integer> +// CHECK-NEXT: <key>line</key><integer>76</integer> // CHECK-NEXT: <key>col</key><integer>1</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1478,12 +1610,12 @@ void test2(int *p) { // CHECK-NEXT: <key>start</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>75</integer> +// CHECK-NEXT: <key>line</key><integer>76</integer> // CHECK-NEXT: <key>col</key><integer>1</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>75</integer> +// CHECK-NEXT: <key>line</key><integer>76</integer> // CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1491,12 +1623,12 @@ void test2(int *p) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>76</integer> +// CHECK-NEXT: <key>line</key><integer>77</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>76</integer> +// CHECK-NEXT: <key>line</key><integer>77</integer> // CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1512,12 +1644,12 @@ void test2(int *p) { // CHECK-NEXT: <key>start</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>76</integer> +// CHECK-NEXT: <key>line</key><integer>77</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>76</integer> +// CHECK-NEXT: <key>line</key><integer>77</integer> // CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1525,12 +1657,12 @@ void test2(int *p) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>78</integer> +// CHECK-NEXT: <key>line</key><integer>79</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>78</integer> +// CHECK-NEXT: <key>line</key><integer>79</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1546,12 +1678,12 @@ void test2(int *p) { // CHECK-NEXT: <key>start</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>78</integer> +// CHECK-NEXT: <key>line</key><integer>79</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>78</integer> +// CHECK-NEXT: <key>line</key><integer>79</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1559,12 +1691,12 @@ void test2(int *p) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>78</integer> +// CHECK-NEXT: <key>line</key><integer>79</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>78</integer> +// CHECK-NEXT: <key>line</key><integer>79</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1576,7 +1708,7 @@ void test2(int *p) { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>78</integer> +// CHECK-NEXT: <key>line</key><integer>79</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1584,12 +1716,12 @@ void test2(int *p) { // CHECK-NEXT: <array> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>78</integer> +// CHECK-NEXT: <key>line</key><integer>79</integer> // CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>78</integer> +// CHECK-NEXT: <key>line</key><integer>79</integer> // CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1613,7 +1745,7 @@ void test2(int *p) { // CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>78</integer> +// CHECK-NEXT: <key>line</key><integer>79</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> diff --git a/test/Analysis/plist-output-alternate.m b/test/Analysis/plist-output-alternate.m index 03f3393af8a7..1a80a4d5c637 100644 --- a/test/Analysis/plist-output-alternate.m +++ b/test/Analysis/plist-output-alternate.m @@ -1,4 +1,4 @@ -// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.RetainCount,alpha.core -fblocks -analyzer-output=plist -analyzer-config path-diagnostics-alternate=false -o %t %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.RetainCount,alpha.core -fblocks -analyzer-output=plist -o %t %s // RUN: FileCheck --input-file %t %s void test_null_init(void) { @@ -113,6 +113,40 @@ void rdar8331641(int x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>6</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>6</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>6</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>6</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>6</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -259,6 +293,40 @@ void rdar8331641(int x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>12</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>12</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>12</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>12</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>12</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -468,6 +536,40 @@ void rdar8331641(int x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -857,6 +959,40 @@ void rdar8331641(int x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> // CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -927,40 +1063,6 @@ void rdar8331641(int x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>36</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>36</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>36</integer> -// CHECK-NEXT: <key>col</key><integer>24</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>36</integer> -// CHECK-NEXT: <key>col</key><integer>24</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>36</integer> // CHECK-NEXT: <key>col</key><integer>24</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1037,6 +1139,40 @@ void rdar8331641(int x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>38</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>38</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>38</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>38</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>38</integer> // CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1133,40 +1269,6 @@ void rdar8331641(int x) { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>54</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>54</integer> -// CHECK-NEXT: <key>col</key><integer>13</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>54</integer> -// CHECK-NEXT: <key>col</key><integer>23</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>54</integer> -// CHECK-NEXT: <key>col</key><integer>36</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1204,12 +1306,12 @@ void rdar8331641(int x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>54</integer> -// CHECK-NEXT: <key>col</key><integer>23</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>54</integer> -// CHECK-NEXT: <key>col</key><integer>36</integer> +// CHECK-NEXT: <key>col</key><integer>13</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1314,12 +1416,12 @@ void rdar8331641(int x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>14</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1335,12 +1437,12 @@ void rdar8331641(int x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>14</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> diff --git a/test/Analysis/plist-output.m b/test/Analysis/plist-output.m index a80ab5c31c66..6b39e31e0e30 100644 --- a/test/Analysis/plist-output.m +++ b/test/Analysis/plist-output.m @@ -1,4 +1,4 @@ -// RUN: %clang_analyze_cc1 %s -analyzer-checker=osx.cocoa.RetainCount,deadcode.DeadStores,core -analyzer-output=plist -analyzer-config path-diagnostics-alternate=false -o %t.plist +// RUN: %clang_analyze_cc1 %s -analyzer-checker=osx.cocoa.RetainCount,deadcode.DeadStores,core -analyzer-output=plist -o %t.plist // RUN: FileCheck --input-file=%t.plist %s void test_null_init(void) { @@ -250,6 +250,40 @@ int testFoo(Foo *x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>6</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>6</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>6</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>6</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>6</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -396,6 +430,40 @@ int testFoo(Foo *x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>12</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>12</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>12</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>12</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>12</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -605,6 +673,40 @@ int testFoo(Foo *x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>19</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -994,6 +1096,40 @@ int testFoo(Foo *x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> // CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1064,40 +1200,6 @@ int testFoo(Foo *x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>36</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>36</integer> -// CHECK-NEXT: <key>col</key><integer>8</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>36</integer> -// CHECK-NEXT: <key>col</key><integer>24</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>36</integer> -// CHECK-NEXT: <key>col</key><integer>24</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>36</integer> // CHECK-NEXT: <key>col</key><integer>24</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1174,6 +1276,40 @@ int testFoo(Foo *x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>38</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>38</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>38</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>38</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>38</integer> // CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1480,6 +1616,40 @@ int testFoo(Foo *x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>50</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>50</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>50</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>50</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>50</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1961,6 +2131,40 @@ int testFoo(Foo *x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>77</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>77</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>77</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>77</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>77</integer> // CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -2181,40 +2385,6 @@ int testFoo(Foo *x) { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>86</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>86</integer> -// CHECK-NEXT: <key>col</key><integer>6</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>86</integer> -// CHECK-NEXT: <key>col</key><integer>14</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>86</integer> -// CHECK-NEXT: <key>col</key><integer>14</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -2252,12 +2422,12 @@ int testFoo(Foo *x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>86</integer> -// CHECK-NEXT: <key>col</key><integer>14</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>86</integer> -// CHECK-NEXT: <key>col</key><integer>14</integer> +// CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -2312,6 +2482,35 @@ int testFoo(Foo *x) { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>95</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>95</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>95</integer> +// CHECK-NEXT: <key>col</key><integer>28</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <array> @@ -2366,6 +2565,40 @@ int testFoo(Foo *x) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>96</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>96</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>96</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>96</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -2443,6 +2676,35 @@ int testFoo(Foo *x) { // CHECK-NEXT: <string>Looping back to the head of the loop</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>95</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>95</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>95</integer> +// CHECK-NEXT: <key>col</key><integer>28</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <array> @@ -2561,6 +2823,40 @@ int testFoo(Foo *x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>98</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>98</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>98</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>98</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>98</integer> // CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -2690,7 +2986,7 @@ int testFoo(Foo *x) { // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>108</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <key>ranges</key> @@ -2698,12 +2994,12 @@ int testFoo(Foo *x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>108</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>108</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -2899,7 +3195,7 @@ int testFoo(Foo *x) { // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>117</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <key>ranges</key> @@ -2907,12 +3203,12 @@ int testFoo(Foo *x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>117</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>117</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -3104,6 +3400,35 @@ int testFoo(Foo *x) { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>126</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>126</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>126</integer> +// CHECK-NEXT: <key>col</key><integer>28</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <array> @@ -3158,6 +3483,40 @@ int testFoo(Foo *x) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>127</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>127</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>127</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>127</integer> +// CHECK-NEXT: <key>col</key><integer>9</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>129</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -3235,6 +3594,35 @@ int testFoo(Foo *x) { // CHECK-NEXT: <string>Looping back to the head of the loop</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>126</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>126</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>126</integer> +// CHECK-NEXT: <key>col</key><integer>28</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <array> @@ -3454,6 +3842,35 @@ int testFoo(Foo *x) { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>135</integer> +// CHECK-NEXT: <key>col</key><integer>19</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>135</integer> +// CHECK-NEXT: <key>col</key><integer>19</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>135</integer> +// CHECK-NEXT: <key>col</key><integer>23</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <array> @@ -3585,6 +4002,35 @@ int testFoo(Foo *x) { // CHECK-NEXT: <string>Looping back to the head of the loop</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>135</integer> +// CHECK-NEXT: <key>col</key><integer>19</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>135</integer> +// CHECK-NEXT: <key>col</key><integer>19</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>135</integer> +// CHECK-NEXT: <key>col</key><integer>23</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <array> @@ -3896,6 +4342,35 @@ int testFoo(Foo *x) { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>141</integer> +// CHECK-NEXT: <key>col</key><integer>19</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>141</integer> +// CHECK-NEXT: <key>col</key><integer>19</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>141</integer> +// CHECK-NEXT: <key>col</key><integer>23</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <array> @@ -3950,6 +4425,40 @@ int testFoo(Foo *x) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>143</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>143</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>143</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>143</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>144</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -4027,6 +4536,35 @@ int testFoo(Foo *x) { // CHECK-NEXT: <string>Looping back to the head of the loop</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>141</integer> +// CHECK-NEXT: <key>col</key><integer>19</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>141</integer> +// CHECK-NEXT: <key>col</key><integer>19</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>141</integer> +// CHECK-NEXT: <key>col</key><integer>23</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <array> @@ -4372,6 +4910,35 @@ int testFoo(Foo *x) { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>151</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>151</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>151</integer> +// CHECK-NEXT: <key>col</key><integer>14</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <array> @@ -4426,6 +4993,40 @@ int testFoo(Foo *x) { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>153</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>153</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>153</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>153</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>154</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -4503,6 +5104,35 @@ int testFoo(Foo *x) { // CHECK-NEXT: <string>Looping back to the head of the loop</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>151</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>151</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>151</integer> +// CHECK-NEXT: <key>col</key><integer>14</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Entering loop body</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <array> @@ -4930,7 +5560,7 @@ int testFoo(Foo *x) { // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>160</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <key>ranges</key> @@ -4938,21 +5568,21 @@ int testFoo(Foo *x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>160</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>160</integer> -// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>col</key><integer>13</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> // CHECK-NEXT: </array> // CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>extended_message</key> -// CHECK-NEXT: <string>Loop body executed 0 times</string> +// CHECK-NEXT: <string>Loop body skipped when collection is empty</string> // CHECK-NEXT: <key>message</key> -// CHECK-NEXT: <string>Loop body executed 0 times</string> +// CHECK-NEXT: <string>Loop body skipped when collection is empty</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> @@ -5122,6 +5752,40 @@ int testFoo(Foo *x) { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>172</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>172</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>172</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>172</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>172</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -5456,40 +6120,6 @@ int testFoo(Foo *x) { // CHECK-NEXT: <string>'returnsPointer' not called because the receiver is nil</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>194</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>194</integer> -// CHECK-NEXT: <key>col</key><integer>12</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>194</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>194</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> diff --git a/test/Analysis/plist-stats-output.c b/test/Analysis/plist-stats-output.c new file mode 100644 index 000000000000..072fe5e2971a --- /dev/null +++ b/test/Analysis/plist-stats-output.c @@ -0,0 +1,14 @@ +// RUN: %clang_analyze_cc1 %s -analyzer-checker=core -analyzer-output=plist -analyzer-config serialize-stats=true -o %t.plist +// REQUIRES: asserts +// RUN: FileCheck --input-file=%t.plist %s + +int foo() {} + + +// CHECK: <key>diagnostics</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>statistics</key> +// CHECK-NEXT: <string>{ +// CHECK: } +// CHECK-NEXT: </string> diff --git a/test/Analysis/pr22954.c b/test/Analysis/pr22954.c index 64a00c5ec087..b4273c0a8943 100644 --- a/test/Analysis/pr22954.c +++ b/test/Analysis/pr22954.c @@ -624,9 +624,10 @@ int f29(int i, int j, int k, int l, int m) { clang_analyzer_eval(m29[i].s3[1] == 1); // expected-warning{{UNKNOWN}} clang_analyzer_eval(m29[i].s3[2] == 1); // expected-warning{{UNKNOWN}} clang_analyzer_eval(m29[i].s3[3] == 1); // expected-warning{{UNKNOWN}} - clang_analyzer_eval(m29[j].s3[k] == 1); // expected-warning{{TRUE}}\ - expected-warning{{Potential leak of memory pointed to by field 's4'}} + clang_analyzer_eval(m29[j].s3[k] == 1); // expected-warning{{TRUE}} clang_analyzer_eval(l29->s1[m] == 2); // expected-warning{{UNKNOWN}} + // FIXME: Should warn that m29[i].s4 leaks. But not on the previous line, + // because l29 and m29 alias. return 0; } diff --git a/test/Analysis/pr37802.cpp b/test/Analysis/pr37802.cpp new file mode 100644 index 000000000000..9acfebaae860 --- /dev/null +++ b/test/Analysis/pr37802.cpp @@ -0,0 +1,107 @@ +// RUN: %clang_analyze_cc1 -w -analyzer-checker=core -verify %s + +// expected-no-diagnostics + +typedef __typeof(sizeof(int)) size_t; +void *operator new(size_t, void *h) { return h; } + +// I've no idea what this code does, but it used to crash, so let's keep it. +namespace pr37802_v1 { +struct J { + int *p; +}; +class X { + void *ar; + +public: + X(void *t) : ar(t) {} + template <typename T> + void f(const T &t) { + new (ar) T(t); + } +}; +class Y { +public: + template <typename T> + void f(T &&); + void f(J t) { + f(*t.p); + } +}; +class Z { + int at() const {} + +public: + Z(const Z &other) { + other.au(X(this)); + } + template <typename T> + void au(T t) const { + void *c = const_cast<Z *>(this); + if (at()) { + t.f(*static_cast<J *>(c)); + } else { + t.f(*static_cast<bool *>(c)); + } + } +}; +Z g() { + Z az = g(); + Z e = az; + Y d; + e.au(d); +} +} // namespace pr37802_v1 + + +// This slightly modified code crashed differently. +namespace pr37802_v2 { +struct J { + int *p; +}; + +class X { + void *ar; + +public: + X(void *t) : ar(t) {} + void f(const J &t) { new (ar) J(t); } + void f(const bool &t) { new (ar) bool(t); } +}; + +class Y { +public: + void boolf(bool &&); + void f(J &&); + void f(J t) { boolf(*t.p); } +}; + +class Z { + int at() const {} + +public: + Z(const Z &other) { other.au(X(this)); } + void au(X t) const { + void *c = const_cast<Z *>(this); + if (at()) { + t.f(*static_cast<J *>(c)); + } else { + t.f(*static_cast<bool *>(c)); + } + } + void au(Y t) const { + void *c = const_cast<Z *>(this); + if (at()) { + t.f(*static_cast<J *>(c)); + } else { + } + } +}; + +Z g() { + Z az = g(); + Z e = az; + Y d; + e.au(d); +} +} // namespace pr37802_v2 diff --git a/test/Analysis/ptr-arith.c b/test/Analysis/ptr-arith.c index 93cb4ee9a66a..c0b20508d8f5 100644 --- a/test/Analysis/ptr-arith.c +++ b/test/Analysis/ptr-arith.c @@ -265,49 +265,26 @@ void size_implies_comparison(int *lhs, int *rhs) { clang_analyzer_eval((rhs - lhs) > 0); // expected-warning{{TRUE}} } -//------------------------------- -// False positives -//------------------------------- - void zero_implies_reversed_equal(int *lhs, int *rhs) { clang_analyzer_eval((rhs - lhs) == 0); // expected-warning{{UNKNOWN}} if ((rhs - lhs) == 0) { -#ifdef ANALYZER_CM_Z3 clang_analyzer_eval(rhs != lhs); // expected-warning{{FALSE}} clang_analyzer_eval(rhs == lhs); // expected-warning{{TRUE}} -#else - clang_analyzer_eval(rhs != lhs); // expected-warning{{UNKNOWN}} - clang_analyzer_eval(rhs == lhs); // expected-warning{{UNKNOWN}} -#endif return; } clang_analyzer_eval((rhs - lhs) == 0); // expected-warning{{FALSE}} -#ifdef ANALYZER_CM_Z3 clang_analyzer_eval(rhs == lhs); // expected-warning{{FALSE}} clang_analyzer_eval(rhs != lhs); // expected-warning{{TRUE}} -#else - clang_analyzer_eval(rhs == lhs); // expected-warning{{UNKNOWN}} - clang_analyzer_eval(rhs != lhs); // expected-warning{{UNKNOWN}} -#endif } void canonical_equal(int *lhs, int *rhs) { clang_analyzer_eval(lhs == rhs); // expected-warning{{UNKNOWN}} if (lhs == rhs) { -#ifdef ANALYZER_CM_Z3 clang_analyzer_eval(rhs == lhs); // expected-warning{{TRUE}} -#else - clang_analyzer_eval(rhs == lhs); // expected-warning{{UNKNOWN}} -#endif return; } clang_analyzer_eval(lhs == rhs); // expected-warning{{FALSE}} - -#ifdef ANALYZER_CM_Z3 clang_analyzer_eval(rhs == lhs); // expected-warning{{FALSE}} -#else - clang_analyzer_eval(rhs == lhs); // expected-warning{{UNKNOWN}} -#endif } void compare_element_region_and_base(int *p) { @@ -347,3 +324,9 @@ void test_no_crash_on_pointer_to_label() { a[0] = 0; label:; } + +typedef __attribute__((__ext_vector_type__(2))) float simd_float2; +float test_nowarning_on_vector_deref() { + simd_float2 x = {0, 1}; + return x[1]; // no-warning +} diff --git a/test/Analysis/region-store.cpp b/test/Analysis/region-store.cpp index cb49f4837d81..ab179ceb1acc 100644 --- a/test/Analysis/region-store.cpp +++ b/test/Analysis/region-store.cpp @@ -25,4 +25,4 @@ int radar13445834(Derived *Builder, Loc l) { Builder->setLoc(l); return Builder->accessBase(); -}
\ No newline at end of file +} diff --git a/test/Analysis/region_store_overflow.c b/test/Analysis/region_store_overflow.c new file mode 100644 index 000000000000..505965301bc2 --- /dev/null +++ b/test/Analysis/region_store_overflow.c @@ -0,0 +1,16 @@ +// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -verify %s + +int **h; +int overflow_in_memregion(long j) { + for (int l = 0;; ++l) { + if (j - l > 0) + return h[j - l][0]; // no-crash + } + return 0; +} + +void rdar39593879(long long *d) { + long e, f; + e = f = d[1]; // no-crash + for (; d[e];) f-- > 0; // expected-warning{{relational comparison result unused}}; +} diff --git a/test/Analysis/retain-release-path-notes-gc.m b/test/Analysis/retain-release-path-notes-gc.m index 04f991263c00..307aef1a5e20 100644 --- a/test/Analysis/retain-release-path-notes-gc.m +++ b/test/Analysis/retain-release-path-notes-gc.m @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,osx.coreFoundation.CFRetainRelease,osx.cocoa.ClassRelease,osx.cocoa.RetainCount -analyzer-store=region -fobjc-gc-only -analyzer-output=text -verify %s -// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,osx.coreFoundation.CFRetainRelease,osx.cocoa.ClassRelease,osx.cocoa.RetainCount -analyzer-store=region -fobjc-gc-only -analyzer-output=plist-multi-file -analyzer-config path-diagnostics-alternate=false %s -o %t.plist +// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,osx.coreFoundation.CFRetainRelease,osx.cocoa.ClassRelease,osx.cocoa.RetainCount -analyzer-store=region -fobjc-gc-only -analyzer-output=plist-multi-file %s -o %t.plist // RUN: FileCheck --input-file=%t.plist %s /*** @@ -79,40 +79,6 @@ void retainReleaseIgnored () { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>43</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>43</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>43</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>43</integer> -// CHECK-NEXT: <key>col</key><integer>38</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -150,12 +116,12 @@ void retainReleaseIgnored () { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>43</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>43</integer> -// CHECK-NEXT: <key>col</key><integer>38</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -225,40 +191,6 @@ void retainReleaseIgnored () { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>48</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>48</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>48</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>48</integer> -// CHECK-NEXT: <key>col</key><integer>38</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -296,12 +228,12 @@ void retainReleaseIgnored () { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>48</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>48</integer> -// CHECK-NEXT: <key>col</key><integer>38</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -671,40 +603,6 @@ void retainReleaseIgnored () { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -742,12 +640,12 @@ void retainReleaseIgnored () { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1042,40 +940,6 @@ void retainReleaseIgnored () { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>66</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>66</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>66</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>66</integer> -// CHECK-NEXT: <key>col</key><integer>36</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1113,12 +977,12 @@ void retainReleaseIgnored () { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>66</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>66</integer> -// CHECK-NEXT: <key>col</key><integer>36</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1229,40 +1093,6 @@ void retainReleaseIgnored () { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>71</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>71</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>71</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>71</integer> -// CHECK-NEXT: <key>col</key><integer>36</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1300,12 +1130,12 @@ void retainReleaseIgnored () { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>71</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>71</integer> -// CHECK-NEXT: <key>col</key><integer>36</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> diff --git a/test/Analysis/retain-release-path-notes.m b/test/Analysis/retain-release-path-notes.m index f44d40fa495b..719a4d488cc0 100644 --- a/test/Analysis/retain-release-path-notes.m +++ b/test/Analysis/retain-release-path-notes.m @@ -1,5 +1,5 @@ // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,osx.coreFoundation.CFRetainRelease,osx.cocoa.ClassRelease,osx.cocoa.RetainCount -analyzer-store=region -analyzer-output=text -verify %s -// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,osx.coreFoundation.CFRetainRelease,osx.cocoa.ClassRelease,osx.cocoa.RetainCount -analyzer-store=region -analyzer-output=plist-multi-file -analyzer-config path-diagnostics-alternate=false %s -o %t +// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,osx.coreFoundation.CFRetainRelease,osx.cocoa.ClassRelease,osx.cocoa.RetainCount -analyzer-store=region -analyzer-output=plist-multi-file %s -o %t // RUN: FileCheck --input-file=%t %s /*** @@ -222,7 +222,7 @@ static int Cond; } +(void)test { - // initX is inlined since we explicitely mark it as interesting + // initX is inlined since we explicitly mark it as interesting id x = [[MyObj alloc] initX]; // expected-warning {{Potential leak of an object}} // expected-note@-1 {{Method returns an instance of MyObj with a +1 retain count}} // expected-note@-2 {{Calling 'initX'}} @@ -335,40 +335,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>47</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>47</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>47</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>47</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -406,12 +372,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>47</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>47</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -481,40 +447,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>52</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>52</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>52</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>52</integer> -// CHECK-NEXT: <key>col</key><integer>38</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -552,12 +484,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>52</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>52</integer> -// CHECK-NEXT: <key>col</key><integer>38</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -627,40 +559,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -698,12 +596,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>57</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -998,40 +896,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>65</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>65</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>65</integer> -// CHECK-NEXT: <key>col</key><integer>19</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>65</integer> -// CHECK-NEXT: <key>col</key><integer>31</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1069,12 +933,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>65</integer> -// CHECK-NEXT: <key>col</key><integer>19</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>65</integer> -// CHECK-NEXT: <key>col</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1219,40 +1083,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>71</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>71</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>71</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>71</integer> -// CHECK-NEXT: <key>col</key><integer>35</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1290,12 +1120,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>71</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>71</integer> -// CHECK-NEXT: <key>col</key><integer>35</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1440,40 +1270,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>77</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>77</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>77</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>77</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1511,12 +1307,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>77</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>77</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1661,40 +1457,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>83</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>83</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>83</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>83</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1732,12 +1494,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>83</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>83</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -1882,40 +1644,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>89</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>89</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>89</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>89</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -1953,12 +1681,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>89</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>89</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -2178,40 +1906,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>96</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>96</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>96</integer> -// CHECK-NEXT: <key>col</key><integer>19</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>96</integer> -// CHECK-NEXT: <key>col</key><integer>31</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -2249,12 +1943,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>96</integer> -// CHECK-NEXT: <key>col</key><integer>19</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>96</integer> -// CHECK-NEXT: <key>col</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -2399,40 +2093,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>102</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>102</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>102</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>102</integer> -// CHECK-NEXT: <key>col</key><integer>38</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -2470,12 +2130,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>102</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>102</integer> -// CHECK-NEXT: <key>col</key><integer>38</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -2695,40 +2355,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>109</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>109</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>109</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>109</integer> -// CHECK-NEXT: <key>col</key><integer>35</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -2766,12 +2392,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>109</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>109</integer> -// CHECK-NEXT: <key>col</key><integer>35</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -2882,40 +2508,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>114</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>114</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>114</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>114</integer> -// CHECK-NEXT: <key>col</key><integer>38</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -2953,12 +2545,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>114</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>114</integer> -// CHECK-NEXT: <key>col</key><integer>38</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -3069,40 +2661,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>120</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>120</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>120</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>120</integer> -// CHECK-NEXT: <key>col</key><integer>32</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -3140,12 +2698,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>120</integer> -// CHECK-NEXT: <key>col</key><integer>20</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>120</integer> -// CHECK-NEXT: <key>col</key><integer>32</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -3256,40 +2814,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>125</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>125</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>125</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>125</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -3327,12 +2851,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>125</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>125</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -3443,40 +2967,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>130</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>130</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>130</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>130</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -3514,12 +3004,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>130</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>130</integer> -// CHECK-NEXT: <key>col</key><integer>18</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -3630,40 +3120,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>135</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>135</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>135</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>135</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -3701,12 +3157,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>135</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>135</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -3817,40 +3273,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>140</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>140</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>140</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>140</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -3888,12 +3310,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>140</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>140</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -4038,40 +3460,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -4109,12 +3497,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>170</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -4184,40 +3572,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>175</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>175</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>175</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>175</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -4255,12 +3609,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>175</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>175</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -4330,40 +3684,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>180</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>180</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>180</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>180</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -4401,12 +3721,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>180</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>180</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -4476,40 +3796,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>185</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>185</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>185</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>185</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -4547,12 +3833,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>185</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>185</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -4622,40 +3908,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>190</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>190</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>190</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>190</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -4693,12 +3945,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>190</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>190</integer> -// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -4831,40 +4083,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <string>Method returns an instance of MyObj with a +1 retain count</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>226</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>226</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>226</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>226</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -5171,13 +4389,13 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>226</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>226</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -5192,13 +4410,13 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>start</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>226</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>226</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -5296,6 +4514,35 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: </array> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>215</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>215</integer> +// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>215</integer> +// CHECK-NEXT: <key>col</key><integer>21</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>1</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Method returns an instance of MyObj with a +1 retain count</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Method returns an instance of MyObj with a +1 retain count</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <array> @@ -5316,13 +4563,13 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>215</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>line</key><integer>216</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>215</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> +// CHECK-NEXT: <key>line</key><integer>216</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -5333,35 +4580,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>215</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <key>ranges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>215</integer> -// CHECK-NEXT: <key>col</key><integer>10</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>215</integer> -// CHECK-NEXT: <key>col</key><integer>21</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>depth</key><integer>1</integer> -// CHECK-NEXT: <key>extended_message</key> -// CHECK-NEXT: <string>Method returns an instance of MyObj with a +1 retain count</string> -// CHECK-NEXT: <key>message</key> -// CHECK-NEXT: <string>Method returns an instance of MyObj with a +1 retain count</string> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>event</string> -// CHECK-NEXT: <key>location</key> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>232</integer> // CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -5408,6 +4626,40 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>end</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>237</integer> // CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> @@ -5505,40 +4757,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>247</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>247</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>247</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>247</integer> -// CHECK-NEXT: <key>col</key><integer>38</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -5576,12 +4794,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>247</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>247</integer> -// CHECK-NEXT: <key>col</key><integer>38</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -5801,40 +5019,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>254</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>254</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>254</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>254</integer> -// CHECK-NEXT: <key>col</key><integer>35</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -5872,12 +5056,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>254</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>254</integer> -// CHECK-NEXT: <key>col</key><integer>35</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> @@ -6022,40 +5206,6 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>260</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>260</integer> -// CHECK-NEXT: <key>col</key><integer>11</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>260</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>260</integer> -// CHECK-NEXT: <key>col</key><integer>35</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -6093,12 +5243,12 @@ void CFAutoreleaseUnownedMixed() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>260</integer> -// CHECK-NEXT: <key>col</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>260</integer> -// CHECK-NEXT: <key>col</key><integer>35</integer> +// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> // CHECK-NEXT: </array> diff --git a/test/Analysis/retain-release-safe.c b/test/Analysis/retain-release-safe.c index de743552428c..6cd150093679 100644 --- a/test/Analysis/retain-release-safe.c +++ b/test/Analysis/retain-release-safe.c @@ -1,4 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.coreFoundation.CFRetainRelease,osx.cocoa.RetainCount -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.coreFoundation.CFRetainRelease,osx.cocoa.RetainCount -analyzer-inline-max-stack-depth=0 -verify %s #pragma clang arc_cf_code_audited begin typedef const void * CFTypeRef; @@ -35,6 +36,19 @@ void SafeCFRelease(CFTypeRef CF_CONSUMED cf) { CFRelease(cf); // no-warning (when inlined) } +// The same thing, just with a different naming style. +CFTypeRef retainCFType(CFTypeRef cf) CF_RETURNS_RETAINED { + if (cf) { + return CFRetain(cf); + } + return cf; +} + +void releaseCFType(CFTypeRef CF_CONSUMED cf) { + if (cf) + CFRelease(cf); // no-warning (when inlined) +} + void escape(CFTypeRef cf); void makeSureTestsWork() { @@ -70,3 +84,10 @@ void falseReleaseNotOwned(CFTypeRef cf) { SafeCFRelease(cf); SafeCFRelease(cf); // no-warning after inlining this. } + +void testTheOtherNamingConvention(CFTypeRef cf) { + retainCFType(cf); + retainCFType(cf); + releaseCFType(cf); + releaseCFType(cf); // no-warning +} diff --git a/test/Analysis/retaincountchecker-compoundregion.m b/test/Analysis/retaincountchecker-compoundregion.m new file mode 100644 index 000000000000..d9967b7fabfc --- /dev/null +++ b/test/Analysis/retaincountchecker-compoundregion.m @@ -0,0 +1,25 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx -fblocks -verify -Wno-objc-root-class %s +typedef const void *CFTypeRef; +enum { kCFNumberSInt8Type = 1, kCFNumberSInt16Type = 2, + kCFNumberSInt32Type = 3, kCFNumberSInt64Type = 4, + kCFNumberFloat32Type = 5, kCFNumberFloat64Type = 6, + kCFNumberCharType = 7, kCFNumberShortType = 8, + kCFNumberIntType = 9, kCFNumberLongType = 10, + kCFNumberLongLongType = 11, kCFNumberFloatType = 12, + kCFNumberDoubleType = 13, kCFNumberCFIndexType = 14, + kCFNumberNSIntegerType = 15, kCFNumberCGFloatType = 16, + kCFNumberMaxType = 16 }; +typedef const struct __CFAllocator * CFAllocatorRef; +typedef signed long CFIndex; +typedef CFIndex CFNumberType; +typedef const struct __CFNumber * CFNumberRef; +extern CFNumberRef CFNumberCreate(CFAllocatorRef allocator, CFNumberType theType, const void *valuePtr); + +void foo(CFAllocatorRef allocator) { + int width = 0; + int height = 0; + CFTypeRef* values = (CFTypeRef[]){ + CFNumberCreate(allocator, kCFNumberSInt32Type, &width), //expected-warning-re{{Potential leak of an object{{$}}}} + CFNumberCreate(allocator, kCFNumberSInt32Type, &height), //expected-warning-re{{Potential leak of an object{{$}}}} + }; +} diff --git a/test/Analysis/return-stmt-merge.cpp b/test/Analysis/return-stmt-merge.cpp new file mode 100644 index 000000000000..a6bacc514575 --- /dev/null +++ b/test/Analysis/return-stmt-merge.cpp @@ -0,0 +1,37 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.AnalysisOrder,debug.ExprInspection -analyzer-config debug.AnalysisOrder:PreCall=true,debug.AnalysisOrder:PostCall=true,debug.AnalysisOrder:LiveSymbols=true %s 2>&1 | FileCheck %s + +// This test ensures that check::LiveSymbols is called as many times on the +// path through the second "return" as it is through the first "return" +// (three), and therefore the two paths were not merged prematurely before the +// respective return statement is evaluated. +// The paths would still be merged later, so we'd have only one post-call for +// foo(), but it is incorrect to merge them in the middle of evaluating two +// different statements. +int coin(); + +void foo() { + int x = coin(); + if (x > 0) + return; + else + return; +} + +void bar() { + foo(); +} + +// CHECK: LiveSymbols +// CHECK-NEXT: LiveSymbols +// CHECK-NEXT: PreCall (foo) +// CHECK-NEXT: LiveSymbols +// CHECK-NEXT: LiveSymbols +// CHECK-NEXT: PreCall (coin) +// CHECK-NEXT: PostCall (coin) +// CHECK-NEXT: LiveSymbols +// CHECK-NEXT: LiveSymbols +// CHECK-NEXT: LiveSymbols +// CHECK-NEXT: PostCall (foo) +// CHECK-NEXT: LiveSymbols +// CHECK-NEXT: LiveSymbols +// CHECK-NEXT: LiveSymbols diff --git a/test/Analysis/scopes-cfg-output.cpp b/test/Analysis/scopes-cfg-output.cpp new file mode 100644 index 000000000000..0f2201abb096 --- /dev/null +++ b/test/Analysis/scopes-cfg-output.cpp @@ -0,0 +1,1171 @@ +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -analyze -analyzer-checker=debug.DumpCFG -analyzer-config cfg-scopes=true %s > %t 2>&1 +// RUN: FileCheck --input-file=%t %s + +class A { +public: +// CHECK: [B1 (ENTRY)] +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 + A() {} + +// CHECK: [B1 (ENTRY)] +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 + ~A() {} + +// CHECK: [B2 (ENTRY)] +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B1] +// CHECK-NEXT: 1: 1 +// CHECK-NEXT: 2: return [B1.1]; +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 + operator int() const { return 1; } +}; + +int getX(); +extern const bool UV; + +// CHECK: [B2 (ENTRY)] +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B1] +// CHECK-NEXT: 1: CFGScopeBegin(a) +// CHECK-NEXT: 2: (CXXConstructExpr, [B1.3], class A [2]) +// CHECK-NEXT: 3: A a[2]; +// CHECK-NEXT: 4: (CXXConstructExpr, [B1.5], class A [0]) +// CHECK-NEXT: 5: A b[0]; +// CHECK-NEXT: 6: [B1.3].~A() (Implicit destructor) +// CHECK-NEXT: 7: CFGScopeEnd(a) +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_array() { + A a[2]; + A b[0]; +} + +// CHECK: [B2 (ENTRY)] +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B1] +// CHECK-NEXT: 1: CFGScopeBegin(a) +// CHECK-NEXT: 2: (CXXConstructExpr, [B1.3], class A) +// CHECK-NEXT: 3: A a; +// CHECK-NEXT: 4: CFGScopeBegin(c) +// CHECK-NEXT: 5: (CXXConstructExpr, [B1.6], class A) +// CHECK-NEXT: 6: A c; +// CHECK-NEXT: 7: (CXXConstructExpr, [B1.8], class A) +// CHECK-NEXT: 8: A d; +// CHECK-NEXT: 9: [B1.8].~A() (Implicit destructor) +// CHECK-NEXT: 10: [B1.6].~A() (Implicit destructor) +// CHECK-NEXT: 11: CFGScopeEnd(c) +// CHECK-NEXT: 12: (CXXConstructExpr, [B1.13], class A) +// CHECK-NEXT: 13: A b; +// CHECK-NEXT: 14: [B1.13].~A() (Implicit destructor) +// CHECK-NEXT: 15: [B1.3].~A() (Implicit destructor) +// CHECK-NEXT: 16: CFGScopeEnd(a) +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_scope() { + A a; + { A c; + A d; + } + A b; +} + +// CHECK: [B4 (ENTRY)] +// CHECK-NEXT: Succs (1): B3 +// CHECK: [B1] +// CHECK-NEXT: 1: (CXXConstructExpr, [B1.2], class A) +// CHECK-NEXT: 2: A c; +// CHECK-NEXT: 3: [B1.2].~A() (Implicit destructor) +// CHECK-NEXT: 4: [B3.5].~A() (Implicit destructor) +// CHECK-NEXT: 5: [B3.3].~A() (Implicit destructor) +// CHECK-NEXT: 6: CFGScopeEnd(a) +// CHECK-NEXT: Preds (1): B3 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: 1: return; +// CHECK-NEXT: 2: [B3.5].~A() (Implicit destructor) +// CHECK-NEXT: 3: [B3.3].~A() (Implicit destructor) +// CHECK-NEXT: 4: CFGScopeEnd(a) +// CHECK-NEXT: Preds (1): B3 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B3] +// CHECK-NEXT: 1: CFGScopeBegin(a) +// CHECK-NEXT: 2: (CXXConstructExpr, [B3.3], class A) +// CHECK-NEXT: 3: A a; +// CHECK-NEXT: 4: (CXXConstructExpr, [B3.5], class A) +// CHECK-NEXT: 5: A b; +// CHECK-NEXT: 6: UV +// CHECK-NEXT: 7: [B3.6] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: if [B3.7] +// CHECK-NEXT: Preds (1): B4 +// CHECK-NEXT: Succs (2): B2 B1 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (2): B1 B2 +void test_return() { + A a; + A b; + if (UV) return; + A c; +} + +// CHECK: [B5 (ENTRY)] +// CHECK-NEXT: Succs (1): B4 +// CHECK: [B1] +// CHECK-NEXT: 1: [B4.8].~A() (Implicit destructor) +// CHECK-NEXT: 2: CFGScopeEnd(b) +// CHECK-NEXT: 3: [B4.3].~A() (Implicit destructor) +// CHECK-NEXT: 4: CFGScopeEnd(a) +// CHECK-NEXT: Preds (2): B2 B3 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: 1: CFGScopeBegin(c) +// CHECK-NEXT: 2: (CXXConstructExpr, [B2.3], class A) +// CHECK-NEXT: 3: A c; +// CHECK-NEXT: 4: [B2.3].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(c) +// CHECK-NEXT: Preds (1): B4 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B3] +// CHECK-NEXT: 1: CFGScopeBegin(c) +// CHECK-NEXT: 2: (CXXConstructExpr, [B3.3], class A) +// CHECK-NEXT: 3: A c; +// CHECK-NEXT: 4: [B3.3].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(c) +// CHECK-NEXT: Preds (1): B4 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B4] +// CHECK-NEXT: 1: CFGScopeBegin(a) +// CHECK-NEXT: 2: (CXXConstructExpr, [B4.3], class A) +// CHECK-NEXT: 3: A a; +// CHECK-NEXT: 4: CFGScopeBegin(b) +// CHECK-NEXT: 5: a +// CHECK-NEXT: 6: [B4.5] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 7: [B4.6] (CXXConstructExpr, [B4.8], class A) +// CHECK-NEXT: 8: A b = a; +// CHECK-NEXT: 9: b +// CHECK-NEXT: 10: [B4.9] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 11: [B4.10].operator int +// CHECK-NEXT: 12: [B4.10] +// CHECK-NEXT: 13: [B4.12] (ImplicitCastExpr, UserDefinedConversion, int) +// CHECK-NEXT: 14: [B4.13] (ImplicitCastExpr, IntegralToBoolean, _Bool) +// CHECK-NEXT: T: if [B4.14] +// CHECK-NEXT: Preds (1): B5 +// CHECK-NEXT: Succs (2): B3 B2 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_if_implicit_scope() { + A a; + if (A b = a) + A c; + else A c; +} + +// CHECK: [B9 (ENTRY)] +// CHECK-NEXT: Succs (1): B8 +// CHECK: [B1] +// CHECK-NEXT: 1: [B8.8].~A() (Implicit destructor) +// CHECK-NEXT: 2: CFGScopeEnd(b) +// CHECK-NEXT: 3: (CXXConstructExpr, [B1.4], class A) +// CHECK-NEXT: 4: A e; +// CHECK-NEXT: 5: [B1.4].~A() (Implicit destructor) +// CHECK-NEXT: 6: [B8.3].~A() (Implicit destructor) +// CHECK-NEXT: 7: CFGScopeEnd(a) +// CHECK-NEXT: Preds (2): B2 B5 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: 1: (CXXConstructExpr, [B2.2], class A) +// CHECK-NEXT: 2: A d; +// CHECK-NEXT: 3: [B2.2].~A() (Implicit destructor) +// CHECK-NEXT: 4: [B4.3].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(c) +// CHECK-NEXT: Preds (1): B4 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B3] +// CHECK-NEXT: 1: return; +// CHECK-NEXT: 2: [B4.3].~A() (Implicit destructor) +// CHECK-NEXT: 3: CFGScopeEnd(c) +// CHECK-NEXT: 4: [B8.8].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(b) +// CHECK-NEXT: 6: [B8.3].~A() (Implicit destructor) +// CHECK-NEXT: 7: CFGScopeEnd(a) +// CHECK-NEXT: Preds (1): B4 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B4] +// CHECK-NEXT: 1: CFGScopeBegin(c) +// CHECK-NEXT: 2: (CXXConstructExpr, [B4.3], class A) +// CHECK-NEXT: 3: A c; +// CHECK-NEXT: 4: UV +// CHECK-NEXT: 5: [B4.4] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: if [B4.5] +// CHECK-NEXT: Preds (1): B8 +// CHECK-NEXT: Succs (2): B3 B2 +// CHECK: [B5] +// CHECK-NEXT: 1: (CXXConstructExpr, [B5.2], class A) +// CHECK-NEXT: 2: A d; +// CHECK-NEXT: 3: [B5.2].~A() (Implicit destructor) +// CHECK-NEXT: 4: [B7.3].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(c) +// CHECK-NEXT: Preds (1): B7 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B6] +// CHECK-NEXT: 1: return; +// CHECK-NEXT: 2: [B7.3].~A() (Implicit destructor) +// CHECK-NEXT: 3: CFGScopeEnd(c) +// CHECK-NEXT: 4: [B8.8].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(b) +// CHECK-NEXT: 6: [B8.3].~A() (Implicit destructor) +// CHECK-NEXT: 7: CFGScopeEnd(a) +// CHECK-NEXT: Preds (1): B7 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B7] +// CHECK-NEXT: 1: CFGScopeBegin(c) +// CHECK-NEXT: 2: (CXXConstructExpr, [B7.3], class A) +// CHECK-NEXT: 3: A c; +// CHECK-NEXT: 4: UV +// CHECK-NEXT: 5: [B7.4] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: if [B7.5] +// CHECK-NEXT: Preds (1): B8 +// CHECK-NEXT: Succs (2): B6 B5 +// CHECK: [B8] +// CHECK-NEXT: 1: CFGScopeBegin(a) +// CHECK-NEXT: 2: (CXXConstructExpr, [B8.3], class A) +// CHECK-NEXT: 3: A a; +// CHECK-NEXT: 4: CFGScopeBegin(b) +// CHECK-NEXT: 5: a +// CHECK-NEXT: 6: [B8.5] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 7: [B8.6] (CXXConstructExpr, [B8.8], class A) +// CHECK-NEXT: 8: A b = a; +// CHECK-NEXT: 9: b +// CHECK-NEXT: 10: [B8.9] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 11: [B8.10].operator int +// CHECK-NEXT: 12: [B8.10] +// CHECK-NEXT: 13: [B8.12] (ImplicitCastExpr, UserDefinedConversion, int) +// CHECK-NEXT: 14: [B8.13] (ImplicitCastExpr, IntegralToBoolean, _Bool) +// CHECK-NEXT: T: if [B8.14] +// CHECK-NEXT: Preds (1): B9 +// CHECK-NEXT: Succs (2): B7 B4 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (3): B1 B3 B6 +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; +} + +// CHECK: [B6 (ENTRY)] +// CHECK-NEXT: Succs (1): B5 +// CHECK: [B1] +// CHECK-NEXT: 1: [B4.5].~A() (Implicit destructor) +// CHECK-NEXT: 2: CFGScopeEnd(b) +// CHECK-NEXT: 3: [B5.3].~A() (Implicit destructor) +// CHECK-NEXT: 4: CFGScopeEnd(a) +// CHECK-NEXT: Preds (1): B4 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: Preds (1): B3 +// CHECK-NEXT: Succs (1): B4 +// CHECK: [B3] +// CHECK-NEXT: 1: CFGScopeBegin(c) +// CHECK-NEXT: 2: (CXXConstructExpr, [B3.3], class A) +// CHECK-NEXT: 3: A c; +// CHECK-NEXT: 4: [B3.3].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(c) +// CHECK-NEXT: 6: [B4.5].~A() (Implicit destructor) +// CHECK-NEXT: 7: CFGScopeEnd(b) +// CHECK-NEXT: Preds (1): B4 +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B4] +// CHECK-NEXT: 1: CFGScopeBegin(b) +// CHECK-NEXT: 2: a +// CHECK-NEXT: 3: [B4.2] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 4: [B4.3] (CXXConstructExpr, [B4.5], class A) +// CHECK-NEXT: 5: A b = a; +// CHECK-NEXT: 6: b +// CHECK-NEXT: 7: [B4.6] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 8: [B4.7].operator int +// CHECK-NEXT: 9: [B4.7] +// CHECK-NEXT: 10: [B4.9] (ImplicitCastExpr, UserDefinedConversion, int) +// CHECK-NEXT: 11: [B4.10] (ImplicitCastExpr, IntegralToBoolean, _Bool) +// CHECK-NEXT: T: while [B4.11] +// CHECK-NEXT: Preds (2): B2 B5 +// CHECK-NEXT: Succs (2): B3 B1 +// CHECK: [B5] +// CHECK-NEXT: 1: CFGScopeBegin(a) +// CHECK-NEXT: 2: (CXXConstructExpr, [B5.3], class A) +// CHECK-NEXT: 3: A a; +// CHECK-NEXT: Preds (1): B6 +// CHECK-NEXT: Succs (1): B4 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_while_implicit_scope() { + A a; + while (A b = a) + A c; +} + +// CHECK: [B12 (ENTRY)] +// CHECK-NEXT: Succs (1): B11 +// CHECK: [B1] +// CHECK-NEXT: 1: [B10.5].~A() (Implicit destructor) +// CHECK-NEXT: 2: CFGScopeEnd(b) +// CHECK-NEXT: 3: (CXXConstructExpr, [B1.4], class A) +// CHECK-NEXT: 4: A e; +// CHECK-NEXT: 5: [B1.4].~A() (Implicit destructor) +// CHECK-NEXT: 6: [B11.3].~A() (Implicit destructor) +// CHECK-NEXT: 7: CFGScopeEnd(a) +// CHECK-NEXT: Preds (2): B8 B10 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: Preds (2): B3 B6 +// CHECK-NEXT: Succs (1): B10 +// CHECK: [B3] +// CHECK-NEXT: 1: (CXXConstructExpr, [B3.2], class A) +// CHECK-NEXT: 2: A d; +// CHECK-NEXT: 3: [B3.2].~A() (Implicit destructor) +// CHECK-NEXT: 4: [B9.3].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(c) +// CHECK-NEXT: 6: [B10.5].~A() (Implicit destructor) +// CHECK-NEXT: 7: CFGScopeEnd(b) +// CHECK-NEXT: Preds (1): B5 +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B4] +// CHECK-NEXT: 1: return; +// CHECK-NEXT: 2: [B9.3].~A() (Implicit destructor) +// CHECK-NEXT: 3: CFGScopeEnd(c) +// CHECK-NEXT: 4: [B10.5].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(b) +// CHECK-NEXT: 6: [B11.3].~A() (Implicit destructor) +// CHECK-NEXT: 7: CFGScopeEnd(a) +// CHECK-NEXT: Preds (1): B5 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B5] +// CHECK-NEXT: 1: UV +// CHECK-NEXT: 2: [B5.1] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: if [B5.2] +// CHECK-NEXT: Preds (1): B7 +// CHECK-NEXT: Succs (2): B4 B3 +// CHECK: [B6] +// CHECK-NEXT: 1: [B9.3].~A() (Implicit destructor) +// CHECK-NEXT: 2: CFGScopeEnd(c) +// CHECK-NEXT: 3: [B10.5].~A() (Implicit destructor) +// CHECK-NEXT: 4: CFGScopeEnd(b) +// CHECK-NEXT: T: continue; +// CHECK-NEXT: Preds (1): B7 +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B7] +// CHECK-NEXT: 1: UV +// CHECK-NEXT: 2: [B7.1] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: if [B7.2] +// CHECK-NEXT: Preds (1): B9 +// CHECK-NEXT: Succs (2): B6 B5 +// CHECK: [B8] +// CHECK-NEXT: 1: [B9.3].~A() (Implicit destructor) +// CHECK-NEXT: 2: CFGScopeEnd(c) +// CHECK-NEXT: T: break; +// CHECK-NEXT: Preds (1): B9 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B9] +// CHECK-NEXT: 1: CFGScopeBegin(c) +// CHECK-NEXT: 2: (CXXConstructExpr, [B9.3], class A) +// CHECK-NEXT: 3: A c; +// CHECK-NEXT: 4: UV +// CHECK-NEXT: 5: [B9.4] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: if [B9.5] +// CHECK-NEXT: Preds (1): B10 +// CHECK-NEXT: Succs (2): B8 B7 +// CHECK: [B10] +// CHECK-NEXT: 1: CFGScopeBegin(b) +// CHECK-NEXT: 2: a +// CHECK-NEXT: 3: [B10.2] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 4: [B10.3] (CXXConstructExpr, [B10.5], class A) +// CHECK-NEXT: 5: A b = a; +// CHECK-NEXT: 6: b +// CHECK-NEXT: 7: [B10.6] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 8: [B10.7].operator int +// CHECK-NEXT: 9: [B10.7] +// CHECK-NEXT: 10: [B10.9] (ImplicitCastExpr, UserDefinedConversion, int) +// CHECK-NEXT: 11: [B10.10] (ImplicitCastExpr, IntegralToBoolean, _Bool) +// CHECK-NEXT: T: while [B10.11] +// CHECK-NEXT: Preds (2): B2 B11 +// CHECK-NEXT: Succs (2): B9 B1 +// CHECK: [B11] +// CHECK-NEXT: 1: CFGScopeBegin(a) +// CHECK-NEXT: 2: (CXXConstructExpr, [B11.3], class A) +// CHECK-NEXT: 3: A a; +// CHECK-NEXT: Preds (1): B12 +// CHECK-NEXT: Succs (1): B10 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (2): B1 B4 +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; +} + +// CHECK: [B12 (ENTRY)] +// CHECK-NEXT: Succs (1): B11 +// CHECK: [B1] +// CHECK-NEXT: 1: (CXXConstructExpr, [B1.2], class A) +// CHECK-NEXT: 2: A d; +// CHECK-NEXT: 3: [B1.2].~A() (Implicit destructor) +// CHECK-NEXT: 4: [B11.3].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(a) +// CHECK-NEXT: Preds (2): B8 B2 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: 1: UV +// CHECK-NEXT: 2: [B2.1] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: do ... while [B2.2] +// CHECK-NEXT: Preds (2): B3 B6 +// CHECK-NEXT: Succs (2): B10 B1 +// CHECK: [B3] +// CHECK-NEXT: 1: (CXXConstructExpr, [B3.2], class A) +// CHECK-NEXT: 2: A c; +// CHECK-NEXT: 3: [B3.2].~A() (Implicit destructor) +// CHECK-NEXT: 4: [B9.3].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(b) +// CHECK-NEXT: Preds (1): B5 +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B4] +// CHECK-NEXT: 1: return; +// CHECK-NEXT: 2: [B9.3].~A() (Implicit destructor) +// CHECK-NEXT: 3: CFGScopeEnd(b) +// CHECK-NEXT: 4: [B11.3].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(a) +// CHECK-NEXT: Preds (1): B5 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B5] +// CHECK-NEXT: 1: UV +// CHECK-NEXT: 2: [B5.1] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: if [B5.2] +// CHECK-NEXT: Preds (1): B7 +// CHECK-NEXT: Succs (2): B4 B3 +// CHECK: [B6] +// CHECK-NEXT: 1: [B9.3].~A() (Implicit destructor) +// CHECK-NEXT: 2: CFGScopeEnd(b) +// CHECK-NEXT: T: continue; +// CHECK-NEXT: Preds (1): B7 +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B7] +// CHECK-NEXT: 1: UV +// CHECK-NEXT: 2: [B7.1] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: if [B7.2] +// CHECK-NEXT: Preds (1): B9 +// CHECK-NEXT: Succs (2): B6 B5 +// CHECK: [B8] +// CHECK-NEXT: 1: [B9.3].~A() (Implicit destructor) +// CHECK-NEXT: 2: CFGScopeEnd(b) +// CHECK-NEXT: T: break; +// CHECK-NEXT: Preds (1): B9 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B9] +// CHECK-NEXT: 1: CFGScopeBegin(b) +// CHECK-NEXT: 2: (CXXConstructExpr, [B9.3], class A) +// CHECK-NEXT: 3: A b; +// CHECK-NEXT: 4: UV +// CHECK-NEXT: 5: [B9.4] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: if [B9.5] +// CHECK-NEXT: Preds (2): B10 B11 +// CHECK-NEXT: Succs (2): B8 B7 +// CHECK: [B10] +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B9 +// CHECK: [B11] +// CHECK-NEXT: 1: CFGScopeBegin(a) +// CHECK-NEXT: 2: (CXXConstructExpr, [B11.3], class A) +// CHECK-NEXT: 3: A a; +// CHECK-NEXT: Preds (1): B12 +// CHECK-NEXT: Succs (1): B9 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (2): B1 B4 +void test_do_jumps() { + A a; + do { + A b; + if (UV) break; + if (UV) continue; + if (UV) return; + A c; + } while (UV); + A d; +} + +// CHECK: [B6 (ENTRY)] +// CHECK-NEXT: Succs (1): B5 +// CHECK: [B1] +// CHECK-NEXT: 1: [B4.5].~A() (Implicit destructor) +// CHECK-NEXT: 2: CFGScopeEnd(b) +// CHECK-NEXT: 3: [B5.3].~A() (Implicit destructor) +// CHECK-NEXT: 4: CFGScopeEnd(a) +// CHECK-NEXT: Preds (1): B4 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: Preds (1): B3 +// CHECK-NEXT: Succs (1): B4 +// CHECK: [B3] +// CHECK-NEXT: 1: CFGScopeBegin(c) +// CHECK-NEXT: 2: (CXXConstructExpr, [B3.3], class A) +// CHECK-NEXT: 3: A c; +// CHECK-NEXT: 4: [B3.3].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(c) +// CHECK-NEXT: 6: [B4.5].~A() (Implicit destructor) +// CHECK-NEXT: 7: CFGScopeEnd(b) +// CHECK-NEXT: Preds (1): B4 +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B4] +// CHECK-NEXT: 1: CFGScopeBegin(b) +// CHECK-NEXT: 2: a +// CHECK-NEXT: 3: [B4.2] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 4: [B4.3] (CXXConstructExpr, [B4.5], class A) +// CHECK-NEXT: 5: A b = a; +// CHECK-NEXT: 6: b +// CHECK-NEXT: 7: [B4.6] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 8: [B4.7].operator int +// CHECK-NEXT: 9: [B4.7] +// CHECK-NEXT: 10: [B4.9] (ImplicitCastExpr, UserDefinedConversion, int) +// CHECK-NEXT: 11: [B4.10] (ImplicitCastExpr, IntegralToBoolean, _Bool) +// CHECK-NEXT: T: for (...; [B4.11]; ) +// CHECK-NEXT: Preds (2): B2 B5 +// CHECK-NEXT: Succs (2): B3 B1 +// CHECK: [B5] +// CHECK-NEXT: 1: CFGScopeBegin(a) +// CHECK-NEXT: 2: (CXXConstructExpr, [B5.3], class A) +// CHECK-NEXT: 3: A a; +// CHECK-NEXT: Preds (1): B6 +// CHECK-NEXT: Succs (1): B4 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_for_implicit_scope() { + for (A a; A b = a; ) + A c; +} + +// CHECK: [B12 (ENTRY)] +// CHECK-NEXT: Succs (1): B11 +// CHECK: [B1] +// CHECK-NEXT: 1: [B10.5].~A() (Implicit destructor) +// CHECK-NEXT: 2: CFGScopeEnd(c) +// CHECK-NEXT: 3: [B11.6].~A() (Implicit destructor) +// CHECK-NEXT: 4: CFGScopeEnd(b) +// CHECK-NEXT: 5: (CXXConstructExpr, [B1.6], class A) +// CHECK-NEXT: 6: A f; +// CHECK-NEXT: 7: [B1.6].~A() (Implicit destructor) +// CHECK-NEXT: 8: [B11.3].~A() (Implicit destructor) +// CHECK-NEXT: 9: CFGScopeEnd(a) +// CHECK-NEXT: Preds (2): B8 B10 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: Preds (2): B3 B6 +// CHECK-NEXT: Succs (1): B10 +// CHECK: [B3] +// CHECK-NEXT: 1: (CXXConstructExpr, [B3.2], class A) +// CHECK-NEXT: 2: A e; +// CHECK-NEXT: 3: [B3.2].~A() (Implicit destructor) +// CHECK-NEXT: 4: [B9.3].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(d) +// CHECK-NEXT: 6: [B10.5].~A() (Implicit destructor) +// CHECK-NEXT: 7: CFGScopeEnd(c) +// CHECK-NEXT: Preds (1): B5 +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B4] +// CHECK-NEXT: 1: return; +// CHECK-NEXT: 2: [B9.3].~A() (Implicit destructor) +// CHECK-NEXT: 3: CFGScopeEnd(d) +// CHECK-NEXT: 4: [B10.5].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(c) +// CHECK-NEXT: 6: [B11.6].~A() (Implicit destructor) +// CHECK-NEXT: 7: CFGScopeEnd(b) +// CHECK-NEXT: 8: [B11.3].~A() (Implicit destructor) +// CHECK-NEXT: 9: CFGScopeEnd(a) +// CHECK-NEXT: Preds (1): B5 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B5] +// CHECK-NEXT: 1: UV +// CHECK-NEXT: 2: [B5.1] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: if [B5.2] +// CHECK-NEXT: Preds (1): B7 +// CHECK-NEXT: Succs (2): B4 B3 +// CHECK: [B6] +// CHECK-NEXT: 1: [B9.3].~A() (Implicit destructor) +// CHECK-NEXT: 2: CFGScopeEnd(d) +// CHECK-NEXT: T: continue; +// CHECK-NEXT: Preds (1): B7 +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B7] +// CHECK-NEXT: 1: UV +// CHECK-NEXT: 2: [B7.1] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: if [B7.2] +// CHECK-NEXT: Preds (1): B9 +// CHECK-NEXT: Succs (2): B6 B5 +// CHECK: [B8] +// CHECK-NEXT: 1: [B9.3].~A() (Implicit destructor) +// CHECK-NEXT: 2: CFGScopeEnd(d) +// CHECK-NEXT: T: break; +// CHECK-NEXT: Preds (1): B9 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B9] +// CHECK-NEXT: 1: CFGScopeBegin(d) +// CHECK-NEXT: 2: (CXXConstructExpr, [B9.3], class A) +// CHECK-NEXT: 3: A d; +// CHECK-NEXT: 4: UV +// CHECK-NEXT: 5: [B9.4] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: if [B9.5] +// CHECK-NEXT: Preds (1): B10 +// CHECK-NEXT: Succs (2): B8 B7 +// CHECK: [B10] +// CHECK-NEXT: 1: CFGScopeBegin(c) +// CHECK-NEXT: 2: b +// CHECK-NEXT: 3: [B10.2] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 4: [B10.3] (CXXConstructExpr, [B10.5], class A) +// CHECK-NEXT: 5: A c = b; +// CHECK-NEXT: 6: c +// CHECK-NEXT: 7: [B10.6] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 8: [B10.7].operator int +// CHECK-NEXT: 9: [B10.7] +// CHECK-NEXT: 10: [B10.9] (ImplicitCastExpr, UserDefinedConversion, int) +// CHECK-NEXT: 11: [B10.10] (ImplicitCastExpr, IntegralToBoolean, _Bool) +// CHECK-NEXT: T: for (...; [B10.11]; ) +// CHECK-NEXT: Preds (2): B2 B11 +// CHECK-NEXT: Succs (2): B9 B1 +// CHECK: [B11] +// CHECK-NEXT: 1: CFGScopeBegin(a) +// CHECK-NEXT: 2: (CXXConstructExpr, [B11.3], class A) +// CHECK-NEXT: 3: A a; +// CHECK-NEXT: 4: CFGScopeBegin(b) +// CHECK-NEXT: 5: (CXXConstructExpr, [B11.6], class A) +// CHECK-NEXT: 6: A b; +// CHECK-NEXT: Preds (1): B12 +// CHECK-NEXT: Succs (1): B10 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (2): B1 B4 +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; +} + +// CHECK: [B8 (ENTRY)] +// CHECK-NEXT: Succs (1): B7 +// CHECK: [B1] +// CHECK-NEXT: l1: +// CHECK-NEXT: 1: (CXXConstructExpr, [B1.2], class A) +// CHECK-NEXT: 2: A c; +// CHECK-NEXT: 3: [B1.2].~A() (Implicit destructor) +// CHECK-NEXT: 4: [B6.5].~A() (Implicit destructor) +// CHECK-NEXT: 5: [B6.3].~A() (Implicit destructor) +// CHECK-NEXT: 6: [B7.3].~A() (Implicit destructor) +// CHECK-NEXT: 7: CFGScopeEnd(a) +// CHECK-NEXT: Preds (2): B2 B3 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: 1: (CXXConstructExpr, [B2.2], class A) +// CHECK-NEXT: 2: A b; +// CHECK-NEXT: 3: [B2.2].~A() (Implicit destructor) +// CHECK-NEXT: 4: [B6.8].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(a) +// CHECK-NEXT: Preds (1): B4 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B3] +// CHECK-NEXT: 1: [B6.8].~A() (Implicit destructor) +// CHECK-NEXT: 2: CFGScopeEnd(a) +// CHECK-NEXT: T: goto l1; +// CHECK-NEXT: Preds (1): B4 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B4] +// CHECK-NEXT: 1: UV +// CHECK-NEXT: 2: [B4.1] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: if [B4.2] +// CHECK-NEXT: Preds (1): B6 +// CHECK-NEXT: Succs (2): B3 B2 +// CHECK: [B5] +// CHECK-NEXT: 1: [B6.8].~A() (Implicit destructor) +// CHECK-NEXT: 2: [B6.5].~A() (Implicit destructor) +// CHECK-NEXT: 3: [B6.3].~A() (Implicit destructor) +// CHECK-NEXT: 4: CFGScopeEnd(cb) +// CHECK-NEXT: T: goto l0; +// CHECK-NEXT: Preds (1): B6 +// CHECK-NEXT: Succs (1): B6 +// CHECK: [B6] +// CHECK-NEXT: l0: +// CHECK-NEXT: 1: CFGScopeBegin(cb) +// CHECK-NEXT: 2: (CXXConstructExpr, [B6.3], class A) +// CHECK-NEXT: 3: A cb; +// CHECK-NEXT: 4: (CXXConstructExpr, [B6.5], class A) +// CHECK-NEXT: 5: A b; +// CHECK-NEXT: 6: CFGScopeBegin(a) +// CHECK-NEXT: 7: (CXXConstructExpr, [B6.8], class A) +// CHECK-NEXT: 8: A a; +// CHECK-NEXT: 9: UV +// CHECK-NEXT: 10: [B6.9] (ImplicitCastExpr, LValueToRValue, _Bool) +// CHECK-NEXT: T: if [B6.10] +// CHECK-NEXT: Preds (2): B7 B5 +// CHECK-NEXT: Succs (2): B5 B4 +// CHECK: [B7] +// CHECK-NEXT: 1: CFGScopeBegin(a) +// CHECK-NEXT: 2: (CXXConstructExpr, [B7.3], class A) +// CHECK-NEXT: 3: A a; +// CHECK-NEXT: Preds (1): B8 +// CHECK-NEXT: Succs (1): B6 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_goto() { + A a; +l0: + A cb; + A b; + { A a; + if (UV) goto l0; + if (UV) goto l1; + A b; + } +l1: + A c; +} + +// CHECK: [B7 (ENTRY)] +// CHECK-NEXT: Succs (1): B6 +// CHECK: [B1] +// CHECK-NEXT: 1: CFGScopeEnd(i) +// CHECK-NEXT: 2: CFGScopeBegin(unused2) +// CHECK-NEXT: 3: int unused2; +// CHECK-NEXT: 4: CFGScopeEnd(unused2) +// CHECK-NEXT: Preds (2): B4 B5 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: 1: i +// CHECK-NEXT: 2: ++[B2.1] +// CHECK-NEXT: Preds (1): B3 +// CHECK-NEXT: Succs (1): B5 +// CHECK: [B3] +// CHECK-NEXT: 1: CFGScopeEnd(unused1) +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B4] +// CHECK-NEXT: 1: CFGScopeBegin(unused1) +// CHECK-NEXT: 2: int unused1; +// CHECK-NEXT: 3: CFGScopeEnd(unused1) +// CHECK-NEXT: T: break; +// CHECK-NEXT: Preds (1): B5 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B5] +// CHECK-NEXT: 1: i +// CHECK-NEXT: 2: [B5.1] (ImplicitCastExpr, LValueToRValue, int) +// CHECK-NEXT: 3: 3 +// CHECK-NEXT: 4: [B5.2] < [B5.3] +// CHECK-NEXT: T: for (...; [B5.4]; ...) +// CHECK-NEXT: Preds (2): B2 B6 +// CHECK-NEXT: Succs (2): B4 B1 +// CHECK: [B6] +// CHECK-NEXT: 1: CFGScopeBegin(i) +// CHECK-NEXT: 2: 0 +// CHECK-NEXT: 3: int i = 0; +// CHECK-NEXT: Preds (1): B7 +// CHECK-NEXT: Succs (1): B5 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_for_compound_and_break() { + for (int i = 0; i < 3; ++i) { + { + int unused1; + break; + } + } + { + int unused2; + } +} + +// CHECK: [B6 (ENTRY)] +// CHECK-NEXT: Succs (1): B5 +// CHECK: [B1] +// CHECK-NEXT: 1: CFGScopeEnd(__end1) +// CHECK-NEXT: 2: CFGScopeEnd(__begin1) +// CHECK-NEXT: 3: CFGScopeEnd(__range1) +// CHECK-NEXT: 4: [B5.3].~A() (Implicit destructor) +// CHECK-NEXT: 5: CFGScopeEnd(a) +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: 1: __begin1 +// CHECK-NEXT: 2: [B2.1] (ImplicitCastExpr, LValueToRValue, class A *) +// CHECK-NEXT: 3: __end1 +// CHECK-NEXT: 4: [B2.3] (ImplicitCastExpr, LValueToRValue, class A *) +// CHECK-NEXT: 5: [B2.2] != [B2.4] +// CHECK-NEXT: T: for (auto &i : [B5.4]) { +// CHECK: [B4.11]; +// CHECK-NEXT:} +// CHECK-NEXT: Preds (2): B3 B5 +// CHECK-NEXT: Succs (2): B4 B1 +// CHECK: [B3] +// CHECK-NEXT: 1: __begin1 +// CHECK-NEXT: 2: ++[B3.1] +// CHECK-NEXT: Preds (1): B4 +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B4] +// CHECK-NEXT: 1: CFGScopeBegin(i) +// CHECK-NEXT: 2: __begin1 +// CHECK-NEXT: 3: [B4.2] (ImplicitCastExpr, LValueToRValue, class A *) +// CHECK-NEXT: 4: *[B4.3] +// CHECK-NEXT: 5: auto &i = *__begin1; +// CHECK-NEXT: 6: operator= +// CHECK-NEXT: 7: [B4.6] (ImplicitCastExpr, FunctionToPointerDecay, class A &(*)(const class A &) +// CHECK-NEXT: 8: i +// CHECK-NEXT: 9: b +// CHECK-NEXT: 10: [B4.9] (ImplicitCastExpr, NoOp, const class A) +// CHECK-NEXT: 11: [B4.8] = [B4.10] (OperatorCall) +// CHECK-NEXT: 12: CFGScopeEnd(i) +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B3 +// CHECK: [B5] +// CHECK-NEXT: 1: CFGScopeBegin(a) +// CHECK-NEXT: 2: (CXXConstructExpr, [B5.3], class A [10]) +// CHECK-NEXT: 3: A a[10]; +// CHECK-NEXT: 4: a +// CHECK-NEXT: 5: auto &&__range1 = a; +// CHECK-NEXT: 6: CFGScopeBegin(__end1) +// CHECK-NEXT: 7: __range1 +// CHECK-NEXT: 8: [B5.7] (ImplicitCastExpr, ArrayToPointerDecay, class A *) +// CHECK-NEXT: 9: 10 +// CHECK-NEXT: 10: [B5.8] + [B5.9] +// CHECK-NEXT: 11: auto __end1 = __range1 + 10 +// CHECK-NEXT: 12: __range1 +// CHECK-NEXT: 13: [B5.12] (ImplicitCastExpr, ArrayToPointerDecay, class A *) +// CHECK-NEXT: 14: auto __begin1 = __range1; +// CHECK-NEXT: Preds (1): B6 +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_range_for(A &b) { + A a[10]; + for (auto &i : a) + i = b; +} + +// CHECK: [B8 (ENTRY)] +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B1] +// CHECK-NEXT: 1: CFGScopeEnd(i) +// CHECK-NEXT: 2: 1 +// CHECK-NEXT: 3: int k = 1; +// CHECK-NEXT: 4: CFGScopeEnd(c) +// CHECK-NEXT: Preds (3): B3 B5 B6 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: 1: CFGScopeBegin(c) +// CHECK-NEXT: 2: '1' +// CHECK-NEXT: 3: char c = '1'; +// CHECK-NEXT: 4: CFGScopeBegin(i) +// CHECK-NEXT: 5: getX +// CHECK-NEXT: 6: [B2.5] (ImplicitCastExpr, FunctionToPointerDecay, int (*)(void)) +// CHECK-NEXT: 7: [B2.6]() +// CHECK-NEXT: 8: int i = getX(); +// CHECK-NEXT: 9: i +// CHECK-NEXT: 10: [B2.9] (ImplicitCastExpr, LValueToRValue, int) +// CHECK-NEXT: T: switch [B2.10] +// CHECK-NEXT: Preds (1): B8 +// CHECK-NEXT: Succs (5): B4 B5 B6 B7 B3 +// CHECK: [B3] +// CHECK-NEXT: default: +// CHECK-NEXT: 1: CFGScopeBegin(a) +// CHECK-NEXT: 2: 0 +// CHECK-NEXT: 3: int a = 0; +// CHECK-NEXT: 4: i +// CHECK-NEXT: 5: ++[B3.4] +// CHECK-NEXT: 6: CFGScopeEnd(a) +// CHECK-NEXT: Preds (2): B4 B2 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B4] +// CHECK-NEXT: case 3: +// CHECK-NEXT: 1: '2' +// CHECK-NEXT: 2: c +// CHECK-NEXT: 3: [B4.2] = [B4.1] +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B3 +// CHECK: [B5] +// CHECK-NEXT: case 2: +// CHECK-NEXT: 1: '2' +// CHECK-NEXT: 2: c +// CHECK-NEXT: 3: [B5.2] = [B5.1] +// CHECK-NEXT: T: break; +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B6] +// CHECK-NEXT: case 1: +// CHECK-NEXT: 1: '3' +// CHECK-NEXT: 2: c +// CHECK-NEXT: 3: [B6.2] = [B6.1] +// CHECK-NEXT: T: break; +// CHECK-NEXT: Preds (2): B2 B7 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B7] +// CHECK-NEXT: case 0: +// CHECK-NEXT: 1: '2' +// CHECK-NEXT: 2: c +// CHECK-NEXT: 3: [B7.2] = [B7.1] +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B6 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_switch_with_compound_with_default() { + char c = '1'; + switch (int i = getX()) { + case 0: + c = '2'; + case 1: + c = '3'; + break; + case 2: { + c = '2'; + break; + } + case 3: + c = '2'; + default: { + int a = 0; + ++i; + } + } + int k = 1; +} + +// CHECK: [B6 (ENTRY)] +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B1] +// CHECK-NEXT: 1: CFGScopeEnd(i) +// CHECK-NEXT: 2: 3 +// CHECK-NEXT: 3: int k = 3; +// CHECK-NEXT: 4: CFGScopeEnd(c) +// CHECK-NEXT: Preds (3): B3 B4 B2 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: 1: CFGScopeBegin(c) +// CHECK-NEXT: 2: '1' +// CHECK-NEXT: 3: char c = '1'; +// CHECK-NEXT: 4: CFGScopeBegin(i) +// CHECK-NEXT: 5: getX +// CHECK-NEXT: 6: [B2.5] (ImplicitCastExpr, FunctionToPointerDecay, int (*)(void)) +// CHECK-NEXT: 7: [B2.6]() +// CHECK-NEXT: 8: int i = getX(); +// CHECK-NEXT: 9: i +// CHECK-NEXT: 10: [B2.9] (ImplicitCastExpr, LValueToRValue, int) +// CHECK-NEXT: T: switch [B2.10] +// CHECK-NEXT: Preds (1): B6 +// CHECK-NEXT: Succs (4): B3 B4 B5 B1 +// CHECK: [B3] +// CHECK-NEXT: case 2: +// CHECK-NEXT: 1: '3' +// CHECK-NEXT: 2: c +// CHECK-NEXT: 3: [B3.2] = [B3.1] +// CHECK-NEXT: T: break; +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B4] +// CHECK-NEXT: case 1: +// CHECK-NEXT: 1: '1' +// CHECK-NEXT: 2: c +// CHECK-NEXT: 3: [B4.2] = [B4.1] +// CHECK-NEXT: T: break; +// CHECK-NEXT: Preds (2): B2 B5 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B5] +// CHECK-NEXT: case 0: +// CHECK-NEXT: 1: '2' +// CHECK-NEXT: 2: c +// CHECK-NEXT: 3: [B5.2] = [B5.1] +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B4 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +int test_switch_with_compound_without_default() { + char c = '1'; + switch (int i = getX()) { + case 0: + c = '2'; + case 1: + c = '1'; + break; + case 2: + c = '3'; + break; + } + int k = 3; +} + +// CHECK: [B5 (ENTRY)] +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B1] +// CHECK-NEXT: 1: CFGScopeEnd(i) +// CHECK-NEXT: 2: 1 +// CHECK-NEXT: 3: int k = 1; +// CHECK-NEXT: 4: CFGScopeEnd(s) +// CHECK-NEXT: Preds (1): B3 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: 1: CFGScopeBegin(s) +// CHECK-NEXT: 2: '1' +// CHECK-NEXT: 3: char s = '1'; +// CHECK-NEXT: 4: CFGScopeBegin(i) +// CHECK-NEXT: 5: getX +// CHECK-NEXT: 6: [B2.5] (ImplicitCastExpr, FunctionToPointerDecay, int (*)(void)) +// CHECK-NEXT: 7: [B2.6]() +// CHECK-NEXT: 8: int i = getX(); +// CHECK-NEXT: 9: i +// CHECK-NEXT: 10: [B2.9] (ImplicitCastExpr, LValueToRValue, int) +// CHECK-NEXT: T: switch [B2.10] +// CHECK-NEXT: Preds (1): B5 +// CHECK-NEXT: Succs (2): B4 B3 +// CHECK: [B3] +// CHECK-NEXT: default: +// CHECK-NEXT: 1: CFGScopeBegin(a) +// CHECK-NEXT: 2: 0 +// CHECK-NEXT: 3: int a = 0; +// CHECK-NEXT: 4: i +// CHECK-NEXT: 5: ++[B3.4] +// CHECK-NEXT: 6: CFGScopeEnd(a) +// CHECK-NEXT: Preds (2): B4 B2 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B4] +// CHECK-NEXT: case 0: +// CHECK-NEXT: Preds (1): B2 +// CHECK-NEXT: Succs (1): B3 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_without_compound() { + char s = '1'; + switch (int i = getX()) + case 0: + default: { + int a = 0; + ++i; + } + int k = 1; +} + +// CHECK: [B12 (ENTRY)] +// CHECK-NEXT: Succs (1): B11 +// CHECK: [B1] +// CHECK-NEXT: 1: CFGScopeEnd(i) +// CHECK-NEXT: Preds (2): B4 B10 +// CHECK-NEXT: Succs (1): B0 +// CHECK: [B2] +// CHECK-NEXT: 1: i +// CHECK-NEXT: 2: ++[B2.1] +// CHECK-NEXT: Preds (2): B3 B7 +// CHECK-NEXT: Succs (1): B10 +// CHECK: [B3] +// CHECK-NEXT: 1: CFGScopeEnd(z) +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B4] +// CHECK-NEXT: 1: CFGScopeBegin(z) +// CHECK-NEXT: 2: 5 +// CHECK-NEXT: 3: int z = 5; +// CHECK-NEXT: 4: CFGScopeEnd(z) +// CHECK-NEXT: T: break; +// CHECK-NEXT: Preds (2): B6 B8 +// CHECK-NEXT: Succs (1): B1 +// CHECK: [B5] +// CHECK-NEXT: 1: x +// CHECK-NEXT: 2: [B5.1] (ImplicitCastExpr, LValueToRValue, int) +// CHECK-NEXT: T: switch [B5.2] +// CHECK-NEXT: Preds (1): B10 +// CHECK-NEXT: Succs (4): B7 B8 B9 B6 +// CHECK: [B6] +// CHECK-NEXT: default: +// CHECK-NEXT: 1: 3 +// CHECK-NEXT: 2: y +// CHECK-NEXT: 3: [B6.2] = [B6.1] +// CHECK-NEXT: Preds (1): B5 +// CHECK-NEXT: Succs (1): B4 +// CHECK: [B7] +// CHECK-NEXT: case 2: +// CHECK-NEXT: 1: 4 +// CHECK-NEXT: 2: y +// CHECK-NEXT: 3: [B7.2] = [B7.1] +// CHECK-NEXT: T: continue; +// CHECK-NEXT: Preds (1): B5 +// CHECK-NEXT: Succs (1): B2 +// CHECK: [B8] +// CHECK-NEXT: case 1: +// CHECK-NEXT: 1: 2 +// CHECK-NEXT: 2: y +// CHECK-NEXT: 3: [B8.2] = [B8.1] +// CHECK-NEXT: T: break; +// CHECK-NEXT: Preds (2): B5 B9 +// CHECK-NEXT: Succs (1): B4 +// CHECK: [B9] +// CHECK-NEXT: case 0: +// CHECK-NEXT: 1: 1 +// CHECK-NEXT: 2: y +// CHECK-NEXT: 3: [B9.2] = [B9.1] +// CHECK-NEXT: Preds (1): B5 +// CHECK-NEXT: Succs (1): B8 +// CHECK: [B10] +// CHECK-NEXT: 1: i +// CHECK-NEXT: 2: [B10.1] (ImplicitCastExpr, LValueToRValue, int) +// CHECK-NEXT: 3: 1000 +// CHECK-NEXT: 4: [B10.2] < [B10.3] +// CHECK-NEXT: T: for (...; [B10.4]; ...) +// CHECK-NEXT: Preds (2): B2 B11 +// CHECK-NEXT: Succs (2): B5 B1 +// CHECK: [B11] +// CHECK-NEXT: 1: CFGScopeBegin(i) +// CHECK-NEXT: 2: int i; +// CHECK-NEXT: 3: int x; +// CHECK-NEXT: 4: int y; +// CHECK-NEXT: 5: 0 +// CHECK-NEXT: 6: i +// CHECK-NEXT: 7: [B11.6] = [B11.5] +// CHECK-NEXT: Preds (1): B12 +// CHECK-NEXT: Succs (1): B10 +// CHECK: [B0 (EXIT)] +// CHECK-NEXT: Preds (1): B1 +void test_for_switch_in_for() { + int i, x, y; + for (i = 0; i < 1000; ++i) { + switch (x) { + case 0: + y = 1; + case 1: + y = 2; + break; // break from switch + case 2: + y = 4; + continue; // continue in loop + default: + y = 3; + } + { + int z = 5; + break; // break from loop + } + } +} diff --git a/test/Analysis/security-syntax-checks.m b/test/Analysis/security-syntax-checks.m index 04a4c7d86655..2c569727addd 100644 --- a/test/Analysis/security-syntax-checks.m +++ b/test/Analysis/security-syntax-checks.m @@ -37,6 +37,27 @@ void test_float_condition() { for (FooType x = 100000001.0f; x <= 100000010.0f; x++ ) {} // expected-warning{{Variable 'x' with floating point type 'FooType'}} } +// Obsolete function bcmp +int bcmp(void *, void *, size_t); + +int test_bcmp(void *a, void *b, size_t n) { + return bcmp(a, b, n); // expected-warning{{The bcmp() function is obsoleted by memcmp()}} +} + +// Obsolete function bcopy +void bcopy(void *, void *, size_t); + +void test_bcopy(void *a, void *b, size_t n) { + bcopy(a, b, n); // expected-warning{{The bcopy() function is obsoleted by memcpy() or memmove(}} +} + +// Obsolete function bzero +void bzero(void *, size_t); + +void test_bzero(void *a, size_t n) { + bzero(a, n); // expected-warning{{The bzero() function is obsoleted by memset()}} +} + // <rdar://problem/6335715> rule request: gets() buffer overflow // Part of recommendation: 300-BSI (buildsecurityin.us-cert.gov) char* gets(char *buf); @@ -146,6 +167,16 @@ void test_strcpy() { strcpy(x, y); //expected-warning{{Call to function 'strcpy' is insecure as it does not provide bounding of the memory buffer. Replace unbounded copy functions with analogous functions that support length arguments such as 'strlcpy'. CWE-119}} } +void test_strcpy_2() { + char x[4]; + strcpy(x, "abcd"); //expected-warning{{Call to function 'strcpy' is insecure as it does not provide bounding of the memory buffer. Replace unbounded copy functions with analogous functions that support length arguments such as 'strlcpy'. CWE-119}} +} + +void test_strcpy_safe() { + char x[5]; + strcpy(x, "abcd"); +} + //===----------------------------------------------------------------------=== // strcat() //===----------------------------------------------------------------------=== diff --git a/test/Analysis/stack-addr-ps.c b/test/Analysis/stack-addr-ps.c index 4026cee90b04..721051ffaf11 100644 --- a/test/Analysis/stack-addr-ps.c +++ b/test/Analysis/stack-addr-ps.c @@ -6,7 +6,7 @@ int* f1() { } int* f2(int y) { - return &y; // expected-warning{{Address of stack memory associated with local variable 'y' returned}} expected-warning{{address of stack memory associated with local variable 'y' returned}} + return &y; // expected-warning{{Address of stack memory associated with local variable 'y' returned}} expected-warning{{address of stack memory associated with parameter 'y' returned}} } int* f3(int x, int *y) { diff --git a/test/Analysis/stack-addr-ps.cpp b/test/Analysis/stack-addr-ps.cpp index 79afd18e1889..e1f06835c784 100644 --- a/test/Analysis/stack-addr-ps.cpp +++ b/test/Analysis/stack-addr-ps.cpp @@ -91,8 +91,8 @@ struct TS { // rdar://11345441 int* f5() { - int& i = i; // expected-warning {{Assigned value is garbage or undefined}} expected-note {{binding reference variable 'i' here}} expected-warning{{reference 'i' is not yet bound to a value when used within its own initialization}} - return &i; // expected-warning {{address of stack memory associated with local variable 'i' returned}} + int& i = i; // expected-warning {{Assigned value is garbage or undefined}} expected-warning{{reference 'i' is not yet bound to a value when used within its own initialization}} + return &i; } void *radar13226577() { diff --git a/test/Analysis/stackaddrleak.c b/test/Analysis/stackaddrleak.c index a037d12fe40c..8a1519e7874f 100644 --- a/test/Analysis/stackaddrleak.c +++ b/test/Analysis/stackaddrleak.c @@ -37,7 +37,7 @@ void test_multi_return() { intptr_t returnAsNonLoc() { int x; - return (intptr_t)&x; // expected-warning{{Address of stack memory associated with local variable 'x' returned to caller}} + return (intptr_t)&x; // expected-warning{{Address of stack memory associated with local variable 'x' returned to caller}} expected-warning{{address of stack memory associated with local variable 'x' returned}} } bool returnAsBool() { diff --git a/test/Analysis/std-c-library-functions.c b/test/Analysis/std-c-library-functions.c index 042b035f8bdf..b8eb3e54bdf0 100644 --- a/test/Analysis/std-c-library-functions.c +++ b/test/Analysis/std-c-library-functions.c @@ -57,8 +57,7 @@ void test_fread_fwrite(FILE *fp, int *buf) { size_t y = fread(buf, sizeof(int), 10, fp); clang_analyzer_eval(y <= 10); // expected-warning{{TRUE}} size_t z = fwrite(buf, sizeof(int), y, fp); - // FIXME: should be TRUE once symbol-symbol constraint support is improved. - clang_analyzer_eval(z <= y); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(z <= y); // expected-warning{{TRUE}} } ssize_t getline(char **, size_t *, FILE *); diff --git a/test/Analysis/string.c b/test/Analysis/string.c index 8ea2068c5613..7e8a7361cd4b 100644 --- a/test/Analysis/string.c +++ b/test/Analysis/string.c @@ -1,7 +1,8 @@ -// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify %s -// RUN: %clang_analyze_cc1 -DUSE_BUILTINS -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify %s -// RUN: %clang_analyze_cc1 -DVARIANT -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify %s -// RUN: %clang_analyze_cc1 -DUSE_BUILTINS -DVARIANT -analyzer-checker=alpha.security.taint,core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify %s +// RUN: %clang_analyze_cc1 -DUSE_BUILTINS -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify %s +// RUN: %clang_analyze_cc1 -DVARIANT -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify %s +// RUN: %clang_analyze_cc1 -DUSE_BUILTINS -DVARIANT -analyzer-checker=alpha.security.taint,core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify %s +// RUN: %clang_analyze_cc1 -DSUPPRESS_OUT_OF_BOUND -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring.BufferOverlap,alpha.unix.cstring.NotNullTerminated,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify %s //===----------------------------------------------------------------------=== // Declarations @@ -30,6 +31,8 @@ typedef typeof(sizeof(int)) size_t; void clang_analyzer_eval(int); int scanf(const char *restrict format, ...); +void *malloc(size_t); +void free(void *); //===----------------------------------------------------------------------=== // strlen() @@ -109,7 +112,7 @@ void strlen_global() { if (a == 0) { clang_analyzer_eval(b == 0); // expected-warning{{TRUE}} // Make sure clang_analyzer_eval does not invalidate globals. - clang_analyzer_eval(strlen(global_str) == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(strlen(global_str) == 0); // expected-warning{{TRUE}} } // Call a function with unknown effects, which should invalidate globals. @@ -308,11 +311,13 @@ void strcpy_effects(char *x, char *y) { clang_analyzer_eval(globalInt == 42); // expected-warning{{TRUE}} } +#ifndef SUPPRESS_OUT_OF_BOUND void strcpy_overflow(char *y) { char x[4]; if (strlen(y) == 4) strcpy(x, y); // expected-warning{{String copy function overflows destination buffer}} } +#endif void strcpy_no_overflow(char *y) { char x[4]; @@ -347,11 +352,13 @@ void stpcpy_effect(char *x, char *y) { clang_analyzer_eval(a == x[0]); // expected-warning{{UNKNOWN}} } +#ifndef SUPPRESS_OUT_OF_BOUND void stpcpy_overflow(char *y) { char x[4]; if (strlen(y) == 4) stpcpy(x, y); // expected-warning{{String copy function overflows destination buffer}} } +#endif void stpcpy_no_overflow(char *y) { char x[4]; @@ -402,6 +409,7 @@ void strcat_effects(char *y) { clang_analyzer_eval((int)strlen(x) == (orig_len + strlen(y))); // expected-warning{{TRUE}} } +#ifndef SUPPRESS_OUT_OF_BOUND void strcat_overflow_0(char *y) { char x[4] = "12"; if (strlen(y) == 4) @@ -419,6 +427,7 @@ void strcat_overflow_2(char *y) { if (strlen(y) == 2) strcat(x, y); // expected-warning{{String copy function overflows destination buffer}} } +#endif void strcat_no_overflow(char *y) { char x[5] = "12"; @@ -495,6 +504,15 @@ void strncpy_effects(char *x, char *y) { clang_analyzer_eval(a == x[0]); // expected-warning{{UNKNOWN}} } +#ifndef SUPPRESS_OUT_OF_BOUND +// Enabling the malloc checker enables some of the buffer-checking portions +// of the C-string checker. +void cstringchecker_bounds_nocrash() { + char *p = malloc(2); + strncpy(p, "AAA", sizeof("AAA")); // expected-warning {{Size argument is greater than the length of the destination buffer}} + free(p); +} + void strncpy_overflow(char *y) { char x[4]; if (strlen(y) == 4) @@ -515,6 +533,7 @@ void strncpy_no_overflow2(char *y, int n) { if (strlen(y) == 3) strncpy(x, y, n); // expected-warning{{Size argument is greater than the length of the destination buffer}} } +#endif void strncpy_truncate(char *y) { char x[4]; @@ -591,6 +610,7 @@ void strncat_effects(char *y) { clang_analyzer_eval(strlen(x) == (orig_len + strlen(y))); // expected-warning{{TRUE}} } +#ifndef SUPPRESS_OUT_OF_BOUND void strncat_overflow_0(char *y) { char x[4] = "12"; if (strlen(y) == 4) @@ -614,6 +634,8 @@ void strncat_overflow_3(char *y) { if (strlen(y) == 4) strncat(x, y, 2); // expected-warning{{Size argument is greater than the free space in the destination buffer}} } +#endif + void strncat_no_overflow_1(char *y) { char x[5] = "12"; if (strlen(y) == 2) @@ -631,6 +653,7 @@ void strncat_symbolic_dst_length(char *dst) { clang_analyzer_eval(strlen(dst) >= 4); // expected-warning{{TRUE}} } +#ifndef SUPPRESS_OUT_OF_BOUND void strncat_symbolic_src_length(char *src) { char dst[8] = "1234"; strncat(dst, src, 3); @@ -648,6 +671,7 @@ void strncat_unknown_src_length(char *src, int offset) { char dst2[8] = "1234"; strncat(dst2, &src[offset], 4); // expected-warning{{Size argument is greater than the free space in the destination buffer}} } +#endif // There is no strncat_unknown_dst_length because if we can't get a symbolic // length for the "before" strlen, we won't be able to set one for "after". @@ -1160,12 +1184,212 @@ void strsep_changes_input_string() { } //===----------------------------------------------------------------------=== +// memset() +//===----------------------------------------------------------------------=== + +void *memset(void *dest, int ch, size_t count); + +void *malloc(size_t size); +void free(void *); + +void memset1_char_array_null() { + char str[] = "abcd"; + clang_analyzer_eval(strlen(str) == 4); // expected-warning{{TRUE}} + memset(str, '\0', 2); + clang_analyzer_eval(strlen(str) == 0); // expected-warning{{TRUE}} +} + +void memset2_char_array_null() { + char str[] = "abcd"; + clang_analyzer_eval(strlen(str) == 4); // expected-warning{{TRUE}} + memset(str, '\0', strlen(str) + 1); + clang_analyzer_eval(strlen(str) == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(str[2] == 0); // expected-warning{{TRUE}} +} + +void memset3_char_malloc_null() { + char *str = (char *)malloc(10 * sizeof(char)); + memset(str + 1, '\0', 8); + clang_analyzer_eval(str[1] == 0); // expected-warning{{UNKNOWN}} + free(str); +} + +void memset4_char_malloc_null() { + char *str = (char *)malloc(10 * sizeof(char)); + //void *str = malloc(10 * sizeof(char)); + memset(str, '\0', 10); + clang_analyzer_eval(str[1] == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(strlen(str) == 0); // expected-warning{{TRUE}} + free(str); +} + +#ifdef SUPPRESS_OUT_OF_BOUND +void memset5_char_malloc_overflow_null() { + char *str = (char *)malloc(10 * sizeof(char)); + memset(str, '\0', 12); + clang_analyzer_eval(str[1] == 0); // expected-warning{{UNKNOWN}} + free(str); +} +#endif + +void memset6_char_array_nonnull() { + char str[] = "abcd"; + clang_analyzer_eval(strlen(str) == 4); // expected-warning{{TRUE}} + memset(str, '0', 2); + clang_analyzer_eval(str[0] == 'a'); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(strlen(str) == 4); // expected-warning{{UNKNOWN}} +} + +#ifdef SUPPRESS_OUT_OF_BOUND +void memset8_char_array_nonnull() { + char str[5] = "abcd"; + clang_analyzer_eval(strlen(str) == 4); // expected-warning{{TRUE}} + memset(str, '0', 10); + clang_analyzer_eval(str[0] != '0'); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(strlen(str) >= 10); // expected-warning{{TRUE}} + clang_analyzer_eval(strlen(str) < 10); // expected-warning{{FALSE}} +} +#endif + +struct POD_memset { + int num; + char c; +}; + +void memset10_struct() { + struct POD_memset pod; + char *str = (char *)&pod; + pod.num = 1; + pod.c = 1; + clang_analyzer_eval(pod.num == 0); // expected-warning{{FALSE}} + memset(str, 0, sizeof(struct POD_memset)); + clang_analyzer_eval(pod.num == 0); // expected-warning{{TRUE}} +} + +#ifdef SUPPRESS_OUT_OF_BOUND +void memset11_struct_field() { + struct POD_memset pod; + pod.num = 1; + pod.c = '1'; + memset(&pod.num, 0, sizeof(struct POD_memset)); + + clang_analyzer_eval(pod.num == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(pod.c == '\0'); // expected-warning{{TRUE}} +} + +void memset12_struct_field() { + struct POD_memset pod; + pod.num = 1; + pod.c = '1'; + memset(&pod.c, 0, sizeof(struct POD_memset)); + clang_analyzer_eval(pod.num == 0); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(pod.c == 0); // expected-warning{{UNKNOWN}} +} + +union U_memset { + int i; + double d; + char c; +}; + +void memset13_union_field() { + union U_memset u; + u.i = 5; + memset(&u.i, '\0', sizeof(union U_memset)); + // Note: This should be TRUE, analyzer can't handle union perfectly now. + clang_analyzer_eval(u.d == 0); // expected-warning{{UNKNOWN}} +} +#endif + +void memset14_region_cast() { + char *str = (char *)malloc(10 * sizeof(int)); + int *array = (int *)str; + memset(array, 0, 10 * sizeof(int)); + clang_analyzer_eval(str[10] == '\0'); // expected-warning{{TRUE}} + clang_analyzer_eval(strlen((char *)array) == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(strlen(str) == 0); // expected-warning{{TRUE}} + free(str); +} + +void memset15_region_cast() { + char *str = (char *)malloc(10 * sizeof(int)); + int *array = (int *)str; + memset(array, 0, 5 * sizeof(int)); + clang_analyzer_eval(str[10] == '\0'); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(strlen((char *)array) == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(strlen(str) == 0); // expected-warning{{TRUE}} + free(str); +} + +int memset20_scalar() { + int *x = malloc(sizeof(int)); + *x = 10; + memset(x, 0, sizeof(int)); + int num = 1 / *x; // expected-warning{{Division by zero}} + free(x); + return num; +} + +int memset21_scalar() { + int *x = malloc(sizeof(int)); + memset(x, 0, 1); + int num = 1 / *x; + free(x); + return num; +} + +void memset22_array() { + int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + clang_analyzer_eval(array[1] == 2); // expected-warning{{TRUE}} + memset(array, 0, sizeof(array)); + clang_analyzer_eval(array[1] == 0); // expected-warning{{TRUE}} +} + +void memset23_array_pod_object() { + struct POD_memset array[10]; + array[1].num = 10; + array[1].c = 'c'; + clang_analyzer_eval(array[1].num == 10); // expected-warning{{TRUE}} + memset(&array[1], 0, sizeof(struct POD_memset)); + clang_analyzer_eval(array[1].num == 0); // expected-warning{{UNKNOWN}} +} + +void memset24_array_pod_object() { + struct POD_memset array[10]; + array[1].num = 10; + array[1].c = 'c'; + clang_analyzer_eval(array[1].num == 10); // expected-warning{{TRUE}} + memset(array, 0, sizeof(array)); + clang_analyzer_eval(array[1].num == 0); // expected-warning{{TRUE}} +} + +void memset25_symbol(char c) { + char array[10] = {1}; + if (c != 0) + return; + + memset(array, c, 10); + + clang_analyzer_eval(strlen(array) == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(array[4] == 0); // expected-warning{{TRUE}} +} + +void memset26_upper_UCHAR_MAX() { + char array[10] = {1}; + + memset(array, 1024, 10); + + clang_analyzer_eval(strlen(array) == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(array[4] == 0); // expected-warning{{TRUE}} +} + +//===----------------------------------------------------------------------=== // FIXMEs //===----------------------------------------------------------------------=== -// The analyzer_eval call below should evaluate to true. We are being too -// aggressive in marking the (length of) src symbol dead. The length of dst -// depends on src. This could be explicitely specified in the checker or the +// The analyzer_eval call below should evaluate to true. We are being too +// aggressive in marking the (length of) src symbol dead. The length of dst +// depends on src. This could be explicitly specified in the checker or the // logic for handling MetadataSymbol in SymbolManager needs to change. void strcat_symbolic_src_length(char *src) { char dst[8] = "1234"; @@ -1173,6 +1397,7 @@ void strcat_symbolic_src_length(char *src) { clang_analyzer_eval(strlen(dst) >= 4); // expected-warning{{UNKNOWN}} } + // The analyzer_eval call below should evaluate to true. Most likely the same // issue as the test above. void strncpy_exactly_matching_buffer2(char *y) { @@ -1185,3 +1410,87 @@ void strncpy_exactly_matching_buffer2(char *y) { // This time, we know that y fits in x anyway. clang_analyzer_eval(strlen(x) <= 3); // expected-warning{{UNKNOWN}} } + +void memset7_char_array_nonnull() { + char str[5] = "abcd"; + clang_analyzer_eval(strlen(str) == 4); // expected-warning{{TRUE}} + memset(str, '0', 5); + // FIXME: This should be TRUE. + clang_analyzer_eval(str[0] == '0'); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(strlen(str) >= 5); // expected-warning{{TRUE}} +} + +void memset16_region_cast() { + char *str = (char *)malloc(10 * sizeof(int)); + int *array = (int *)str; + memset(array, '0', 10 * sizeof(int)); + // FIXME: This should be TRUE. + clang_analyzer_eval(str[10] == '0'); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(strlen((char *)array) >= 10 * sizeof(int)); // expected-warning{{TRUE}} + clang_analyzer_eval(strlen(str) >= 10 * sizeof(int)); // expected-warning{{TRUE}} + free(str); +} + +#ifdef SUPPRESS_OUT_OF_BOUND +void memset17_region_cast() { + char *str = (char *)malloc(10 * sizeof(int)); + int *array = (int *)str; + memset(array, '0', 12 * sizeof(int)); + clang_analyzer_eval(str[10] == '0'); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(strlen((char *)array) >= 12 * sizeof(int)); // expected-warning{{TRUE}} + clang_analyzer_eval(strlen(str) >= 12 * sizeof(int)); // expected-warning{{TRUE}} + free(str); +} + +void memset18_memset_multiple_times() { + char *str = (char *)malloc(10 * sizeof(char)); + clang_analyzer_eval(strlen(str) == 0); // expected-warning{{UNKNOWN}} + + memset(str + 2, '\0', 10 * sizeof(char)); + clang_analyzer_eval(strlen(str) == 0); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(str[1] == '\0'); // expected-warning{{UNKNOWN}} + + memset(str, '0', 10 * sizeof(char)); + clang_analyzer_eval(strlen(str) >= 10); // expected-warning{{TRUE}} + // FIXME: This should be TRUE. + clang_analyzer_eval(str[1] == '0'); // expected-warning{{UNKNOWN}} + + free(str); +} + +void memset19_memset_multiple_times() { + char *str = (char *)malloc(10 * sizeof(char)); + clang_analyzer_eval(strlen(str) == 0); // expected-warning{{UNKNOWN}} + + memset(str, '0', 10 * sizeof(char)); + clang_analyzer_eval(strlen(str) >= 10); // expected-warning{{TRUE}} + // FIXME: This should be TRUE. + clang_analyzer_eval(str[1] == '0'); // expected-warning{{UNKNOWN}} + + memset(str + 2, '\0', 10 * sizeof(char)); + clang_analyzer_eval(strlen(str) >= 10); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(str[1] == '0'); // expected-warning{{UNKNOWN}} + + free(str); +} +#endif + +// The analyzer does not support binding a symbol with default binding. +void memset27_symbol(char c) { + char array[10] = {0}; + if (c < 10) + return; + + memset(array, c, 10); + + clang_analyzer_eval(strlen(array) >= 10); // expected-warning{{TRUE}} + // FIXME: This should be TRUE. + clang_analyzer_eval(array[4] >= 10); // expected-warning{{UNKNOWN}} +} + +void memset28() { + short x; + memset(&x, 1, sizeof(short)); + // This should be true. + clang_analyzer_eval(x == 0x101); // expected-warning{{UNKNOWN}} +} diff --git a/test/Analysis/structured_bindings.cc b/test/Analysis/structured_bindings.cc new file mode 100644 index 000000000000..1e23246f9a12 --- /dev/null +++ b/test/Analysis/structured_bindings.cc @@ -0,0 +1,10 @@ +// RUN: %clang_analyze_cc1 -std=c++17 -analyzer-checker=core -verify %s + +// expected-no-diagnostics +struct s { int a; }; +int foo() { + auto[a] = s{1}; // FIXME: proper modelling + if (a) { + } +} + diff --git a/test/Analysis/sval-dump-int128.c b/test/Analysis/sval-dump-int128.c new file mode 100644 index 000000000000..3c28f1bd1bb6 --- /dev/null +++ b/test/Analysis/sval-dump-int128.c @@ -0,0 +1,7 @@ +// RUN: %clang_analyze_cc1 -triple x86_64-linux-gnu -analyzer-checker=debug.ExprInspection %s -verify + +void clang_analyzer_dump(unsigned __int128 x); + +void testDumpInt128() { + clang_analyzer_dump((unsigned __int128)5 << 64); // expected-warning{{92233720368547758080 U128b}} +} diff --git a/test/Analysis/svalbuilder-rearrange-comparisons.c b/test/Analysis/svalbuilder-rearrange-comparisons.c new file mode 100644 index 000000000000..ac186120fe11 --- /dev/null +++ b/test/Analysis/svalbuilder-rearrange-comparisons.c @@ -0,0 +1,936 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.ExprInspection,core.builtin -analyzer-config aggressive-binary-operation-simplification=true -verify %s + +void clang_analyzer_dump(int x); +void clang_analyzer_eval(int x); + +void exit(int); + +#define UINT_MAX (~0U) +#define INT_MAX (UINT_MAX & (UINT_MAX >> 1)) + +extern void __assert_fail (__const char *__assertion, __const char *__file, + unsigned int __line, __const char *__function) + __attribute__ ((__noreturn__)); +#define assert(expr) \ + ((expr) ? (void)(0) : __assert_fail (#expr, __FILE__, __LINE__, __func__)) + +int g(); +int f() { + int x = g(); + // Assert that no overflows occur in this test file. + // Assuming that concrete integers are also within that range. + assert(x <= ((int)INT_MAX / 4)); + assert(x >= -((int)INT_MAX / 4)); + return x; +} + +void compare_different_symbol_equal() { + int x = f(), y = f(); + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 0}} +} + +void compare_different_symbol_plus_left_int_equal() { + int x = f()+1, y = f(); + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 1}} +} + +void compare_different_symbol_minus_left_int_equal() { + int x = f()-1, y = f(); + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 1}} +} + +void compare_different_symbol_plus_right_int_equal() { + int x = f(), y = f()+2; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 2}} +} + +void compare_different_symbol_minus_right_int_equal() { + int x = f(), y = f()-2; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 2}} +} + +void compare_different_symbol_plus_left_plus_right_int_equal() { + int x = f()+2, y = f()+1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 1}} +} + +void compare_different_symbol_plus_left_minus_right_int_equal() { + int x = f()+2, y = f()-1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 3}} +} + +void compare_different_symbol_minus_left_plus_right_int_equal() { + int x = f()-2, y = f()+1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 3}} +} + +void compare_different_symbol_minus_left_minus_right_int_equal() { + int x = f()-2, y = f()-1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 1}} +} + +void compare_same_symbol_equal() { + int x = f(), y = x; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_eval(x == y); + // expected-warning@-1{{TRUE}} +} + +void compare_same_symbol_plus_left_int_equal() { + int x = f(), y = x; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_eval(x == y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_minus_left_int_equal() { + int x = f(), y = x; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_eval(x == y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_plus_right_int_equal() { + int x = f(), y = x+1; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_eval(x == y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_minus_right_int_equal() { + int x = f(), y = x-1; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_eval(x == y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_plus_left_plus_right_int_equal() { + int x = f(), y = x+1; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_eval(x == y); + // expected-warning@-1{{TRUE}} +} + +void compare_same_symbol_plus_left_minus_right_int_equal() { + int x = f(), y = x-1; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_eval(x == y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_minus_left_plus_right_int_equal() { + int x = f(), y = x+1; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_eval(x == y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_minus_left_minus_right_int_equal() { + int x = f(), y = x-1; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_eval(x == y); + // expected-warning@-1{{TRUE}} +} + +void compare_different_symbol_less_or_equal() { + int x = f(), y = f(); + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 0}} +} + +void compare_different_symbol_plus_left_int_less_or_equal() { + int x = f()+1, y = f(); + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 1}} +} + +void compare_different_symbol_minus_left_int_less_or_equal() { + int x = f()-1, y = f(); + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 1}} +} + +void compare_different_symbol_plus_right_int_less_or_equal() { + int x = f(), y = f()+2; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 2}} +} + +void compare_different_symbol_minus_right_int_less_or_equal() { + int x = f(), y = f()-2; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 2}} +} + +void compare_different_symbol_plus_left_plus_right_int_less_or_equal() { + int x = f()+2, y = f()+1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 1}} +} + +void compare_different_symbol_plus_left_minus_right_int_less_or_equal() { + int x = f()+2, y = f()-1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 3}} +} + +void compare_different_symbol_minus_left_plus_right_int_less_or_equal() { + int x = f()-2, y = f()+1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 3}} +} + +void compare_different_symbol_minus_left_minus_right_int_less_or_equal() { + int x = f()-2, y = f()-1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 1}} +} + +void compare_same_symbol_less_or_equal() { + int x = f(), y = x; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_eval(x <= y); + // expected-warning@-1{{TRUE}} +} + +void compare_same_symbol_plus_left_int_less_or_equal() { + int x = f(), y = x; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_eval(x <= y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_minus_left_int_less_or_equal() { + int x = f(), y = x; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_eval(x <= y); + // expected-warning@-1{{TRUE}} +} + +void compare_same_symbol_plus_right_int_less_or_equal() { + int x = f(), y = x+1; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_eval(x <= y); + // expected-warning@-1{{TRUE}} +} + +void compare_same_symbol_minus_right_int_less_or_equal() { + int x = f(), y = x-1; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_eval(x <= y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_plus_left_plus_right_int_less_or_equal() { + int x = f(), y = x+1; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_eval(x <= y); + // expected-warning@-1{{TRUE}} +} + +void compare_same_symbol_plus_left_minus_right_int_less_or_equal() { + int x = f(), y = x-1; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_eval(x <= y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_minus_left_plus_right_int_less_or_equal() { + int x = f(), y = x+1; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_eval(x <= y); + // expected-warning@-1{{TRUE}} +} + +void compare_same_symbol_minus_left_minus_right_int_less_or_equal() { + int x = f(), y = x-1; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_eval(x <= y); + // expected-warning@-1{{TRUE}} +} + +void compare_different_symbol_less() { + int x = f(), y = f(); + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 0}} +} + +void compare_different_symbol_plus_left_int_less() { + int x = f()+1, y = f(); + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 1}} +} + +void compare_different_symbol_minus_left_int_less() { + int x = f()-1, y = f(); + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 1}} +} + +void compare_different_symbol_plus_right_int_less() { + int x = f(), y = f()+2; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 2}} +} + +void compare_different_symbol_minus_right_int_less() { + int x = f(), y = f()-2; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 2}} +} + +void compare_different_symbol_plus_left_plus_right_int_less() { + int x = f()+2, y = f()+1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 1}} +} + +void compare_different_symbol_plus_left_minus_right_int_less() { + int x = f()+2, y = f()-1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 3}} +} + +void compare_different_symbol_minus_left_plus_right_int_less() { + int x = f()-2, y = f()+1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 3}} +} + +void compare_different_symbol_minus_left_minus_right_int_less() { + int x = f()-2, y = f()-1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 1}} +} + +void compare_same_symbol_less() { + int x = f(), y = x; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_eval(x < y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_plus_left_int_less() { + int x = f(), y = x; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_eval(x < y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_minus_left_int_less() { + int x = f(), y = x; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_eval(x < y); + // expected-warning@-1{{TRUE}} +} + +void compare_same_symbol_plus_right_int_less() { + int x = f(), y = x+1; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_eval(x < y); + // expected-warning@-1{{TRUE}} +} + +void compare_same_symbol_minus_right_int_less() { + int x = f(), y = x-1; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_eval(x < y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_plus_left_plus_right_int_less() { + int x = f(), y = x+1; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_eval(x < y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_plus_left_minus_right_int_less() { + int x = f(), y = x-1; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_eval(x < y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_minus_left_plus_right_int_less() { + int x = f(), y = x+1; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_eval(x < y); + // expected-warning@-1{{TRUE}} +} + +void compare_same_symbol_minus_left_minus_right_int_less() { + int x = f(), y = x-1; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_eval(x < y); + // expected-warning@-1{{FALSE}} +} + +void compare_different_symbol_equal_unsigned() { + unsigned x = f(), y = f(); + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 0}} +} + +void compare_different_symbol_plus_left_int_equal_unsigned() { + unsigned x = f()+1, y = f(); + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 1}} +} + +void compare_different_symbol_minus_left_int_equal_unsigned() { + unsigned x = f()-1, y = f(); + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 1}} +} + +void compare_different_symbol_plus_right_int_equal_unsigned() { + unsigned x = f(), y = f()+2; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 2}} +} + +void compare_different_symbol_minus_right_int_equal_unsigned() { + unsigned x = f(), y = f()-2; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 2}} +} + +void compare_different_symbol_plus_left_plus_right_int_equal_unsigned() { + unsigned x = f()+2, y = f()+1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 1}} +} + +void compare_different_symbol_plus_left_minus_right_int_equal_unsigned() { + unsigned x = f()+2, y = f()-1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 3}} +} + +void compare_different_symbol_minus_left_plus_right_int_equal_unsigned() { + unsigned x = f()-2, y = f()+1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 3}} +} + +void compare_different_symbol_minus_left_minus_right_int_equal_unsigned() { + unsigned x = f()-2, y = f()-1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 1}} +} + +void compare_same_symbol_equal_unsigned() { + unsigned x = f(), y = x; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_eval(x == y); + // expected-warning@-1{{TRUE}} +} + +void compare_same_symbol_plus_left_int_equal_unsigned() { + unsigned x = f(), y = x; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$2{int}) + 1U) == (conj_$2{int})}} +} + +void compare_same_symbol_minus_left_int_equal_unsigned() { + unsigned x = f(), y = x; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$2{int}) - 1U) == (conj_$2{int})}} +} + +void compare_same_symbol_plus_right_int_equal_unsigned() { + unsigned x = f(), y = x+1; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{(conj_$2{int}) == ((conj_$2{int}) + 1U)}} +} + +void compare_same_symbol_minus_right_int_equal_unsigned() { + unsigned x = f(), y = x-1; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{(conj_$2{int}) == ((conj_$2{int}) - 1U)}} +} + +void compare_same_symbol_plus_left_plus_right_int_equal_unsigned() { + unsigned x = f(), y = x+1; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_eval(x == y); + // expected-warning@-1{{TRUE}} +} + +void compare_same_symbol_plus_left_minus_right_int_equal_unsigned() { + unsigned x = f(), y = x-1; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$2{int}) + 1U) == ((conj_$2{int}) - 1U)}} +} + +void compare_same_symbol_minus_left_plus_right_int_equal_unsigned() { + unsigned x = f(), y = x+1; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(x == y); + // expected-warning@-1{{((conj_$2{int}) - 1U) == ((conj_$2{int}) + 1U)}} +} + +void compare_same_symbol_minus_left_minus_right_int_equal_unsigned() { + unsigned x = f(), y = x-1; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_eval(x == y); + // expected-warning@-1{{TRUE}} +} + +void compare_different_symbol_less_or_equal_unsigned() { + unsigned x = f(), y = f(); + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 0}} +} + +void compare_different_symbol_plus_left_int_less_or_equal_unsigned() { + unsigned x = f()+1, y = f(); + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 1}} +} + +void compare_different_symbol_minus_left_int_less_or_equal_unsigned() { + unsigned x = f()-1, y = f(); + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 1}} +} + +void compare_different_symbol_plus_right_int_less_or_equal_unsigned() { + unsigned x = f(), y = f()+2; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 2}} +} + +void compare_different_symbol_minus_right_int_less_or_equal_unsigned() { + unsigned x = f(), y = f()-2; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 2}} +} + +void compare_different_symbol_plus_left_plus_right_int_less_or_equal_unsigned() { + unsigned x = f()+2, y = f()+1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 1}} +} + +void compare_different_symbol_plus_left_minus_right_int_less_or_equal_unsigned() { + unsigned x = f()+2, y = f()-1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 3}} +} + +void compare_different_symbol_minus_left_plus_right_int_less_or_equal_unsigned() { + unsigned x = f()-2, y = f()+1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 3}} +} + +void compare_different_symbol_minus_left_minus_right_int_less_or_equal_unsigned() { + unsigned x = f()-2, y = f()-1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 1}} +} + +void compare_same_symbol_less_or_equal_unsigned() { + unsigned x = f(), y = x; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_eval(x <= y); + // expected-warning@-1{{TRUE}} +} + +void compare_same_symbol_plus_left_int_less_or_equal_unsigned() { + unsigned x = f(), y = x; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$2{int}) + 1U) <= (conj_$2{int})}} +} + +void compare_same_symbol_minus_left_int_less_or_equal_unsigned() { + unsigned x = f(), y = x; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$2{int}) - 1U) <= (conj_$2{int})}} +} + +void compare_same_symbol_plus_right_int_less_or_equal_unsigned() { + unsigned x = f(), y = x+1; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{(conj_$2{int}) <= ((conj_$2{int}) + 1U)}} +} + +void compare_same_symbol_minus_right_int_less_or_equal_unsigned() { + unsigned x = f(), y = x-1; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{(conj_$2{int}) <= ((conj_$2{int}) - 1U)}} +} + +void compare_same_symbol_plus_left_plus_right_int_less_or_equal_unsigned() { + unsigned x = f(), y = x+1; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_eval(x <= y); + // expected-warning@-1{{TRUE}} +} + +void compare_same_symbol_plus_left_minus_right_int_less_or_equal_unsigned() { + unsigned x = f(), y = x-1; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$2{int}) + 1U) <= ((conj_$2{int}) - 1U)}} +} + +void compare_same_symbol_minus_left_plus_right_int_less_or_equal_unsigned() { + unsigned x = f(), y = x+1; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(x <= y); + // expected-warning@-1{{((conj_$2{int}) - 1U) <= ((conj_$2{int}) + 1U)}} +} + +void compare_same_symbol_minus_left_minus_right_int_less_or_equal_unsigned() { + unsigned x = f(), y = x-1; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_eval(x <= y); + // expected-warning@-1{{TRUE}} +} + +void compare_different_symbol_less_unsigned() { + unsigned x = f(), y = f(); + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 0}} +} + +void compare_different_symbol_plus_left_int_less_unsigned() { + unsigned x = f()+1, y = f(); + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 1}} +} + +void compare_different_symbol_minus_left_int_less_unsigned() { + unsigned x = f()-1, y = f(); + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 1}} +} + +void compare_different_symbol_plus_right_int_less_unsigned() { + unsigned x = f(), y = f()+2; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 2}} +} + +void compare_different_symbol_minus_right_int_less_unsigned() { + unsigned x = f(), y = f()-2; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 2}} +} + +void compare_different_symbol_plus_left_plus_right_int_less_unsigned() { + unsigned x = f()+2, y = f()+1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 1}} +} + +void compare_different_symbol_plus_left_minus_right_int_less_unsigned() { + unsigned x = f()+2, y = f()-1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 3}} +} + +void compare_different_symbol_minus_left_plus_right_int_less_unsigned() { + unsigned x = f()-2, y = f()+1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 3}} +} + +void compare_different_symbol_minus_left_minus_right_int_less_unsigned() { + unsigned x = f()-2, y = f()-1; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}} + clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 1}} +} + +void compare_same_symbol_less_unsigned() { + unsigned x = f(), y = x; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_eval(x < y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_plus_left_int_less_unsigned() { + unsigned x = f(), y = x; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$2{int}) + 1U) < (conj_$2{int})}} +} + +void compare_same_symbol_minus_left_int_less_unsigned() { + unsigned x = f(), y = x; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$2{int}) - 1U) < (conj_$2{int})}} +} + +void compare_same_symbol_plus_right_int_less_unsigned() { + unsigned x = f(), y = x+1; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{(conj_$2{int}) < ((conj_$2{int}) + 1U)}} +} + +void compare_same_symbol_minus_right_int_less_unsigned() { + unsigned x = f(), y = x-1; + clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{(conj_$2{int}) < ((conj_$2{int}) - 1U)}} +} + +void compare_same_symbol_plus_left_plus_right_int_less_unsigned() { + unsigned x = f(), y = x+1; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_eval(x < y); + // expected-warning@-1{{FALSE}} +} + +void compare_same_symbol_plus_left_minus_right_int_less_unsigned() { + unsigned x = f(), y = x-1; + ++x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$2{int}) + 1U) < ((conj_$2{int}) - 1U)}} +} + +void compare_same_symbol_minus_left_plus_right_int_less_unsigned() { + unsigned x = f(), y = x+1; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}} + clang_analyzer_dump(x < y); + // expected-warning@-1{{((conj_$2{int}) - 1U) < ((conj_$2{int}) + 1U)}} +} + +void compare_same_symbol_minus_left_minus_right_int_less_unsigned() { + unsigned x = f(), y = x-1; + --x; + clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}} + clang_analyzer_eval(x < y); + // expected-warning@-1{{FALSE}} +} + +void overflow(signed char n, signed char m) { + if (n + 0 > m + 0) { + clang_analyzer_eval(n - 126 == m + 3); // expected-warning{{UNKNOWN}} + } +} + +int mixed_integer_types(int x, int y) { + short a = x - 1U; + return a - y; +} diff --git a/test/Analysis/symbol-reaper.c b/test/Analysis/symbol-reaper.c index 72fcc7e2b9df..a47161bea2e3 100644 --- a/test/Analysis/symbol-reaper.c +++ b/test/Analysis/symbol-reaper.c @@ -3,6 +3,9 @@ void clang_analyzer_eval(int); void clang_analyzer_warnOnDeadSymbol(int); void clang_analyzer_numTimesReached(); +void clang_analyzer_warnIfReached(); + +void exit(int); int conjure_index(); @@ -58,6 +61,12 @@ struct S1 { struct S2 { struct S1 array[5]; } s2; +struct S3 { + void *field; +}; + +struct S1 *conjure_S1(); +struct S3 *conjure_S3(); void test_element_index_lifetime_with_complicated_hierarchy_of_regions() { do { @@ -68,6 +77,18 @@ void test_element_index_lifetime_with_complicated_hierarchy_of_regions() { } while (0); // no-warning } +void test_loc_as_integer_element_index_lifetime() { + do { + int x; + struct S3 *s = conjure_S3(); + clang_analyzer_warnOnDeadSymbol((int)s); + x = (int)&(s->field); + ptr = &arr[x]; + if (s) {} + // FIXME: Should not warn. The symbol is still alive within the ptr's index. + } while (0); // expected-warning{{SYMBOL DEAD}} +} + // Test below checks lifetime of SymbolRegionValue in certain conditions. int **ptrptr; @@ -78,3 +99,38 @@ void test_region_lifetime_as_store_value(int *x) { (void)0; // No-op; make sure the environment forgets things and the GC runs. clang_analyzer_eval(**ptrptr); // expected-warning{{TRUE}} } // no-warning + +int *produce_region_referenced_only_through_field_in_environment_value() { + struct S1 *s = conjure_S1(); + clang_analyzer_warnOnDeadSymbol((int) s); + int *x = &s->field; + return x; +} + +void test_region_referenced_only_through_field_in_environment_value() { + produce_region_referenced_only_through_field_in_environment_value(); +} // expected-warning{{SYMBOL DEAD}} + +void test_region_referenced_only_through_field_in_store_value() { + struct S1 *s = conjure_S1(); + clang_analyzer_warnOnDeadSymbol((int) s); + ptr = &s->field; // Write the symbol into a global. It should live forever. + if (!s) { + exit(0); // no-warning (symbol should not die here) + // exit() is noreturn. + clang_analyzer_warnIfReached(); // no-warning + } + if (!ptr) { // no-warning (symbol should not die here) + // We exit()ed under these constraints earlier. + clang_analyzer_warnIfReached(); // no-warning + } + // The exit() call invalidates globals. The symbol will die here because + // the exit() statement itself is already over and there's no better statement + // to put the diagnostic on. +} // expected-warning{{SYMBOL DEAD}} + +void test_zombie_referenced_only_through_field_in_store_value() { + struct S1 *s = conjure_S1(); + clang_analyzer_warnOnDeadSymbol((int) s); + int *x = &s->field; +} // expected-warning{{SYMBOL DEAD}} diff --git a/test/Analysis/taint-diagnostic-visitor.c b/test/Analysis/taint-diagnostic-visitor.c index 50fc0b6a4e26..6533cd7625ca 100644 --- a/test/Analysis/taint-diagnostic-visitor.c +++ b/test/Analysis/taint-diagnostic-visitor.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.security.taint,core -analyzer-output=text -verify %s +// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.security.taint,core,alpha.security.ArrayBoundV2 -analyzer-output=text -verify %s // This file is for testing enhanced diagnostics produced by the GenericTaintChecker @@ -11,3 +11,26 @@ void taintDiagnostic() scanf("%s", buf); // expected-note {{Taint originated here}} system(buf); // expected-warning {{Untrusted data is passed to a system call}} // expected-note {{Untrusted data is passed to a system call (CERT/STR02-C. Sanitize data passed to complex subsystems)}} } + +int taintDiagnosticOutOfBound() { + int index; + int Array[] = {1, 2, 3, 4, 5}; + scanf("%d", &index); // expected-note {{Taint originated here}} + return Array[index]; // expected-warning {{Out of bound memory access (index is tainted)}} + // expected-note@-1 {{Out of bound memory access (index is tainted)}} +} + +int taintDiagnosticDivZero(int operand) { + scanf("%d", &operand); // expected-note {{Value assigned to 'operand'}} + // expected-note@-1 {{Taint originated here}} + return 10 / operand; // expected-warning {{Division by a tainted value, possibly zero}} + // expected-note@-1 {{Division by a tainted value, possibly zero}} +} + +void taintDiagnosticVLA() { + int x; + scanf("%d", &x); // expected-note {{Value assigned to 'x'}} + // expected-note@-1 {{Taint originated here}} + int vla[x]; // expected-warning {{Declared variable-length array (VLA) has tainted size}} + // expected-note@-1 {{Declared variable-length array (VLA) has tainted size}} +} diff --git a/test/Analysis/taint-generic.c b/test/Analysis/taint-generic.c index d3ca246b82a8..2717e91b4304 100644 --- a/test/Analysis/taint-generic.c +++ b/test/Analysis/taint-generic.c @@ -1,10 +1,16 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=alpha.security.taint,core,alpha.security.ArrayBoundV2 -Wno-format-security -verify %s +// RUN: %clang_analyze_cc1 -DFILE_IS_STRUCT -analyzer-checker=alpha.security.taint,core,alpha.security.ArrayBoundV2 -Wno-format-security -verify %s int scanf(const char *restrict format, ...); int getchar(void); typedef struct _FILE FILE; +#ifdef FILE_IS_STRUCT +extern struct _FILE *stdin; +#else extern FILE *stdin; +#endif + int fscanf(FILE *restrict stream, const char *restrict format, ...); int sprintf(char *str, const char *format, ...); void setproctitle(const char *fmt, ...); diff --git a/test/Analysis/temp-obj-dtors-cfg-output.cpp b/test/Analysis/temp-obj-dtors-cfg-output.cpp index 05b6a31059b4..d08b01cd3964 100644 --- a/test/Analysis/temp-obj-dtors-cfg-output.cpp +++ b/test/Analysis/temp-obj-dtors-cfg-output.cpp @@ -1,8 +1,23 @@ // RUN: rm -f %t -// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -analyzer-config cfg-temporary-dtors=true -std=c++98 %s > %t 2>&1 -// RUN: FileCheck --input-file=%t -check-prefix=CXX98 -check-prefix=CHECK %s -// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -analyzer-config cfg-temporary-dtors=true -std=c++11 %s > %t 2>&1 -// RUN: FileCheck --input-file=%t -check-prefix=CXX11 -check-prefix=CHECK %s +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=false -std=c++98 %s > %t 2>&1 +// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,CXX98,WARNINGS,CXX98-WARNINGS %s +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=false -std=c++11 %s > %t 2>&1 +// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,CXX11,WARNINGS,CXX11-WARNINGS %s +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=true -std=c++98 %s > %t 2>&1 +// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,CXX98,ANALYZER,CXX98-ANALYZER %s +// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=true -std=c++11 %s > %t 2>&1 +// 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. class A { public: @@ -190,6 +205,24 @@ int testConsistencyNestedNormalReturn(bool value) { return 0; } +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 +const C &bar3(bool coin) { + return coin ? foo1() : foo1(); // no-crash +} +} // end namespace pass_references_through + // CHECK: [B1 (ENTRY)] // CHECK: Succs (1): B0 // CHECK: [B0 (EXIT)] @@ -201,11 +234,13 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B2 (ENTRY)] // CHECK: Succs (1): B1 // CHECK: [B1] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER: 1: A() (CXXConstructExpr, [B1.2], [B1.4], [B1.5], class A) // CHECK: 2: [B1.1] (BindTemporary) // CHECK: 3: [B1.2] (ImplicitCastExpr, NoOp, const class A) // CHECK: 4: [B1.3] -// CHECK: 5: [B1.4] (CXXConstructExpr, class A) +// WARNINGS: 5: [B1.4] (CXXConstructExpr, class A) +// ANALYZER: 5: [B1.4] (CXXConstructExpr, [B1.7], class A) // CHECK: 6: ~A() (Temporary object destructor) // CHECK: 7: return [B1.5]; // CHECK: Preds (1): B2 @@ -259,11 +294,13 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B2 (ENTRY)] // CHECK: Succs (1): B1 // CHECK: [B1] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER: 1: A() (CXXConstructExpr, [B1.2], [B1.4], [B1.5], class A) // CHECK: 2: [B1.1] (BindTemporary) // CHECK: 3: [B1.2] (ImplicitCastExpr, NoOp, const class A) // CHECK: 4: [B1.3] -// CHECK: 5: [B1.4] (CXXConstructExpr, class A) +// WARNINGS: 5: [B1.4] (CXXConstructExpr, class A) +// ANALYZER: 5: [B1.4] (CXXConstructExpr, [B1.7], class A) // CHECK: 6: ~A() (Temporary object destructor) // CHECK: 7: return [B1.5]; // CHECK: Preds (1): B2 @@ -273,41 +310,49 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B2 (ENTRY)] // CHECK: Succs (1): B1 // CHECK: [B1] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER: 1: A() (CXXConstructExpr, [B1.2], [B1.3], class A) // CHECK: 2: [B1.1] (BindTemporary) -// CHECK: 3: [B1.2].operator int -// CHECK: 4: [B1.2] -// CHECK: 5: [B1.4] (ImplicitCastExpr, UserDefinedConversion, int) -// CHECK: 6: int([B1.5]) (CXXFunctionalCastExpr, NoOp, int) -// CHECK: 7: B() (CXXConstructExpr, class B) -// CHECK: 8: [B1.7] (BindTemporary) -// CHECK: 9: [B1.8].operator int -// CHECK: 10: [B1.8] -// CHECK: 11: [B1.10] (ImplicitCastExpr, UserDefinedConversion, int) -// CHECK: 12: int([B1.11]) (CXXFunctionalCastExpr, NoOp, int) -// CHECK: 13: [B1.6] + [B1.12] -// CHECK: 14: int a = int(A()) + int(B()); -// CHECK: 15: ~B() (Temporary object destructor) -// CHECK: 16: ~A() (Temporary object destructor) -// CHECK: 17: foo -// CHECK: 18: [B1.17] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(int)) -// CHECK: 19: A() (CXXConstructExpr, class A) -// CHECK: 20: [B1.19] (BindTemporary) -// CHECK: 21: [B1.20].operator int -// CHECK: 22: [B1.20] -// CHECK: 23: [B1.22] (ImplicitCastExpr, UserDefinedConversion, int) -// CHECK: 24: int([B1.23]) (CXXFunctionalCastExpr, NoOp, int) -// CHECK: 25: B() (CXXConstructExpr, class B) -// CHECK: 26: [B1.25] (BindTemporary) -// CHECK: 27: [B1.26].operator int -// CHECK: 28: [B1.26] -// CHECK: 29: [B1.28] (ImplicitCastExpr, UserDefinedConversion, int) -// CHECK: 30: int([B1.29]) (CXXFunctionalCastExpr, NoOp, int) -// CHECK: 31: [B1.24] + [B1.30] -// CHECK: 32: [B1.18]([B1.31]) -// CHECK: 33: ~B() (Temporary object destructor) -// CHECK: 34: ~A() (Temporary object destructor) -// CHECK: 35: int b; +// 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; // CHECK: Preds (1): B2 // CHECK: Succs (1): B0 // CHECK: [B0 (EXIT)] @@ -324,29 +369,33 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (1): B3 // CHECK: Succs (1): B1 // CHECK: [B3] -// CHECK: 1: [B5.8] && [B4.5] +// CHECK: 1: [B5.9] && [B4.6] // CHECK: 2: [B5.3]([B3.1]) // CHECK: T: (Temp Dtor) [B4.2] // CHECK: Preds (2): B4 B5 // CHECK: Succs (2): B2 B1 // CHECK: [B4] -// CHECK: 1: B() (CXXConstructExpr, class B) +// WARNINGS: 1: B() (CXXConstructExpr, class B) +// ANALYZER: 1: B() (CXXConstructExpr, [B4.2], [B4.3], class B) // CHECK: 2: [B4.1] (BindTemporary) -// CHECK: 3: [B4.2].operator bool -// CHECK: 4: [B4.2] -// CHECK: 5: [B4.4] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CHECK: 3: [B4.2] +// CHECK: 4: [B4.3].operator bool +// CHECK: 5: [B4.3] +// CHECK: 6: [B4.5] (ImplicitCastExpr, UserDefinedConversion, _Bool) // CHECK: Preds (1): B5 // CHECK: Succs (1): B3 // CHECK: [B5] // CHECK: 1: ~A() (Temporary object destructor) // CHECK: 2: foo // CHECK: 3: [B5.2] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(_Bool)) -// CHECK: 4: A() (CXXConstructExpr, class A) +// WARNINGS: 4: A() (CXXConstructExpr, class A) +// ANALYZER: 4: A() (CXXConstructExpr, [B5.5], [B5.6], class A) // CHECK: 5: [B5.4] (BindTemporary) -// CHECK: 6: [B5.5].operator bool -// CHECK: 7: [B5.5] -// CHECK: 8: [B5.7] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CHECK: T: [B5.8] && ... +// 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] && ... // CHECK: Preds (2): B6 B7 // CHECK: Succs (2): B4 B3 // CHECK: [B6] @@ -354,26 +403,30 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (1): B7 // CHECK: Succs (1): B5 // CHECK: [B7] -// CHECK: 1: [B9.5] && [B8.5] +// CHECK: 1: [B9.6] && [B8.6] // CHECK: 2: bool a = A() && B(); // CHECK: T: (Temp Dtor) [B8.2] // CHECK: Preds (2): B8 B9 // CHECK: Succs (2): B6 B5 // CHECK: [B8] -// CHECK: 1: B() (CXXConstructExpr, class B) +// WARNINGS: 1: B() (CXXConstructExpr, class B) +// ANALYZER: 1: B() (CXXConstructExpr, [B8.2], [B8.3], class B) // CHECK: 2: [B8.1] (BindTemporary) -// CHECK: 3: [B8.2].operator bool -// CHECK: 4: [B8.2] -// CHECK: 5: [B8.4] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CHECK: 3: [B8.2] +// CHECK: 4: [B8.3].operator bool +// CHECK: 5: [B8.3] +// CHECK: 6: [B8.5] (ImplicitCastExpr, UserDefinedConversion, _Bool) // CHECK: Preds (1): B9 // CHECK: Succs (1): B7 // CHECK: [B9] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER: 1: A() (CXXConstructExpr, [B9.2], [B9.3], class A) // CHECK: 2: [B9.1] (BindTemporary) -// CHECK: 3: [B9.2].operator bool -// CHECK: 4: [B9.2] -// CHECK: 5: [B9.4] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CHECK: T: [B9.5] && ... +// 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] && ... // CHECK: Preds (1): B10 // CHECK: Succs (2): B8 B7 // CHECK: [B0 (EXIT)] @@ -390,29 +443,33 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (1): B3 // CHECK: Succs (1): B1 // CHECK: [B3] -// CHECK: 1: [B5.8] || [B4.5] +// CHECK: 1: [B5.9] || [B4.6] // CHECK: 2: [B5.3]([B3.1]) // CHECK: T: (Temp Dtor) [B4.2] // CHECK: Preds (2): B4 B5 // CHECK: Succs (2): B2 B1 // CHECK: [B4] -// CHECK: 1: B() (CXXConstructExpr, class B) +// WARNINGS: 1: B() (CXXConstructExpr, class B) +// ANALYZER: 1: B() (CXXConstructExpr, [B4.2], [B4.3], class B) // CHECK: 2: [B4.1] (BindTemporary) -// CHECK: 3: [B4.2].operator bool -// CHECK: 4: [B4.2] -// CHECK: 5: [B4.4] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CHECK: 3: [B4.2] +// CHECK: 4: [B4.3].operator bool +// CHECK: 5: [B4.3] +// CHECK: 6: [B4.5] (ImplicitCastExpr, UserDefinedConversion, _Bool) // CHECK: Preds (1): B5 // CHECK: Succs (1): B3 // CHECK: [B5] // CHECK: 1: ~A() (Temporary object destructor) // CHECK: 2: foo // CHECK: 3: [B5.2] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(_Bool)) -// CHECK: 4: A() (CXXConstructExpr, class A) +// WARNINGS: 4: A() (CXXConstructExpr, class A) +// ANALYZER: 4: A() (CXXConstructExpr, [B5.5], [B5.6], class A) // CHECK: 5: [B5.4] (BindTemporary) -// CHECK: 6: [B5.5].operator bool -// CHECK: 7: [B5.5] -// CHECK: 8: [B5.7] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CHECK: T: [B5.8] || ... +// 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] || ... // CHECK: Preds (2): B6 B7 // CHECK: Succs (2): B3 B4 // CHECK: [B6] @@ -420,26 +477,30 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (1): B7 // CHECK: Succs (1): B5 // CHECK: [B7] -// CHECK: 1: [B9.5] || [B8.5] +// CHECK: 1: [B9.6] || [B8.6] // CHECK: 2: bool a = A() || B(); // CHECK: T: (Temp Dtor) [B8.2] // CHECK: Preds (2): B8 B9 // CHECK: Succs (2): B6 B5 // CHECK: [B8] -// CHECK: 1: B() (CXXConstructExpr, class B) +// WARNINGS: 1: B() (CXXConstructExpr, class B) +// ANALYZER: 1: B() (CXXConstructExpr, [B8.2], [B8.3], class B) // CHECK: 2: [B8.1] (BindTemporary) -// CHECK: 3: [B8.2].operator bool -// CHECK: 4: [B8.2] -// CHECK: 5: [B8.4] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CHECK: 3: [B8.2] +// CHECK: 4: [B8.3].operator bool +// CHECK: 5: [B8.3] +// CHECK: 6: [B8.5] (ImplicitCastExpr, UserDefinedConversion, _Bool) // CHECK: Preds (1): B9 // CHECK: Succs (1): B7 // CHECK: [B9] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER: 1: A() (CXXConstructExpr, [B9.2], [B9.3], class A) // CHECK: 2: [B9.1] (BindTemporary) -// CHECK: 3: [B9.2].operator bool -// CHECK: 4: [B9.2] -// CHECK: 5: [B9.4] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CHECK: T: [B9.5] || ... +// 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] || ... // CHECK: Preds (1): B10 // CHECK: Succs (2): B7 B8 // CHECK: [B0 (EXIT)] @@ -467,13 +528,15 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B1 // CHECK: [B4] // CHECK: 1: ~B() (Temporary object destructor) -// CHECK: 2: B() (CXXConstructExpr, class B) +// WARNINGS: 2: B() (CXXConstructExpr, class B) +// ANALYZER: 2: B() (CXXConstructExpr, [B4.3], [B4.4], class B) // CHECK: 3: [B4.2] (BindTemporary) -// CHECK: 4: [B4.3].operator bool -// CHECK: 5: [B4.3] -// CHECK: 6: [B4.5] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CHECK: 7: ~B() (Temporary object destructor) -// CHECK: T: if [B4.6] +// 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] // CHECK: Preds (2): B5 B6 // CHECK: Succs (2): B3 B2 // CHECK: [B5] @@ -489,48 +552,57 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (1): B7 // CHECK: Succs (1): B4 // CHECK: [B7] -// CHECK: 1: [B10.5] ? [B8.6] : [B9.15] +// CHECK: 1: [B10.6] ? [B8.6] : [B9.16] // CHECK: 2: [B7.1] (ImplicitCastExpr, NoOp, const class A) // CHECK: 3: [B7.2] -// CHECK: 4: [B7.3] (CXXConstructExpr, class A) +// WARNINGS: 4: [B7.3] (CXXConstructExpr, class A) +// ANALYZER: 4: [B7.3] (CXXConstructExpr, [B7.5], class A) // CHECK: 5: A a = B() ? A() : A(B()); // CHECK: T: (Temp Dtor) [B9.2] // CHECK: Preds (2): B8 B9 // CHECK: Succs (2): B6 B5 // CHECK: [B8] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER: 1: A() (CXXConstructExpr, [B8.2], [B8.4], [B8.5], class A) // CHECK: 2: [B8.1] (BindTemporary) // CHECK: 3: [B8.2] (ImplicitCastExpr, NoOp, const class A) // CHECK: 4: [B8.3] -// CHECK: 5: [B8.4] (CXXConstructExpr, class A) +// WARNINGS: 5: [B8.4] (CXXConstructExpr, class A) +// ANALYZER: 5: [B8.4] (CXXConstructExpr, [B8.6], [B7.3], [B7.4], class A) // CHECK: 6: [B8.5] (BindTemporary) // CHECK: Preds (1): B10 // CHECK: Succs (1): B7 // CHECK: [B9] -// CHECK: 1: B() (CXXConstructExpr, class B) +// WARNINGS: 1: B() (CXXConstructExpr, class B) +// ANALYZER: 1: B() (CXXConstructExpr, [B9.2], [B9.3], class B) // CHECK: 2: [B9.1] (BindTemporary) -// CHECK: 3: [B9.2].operator A -// CHECK: 4: [B9.2] -// CHECK: 5: [B9.4] (ImplicitCastExpr, UserDefinedConversion, class A) -// CHECK: 6: [B9.5] (BindTemporary) -// CHECK: 7: [B9.6] (ImplicitCastExpr, NoOp, const class A) -// CHECK: 8: [B9.7] -// CHECK: 9: [B9.8] (CXXConstructExpr, class A) -// CHECK: 10: [B9.9] (BindTemporary) -// CHECK: 11: A([B9.10]) (CXXFunctionalCastExpr, ConstructorConversion, class A) -// CHECK: 12: [B9.11] (ImplicitCastExpr, NoOp, const class A) -// CHECK: 13: [B9.12] -// CHECK: 14: [B9.13] (CXXConstructExpr, class A) -// CHECK: 15: [B9.14] (BindTemporary) +// 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) // CHECK: Preds (1): B10 // CHECK: Succs (1): B7 // CHECK: [B10] -// CHECK: 1: B() (CXXConstructExpr, class B) +// WARNINGS: 1: B() (CXXConstructExpr, class B) +// ANALYZER: 1: B() (CXXConstructExpr, [B10.2], [B10.3], class B) // CHECK: 2: [B10.1] (BindTemporary) -// CHECK: 3: [B10.2].operator bool -// CHECK: 4: [B10.2] -// CHECK: 5: [B10.4] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CHECK: T: [B10.5] ? ... : ... +// 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] ? ... : ... // CHECK: Preds (1): B11 // CHECK: Succs (2): B8 B9 // CHECK: [B0 (EXIT)] @@ -592,13 +664,15 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (1): B3 // CHECK: Succs (1): B0 // CHECK: [B3] -// CHECK: 1: C() (CXXConstructExpr, struct C) +// WARNINGS: 1: C() (CXXConstructExpr, struct C) +// ANALYZER: 1: C() (CXXConstructExpr, [B3.2], [B3.3], struct C) // CHECK: 2: [B3.1] (BindTemporary) -// CHECK: 3: [B3.2].operator bool -// CHECK: 4: [B3.2] -// CHECK: 5: [B3.4] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CHECK: 6: ~C() (Temporary object destructor) -// CHECK: T: if [B3.5] +// 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] // CHECK: Preds (1): B4 // CHECK: Succs (2): B2 B1 // CHECK: [B0 (EXIT)] @@ -621,11 +695,13 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (1): B4 // CHECK: Succs (1): B0 // CHECK: [B4] -// CHECK: 1: C() (CXXConstructExpr, struct C) +// WARNINGS: 1: C() (CXXConstructExpr, struct C) +// ANALYZER: 1: C() (CXXConstructExpr, [B4.2], [B4.4], [B4.5], struct C) // CHECK: 2: [B4.1] (BindTemporary) // CHECK: 3: [B4.2] (ImplicitCastExpr, NoOp, const struct C) // CHECK: 4: [B4.3] -// CHECK: 5: [B4.4] (CXXConstructExpr, struct C) +// WARNINGS: 5: [B4.4] (CXXConstructExpr, struct C) +// ANALYZER: 5: [B4.4] (CXXConstructExpr, [B4.6], struct C) // CHECK: 6: C c = C(); // CHECK: 7: ~C() (Temporary object destructor) // CHECK: 8: c @@ -650,11 +726,13 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (1): B3 // CHECK: Succs (1): B0 // CHECK: [B3] -// CHECK: 1: D() (CXXConstructExpr, struct D) -// CHECK: 2: [B3.1].operator bool -// CHECK: 3: [B3.1] -// CHECK: 4: [B3.3] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CHECK: T: if [B3.4] +// 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] // CHECK: Preds (1): B4 // CHECK: Succs (2): B2 B1 // CHECK: [B0 (EXIT)] @@ -672,18 +750,23 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (1): B3 // CHECK: Succs (1): B0 // CHECK: [B3] -// CHECK: 1: D() (CXXConstructExpr, struct D) +// CXX98-WARNINGS: 1: D() (CXXConstructExpr, struct D) +// CXX98-ANALYZER: 1: D() (CXXConstructExpr, [B3.3], [B3.4], struct D) // CXX98: 2: [B3.1] (ImplicitCastExpr, NoOp, const struct D) // CXX98: 3: [B3.2] -// CXX98: 4: [B3.3] (CXXConstructExpr, struct D) +// CXX98-WARNINGS: 4: [B3.3] (CXXConstructExpr, struct D) +// CXX98-ANALYZER: 4: [B3.3] (CXXConstructExpr, [B3.5], struct D) // 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] +// CXX11-WARNINGS: 1: D() (CXXConstructExpr, struct D) +// CXX11-ANALYZER: 1: D() (CXXConstructExpr, [B3.2], [B3.3], struct D) // CXX11: 2: [B3.1] -// CXX11: 3: [B3.2] (CXXConstructExpr, struct D) +// CXX11-WARNINGS: 3: [B3.2] (CXXConstructExpr, struct D) +// CXX11-ANALYZER: 3: [B3.2] (CXXConstructExpr, [B3.4], struct D) // CXX11: 4: D d = D(); // CXX11: 5: d // CXX11: 6: [B3.5].operator bool @@ -715,7 +798,7 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (1): B4 // CHECK: Succs (1): B1 // CHECK: [B4] -// CHECK: 1: [B7.8] ? [B5.6] : [B6.15] +// CHECK: 1: [B7.9] ? [B5.6] : [B6.16] // CHECK: 2: [B4.1] (ImplicitCastExpr, NoOp, const class A) // CHECK: 3: [B4.2] // CHECK: 4: [B7.3]([B4.3]) @@ -723,42 +806,50 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (2): B5 B6 // CHECK: Succs (2): B3 B2 // CHECK: [B5] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER: 1: A() (CXXConstructExpr, [B5.2], [B5.4], [B5.5], class A) // CHECK: 2: [B5.1] (BindTemporary) // CHECK: 3: [B5.2] (ImplicitCastExpr, NoOp, const class A) // CHECK: 4: [B5.3] -// CHECK: 5: [B5.4] (CXXConstructExpr, class A) +// WARNINGS: 5: [B5.4] (CXXConstructExpr, class A) +// ANALYZER: 5: [B5.4] (CXXConstructExpr, [B5.6], [B4.3], class A) // CHECK: 6: [B5.5] (BindTemporary) // CHECK: Preds (1): B7 // CHECK: Succs (1): B4 // CHECK: [B6] -// CHECK: 1: B() (CXXConstructExpr, class B) +// WARNINGS: 1: B() (CXXConstructExpr, class B) +// ANALYZER: 1: B() (CXXConstructExpr, [B6.2], [B6.3], class B) // CHECK: 2: [B6.1] (BindTemporary) -// CHECK: 3: [B6.2].operator A -// CHECK: 4: [B6.2] -// CHECK: 5: [B6.4] (ImplicitCastExpr, UserDefinedConversion, class A) -// CHECK: 6: [B6.5] (BindTemporary) -// CHECK: 7: [B6.6] (ImplicitCastExpr, NoOp, const class A) -// CHECK: 8: [B6.7] -// CHECK: 9: [B6.8] (CXXConstructExpr, class A) -// CHECK: 10: [B6.9] (BindTemporary) -// CHECK: 11: A([B6.10]) (CXXFunctionalCastExpr, ConstructorConversion, class A) -// CHECK: 12: [B6.11] (ImplicitCastExpr, NoOp, const class A) -// CHECK: 13: [B6.12] -// CHECK: 14: [B6.13] (CXXConstructExpr, class A) -// CHECK: 15: [B6.14] (BindTemporary) +// 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) // CHECK: Preds (1): B7 // CHECK: Succs (1): B4 // CHECK: [B7] // CHECK: 1: ~B() (Temporary object destructor) // CHECK: 2: foo // CHECK: 3: [B7.2] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &)) -// CHECK: 4: B() (CXXConstructExpr, class B) +// WARNINGS: 4: B() (CXXConstructExpr, class B) +// ANALYZER: 4: B() (CXXConstructExpr, [B7.5], [B7.6], class B) // CHECK: 5: [B7.4] (BindTemporary) -// CHECK: 6: [B7.5].operator bool -// CHECK: 7: [B7.5] -// CHECK: 8: [B7.7] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CHECK: T: [B7.8] ? ... : ... +// 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] ? ... : ... // CHECK: Preds (2): B8 B9 // CHECK: Succs (2): B5 B6 // CHECK: [B8] @@ -772,7 +863,7 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (1): B10 // CHECK: Succs (1): B7 // CHECK: [B10] -// CHECK: 1: [B13.5] ? [B11.6] : [B12.15] +// CHECK: 1: [B13.6] ? [B11.6] : [B12.16] // CHECK: 2: [B10.1] (ImplicitCastExpr, NoOp, const class A) // CHECK: 3: [B10.2] // CHECK: 4: const A &a = B() ? A() : A(B()); @@ -780,39 +871,47 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (2): B11 B12 // CHECK: Succs (2): B9 B8 // CHECK: [B11] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER: 1: A() (CXXConstructExpr, [B11.2], [B11.4], [B11.5], class A) // CHECK: 2: [B11.1] (BindTemporary) // CHECK: 3: [B11.2] (ImplicitCastExpr, NoOp, const class A) // CHECK: 4: [B11.3] -// CHECK: 5: [B11.4] (CXXConstructExpr, class A) +// WARNINGS: 5: [B11.4] (CXXConstructExpr, class A) +// ANALYZER: 5: [B11.4] (CXXConstructExpr, [B10.3], class A) // CHECK: 6: [B11.5] (BindTemporary) // CHECK: Preds (1): B13 // CHECK: Succs (1): B10 // CHECK: [B12] -// CHECK: 1: B() (CXXConstructExpr, class B) +// WARNINGS: 1: B() (CXXConstructExpr, class B) +// ANALYZER: 1: B() (CXXConstructExpr, [B12.2], [B12.3], class B) // CHECK: 2: [B12.1] (BindTemporary) -// CHECK: 3: [B12.2].operator A -// CHECK: 4: [B12.2] -// CHECK: 5: [B12.4] (ImplicitCastExpr, UserDefinedConversion, class A) -// CHECK: 6: [B12.5] (BindTemporary) -// CHECK: 7: [B12.6] (ImplicitCastExpr, NoOp, const class A) -// CHECK: 8: [B12.7] -// CHECK: 9: [B12.8] (CXXConstructExpr, class A) -// CHECK: 10: [B12.9] (BindTemporary) -// CHECK: 11: A([B12.10]) (CXXFunctionalCastExpr, ConstructorConversion, class A) -// CHECK: 12: [B12.11] (ImplicitCastExpr, NoOp, const class A) -// CHECK: 13: [B12.12] -// CHECK: 14: [B12.13] (CXXConstructExpr, class A) -// CHECK: 15: [B12.14] (BindTemporary) +// 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) // CHECK: Preds (1): B13 // CHECK: Succs (1): B10 // CHECK: [B13] -// CHECK: 1: B() (CXXConstructExpr, class B) +// WARNINGS: 1: B() (CXXConstructExpr, class B) +// ANALYZER: 1: B() (CXXConstructExpr, [B13.2], [B13.3], class B) // CHECK: 2: [B13.1] (BindTemporary) -// CHECK: 3: [B13.2].operator bool -// CHECK: 4: [B13.2] -// CHECK: 5: [B13.4] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CHECK: T: [B13.5] ? ... : ... +// 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] ? ... : ... // CHECK: Preds (1): B14 // CHECK: Succs (2): B11 B12 // CHECK: [B0 (EXIT)] @@ -838,7 +937,8 @@ int testConsistencyNestedNormalReturn(bool value) { // CXX11: 1: [B7.3] ?: [B6.6] // CHECK: 2: [B4.1] (ImplicitCastExpr, NoOp, const class A) // CHECK: 3: [B4.2] -// CHECK: 4: [B4.3] (CXXConstructExpr, class A) +// WARNINGS: 4: [B4.3] (CXXConstructExpr, class A) +// ANALYZER: 4: [B4.3] (CXXConstructExpr, [B4.5], class A) // CHECK: 5: A a = A() ?: A(); // CHECK: T: (Temp Dtor) [B6.2] // CHECK: Preds (2): B5 B6 @@ -846,34 +946,36 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B5] // CXX98: 1: [B7.2] (ImplicitCastExpr, NoOp, const class A) // CXX98: 2: [B5.1] -// CXX98: 3: [B5.2] (CXXConstructExpr, class A) +// WARNINGS-CXX98: 3: [B5.2] (CXXConstructExpr, class A) +// ANALYZER-CXX98: 3: [B5.2] (CXXConstructExpr, [B5.4], class A) // CXX98: 4: [B5.3] (BindTemporary) // CXX11: 1: [B7.3] (ImplicitCastExpr, NoOp, const class A) -// CXX11: 2: [B5.1] (CXXConstructExpr, class A) +// WARNINGS-CXX11: 2: [B5.1] (CXXConstructExpr, class A) +// ANALYZER-CXX11: 2: [B5.1] (CXXConstructExpr, [B5.3], class A) // CXX11: 3: [B5.2] (BindTemporary) // CHECK: Preds (1): B7 // CHECK: Succs (1): B4 // CHECK: [B6] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER: 1: A() (CXXConstructExpr, [B6.2], [B6.4], [B6.5], class A) // CHECK: 2: [B6.1] (BindTemporary) // CHECK: 3: [B6.2] (ImplicitCastExpr, NoOp, const class A) // CHECK: 4: [B6.3] -// CHECK: 5: [B6.4] (CXXConstructExpr, class A) +// WARNINGS: 5: [B6.4] (CXXConstructExpr, class A) +// ANALYZER: 5: [B6.4] (CXXConstructExpr, [B6.6], class A) // CHECK: 6: [B6.5] (BindTemporary) // CHECK: Preds (1): B7 // CHECK: Succs (1): B4 // CHECK: [B7] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER-CXX98: 1: A() (CXXConstructExpr, [B7.2], [B7.3], class A) +// ANALYZER-CXX11: 1: A() (CXXConstructExpr, [B7.2], class A) // CHECK: 2: [B7.1] (BindTemporary) -// CXX98: 3: [B7.2].operator bool -// CXX98: 4: [B7.2] -// CXX98: 5: [B7.4] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CXX98: T: [B7.5] ? ... : ... -// CXX11: 3: [B7.2] -// CXX11: 4: [B7.3].operator bool -// CXX11: 5: [B7.3] -// CXX11: 6: [B7.5] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CXX11: T: [B7.6] ? ... : ... +// 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] ? ... : ... // CHECK: Preds (1): B8 // CHECK: Succs (2): B5 B6 // CHECK: [B0 (EXIT)] @@ -906,36 +1008,38 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B5] // CXX98: 1: [B7.4] (ImplicitCastExpr, NoOp, const class A) // CXX98: 2: [B5.1] -// CXX98: 3: [B5.2] (CXXConstructExpr, class A) +// WARNINGS-CXX98: 3: [B5.2] (CXXConstructExpr, class A) +// ANALYZER-CXX98: 3: [B5.2] (CXXConstructExpr, [B5.4], class A) // CXX98: 4: [B5.3] (BindTemporary) // CXX11: 1: [B7.5] (ImplicitCastExpr, NoOp, const class A) -// CXX11: 2: [B5.1] (CXXConstructExpr, class A) +// WARNINGS-CXX11: 2: [B5.1] (CXXConstructExpr, class A) +// ANALYZER-CXX11: 2: [B5.1] (CXXConstructExpr, [B5.3], class A) // CXX11: 3: [B5.2] (BindTemporary) // CHECK: Preds (1): B7 // CHECK: Succs (1): B4 // CHECK: [B6] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER: 1: A() (CXXConstructExpr, [B6.2], [B6.4], [B6.5], class A) // CHECK: 2: [B6.1] (BindTemporary) // CHECK: 3: [B6.2] (ImplicitCastExpr, NoOp, const class A) // CHECK: 4: [B6.3] -// CHECK: 5: [B6.4] (CXXConstructExpr, class A) +// WARNINGS: 5: [B6.4] (CXXConstructExpr, class A) +// ANALYZER: 5: [B6.4] (CXXConstructExpr, [B6.6], class A) // CHECK: 6: [B6.5] (BindTemporary) // CHECK: Preds (1): B7 // CHECK: Succs (1): B4 // CHECK: [B7] // CHECK: 1: foo // CHECK: 2: [B7.1] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &)) -// CHECK: 3: A() (CXXConstructExpr, class A) +// WARNINGS: 3: A() (CXXConstructExpr, class A) +// ANALYZER-CXX98: 3: A() (CXXConstructExpr, [B7.4], class A) +// ANALYZER-CXX11: 3: A() (CXXConstructExpr, class A) // CHECK: 4: [B7.3] (BindTemporary) -// CXX98: 5: [B7.4].operator bool -// CXX98: 6: [B7.4] -// CXX98: 7: [B7.6] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CXX98: T: [B7.7] ? ... : ... -// CXX11: 5: [B7.4] -// CXX11: 6: [B7.5].operator bool -// CXX11: 7: [B7.5] -// CXX11: 8: [B7.7] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CXX11: T: [B7.8] ? ... : ... +// 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] ? ... : ... // CHECK: Preds (2): B8 B9 // CHECK: Succs (2): B5 B6 // CHECK: [B8] @@ -954,34 +1058,36 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B10] // CXX98: 1: [B12.2] (ImplicitCastExpr, NoOp, const class A) // CXX98: 2: [B10.1] -// CXX98: 3: [B10.2] (CXXConstructExpr, class A) +// WARNINGS-CXX98: 3: [B10.2] (CXXConstructExpr, class A) +// ANALYZER-CXX98: 3: [B10.2] (CXXConstructExpr, [B10.4], class A) // CXX98: 4: [B10.3] (BindTemporary) // CXX11: 1: [B12.3] (ImplicitCastExpr, NoOp, const class A) -// CXX11: 2: [B10.1] (CXXConstructExpr, class A) +// WARNINGS-CXX11: 2: [B10.1] (CXXConstructExpr, class A) +// ANALYZER-CXX11: 2: [B10.1] (CXXConstructExpr, [B10.3], class A) // CXX11: 3: [B10.2] (BindTemporary) // CHECK: Preds (1): B12 // CHECK: Succs (1): B9 // CHECK: [B11] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS-CHECK: 1: A() (CXXConstructExpr, class A) +// ANALYZER-CHECK: 1: A() (CXXConstructExpr, [B11.2], class A) // CHECK: 2: [B11.1] (BindTemporary) // CHECK: 3: [B11.2] (ImplicitCastExpr, NoOp, const class A) // CHECK: 4: [B11.3] -// CHECK: 5: [B11.4] (CXXConstructExpr, class A) +// WARNINGS: 5: [B11.4] (CXXConstructExpr, class A) +// ANALYZER: 5: [B11.4] (CXXConstructExpr, [B11.6], class A) // CHECK: 6: [B11.5] (BindTemporary) // CHECK: Preds (1): B12 // CHECK: Succs (1): B9 // CHECK: [B12] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER-CXX98: 1: A() (CXXConstructExpr, [B12.2], [B12.3], class A) +// ANALYZER-CXX11: 1: A() (CXXConstructExpr, [B12.2], class A) // CHECK: 2: [B12.1] (BindTemporary) -// CXX98: 3: [B12.2].operator bool -// CXX98: 4: [B12.2] -// CXX98: 5: [B12.4] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CXX98: T: [B12.5] ? ... : ... -// CXX11: 3: [B12.2] -// CXX11: 4: [B12.3].operator bool -// CXX11: 5: [B12.3] -// CXX11: 6: [B12.5] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CXX11: T: [B12.6] ? ... : ... +// 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] ? ... : ... // CHECK: Preds (1): B13 // CHECK: Succs (2): B10 B11 // CHECK: [B0 (EXIT)] @@ -989,11 +1095,13 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B2 (ENTRY)] // CHECK: Succs (1): B1 // CHECK: [B1] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER: 1: A() (CXXConstructExpr, [B1.2], [B1.4], [B1.5], class A) // CHECK: 2: [B1.1] (BindTemporary) // CHECK: 3: [B1.2] (ImplicitCastExpr, NoOp, const class A) // CHECK: 4: [B1.3] -// CHECK: 5: [B1.4] (CXXConstructExpr, class A) +// WARNINGS: 5: [B1.4] (CXXConstructExpr, class A) +// ANALYZER: 5: [B1.4] (CXXConstructExpr, [B1.6], class A) // CHECK: 6: A a = A(); // CHECK: 7: ~A() (Temporary object destructor) // CHECK: 8: int b; @@ -1005,14 +1113,16 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B2 (ENTRY)] // CHECK: Succs (1): B1 // CHECK: [B1] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER: 1: A() (CXXConstructExpr, [B1.4], class A) // CHECK: 2: [B1.1] (BindTemporary) // CHECK: 3: [B1.2] (ImplicitCastExpr, NoOp, const class A) // CHECK: 4: [B1.3] // CHECK: 5: const A &a = A(); // CHECK: 6: foo // CHECK: 7: [B1.6] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &)) -// CHECK: 8: A() (CXXConstructExpr, class A) +// WARNINGS: 8: A() (CXXConstructExpr, class A) +// ANALYZER: 8: A() (CXXConstructExpr, [B1.9], [B1.11], class A) // CHECK: 9: [B1.8] (BindTemporary) // CHECK: 10: [B1.9] (ImplicitCastExpr, NoOp, const class A) // CHECK: 11: [B1.10] @@ -1029,11 +1139,13 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B1] // CHECK: 1: A::make // CHECK: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class A (*)(void)) -// CHECK: 3: [B1.2]() +// WARNINGS: 3: [B1.2]() +// ANALYZER: 3: [B1.2]() (CXXRecordTypedCall, [B1.4], [B1.6], [B1.7]) // CHECK: 4: [B1.3] (BindTemporary) // CHECK: 5: [B1.4] (ImplicitCastExpr, NoOp, const class A) // CHECK: 6: [B1.5] -// CHECK: 7: [B1.6] (CXXConstructExpr, class A) +// WARNINGS: 7: [B1.6] (CXXConstructExpr, class A) +// ANALYZER: 7: [B1.6] (CXXConstructExpr, [B1.8], class A) // CHECK: 8: A a = A::make(); // CHECK: 9: ~A() (Temporary object destructor) // CHECK: 10: int b; @@ -1047,7 +1159,8 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B1] // CHECK: 1: A::make // CHECK: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class A (*)(void)) -// CHECK: 3: [B1.2]() +// WARNINGS: 3: [B1.2]() +// ANALYZER: 3: [B1.2]() (CXXRecordTypedCall, [B1.6]) // CHECK: 4: [B1.3] (BindTemporary) // CHECK: 5: [B1.4] (ImplicitCastExpr, NoOp, const class A) // CHECK: 6: [B1.5] @@ -1056,7 +1169,8 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: 9: [B1.8] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &)) // CHECK: 10: A::make // CHECK: 11: [B1.10] (ImplicitCastExpr, FunctionToPointerDecay, class A (*)(void)) -// CHECK: 12: [B1.11]() +// WARNINGS: 12: [B1.11]() +// ANALYZER: 12: [B1.11]() (CXXRecordTypedCall, [B1.13], [B1.15]) // CHECK: 13: [B1.12] (BindTemporary) // CHECK: 14: [B1.13] (ImplicitCastExpr, NoOp, const class A) // CHECK: 15: [B1.14] @@ -1072,15 +1186,17 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B1 // CHECK: [B1] // CHECK: 1: int a; -// CHECK: 2: A() (CXXConstructExpr, class A) +// WARNINGS: 2: A() (CXXConstructExpr, class A) +// ANALYZER: 2: A() (CXXConstructExpr, [B1.3], [B1.4], class A) // CHECK: 3: [B1.2] (BindTemporary) -// CHECK: 4: [B1.3].operator int -// CHECK: 5: [B1.3] -// CHECK: 6: [B1.5] (ImplicitCastExpr, UserDefinedConversion, int) -// CHECK: 7: a -// CHECK: 8: [B1.7] = [B1.6] -// CHECK: 9: ~A() (Temporary object destructor) -// CHECK: 10: int b; +// 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; // CHECK: Preds (1): B2 // CHECK: Succs (1): B0 // CHECK: [B0 (EXIT)] @@ -1088,24 +1204,28 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B2 (ENTRY)] // CHECK: Succs (1): B1 // CHECK: [B1] -// CHECK: 1: A() (CXXConstructExpr, class A) +// WARNINGS: 1: A() (CXXConstructExpr, class A) +// ANALYZER: 1: A() (CXXConstructExpr, [B1.2], [B1.3], class A) // CHECK: 2: [B1.1] (BindTemporary) -// CHECK: 3: [B1.2].operator int -// CHECK: 4: [B1.2] -// CHECK: 5: [B1.4] (ImplicitCastExpr, UserDefinedConversion, int) -// CHECK: 6: int([B1.5]) (CXXFunctionalCastExpr, NoOp, int) -// CHECK: 7: B() (CXXConstructExpr, class B) -// CHECK: 8: [B1.7] (BindTemporary) -// CHECK: 9: [B1.8].operator int -// CHECK: 10: [B1.8] -// CHECK: 11: [B1.10] (ImplicitCastExpr, UserDefinedConversion, int) -// CHECK: 12: int([B1.11]) (CXXFunctionalCastExpr, NoOp, int) -// CHECK: 13: [B1.6] + [B1.12] -// CHECK: 14: a([B1.13]) (Member initializer) -// CHECK: 15: ~B() (Temporary object destructor) -// CHECK: 16: ~A() (Temporary object destructor) -// CHECK: 17: /*implicit*/(int)0 -// CHECK: 18: b([B1.17]) (Member initializer) +// 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) +// CHECK: 19: /*implicit*/(int)0 +// CHECK: 20: b([B1.19]) (Member initializer) // CHECK: Preds (1): B2 // CHECK: Succs (1): B0 // CHECK: [B0 (EXIT)] @@ -1118,7 +1238,9 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B0 // CHECK: [B2 (NORETURN)] // CHECK: 1: int a; -// CHECK: 2: NoReturn() (CXXConstructExpr, class NoReturn) +// WARNINGS: 2: NoReturn() (CXXConstructExpr, class NoReturn) +// ANALYZER-CXX98: 2: NoReturn() (CXXConstructExpr, [B2.3], [B2.4], class NoReturn) +// ANALYZER-CXX11: 2: NoReturn() (CXXConstructExpr, [B2.3], class NoReturn) // CHECK: 3: [B2.2] (BindTemporary) // CHECK: [[MEMBER:[45]]]: [B2.{{[34]}}].f // CHECK: {{[56]}}: [B2.[[MEMBER]]]() @@ -1135,7 +1257,8 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B0 // CHECK: [B2 (NORETURN)] // CHECK: 1: int a; -// CHECK: 2: NoReturn() (CXXConstructExpr, class NoReturn) +// WARNINGS: 2: NoReturn() (CXXConstructExpr, class NoReturn) +// ANALYZER: 2: NoReturn() (CXXConstructExpr, [B2.3], class NoReturn) // CHECK: 3: [B2.2] (BindTemporary) // CHECK: 4: 47 // CHECK: 5: ... , [B2.4] @@ -1172,7 +1295,8 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B6] // CHECK: 1: check // CHECK: 2: [B6.1] (ImplicitCastExpr, FunctionToPointerDecay, _Bool (*)(const class NoReturn &)) -// CHECK: 3: NoReturn() (CXXConstructExpr, class NoReturn) +// WARNINGS: 3: NoReturn() (CXXConstructExpr, class NoReturn) +// ANALYZER: 3: NoReturn() (CXXConstructExpr, [B6.4], [B6.6], class NoReturn) // CHECK: 4: [B6.3] (BindTemporary) // CHECK: 5: [B6.4] (ImplicitCastExpr, NoOp, const class NoReturn) // CHECK: 6: [B6.5] @@ -1222,7 +1346,8 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B6] // CHECK: 1: check // CHECK: 2: [B6.1] (ImplicitCastExpr, FunctionToPointerDecay, _Bool (*)(const class NoReturn &)) -// CHECK: 3: NoReturn() (CXXConstructExpr, class NoReturn) +// WARNINGS: 3: NoReturn() (CXXConstructExpr, class NoReturn) +// ANALYZER: 3: NoReturn() (CXXConstructExpr, [B6.4], [B6.6], class NoReturn) // CHECK: 4: [B6.3] (BindTemporary) // CHECK: 5: [B6.4] (ImplicitCastExpr, NoOp, const class NoReturn) // CHECK: 6: [B6.5] @@ -1279,7 +1404,8 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B6] // CHECK: 1: check // CHECK: 2: [B6.1] (ImplicitCastExpr, FunctionToPointerDecay, _Bool (*)(const class NoReturn &)) -// CHECK: 3: NoReturn() (CXXConstructExpr, class NoReturn) +// WARNINGS: 3: NoReturn() (CXXConstructExpr, class NoReturn) +// ANALYZER: 3: NoReturn() (CXXConstructExpr, [B6.4], [B6.6], class NoReturn) // CHECK: 4: [B6.3] (BindTemporary) // CHECK: 5: [B6.4] (ImplicitCastExpr, NoOp, const class NoReturn) // CHECK: 6: [B6.5] @@ -1307,3 +1433,29 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (2): B8 B1 // CHECK: [B0 (EXIT)] // CHECK: Preds (3): B1 B2 B4 +// 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 diff --git a/test/Analysis/temp-obj-dtors-option.cpp b/test/Analysis/temp-obj-dtors-option.cpp new file mode 100644 index 000000000000..25cc86ebde43 --- /dev/null +++ b/test/Analysis/temp-obj-dtors-option.cpp @@ -0,0 +1,22 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-temp-dtor-inlining=false -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-temp-dtor-inlining=true -DINLINE -verify %s + +void clang_analyzer_eval(bool); + +struct S { + int &x; + + S(int &x) : x(x) { ++x; } + ~S() { --x; } +}; + +void foo() { + int x = 0; + S(x).x += 1; + clang_analyzer_eval(x == 1); +#ifdef INLINE + // expected-warning@-2{{TRUE}} +#else + // expected-warning@-4{{UNKNOWN}} +#endif +} diff --git a/test/Analysis/temporaries-callback-order.cpp b/test/Analysis/temporaries-callback-order.cpp index df916cc4e767..120fabc10478 100644 --- a/test/Analysis/temporaries-callback-order.cpp +++ b/test/Analysis/temporaries-callback-order.cpp @@ -8,11 +8,7 @@ struct Sub : Super { }; void testTemporaries() { - // This triggers RegionChanges twice: - // - Once for zero-initialization of the structure. - // - Once for creating a temporary region and copying the structure there. - // FIXME: This code shouldn't really produce the extra temporary, however - // that's how we behave for now. + // This triggers RegionChanges once for zero-initialization of the structure. Sub().m(); } @@ -29,7 +25,6 @@ void seeIfCheckBindWorks() { // testTemporaries(): // CHECK-NEXT: RegionChanges -// CHECK-NEXT: RegionChanges // Make sure there's no further output. // CHECK-NOT: Bind diff --git a/test/Analysis/temporaries.cpp b/test/Analysis/temporaries.cpp index 99851dd68539..de3420e70891 100644 --- a/test/Analysis/temporaries.cpp +++ b/test/Analysis/temporaries.cpp @@ -1,9 +1,15 @@ -// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify -w -std=c++03 %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify -w -std=c++11 %s -// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -DTEMPORARY_DTORS -verify -w -analyzer-config cfg-temporary-dtors=true %s -std=c++11 +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=false -verify -w -std=c++03 %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=false -verify -w -std=c++11 %s +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -DTEMPORARY_DTORS -verify -w -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true %s -std=c++11 +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -DTEMPORARY_DTORS -w -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true %s -std=c++17 + +// Note: The C++17 run-line doesn't -verify yet - it is a no-crash test. extern bool clang_analyzer_eval(bool); extern bool clang_analyzer_warnIfReached(); +void clang_analyzer_checkInlined(bool); + +#include "Inputs/system-header-simulator-cxx.h"; struct Trivial { Trivial(int x) : value(x) {} @@ -422,6 +428,10 @@ namespace destructors { struct CtorWithNoReturnDtor { CtorWithNoReturnDtor() = default; + CtorWithNoReturnDtor(int x) { + clang_analyzer_checkInlined(false); // no-warning + } + ~CtorWithNoReturnDtor() __attribute__((noreturn)); }; @@ -434,11 +444,17 @@ namespace destructors { const CtorWithNoReturnDtor &c = CtorWithNoReturnDtor(); // This represents an (expected) loss of coverage, since the destructor - // of the lifetime-exended temporary is executed at at the end of + // of the lifetime-exended temporary is executed at the end of // scope. clang_analyzer_warnIfReached(); // no-warning } +#if __cplusplus >= 201103L + CtorWithNoReturnDtor returnNoReturnDtor() { + return {1}; // no-crash + } +#endif + #endif // TEMPORARY_DTORS } @@ -530,3 +546,402 @@ void run() { Sub(i).m(); } } + +namespace test_return_temporary { +class C { + int x, y; + +public: + C(int x, int y) : x(x), y(y) {} + int getX() const { return x; } + int getY() const { return y; } + ~C() {} +}; + +class D: public C { +public: + D() : C(1, 2) {} + D(const D &d): C(d.getX(), d.getY()) {} +}; + +C returnTemporaryWithVariable() { C c(1, 2); return c; } +C returnTemporaryWithAnotherFunctionWithVariable() { + return returnTemporaryWithVariable(); +} +C returnTemporaryWithCopyConstructionWithVariable() { + return C(returnTemporaryWithVariable()); +} + +C returnTemporaryWithConstruction() { return C(1, 2); } +C returnTemporaryWithAnotherFunctionWithConstruction() { + return returnTemporaryWithConstruction(); +} +C returnTemporaryWithCopyConstructionWithConstruction() { + return C(returnTemporaryWithConstruction()); +} + +D returnTemporaryWithVariableAndNonTrivialCopy() { D d; return d; } +D returnTemporaryWithAnotherFunctionWithVariableAndNonTrivialCopy() { + return returnTemporaryWithVariableAndNonTrivialCopy(); +} +D returnTemporaryWithCopyConstructionWithVariableAndNonTrivialCopy() { + return D(returnTemporaryWithVariableAndNonTrivialCopy()); +} + +#if __cplusplus >= 201103L +C returnTemporaryWithBraces() { return {1, 2}; } +C returnTemporaryWithAnotherFunctionWithBraces() { + return returnTemporaryWithBraces(); +} +C returnTemporaryWithCopyConstructionWithBraces() { + return C(returnTemporaryWithBraces()); +} +#endif // C++11 + +void test() { + C c1 = returnTemporaryWithVariable(); + clang_analyzer_eval(c1.getX() == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(c1.getY() == 2); // expected-warning{{TRUE}} + + C c2 = returnTemporaryWithAnotherFunctionWithVariable(); + clang_analyzer_eval(c2.getX() == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(c2.getY() == 2); // expected-warning{{TRUE}} + + C c3 = returnTemporaryWithCopyConstructionWithVariable(); + clang_analyzer_eval(c3.getX() == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(c3.getY() == 2); // expected-warning{{TRUE}} + + C c4 = returnTemporaryWithConstruction(); + clang_analyzer_eval(c4.getX() == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(c4.getY() == 2); // expected-warning{{TRUE}} + + C c5 = returnTemporaryWithAnotherFunctionWithConstruction(); + clang_analyzer_eval(c5.getX() == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(c5.getY() == 2); // expected-warning{{TRUE}} + + C c6 = returnTemporaryWithCopyConstructionWithConstruction(); + clang_analyzer_eval(c5.getX() == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(c5.getY() == 2); // expected-warning{{TRUE}} + +#if __cplusplus >= 201103L + + C c7 = returnTemporaryWithBraces(); + clang_analyzer_eval(c7.getX() == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(c7.getY() == 2); // expected-warning{{TRUE}} + + C c8 = returnTemporaryWithAnotherFunctionWithBraces(); + clang_analyzer_eval(c8.getX() == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(c8.getY() == 2); // expected-warning{{TRUE}} + + C c9 = returnTemporaryWithCopyConstructionWithBraces(); + clang_analyzer_eval(c9.getX() == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(c9.getY() == 2); // expected-warning{{TRUE}} + +#endif // C++11 + + D d1 = returnTemporaryWithVariableAndNonTrivialCopy(); + clang_analyzer_eval(d1.getX() == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(d1.getY() == 2); // expected-warning{{TRUE}} + + D d2 = returnTemporaryWithAnotherFunctionWithVariableAndNonTrivialCopy(); + clang_analyzer_eval(d2.getX() == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(d2.getY() == 2); // expected-warning{{TRUE}} + + D d3 = returnTemporaryWithCopyConstructionWithVariableAndNonTrivialCopy(); + clang_analyzer_eval(d3.getX() == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(d3.getY() == 2); // expected-warning{{TRUE}} +} +} // namespace test_return_temporary + + +namespace test_temporary_object_expr_without_dtor { +class C { + int x; +public: + C(int x) : x(x) {} + int getX() const { return x; } +}; + +void test() { + clang_analyzer_eval(C(3).getX() == 3); // expected-warning{{TRUE}} +}; +} + +namespace test_temporary_object_expr_with_dtor { +class C { + int x; + +public: + C(int x) : x(x) {} + ~C() {} + int getX() const { return x; } +}; + +void test(int coin) { + clang_analyzer_eval(C(3).getX() == 3); +#ifdef TEMPORARY_DTORS + // expected-warning@-2{{TRUE}} +#else + // expected-warning@-4{{UNKNOWN}} +#endif + + const C &c1 = coin ? C(1) : C(2); + if (coin) { + clang_analyzer_eval(c1.getX() == 1); +#ifdef TEMPORARY_DTORS + // expected-warning@-2{{TRUE}} +#else + // expected-warning@-4{{UNKNOWN}} +#endif + } else { + clang_analyzer_eval(c1.getX() == 2); +#ifdef TEMPORARY_DTORS + // expected-warning@-2{{TRUE}} +#else + // expected-warning@-4{{UNKNOWN}} +#endif + } + + C c2 = coin ? C(1) : C(2); + if (coin) { + clang_analyzer_eval(c2.getX() == 1); // expected-warning{{TRUE}} + } else { + clang_analyzer_eval(c2.getX() == 2); // expected-warning{{TRUE}} + } +} + +} // namespace test_temporary_object_expr + +namespace test_match_constructors_and_destructors { +class C { +public: + int &x, &y; + C(int &_x, int &_y) : x(_x), y(_y) { ++x; } + C(const C &c): x(c.x), y(c.y) { ++x; } + ~C() { ++y; } +}; + +void test_simple_temporary() { + int x = 0, y = 0; + { + const C &c = C(x, y); + } + // One constructor and one destructor. + clang_analyzer_eval(x == 1); + clang_analyzer_eval(y == 1); +#ifdef TEMPORARY_DTORS + // expected-warning@-3{{TRUE}} + // expected-warning@-3{{TRUE}} +#else + // expected-warning@-6{{UNKNOWN}} + // expected-warning@-6{{UNKNOWN}} +#endif +} + +void test_simple_temporary_with_copy() { + int x = 0, y = 0; + { + C c = C(x, y); + } + // Only one constructor directly into the variable, and one destructor. + clang_analyzer_eval(x == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(y == 1); // expected-warning{{TRUE}} +} + +void test_ternary_temporary(int coin) { + int x = 0, y = 0, z = 0, w = 0; + { + const C &c = coin ? C(x, y) : C(z, w); + } + // Only one constructor on every branch, and one automatic destructor. + if (coin) { + clang_analyzer_eval(x == 1); + clang_analyzer_eval(y == 1); +#ifdef TEMPORARY_DTORS + // expected-warning@-3{{TRUE}} + // expected-warning@-3{{TRUE}} +#else + // expected-warning@-6{{UNKNOWN}} + // expected-warning@-6{{UNKNOWN}} +#endif + clang_analyzer_eval(z == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(w == 0); // expected-warning{{TRUE}} + + } else { + clang_analyzer_eval(x == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(y == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(z == 1); + clang_analyzer_eval(w == 1); +#ifdef TEMPORARY_DTORS + // expected-warning@-3{{TRUE}} + // expected-warning@-3{{TRUE}} +#else + // expected-warning@-6{{UNKNOWN}} + // expected-warning@-6{{UNKNOWN}} +#endif + } +} + +void test_ternary_temporary_with_copy(int coin) { + int x = 0, y = 0, z = 0, w = 0; + { + C c = coin ? C(x, y) : C(z, w); + } + // On each branch the variable is constructed directly. + if (coin) { + clang_analyzer_eval(x == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(y == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(z == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(w == 0); // expected-warning{{TRUE}} + + } else { + clang_analyzer_eval(x == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(y == 0); // expected-warning{{TRUE}} + clang_analyzer_eval(z == 1); // expected-warning{{TRUE}} + clang_analyzer_eval(w == 1); // expected-warning{{TRUE}} + } +} +} // namespace test_match_constructors_and_destructors + +namespace destructors_for_return_values { + +class C { +public: + ~C() { + 1 / 0; // expected-warning{{Division by zero}} + } +}; + +C make(); + +void testFloatingCall() { + make(); + // Should have divided by zero in the destructor. + clang_analyzer_warnIfReached(); +#ifndef TEMPORARY_DTORS + // expected-warning@-2{{REACHABLE}} +#endif +} + +void testLifetimeExtendedCall() { + { + const C &c = make(); + clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}} + } + // Should have divided by zero in the destructor. + clang_analyzer_warnIfReached(); // no-warning +} + +void testCopiedCall() { + { + C c = make(); + // Should have elided the constructor/destructor for the temporary + clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}} + } + // Should have divided by zero in the destructor. + clang_analyzer_warnIfReached(); // no-warning +} +} // namespace destructors_for_return_values + +namespace dont_forget_destructor_around_logical_op { +int glob; + +class C { +public: + ~C() { + glob = 1; + clang_analyzer_checkInlined(true); +#ifdef TEMPORARY_DTORS + // expected-warning@-2{{TRUE}} +#endif + } +}; + +C get(); + +bool is(C); + + +void test(int coin) { + // Here temporaries are being cleaned up after && is evaluated. There are two + // temporaries: the return value of get() and the elidable copy constructor + // of that return value into is(). According to the CFG, we need to cleanup + // both of them depending on whether the temporary corresponding to the + // return value of get() was initialized. However, we didn't track + // temporaries returned from functions, so we took the wrong branch. + coin && is(get()); // no-crash + if (coin) { + clang_analyzer_eval(glob); +#ifdef TEMPORARY_DTORS + // expected-warning@-2{{TRUE}} +#else + // expected-warning@-4{{UNKNOWN}} +#endif + } else { + // The destructor is not called on this branch. + clang_analyzer_eval(glob); // expected-warning{{UNKNOWN}} + } +} +} // namespace dont_forget_destructor_around_logical_op + +#if __cplusplus >= 201103L +namespace temporary_list_crash { +class C { +public: + C() {} + ~C() {} +}; + +void test() { + std::initializer_list<C>{C(), C()}; // no-crash +} +} // namespace temporary_list_crash +#endif // C++11 + +namespace implicit_constructor_conversion { +struct S { + int x; + S(int x) : x(x) {} + ~S() {} +}; + +class C { + int x; + +public: + C(const S &s) : x(s.x) {} + ~C() {} + int getX() const { return x; } +}; + +void test() { + const C &c1 = S(10); + clang_analyzer_eval(c1.getX() == 10); +#ifdef TEMPORARY_DTORS + // expected-warning@-2{{TRUE}} +#else + // expected-warning@-4{{UNKNOWN}} +#endif + + S s = 20; + clang_analyzer_eval(s.x == 20); // expected-warning{{TRUE}} + + C c2 = s; + clang_analyzer_eval(c2.getX() == 20); // expected-warning{{TRUE}} +} +} // end namespace implicit_constructor_conversion + +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 +} // end namespace pass_references_through diff --git a/test/Analysis/this-pointer.cpp b/test/Analysis/this-pointer.cpp new file mode 100644 index 000000000000..d160a942ef28 --- /dev/null +++ b/test/Analysis/this-pointer.cpp @@ -0,0 +1,88 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config widen-loops=true -analyzer-disable-retry-exhausted -verify %s + +void clang_analyzer_eval(bool); +void clang_analyzer_dump(int); + +// 'this' pointer is not an lvalue, we should not invalidate it. +namespace this_pointer_after_loop_widen { +class A { +public: + A() { + int count = 10; + do { + } while (count--); + } +}; + +void goo(A a); +void test_temporary_object() { + goo(A()); // no-crash +} + +struct B { + int mem; + B() : mem(0) { + for (int i = 0; i < 10; ++i) { + } + mem = 0; + } +}; + +void test_ctor() { + B b; + clang_analyzer_eval(b.mem == 0); // expected-warning{{TRUE}} +} + +struct C { + int mem; + C() : mem(0) {} + void set() { + for (int i = 0; i < 10; ++i) { + } + mem = 10; + } +}; + +void test_method() { + C c; + clang_analyzer_eval(c.mem == 0); // expected-warning{{TRUE}} + c.set(); + clang_analyzer_eval(c.mem == 10); // expected-warning{{TRUE}} +} + +struct D { + int mem; + D() : mem(0) {} + void set() { + for (int i = 0; i < 10; ++i) { + } + mem = 10; + } +}; + +void test_new() { + D *d = new D; + clang_analyzer_eval(d->mem == 0); // expected-warning{{TRUE}} + d->set(); + clang_analyzer_eval(d->mem == 10); // expected-warning{{TRUE}} +} + +struct E { + int mem; + E() : mem(0) {} + void set() { + for (int i = 0; i < 10; ++i) { + } + setAux(); + } + void setAux() { + this->mem = 10; + } +}; + +void test_chained_method_call() { + E e; + e.set(); + clang_analyzer_eval(e.mem == 10); // expected-warning{{TRUE}} +} +} // namespace this_pointer_after_loop_widen diff --git a/test/Analysis/trustnonnullchecker_test.m b/test/Analysis/trustnonnullchecker_test.m new file mode 100644 index 000000000000..67b6bd27c918 --- /dev/null +++ b/test/Analysis/trustnonnullchecker_test.m @@ -0,0 +1,69 @@ +// RUN: %clang_analyze_cc1 -fblocks -analyze -analyzer-checker=core,nullability,apiModeling -verify %s + +#include "Inputs/system-header-simulator-for-nullability.h" + +NSString* _Nonnull trust_nonnull_framework_annotation() { + NSString* out = [NSString generateString]; + if (out) {} + return out; // no-warning +} + +NSString* _Nonnull trust_instancemsg_annotation(NSString* _Nonnull param) { + NSString* out = [param stringByAppendingString:@"string"]; + if (out) {} + return out; // no-warning +} + +NSString* _Nonnull distrust_instancemsg_noannotation(NSString* param) { + if (param) {} + NSString* out = [param stringByAppendingString:@"string"]; + if (out) {} + return out; // expected-warning{{}} +} + +NSString* _Nonnull trust_analyzer_knowledge(NSString* param) { + if (!param) + return @""; + NSString* out = [param stringByAppendingString:@"string"]; + if (out) {} + return out; // no-warning +} + +NSString* _Nonnull trust_assume_nonnull_macro() { + NSString* out = [NSString generateImplicitlyNonnullString]; + if (out) {} + return out; // no-warning +} + +NSString* _Nonnull distrust_without_annotation() { + NSString* out = [NSString generatePossiblyNullString]; + if (out) {} + return out; // expected-warning{{}} +} + +NSString* _Nonnull nonnull_please_trust_me(); + +NSString* _Nonnull distrust_local_nonnull_annotation() { + NSString* out = nonnull_please_trust_me(); + if (out) {} + return out; // expected-warning{{}} +} + +NSString* _Nonnull trust_c_function() { + NSString* out = getString(); + if (out) {}; + return out; // no-warning +} + +NSString* _Nonnull distrust_unannoted_function() { + NSString* out = getPossiblyNullString(); + if (out) {}; + return out; // expected-warning{{}} +} + +NSString * _Nonnull distrustProtocol(id<MyProtocol> o) { + NSString* out = [o getString]; + if (out) {}; + return out; // expected-warning{{}} +} + diff --git a/test/Analysis/trustnonnullchecker_test.mm b/test/Analysis/trustnonnullchecker_test.mm new file mode 100644 index 000000000000..fa84673492be --- /dev/null +++ b/test/Analysis/trustnonnullchecker_test.mm @@ -0,0 +1,9 @@ +// RUN: %clang_analyze_cc1 -fblocks -analyze -analyzer-checker=core,nullability,apiModeling -verify %s + +#include "Inputs/system-header-simulator-for-nullability-cxx.h" + +// expected-no-diagnostics + +void blah() { + foo(); // no-crash +} diff --git a/test/Analysis/undef-call.c b/test/Analysis/undef-call.c new file mode 100644 index 000000000000..35c0b685ce7e --- /dev/null +++ b/test/Analysis/undef-call.c @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -fsyntax-only -analyze -analyzer-checker=debug.ExprInspection -analyzer-config experimental-enable-naive-ctu-analysis=true -analyzer-config ctu-dir=%T/ctudir -verify %s +// expected-no-diagnostics + +struct S { + void (*fp)(); +}; + +int main() { + struct S s; + // This will cause the analyzer to look for a function definition that has + // no FunctionDecl. It used to cause a crash in AnyFunctionCall::getRuntimeDefinition. + // It would only occur when CTU analysis is enabled. + s.fp(); +} diff --git a/test/Analysis/unified-sources/UnifiedSource-1.cpp b/test/Analysis/unified-sources/UnifiedSource-1.cpp new file mode 100644 index 000000000000..02569f247ee0 --- /dev/null +++ b/test/Analysis/unified-sources/UnifiedSource-1.cpp @@ -0,0 +1,5 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core -verify %s + +// There should still be diagnostics within included files. +#include "source1.cpp" +#include "source2.cpp" diff --git a/test/Analysis/unified-sources/container.h b/test/Analysis/unified-sources/container.h new file mode 100644 index 000000000000..d0bcd778899a --- /dev/null +++ b/test/Analysis/unified-sources/container.h @@ -0,0 +1,10 @@ +class ContainerInHeaderFile { + class Iterator { + }; + +public: + Iterator begin() const; + Iterator end() const; + + int method() { return 0; } +}; diff --git a/test/Analysis/unified-sources/source1.cpp b/test/Analysis/unified-sources/source1.cpp new file mode 100644 index 000000000000..886afed8d417 --- /dev/null +++ b/test/Analysis/unified-sources/source1.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core -verify %s + +// This test tests that the warning is here when it is included from +// the unified sources file. The run-line in this file is there +// only to suppress LIT warning for the complete lack of run-line. +int foo(int x) { + if (x) {} + return 1 / x; // expected-warning{{}} +} + +// Let's see if the container inlining heuristic still works. +#include "container.h" +int testContainerMethodInHeaderFile(ContainerInHeaderFile Cont) { + return 1 / Cont.method(); // no-warning +} diff --git a/test/Analysis/unified-sources/source2.cpp b/test/Analysis/unified-sources/source2.cpp new file mode 100644 index 000000000000..cd85e3522343 --- /dev/null +++ b/test/Analysis/unified-sources/source2.cpp @@ -0,0 +1,25 @@ +// RUN: %clang_analyze_cc1 -analyzer-checker=core -verify %s + +// This test tests that the warning is here when it is included from +// the unified sources file. The run-line in this file is there +// only to suppress LIT warning for the complete lack of run-line. +int testNullDereference() { + int *x = 0; + return *x; // expected-warning{{}} +} + +// Let's see if the container inlining heuristic still works. +class ContainerInCodeFile { + class Iterator { + }; + +public: + Iterator begin() const; + Iterator end() const; + + int method() { return 0; } +}; + +int testContainerMethodInCodeFile(ContainerInCodeFile Cont) { + return 1 / Cont.method(); // expected-warning{{}} +} diff --git a/test/Analysis/uninit-const.cpp b/test/Analysis/uninit-const.cpp index 2ffc71bcbd66..f5166e6b27b2 100644 --- a/test/Analysis/uninit-const.cpp +++ b/test/Analysis/uninit-const.cpp @@ -1,4 +1,5 @@ // RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.NewDelete,core,alpha.core.CallAndMessageUnInitRefArg -analyzer-output=text -verify %s +// RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.NewDelete,core,alpha.core.CallAndMessageUnInitRefArg -analyzer-output=text -DTEST_INLINABLE_ALLOCATORS -verify %s // Passing uninitialized const data to unknown function #include "Inputs/system-header-simulator-cxx.h" diff --git a/test/Analysis/unions.cpp b/test/Analysis/unions.cpp index 2758cdaa26b3..2d6d0ae4a0db 100644 --- a/test/Analysis/unions.cpp +++ b/test/Analysis/unions.cpp @@ -79,8 +79,7 @@ namespace PR17596 { IntOrString vv; vv.i = 5; uu = vv; - // FIXME: Should be true. - clang_analyzer_eval(uu.i == 5); // expected-warning{{UNKNOWN}} + clang_analyzer_eval(uu.i == 5); // expected-warning{{TRUE}} } void testInvalidation() { @@ -106,3 +105,20 @@ namespace PR17596 { clang_analyzer_eval(uu.s[0] == 'a'); // expected-warning{{UNKNOWN}} } } + +namespace assume_union_contents { +union U { + int x; +}; + +U get(); + +void test() { + U u = get(); + int y = 0; + if (u.x) + y = 1; + if (u.x) + y = 1 / y; // no-warning +} +} // end namespace assume_union_contents diff --git a/test/Analysis/unix-fns.c b/test/Analysis/unix-fns.c index 9126e1bb39b4..44e7a2e643e3 100644 --- a/test/Analysis/unix-fns.c +++ b/test/Analysis/unix-fns.c @@ -1,4 +1,4 @@ -// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,unix.API,osx.API,optin.portability %s -analyzer-store=region -analyzer-output=plist -analyzer-eagerly-assume -analyzer-config faux-bodies=true -analyzer-config path-diagnostics-alternate=false -fblocks -verify -o %t.plist +// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,unix.API,osx.API,optin.portability %s -analyzer-store=region -analyzer-output=plist -analyzer-eagerly-assume -analyzer-config faux-bodies=true -fblocks -verify -o %t.plist // RUN: FileCheck --input-file=%t.plist %s // RUN: mkdir -p %t.dir // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.API,osx.API,optin.portability -analyzer-output=html -analyzer-config faux-bodies=true -fblocks -o %t.dir %s @@ -700,40 +700,6 @@ void test_inline_dispatch_once_reachable() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>103</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>103</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>kind</key><string>control</string> -// CHECK-NEXT: <key>edges</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>start</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>103</integer> -// CHECK-NEXT: <key>col</key><integer>3</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>103</integer> -// CHECK-NEXT: <key>col</key><integer>4</integer> -// CHECK-NEXT: <key>file</key><integer>0</integer> -// CHECK-NEXT: </dict> -// CHECK-NEXT: </array> -// CHECK-NEXT: <key>end</key> -// CHECK-NEXT: <array> -// CHECK-NEXT: <dict> -// CHECK-NEXT: <key>line</key><integer>103</integer> // CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -1786,6 +1752,40 @@ void test_inline_dispatch_once_reachable() { // CHECK-NEXT: <string>'p' captured by block as a null pointer value</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>221</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>221</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>221</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>221</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -2153,6 +2153,40 @@ void test_inline_dispatch_once_reachable() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>232</integer> // CHECK-NEXT: <key>col</key><integer>24</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> @@ -2195,6 +2229,40 @@ void test_inline_dispatch_once_reachable() { // CHECK-NEXT: <string>'p' captured by block as a null pointer value</string> // CHECK-NEXT: </dict> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>232</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -2492,6 +2560,40 @@ void test_inline_dispatch_once_reachable() { // CHECK-NEXT: <key>path</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>239</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>239</integer> +// CHECK-NEXT: <key>col</key><integer>8</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>241</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>241</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> // CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>location</key> // CHECK-NEXT: <dict> @@ -2880,6 +2982,40 @@ void test_inline_dispatch_once_reachable() { // CHECK-NEXT: <array> // CHECK-NEXT: <dict> // CHECK-NEXT: <key>line</key><integer>245</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>245</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>245</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>245</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>245</integer> // CHECK-NEXT: <key>col</key><integer>6</integer> // CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: </dict> diff --git a/test/Analysis/unreachable-code-path.c b/test/Analysis/unreachable-code-path.c index effa4d9bfa6f..95cc4eab50db 100644 --- a/test/Analysis/unreachable-code-path.c +++ b/test/Analysis/unreachable-code-path.c @@ -63,6 +63,7 @@ void test6(const char *c) { if (c) return; if (!c) return; __builtin_unreachable(); // no-warning + __builtin_assume(0); // no-warning } // Compile-time constant false positives diff --git a/test/Analysis/virtualcall.cpp b/test/Analysis/virtualcall.cpp index c22a8463c04a..1929abf6f0aa 100644 --- a/test/Analysis/virtualcall.cpp +++ b/test/Analysis/virtualcall.cpp @@ -262,6 +262,9 @@ int main() { //expected-note-re@-2 {{{{^}}Calling default constructor for 'M'}} #endif Y *y = new Y; +#if !PUREONLY + //expected-note-re@-2 {{{{^}}Calling default constructor for 'Y'}} +#endif delete y; header::Z z; #if !PUREONLY diff --git a/test/Analysis/yaccignore.c b/test/Analysis/yaccignore.c new file mode 100644 index 000000000000..c9edfadaf2f8 --- /dev/null +++ b/test/Analysis/yaccignore.c @@ -0,0 +1,13 @@ +/* A Bison parser, made by GNU Bison 1.875. */ + +// RUN: rm -rf %t.plist +// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist -o %t.plist -verify %s +// RUN: FileCheck --input-file=%t.plist %s + +// expected-no-diagnostics +int foo() { + int *x = 0; + return *x; // no-warning +} + +// CHECK: <key>diagnostics</key> diff --git a/test/Analysis/z3-crosscheck.c b/test/Analysis/z3-crosscheck.c new file mode 100644 index 000000000000..67d410434fbb --- /dev/null +++ b/test/Analysis/z3-crosscheck.c @@ -0,0 +1,43 @@ +// RUN: %clang_cc1 -analyze -analyzer-checker=core,unix.Malloc,debug.ExprInspection -DNO_CROSSCHECK -verify %s +// RUN: %clang_cc1 -analyze -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config crosscheck-with-z3=true -verify %s +// REQUIRES: z3 + +int foo(int x) +{ + int *z = 0; + if ((x & 1) && ((x & 1) ^ 1)) +#ifdef NO_CROSSCHECK + return *z; // expected-warning {{Dereference of null pointer (loaded from variable 'z')}} +#else + return *z; // no-warning +#endif + return 0; +} + +void g(int d); + +void f(int *a, int *b) { + int c = 5; + if ((a - b) == 0) + c = 0; + if (a != b) + g(3 / c); // no-warning +} + +_Bool nondet_bool(); + +void h(int d) { + int x, y, k, z = 1; + while (z < k) { // expected-warning {{The right operand of '<' is a garbage value}} + z = 2 * z; + } +} + +void i() { + _Bool c = nondet_bool(); + if (c) { + h(1); + } else { + h(2); + } +} diff --git a/test/Analysis/z3/apsint.c b/test/Analysis/z3/apsint.c new file mode 100644 index 000000000000..670ef2be1c59 --- /dev/null +++ b/test/Analysis/z3/apsint.c @@ -0,0 +1,16 @@ +// RUN: %clang_analyze_cc1 -triple x86_64-unknown-linux-gnu -analyzer-checker=core -verify %s +// expected-no-diagnostics + +// https://bugs.llvm.org/show_bug.cgi?id=37622 +_Bool a() { + return !({ a(); }); +} + +// https://bugs.llvm.org/show_bug.cgi?id=37646 +_Bool b; +void c() { + _Bool a = b | 0; + for (;;) + if (a) + ; +} diff --git a/test/Analysis/z3/enabled.c b/test/Analysis/z3/enabled.c new file mode 100644 index 000000000000..9f44233b266c --- /dev/null +++ b/test/Analysis/z3/enabled.c @@ -0,0 +1,3 @@ +// REQUIRES: z3 +// RUN: echo %clang_analyze_cc1 | FileCheck %s +// CHECK: -analyzer-constraints=z3 |