blob: 662104ec701885557910a5289cdca8e72e96b06d [file] [log] [blame]
Chris Lattnerb542afe2008-07-11 19:10:17 +00001//===--- ExprConstant.cpp - Expression Constant Evaluator -----------------===//
Anders Carlssonc44eec62008-07-03 04:20:39 +00002//
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 implements the Expr constant evaluator.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/APValue.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/Expr.h"
Seo Sanghyeon0fe52e12008-07-08 07:23:12 +000017#include "clang/AST/StmtVisitor.h"
Anders Carlsson06a36752008-07-08 05:49:43 +000018#include "clang/Basic/TargetInfo.h"
Anders Carlssonc754aa62008-07-08 05:13:58 +000019#include "llvm/Support/Compiler.h"
Anders Carlssonc44eec62008-07-03 04:20:39 +000020using namespace clang;
Chris Lattnerf5eeb052008-07-11 18:11:29 +000021using llvm::APSInt;
Anders Carlssonc44eec62008-07-03 04:20:39 +000022
Anders Carlssonc754aa62008-07-08 05:13:58 +000023#define USE_NEW_EVALUATOR 0
Anders Carlssonc44eec62008-07-03 04:20:39 +000024
Chris Lattnerf5eeb052008-07-11 18:11:29 +000025static bool CalcFakeICEVal(const Expr *Expr,
26 llvm::APSInt &Result,
27 ASTContext &Context) {
Anders Carlssonc44eec62008-07-03 04:20:39 +000028 // Calculate the value of an expression that has a calculatable
29 // value, but isn't an ICE. Currently, this only supports
30 // a very narrow set of extensions, but it can be expanded if needed.
31 if (const ParenExpr *PE = dyn_cast<ParenExpr>(Expr))
32 return CalcFakeICEVal(PE->getSubExpr(), Result, Context);
33
34 if (const CastExpr *CE = dyn_cast<CastExpr>(Expr)) {
35 QualType CETy = CE->getType();
36 if ((CETy->isIntegralType() && !CETy->isBooleanType()) ||
37 CETy->isPointerType()) {
38 if (CalcFakeICEVal(CE->getSubExpr(), Result, Context)) {
39 Result.extOrTrunc(Context.getTypeSize(CETy));
40 // FIXME: This assumes pointers are signed.
41 Result.setIsSigned(CETy->isSignedIntegerType() ||
42 CETy->isPointerType());
43 return true;
44 }
45 }
46 }
47
48 if (Expr->getType()->isIntegralType())
49 return Expr->isIntegerConstantExpr(Result, Context);
50
51 return false;
52}
53
Chris Lattnerf5eeb052008-07-11 18:11:29 +000054static bool EvaluatePointer(const Expr *E, APValue &Result, ASTContext &Ctx);
55static bool EvaluateInteger(const Expr *E, APSInt &Result, ASTContext &Ctx);
56
57
58//===----------------------------------------------------------------------===//
59// Pointer Evaluation
60//===----------------------------------------------------------------------===//
61
Anders Carlssonc754aa62008-07-08 05:13:58 +000062namespace {
Anders Carlsson2bad1682008-07-08 14:30:00 +000063class VISIBILITY_HIDDEN PointerExprEvaluator
64 : public StmtVisitor<PointerExprEvaluator, APValue> {
65 ASTContext &Ctx;
Anders Carlsson2bad1682008-07-08 14:30:00 +000066public:
Anders Carlsson2bad1682008-07-08 14:30:00 +000067
Chris Lattnerf5eeb052008-07-11 18:11:29 +000068 PointerExprEvaluator(ASTContext &ctx) : Ctx(ctx) {}
69
Anders Carlsson2bad1682008-07-08 14:30:00 +000070 APValue VisitStmt(Stmt *S) {
71 // FIXME: Remove this when we support more expressions.
Anders Carlsson650c92f2008-07-08 15:34:11 +000072 printf("Unhandled pointer statement\n");
Anders Carlsson2bad1682008-07-08 14:30:00 +000073 S->dump();
74 return APValue();
75 }
76
77 APValue VisitParenExpr(ParenExpr *E) { return Visit(E->getSubExpr()); }
78
Anders Carlsson650c92f2008-07-08 15:34:11 +000079 APValue VisitBinaryOperator(const BinaryOperator *E);
80 APValue VisitCastExpr(const CastExpr* E);
Anders Carlsson650c92f2008-07-08 15:34:11 +000081};
Chris Lattnerf5eeb052008-07-11 18:11:29 +000082} // end anonymous namespace
Anders Carlsson650c92f2008-07-08 15:34:11 +000083
Chris Lattnerf5eeb052008-07-11 18:11:29 +000084static bool EvaluatePointer(const Expr* E, APValue& Result, ASTContext &Ctx) {
85 if (!E->getType()->isPointerType())
86 return false;
87 Result = PointerExprEvaluator(Ctx).Visit(const_cast<Expr*>(E));
88 return Result.isLValue();
89}
90
91APValue PointerExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
92 if (E->getOpcode() != BinaryOperator::Add &&
93 E->getOpcode() != BinaryOperator::Sub)
94 return APValue();
95
96 const Expr *PExp = E->getLHS();
97 const Expr *IExp = E->getRHS();
98 if (IExp->getType()->isPointerType())
99 std::swap(PExp, IExp);
100
101 APValue ResultLValue;
102 if (!EvaluatePointer(PExp, ResultLValue, Ctx))
103 return APValue();
104
105 llvm::APSInt AdditionalOffset(32);
106 if (!EvaluateInteger(IExp, AdditionalOffset, Ctx))
107 return APValue();
108
109 uint64_t Offset = ResultLValue.getLValueOffset();
110 if (E->getOpcode() == BinaryOperator::Add)
111 Offset += AdditionalOffset.getZExtValue();
112 else
113 Offset -= AdditionalOffset.getZExtValue();
114
115 return APValue(ResultLValue.getLValueBase(), Offset);
116}
117
118
Chris Lattnerb542afe2008-07-11 19:10:17 +0000119APValue PointerExprEvaluator::VisitCastExpr(const CastExpr* E) {
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000120 const Expr* SubExpr = E->getSubExpr();
121
122 // Check for pointer->pointer cast
123 if (SubExpr->getType()->isPointerType()) {
124 APValue Result;
125 if (EvaluatePointer(SubExpr, Result, Ctx))
126 return Result;
127 return APValue();
128 }
129
130 if (SubExpr->getType()->isArithmeticType()) {
131 llvm::APSInt Result(32);
132 if (EvaluateInteger(SubExpr, Result, Ctx)) {
133 Result.extOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(E->getType())));
134 return APValue(0, Result.getZExtValue());
135 }
136 }
137
138 assert(0 && "Unhandled cast");
139 return APValue();
140}
141
142
143//===----------------------------------------------------------------------===//
144// Integer Evaluation
145//===----------------------------------------------------------------------===//
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000146
147namespace {
Anders Carlssonc754aa62008-07-08 05:13:58 +0000148class VISIBILITY_HIDDEN IntExprEvaluator
Chris Lattnerb542afe2008-07-11 19:10:17 +0000149 : public StmtVisitor<IntExprEvaluator, bool> {
Anders Carlssonc754aa62008-07-08 05:13:58 +0000150 ASTContext &Ctx;
Chris Lattnerb542afe2008-07-11 19:10:17 +0000151 APSInt &Result;
Anders Carlssonc754aa62008-07-08 05:13:58 +0000152public:
Chris Lattnerb542afe2008-07-11 19:10:17 +0000153 IntExprEvaluator(ASTContext &ctx, APSInt &result) : Ctx(ctx), Result(result){}
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000154
Chris Lattner7a767782008-07-11 19:24:49 +0000155 unsigned getIntTypeSizeInBits(QualType T) const {
156 return (unsigned)Ctx.getTypeSize(T);
157 }
158
Anders Carlssonc754aa62008-07-08 05:13:58 +0000159 //===--------------------------------------------------------------------===//
160 // Visitor Methods
161 //===--------------------------------------------------------------------===//
Chris Lattner7a767782008-07-11 19:24:49 +0000162
Chris Lattnerb542afe2008-07-11 19:10:17 +0000163 bool VisitStmt(Stmt *S) {
Anders Carlssonc754aa62008-07-08 05:13:58 +0000164 // FIXME: Remove this when we support more expressions.
Anders Carlsson650c92f2008-07-08 15:34:11 +0000165 printf("unhandled int expression");
Anders Carlssonc754aa62008-07-08 05:13:58 +0000166 S->dump();
Chris Lattnerb542afe2008-07-11 19:10:17 +0000167 return false;
Anders Carlssonc754aa62008-07-08 05:13:58 +0000168 }
169
Chris Lattnerb542afe2008-07-11 19:10:17 +0000170 bool VisitParenExpr(ParenExpr *E) { return Visit(E->getSubExpr()); }
Anders Carlssonc754aa62008-07-08 05:13:58 +0000171
Chris Lattnerb542afe2008-07-11 19:10:17 +0000172 bool VisitBinaryOperator(const BinaryOperator *E);
173 bool VisitUnaryOperator(const UnaryOperator *E);
Anders Carlsson06a36752008-07-08 05:49:43 +0000174
Chris Lattnerb542afe2008-07-11 19:10:17 +0000175 bool HandleCast(const Expr* SubExpr, QualType DestType);
176 bool VisitCastExpr(const CastExpr* E) {
Anders Carlsson650c92f2008-07-08 15:34:11 +0000177 return HandleCast(E->getSubExpr(), E->getType());
178 }
Chris Lattnerb542afe2008-07-11 19:10:17 +0000179 bool VisitImplicitCastExpr(const ImplicitCastExpr* E) {
Anders Carlsson650c92f2008-07-08 15:34:11 +0000180 return HandleCast(E->getSubExpr(), E->getType());
181 }
Chris Lattnerb542afe2008-07-11 19:10:17 +0000182 bool VisitSizeOfAlignOfTypeExpr(const SizeOfAlignOfTypeExpr *E);
Anders Carlsson650c92f2008-07-08 15:34:11 +0000183
Chris Lattnerb542afe2008-07-11 19:10:17 +0000184 bool VisitIntegerLiteral(const IntegerLiteral *E) {
Anders Carlsson650c92f2008-07-08 15:34:11 +0000185 Result = E->getValue();
Chris Lattnerb542afe2008-07-11 19:10:17 +0000186 return true;
Anders Carlsson650c92f2008-07-08 15:34:11 +0000187 }
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000188};
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000189} // end anonymous namespace
Anders Carlsson650c92f2008-07-08 15:34:11 +0000190
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000191static bool EvaluateInteger(const Expr* E, APSInt &Result, ASTContext &Ctx) {
Chris Lattnerb542afe2008-07-11 19:10:17 +0000192 return IntExprEvaluator(Ctx, Result).Visit(const_cast<Expr*>(E));
Anders Carlsson650c92f2008-07-08 15:34:11 +0000193}
Anders Carlsson650c92f2008-07-08 15:34:11 +0000194
Anders Carlsson650c92f2008-07-08 15:34:11 +0000195
Chris Lattnerb542afe2008-07-11 19:10:17 +0000196bool IntExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000197 // The LHS of a constant expr is always evaluated and needed.
Chris Lattnerb542afe2008-07-11 19:10:17 +0000198 if (!Visit(E->getLHS()))
199 return false;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000200
201 llvm::APSInt RHS(32);
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000202 if (!EvaluateInteger(E->getRHS(), RHS, Ctx))
Chris Lattnerb542afe2008-07-11 19:10:17 +0000203 return false;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000204
205 switch (E->getOpcode()) {
206 default:
Chris Lattnerb542afe2008-07-11 19:10:17 +0000207 return false;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000208 case BinaryOperator::Mul:
209 Result *= RHS;
210 break;
211 case BinaryOperator::Div:
212 if (RHS == 0)
Chris Lattnerb542afe2008-07-11 19:10:17 +0000213 return false;
214 Result /= RHS;
215 break;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000216 case BinaryOperator::Rem:
217 if (RHS == 0)
Chris Lattnerb542afe2008-07-11 19:10:17 +0000218 return false;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000219 Result %= RHS;
220 break;
221 case BinaryOperator::Add: Result += RHS; break;
222 case BinaryOperator::Sub: Result -= RHS; break;
223 case BinaryOperator::Shl:
Chris Lattnerb542afe2008-07-11 19:10:17 +0000224 Result <<= (unsigned)RHS.getLimitedValue(Result.getBitWidth()-1);
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000225 break;
226 case BinaryOperator::Shr:
Chris Lattnerb542afe2008-07-11 19:10:17 +0000227 Result >>= (unsigned)RHS.getLimitedValue(Result.getBitWidth()-1);
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000228 break;
Chris Lattnerb542afe2008-07-11 19:10:17 +0000229
230 // FIXME: Need to set the result width?
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000231 case BinaryOperator::LT: Result = Result < RHS; break;
232 case BinaryOperator::GT: Result = Result > RHS; break;
233 case BinaryOperator::LE: Result = Result <= RHS; break;
234 case BinaryOperator::GE: Result = Result >= RHS; break;
235 case BinaryOperator::EQ: Result = Result == RHS; break;
236 case BinaryOperator::NE: Result = Result != RHS; break;
237 case BinaryOperator::And: Result &= RHS; break;
238 case BinaryOperator::Xor: Result ^= RHS; break;
239 case BinaryOperator::Or: Result |= RHS; break;
Anders Carlsson06a36752008-07-08 05:49:43 +0000240
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000241 case BinaryOperator::Comma:
242 // C99 6.6p3: "shall not contain assignment, ..., or comma operators,
243 // *except* when they are contained within a subexpression that is not
244 // evaluated". Note that Assignment can never happen due to constraints
245 // on the LHS subexpr, so we don't need to check it here.
246 // FIXME: Need to come up with an efficient way to deal with the C99
247 // rules on evaluation while still evaluating this. Maybe a
248 // "evaluated comma" out parameter?
Chris Lattnerb542afe2008-07-11 19:10:17 +0000249 return false;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000250 }
251
252 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
Chris Lattnerb542afe2008-07-11 19:10:17 +0000253 return true;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000254}
255
Chris Lattnerb542afe2008-07-11 19:10:17 +0000256bool IntExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000257 if (E->isOffsetOfOp())
258 Result = E->evaluateOffsetOf(Ctx);
259 else if (E->isSizeOfAlignOfOp()) {
260 // Return the result in the right width.
Chris Lattner7a767782008-07-11 19:24:49 +0000261 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000262
263 // sizeof(void) and __alignof__(void) = 1 as a gcc extension.
264 if (E->getSubExpr()->getType()->isVoidType())
265 Result = 1;
266
267 // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
268 if (!E->getSubExpr()->getType()->isConstantSizeType()) {
269 // FIXME: Should we attempt to evaluate this?
Chris Lattnerb542afe2008-07-11 19:10:17 +0000270 return false;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000271 }
272
273 // Get information about the size or align.
274 if (E->getSubExpr()->getType()->isFunctionType()) {
275 // GCC extension: sizeof(function) = 1.
276 // FIXME: AlignOf shouldn't be unconditionally 4!
277 Result = E->getOpcode() == UnaryOperator::AlignOf ? 4 : 1;
278 } else {
279 unsigned CharSize = Ctx.Target.getCharWidth();
280 if (E->getOpcode() == UnaryOperator::AlignOf)
281 Result = Ctx.getTypeAlign(E->getSubExpr()->getType()) / CharSize;
282 else
Chris Lattner7a767782008-07-11 19:24:49 +0000283 Result = getIntTypeSizeInBits(E->getSubExpr()->getType()) / CharSize;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000284 }
285 } else {
286 // Get the operand value. If this is sizeof/alignof, do not evalute the
287 // operand. This affects C99 6.6p3.
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000288 if (!EvaluateInteger(E->getSubExpr(), Result, Ctx))
Chris Lattnerb542afe2008-07-11 19:10:17 +0000289 return false;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000290
Anders Carlsson06a36752008-07-08 05:49:43 +0000291 switch (E->getOpcode()) {
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000292 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
293 // See C99 6.6p3.
Anders Carlsson06a36752008-07-08 05:49:43 +0000294 default:
Chris Lattnerb542afe2008-07-11 19:10:17 +0000295 return false;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000296 case UnaryOperator::Extension:
297 assert(0 && "Handle UnaryOperator::Extension");
Chris Lattnerb542afe2008-07-11 19:10:17 +0000298 return false;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000299 case UnaryOperator::LNot: {
300 bool Val = Result == 0;
Chris Lattner7a767782008-07-11 19:24:49 +0000301 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000302 Result = Val;
Anders Carlsson06a36752008-07-08 05:49:43 +0000303 break;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000304 }
305 case UnaryOperator::Plus:
Anders Carlsson06a36752008-07-08 05:49:43 +0000306 break;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000307 case UnaryOperator::Minus:
308 Result = -Result;
Anders Carlsson06a36752008-07-08 05:49:43 +0000309 break;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000310 case UnaryOperator::Not:
311 Result = ~Result;
Anders Carlsson06a36752008-07-08 05:49:43 +0000312 break;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000313 }
314 }
315
316 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
Chris Lattnerb542afe2008-07-11 19:10:17 +0000317 return true;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000318}
319
Chris Lattnerb542afe2008-07-11 19:10:17 +0000320bool IntExprEvaluator::HandleCast(const Expr* SubExpr, QualType DestType) {
Chris Lattner7a767782008-07-11 19:24:49 +0000321 unsigned DestWidth = getIntTypeSizeInBits(DestType);
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000322
323 // Handle simple integer->integer casts.
324 if (SubExpr->getType()->isIntegerType()) {
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000325 if (!EvaluateInteger(SubExpr, Result, Ctx))
Chris Lattnerb542afe2008-07-11 19:10:17 +0000326 return false;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000327
328 // Figure out if this is a truncate, extend or noop cast.
329 // If the input is signed, do a sign extend, noop, or truncate.
330 if (DestType->isBooleanType()) {
331 // Conversion to bool compares against zero.
332 Result = Result != 0;
333 Result.zextOrTrunc(DestWidth);
Chris Lattner7a767782008-07-11 19:24:49 +0000334 } else
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000335 Result.extOrTrunc(DestWidth);
336 } else if (SubExpr->getType()->isPointerType()) {
337 APValue LV;
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000338 if (!EvaluatePointer(SubExpr, LV, Ctx))
Chris Lattnerb542afe2008-07-11 19:10:17 +0000339 return false;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000340 if (LV.getLValueBase())
Chris Lattnerb542afe2008-07-11 19:10:17 +0000341 return false;
Anders Carlsson06a36752008-07-08 05:49:43 +0000342
Anders Carlsson559e56b2008-07-08 16:49:00 +0000343 Result.extOrTrunc(DestWidth);
344 Result = LV.getLValueOffset();
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000345 } else {
346 assert(0 && "Unhandled cast!");
Anders Carlsson2bad1682008-07-08 14:30:00 +0000347 }
348
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000349 Result.setIsUnsigned(DestType->isUnsignedIntegerType());
Chris Lattnerb542afe2008-07-11 19:10:17 +0000350 return true;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000351}
Anders Carlsson2bad1682008-07-08 14:30:00 +0000352
Chris Lattnerb542afe2008-07-11 19:10:17 +0000353bool IntExprEvaluator::
354VisitSizeOfAlignOfTypeExpr(const SizeOfAlignOfTypeExpr *E) {
Anders Carlsson650c92f2008-07-08 15:34:11 +0000355 // Return the result in the right width.
Chris Lattner7a767782008-07-11 19:24:49 +0000356 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
Anders Carlsson650c92f2008-07-08 15:34:11 +0000357
358 // sizeof(void) and __alignof__(void) = 1 as a gcc extension.
359 if (E->getArgumentType()->isVoidType()) {
360 Result = 1;
361 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
Chris Lattnerb542afe2008-07-11 19:10:17 +0000362 return true;
Anders Carlsson650c92f2008-07-08 15:34:11 +0000363 }
364
365 // alignof always evaluates to a constant, sizeof does if arg is not VLA.
366 if (E->isSizeOf() && !E->getArgumentType()->isConstantSizeType())
Chris Lattnerb542afe2008-07-11 19:10:17 +0000367 return false;
Anders Carlsson650c92f2008-07-08 15:34:11 +0000368
369 // Get information about the size or align.
370 if (E->getArgumentType()->isFunctionType()) {
371 // GCC extension: sizeof(function) = 1.
372 Result = E->isSizeOf() ? 1 : 4;
373 } else {
374 unsigned CharSize = Ctx.Target.getCharWidth();
375 if (E->isSizeOf())
Chris Lattner7a767782008-07-11 19:24:49 +0000376 Result = getIntTypeSizeInBits(E->getArgumentType()) / CharSize;
Anders Carlsson650c92f2008-07-08 15:34:11 +0000377 else
378 Result = Ctx.getTypeAlign(E->getArgumentType()) / CharSize;
379 }
380
381 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
Chris Lattnerb542afe2008-07-11 19:10:17 +0000382 return true;
Anders Carlsson650c92f2008-07-08 15:34:11 +0000383}
384
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000385//===----------------------------------------------------------------------===//
386// Top level TryEvaluate.
387//===----------------------------------------------------------------------===//
388
Chris Lattnerb542afe2008-07-11 19:10:17 +0000389bool Expr::tryEvaluate(APValue &Result, ASTContext &Ctx) const {
Chris Lattnercf0f51d2008-07-11 19:19:21 +0000390 llvm::APSInt sInt(32);
Anders Carlssonc754aa62008-07-08 05:13:58 +0000391#if USE_NEW_EVALUATOR
Anders Carlsson06a36752008-07-08 05:49:43 +0000392 if (getType()->isIntegerType()) {
Chris Lattnerb542afe2008-07-11 19:10:17 +0000393 if (EvaluateInteger(this, sInt, Ctx)) {
Anders Carlsson06a36752008-07-08 05:49:43 +0000394 Result = APValue(sInt);
395 return true;
396 }
397 } else
Anders Carlssonc754aa62008-07-08 05:13:58 +0000398 return false;
399
400#else
Anders Carlssonc44eec62008-07-03 04:20:39 +0000401 if (CalcFakeICEVal(this, sInt, Ctx)) {
402 Result = APValue(sInt);
403 return true;
404 }
Anders Carlssonc754aa62008-07-08 05:13:58 +0000405#endif
Anders Carlssonc44eec62008-07-03 04:20:39 +0000406
407 return false;
408}