StateTy AssumeSymEQ(StateTy St, SymbolID sym, const llvm::APSInt& V,
bool& isFeasible);
+ StateTy AssumeSymInt(StateTy St, bool Assumption, const SymIntConstraint& C,
+ bool& isFeasible);
+
void Nodify(NodeSet& Dst, Stmt* S, NodeTy* Pred, StateTy St);
/// Nodify - This version of Nodify is used to batch process a set of states.
return AssumeSymEQ(St, cast<lval::SymbolVal>(Cond).getSymbol(),
ValMgr.getZeroWithPtrWidth(), isFeasible);
+
case lval::DeclValKind:
isFeasible = Assumption;
return St;
assert (false && "'Assume' not implemented for this NonLValue.");
return St;
+ case nonlval::SymIntConstraintValKind:
+ return
+ AssumeSymInt(St, Assumption,
+ cast<nonlval::SymIntConstraintVal>(Cond).getConstraint(),
+ isFeasible);
+
case nonlval::ConcreteIntKind: {
bool b = cast<nonlval::ConcreteInt>(Cond).getValue() != 0;
isFeasible = b ? Assumption : !Assumption;
return StateMgr.AddEQ(St, sym, V);
}
+GRConstants::StateTy
+GRConstants::AssumeSymInt(StateTy St, bool Assumption,
+ const SymIntConstraint& C, bool& isFeasible) {
+
+ switch (C.getOpcode()) {
+ default:
+ // No logic yet for other operators.
+ return St;
+
+ case BinaryOperator::EQ:
+ if (Assumption)
+ return AssumeSymEQ(St, C.getSymbol(), C.getInt(), isFeasible);
+ else
+ return AssumeSymNE(St, C.getSymbol(), C.getInt(), isFeasible);
+
+ case BinaryOperator::NE:
+ if (Assumption)
+ return AssumeSymNE(St, C.getSymbol(), C.getInt(), isFeasible);
+ else
+ return AssumeSymEQ(St, C.getSymbol(), C.getInt(), isFeasible);
+ }
+}
+
//===----------------------------------------------------------------------===//
// Driver.
//===----------------------------------------------------------------------===//
APSInt V = cast<nonlval::ConcreteInt>(this)->getValue();
QualType T = CastExpr->getType();
- V.setIsUnsigned(T->isUnsignedIntegerType());
+ V.setIsUnsigned(T->isUnsignedIntegerType() || T->isPointerType());
V.extOrTrunc(ValMgr.getContext().getTypeSize(T, CastExpr->getLocStart()));
if (CastExpr->getType()->isPointerType())
case lval::SymbolValKind:
Out << '$' << cast<lval::SymbolVal>(this)->getSymbol();
break;
-
- case lval::SymIntConstraintValKind: {
- const lval::SymIntConstraintVal& C =
- *cast<lval::SymIntConstraintVal>(this);
-
- Out << '$' << C.getConstraint().getSymbol() << ' ';
- printOpcode(Out, C.getConstraint().getOpcode());
- Out << ' ' << C.getConstraint().getInt().toString();
- break;
- }
-
+
case lval::DeclValKind:
Out << '&'
<< cast<lval::DeclVal>(this)->getDecl()->getIdentifier()->getName();
namespace lval {
enum Kind { SymbolValKind,
- SymIntConstraintValKind,
DeclValKind,
ConcreteIntKind,
NumKind };
}
};
- class SymIntConstraintVal : public LValue {
- public:
- SymIntConstraintVal(const SymIntConstraint& C)
- : LValue(SymIntConstraintValKind, reinterpret_cast<const void*>(&C)) {}
-
- const SymIntConstraint& getConstraint() const {
- return *reinterpret_cast<SymIntConstraint*>(getRawPtr());
- }
-
- static inline bool classof(const RValue* V) {
- return isa<LValue>(V) && V->getSubKind() == SymIntConstraintValKind;
- }
- };
-
class DeclVal : public LValue {
public:
DeclVal(const ValueDecl* vd) : LValue(DeclValKind,vd) {}