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

   1 //== SymExpr.h - Management of Symbolic Values ------------------*- 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 SymExpr and SymbolData.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SYMEXPR_H
  15 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SYMEXPR_H
  16
  17 #include "clang/AST/Type.h"
  18 #include "llvm/ADT/FoldingSet.h"
  19 #include "llvm/ADT/SmallVector.h"
  20 #include "llvm/Support/raw_ostream.h"
  21
  22 namespace clang {
  23 namespace ento {
  24
  25 class MemRegion;
  26
  27 /// \brief Symbolic value. These values used to capture symbolic execution of
  28 /// the program.
  29 class SymExpr : public llvm::FoldingSetNode {
  30   virtual void anchor();
  31
  32 public:
  33   enum Kind {
  34 #define SYMBOL(Id, Parent) Id##Kind,
  35 #define SYMBOL_RANGE(Id, First, Last) BEGIN_##Id = First, END_##Id = Last,
  36 #include "clang/StaticAnalyzer/Core/PathSensitive/Symbols.def"
  37   };
  38
  39 private:
  40   Kind K;
  41
  42 protected:
  43   SymExpr(Kind k) : K(k) {}
  44
  45 public:
  46   virtual ~SymExpr() {}
  47
  48   Kind getKind() const { return K; }
  49
  50   virtual void dump() const;
  51
  52   virtual void dumpToStream(raw_ostream &os) const {}
  53
  54   virtual QualType getType() const = 0;
  55   virtual void Profile(llvm::FoldingSetNodeID &profile) = 0;
  56
  57   /// \brief Iterator over symbols that the current symbol depends on.
  58   ///
  59   /// For SymbolData, it's the symbol itself; for expressions, it's the
  60   /// expression symbol and all the operands in it. Note, SymbolDerived is
  61   /// treated as SymbolData - the iterator will NOT visit the parent region.
  62   class symbol_iterator {
  63     SmallVector<const SymExpr *, 5> itr;
  64     void expand();
  65
  66   public:
  67     symbol_iterator() {}
  68     symbol_iterator(const SymExpr *SE);
  69
  70     symbol_iterator &operator++();
  71     const SymExpr *operator*();
  72
  73     bool operator==(const symbol_iterator &X) const;
  74     bool operator!=(const symbol_iterator &X) const;
  75   };
  76
  77   symbol_iterator symbol_begin() const { return symbol_iterator(this); }
  78   static symbol_iterator symbol_end() { return symbol_iterator(); }
  79
  80   unsigned computeComplexity() const;
  81
  82   /// \brief Find the region from which this symbol originates.
  83   ///
  84   /// Whenever the symbol was constructed to denote an unknown value of
  85   /// a certain memory region, return this region. This method
  86   /// allows checkers to make decisions depending on the origin of the symbol.
  87   /// Symbol classes for which the origin region is known include
  88   /// SymbolRegionValue which denotes the value of the region before
  89   /// the beginning of the analysis, and SymbolDerived which denotes the value
  90   /// of a certain memory region after its super region (a memory space or
  91   /// a larger record region) is default-bound with a certain symbol.
  92   virtual const MemRegion *getOriginRegion() const { return nullptr; }
  93 };
  94
  95 typedef const SymExpr *SymbolRef;
  96 typedef SmallVector<SymbolRef, 2> SymbolRefSmallVectorTy;
  97
  98 typedef unsigned SymbolID;
  99 /// \brief A symbol representing data which can be stored in a memory location
 100 /// (region).
 101 class SymbolData : public SymExpr {
 102   void anchor() override;
 103   const SymbolID Sym;
 104
 105 protected:
 106   SymbolData(Kind k, SymbolID sym) : SymExpr(k), Sym(sym) {}
 107
 108 public:
 109   ~SymbolData() override {}
 110
 111   SymbolID getSymbolID() const { return Sym; }
 112
 113   // Implement isa<T> support.
 114   static inline bool classof(const SymExpr *SE) {
 115     Kind k = SE->getKind();
 116     return k >= BEGIN_SYMBOLS && k <= END_SYMBOLS;
 117   }
 118 };
 119
 120 } // namespace ento
 121 } // namespace clang
 122
 123 #endif