contrib/llvm/tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BasicValueFactory.h

   1 //=== BasicValueFactory.h - Basic values for Path Sens analysis --*- 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 BasicValueFactory, a class that manages the lifetime
  11 //  of APSInt objects and symbolic constraints used by ExprEngine
  12 //  and related classes.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_CLANG_GR_BASICVALUEFACTORY_H
  17 #define LLVM_CLANG_GR_BASICVALUEFACTORY_H
  18
  19 #include "clang/AST/ASTContext.h"
  20 #include "clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h"
  21 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
  22 #include "clang/StaticAnalyzer/Core/PathSensitive/StoreRef.h"
  23
  24 namespace clang {
  25 namespace ento {
  26
  27 class CompoundValData : public llvm::FoldingSetNode {
  28   QualType T;
  29   llvm::ImmutableList<SVal> L;
  30
  31 public:
  32   CompoundValData(QualType t, llvm::ImmutableList<SVal> l)
  33     : T(t), L(l) {}
  34
  35   typedef llvm::ImmutableList<SVal>::iterator iterator;
  36   iterator begin() const { return L.begin(); }
  37   iterator end() const { return L.end(); }
  38
  39   static void Profile(llvm::FoldingSetNodeID& ID, QualType T,
  40                       llvm::ImmutableList<SVal> L);
  41
  42   void Profile(llvm::FoldingSetNodeID& ID) { Profile(ID, T, L); }
  43 };
  44
  45 class LazyCompoundValData : public llvm::FoldingSetNode {
  46   StoreRef store;
  47   const TypedValueRegion *region;
  48 public:
  49   LazyCompoundValData(const StoreRef &st, const TypedValueRegion *r)
  50     : store(st), region(r) {}
  51
  52   const void *getStore() const { return store.getStore(); }
  53   const TypedValueRegion *getRegion() const { return region; }
  54
  55   static void Profile(llvm::FoldingSetNodeID& ID,
  56                       const StoreRef &store,
  57                       const TypedValueRegion *region);
  58
  59   void Profile(llvm::FoldingSetNodeID& ID) { Profile(ID, store, region); }
  60 };
  61
  62 class BasicValueFactory {
  63   typedef llvm::FoldingSet<llvm::FoldingSetNodeWrapper<llvm::APSInt> >
  64           APSIntSetTy;
  65
  66   ASTContext &Ctx;
  67   llvm::BumpPtrAllocator& BPAlloc;
  68
  69   APSIntSetTy   APSIntSet;
  70   void *        PersistentSVals;
  71   void *        PersistentSValPairs;
  72
  73   llvm::ImmutableList<SVal>::Factory SValListFactory;
  74   llvm::FoldingSet<CompoundValData>  CompoundValDataSet;
  75   llvm::FoldingSet<LazyCompoundValData> LazyCompoundValDataSet;
  76
  77   // This is private because external clients should use the factory
  78   // method that takes a QualType.
  79   const llvm::APSInt& getValue(uint64_t X, unsigned BitWidth, bool isUnsigned);
  80
  81 public:
  82   BasicValueFactory(ASTContext &ctx, llvm::BumpPtrAllocator& Alloc)
  83   : Ctx(ctx), BPAlloc(Alloc), PersistentSVals(0), PersistentSValPairs(0),
  84     SValListFactory(Alloc) {}
  85
  86   ~BasicValueFactory();
  87
  88   ASTContext &getContext() const { return Ctx; }
  89
  90   const llvm::APSInt& getValue(const llvm::APSInt& X);
  91   const llvm::APSInt& getValue(const llvm::APInt& X, bool isUnsigned);
  92   const llvm::APSInt& getValue(uint64_t X, QualType T);
  93
  94   /// Returns the type of the APSInt used to store values of the given QualType.
  95   APSIntType getAPSIntType(QualType T) const {
  96     assert(T->isIntegralOrEnumerationType() || Loc::isLocType(T));
  97     return APSIntType(Ctx.getTypeSize(T),
  98                       !T->isSignedIntegerOrEnumerationType());
  99   }
 100
 101   /// Convert - Create a new persistent APSInt with the same value as 'From'
 102   ///  but with the bitwidth and signedness of 'To'.
 103   const llvm::APSInt &Convert(const llvm::APSInt& To,
 104                               const llvm::APSInt& From) {
 105     APSIntType TargetType(To);
 106     if (TargetType == APSIntType(From))
 107       return From;
 108
 109     return getValue(TargetType.convert(From));
 110   }
 111
 112   const llvm::APSInt &Convert(QualType T, const llvm::APSInt &From) {
 113     APSIntType TargetType = getAPSIntType(T);
 114     if (TargetType == APSIntType(From))
 115       return From;
 116
 117     return getValue(TargetType.convert(From));
 118   }
 119
 120   const llvm::APSInt& getIntValue(uint64_t X, bool isUnsigned) {
 121     QualType T = isUnsigned ? Ctx.UnsignedIntTy : Ctx.IntTy;
 122     return getValue(X, T);
 123   }
 124
 125   inline const llvm::APSInt& getMaxValue(const llvm::APSInt &v) {
 126     return getValue(APSIntType(v).getMaxValue());
 127   }
 128
 129   inline const llvm::APSInt& getMinValue(const llvm::APSInt &v) {
 130     return getValue(APSIntType(v).getMinValue());
 131   }
 132
 133   inline const llvm::APSInt& getMaxValue(QualType T) {
 134     return getValue(getAPSIntType(T).getMaxValue());
 135   }
 136
 137   inline const llvm::APSInt& getMinValue(QualType T) {
 138     return getValue(getAPSIntType(T).getMinValue());
 139   }
 140
 141   inline const llvm::APSInt& Add1(const llvm::APSInt& V) {
 142     llvm::APSInt X = V;
 143     ++X;
 144     return getValue(X);
 145   }
 146
 147   inline const llvm::APSInt& Sub1(const llvm::APSInt& V) {
 148     llvm::APSInt X = V;
 149     --X;
 150     return getValue(X);
 151   }
 152
 153   inline const llvm::APSInt& getZeroWithPtrWidth(bool isUnsigned = true) {
 154     return getValue(0, Ctx.getTypeSize(Ctx.VoidPtrTy), isUnsigned);
 155   }
 156
 157   inline const llvm::APSInt &getIntWithPtrWidth(uint64_t X, bool isUnsigned) {
 158     return getValue(X, Ctx.getTypeSize(Ctx.VoidPtrTy), isUnsigned);
 159   }
 160
 161   inline const llvm::APSInt& getTruthValue(bool b, QualType T) {
 162     return getValue(b ? 1 : 0, Ctx.getTypeSize(T), false);
 163   }
 164
 165   inline const llvm::APSInt& getTruthValue(bool b) {
 166     return getTruthValue(b, Ctx.getLogicalOperationType());
 167   }
 168
 169   const CompoundValData *getCompoundValData(QualType T,
 170                                             llvm::ImmutableList<SVal> Vals);
 171
 172   const LazyCompoundValData *getLazyCompoundValData(const StoreRef &store,
 173                                             const TypedValueRegion *region);
 174
 175   llvm::ImmutableList<SVal> getEmptySValList() {
 176     return SValListFactory.getEmptyList();
 177   }
 178
 179   llvm::ImmutableList<SVal> consVals(SVal X, llvm::ImmutableList<SVal> L) {
 180     return SValListFactory.add(X, L);
 181   }
 182
 183   const llvm::APSInt* evalAPSInt(BinaryOperator::Opcode Op,
 184                                      const llvm::APSInt& V1,
 185                                      const llvm::APSInt& V2);
 186
 187   const std::pair<SVal, uintptr_t>&
 188   getPersistentSValWithData(const SVal& V, uintptr_t Data);
 189
 190   const std::pair<SVal, SVal>&
 191   getPersistentSValPair(const SVal& V1, const SVal& V2);
 192
 193   const SVal* getPersistentSVal(SVal X);
 194 };
 195
 196 } // end GR namespace
 197
 198 } // end clang namespace
 199
 200 #endif