clang  7.0.0svn
ProgramStateTrait.h
Go to the documentation of this file.
1 //ProgramStateTrait.h - Partial implementations of ProgramStateTrait -*- C++ -*-
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines partial implementations of template specializations of
11 // the class ProgramStateTrait<>. ProgramStateTrait<> is used by ProgramState
12 // to implement set/get methods for manipulating a ProgramState's
13 // generic data map.
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H
18 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H
19 
20 #include "llvm/ADT/ImmutableList.h"
21 #include "llvm/ADT/ImmutableMap.h"
22 #include "llvm/ADT/ImmutableSet.h"
23 #include "llvm/Support/Allocator.h"
24 #include <cstdint>
25 
26 namespace clang {
27 namespace ento {
28 
29  template <typename T> struct ProgramStatePartialTrait;
30 
31  /// Declares a program state trait for type \p Type called \p Name, and
32  /// introduce a type named \c NameTy.
33  /// The macro should not be used inside namespaces, or for traits that must
34  /// be accessible from more than one translation unit.
35  #define REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, Type) \
36  namespace { \
37  class Name {}; \
38  using Name ## Ty = Type; \
39  } \
40  namespace clang { \
41  namespace ento { \
42  template <> \
43  struct ProgramStateTrait<Name> \
44  : public ProgramStatePartialTrait<Name ## Ty> { \
45  static void *GDMIndex() { static int Index; return &Index; } \
46  }; \
47  } \
48  }
49 
50  // Partial-specialization for ImmutableMap.
51  template <typename Key, typename Data, typename Info>
52  struct ProgramStatePartialTrait<llvm::ImmutableMap<Key, Data, Info>> {
53  using data_type = llvm::ImmutableMap<Key, Data, Info>;
54  using context_type = typename data_type::Factory &;
55  using key_type = Key;
56  using value_type = Data;
57  using lookup_type = const value_type *;
58 
59  static data_type MakeData(void *const *p) {
60  return p ? data_type((typename data_type::TreeTy *) *p)
61  : data_type(nullptr);
62  }
63 
64  static void *MakeVoidPtr(data_type B) {
65  return B.getRoot();
66  }
67 
69  return B.lookup(K);
70  }
71 
73  context_type F) {
74  return F.add(B, K, E);
75  }
76 
78  return F.remove(B, K);
79  }
80 
81  static bool Contains(data_type B, key_type K) {
82  return B.contains(K);
83  }
84 
85  static context_type MakeContext(void *p) {
86  return *((typename data_type::Factory *) p);
87  }
88 
89  static void *CreateContext(llvm::BumpPtrAllocator& Alloc) {
90  return new typename data_type::Factory(Alloc);
91  }
92 
93  static void DeleteContext(void *Ctx) {
94  delete (typename data_type::Factory *) Ctx;
95  }
96  };
97 
98  /// Helper for registering a map trait.
99  ///
100  /// If the map type were written directly in the invocation of
101  /// REGISTER_TRAIT_WITH_PROGRAMSTATE, the comma in the template arguments
102  /// would be treated as a macro argument separator, which is wrong.
103  /// This allows the user to specify a map type in a way that the preprocessor
104  /// can deal with.
105  #define CLANG_ENTO_PROGRAMSTATE_MAP(Key, Value) llvm::ImmutableMap<Key, Value>
106 
107  // Partial-specialization for ImmutableSet.
108  template <typename Key, typename Info>
109  struct ProgramStatePartialTrait<llvm::ImmutableSet<Key, Info>> {
110  using data_type = llvm::ImmutableSet<Key, Info>;
111  using context_type = typename data_type::Factory &;
112  using key_type = Key;
113 
114  static data_type MakeData(void *const *p) {
115  return p ? data_type((typename data_type::TreeTy *) *p)
116  : data_type(nullptr);
117  }
118 
119  static void *MakeVoidPtr(data_type B) {
120  return B.getRoot();
121  }
122 
124  return F.add(B, K);
125  }
126 
128  return F.remove(B, K);
129  }
130 
131  static bool Contains(data_type B, key_type K) {
132  return B.contains(K);
133  }
134 
135  static context_type MakeContext(void *p) {
136  return *((typename data_type::Factory *) p);
137  }
138 
139  static void *CreateContext(llvm::BumpPtrAllocator &Alloc) {
140  return new typename data_type::Factory(Alloc);
141  }
142 
143  static void DeleteContext(void *Ctx) {
144  delete (typename data_type::Factory *) Ctx;
145  }
146  };
147 
148  // Partial-specialization for ImmutableList.
149  template <typename T>
150  struct ProgramStatePartialTrait<llvm::ImmutableList<T>> {
151  using data_type = llvm::ImmutableList<T>;
152  using key_type = T;
153  using context_type = typename data_type::Factory &;
154 
156  return F.add(K, L);
157  }
158 
159  static bool Contains(data_type L, key_type K) {
160  return L.contains(K);
161  }
162 
163  static data_type MakeData(void *const *p) {
164  return p ? data_type((const llvm::ImmutableListImpl<T> *) *p)
165  : data_type(nullptr);
166  }
167 
168  static void *MakeVoidPtr(data_type D) {
169  return const_cast<llvm::ImmutableListImpl<T> *>(D.getInternalPointer());
170  }
171 
172  static context_type MakeContext(void *p) {
173  return *((typename data_type::Factory *) p);
174  }
175 
176  static void *CreateContext(llvm::BumpPtrAllocator &Alloc) {
177  return new typename data_type::Factory(Alloc);
178  }
179 
180  static void DeleteContext(void *Ctx) {
181  delete (typename data_type::Factory *) Ctx;
182  }
183  };
184 
185  // Partial specialization for bool.
186  template <> struct ProgramStatePartialTrait<bool> {
187  using data_type = bool;
188 
189  static data_type MakeData(void *const *p) {
190  return p ? (data_type) (uintptr_t) *p
191  : data_type();
192  }
193 
194  static void *MakeVoidPtr(data_type d) {
195  return (void *) (uintptr_t) d;
196  }
197  };
198 
199  // Partial specialization for unsigned.
200  template <> struct ProgramStatePartialTrait<unsigned> {
201  using data_type = unsigned;
202 
203  static data_type MakeData(void *const *p) {
204  return p ? (data_type) (uintptr_t) *p
205  : data_type();
206  }
207 
208  static void *MakeVoidPtr(data_type d) {
209  return (void *) (uintptr_t) d;
210  }
211  };
212 
213  // Partial specialization for void*.
214  template <> struct ProgramStatePartialTrait<void *> {
215  using data_type = void *;
216 
217  static data_type MakeData(void *const *p) {
218  return p ? *p
219  : data_type();
220  }
221 
222  static void *MakeVoidPtr(data_type d) {
223  return d;
224  }
225  };
226 
227  // Partial specialization for const void *.
228  template <> struct ProgramStatePartialTrait<const void *> {
229  using data_type = const void *;
230 
231  static data_type MakeData(void *const *p) {
232  return p ? *p : data_type();
233  }
234 
235  static void *MakeVoidPtr(data_type d) {
236  return const_cast<void *>(d);
237  }
238  };
239 
240 } // namespace ento
241 } // namespace clang
242 
243 #endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
static data_type Add(data_type L, key_type K, context_type F)
static void * CreateContext(llvm::BumpPtrAllocator &Alloc)
static data_type Remove(data_type B, key_type K, context_type F)
#define bool
Definition: stdbool.h:31
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Definition: opencl-c.h:82
static data_type MakeData(void *const *p)
static data_type Set(data_type B, key_type K, value_type E, context_type F)
static data_type Remove(data_type B, key_type K, context_type F)
Dataflow Directional Tag Classes.
static data_type Add(data_type B, key_type K, context_type F)
static llvm::ImmutableListFactory< const FieldRegion * > Factory