ProgramStateTrait.h revision 355940 
1//ProgramStateTrait.h - Partial implementations of ProgramStateTrait -*- C++ -*-
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file defines partial implementations of template specializations of
10//  the class ProgramStateTrait<>.  ProgramStateTrait<> is used by ProgramState
11//  to implement set/get methods for manipulating a ProgramState's
12//  generic data map.
13//
14//===----------------------------------------------------------------------===//
15
16#ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H
17#define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H
18
19#include "llvm/ADT/ImmutableList.h"
20#include "llvm/ADT/ImmutableMap.h"
21#include "llvm/ADT/ImmutableSet.h"
22#include "llvm/Support/Allocator.h"
23#include <cstdint>
24
25namespace clang {
26namespace ento {
27
28  template <typename T> struct ProgramStatePartialTrait;
29
30  /// Declares a program state trait for type \p Type called \p Name, and
31  /// introduce a type named \c NameTy.
32  /// The macro should not be used inside namespaces.
33  #define REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, Type) \
34    namespace { \
35      class Name {}; \
36      using Name ## Ty = Type; \
37    } \
38    namespace clang { \
39    namespace ento { \
40      template <> \
41      struct ProgramStateTrait<Name> \
42        : public ProgramStatePartialTrait<Name ## Ty> { \
43        static void *GDMIndex() { static int Index; return &Index; } \
44      }; \
45    } \
46    }
47
48  /// Declares a factory for objects of type \p Type in the program state
49  /// manager. The type must provide a ::Factory sub-class. Commonly used for
50  /// ImmutableMap, ImmutableSet, ImmutableList. The macro should not be used
51  /// inside namespaces.
52  #define REGISTER_FACTORY_WITH_PROGRAMSTATE(Type) \
53    namespace clang { \
54    namespace ento { \
55      template <> \
56      struct ProgramStateTrait<Type> \
57        : public ProgramStatePartialTrait<Type> { \
58        static void *GDMIndex() { static int Index; return &Index; } \
59      }; \
60    } \
61    }
62
63  /// Helper for registering a map trait.
64  ///
65  /// If the map type were written directly in the invocation of
66  /// REGISTER_TRAIT_WITH_PROGRAMSTATE, the comma in the template arguments
67  /// would be treated as a macro argument separator, which is wrong.
68  /// This allows the user to specify a map type in a way that the preprocessor
69  /// can deal with.
70  #define CLANG_ENTO_PROGRAMSTATE_MAP(Key, Value) llvm::ImmutableMap<Key, Value>
71
72  /// Declares an immutable map of type \p NameTy, suitable for placement into
73  /// the ProgramState. This is implementing using llvm::ImmutableMap.
74  ///
75  /// \code
76  /// State = State->set<Name>(K, V);
77  /// const Value *V = State->get<Name>(K); // Returns NULL if not in the map.
78  /// State = State->remove<Name>(K);
79  /// NameTy Map = State->get<Name>();
80  /// \endcode
81  ///
82  /// The macro should not be used inside namespaces, or for traits that must
83  /// be accessible from more than one translation unit.
84  #define REGISTER_MAP_WITH_PROGRAMSTATE(Name, Key, Value) \
85    REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, \
86                                     CLANG_ENTO_PROGRAMSTATE_MAP(Key, Value))
87
88  /// Declares an immutable map type \p Name and registers the factory
89  /// for such maps in the program state, but does not add the map itself
90  /// to the program state. Useful for managing lifetime of maps that are used
91  /// as elements of other program state data structures.
92  #define REGISTER_MAP_FACTORY_WITH_PROGRAMSTATE(Name, Key, Value) \
93    using Name = llvm::ImmutableMap<Key, Value>; \
94    REGISTER_FACTORY_WITH_PROGRAMSTATE(Name)
95
96
97  /// Declares an immutable set of type \p NameTy, suitable for placement into
98  /// the ProgramState. This is implementing using llvm::ImmutableSet.
99  ///
100  /// \code
101  /// State = State->add<Name>(E);
102  /// State = State->remove<Name>(E);
103  /// bool Present = State->contains<Name>(E);
104  /// NameTy Set = State->get<Name>();
105  /// \endcode
106  ///
107  /// The macro should not be used inside namespaces, or for traits that must
108  /// be accessible from more than one translation unit.
109  #define REGISTER_SET_WITH_PROGRAMSTATE(Name, Elem) \
110    REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, llvm::ImmutableSet<Elem>)
111
112  /// Declares an immutable set type \p Name and registers the factory
113  /// for such sets in the program state, but does not add the set itself
114  /// to the program state. Useful for managing lifetime of sets that are used
115  /// as elements of other program state data structures.
116  #define REGISTER_SET_FACTORY_WITH_PROGRAMSTATE(Name, Elem) \
117    using Name = llvm::ImmutableSet<Elem>; \
118    REGISTER_FACTORY_WITH_PROGRAMSTATE(Name)
119
120
121  /// Declares an immutable list type \p NameTy, suitable for placement into
122  /// the ProgramState. This is implementing using llvm::ImmutableList.
123  ///
124  /// \code
125  /// State = State->add<Name>(E); // Adds to the /end/ of the list.
126  /// bool Present = State->contains<Name>(E);
127  /// NameTy List = State->get<Name>();
128  /// \endcode
129  ///
130  /// The macro should not be used inside namespaces, or for traits that must
131  /// be accessible from more than one translation unit.
132  #define REGISTER_LIST_WITH_PROGRAMSTATE(Name, Elem) \
133    REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, llvm::ImmutableList<Elem>)
134
135  /// Declares an immutable list of type \p Name and registers the factory
136  /// for such lists in the program state, but does not add the list itself
137  /// to the program state. Useful for managing lifetime of lists that are used
138  /// as elements of other program state data structures.
139  #define REGISTER_LIST_FACTORY_WITH_PROGRAMSTATE(Name, Elem) \
140    using Name = llvm::ImmutableList<Elem>; \
141    REGISTER_FACTORY_WITH_PROGRAMSTATE(Name)
142
143
144  // Partial-specialization for ImmutableMap.
145  template <typename Key, typename Data, typename Info>
146  struct ProgramStatePartialTrait<llvm::ImmutableMap<Key, Data, Info>> {
147    using data_type = llvm::ImmutableMap<Key, Data, Info>;
148    using context_type = typename data_type::Factory &;
149    using key_type = Key;
150    using value_type = Data;
151    using lookup_type = const value_type *;
152
153    static data_type MakeData(void *const *p) {
154      return p ? data_type((typename data_type::TreeTy *) *p)
155               : data_type(nullptr);
156    }
157
158    static void *MakeVoidPtr(data_type B) {
159      return B.getRoot();
160    }
161
162    static lookup_type Lookup(data_type B, key_type K) {
163      return B.lookup(K);
164    }
165
166    static data_type Set(data_type B, key_type K, value_type E,
167                         context_type F) {
168      return F.add(B, K, E);
169    }
170
171    static data_type Remove(data_type B, key_type K, context_type F) {
172      return F.remove(B, K);
173    }
174
175    static bool Contains(data_type B, key_type K) {
176      return B.contains(K);
177    }
178
179    static context_type MakeContext(void *p) {
180      return *((typename data_type::Factory *) p);
181    }
182
183    static void *CreateContext(llvm::BumpPtrAllocator& Alloc) {
184      return new typename data_type::Factory(Alloc);
185    }
186
187    static void DeleteContext(void *Ctx) {
188      delete (typename data_type::Factory *) Ctx;
189    }
190  };
191
192  // Partial-specialization for ImmutableSet.
193  template <typename Key, typename Info>
194  struct ProgramStatePartialTrait<llvm::ImmutableSet<Key, Info>> {
195    using data_type = llvm::ImmutableSet<Key, Info>;
196    using context_type = typename data_type::Factory &;
197    using key_type = Key;
198
199    static data_type MakeData(void *const *p) {
200      return p ? data_type((typename data_type::TreeTy *) *p)
201               : data_type(nullptr);
202    }
203
204    static void *MakeVoidPtr(data_type B) {
205      return B.getRoot();
206    }
207
208    static data_type Add(data_type B, key_type K, context_type F) {
209      return F.add(B, K);
210    }
211
212    static data_type Remove(data_type B, key_type K, context_type F) {
213      return F.remove(B, K);
214    }
215
216    static bool Contains(data_type B, key_type K) {
217      return B.contains(K);
218    }
219
220    static context_type MakeContext(void *p) {
221      return *((typename data_type::Factory *) p);
222    }
223
224    static void *CreateContext(llvm::BumpPtrAllocator &Alloc) {
225      return new typename data_type::Factory(Alloc);
226    }
227
228    static void DeleteContext(void *Ctx) {
229      delete (typename data_type::Factory *) Ctx;
230    }
231  };
232
233  // Partial-specialization for ImmutableList.
234  template <typename T>
235  struct ProgramStatePartialTrait<llvm::ImmutableList<T>> {
236    using data_type = llvm::ImmutableList<T>;
237    using key_type = T;
238    using context_type = typename data_type::Factory &;
239
240    static data_type Add(data_type L, key_type K, context_type F) {
241      return F.add(K, L);
242    }
243
244    static bool Contains(data_type L, key_type K) {
245      return L.contains(K);
246    }
247
248    static data_type MakeData(void *const *p) {
249      return p ? data_type((const llvm::ImmutableListImpl<T> *) *p)
250               : data_type(nullptr);
251    }
252
253    static void *MakeVoidPtr(data_type D) {
254      return const_cast<llvm::ImmutableListImpl<T> *>(D.getInternalPointer());
255    }
256
257    static context_type MakeContext(void *p) {
258      return *((typename data_type::Factory *) p);
259    }
260
261    static void *CreateContext(llvm::BumpPtrAllocator &Alloc) {
262      return new typename data_type::Factory(Alloc);
263    }
264
265    static void DeleteContext(void *Ctx) {
266      delete (typename data_type::Factory *) Ctx;
267    }
268  };
269
270  // Partial specialization for bool.
271  template <> struct ProgramStatePartialTrait<bool> {
272    using data_type = bool;
273
274    static data_type MakeData(void *const *p) {
275      return p ? (data_type) (uintptr_t) *p
276               : data_type();
277    }
278
279    static void *MakeVoidPtr(data_type d) {
280      return (void *) (uintptr_t) d;
281    }
282  };
283
284  // Partial specialization for unsigned.
285  template <> struct ProgramStatePartialTrait<unsigned> {
286    using data_type = unsigned;
287
288    static data_type MakeData(void *const *p) {
289      return p ? (data_type) (uintptr_t) *p
290               : data_type();
291    }
292
293    static void *MakeVoidPtr(data_type d) {
294      return (void *) (uintptr_t) d;
295    }
296  };
297
298  // Partial specialization for void*.
299  template <> struct ProgramStatePartialTrait<void *> {
300    using data_type = void *;
301
302    static data_type MakeData(void *const *p) {
303      return p ? *p
304               : data_type();
305    }
306
307    static void *MakeVoidPtr(data_type d) {
308      return d;
309    }
310  };
311
312  // Partial specialization for const void *.
313  template <> struct ProgramStatePartialTrait<const void *> {
314    using data_type = const void *;
315
316    static data_type MakeData(void *const *p) {
317      return p ? *p : data_type();
318    }
319
320    static void *MakeVoidPtr(data_type d) {
321      return const_cast<void *>(d);
322    }
323  };
324
325} // namespace ento
326} // namespace clang
327
328#endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H
329