From f870aa1e0723e9203df495020ee2bf2bc47a6246 Mon Sep 17 00:00:00 2001 From: Daniel Dunbar Date: Thu, 4 Jun 2009 08:31:20 +0000 Subject: Finish removing uses of Expr::isConstant. git-svn-id: https://llvm.org/svn/llvm-project/klee/trunk@72859 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Expr/Constraints.cpp | 6 +-- lib/Expr/Expr.cpp | 93 ++++++++++++++++++++++------------------------ lib/Expr/ExprEvaluator.cpp | 13 ++++--- 3 files changed, 54 insertions(+), 58 deletions(-) (limited to 'lib/Expr') diff --git a/lib/Expr/Constraints.cpp b/lib/Expr/Constraints.cpp index 9103c7c3..5869a852 100644 --- a/lib/Expr/Constraints.cpp +++ b/lib/Expr/Constraints.cpp @@ -87,7 +87,7 @@ void ConstraintManager::simplifyForValidConstraint(ref e) { } ref ConstraintManager::simplifyExpr(ref e) const { - if (e->isConstant()) + if (isa(e)) return e; std::map< ref, ref > equalities; @@ -95,7 +95,7 @@ ref ConstraintManager::simplifyExpr(ref e) const { for (ConstraintManager::constraints_ty::const_iterator it = constraints.begin(), ie = constraints.end(); it != ie; ++it) { if (const EqExpr *ee = dyn_cast(*it)) { - if (ee->left->isConstant()) { + if (isa(ee->left)) { equalities.insert(std::make_pair(ee->right, ee->left)); } else { @@ -135,7 +135,7 @@ void ConstraintManager::addConstraintInternal(ref e) { case Expr::Eq: { BinaryExpr *be = cast(e); - if (be->left->isConstant()) { + if (isa(be->left)) { ExprReplaceVisitor visitor(be->right, be->left); rewriteConstraints(visitor); } diff --git a/lib/Expr/Expr.cpp b/lib/Expr/Expr.cpp index 0a174179..f95369f4 100644 --- a/lib/Expr/Expr.cpp +++ b/lib/Expr/Expr.cpp @@ -378,8 +378,8 @@ ref ReadExpr::create(const UpdateList &ul, ref index) { for (; un; un=un->next) { ref cond = EqExpr::create(index, un->index); - if (cond->isConstant()) { - if (cond->getConstantValue()) + if (ConstantExpr *CE = dyn_cast(cond)) { + if (CE->getConstantValue()) return un->value; } else { break; @@ -399,19 +399,19 @@ ref SelectExpr::create(ref c, ref t, ref f) { assert(c->getWidth()==Bool && "type mismatch"); assert(kt==f->getWidth() && "type mismatch"); - if (c->isConstant()) { - return c->getConstantValue() ? t : f; + if (ConstantExpr *CE = dyn_cast(c)) { + return CE->getConstantValue() ? t : f; } else if (t==f) { return t; } else if (kt==Expr::Bool) { // c ? t : f <=> (c and t) or (not c and f) - if (t->isConstant()) { - if (t->getConstantValue()) { + if (ConstantExpr *CE = dyn_cast(t)) { + if (CE->getConstantValue()) { return OrExpr::create(c, f); } else { return AndExpr::create(Expr::createNot(c), f); } - } else if (f->isConstant()) { - if (f->getConstantValue()) { + } else if (ConstantExpr *CE = dyn_cast(f)) { + if (CE->getConstantValue()) { return OrExpr::create(Expr::createNot(c), t); } else { return AndExpr::create(c, t); @@ -483,12 +483,12 @@ ref ExtractExpr::create(ref expr, unsigned off, Width w) { unsigned kw = expr->getWidth(); assert(w > 0 && off + w <= kw && "invalid extract"); - if (w == kw) + if (w == kw) { return expr; - else if (expr->isConstant()) { - return ConstantExpr::create(ints::trunc(expr->getConstantValue() >> off, w, kw), w); - } - else + } else if (ConstantExpr *CE = dyn_cast(expr)) { + return ConstantExpr::create(ints::trunc(CE->getConstantValue() >> off, w, + kw), w); + } else { // Extract(Concat) if (ConcatExpr *ce = dyn_cast(expr)) { // if the extract skips the right side of the concat @@ -503,6 +503,7 @@ ref ExtractExpr::create(ref expr, unsigned off, Width w) { return ConcatExpr::create(ExtractExpr::create(ce->getKid(0), 0, w - ce->getKid(1)->getWidth() + off), ExtractExpr::create(ce->getKid(1), off, ce->getKid(1)->getWidth() - off)); } + } return ExtractExpr::alloc(expr, off, w); } @@ -521,10 +522,9 @@ ref ZExtExpr::create(const ref &e, Width w) { } else if (w < kBits) { // trunc return ExtractExpr::createByteOff(e, 0, w); } else { - if (e->isConstant()) { - return ConstantExpr::create(ints::zext(e->getConstantValue(), w, kBits), + if (ConstantExpr *CE = dyn_cast(e)) + return ConstantExpr::create(ints::zext(CE->getConstantValue(), w, kBits), w); - } return ZExtExpr::alloc(e, w); } @@ -537,10 +537,9 @@ ref SExtExpr::create(const ref &e, Width w) { } else if (w < kBits) { // trunc return ExtractExpr::createByteOff(e, 0, w); } else { - if (e->isConstant()) { - return ConstantExpr::create(ints::sext(e->getConstantValue(), w, kBits), + if (ConstantExpr *CE = dyn_cast(e)) + return ConstantExpr::create(ints::sext(CE->getConstantValue(), w, kBits), w); - } return SExtExpr::alloc(e, w); } @@ -612,10 +611,10 @@ static ref SubExpr_createPartialR(const ref &cl, Expr *r) { return XorExpr_createPartialR(cl, r); } else { Expr::Kind rk = r->getKind(); - if (rk==Expr::Add && r->getKid(0)->isConstant()) { // A - (B+c) == (A-B) - c + if (rk==Expr::Add && isa(r->getKid(0))) { // A - (B+c) == (A-B) - c return SubExpr::create(SubExpr::create(cl, r->getKid(0)), r->getKid(1)); - } else if (rk==Expr::Sub && r->getKid(0)->isConstant()) { // A - (B-c) == (A-B) + c + } else if (rk==Expr::Sub && isa(r->getKid(0))) { // A - (B-c) == (A-B) + c return AddExpr::create(SubExpr::create(cl, r->getKid(0)), r->getKid(1)); } else { @@ -624,7 +623,6 @@ static ref SubExpr_createPartialR(const ref &cl, Expr *r) { } } static ref SubExpr_createPartial(Expr *l, const ref &cr) { - assert(cr->isConstant() && "non-constant passed in place of constant"); uint64_t value = cr->getConstantValue(); Expr::Width width = cr->getWidth(); uint64_t nvalue = ints::sub(0, value, width); @@ -659,7 +657,6 @@ static ref SubExpr_create(Expr *l, Expr *r) { } static ref MulExpr_createPartialR(const ref &cl, Expr *r) { - assert(cl->isConstant() && "non-constant passed in place of constant"); uint64_t value = cl->getConstantValue(); Expr::Width type = cl->getWidth(); @@ -897,9 +894,8 @@ static ref EqExpr_create(const ref &l, const ref &r) { /// rd a ReadExpr. If rd is a read into an all-constant array, /// returns a disjunction of equalities on the index. Otherwise, /// returns the initial equality expression. -static ref TryConstArrayOpt(const ref &cl, +static ref TryConstArrayOpt(const ref &cl, ReadExpr *rd) { - assert(cl->isConstant() && "constant expression required"); assert(rd->getKind() == Expr::Read && "read expression required"); uint64_t ct = cl->getConstantValue(); @@ -921,22 +917,21 @@ static ref TryConstArrayOpt(const ref &cl, ref idx = un->index; ref val = un->value; - if (!idx->isConstant() || !val->isConstant()) { - all_const = false; - //llvm::cerr << "Idx or val not constant\n"; - break; + ConstantExpr *idxCE = dyn_cast(idx); + ConstantExpr *valCE = dyn_cast(val); + if (!idxCE || !valCE) { + all_const = false; + break; + } + + if (idxCE->getConstantValue() != k) { + all_const = false; + break; } - else { - if (idx->getConstantValue() != k) { - all_const = false; - //llvm::cerr << "Wrong constant\n"; - break; - } - if (val->getConstantValue() == ct) { - matches++; - if (matches == 1) - first_idx_match = un->index; - } + if (valCE->getConstantValue() == ct) { + matches++; + if (matches == 1) + first_idx_match = un->index; } } } @@ -968,7 +963,6 @@ static ref TryConstArrayOpt(const ref &cl, static ref EqExpr_createPartialR(const ref &cl, Expr *r) { - assert(cl->isConstant() && "non-constant passed in place of constant"); uint64_t value = cl->getConstantValue(); Expr::Width width = cl->getWidth(); @@ -983,10 +977,11 @@ static ref EqExpr_createPartialR(const ref &cl, Expr *r) { const EqExpr *ree = cast(r); // eliminate double negation - if (ree->left->isConstant() && - ree->left->getWidth()==Expr::Bool) { - assert(!ree->left->getConstantValue()); - return ree->right; + if (ConstantExpr *CE = dyn_cast(ree->left)) { + if (CE->getWidth() == Expr::Bool) { + assert(!CE->getConstantValue()); + return ree->right; + } } } else if (rk == Expr::Or) { const OrExpr *roe = cast(r); @@ -1024,7 +1019,7 @@ static ref EqExpr_createPartialR(const ref &cl, Expr *r) { } } else if (rk==Expr::Add) { const AddExpr *ae = cast(r); - if (ae->left->isConstant()) { + if (isa(ae->left)) { // c0 = c1 + b => c0 - c1 = b return EqExpr_createPartialR(cast(SubExpr::create(cl, ae->left)), @@ -1032,7 +1027,7 @@ static ref EqExpr_createPartialR(const ref &cl, Expr *r) { } } else if (rk==Expr::Sub) { const SubExpr *se = cast(r); - if (se->left->isConstant()) { + if (isa(se->left)) { // c0 = c1 - b => c1 - c0 = b return EqExpr_createPartialR(cast(SubExpr::create(se->left, cl)), @@ -1073,8 +1068,8 @@ static ref UltExpr_create(const ref &l, const ref &r) { if (t == Expr::Bool) { // !l && r return AndExpr::create(Expr::createNot(l), r); } else { - if (r->isConstant()) { - uint64_t value = r->getConstantValue(); + if (ConstantExpr *CE = dyn_cast(r)) { + uint64_t value = CE->getConstantValue(); if (value <= 8) { ref res = ConstantExpr::alloc(0, Expr::Bool); for (unsigned i=0; inext) { ref ui = visit(un->index); - if (ui->isConstant()) { - if (ui->getConstantValue() == index) + if (ConstantExpr *CE = dyn_cast(ui)) { + if (CE->getConstantValue() == index) return Action::changeTo(visit(un->value)); } else { // update index is unknown, so may or may not be index, we @@ -36,8 +36,8 @@ ExprVisitor::Action ExprEvaluator::evalRead(const UpdateList &ul, ExprVisitor::Action ExprEvaluator::visitRead(const ReadExpr &re) { ref v = visit(re.index); - if (v->isConstant()) { - return evalRead(re.updates, v->getConstantValue()); + if (ConstantExpr *CE = dyn_cast(v)) { + return evalRead(re.updates, CE->getConstantValue()); } else { return Action::doChildren(); } @@ -50,8 +50,9 @@ ExprVisitor::Action ExprEvaluator::protectedDivOperation(const BinaryExpr &e) { ref kids[2] = { visit(e.left), visit(e.right) }; - if (kids[1]->isConstant() && !kids[1]->getConstantValue()) - kids[1] = e.right; + if (ConstantExpr *CE = dyn_cast(kids[1])) + if (!CE->getConstantValue()) + kids[1] = e.right; if (kids[0]!=e.left || kids[1]!=e.right) { return Action::changeTo(e.rebuild(kids)); -- cgit 1.4.1