 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
78.9% |
30 / 38 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
89.5% |
34 / 38 |
| |
|
Line Coverage: |
90.0% |
54 / 60 |
| |
 |
|
 |
1 : //== ValueManager.cpp - Aggregate manager of symbols and SVals --*- 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 ValueManager, a class that manages symbolic values
11 : // and SVals created for use by GRExprEngine and related classes. It
12 : // wraps and owns SymbolManager, MemRegionManager, and BasicValueFactory.
13 : //
14 : //===----------------------------------------------------------------------===//
15 :
16 : #include "clang/Checker/PathSensitive/ValueManager.h"
17 : #include "clang/Analysis/AnalysisContext.h"
18 :
19 : using namespace clang;
20 : using namespace llvm;
21 :
22 : //===----------------------------------------------------------------------===//
23 : // Utility methods for constructing SVals.
24 : //===----------------------------------------------------------------------===//
25 :
26 155: DefinedOrUnknownSVal ValueManager::makeZeroVal(QualType T) {
97: branch 1 taken
58: branch 2 taken
27 155: if (Loc::IsLocType(T))
28 97: return makeNull();
29 :
54: branch 2 taken
4: branch 3 taken
30 58: if (T->isIntegerType())
31 54: return makeIntVal(0, T);
32 :
33 : // FIXME: Handle floats.
34 : // FIXME: Handle structs.
35 4: return UnknownVal();
36 : }
37 :
38 : //===----------------------------------------------------------------------===//
39 : // Utility methods for constructing Non-Locs.
40 : //===----------------------------------------------------------------------===//
41 :
42 : NonLoc ValueManager::makeNonLoc(const SymExpr *lhs, BinaryOperator::Opcode op,
43 1266: const APSInt& v, QualType T) {
44 : // The Environment ensures we always get a persistent APSInt in
45 : // BasicValueFactory, so we don't need to get the APSInt from
46 : // BasicValueFactory again.
0: branch 1 not taken
1266: branch 2 taken
47 1266: assert(!Loc::IsLocType(T));
48 1266: return nonloc::SymExprVal(SymMgr.getSymIntExpr(lhs, op, v, T));
49 : }
50 :
51 : NonLoc ValueManager::makeNonLoc(const SymExpr *lhs, BinaryOperator::Opcode op,
52 0: const SymExpr *rhs, QualType T) {
0: branch 3 not taken
0: branch 4 not taken
53 0: assert(SymMgr.getType(lhs) == SymMgr.getType(rhs));
0: branch 1 not taken
0: branch 2 not taken
54 0: assert(!Loc::IsLocType(T));
55 0: return nonloc::SymExprVal(SymMgr.getSymSymExpr(lhs, op, rhs, T));
56 : }
57 :
58 :
59 559: SVal ValueManager::convertToArrayIndex(SVal V) {
0: branch 1 not taken
559: branch 2 taken
60 559: if (V.isUnknownOrUndef())
61 0: return V;
62 :
63 : // Common case: we have an appropriately sized integer.
559: branch 1 taken
0: branch 2 not taken
64 559: if (nonloc::ConcreteInt* CI = dyn_cast<nonloc::ConcreteInt>(&V)) {
65 559: const llvm::APSInt& I = CI->getValue();
480: branch 1 taken
79: branch 2 taken
265: branch 4 taken
215: branch 5 taken
265: branch 6 taken
294: branch 7 taken
66 559: if (I.getBitWidth() == ArrayIndexWidth && I.isSigned())
67 265: return V;
68 : }
69 :
70 294: return SVator->EvalCastNL(cast<NonLoc>(V), ArrayIndexTy);
71 : }
72 :
73 : DefinedOrUnknownSVal ValueManager::getRegionValueSymbolVal(const MemRegion* R,
74 2632: QualType T) {
75 :
680: branch 1 taken
1952: branch 2 taken
76 2632: if (T.isNull()) {
77 680: const TypedRegion* TR = cast<TypedRegion>(R);
78 680: T = TR->getValueType(SymMgr.getContext());
79 : }
80 :
38: branch 1 taken
2594: branch 2 taken
81 2632: if (!SymbolManager::canSymbolicate(T))
82 38: return UnknownVal();
83 :
84 2594: SymbolRef sym = SymMgr.getRegionValueSymbol(R, T);
85 :
1653: branch 1 taken
941: branch 2 taken
86 2594: if (Loc::IsLocType(T))
87 1653: return loc::MemRegionVal(MemMgr.getSymbolicRegion(sym));
88 :
89 941: return nonloc::SymbolVal(sym);
90 : }
91 :
92 : DefinedOrUnknownSVal ValueManager::getConjuredSymbolVal(const void *SymbolTag,
93 : const Expr *E,
94 355: unsigned Count) {
95 355: QualType T = E->getType();
96 :
76: branch 1 taken
279: branch 2 taken
97 355: if (!SymbolManager::canSymbolicate(T))
98 76: return UnknownVal();
99 :
100 279: SymbolRef sym = SymMgr.getConjuredSymbol(E, Count, SymbolTag);
101 :
96: branch 1 taken
183: branch 2 taken
102 279: if (Loc::IsLocType(T))
103 96: return loc::MemRegionVal(MemMgr.getSymbolicRegion(sym));
104 :
105 183: return nonloc::SymbolVal(sym);
106 : }
107 :
108 : DefinedOrUnknownSVal ValueManager::getConjuredSymbolVal(const void *SymbolTag,
109 : const Expr *E,
110 : QualType T,
111 1246: unsigned Count) {
112 :
66: branch 1 taken
1180: branch 2 taken
113 1246: if (!SymbolManager::canSymbolicate(T))
114 66: return UnknownVal();
115 :
116 1180: SymbolRef sym = SymMgr.getConjuredSymbol(E, T, Count, SymbolTag);
117 :
430: branch 1 taken
750: branch 2 taken
118 1180: if (Loc::IsLocType(T))
119 430: return loc::MemRegionVal(MemMgr.getSymbolicRegion(sym));
120 :
121 750: return nonloc::SymbolVal(sym);
122 : }
123 :
124 :
125 : DefinedOrUnknownSVal
126 : ValueManager::getDerivedRegionValueSymbolVal(SymbolRef parentSymbol,
127 80: const TypedRegion *R) {
128 80: QualType T = R->getValueType(R->getContext());
129 :
0: branch 1 not taken
80: branch 2 taken
130 80: if (!SymbolManager::canSymbolicate(T))
131 0: return UnknownVal();
132 :
133 80: SymbolRef sym = SymMgr.getDerivedSymbol(parentSymbol, R);
134 :
37: branch 1 taken
43: branch 2 taken
135 80: if (Loc::IsLocType(T))
136 37: return loc::MemRegionVal(MemMgr.getSymbolicRegion(sym));
137 :
138 43: return nonloc::SymbolVal(sym);
139 : }
140 :
141 1634: DefinedSVal ValueManager::getFunctionPointer(const FunctionDecl* FD) {
142 1634: return loc::MemRegionVal(MemMgr.getFunctionTextRegion(FD));
143 : }
144 :
145 : DefinedSVal ValueManager::getBlockPointer(const BlockDecl *D,
146 : CanQualType locTy,
147 66: const LocationContext *LC) {
148 : const BlockTextRegion *BC =
149 66: MemMgr.getBlockTextRegion(D, locTy, LC->getAnalysisContext());
150 66: const BlockDataRegion *BD = MemMgr.getBlockDataRegion(BC, LC);
151 66: return loc::MemRegionVal(BD);
152 : }
153 :
Generated: 2010-02-10 01:31 by zcov