include/clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h

   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
  68     static lookup_type Lookup(data_type B, key_type K) {
  69       return B.lookup(K);
  70     }
  71
  72     static data_type Set(data_type B, key_type K, value_type E,
  73                          context_type F) {
  74       return F.add(B, K, E);
  75     }
  76
  77     static data_type Remove(data_type B, key_type K, context_type F) {
  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
 123     static data_type Add(data_type B, key_type K, context_type F) {
 124       return F.add(B, K);
 125     }
 126
 127     static data_type Remove(data_type B, key_type K, context_type F) {
 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
 155     static data_type Add(data_type L, key_type K, context_type F) {
 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