Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 1 | // SValuator.cpp - Basic class for all SValuator implementations --*- 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 SValuator, the base class for all (complete) SValuator |
| 11 | // implementations. |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
| 15 | #include "clang/Analysis/PathSensitive/SValuator.h" |
| 16 | #include "clang/Analysis/PathSensitive/GRState.h" |
| 17 | |
| 18 | using namespace clang; |
| 19 | |
Ted Kremenek | ff4264d | 2009-08-25 18:44:25 +0000 | [diff] [blame] | 20 | |
| 21 | SVal SValuator::EvalBinOp(const GRState *ST, BinaryOperator::Opcode Op, |
| 22 | SVal L, SVal R, QualType T) { |
| 23 | |
| 24 | if (L.isUndef() || R.isUndef()) |
| 25 | return UndefinedVal(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 26 | |
Ted Kremenek | ff4264d | 2009-08-25 18:44:25 +0000 | [diff] [blame] | 27 | if (L.isUnknown() || R.isUnknown()) |
| 28 | return UnknownVal(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 29 | |
Ted Kremenek | ff4264d | 2009-08-25 18:44:25 +0000 | [diff] [blame] | 30 | if (isa<Loc>(L)) { |
| 31 | if (isa<Loc>(R)) |
| 32 | return EvalBinOpLL(Op, cast<Loc>(L), cast<Loc>(R), T); |
| 33 | |
| 34 | return EvalBinOpLN(ST, Op, cast<Loc>(L), cast<NonLoc>(R), T); |
| 35 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 36 | |
Ted Kremenek | ff4264d | 2009-08-25 18:44:25 +0000 | [diff] [blame] | 37 | if (isa<Loc>(R)) { |
| 38 | // Support pointer arithmetic where the increment/decrement operand |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 39 | // is on the left and the pointer on the right. |
Ted Kremenek | ff4264d | 2009-08-25 18:44:25 +0000 | [diff] [blame] | 40 | assert(Op == BinaryOperator::Add || Op == BinaryOperator::Sub); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 41 | |
Ted Kremenek | ff4264d | 2009-08-25 18:44:25 +0000 | [diff] [blame] | 42 | // Commute the operands. |
| 43 | return EvalBinOpLN(ST, Op, cast<Loc>(R), cast<NonLoc>(L), T); |
| 44 | } |
| 45 | |
Ted Kremenek | cd8f6ac | 2009-10-06 01:39:48 +0000 | [diff] [blame] | 46 | return EvalBinOpNN(ST, Op, cast<NonLoc>(L), cast<NonLoc>(R), T); |
Ted Kremenek | ff4264d | 2009-08-25 18:44:25 +0000 | [diff] [blame] | 47 | } |
| 48 | |
Ted Kremenek | 5b9bd21 | 2009-09-11 22:07:28 +0000 | [diff] [blame] | 49 | DefinedOrUnknownSVal SValuator::EvalEQ(const GRState *ST, |
| 50 | DefinedOrUnknownSVal L, |
| 51 | DefinedOrUnknownSVal R) { |
| 52 | return cast<DefinedOrUnknownSVal>(EvalBinOp(ST, BinaryOperator::EQ, L, R, |
| 53 | ValMgr.getContext().IntTy)); |
| 54 | } |
| 55 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 56 | SValuator::CastResult SValuator::EvalCast(SVal val, const GRState *state, |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 57 | QualType castTy, QualType originalTy){ |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 58 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 59 | if (val.isUnknownOrUndef() || castTy == originalTy) |
| 60 | return CastResult(state, val); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 61 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 62 | ASTContext &C = ValMgr.getContext(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 63 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 64 | // For const casts, just propagate the value. |
Douglas Gregor | a4923eb | 2009-11-16 21:35:15 +0000 | [diff] [blame] | 65 | if (C.hasSameUnqualifiedType(castTy, originalTy)) |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 66 | return CastResult(state, val); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 67 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 68 | // Check for casts from pointers to integers. |
| 69 | if (castTy->isIntegerType() && Loc::IsLocType(originalTy)) |
| 70 | return CastResult(state, EvalCastL(cast<Loc>(val), castTy)); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 71 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 72 | // Check for casts from integers to pointers. |
| 73 | if (Loc::IsLocType(castTy) && originalTy->isIntegerType()) { |
| 74 | if (nonloc::LocAsInteger *LV = dyn_cast<nonloc::LocAsInteger>(&val)) { |
| 75 | // Just unpackage the lval and return it. |
| 76 | return CastResult(state, LV->getLoc()); |
| 77 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 78 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 79 | goto DispatchCast; |
| 80 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 81 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 82 | // Just pass through function and block pointers. |
| 83 | if (originalTy->isBlockPointerType() || originalTy->isFunctionPointerType()) { |
| 84 | assert(Loc::IsLocType(castTy)); |
| 85 | return CastResult(state, val); |
| 86 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 87 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 88 | // Check for casts from array type to another type. |
| 89 | if (originalTy->isArrayType()) { |
| 90 | // We will always decay to a pointer. |
| 91 | val = ValMgr.getStateManager().ArrayToPointer(cast<Loc>(val)); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 92 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 93 | // Are we casting from an array to a pointer? If so just pass on |
| 94 | // the decayed value. |
| 95 | if (castTy->isPointerType()) |
| 96 | return CastResult(state, val); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 97 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 98 | // Are we casting from an array to an integer? If so, cast the decayed |
| 99 | // pointer value to an integer. |
| 100 | assert(castTy->isIntegerType()); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 101 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 102 | // FIXME: Keep these here for now in case we decide soon that we |
| 103 | // need the original decayed type. |
| 104 | // QualType elemTy = cast<ArrayType>(originalTy)->getElementType(); |
| 105 | // QualType pointerTy = C.getPointerType(elemTy); |
| 106 | return CastResult(state, EvalCastL(cast<Loc>(val), castTy)); |
| 107 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 108 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 109 | // Check for casts from a region to a specific type. |
| 110 | if (const MemRegion *R = val.getAsRegion()) { |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 111 | // FIXME: We should handle the case where we strip off view layers to get |
| 112 | // to a desugared type. |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 113 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 114 | assert(Loc::IsLocType(castTy)); |
| 115 | // We get a symbolic function pointer for a dereference of a function |
| 116 | // pointer, but it is of function type. Example: |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 117 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 118 | // struct FPRec { |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 119 | // void (*my_func)(int * x); |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 120 | // }; |
| 121 | // |
| 122 | // int bar(int x); |
| 123 | // |
| 124 | // int f1_a(struct FPRec* foo) { |
| 125 | // int x; |
| 126 | // (*foo->my_func)(&x); |
| 127 | // return bar(x)+1; // no-warning |
| 128 | // } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 129 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 130 | assert(Loc::IsLocType(originalTy) || originalTy->isFunctionType() || |
| 131 | originalTy->isBlockPointerType()); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 132 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 133 | StoreManager &storeMgr = ValMgr.getStateManager().getStoreManager(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 134 | |
Zhongxing Xu | 09270cc | 2009-10-14 06:55:01 +0000 | [diff] [blame] | 135 | // Delegate to store manager to get the result of casting a region to a |
| 136 | // different type. If the MemRegion* returned is NULL, this expression |
| 137 | // evaluates to UnknownVal. |
| 138 | R = storeMgr.CastRegion(R, castTy); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 139 | |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 140 | if (R) |
Zhongxing Xu | 09270cc | 2009-10-14 06:55:01 +0000 | [diff] [blame] | 141 | return CastResult(state, loc::MemRegionVal(R)); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 142 | |
Zhongxing Xu | 09270cc | 2009-10-14 06:55:01 +0000 | [diff] [blame] | 143 | return CastResult(state, UnknownVal()); |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 144 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 145 | |
| 146 | // All other cases. |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 147 | DispatchCast: |
| 148 | return CastResult(state, |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 149 | isa<Loc>(val) ? EvalCastL(cast<Loc>(val), castTy) |
Ted Kremenek | 32c3fa4 | 2009-07-21 21:03:30 +0000 | [diff] [blame] | 150 | : EvalCastNL(cast<NonLoc>(val), castTy)); |
Owen Anderson | 4a28d5d | 2009-07-24 23:12:58 +0000 | [diff] [blame] | 151 | } |
Ted Kremenek | 5b9bd21 | 2009-09-11 22:07:28 +0000 | [diff] [blame] | 152 | |
| 153 | SValuator::DefinedOrUnknownCastResult |
| 154 | SValuator::EvalCast(DefinedOrUnknownSVal V, const GRState *ST, |
| 155 | QualType castTy, QualType originalType) { |
| 156 | SValuator::CastResult X = EvalCast((SVal) V, ST, castTy, originalType); |
| 157 | return DefinedOrUnknownCastResult(X.getState(), |
| 158 | cast<DefinedOrUnknownSVal>(X.getSVal())); |
| 159 | } |