clang 8.0.0

SMTConstraintManager.h
Go to the documentation of this file.
1 //== SMTConstraintManager.h -------------------------------------*- 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 a SMT generic API, which will be the base class for
11 // every SMT solver specific class.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SMTCONSTRAINTMANAGER_H
16 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SMTCONSTRAINTMANAGER_H
17
18 #include "clang/StaticAnalyzer/Core/PathSensitive/RangedConstraintManager.h"
19 #include "clang/StaticAnalyzer/Core/PathSensitive/SMTConv.h"
20
21 namespace clang {
22 namespace ento {
23
24 template <typename ConstraintSMT, typename SMTExprTy>
25 class SMTConstraintManager : public clang::ento::SimpleConstraintManager {
26 SMTSolverRef &Solver;
27
28 public:
29 SMTConstraintManager(clang::ento::SubEngine *SE, clang::ento::SValBuilder &SB,
30 SMTSolverRef &S)
31 : SimpleConstraintManager(SE, SB), Solver(S) {}
32 virtual ~SMTConstraintManager() = default;
33
34 //===------------------------------------------------------------------===//
35 // Implementation for interface from SimpleConstraintManager.
36 //===------------------------------------------------------------------===//
37
38 ProgramStateRef assumeSym(ProgramStateRef State, SymbolRef Sym,
39 bool Assumption) override {
40 ASTContext &Ctx = getBasicVals().getContext();
41
42 QualType RetTy;
43 bool hasComparison;
44
45 SMTExprRef Exp = SMTConv::getExpr(Solver, Ctx, Sym, &RetTy, &hasComparison);
46
47 // Create zero comparison for implicit boolean cast, with reversed
48 // assumption
49 if (!hasComparison && !RetTy->isBooleanType())
50 return assumeExpr(
51 State, Sym,
52 SMTConv::getZeroExpr(Solver, Ctx, Exp, RetTy, !Assumption));
53
54 return assumeExpr(State, Sym, Assumption ? Exp : Solver->mkNot(Exp));
55 }
56
57 ProgramStateRef assumeSymInclusiveRange(ProgramStateRef State, SymbolRef Sym,
58 const llvm::APSInt &From,
59 const llvm::APSInt &To,
60 bool InRange) override {
61 ASTContext &Ctx = getBasicVals().getContext();
62 return assumeExpr(
63 State, Sym, SMTConv::getRangeExpr(Solver, Ctx, Sym, From, To, InRange));
64 }
65
66 ProgramStateRef assumeSymUnsupported(ProgramStateRef State, SymbolRef Sym,
67 bool Assumption) override {
68 // Skip anything that is unsupported
69 return State;
70 }
71
72 //===------------------------------------------------------------------===//
73 // Implementation for interface from ConstraintManager.
74 //===------------------------------------------------------------------===//
75
76 ConditionTruthVal checkNull(ProgramStateRef State, SymbolRef Sym) override {
77 ASTContext &Ctx = getBasicVals().getContext();
78
79 QualType RetTy;
80 // The expression may be casted, so we cannot call getZ3DataExpr() directly
81 SMTExprRef VarExp = SMTConv::getExpr(Solver, Ctx, Sym, &RetTy);
82 SMTExprRef Exp =
83 SMTConv::getZeroExpr(Solver, Ctx, VarExp, RetTy, /*Assumption=*/true);
84
85 // Negate the constraint
86 SMTExprRef NotExp =
87 SMTConv::getZeroExpr(Solver, Ctx, VarExp, RetTy, /*Assumption=*/false);
88
89 ConditionTruthVal isSat = checkModel(State, Sym, Exp);
90 ConditionTruthVal isNotSat = checkModel(State, Sym, NotExp);
91
92 // Zero is the only possible solution
93 if (isSat.isConstrainedTrue() && isNotSat.isConstrainedFalse())
94 return true;
95
96 // Zero is not a solution
97 if (isSat.isConstrainedFalse() && isNotSat.isConstrainedTrue())
98 return false;
99
100 // Zero may be a solution
101 return ConditionTruthVal();
102 }
103
104 const llvm::APSInt *getSymVal(ProgramStateRef State,
105 SymbolRef Sym) const override {
106 BasicValueFactory &BVF = getBasicVals();
107 ASTContext &Ctx = BVF.getContext();
108
109 if (const SymbolData *SD = dyn_cast<SymbolData>(Sym)) {
110 QualType Ty = Sym->getType();
111 assert(!Ty->isRealFloatingType());
112 llvm::APSInt Value(Ctx.getTypeSize(Ty),
113 !Ty->isSignedIntegerOrEnumerationType());
114
115 // TODO: this should call checkModel so we can use the cache, however,
116 // this method tries to get the interpretation (the actual value) from
117 // the solver, which is currently not cached.
118
119 SMTExprRef Exp =
120 SMTConv::fromData(Solver, SD->getSymbolID(), Ty, Ctx.getTypeSize(Ty));
121
122 Solver->reset();
123 addStateConstraints(State);
124
125 // Constraints are unsatisfiable
126 Optional<bool> isSat = Solver->check();
127 if (!isSat.hasValue() || !isSat.getValue())
128 return nullptr;
129
130 // Model does not assign interpretation
131 if (!Solver->getInterpretation(Exp, Value))
132 return nullptr;
133
134 // A value has been obtained, check if it is the only value
135 SMTExprRef NotExp = SMTConv::fromBinOp(
136 Solver, Exp, BO_NE,
137 Ty->isBooleanType() ? Solver->mkBoolean(Value.getBoolValue())
138 : Solver->mkBitvector(Value, Value.getBitWidth()),
139 /*isSigned=*/false);
140
141 Solver->addConstraint(NotExp);
142
143 Optional<bool> isNotSat = Solver->check();
144 if (!isSat.hasValue() || isNotSat.getValue())
145 return nullptr;
146
147 // This is the only solution, store it
148 return &BVF.getValue(Value);
149 }
150
151 if (const SymbolCast *SC = dyn_cast<SymbolCast>(Sym)) {
152 SymbolRef CastSym = SC->getOperand();
153 QualType CastTy = SC->getType();
154 // Skip the void type
155 if (CastTy->isVoidType())
156 return nullptr;
157
158 const llvm::APSInt *Value;
159 if (!(Value = getSymVal(State, CastSym)))
160 return nullptr;
161 return &BVF.Convert(SC->getType(), *Value);
162 }
163
164 if (const BinarySymExpr *BSE = dyn_cast<BinarySymExpr>(Sym)) {
165 const llvm::APSInt *LHS, *RHS;
166 if (const SymIntExpr *SIE = dyn_cast<SymIntExpr>(BSE)) {
167 LHS = getSymVal(State, SIE->getLHS());
168 RHS = &SIE->getRHS();
169 } else if (const IntSymExpr *ISE = dyn_cast<IntSymExpr>(BSE)) {
170 LHS = &ISE->getLHS();
171 RHS = getSymVal(State, ISE->getRHS());
172 } else if (const SymSymExpr *SSM = dyn_cast<SymSymExpr>(BSE)) {
173 // Early termination to avoid expensive call
174 LHS = getSymVal(State, SSM->getLHS());
175 RHS = LHS ? getSymVal(State, SSM->getRHS()) : nullptr;
176 } else {
177 llvm_unreachable("Unsupported binary expression to get symbol value!");
178 }
179
180 if (!LHS || !RHS)
181 return nullptr;
182
183 llvm::APSInt ConvertedLHS, ConvertedRHS;
184 QualType LTy, RTy;
185 std::tie(ConvertedLHS, LTy) = SMTConv::fixAPSInt(Ctx, *LHS);
186 std::tie(ConvertedRHS, RTy) = SMTConv::fixAPSInt(Ctx, *RHS);
187 SMTConv::doIntTypeConversion<llvm::APSInt, &SMTConv::castAPSInt>(
188 Solver, Ctx, ConvertedLHS, LTy, ConvertedRHS, RTy);
189 return BVF.evalAPSInt(BSE->getOpcode(), ConvertedLHS, ConvertedRHS);
190 }
191
192 llvm_unreachable("Unsupported expression to get symbol value!");
193 }
194
195 ProgramStateRef removeDeadBindings(ProgramStateRef State,
196 SymbolReaper &SymReaper) override {
197 auto CZ = State->get<ConstraintSMT>();
198 auto &CZFactory = State->get_context<ConstraintSMT>();
199
200 for (auto I = CZ.begin(), E = CZ.end(); I != E; ++I) {
201 if (SymReaper.isDead(I->first))
202 CZ = CZFactory.remove(CZ, *I);
203 }
204
205 return State->set<ConstraintSMT>(CZ);
206 }
207
208 void print(ProgramStateRef St, raw_ostream &OS, const char *nl,
209 const char *sep) override {
210
211 auto CZ = St->get<ConstraintSMT>();
212
213 OS << nl << sep << "Constraints:";
214 for (auto I = CZ.begin(), E = CZ.end(); I != E; ++I) {
215 OS << nl << ' ' << I->first << " : ";
216 I->second.print(OS);
217 }
218 OS << nl;
219 }
220
221 bool canReasonAbout(SVal X) const override {
222 const TargetInfo &TI = getBasicVals().getContext().getTargetInfo();
223
224 Optional<nonloc::SymbolVal> SymVal = X.getAs<nonloc::SymbolVal>();
225 if (!SymVal)
226 return true;
227
228 const SymExpr *Sym = SymVal->getSymbol();
229 QualType Ty = Sym->getType();
230
231 // Complex types are not modeled
232 if (Ty->isComplexType() || Ty->isComplexIntegerType())
233 return false;
234
235 // Non-IEEE 754 floating-point types are not modeled
236 if ((Ty->isSpecificBuiltinType(BuiltinType::LongDouble) &&
237 (&TI.getLongDoubleFormat() == &llvm::APFloat::x87DoubleExtended() ||
238 &TI.getLongDoubleFormat() == &llvm::APFloat::PPCDoubleDouble())))
239 return false;
240
241 if (Ty->isRealFloatingType())
242 return Solver->isFPSupported();
243
244 if (isa<SymbolData>(Sym))
245 return true;
246
247 SValBuilder &SVB = getSValBuilder();
248
249 if (const SymbolCast *SC = dyn_cast<SymbolCast>(Sym))
250 return canReasonAbout(SVB.makeSymbolVal(SC->getOperand()));
251
252 if (const BinarySymExpr *BSE = dyn_cast<BinarySymExpr>(Sym)) {
253 if (const SymIntExpr *SIE = dyn_cast<SymIntExpr>(BSE))
254 return canReasonAbout(SVB.makeSymbolVal(SIE->getLHS()));
255
256 if (const IntSymExpr *ISE = dyn_cast<IntSymExpr>(BSE))
257 return canReasonAbout(SVB.makeSymbolVal(ISE->getRHS()));
258
259 if (const SymSymExpr *SSE = dyn_cast<SymSymExpr>(BSE))
260 return canReasonAbout(SVB.makeSymbolVal(SSE->getLHS())) &&
261 canReasonAbout(SVB.makeSymbolVal(SSE->getRHS()));
262 }
263
264 llvm_unreachable("Unsupported expression to reason about!");
265 }
266
267 /// Dumps SMT formula
268 LLVM_DUMP_METHOD void dump() const { Solver->dump(); }
269
270 protected:
271 // Check whether a new model is satisfiable, and update the program state.
272 virtual ProgramStateRef assumeExpr(ProgramStateRef State, SymbolRef Sym,
273 const SMTExprRef &Exp) {
274 // Check the model, avoid simplifying AST to save time
275 if (checkModel(State, Sym, Exp).isConstrainedTrue())
276 return State->add<ConstraintSMT>(
277 std::make_pair(Sym, static_cast<const SMTExprTy &>(*Exp)));
278
279 return nullptr;
280 }
281
282 /// Given a program state, construct the logical conjunction and add it to
283 /// the solver
284 virtual void addStateConstraints(ProgramStateRef State) const {
285 // TODO: Don't add all the constraints, only the relevant ones
286 auto CZ = State->get<ConstraintSMT>();
287 auto I = CZ.begin(), IE = CZ.end();
288
289 // Construct the logical AND of all the constraints
290 if (I != IE) {
291 std::vector<SMTExprRef> ASTs;
292
293 SMTExprRef Constraint = Solver->newExprRef(I++->second);
294 while (I != IE) {
295 Constraint = Solver->mkAnd(Constraint, Solver->newExprRef(I++->second));
296 }
297
298 Solver->addConstraint(Constraint);
299 }
300 }
301
302 // Generate and check a Z3 model, using the given constraint.
303 ConditionTruthVal checkModel(ProgramStateRef State, SymbolRef Sym,
304 const SMTExprRef &Exp) const {
305 ProgramStateRef NewState = State->add<ConstraintSMT>(
306 std::make_pair(Sym, static_cast<const SMTExprTy &>(*Exp)));
307
308 llvm::FoldingSetNodeID ID;
309 NewState->get<ConstraintSMT>().Profile(ID);
310
311 unsigned hash = ID.ComputeHash();
312 auto I = Cached.find(hash);
313 if (I != Cached.end())
314 return I->second;
315
316 Solver->reset();
317 addStateConstraints(NewState);
318
319 Optional<bool> res = Solver->check();
320 if (!res.hasValue())
321 Cached[hash] = ConditionTruthVal();
322 else
323 Cached[hash] = ConditionTruthVal(res.getValue());
324
325 return Cached[hash];
326 }
327
328 // Cache the result of an SMT query (true, false, unknown). The key is the
329 // hash of the constraints in a state
330 mutable llvm::DenseMap<unsigned, ConditionTruthVal> Cached;
331 }; // end class SMTConstraintManager
332
333 } // namespace ento
334 } // namespace clang
335
336 #endif
clang::ento::ConditionTruthVal::isConstrainedFalse
bool isConstrainedFalse() const
Return true if the constraint is perfectly constrained to &#39;false&#39;.
Definition: ConstraintManager.h:62
clang::Builtin::ID
ID
Definition: Builtins.h:49
ento
clang::ento::SubEngine
Definition: SubEngine.h:47
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:638
clang::ento::SMTConstraintManager::checkModel
ConditionTruthVal checkModel(ProgramStateRef State, SymbolRef Sym, const SMTExprRef &Exp) const
Definition: SMTConstraintManager.h:303
clang::ento::SymbolReaper::isDead
bool isDead(SymbolRef sym)
Returns whether or not a symbol has been confirmed dead.
Definition: SymbolManager.h:614
clang::ento::SMTConv::getRangeExpr
static SMTExprRef getRangeExpr(SMTSolverRef &Solver, ASTContext &Ctx, SymbolRef Sym, const llvm::APSInt &From, const llvm::APSInt &To, bool InRange)
Definition: SMTConv.h:491
RangedConstraintManager.h
clang::Type::isRealFloatingType
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1937
clang::ento::SMTConv::getZeroExpr
static SMTExprRef getZeroExpr(SMTSolverRef &Solver, ASTContext &Ctx, const SMTExprRef &Exp, QualType Ty, bool Assumption)
Definition: SMTConv.h:461
clang::ento::SMTConv::getExpr
static SMTExprRef getExpr(SMTSolverRef &Solver, ASTContext &Ctx, SymbolRef Sym, QualType *RetTy=nullptr, bool *hasComparison=nullptr)
Definition: SMTConv.h:450
clang::ento::SMTConstraintManager
Definition: SMTConstraintManager.h:25
clang::ento::SMTConstraintManager::assumeSym
ProgramStateRef assumeSym(ProgramStateRef State, SymbolRef Sym, bool Assumption) override
Given a symbolic expression that can be reasoned about, assume that it is true/false and generate the...
Definition: SMTConstraintManager.h:38
clang::ento::SMTConstraintManager::print
void print(ProgramStateRef St, raw_ostream &OS, const char *nl, const char *sep) override
Definition: SMTConstraintManager.h:208
clang::ento::SMTConstraintManager::SMTConstraintManager
SMTConstraintManager(clang::ento::SubEngine *SE, clang::ento::SValBuilder &SB, SMTSolverRef &S)
Definition: SMTConstraintManager.h:29
clang::ASTContext::getTargetInfo
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:690
clang::ento::SMTConstraintManager::~SMTConstraintManager
virtual ~SMTConstraintManager()=default
Value
Value
Definition: UninitializedValues.cpp:102
clang::ento::BasicValueFactory
Definition: BasicValueFactory.h:107
clang::ento::SymExpr
Symbolic value.
Definition: SymExpr.h:30
clang::ento::SMTConv::fixAPSInt
static std::pair< llvm::APSInt, QualType > fixAPSInt(ASTContext &Ctx, const llvm::APSInt &Int)
Definition: SMTConv.h:537
clang::ento::SValBuilder::makeSymbolVal
SVal makeSymbolVal(SymbolRef Sym)
Make an SVal that represents the given symbol.
Definition: SValBuilder.h:373
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:155
clang::ento::SMTConv::fromData
static SMTExprRef fromData(SMTSolverRef &Solver, const SymbolID ID, const QualType &Ty, uint64_t BitWidth)
Construct an SMTExprRef from a SymbolData.
Definition: SMTConv.h:319
llvm::Optional
Definition: LLVM.h:38
State
LineState State
Definition: UnwrappedLineFormatter.cpp:877
clang::ento::SimpleConstraintManager
Definition: SimpleConstraintManager.h:24
clang::Type::isSpecificBuiltinType
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:6511
clang::ento::BasicValueFactory::Convert
const llvm::APSInt & Convert(const llvm::APSInt &To, const llvm::APSInt &From)
Convert - Create a new persistent APSInt with the same value as &#39;From&#39; but with the bitwidth and sign...
Definition: BasicValueFactory.h:150
clang::ento::SMTConstraintManager::checkNull
ConditionTruthVal checkNull(ProgramStateRef State, SymbolRef Sym) override
Returns whether or not a symbol is known to be null ("true"), known to be non-null ("false")...
Definition: SMTConstraintManager.h:76
clang::ento::SMTConstraintManager::assumeSymUnsupported
ProgramStateRef assumeSymUnsupported(ProgramStateRef State, SymbolRef Sym, bool Assumption) override
Given a symbolic expression that cannot be reasoned about, assume that it is zero/nonzero and add it ...
Definition: SMTConstraintManager.h:66
clang::ento::SymIntExpr
Represents a symbolic expression like &#39;x&#39; + 3.
Definition: SymbolManager.h:333
clang::ento::SMTConstraintManager::removeDeadBindings
ProgramStateRef removeDeadBindings(ProgramStateRef State, SymbolReaper &SymReaper) override
Scan all symbols referenced by the constraints.
Definition: SMTConstraintManager.h:195
clang::ento::SMTConstraintManager::dump
LLVM_DUMP_METHOD void dump() const
Dumps SMT formula.
Definition: SMTConstraintManager.h:268
clang::ento::SymExpr::getType
virtual QualType getType() const =0
clang::ento::SMTConstraintManager::getSymVal
const llvm::APSInt * getSymVal(ProgramStateRef State, SymbolRef Sym) const override
If a symbol is perfectly constrained to a constant, attempt to return the concrete value...
Definition: SMTConstraintManager.h:104
clang::ento::ConditionTruthVal::isConstrainedTrue
bool isConstrainedTrue() const
Return true if the constraint is perfectly constrained to &#39;true&#39;.
Definition: ConstraintManager.h:57
clang::Type::isComplexType
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
Definition: Type.cpp:481
clang::TargetInfo::getLongDoubleFormat
const llvm::fltSemantics & getLongDoubleFormat() const
Definition: TargetInfo.h:579
clang::TargetInfo
Exposes information about the current target.
Definition: TargetInfo.h:54
clang::ento::SMTConstraintManager::addStateConstraints
virtual void addStateConstraints(ProgramStateRef State) const
Given a program state, construct the logical conjunction and add it to the solver.
Definition: SMTConstraintManager.h:284
clang::ento::SimpleConstraintManager::getBasicVals
BasicValueFactory & getBasicVals() const
Definition: SimpleConstraintManager.h:79
clang::ento::BasicValueFactory::getContext
ASTContext & getContext() const
Definition: BasicValueFactory.h:135
clang::ento::SMTConstraintManager::assumeExpr
virtual ProgramStateRef assumeExpr(ProgramStateRef State, SymbolRef Sym, const SMTExprRef &Exp)
Definition: SMTConstraintManager.h:272
clang::ento::SymbolCast
Represents a cast expression.
Definition: SymbolManager.h:255
clang::ento::SimpleConstraintManager::getSValBuilder
SValBuilder & getSValBuilder() const
Definition: SimpleConstraintManager.h:78
clang::ento::SMTConstraintManager::canReasonAbout
bool canReasonAbout(SVal X) const override
canReasonAbout - Not all ConstraintManagers can accurately reason about all SVal values.
Definition: SMTConstraintManager.h:221
clang::ento::SVal::getAs
Optional< T > getAs() const
Convert to the specified SVal type, returning None if this SVal is not of the desired type...
Definition: SVals.h:112
llvm::IntrusiveRefCntPtr
Definition: LLVM.h:45
clang::ento::SMTConstraintManager::Cached
llvm::DenseMap< unsigned, ConditionTruthVal > Cached
Definition: SMTConstraintManager.h:330
clang::ento::SVal
SVal - This represents a symbolic expression, which can be either an L-value or an R-value...
Definition: SVals.h:76
clang::Type::isSignedIntegerOrEnumerationType
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition: Type.cpp:1860
clang::ento::IntSymExpr
Represents a symbolic expression like 3 - &#39;x&#39;.
Definition: SymbolManager.h:376
clang::ento::SymbolReaper
A class responsible for cleaning up unused symbols.
Definition: SymbolManager.h:549
clang::ento::BasicValueFactory::evalAPSInt
const llvm::APSInt * evalAPSInt(BinaryOperator::Opcode Op, const llvm::APSInt &V1, const llvm::APSInt &V2)
Definition: BasicValueFactory.cpp:206
clang::ento::SMTConv::fromBinOp
static SMTExprRef fromBinOp(SMTSolverRef &Solver, const SMTExprRef &LHS, const BinaryOperator::Opcode Op, const SMTExprRef &RHS, bool isSigned)
Construct an SMTExprRef from a binary operator.
Definition: SMTConv.h:91
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:22
clang::ento::BinarySymExpr
Represents a symbolic expression involving a binary operator.
Definition: SymbolManager.h:304
SMTConv.h
clang::Type::isBooleanType
bool isBooleanType() const
Definition: Type.h:6657
clang::ento::SValBuilder
Definition: SValBuilder.h:53
clang::ento::nonloc::SymbolVal
Represents symbolic expression that isn&#39;t a location.
Definition: SVals.h:347
clang::ento::SMTSolverRef
std::shared_ptr< SMTSolver > SMTSolverRef
Shared pointer for SMTSolvers.
Definition: SMTSolver.h:295
clang::ento::ObjKind::OS
Indicates that the tracking object is a descendant of a referenced-counted OSObject, used in the Darwin kernel.
clang::ASTContext::getTypeSize
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2070
X
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:13954
clang::ento::SMTConstraintManager::assumeSymInclusiveRange
ProgramStateRef assumeSymInclusiveRange(ProgramStateRef State, SymbolRef Sym, const llvm::APSInt &From, const llvm::APSInt &To, bool InRange) override
Given a symbolic expression within the range [From, To], assume that it is true/false and generate th...
Definition: SMTConstraintManager.h:57
clang::Type::isVoidType
bool isVoidType() const
Definition: Type.h:6544
clang::Type::isComplexIntegerType
bool isComplexIntegerType() const
Definition: Type.cpp:487
clang::ento::SMTExprRef
std::shared_ptr< SMTExpr > SMTExprRef
Shared pointer for SMTExprs, used by SMTSolver API.
Definition: SMTExpr.h:57
clang::ento::ConditionTruthVal
Definition: ConstraintManager.h:39
clang::ento::SymSymExpr
Represents a symbolic expression like &#39;x&#39; + &#39;y&#39;.
Definition: SymbolManager.h:419
clang::ento::SymbolData
A symbol representing data which can be stored in a memory location (region).
Definition: SymExpr.h:117