1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
// RUN: %clang_analyze_cc1 \
// RUN: -analyzer-checker=core.CallAndMessage \
// RUN: -analyzer-config suppress-null-return-paths=false \
// RUN: -verify %s
// RUN: %clang_analyze_cc1 \
// RUN: -analyzer-checker=core.CallAndMessage \
// RUN: -DSUPPRESSED \
// RUN: -verify %s
#ifdef SUPPRESSED
// expected-no-diagnostics
#endif
#include <stdint.h>
#include "../Inputs/system-header-simulator-cxx.h"
void error();
void *malloc(size_t);
// From llvm/include/llvm/Support/MathExtras.h
inline uintptr_t alignAddr(const void *Addr, size_t Alignment) {
return (((uintptr_t)Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1));
}
inline size_t alignmentAdjustment(const void *Ptr, size_t Alignment) {
return alignAddr(Ptr, Alignment) - (uintptr_t)Ptr;
}
// From llvm/include/llvm/Support/MemAlloc.h
inline void *safe_malloc(size_t Sz) {
void *Result = malloc(Sz);
if (Result == nullptr)
error();
return Result;
}
// From llvm/include/llvm/Support/Allocator.h
class MallocAllocator {
public:
void *Allocate(size_t Size, size_t /*Alignment*/) {
return safe_malloc(Size);
}
};
class BumpPtrAllocator {
public:
void *Allocate(size_t Size, size_t Alignment) {
BytesAllocated += Size;
size_t Adjustment = alignmentAdjustment(CurPtr, Alignment);
size_t SizeToAllocate = Size;
size_t PaddedSize = SizeToAllocate + Alignment - 1;
uintptr_t AlignedAddr = alignAddr(Allocator.Allocate(PaddedSize, 0),
Alignment);
char *AlignedPtr = (char*)AlignedAddr;
return AlignedPtr;
}
private:
char *CurPtr = nullptr;
size_t BytesAllocated = 0;
MallocAllocator Allocator;
};
// From clang/include/clang/AST/ASTContextAllocate.h
class ASTContext;
void *operator new(size_t Bytes, const ASTContext &C, size_t Alignment = 8);
void *operator new[](size_t Bytes, const ASTContext &C, size_t Alignment = 8);
// From clang/include/clang/AST/ASTContext.h
class ASTContext {
public:
void *Allocate(size_t Size, unsigned Align = 8) const {
return BumpAlloc.Allocate(Size, Align);
}
template <typename T>
T *Allocate(size_t Num = 1) const {
return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
}
private:
mutable BumpPtrAllocator BumpAlloc;
};
// From clang/include/clang/AST/ASTContext.h
inline void *operator new(size_t Bytes, const ASTContext &C,
size_t Alignment /* = 8 */) {
return C.Allocate(Bytes, Alignment);
}
inline void *operator new[](size_t Bytes, const ASTContext &C,
size_t Alignment /* = 8 */) {
return C.Allocate(Bytes, Alignment);
}
// From clang/include/clang/AST/Attr.h
void *operator new(size_t Bytes, ASTContext &C,
size_t Alignment = 8) noexcept {
return ::operator new(Bytes, C, Alignment);
}
class A {
public:
void setValue(int value) { Value = value; }
private:
int Value;
};
void f(const ASTContext &C) {
A *a = new (C) A;
a->setValue(13);
#ifndef SUPPRESSED
// expected-warning@-2 {{Called C++ object pointer is null}}
#endif
}
void g(const ASTContext &C) {
A *a = new (C) A[1];
a[0].setValue(13);
#ifndef SUPPRESSED
// expected-warning@-2 {{Called C++ object pointer is null}}
#endif
}
|
