Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h
Line
Count
Source (jump to first uncovered line)
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
48.9k
  SymExpr(Kind k) : K(k) {}
44
45
0
  static bool isValidTypeForSymbol(QualType T) {
46
0
    // FIXME: Depending on whether we choose to deprecate structural symbols,
47
0
    // this may become much stricter.
48
0
    return !T.isNull() && !T->isVoidType();
49
0
  }
50
51
public:
52
0
  virtual ~SymExpr() {}
53
54
6.82M
  Kind getKind() const { return K; }
55
56
  virtual void dump() const;
57
58
0
  virtual void dumpToStream(raw_ostream &os) const {}
59
60
  virtual QualType getType() const = 0;
61
  virtual void Profile(llvm::FoldingSetNodeID &profile) = 0;
62
63
  /// \brief Iterator over symbols that the current symbol depends on.
64
  ///
65
  /// For SymbolData, it's the symbol itself; for expressions, it's the
66
  /// expression symbol and all the operands in it. Note, SymbolDerived is
67
  /// treated as SymbolData - the iterator will NOT visit the parent region.
68
  class symbol_iterator {
69
    SmallVector<const SymExpr *, 5> itr;
70
    void expand();
71
72
  public:
73
2.09M
    symbol_iterator() {}
74
    symbol_iterator(const SymExpr *SE);
75
76
    symbol_iterator &operator++();
77
    const SymExpr *operator*();
78
79
    bool operator==(const symbol_iterator &X) const;
80
    bool operator!=(const symbol_iterator &X) const;
81
  };
82
83
907k
  symbol_iterator symbol_begin() const { return symbol_iterator(this); }
84
1.50M
  static symbol_iterator symbol_end() { return symbol_iterator(); }
85
86
  unsigned computeComplexity() const;
87
88
  /// \brief Find the region from which this symbol originates.
89
  ///
90
  /// Whenever the symbol was constructed to denote an unknown value of
91
  /// a certain memory region, return this region. This method
92
  /// allows checkers to make decisions depending on the origin of the symbol.
93
  /// Symbol classes for which the origin region is known include
94
  /// SymbolRegionValue which denotes the value of the region before
95
  /// the beginning of the analysis, and SymbolDerived which denotes the value
96
  /// of a certain memory region after its super region (a memory space or
97
  /// a larger record region) is default-bound with a certain symbol.
98
255
  virtual const MemRegion *getOriginRegion() const { return nullptr; }
99
};
100
101
typedef const SymExpr *SymbolRef;
102
typedef SmallVector<SymbolRef, 2> SymbolRefSmallVectorTy;
103
104
typedef unsigned SymbolID;
105
/// \brief A symbol representing data which can be stored in a memory location
106
/// (region).
107
class SymbolData : public SymExpr {
108
  void anchor() override;
109
  const SymbolID Sym;
110
111
protected:
112
37.1k
  SymbolData(Kind k, SymbolID sym) : SymExpr(k), Sym(sym) {
113
37.1k
    assert(classof(this));
114
37.1k
  }
115
116
public:
117
0
  ~SymbolData() override {}
118
119
866
  SymbolID getSymbolID() const { return Sym; }
120
121
  // Implement isa<T> support.
122
277k
  static inline bool classof(const SymExpr *SE) {
123
277k
    Kind k = SE->getKind();
124
28.5k
    return k >= BEGIN_SYMBOLS && k <= END_SYMBOLS;
125
277k
  }
126
};
127
128
} // namespace ento
129
} // namespace clang
130
131
#endif