2013-04-06 01:55:07 +08:00
|
|
|
// RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDelete -std=c++11 -fblocks -verify %s
|
2013-04-13 07:25:40 +08:00
|
|
|
// RUN: %clang_cc1 -analyze -analyzer-checker=core,alpha.cplusplus.NewDeleteLeaks -DLEAKS -std=c++11 -fblocks -verify %s
|
2013-03-25 09:35:45 +08:00
|
|
|
#include "Inputs/system-header-simulator-cxx.h"
|
|
|
|
|
|
|
|
typedef __typeof__(sizeof(int)) size_t;
|
|
|
|
extern "C" void *malloc(size_t);
|
2013-08-09 08:55:47 +08:00
|
|
|
extern "C" void free (void* ptr);
|
2013-03-25 09:35:45 +08:00
|
|
|
int *global;
|
|
|
|
|
|
|
|
//------------------
|
|
|
|
// check for leaks
|
|
|
|
//------------------
|
|
|
|
|
2013-03-29 00:10:38 +08:00
|
|
|
//----- Standard non-placement operators
|
|
|
|
void testGlobalOpNew() {
|
|
|
|
void *p = operator new(0);
|
2013-04-06 01:55:00 +08:00
|
|
|
}
|
|
|
|
#ifdef LEAKS
|
2013-04-06 08:41:36 +08:00
|
|
|
// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
|
2013-04-06 01:55:00 +08:00
|
|
|
#endif
|
2013-03-25 09:35:45 +08:00
|
|
|
|
2013-03-29 00:10:38 +08:00
|
|
|
void testGlobalOpNewArray() {
|
|
|
|
void *p = operator new[](0);
|
2013-04-06 01:55:00 +08:00
|
|
|
}
|
|
|
|
#ifdef LEAKS
|
2013-04-06 08:41:36 +08:00
|
|
|
// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
|
2013-04-06 01:55:00 +08:00
|
|
|
#endif
|
2013-03-25 09:35:45 +08:00
|
|
|
|
2013-03-29 00:10:38 +08:00
|
|
|
void testGlobalNewExpr() {
|
2013-03-25 09:35:45 +08:00
|
|
|
int *p = new int;
|
2013-04-06 01:55:00 +08:00
|
|
|
}
|
|
|
|
#ifdef LEAKS
|
2013-04-06 08:41:36 +08:00
|
|
|
// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
|
2013-04-06 01:55:00 +08:00
|
|
|
#endif
|
2013-03-25 09:35:45 +08:00
|
|
|
|
2013-03-29 00:10:38 +08:00
|
|
|
void testGlobalNewExprArray() {
|
|
|
|
int *p = new int[0];
|
2013-04-06 01:55:00 +08:00
|
|
|
}
|
|
|
|
#ifdef LEAKS
|
2013-04-06 08:41:36 +08:00
|
|
|
// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
|
2013-04-06 01:55:00 +08:00
|
|
|
#endif
|
2013-03-25 09:35:45 +08:00
|
|
|
|
2013-03-29 00:10:38 +08:00
|
|
|
//----- Standard nothrow placement operators
|
|
|
|
void testGlobalNoThrowPlacementOpNewBeforeOverload() {
|
|
|
|
void *p = operator new(0, std::nothrow);
|
2013-04-06 01:55:00 +08:00
|
|
|
}
|
|
|
|
#ifdef LEAKS
|
2013-04-06 08:41:36 +08:00
|
|
|
// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
|
2013-04-06 01:55:00 +08:00
|
|
|
#endif
|
2013-03-25 09:35:45 +08:00
|
|
|
|
2013-03-29 00:10:38 +08:00
|
|
|
void testGlobalNoThrowPlacementExprNewBeforeOverload() {
|
|
|
|
int *p = new(std::nothrow) int;
|
2013-04-06 01:55:00 +08:00
|
|
|
}
|
|
|
|
#ifdef LEAKS
|
2013-04-06 08:41:36 +08:00
|
|
|
// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
|
2013-04-06 01:55:00 +08:00
|
|
|
#endif
|
2013-03-25 09:35:45 +08:00
|
|
|
|
2013-03-29 00:10:38 +08:00
|
|
|
//----- Standard pointer placement operators
|
|
|
|
void testGlobalPointerPlacementNew() {
|
2013-03-25 09:35:45 +08:00
|
|
|
int i;
|
|
|
|
|
2013-03-29 00:10:38 +08:00
|
|
|
void *p1 = operator new(0, &i); // no warn
|
2013-03-25 09:35:45 +08:00
|
|
|
|
2013-03-29 00:10:38 +08:00
|
|
|
void *p2 = operator new[](0, &i); // no warn
|
2013-03-25 09:35:45 +08:00
|
|
|
|
2013-03-29 00:10:38 +08:00
|
|
|
int *p3 = new(&i) int; // no warn
|
2013-03-25 09:35:45 +08:00
|
|
|
|
2013-03-29 00:10:38 +08:00
|
|
|
int *p4 = new(&i) int[0]; // no warn
|
2013-03-25 09:35:45 +08:00
|
|
|
}
|
|
|
|
|
2013-03-29 00:10:38 +08:00
|
|
|
//----- Other cases
|
|
|
|
void testNewMemoryIsInHeap() {
|
|
|
|
int *p = new int;
|
|
|
|
if (global != p) // condition is always true as 'p' wraps a heap region that
|
|
|
|
// is different from a region wrapped by 'global'
|
|
|
|
global = p; // pointer escapes
|
2013-03-25 09:35:45 +08:00
|
|
|
}
|
|
|
|
|
2013-03-29 00:10:38 +08:00
|
|
|
struct PtrWrapper {
|
|
|
|
int *x;
|
|
|
|
|
|
|
|
PtrWrapper(int *input) : x(input) {}
|
|
|
|
};
|
2013-03-25 09:35:45 +08:00
|
|
|
|
2013-03-29 00:10:38 +08:00
|
|
|
void testNewInvalidationPlacement(PtrWrapper *w) {
|
|
|
|
// Ensure that we don't consider this a leak.
|
|
|
|
new (w) PtrWrapper(new int); // no warn
|
2013-03-25 09:35:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//---------------
|
|
|
|
// other checks
|
|
|
|
//---------------
|
|
|
|
|
2013-04-11 06:21:41 +08:00
|
|
|
class SomeClass {
|
|
|
|
public:
|
|
|
|
void f(int *p);
|
|
|
|
};
|
|
|
|
|
|
|
|
void f(int *p1, int *p2 = 0, int *p3 = 0);
|
|
|
|
void g(SomeClass &c, ...);
|
2013-03-25 09:35:45 +08:00
|
|
|
|
2013-04-11 06:21:41 +08:00
|
|
|
void testUseFirstArgAfterDelete() {
|
2013-03-25 09:35:45 +08:00
|
|
|
int *p = new int;
|
|
|
|
delete p;
|
|
|
|
f(p); // expected-warning{{Use of memory after it is freed}}
|
|
|
|
}
|
|
|
|
|
2013-04-11 06:21:41 +08:00
|
|
|
void testUseMiddleArgAfterDelete(int *p) {
|
|
|
|
delete p;
|
|
|
|
f(0, p); // expected-warning{{Use of memory after it is freed}}
|
|
|
|
}
|
|
|
|
|
|
|
|
void testUseLastArgAfterDelete(int *p) {
|
|
|
|
delete p;
|
|
|
|
f(0, 0, p); // expected-warning{{Use of memory after it is freed}}
|
|
|
|
}
|
|
|
|
|
2013-04-11 06:36:16 +08:00
|
|
|
void testUseSeveralArgsAfterDelete(int *p) {
|
|
|
|
delete p;
|
|
|
|
f(p, p, p); // expected-warning{{Use of memory after it is freed}}
|
|
|
|
}
|
|
|
|
|
2013-04-11 06:21:41 +08:00
|
|
|
void testUseRefArgAfterDelete(SomeClass &c) {
|
|
|
|
delete &c;
|
|
|
|
g(c); // expected-warning{{Use of memory after it is freed}}
|
|
|
|
}
|
|
|
|
|
|
|
|
void testVariadicArgAfterDelete() {
|
|
|
|
SomeClass c;
|
|
|
|
int *p = new int;
|
|
|
|
delete p;
|
|
|
|
g(c, 0, p); // expected-warning{{Use of memory after it is freed}}
|
|
|
|
}
|
|
|
|
|
|
|
|
void testUseMethodArgAfterDelete(int *p) {
|
|
|
|
SomeClass *c = new SomeClass;
|
|
|
|
delete p;
|
|
|
|
c->f(p); // expected-warning{{Use of memory after it is freed}}
|
|
|
|
}
|
|
|
|
|
|
|
|
void testUseThisAfterDelete() {
|
|
|
|
SomeClass *c = new SomeClass;
|
|
|
|
delete c;
|
|
|
|
c->f(0); // expected-warning{{Use of memory after it is freed}}
|
|
|
|
}
|
|
|
|
|
2013-03-25 09:35:45 +08:00
|
|
|
void testDeleteAlloca() {
|
|
|
|
int *p = (int *)__builtin_alloca(sizeof(int));
|
2013-03-29 01:05:19 +08:00
|
|
|
delete p; // expected-warning{{Memory allocated by alloca() should not be deallocated}}
|
2013-03-25 09:35:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void testDoubleDelete() {
|
|
|
|
int *p = new int;
|
|
|
|
delete p;
|
|
|
|
delete p; // expected-warning{{Attempt to free released memory}}
|
|
|
|
}
|
|
|
|
|
|
|
|
void testExprDeleteArg() {
|
|
|
|
int i;
|
2013-03-29 01:05:19 +08:00
|
|
|
delete &i; // expected-warning{{Argument to 'delete' is the address of the local variable 'i', which is not memory allocated by 'new'}}
|
|
|
|
}
|
2013-03-25 09:35:45 +08:00
|
|
|
|
|
|
|
void testExprDeleteArrArg() {
|
|
|
|
int i;
|
2013-03-29 01:05:19 +08:00
|
|
|
delete[] &i; // expected-warning{{Argument to 'delete[]' is the address of the local variable 'i', which is not memory allocated by 'new[]'}}
|
|
|
|
}
|
2013-03-25 09:35:45 +08:00
|
|
|
|
|
|
|
void testAllocDeallocNames() {
|
|
|
|
int *p = new(std::nothrow) int[1];
|
2013-03-29 01:05:19 +08:00
|
|
|
delete[] (++p); // expected-warning{{Argument to 'delete[]' is offset by 4 bytes from the start of memory allocated by 'new[]'}}
|
|
|
|
}
|
2013-03-25 09:35:45 +08:00
|
|
|
|
2013-03-29 07:15:29 +08:00
|
|
|
//--------------------------------
|
|
|
|
// Test escape of newed const pointer. Note, a const pointer can be deleted.
|
|
|
|
//--------------------------------
|
|
|
|
struct StWithConstPtr {
|
|
|
|
const int *memp;
|
|
|
|
};
|
|
|
|
void escape(const int &x);
|
|
|
|
void escapeStruct(const StWithConstPtr &x);
|
|
|
|
void escapePtr(const StWithConstPtr *x);
|
|
|
|
void escapeVoidPtr(const void *x);
|
|
|
|
|
|
|
|
void testConstEscape() {
|
|
|
|
int *p = new int(1);
|
|
|
|
escape(*p);
|
|
|
|
} // no-warning
|
|
|
|
|
|
|
|
void testConstEscapeStruct() {
|
|
|
|
StWithConstPtr *St = new StWithConstPtr();
|
|
|
|
escapeStruct(*St);
|
|
|
|
} // no-warning
|
|
|
|
|
|
|
|
void testConstEscapeStructPtr() {
|
|
|
|
StWithConstPtr *St = new StWithConstPtr();
|
|
|
|
escapePtr(St);
|
|
|
|
} // no-warning
|
|
|
|
|
|
|
|
void testConstEscapeMember() {
|
|
|
|
StWithConstPtr St;
|
|
|
|
St.memp = new int(2);
|
|
|
|
escapeVoidPtr(St.memp);
|
|
|
|
} // no-warning
|
|
|
|
|
|
|
|
void testConstEscapePlacementNew() {
|
|
|
|
int *x = (int *)malloc(sizeof(int));
|
|
|
|
void *y = new (x) int;
|
|
|
|
escapeVoidPtr(y);
|
|
|
|
} // no-warning
|
2013-05-17 10:16:49 +08:00
|
|
|
|
2013-08-09 08:55:47 +08:00
|
|
|
//============== Test Uninitialized delete delete[]========================
|
|
|
|
void testUninitDelete() {
|
|
|
|
int *x;
|
|
|
|
int * y = new int;
|
|
|
|
delete y;
|
|
|
|
delete x; // expected-warning{{Argument to 'delete' is uninitialized}}
|
|
|
|
}
|
|
|
|
|
|
|
|
void testUninitDeleteArray() {
|
|
|
|
int *x;
|
|
|
|
int * y = new int[5];
|
|
|
|
delete[] y;
|
|
|
|
delete[] x; // expected-warning{{Argument to 'delete[]' is uninitialized}}
|
|
|
|
}
|
|
|
|
|
|
|
|
void testUninitFree() {
|
|
|
|
int *x;
|
|
|
|
free(x); // expected-warning{{Function call argument is an uninitialized value}}
|
|
|
|
}
|
|
|
|
|
|
|
|
void testUninitDeleteSink() {
|
|
|
|
int *x;
|
|
|
|
delete x; // expected-warning{{Argument to 'delete' is uninitialized}}
|
|
|
|
(*(volatile int *)0 = 1); // no warn
|
|
|
|
}
|
|
|
|
|
|
|
|
void testUninitDeleteArraySink() {
|
|
|
|
int *x;
|
|
|
|
delete[] x; // expected-warning{{Argument to 'delete[]' is uninitialized}}
|
|
|
|
(*(volatile int *)0 = 1); // no warn
|
|
|
|
}
|
2013-05-17 10:16:49 +08:00
|
|
|
|
|
|
|
namespace reference_count {
|
|
|
|
class control_block {
|
|
|
|
unsigned count;
|
|
|
|
public:
|
|
|
|
control_block() : count(0) {}
|
|
|
|
void retain() { ++count; }
|
|
|
|
int release() { return --count; }
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
class shared_ptr {
|
|
|
|
T *p;
|
|
|
|
control_block *control;
|
|
|
|
|
|
|
|
public:
|
|
|
|
shared_ptr() : p(0), control(0) {}
|
|
|
|
explicit shared_ptr(T *p) : p(p), control(new control_block) {
|
|
|
|
control->retain();
|
|
|
|
}
|
|
|
|
shared_ptr(shared_ptr &other) : p(other.p), control(other.control) {
|
|
|
|
if (control)
|
|
|
|
control->retain();
|
|
|
|
}
|
|
|
|
~shared_ptr() {
|
|
|
|
if (control && control->release() == 0) {
|
|
|
|
delete p;
|
|
|
|
delete control;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
T &operator *() {
|
|
|
|
return *p;
|
|
|
|
};
|
|
|
|
|
|
|
|
void swap(shared_ptr &other) {
|
|
|
|
T *tmp = p;
|
|
|
|
p = other.p;
|
|
|
|
other.p = tmp;
|
|
|
|
|
|
|
|
control_block *ctrlTmp = control;
|
|
|
|
control = other.control;
|
|
|
|
other.control = ctrlTmp;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
void testSingle() {
|
|
|
|
shared_ptr<int> a(new int);
|
|
|
|
*a = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void testDouble() {
|
|
|
|
shared_ptr<int> a(new int);
|
|
|
|
shared_ptr<int> b = a;
|
|
|
|
*a = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void testInvalidated() {
|
|
|
|
shared_ptr<int> a(new int);
|
|
|
|
shared_ptr<int> b = a;
|
|
|
|
*a = 1;
|
|
|
|
|
|
|
|
extern void use(shared_ptr<int> &);
|
|
|
|
use(b);
|
|
|
|
}
|
|
|
|
|
|
|
|
void testNestedScope() {
|
|
|
|
shared_ptr<int> a(new int);
|
|
|
|
{
|
|
|
|
shared_ptr<int> b = a;
|
|
|
|
}
|
|
|
|
*a = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void testSwap() {
|
|
|
|
shared_ptr<int> a(new int);
|
|
|
|
shared_ptr<int> b;
|
|
|
|
shared_ptr<int> c = a;
|
|
|
|
shared_ptr<int>(c).swap(b);
|
|
|
|
}
|
|
|
|
|
|
|
|
void testUseAfterFree() {
|
|
|
|
int *p = new int;
|
|
|
|
{
|
|
|
|
shared_ptr<int> a(p);
|
|
|
|
shared_ptr<int> b = a;
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: We should get a warning here, but we don't because we've
|
|
|
|
// conservatively modeled ~shared_ptr.
|
|
|
|
*p = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|