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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
| //ProgramStateTrait.h - Partial implementations of ProgramStateTrait -*- C++ -*-
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines partial implementations of template specializations of
// the class ProgramStateTrait<>. ProgramStateTrait<> is used by ProgramState
// to implement set/get methods for manipulating a ProgramState's
// generic data map.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H
#define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H
#include "llvm/ADT/ImmutableList.h"
#include "llvm/ADT/ImmutableMap.h"
#include "llvm/ADT/ImmutableSet.h"
#include "llvm/Support/Allocator.h"
#include <cstdint>
namespace clang {
namespace ento {
template <typename T> struct ProgramStatePartialTrait;
/// Declares a program state trait for type \p Type called \p Name, and
/// introduce a type named \c NameTy.
/// The macro should not be used inside namespaces.
#define REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, Type) \
namespace { \
class Name {}; \
using Name ## Ty = Type; \
} \
namespace clang { \
namespace ento { \
template <> \
struct ProgramStateTrait<Name> \
: public ProgramStatePartialTrait<Name ## Ty> { \
static void *GDMIndex() { static int Index; return &Index; } \
}; \
} \
}
/// Declares a factory for objects of type \p Type in the program state
/// manager. The type must provide a ::Factory sub-class. Commonly used for
/// ImmutableMap, ImmutableSet, ImmutableList. The macro should not be used
/// inside namespaces.
#define REGISTER_FACTORY_WITH_PROGRAMSTATE(Type) \
namespace clang { \
namespace ento { \
template <> \
struct ProgramStateTrait<Type> \
: public ProgramStatePartialTrait<Type> { \
static void *GDMIndex() { static int Index; return &Index; } \
}; \
} \
}
/// Helper for registering a map trait.
///
/// If the map type were written directly in the invocation of
/// REGISTER_TRAIT_WITH_PROGRAMSTATE, the comma in the template arguments
/// would be treated as a macro argument separator, which is wrong.
/// This allows the user to specify a map type in a way that the preprocessor
/// can deal with.
#define CLANG_ENTO_PROGRAMSTATE_MAP(Key, Value) llvm::ImmutableMap<Key, Value>
/// Declares an immutable map of type \p NameTy, suitable for placement into
/// the ProgramState. This is implementing using llvm::ImmutableMap.
///
/// \code
/// State = State->set<Name>(K, V);
/// const Value *V = State->get<Name>(K); // Returns NULL if not in the map.
/// State = State->remove<Name>(K);
/// NameTy Map = State->get<Name>();
/// \endcode
///
/// The macro should not be used inside namespaces, or for traits that must
/// be accessible from more than one translation unit.
#define REGISTER_MAP_WITH_PROGRAMSTATE(Name, Key, Value) \
REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, \
CLANG_ENTO_PROGRAMSTATE_MAP(Key, Value))
/// Declares an immutable map type \p Name and registers the factory
/// for such maps in the program state, but does not add the map itself
/// to the program state. Useful for managing lifetime of maps that are used
/// as elements of other program state data structures.
#define REGISTER_MAP_FACTORY_WITH_PROGRAMSTATE(Name, Key, Value) \
using Name = llvm::ImmutableMap<Key, Value>; \
REGISTER_FACTORY_WITH_PROGRAMSTATE(Name)
/// Declares an immutable set of type \p NameTy, suitable for placement into
/// the ProgramState. This is implementing using llvm::ImmutableSet.
///
/// \code
/// State = State->add<Name>(E);
/// State = State->remove<Name>(E);
/// bool Present = State->contains<Name>(E);
/// NameTy Set = State->get<Name>();
/// \endcode
///
/// The macro should not be used inside namespaces, or for traits that must
/// be accessible from more than one translation unit.
#define REGISTER_SET_WITH_PROGRAMSTATE(Name, Elem) \
REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, llvm::ImmutableSet<Elem>)
/// Declares an immutable set type \p Name and registers the factory
/// for such sets in the program state, but does not add the set itself
/// to the program state. Useful for managing lifetime of sets that are used
/// as elements of other program state data structures.
#define REGISTER_SET_FACTORY_WITH_PROGRAMSTATE(Name, Elem) \
using Name = llvm::ImmutableSet<Elem>; \
REGISTER_FACTORY_WITH_PROGRAMSTATE(Name)
/// Declares an immutable list type \p NameTy, suitable for placement into
/// the ProgramState. This is implementing using llvm::ImmutableList.
///
/// \code
/// State = State->add<Name>(E); // Adds to the /end/ of the list.
/// bool Present = State->contains<Name>(E);
/// NameTy List = State->get<Name>();
/// \endcode
///
/// The macro should not be used inside namespaces, or for traits that must
/// be accessible from more than one translation unit.
#define REGISTER_LIST_WITH_PROGRAMSTATE(Name, Elem) \
REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, llvm::ImmutableList<Elem>)
/// Declares an immutable list of type \p Name and registers the factory
/// for such lists in the program state, but does not add the list itself
/// to the program state. Useful for managing lifetime of lists that are used
/// as elements of other program state data structures.
#define REGISTER_LIST_FACTORY_WITH_PROGRAMSTATE(Name, Elem) \
using Name = llvm::ImmutableList<Elem>; \
REGISTER_FACTORY_WITH_PROGRAMSTATE(Name)
// Partial-specialization for ImmutableMap.
template <typename Key, typename Data, typename Info>
struct ProgramStatePartialTrait<llvm::ImmutableMap<Key, Data, Info>> {
using data_type = llvm::ImmutableMap<Key, Data, Info>;
using context_type = typename data_type::Factory &;
using key_type = Key;
using value_type = Data;
using lookup_type = const value_type *;
static data_type MakeData(void *const *p) {
return p ? data_type((typename data_type::TreeTy *) *p)
: data_type(nullptr);
}
static void *MakeVoidPtr(data_type B) {
return B.getRoot();
}
static lookup_type Lookup(data_type B, key_type K) {
return B.lookup(K);
}
static data_type Set(data_type B, key_type K, value_type E,
context_type F) {
return F.add(B, K, E);
}
static data_type Remove(data_type B, key_type K, context_type F) {
return F.remove(B, K);
}
static bool Contains(data_type B, key_type K) {
return B.contains(K);
}
static context_type MakeContext(void *p) {
return *((typename data_type::Factory *) p);
}
static void *CreateContext(llvm::BumpPtrAllocator& Alloc) {
return new typename data_type::Factory(Alloc);
}
static void DeleteContext(void *Ctx) {
delete (typename data_type::Factory *) Ctx;
}
};
// Partial-specialization for ImmutableSet.
template <typename Key, typename Info>
struct ProgramStatePartialTrait<llvm::ImmutableSet<Key, Info>> {
using data_type = llvm::ImmutableSet<Key, Info>;
using context_type = typename data_type::Factory &;
using key_type = Key;
static data_type MakeData(void *const *p) {
return p ? data_type((typename data_type::TreeTy *) *p)
: data_type(nullptr);
}
static void *MakeVoidPtr(data_type B) {
return B.getRoot();
}
static data_type Add(data_type B, key_type K, context_type F) {
return F.add(B, K);
}
static data_type Remove(data_type B, key_type K, context_type F) {
return F.remove(B, K);
}
static bool Contains(data_type B, key_type K) {
return B.contains(K);
}
static context_type MakeContext(void *p) {
return *((typename data_type::Factory *) p);
}
static void *CreateContext(llvm::BumpPtrAllocator &Alloc) {
return new typename data_type::Factory(Alloc);
}
static void DeleteContext(void *Ctx) {
delete (typename data_type::Factory *) Ctx;
}
};
// Partial-specialization for ImmutableList.
template <typename T>
struct ProgramStatePartialTrait<llvm::ImmutableList<T>> {
using data_type = llvm::ImmutableList<T>;
using key_type = T;
using context_type = typename data_type::Factory &;
static data_type Add(data_type L, key_type K, context_type F) {
return F.add(K, L);
}
static bool Contains(data_type L, key_type K) {
return L.contains(K);
}
static data_type MakeData(void *const *p) {
return p ? data_type((const llvm::ImmutableListImpl<T> *) *p)
: data_type(nullptr);
}
static void *MakeVoidPtr(data_type D) {
return const_cast<llvm::ImmutableListImpl<T> *>(D.getInternalPointer());
}
static context_type MakeContext(void *p) {
return *((typename data_type::Factory *) p);
}
static void *CreateContext(llvm::BumpPtrAllocator &Alloc) {
return new typename data_type::Factory(Alloc);
}
static void DeleteContext(void *Ctx) {
delete (typename data_type::Factory *) Ctx;
}
};
// Partial specialization for bool.
template <> struct ProgramStatePartialTrait<bool> {
using data_type = bool;
static data_type MakeData(void *const *p) {
return p ? (data_type) (uintptr_t) *p
: data_type();
}
static void *MakeVoidPtr(data_type d) {
return (void *) (uintptr_t) d;
}
};
// Partial specialization for unsigned.
template <> struct ProgramStatePartialTrait<unsigned> {
using data_type = unsigned;
static data_type MakeData(void *const *p) {
return p ? (data_type) (uintptr_t) *p
: data_type();
}
static void *MakeVoidPtr(data_type d) {
return (void *) (uintptr_t) d;
}
};
// Partial specialization for void*.
template <> struct ProgramStatePartialTrait<void *> {
using data_type = void *;
static data_type MakeData(void *const *p) {
return p ? *p
: data_type();
}
static void *MakeVoidPtr(data_type d) {
return d;
}
};
// Partial specialization for const void *.
template <> struct ProgramStatePartialTrait<const void *> {
using data_type = const void *;
static data_type MakeData(void *const *p) {
return p ? *p : data_type();
}
static void *MakeVoidPtr(data_type d) {
return const_cast<void *>(d);
}
};
} // namespace ento
} // namespace clang
#endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H
|