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