Newer
Older
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
132
133
134
135
136
137
138
139
140
141
//== BasicStore.cpp - Basic map from Locations to 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 defined the BasicStore and BasicStoreManager classes.
//
//===----------------------------------------------------------------------===//
#include "clang/Analysis/PathSensitive/BasicStore.h"
#include "llvm/ADT/ImmutableMap.h"
#include "llvm/Support/Compiler.h"
using namespace clang;
namespace {
class VISIBILITY_HIDDEN BasicStoreManager : public StoreManager {
typedef llvm::ImmutableMap<VarDecl*,RVal> VarBindingsTy;
VarBindingsTy::Factory VBFactory;
public:
BasicStoreManager(llvm::BumpPtrAllocator& A) : VBFactory(A) {}
virtual ~BasicStoreManager() {}
virtual RVal GetRVal(Store St, LVal LV, QualType T);
virtual Store SetRVal(Store St, LVal LV, RVal V);
virtual Store Remove(Store St, LVal LV);
virtual Store getInitialStore() {
return VBFactory.GetEmptyMap().getRoot();
}
};
} // end anonymous namespace
StoreManager* clang::CreateBasicStoreManager(llvm::BumpPtrAllocator& A) {
return new BasicStoreManager(A);
}
RVal BasicStoreManager::GetRVal(Store St, LVal LV, QualType T) {
if (isa<UnknownVal>(LV))
return UnknownVal();
assert (!isa<UndefinedVal>(LV));
switch (LV.getSubKind()) {
case lval::DeclValKind: {
VarBindingsTy B(static_cast<const VarBindingsTy::TreeTy*>(St));
VarBindingsTy::data_type* T = B.lookup(cast<lval::DeclVal>(LV).getDecl());
return T ? *T : UnknownVal();
}
case lval::SymbolValKind: {
// FIXME: This is a broken representation of memory, and is prone
// to crashing the analyzer when addresses to symbolic values are
// passed through casts. We need a better representation of symbolic
// memory (or just memory in general); probably we should do this
// as a plugin class (similar to GRTransferFuncs).
#if 0
const lval::SymbolVal& SV = cast<lval::SymbolVal>(LV);
assert (T.getTypePtr());
// Punt on "symbolic" function pointers.
if (T->isFunctionType())
return UnknownVal();
if (T->isPointerType())
return lval::SymbolVal(SymMgr.getContentsOfSymbol(SV.getSymbol()));
else
return nonlval::SymbolVal(SymMgr.getContentsOfSymbol(SV.getSymbol()));
#endif
return UnknownVal();
}
case lval::ConcreteIntKind:
// Some clients may call GetRVal with such an option simply because
// they are doing a quick scan through their LVals (potentially to
// invalidate their bindings). Just return Undefined.
return UndefinedVal();
case lval::ArrayOffsetKind:
case lval::FieldOffsetKind:
return UnknownVal();
case lval::FuncValKind:
return LV;
case lval::StringLiteralValKind:
// FIXME: Implement better support for fetching characters from strings.
return UnknownVal();
default:
assert (false && "Invalid LVal.");
break;
}
return UnknownVal();
}
Store BasicStoreManager::SetRVal(Store St, LVal LV, RVal V) {
VarBindingsTy B(static_cast<const VarBindingsTy::TreeTy*>(St));
switch (LV.getSubKind()) {
case lval::DeclValKind:
return V.isUnknown()
? VBFactory.Remove(B,cast<lval::DeclVal>(LV).getDecl()).getRoot()
: VBFactory.Add(B, cast<lval::DeclVal>(LV).getDecl(), V).getRoot();
default:
assert ("SetRVal for given LVal type not yet implemented.");
return St;
}
}
Store BasicStoreManager::Remove(Store St, LVal LV) {
VarBindingsTy B(static_cast<const VarBindingsTy::TreeTy*>(St));
switch (LV.getSubKind()) {
case lval::DeclValKind:
return VBFactory.Remove(B,cast<lval::DeclVal>(LV).getDecl()).getRoot();
default:
assert ("Remove for given LVal type not yet implemented.");
return St;
}
}