ProgramStateRef SimpleConstraintManager::assumeSymWithinInclusiveRange( ProgramStateRef State, SymbolRef Sym, const llvm::APSInt &From, const llvm::APSInt &To, bool InRange) { // Get the type used for calculating wraparound. BasicValueFactory &BVF = getBasicVals(); APSIntType WraparoundType = BVF.getAPSIntType(Sym->getType()); llvm::APSInt Adjustment = WraparoundType.getZeroValue(); SymbolRef AdjustedSym = Sym; computeAdjustment(AdjustedSym, Adjustment); // Convert the right-hand side integer as necessary. APSIntType ComparisonType = std::max(WraparoundType, APSIntType(From)); llvm::APSInt ConvertedFrom = ComparisonType.convert(From); llvm::APSInt ConvertedTo = ComparisonType.convert(To); // Prefer unsigned comparisons. if (ComparisonType.getBitWidth() == WraparoundType.getBitWidth() && ComparisonType.isUnsigned() && !WraparoundType.isUnsigned()) Adjustment.setIsSigned(false); if (InRange) return assumeSymbolWithinInclusiveRange(State, AdjustedSym, ConvertedFrom, ConvertedTo, Adjustment); return assumeSymbolOutOfInclusiveRange(State, AdjustedSym, ConvertedFrom, ConvertedTo, Adjustment); }
ProgramStateRef SimpleConstraintManager::assumeSymRel(ProgramStateRef State, const SymExpr *LHS, BinaryOperator::Opcode Op, const llvm::APSInt &Int) { assert(BinaryOperator::isComparisonOp(Op) && "Non-comparison ops should be rewritten as comparisons to zero."); // Get the type used for calculating wraparound. BasicValueFactory &BVF = getBasicVals(); APSIntType WraparoundType = BVF.getAPSIntType(LHS->getType()); // We only handle simple comparisons of the form "$sym == constant" // or "($sym+constant1) == constant2". // The adjustment is "constant1" in the above expression. It's used to // "slide" the solution range around for modular arithmetic. For example, // x < 4 has the solution [0, 3]. x+2 < 4 has the solution [0-2, 3-2], which // in modular arithmetic is [0, 1] U [UINT_MAX-1, UINT_MAX]. It's up to // the subclasses of SimpleConstraintManager to handle the adjustment. SymbolRef Sym = LHS; llvm::APSInt Adjustment = WraparoundType.getZeroValue(); computeAdjustment(Sym, Adjustment); // Convert the right-hand side integer as necessary. APSIntType ComparisonType = std::max(WraparoundType, APSIntType(Int)); llvm::APSInt ConvertedInt = ComparisonType.convert(Int); // Prefer unsigned comparisons. if (ComparisonType.getBitWidth() == WraparoundType.getBitWidth() && ComparisonType.isUnsigned() && !WraparoundType.isUnsigned()) Adjustment.setIsSigned(false); switch (Op) { default: llvm_unreachable("invalid operation not caught by assertion above"); case BO_EQ: return assumeSymEQ(State, Sym, ConvertedInt, Adjustment); case BO_NE: return assumeSymNE(State, Sym, ConvertedInt, Adjustment); case BO_GT: return assumeSymGT(State, Sym, ConvertedInt, Adjustment); case BO_GE: return assumeSymGE(State, Sym, ConvertedInt, Adjustment); case BO_LT: return assumeSymLT(State, Sym, ConvertedInt, Adjustment); case BO_LE: return assumeSymLE(State, Sym, ConvertedInt, Adjustment); } // end switch }