Ted Kremenek | 25a484d | 2008-02-14 18:28:23 +0000 | [diff] [blame] | 1 | // GRSimpleVals.cpp - Transfer functions for tracking simple values -*- 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 | // |
Gabor Greif | 2224fcb | 2008-03-06 10:40:09 +0000 | [diff] [blame] | 10 | // This file defines GRSimpleVals, a sub-class of GRTransferFuncs that |
Ted Kremenek | 25a484d | 2008-02-14 18:28:23 +0000 | [diff] [blame] | 11 | // provides transfer functions for performing simple value tracking with |
| 12 | // limited support for symbolics. |
| 13 | // |
| 14 | //===----------------------------------------------------------------------===// |
| 15 | |
| 16 | #include "GRSimpleVals.h" |
Ted Kremenek | 7a68194 | 2008-03-27 17:17:22 +0000 | [diff] [blame] | 17 | #include "BasicObjCFoundationChecks.h" |
Ted Kremenek | 07d4620 | 2008-04-02 22:03:53 +0000 | [diff] [blame] | 18 | #include "clang/Basic/SourceManager.h" |
Ted Kremenek | dd0126b | 2008-03-31 18:26:32 +0000 | [diff] [blame] | 19 | #include "clang/Analysis/PathDiagnostic.h" |
Ted Kremenek | 7d88220 | 2008-04-03 04:42:52 +0000 | [diff] [blame] | 20 | #include "clang/Analysis/PathSensitive/ValueState.h" |
| 21 | #include "clang/Analysis/PathSensitive/BugReporter.h" |
Ted Kremenek | b1983ba | 2008-04-10 22:16:52 +0000 | [diff] [blame] | 22 | #include "clang/Analysis/LocalCheckers.h" |
Ted Kremenek | 7cefcac | 2008-04-30 20:17:27 +0000 | [diff] [blame] | 23 | #include "clang/Analysis/PathSensitive/GRExprEngine.h" |
Ted Kremenek | 7d88220 | 2008-04-03 04:42:52 +0000 | [diff] [blame] | 24 | #include "llvm/Support/Compiler.h" |
Ted Kremenek | 9cac66e | 2008-02-27 17:56:16 +0000 | [diff] [blame] | 25 | #include <sstream> |
Ted Kremenek | 25a484d | 2008-02-14 18:28:23 +0000 | [diff] [blame] | 26 | |
| 27 | using namespace clang; |
| 28 | |
Ted Kremenek | d1d4d75 | 2008-04-02 07:05:46 +0000 | [diff] [blame] | 29 | //===----------------------------------------------------------------------===// |
Ted Kremenek | b1983ba | 2008-04-10 22:16:52 +0000 | [diff] [blame] | 30 | // Transfer Function creation for External clients. |
Ted Kremenek | 139bf40 | 2008-04-02 05:15:22 +0000 | [diff] [blame] | 31 | //===----------------------------------------------------------------------===// |
Ted Kremenek | 7d88220 | 2008-04-03 04:42:52 +0000 | [diff] [blame] | 32 | |
Ted Kremenek | b1983ba | 2008-04-10 22:16:52 +0000 | [diff] [blame] | 33 | GRTransferFuncs* clang::MakeGRSimpleValsTF() { return new GRSimpleVals(); } |
Ted Kremenek | 3862eb1 | 2008-02-14 22:36:46 +0000 | [diff] [blame] | 34 | |
Ted Kremenek | 25a484d | 2008-02-14 18:28:23 +0000 | [diff] [blame] | 35 | //===----------------------------------------------------------------------===// |
| 36 | // Transfer function for Casts. |
| 37 | //===----------------------------------------------------------------------===// |
| 38 | |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 39 | RVal GRSimpleVals::EvalCast(GRExprEngine& Eng, NonLVal X, QualType T) { |
Ted Kremenek | bc965a6 | 2008-02-18 22:57:02 +0000 | [diff] [blame] | 40 | |
Ted Kremenek | 25a484d | 2008-02-14 18:28:23 +0000 | [diff] [blame] | 41 | if (!isa<nonlval::ConcreteInt>(X)) |
| 42 | return UnknownVal(); |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 43 | |
Ted Kremenek | 9ea2f77 | 2008-07-16 00:23:49 +0000 | [diff] [blame] | 44 | bool isLValType = LVal::IsLValType(T); |
| 45 | |
Ted Kremenek | d9eb592 | 2008-07-15 23:17:54 +0000 | [diff] [blame] | 46 | // Only handle casts from integers to integers. |
Ted Kremenek | 9ea2f77 | 2008-07-16 00:23:49 +0000 | [diff] [blame] | 47 | if (!isLValType && !T->isIntegerType()) |
Ted Kremenek | d9eb592 | 2008-07-15 23:17:54 +0000 | [diff] [blame] | 48 | return UnknownVal(); |
| 49 | |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 50 | BasicValueFactory& BasicVals = Eng.getBasicVals(); |
Ted Kremenek | 25a484d | 2008-02-14 18:28:23 +0000 | [diff] [blame] | 51 | |
| 52 | llvm::APSInt V = cast<nonlval::ConcreteInt>(X).getValue(); |
Ted Kremenek | 9e2c1ea | 2008-05-09 23:45:33 +0000 | [diff] [blame] | 53 | V.setIsUnsigned(T->isUnsignedIntegerType() || LVal::IsLValType(T)); |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 54 | V.extOrTrunc(Eng.getContext().getTypeSize(T)); |
Ted Kremenek | 25a484d | 2008-02-14 18:28:23 +0000 | [diff] [blame] | 55 | |
Ted Kremenek | 9ea2f77 | 2008-07-16 00:23:49 +0000 | [diff] [blame] | 56 | if (isLValType) |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 57 | return lval::ConcreteInt(BasicVals.getValue(V)); |
Ted Kremenek | 25a484d | 2008-02-14 18:28:23 +0000 | [diff] [blame] | 58 | else |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 59 | return nonlval::ConcreteInt(BasicVals.getValue(V)); |
Ted Kremenek | 25a484d | 2008-02-14 18:28:23 +0000 | [diff] [blame] | 60 | } |
| 61 | |
| 62 | // Casts. |
| 63 | |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 64 | RVal GRSimpleVals::EvalCast(GRExprEngine& Eng, LVal X, QualType T) { |
Ted Kremenek | bc965a6 | 2008-02-18 22:57:02 +0000 | [diff] [blame] | 65 | |
Ted Kremenek | 3194306 | 2008-04-30 21:10:19 +0000 | [diff] [blame] | 66 | // Casts from pointers -> pointers, just return the lval. |
| 67 | // |
| 68 | // Casts from pointers -> references, just return the lval. These |
| 69 | // can be introduced by the frontend for corner cases, e.g |
| 70 | // casting from va_list* to __builtin_va_list&. |
| 71 | // |
Ted Kremenek | 9e2c1ea | 2008-05-09 23:45:33 +0000 | [diff] [blame] | 72 | if (LVal::IsLValType(T) || T->isReferenceType()) |
Ted Kremenek | 25a484d | 2008-02-14 18:28:23 +0000 | [diff] [blame] | 73 | return X; |
| 74 | |
Ted Kremenek | 9cfda3f | 2008-02-21 18:43:30 +0000 | [diff] [blame] | 75 | assert (T->isIntegerType()); |
Ted Kremenek | 25a484d | 2008-02-14 18:28:23 +0000 | [diff] [blame] | 76 | |
| 77 | if (!isa<lval::ConcreteInt>(X)) |
| 78 | return UnknownVal(); |
| 79 | |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 80 | BasicValueFactory& BasicVals = Eng.getBasicVals(); |
| 81 | |
Ted Kremenek | 25a484d | 2008-02-14 18:28:23 +0000 | [diff] [blame] | 82 | llvm::APSInt V = cast<lval::ConcreteInt>(X).getValue(); |
Ted Kremenek | 9e2c1ea | 2008-05-09 23:45:33 +0000 | [diff] [blame] | 83 | V.setIsUnsigned(T->isUnsignedIntegerType() || LVal::IsLValType(T)); |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 84 | V.extOrTrunc(Eng.getContext().getTypeSize(T)); |
Ted Kremenek | 25a484d | 2008-02-14 18:28:23 +0000 | [diff] [blame] | 85 | |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 86 | return nonlval::ConcreteInt(BasicVals.getValue(V)); |
Ted Kremenek | c9922fd | 2008-02-14 18:40:24 +0000 | [diff] [blame] | 87 | } |
| 88 | |
| 89 | // Unary operators. |
| 90 | |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 91 | RVal GRSimpleVals::EvalMinus(GRExprEngine& Eng, UnaryOperator* U, NonLVal X){ |
Ted Kremenek | bc965a6 | 2008-02-18 22:57:02 +0000 | [diff] [blame] | 92 | |
Ted Kremenek | c9922fd | 2008-02-14 18:40:24 +0000 | [diff] [blame] | 93 | switch (X.getSubKind()) { |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 94 | |
Ted Kremenek | c9922fd | 2008-02-14 18:40:24 +0000 | [diff] [blame] | 95 | case nonlval::ConcreteIntKind: |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 96 | return cast<nonlval::ConcreteInt>(X).EvalMinus(Eng.getBasicVals(), U); |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 97 | |
Ted Kremenek | c9922fd | 2008-02-14 18:40:24 +0000 | [diff] [blame] | 98 | default: |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 99 | return UnknownVal(); |
Ted Kremenek | c9922fd | 2008-02-14 18:40:24 +0000 | [diff] [blame] | 100 | } |
| 101 | } |
| 102 | |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 103 | RVal GRSimpleVals::EvalComplement(GRExprEngine& Eng, NonLVal X) { |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 104 | |
Ted Kremenek | 0cd9635 | 2008-02-20 04:12:31 +0000 | [diff] [blame] | 105 | switch (X.getSubKind()) { |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 106 | |
Ted Kremenek | c9922fd | 2008-02-14 18:40:24 +0000 | [diff] [blame] | 107 | case nonlval::ConcreteIntKind: |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 108 | return cast<nonlval::ConcreteInt>(X).EvalComplement(Eng.getBasicVals()); |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 109 | |
Ted Kremenek | c9922fd | 2008-02-14 18:40:24 +0000 | [diff] [blame] | 110 | default: |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 111 | return UnknownVal(); |
Ted Kremenek | c9922fd | 2008-02-14 18:40:24 +0000 | [diff] [blame] | 112 | } |
| 113 | } |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 114 | |
| 115 | // Binary operators. |
| 116 | |
Ted Kremenek | 19c5407 | 2008-07-18 15:46:06 +0000 | [diff] [blame] | 117 | static unsigned char LNotOpMap[] = { |
| 118 | (unsigned char) BinaryOperator::GE, /* LT => GE */ |
| 119 | (unsigned char) BinaryOperator::LE, /* GT => LE */ |
| 120 | (unsigned char) BinaryOperator::GT, /* LE => GT */ |
| 121 | (unsigned char) BinaryOperator::LT, /* GE => LT */ |
| 122 | (unsigned char) BinaryOperator::NE, /* EQ => NE */ |
| 123 | (unsigned char) BinaryOperator::EQ /* NE => EQ */ |
| 124 | }; |
| 125 | |
Ted Kremenek | 589f881 | 2008-07-18 15:27:58 +0000 | [diff] [blame] | 126 | RVal GRSimpleVals::DetermEvalBinOpNN(ValueStateManager& StateMgr, |
| 127 | BinaryOperator::Opcode Op, |
| 128 | NonLVal L, NonLVal R) { |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 129 | |
Ted Kremenek | 9c4ce60 | 2008-07-18 05:53:58 +0000 | [diff] [blame] | 130 | BasicValueFactory& BasicVals = StateMgr.getBasicVals(); |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 131 | |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 132 | while (1) { |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 133 | |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 134 | switch (L.getSubKind()) { |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 135 | default: |
Ted Kremenek | de89ec0 | 2008-02-21 19:10:12 +0000 | [diff] [blame] | 136 | return UnknownVal(); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 137 | |
Ted Kremenek | 19c5407 | 2008-07-18 15:46:06 +0000 | [diff] [blame] | 138 | case nonlval::SymIntConstraintValKind: { |
Ted Kremenek | 99b4f43 | 2008-07-18 15:54:51 +0000 | [diff] [blame] | 139 | |
| 140 | // Logical not? |
| 141 | if (!(Op == BinaryOperator::EQ && R.isZeroConstant())) |
| 142 | return UnknownVal(); |
| 143 | |
Ted Kremenek | 19c5407 | 2008-07-18 15:46:06 +0000 | [diff] [blame] | 144 | const SymIntConstraint& C = |
| 145 | cast<nonlval::SymIntConstraintVal>(L).getConstraint(); |
| 146 | |
| 147 | BinaryOperator::Opcode Opc = C.getOpcode(); |
Ted Kremenek | 99b4f43 | 2008-07-18 15:54:51 +0000 | [diff] [blame] | 148 | |
Ted Kremenek | 19c5407 | 2008-07-18 15:46:06 +0000 | [diff] [blame] | 149 | if (Opc < BinaryOperator::LT || Opc > BinaryOperator::NE) |
| 150 | return UnknownVal(); |
| 151 | |
| 152 | // For comparison operators, translate the constraint by |
| 153 | // changing the opcode. |
| 154 | |
| 155 | int idx = (unsigned) Opc - (unsigned) BinaryOperator::LT; |
| 156 | |
| 157 | assert (idx >= 0 && |
| 158 | (unsigned) idx < sizeof(LNotOpMap)/sizeof(unsigned char)); |
| 159 | |
| 160 | Opc = (BinaryOperator::Opcode) LNotOpMap[idx]; |
| 161 | |
| 162 | const SymIntConstraint& CNew = |
| 163 | BasicVals.getConstraint(C.getSymbol(), Opc, C.getInt()); |
| 164 | |
| 165 | return nonlval::SymIntConstraintVal(CNew); |
| 166 | } |
| 167 | |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 168 | case nonlval::ConcreteIntKind: |
| 169 | |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 170 | if (isa<nonlval::ConcreteInt>(R)) { |
| 171 | const nonlval::ConcreteInt& L_CI = cast<nonlval::ConcreteInt>(L); |
| 172 | const nonlval::ConcreteInt& R_CI = cast<nonlval::ConcreteInt>(R); |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 173 | return L_CI.EvalBinOp(BasicVals, Op, R_CI); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 174 | } |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 175 | else { |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 176 | NonLVal tmp = R; |
| 177 | R = L; |
| 178 | L = tmp; |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 179 | continue; |
| 180 | } |
| 181 | |
| 182 | case nonlval::SymbolValKind: { |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 183 | |
| 184 | if (isa<nonlval::ConcreteInt>(R)) { |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 185 | const SymIntConstraint& C = |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 186 | BasicVals.getConstraint(cast<nonlval::SymbolVal>(L).getSymbol(), Op, |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 187 | cast<nonlval::ConcreteInt>(R).getValue()); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 188 | |
| 189 | return nonlval::SymIntConstraintVal(C); |
| 190 | } |
| 191 | else |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 192 | return UnknownVal(); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 193 | } |
| 194 | } |
| 195 | } |
| 196 | } |
| 197 | |
Ted Kremenek | 775e0d8 | 2008-02-15 00:52:26 +0000 | [diff] [blame] | 198 | |
Ted Kremenek | 521d972 | 2008-02-15 23:15:23 +0000 | [diff] [blame] | 199 | // Binary Operators (except assignments and comma). |
| 200 | |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 201 | RVal GRSimpleVals::EvalBinOp(GRExprEngine& Eng, BinaryOperator::Opcode Op, |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 202 | LVal L, LVal R) { |
Ted Kremenek | bc965a6 | 2008-02-18 22:57:02 +0000 | [diff] [blame] | 203 | |
Ted Kremenek | 521d972 | 2008-02-15 23:15:23 +0000 | [diff] [blame] | 204 | switch (Op) { |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 205 | |
Ted Kremenek | 521d972 | 2008-02-15 23:15:23 +0000 | [diff] [blame] | 206 | default: |
| 207 | return UnknownVal(); |
| 208 | |
| 209 | case BinaryOperator::EQ: |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 210 | return EvalEQ(Eng, L, R); |
Ted Kremenek | 521d972 | 2008-02-15 23:15:23 +0000 | [diff] [blame] | 211 | |
| 212 | case BinaryOperator::NE: |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 213 | return EvalNE(Eng, L, R); |
Ted Kremenek | 521d972 | 2008-02-15 23:15:23 +0000 | [diff] [blame] | 214 | } |
| 215 | } |
| 216 | |
Ted Kremenek | 775e0d8 | 2008-02-15 00:52:26 +0000 | [diff] [blame] | 217 | // Pointer arithmetic. |
| 218 | |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 219 | RVal GRSimpleVals::EvalBinOp(GRExprEngine& Eng, BinaryOperator::Opcode Op, |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 220 | LVal L, NonLVal R) { |
| 221 | return UnknownVal(); |
Ted Kremenek | 775e0d8 | 2008-02-15 00:52:26 +0000 | [diff] [blame] | 222 | } |
| 223 | |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 224 | // Equality operators for LVals. |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 225 | |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 226 | RVal GRSimpleVals::EvalEQ(GRExprEngine& Eng, LVal L, LVal R) { |
| 227 | |
| 228 | BasicValueFactory& BasicVals = Eng.getBasicVals(); |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 229 | |
| 230 | switch (L.getSubKind()) { |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 231 | |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 232 | default: |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 233 | assert(false && "EQ not implemented for this LVal."); |
| 234 | return UnknownVal(); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 235 | |
| 236 | case lval::ConcreteIntKind: |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 237 | |
| 238 | if (isa<lval::ConcreteInt>(R)) { |
| 239 | bool b = cast<lval::ConcreteInt>(L).getValue() == |
| 240 | cast<lval::ConcreteInt>(R).getValue(); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 241 | |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 242 | return NonLVal::MakeIntTruthVal(BasicVals, b); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 243 | } |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 244 | else if (isa<lval::SymbolVal>(R)) { |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 245 | |
| 246 | const SymIntConstraint& C = |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 247 | BasicVals.getConstraint(cast<lval::SymbolVal>(R).getSymbol(), |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 248 | BinaryOperator::EQ, |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 249 | cast<lval::ConcreteInt>(L).getValue()); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 250 | |
| 251 | return nonlval::SymIntConstraintVal(C); |
| 252 | } |
| 253 | |
| 254 | break; |
| 255 | |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 256 | case lval::SymbolValKind: { |
| 257 | |
| 258 | if (isa<lval::ConcreteInt>(R)) { |
| 259 | const SymIntConstraint& C = |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 260 | BasicVals.getConstraint(cast<lval::SymbolVal>(L).getSymbol(), |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 261 | BinaryOperator::EQ, |
| 262 | cast<lval::ConcreteInt>(R).getValue()); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 263 | |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 264 | return nonlval::SymIntConstraintVal(C); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 265 | } |
| 266 | |
Ted Kremenek | fe944c4 | 2008-02-22 18:41:59 +0000 | [diff] [blame] | 267 | // FIXME: Implement == for lval Symbols. This is mainly useful |
| 268 | // in iterator loops when traversing a buffer, e.g. while(z != zTerm). |
| 269 | // Since this is not useful for many checkers we'll punt on this for |
| 270 | // now. |
| 271 | |
| 272 | return UnknownVal(); |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 273 | } |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 274 | |
Ted Kremenek | de9c960 | 2008-04-30 16:07:22 +0000 | [diff] [blame] | 275 | // FIXME: Different offsets can map to the same memory cell. |
| 276 | case lval::ArrayOffsetKind: |
| 277 | case lval::FieldOffsetKind: |
| 278 | // Fall-through. |
| 279 | |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 280 | case lval::DeclValKind: |
Ted Kremenek | 3870619 | 2008-02-22 00:54:56 +0000 | [diff] [blame] | 281 | case lval::FuncValKind: |
| 282 | case lval::GotoLabelKind: |
Ted Kremenek | f06f514 | 2008-05-12 17:41:30 +0000 | [diff] [blame] | 283 | case lval::StringLiteralValKind: |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 284 | return NonLVal::MakeIntTruthVal(BasicVals, L == R); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 285 | } |
| 286 | |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 287 | return NonLVal::MakeIntTruthVal(BasicVals, false); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 288 | } |
| 289 | |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 290 | RVal GRSimpleVals::EvalNE(GRExprEngine& Eng, LVal L, LVal R) { |
Ted Kremenek | bc965a6 | 2008-02-18 22:57:02 +0000 | [diff] [blame] | 291 | |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 292 | BasicValueFactory& BasicVals = Eng.getBasicVals(); |
| 293 | |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 294 | switch (L.getSubKind()) { |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 295 | |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 296 | default: |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 297 | assert(false && "NE not implemented for this LVal."); |
| 298 | return UnknownVal(); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 299 | |
| 300 | case lval::ConcreteIntKind: |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 301 | |
| 302 | if (isa<lval::ConcreteInt>(R)) { |
| 303 | bool b = cast<lval::ConcreteInt>(L).getValue() != |
| 304 | cast<lval::ConcreteInt>(R).getValue(); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 305 | |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 306 | return NonLVal::MakeIntTruthVal(BasicVals, b); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 307 | } |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 308 | else if (isa<lval::SymbolVal>(R)) { |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 309 | const SymIntConstraint& C = |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 310 | BasicVals.getConstraint(cast<lval::SymbolVal>(R).getSymbol(), |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 311 | BinaryOperator::NE, |
| 312 | cast<lval::ConcreteInt>(L).getValue()); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 313 | |
| 314 | return nonlval::SymIntConstraintVal(C); |
| 315 | } |
| 316 | |
| 317 | break; |
| 318 | |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 319 | case lval::SymbolValKind: { |
| 320 | if (isa<lval::ConcreteInt>(R)) { |
| 321 | const SymIntConstraint& C = |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 322 | BasicVals.getConstraint(cast<lval::SymbolVal>(L).getSymbol(), |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 323 | BinaryOperator::NE, |
| 324 | cast<lval::ConcreteInt>(R).getValue()); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 325 | |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 326 | return nonlval::SymIntConstraintVal(C); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 327 | } |
| 328 | |
Ted Kremenek | fe944c4 | 2008-02-22 18:41:59 +0000 | [diff] [blame] | 329 | // FIXME: Implement != for lval Symbols. This is mainly useful |
| 330 | // in iterator loops when traversing a buffer, e.g. while(z != zTerm). |
| 331 | // Since this is not useful for many checkers we'll punt on this for |
| 332 | // now. |
| 333 | |
| 334 | return UnknownVal(); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 335 | |
| 336 | break; |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 337 | } |
| 338 | |
Ted Kremenek | de9c960 | 2008-04-30 16:07:22 +0000 | [diff] [blame] | 339 | // FIXME: Different offsets can map to the same memory cell. |
| 340 | case lval::ArrayOffsetKind: |
| 341 | case lval::FieldOffsetKind: |
| 342 | // Fall-through. |
| 343 | |
Ted Kremenek | 07baa25 | 2008-02-21 18:02:17 +0000 | [diff] [blame] | 344 | case lval::DeclValKind: |
Ted Kremenek | 3870619 | 2008-02-22 00:54:56 +0000 | [diff] [blame] | 345 | case lval::FuncValKind: |
| 346 | case lval::GotoLabelKind: |
Ted Kremenek | f06f514 | 2008-05-12 17:41:30 +0000 | [diff] [blame] | 347 | case lval::StringLiteralValKind: |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 348 | return NonLVal::MakeIntTruthVal(BasicVals, L != R); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 349 | } |
| 350 | |
Ted Kremenek | 8ad1987 | 2008-03-07 20:13:31 +0000 | [diff] [blame] | 351 | return NonLVal::MakeIntTruthVal(BasicVals, true); |
Ted Kremenek | b193413 | 2008-02-14 19:37:24 +0000 | [diff] [blame] | 352 | } |
Ted Kremenek | 348d785 | 2008-02-26 23:04:29 +0000 | [diff] [blame] | 353 | |
| 354 | //===----------------------------------------------------------------------===// |
Ted Kremenek | ca5f620 | 2008-04-15 23:06:53 +0000 | [diff] [blame] | 355 | // Transfer function for function calls. |
Ted Kremenek | 348d785 | 2008-02-26 23:04:29 +0000 | [diff] [blame] | 356 | //===----------------------------------------------------------------------===// |
| 357 | |
Ted Kremenek | 3eea8dd | 2008-03-05 00:33:14 +0000 | [diff] [blame] | 358 | void GRSimpleVals::EvalCall(ExplodedNodeSet<ValueState>& Dst, |
Ted Kremenek | ce3ed1e | 2008-03-12 01:21:45 +0000 | [diff] [blame] | 359 | GRExprEngine& Eng, |
Ted Kremenek | 3eea8dd | 2008-03-05 00:33:14 +0000 | [diff] [blame] | 360 | GRStmtNodeBuilder<ValueState>& Builder, |
Ted Kremenek | 0a6a80b | 2008-04-23 20:12:28 +0000 | [diff] [blame] | 361 | CallExpr* CE, RVal L, |
Ted Kremenek | 3eea8dd | 2008-03-05 00:33:14 +0000 | [diff] [blame] | 362 | ExplodedNode<ValueState>* Pred) { |
| 363 | |
Ted Kremenek | 1a53194 | 2008-03-12 21:04:07 +0000 | [diff] [blame] | 364 | ValueStateManager& StateMgr = Eng.getStateManager(); |
Ted Kremenek | f22f868 | 2008-07-10 22:03:41 +0000 | [diff] [blame] | 365 | const ValueState* St = Builder.GetState(Pred); |
Ted Kremenek | 348d785 | 2008-02-26 23:04:29 +0000 | [diff] [blame] | 366 | |
| 367 | // Invalidate all arguments passed in by reference (LVals). |
| 368 | |
| 369 | for (CallExpr::arg_iterator I = CE->arg_begin(), E = CE->arg_end(); |
| 370 | I != E; ++I) { |
| 371 | |
Ted Kremenek | 1a53194 | 2008-03-12 21:04:07 +0000 | [diff] [blame] | 372 | RVal V = StateMgr.GetRVal(St, *I); |
Ted Kremenek | 348d785 | 2008-02-26 23:04:29 +0000 | [diff] [blame] | 373 | |
| 374 | if (isa<LVal>(V)) |
Ted Kremenek | 1a53194 | 2008-03-12 21:04:07 +0000 | [diff] [blame] | 375 | St = StateMgr.SetRVal(St, cast<LVal>(V), UnknownVal()); |
Ted Kremenek | be62129 | 2008-04-22 21:39:21 +0000 | [diff] [blame] | 376 | else if (isa<nonlval::LValAsInteger>(V)) |
| 377 | St = StateMgr.SetRVal(St, cast<nonlval::LValAsInteger>(V).getLVal(), |
| 378 | UnknownVal()); |
| 379 | |
Ted Kremenek | 348d785 | 2008-02-26 23:04:29 +0000 | [diff] [blame] | 380 | } |
Ted Kremenek | 1a53194 | 2008-03-12 21:04:07 +0000 | [diff] [blame] | 381 | |
| 382 | // Make up a symbol for the return value of this function. |
| 383 | |
| 384 | if (CE->getType() != Eng.getContext().VoidTy) { |
| 385 | unsigned Count = Builder.getCurrentBlockCount(); |
Ted Kremenek | d467651 | 2008-03-12 21:45:47 +0000 | [diff] [blame] | 386 | SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(CE, Count); |
Ted Kremenek | 1a53194 | 2008-03-12 21:04:07 +0000 | [diff] [blame] | 387 | |
Ted Kremenek | 9e2c1ea | 2008-05-09 23:45:33 +0000 | [diff] [blame] | 388 | RVal X = LVal::IsLValType(CE->getType()) |
Ted Kremenek | 1a53194 | 2008-03-12 21:04:07 +0000 | [diff] [blame] | 389 | ? cast<RVal>(lval::SymbolVal(Sym)) |
| 390 | : cast<RVal>(nonlval::SymbolVal(Sym)); |
| 391 | |
| 392 | St = StateMgr.SetRVal(St, CE, X, Eng.getCFG().isBlkExpr(CE), false); |
| 393 | } |
Ted Kremenek | 3eea8dd | 2008-03-05 00:33:14 +0000 | [diff] [blame] | 394 | |
Ted Kremenek | f10f288 | 2008-03-21 21:30:14 +0000 | [diff] [blame] | 395 | Builder.MakeNode(Dst, CE, Pred, St); |
Ted Kremenek | 348d785 | 2008-02-26 23:04:29 +0000 | [diff] [blame] | 396 | } |
Ted Kremenek | ca5f620 | 2008-04-15 23:06:53 +0000 | [diff] [blame] | 397 | |
| 398 | //===----------------------------------------------------------------------===// |
| 399 | // Transfer function for Objective-C message expressions. |
| 400 | //===----------------------------------------------------------------------===// |
| 401 | |
| 402 | void GRSimpleVals::EvalObjCMessageExpr(ExplodedNodeSet<ValueState>& Dst, |
| 403 | GRExprEngine& Eng, |
| 404 | GRStmtNodeBuilder<ValueState>& Builder, |
| 405 | ObjCMessageExpr* ME, |
| 406 | ExplodedNode<ValueState>* Pred) { |
| 407 | |
| 408 | |
| 409 | // The basic transfer function logic for message expressions does nothing. |
| 410 | // We just invalidate all arguments passed in by references. |
| 411 | |
| 412 | ValueStateManager& StateMgr = Eng.getStateManager(); |
Ted Kremenek | f22f868 | 2008-07-10 22:03:41 +0000 | [diff] [blame] | 413 | const ValueState* St = Builder.GetState(Pred); |
Ted Kremenek | ca5f620 | 2008-04-15 23:06:53 +0000 | [diff] [blame] | 414 | |
| 415 | for (ObjCMessageExpr::arg_iterator I = ME->arg_begin(), E = ME->arg_end(); |
| 416 | I != E; ++I) { |
| 417 | |
| 418 | RVal V = StateMgr.GetRVal(St, *I); |
| 419 | |
| 420 | if (isa<LVal>(V)) |
| 421 | St = StateMgr.SetRVal(St, cast<LVal>(V), UnknownVal()); |
| 422 | } |
| 423 | |
| 424 | Builder.MakeNode(Dst, ME, Pred, St); |
| 425 | } |