blob: d26ba8b579a9aa2f94e7842da131e949a0a9e428 [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"
Eli Friedman4efaa272008-11-12 09:44:48 +000016#include "clang/AST/RecordLayout.h"
Seo Sanghyeon0fe52e12008-07-08 07:23:12 +000017#include "clang/AST/StmtVisitor.h"
Chris Lattner54176fd2008-07-12 00:14:42 +000018#include "clang/Basic/Diagnostic.h"
Anders Carlsson06a36752008-07-08 05:49:43 +000019#include "clang/Basic/TargetInfo.h"
Anders Carlssonc754aa62008-07-08 05:13:58 +000020#include "llvm/Support/Compiler.h"
Anders Carlssonc44eec62008-07-03 04:20:39 +000021using namespace clang;
Chris Lattnerf5eeb052008-07-11 18:11:29 +000022using llvm::APSInt;
Eli Friedmand8bfe7f2008-08-22 00:06:13 +000023using llvm::APFloat;
Anders Carlssonc44eec62008-07-03 04:20:39 +000024
Chris Lattner87eae5e2008-07-11 22:52:41 +000025/// EvalInfo - This is a private struct used by the evaluator to capture
26/// information about a subexpression as it is folded. It retains information
27/// about the AST context, but also maintains information about the folded
28/// expression.
29///
30/// If an expression could be evaluated, it is still possible it is not a C
31/// "integer constant expression" or constant expression. If not, this struct
32/// captures information about how and why not.
33///
34/// One bit of information passed *into* the request for constant folding
35/// indicates whether the subexpression is "evaluated" or not according to C
36/// rules. For example, the RHS of (0 && foo()) is not evaluated. We can
37/// evaluate the expression regardless of what the RHS is, but C only allows
38/// certain things in certain situations.
39struct EvalInfo {
40 ASTContext &Ctx;
41
Anders Carlsson54da0492008-11-30 16:38:33 +000042 /// EvalResult - Contains information about the evaluation.
43 Expr::EvalResult &EvalResult;
44
Chris Lattner87eae5e2008-07-11 22:52:41 +000045 /// isEvaluated - True if the subexpression is required to be evaluated, false
46 /// if it is short-circuited (according to C rules).
47 bool isEvaluated;
Chris Lattner87eae5e2008-07-11 22:52:41 +000048
Anders Carlsson54da0492008-11-30 16:38:33 +000049 EvalInfo(ASTContext &ctx, Expr::EvalResult& evalresult) : Ctx(ctx),
50 EvalResult(evalresult), isEvaluated(true) {}
Chris Lattner87eae5e2008-07-11 22:52:41 +000051};
52
53
Eli Friedman4efaa272008-11-12 09:44:48 +000054static bool EvaluateLValue(const Expr *E, APValue &Result, EvalInfo &Info);
Chris Lattner87eae5e2008-07-11 22:52:41 +000055static bool EvaluatePointer(const Expr *E, APValue &Result, EvalInfo &Info);
56static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info);
Eli Friedmand8bfe7f2008-08-22 00:06:13 +000057static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info);
Anders Carlsson9ad16ae2008-11-16 20:27:53 +000058static bool EvaluateComplexFloat(const Expr *E, APValue &Result,
59 EvalInfo &Info);
Chris Lattnerf5eeb052008-07-11 18:11:29 +000060
61//===----------------------------------------------------------------------===//
Eli Friedman4efaa272008-11-12 09:44:48 +000062// Misc utilities
63//===----------------------------------------------------------------------===//
64
65static bool HandleConversionToBool(Expr* E, bool& Result, EvalInfo &Info) {
66 if (E->getType()->isIntegralType()) {
67 APSInt IntResult;
68 if (!EvaluateInteger(E, IntResult, Info))
69 return false;
70 Result = IntResult != 0;
71 return true;
72 } else if (E->getType()->isRealFloatingType()) {
73 APFloat FloatResult(0.0);
74 if (!EvaluateFloat(E, FloatResult, Info))
75 return false;
76 Result = !FloatResult.isZero();
77 return true;
78 } else if (E->getType()->isPointerType()) {
79 APValue PointerResult;
80 if (!EvaluatePointer(E, PointerResult, Info))
81 return false;
82 // FIXME: Is this accurate for all kinds of bases? If not, what would
83 // the check look like?
84 Result = PointerResult.getLValueBase() || PointerResult.getLValueOffset();
85 return true;
86 }
87
88 return false;
89}
90
91//===----------------------------------------------------------------------===//
92// LValue Evaluation
93//===----------------------------------------------------------------------===//
94namespace {
95class VISIBILITY_HIDDEN LValueExprEvaluator
96 : public StmtVisitor<LValueExprEvaluator, APValue> {
97 EvalInfo &Info;
98public:
99
100 LValueExprEvaluator(EvalInfo &info) : Info(info) {}
101
102 APValue VisitStmt(Stmt *S) {
Daniel Dunbar8a7b7c62008-11-12 21:52:46 +0000103#if 0
Eli Friedman4efaa272008-11-12 09:44:48 +0000104 // FIXME: Remove this when we support more expressions.
105 printf("Unhandled pointer statement\n");
106 S->dump();
Daniel Dunbar8a7b7c62008-11-12 21:52:46 +0000107#endif
Eli Friedman4efaa272008-11-12 09:44:48 +0000108 return APValue();
109 }
110
111 APValue VisitParenExpr(ParenExpr *E) { return Visit(E->getSubExpr()); }
Anders Carlsson35873c42008-11-24 04:41:22 +0000112 APValue VisitDeclRefExpr(DeclRefExpr *E);
Eli Friedman4efaa272008-11-12 09:44:48 +0000113 APValue VisitPredefinedExpr(PredefinedExpr *E) { return APValue(E, 0); }
114 APValue VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
115 APValue VisitMemberExpr(MemberExpr *E);
116 APValue VisitStringLiteral(StringLiteral *E) { return APValue(E, 0); }
Anders Carlsson3068d112008-11-16 19:01:22 +0000117 APValue VisitArraySubscriptExpr(ArraySubscriptExpr *E);
Eli Friedman4efaa272008-11-12 09:44:48 +0000118};
119} // end anonymous namespace
120
121static bool EvaluateLValue(const Expr* E, APValue& Result, EvalInfo &Info) {
122 Result = LValueExprEvaluator(Info).Visit(const_cast<Expr*>(E));
123 return Result.isLValue();
124}
125
Anders Carlsson35873c42008-11-24 04:41:22 +0000126APValue LValueExprEvaluator::VisitDeclRefExpr(DeclRefExpr *E)
127{
128 if (!E->hasGlobalStorage())
129 return APValue();
130
131 return APValue(E, 0);
132}
133
Eli Friedman4efaa272008-11-12 09:44:48 +0000134APValue LValueExprEvaluator::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
135 if (E->isFileScope())
136 return APValue(E, 0);
137 return APValue();
138}
139
140APValue LValueExprEvaluator::VisitMemberExpr(MemberExpr *E) {
141 APValue result;
142 QualType Ty;
143 if (E->isArrow()) {
144 if (!EvaluatePointer(E->getBase(), result, Info))
145 return APValue();
146 Ty = E->getBase()->getType()->getAsPointerType()->getPointeeType();
147 } else {
148 result = Visit(E->getBase());
149 if (result.isUninit())
150 return APValue();
151 Ty = E->getBase()->getType();
152 }
153
154 RecordDecl *RD = Ty->getAsRecordType()->getDecl();
155 const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
156 FieldDecl *FD = E->getMemberDecl();
157
158 // FIXME: This is linear time.
159 unsigned i = 0, e = 0;
160 for (i = 0, e = RD->getNumMembers(); i != e; i++) {
161 if (RD->getMember(i) == FD)
162 break;
163 }
164
165 result.setLValue(result.getLValueBase(),
166 result.getLValueOffset() + RL.getFieldOffset(i) / 8);
167
168 return result;
169}
170
Anders Carlsson3068d112008-11-16 19:01:22 +0000171APValue LValueExprEvaluator::VisitArraySubscriptExpr(ArraySubscriptExpr *E)
172{
173 APValue Result;
174
175 if (!EvaluatePointer(E->getBase(), Result, Info))
176 return APValue();
177
178 APSInt Index;
179 if (!EvaluateInteger(E->getIdx(), Index, Info))
180 return APValue();
181
182 uint64_t ElementSize = Info.Ctx.getTypeSize(E->getType()) / 8;
183
184 uint64_t Offset = Index.getSExtValue() * ElementSize;
185 Result.setLValue(Result.getLValueBase(),
186 Result.getLValueOffset() + Offset);
187 return Result;
188}
Eli Friedman4efaa272008-11-12 09:44:48 +0000189
190//===----------------------------------------------------------------------===//
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000191// Pointer Evaluation
192//===----------------------------------------------------------------------===//
193
Anders Carlssonc754aa62008-07-08 05:13:58 +0000194namespace {
Anders Carlsson2bad1682008-07-08 14:30:00 +0000195class VISIBILITY_HIDDEN PointerExprEvaluator
196 : public StmtVisitor<PointerExprEvaluator, APValue> {
Chris Lattner87eae5e2008-07-11 22:52:41 +0000197 EvalInfo &Info;
Anders Carlsson2bad1682008-07-08 14:30:00 +0000198public:
Anders Carlsson2bad1682008-07-08 14:30:00 +0000199
Chris Lattner87eae5e2008-07-11 22:52:41 +0000200 PointerExprEvaluator(EvalInfo &info) : Info(info) {}
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000201
Anders Carlsson2bad1682008-07-08 14:30:00 +0000202 APValue VisitStmt(Stmt *S) {
Anders Carlsson2bad1682008-07-08 14:30:00 +0000203 return APValue();
204 }
205
206 APValue VisitParenExpr(ParenExpr *E) { return Visit(E->getSubExpr()); }
207
Anders Carlsson650c92f2008-07-08 15:34:11 +0000208 APValue VisitBinaryOperator(const BinaryOperator *E);
209 APValue VisitCastExpr(const CastExpr* E);
Eli Friedman4efaa272008-11-12 09:44:48 +0000210 APValue VisitUnaryOperator(const UnaryOperator *E);
211 APValue VisitObjCStringLiteral(ObjCStringLiteral *E)
212 { return APValue(E, 0); }
213 APValue VisitConditionalOperator(ConditionalOperator *E);
Anders Carlsson650c92f2008-07-08 15:34:11 +0000214};
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000215} // end anonymous namespace
Anders Carlsson650c92f2008-07-08 15:34:11 +0000216
Chris Lattner87eae5e2008-07-11 22:52:41 +0000217static bool EvaluatePointer(const Expr* E, APValue& Result, EvalInfo &Info) {
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000218 if (!E->getType()->isPointerType())
219 return false;
Chris Lattner87eae5e2008-07-11 22:52:41 +0000220 Result = PointerExprEvaluator(Info).Visit(const_cast<Expr*>(E));
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000221 return Result.isLValue();
222}
223
224APValue PointerExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
225 if (E->getOpcode() != BinaryOperator::Add &&
226 E->getOpcode() != BinaryOperator::Sub)
227 return APValue();
228
229 const Expr *PExp = E->getLHS();
230 const Expr *IExp = E->getRHS();
231 if (IExp->getType()->isPointerType())
232 std::swap(PExp, IExp);
233
234 APValue ResultLValue;
Chris Lattner87eae5e2008-07-11 22:52:41 +0000235 if (!EvaluatePointer(PExp, ResultLValue, Info))
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000236 return APValue();
237
238 llvm::APSInt AdditionalOffset(32);
Chris Lattner87eae5e2008-07-11 22:52:41 +0000239 if (!EvaluateInteger(IExp, AdditionalOffset, Info))
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000240 return APValue();
241
Eli Friedman4efaa272008-11-12 09:44:48 +0000242 QualType PointeeType = PExp->getType()->getAsPointerType()->getPointeeType();
243 uint64_t SizeOfPointee = Info.Ctx.getTypeSize(PointeeType) / 8;
244
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000245 uint64_t Offset = ResultLValue.getLValueOffset();
Eli Friedman4efaa272008-11-12 09:44:48 +0000246
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000247 if (E->getOpcode() == BinaryOperator::Add)
Eli Friedman4efaa272008-11-12 09:44:48 +0000248 Offset += AdditionalOffset.getLimitedValue() * SizeOfPointee;
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000249 else
Eli Friedman4efaa272008-11-12 09:44:48 +0000250 Offset -= AdditionalOffset.getLimitedValue() * SizeOfPointee;
251
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000252 return APValue(ResultLValue.getLValueBase(), Offset);
253}
Eli Friedman4efaa272008-11-12 09:44:48 +0000254
255APValue PointerExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
256 if (E->getOpcode() == UnaryOperator::Extension) {
257 // FIXME: Deal with warnings?
258 return Visit(E->getSubExpr());
259 }
260
261 if (E->getOpcode() == UnaryOperator::AddrOf) {
262 APValue result;
263 if (EvaluateLValue(E->getSubExpr(), result, Info))
264 return result;
265 }
266
267 return APValue();
268}
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000269
270
Chris Lattnerb542afe2008-07-11 19:10:17 +0000271APValue PointerExprEvaluator::VisitCastExpr(const CastExpr* E) {
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000272 const Expr* SubExpr = E->getSubExpr();
273
274 // Check for pointer->pointer cast
275 if (SubExpr->getType()->isPointerType()) {
276 APValue Result;
Chris Lattner87eae5e2008-07-11 22:52:41 +0000277 if (EvaluatePointer(SubExpr, Result, Info))
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000278 return Result;
279 return APValue();
280 }
281
Eli Friedmand9f4bcd2008-07-27 05:46:18 +0000282 if (SubExpr->getType()->isIntegralType()) {
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000283 llvm::APSInt Result(32);
Chris Lattner87eae5e2008-07-11 22:52:41 +0000284 if (EvaluateInteger(SubExpr, Result, Info)) {
285 Result.extOrTrunc((unsigned)Info.Ctx.getTypeSize(E->getType()));
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000286 return APValue(0, Result.getZExtValue());
287 }
288 }
Eli Friedman4efaa272008-11-12 09:44:48 +0000289
290 if (SubExpr->getType()->isFunctionType() ||
291 SubExpr->getType()->isArrayType()) {
292 APValue Result;
293 if (EvaluateLValue(SubExpr, Result, Info))
294 return Result;
295 return APValue();
296 }
297
298 //assert(0 && "Unhandled cast");
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000299 return APValue();
300}
301
Eli Friedman4efaa272008-11-12 09:44:48 +0000302APValue PointerExprEvaluator::VisitConditionalOperator(ConditionalOperator *E) {
303 bool BoolResult;
304 if (!HandleConversionToBool(E->getCond(), BoolResult, Info))
305 return APValue();
306
307 Expr* EvalExpr = BoolResult ? E->getTrueExpr() : E->getFalseExpr();
308
309 APValue Result;
310 if (EvaluatePointer(EvalExpr, Result, Info))
311 return Result;
312 return APValue();
313}
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000314
315//===----------------------------------------------------------------------===//
316// Integer Evaluation
317//===----------------------------------------------------------------------===//
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000318
319namespace {
Anders Carlssonc754aa62008-07-08 05:13:58 +0000320class VISIBILITY_HIDDEN IntExprEvaluator
Chris Lattnerb542afe2008-07-11 19:10:17 +0000321 : public StmtVisitor<IntExprEvaluator, bool> {
Chris Lattner87eae5e2008-07-11 22:52:41 +0000322 EvalInfo &Info;
Chris Lattnerb542afe2008-07-11 19:10:17 +0000323 APSInt &Result;
Anders Carlssonc754aa62008-07-08 05:13:58 +0000324public:
Chris Lattner87eae5e2008-07-11 22:52:41 +0000325 IntExprEvaluator(EvalInfo &info, APSInt &result)
326 : Info(info), Result(result) {}
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000327
Chris Lattner7a767782008-07-11 19:24:49 +0000328 unsigned getIntTypeSizeInBits(QualType T) const {
Chris Lattner54176fd2008-07-12 00:14:42 +0000329 return (unsigned)Info.Ctx.getIntWidth(T);
330 }
331
332 bool Extension(SourceLocation L, diag::kind D) {
Anders Carlsson54da0492008-11-30 16:38:33 +0000333 Info.EvalResult.DiagLoc = L;
334 Info.EvalResult.Diag = D;
Chris Lattner54176fd2008-07-12 00:14:42 +0000335 return true; // still a constant.
336 }
337
Chris Lattner32fea9d2008-11-12 07:43:42 +0000338 bool Error(SourceLocation L, diag::kind D, QualType ExprTy) {
Chris Lattner54176fd2008-07-12 00:14:42 +0000339 // If this is in an unevaluated portion of the subexpression, ignore the
340 // error.
Chris Lattner32fea9d2008-11-12 07:43:42 +0000341 if (!Info.isEvaluated) {
342 // If error is ignored because the value isn't evaluated, get the real
343 // type at least to prevent errors downstream.
344 Result.zextOrTrunc(getIntTypeSizeInBits(ExprTy));
345 Result.setIsUnsigned(ExprTy->isUnsignedIntegerType());
Chris Lattner54176fd2008-07-12 00:14:42 +0000346 return true;
Chris Lattner32fea9d2008-11-12 07:43:42 +0000347 }
Chris Lattner54176fd2008-07-12 00:14:42 +0000348
Chris Lattner32fea9d2008-11-12 07:43:42 +0000349 // Take the first error.
Anders Carlsson54da0492008-11-30 16:38:33 +0000350 if (Info.EvalResult.Diag == 0) {
351 Info.EvalResult.DiagLoc = L;
352 Info.EvalResult.Diag = D;
Chris Lattner32fea9d2008-11-12 07:43:42 +0000353 }
Chris Lattner54176fd2008-07-12 00:14:42 +0000354 return false;
Chris Lattner7a767782008-07-11 19:24:49 +0000355 }
356
Anders Carlssonc754aa62008-07-08 05:13:58 +0000357 //===--------------------------------------------------------------------===//
358 // Visitor Methods
359 //===--------------------------------------------------------------------===//
Chris Lattner32fea9d2008-11-12 07:43:42 +0000360
361 bool VisitStmt(Stmt *) {
362 assert(0 && "This should be called on integers, stmts are not integers");
363 return false;
364 }
Chris Lattner7a767782008-07-11 19:24:49 +0000365
Chris Lattner32fea9d2008-11-12 07:43:42 +0000366 bool VisitExpr(Expr *E) {
367 return Error(E->getLocStart(), diag::err_expr_not_constant, E->getType());
Anders Carlssonc754aa62008-07-08 05:13:58 +0000368 }
369
Chris Lattnerb542afe2008-07-11 19:10:17 +0000370 bool VisitParenExpr(ParenExpr *E) { return Visit(E->getSubExpr()); }
Anders Carlssonc754aa62008-07-08 05:13:58 +0000371
Chris Lattner4c4867e2008-07-12 00:38:25 +0000372 bool VisitIntegerLiteral(const IntegerLiteral *E) {
373 Result = E->getValue();
374 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
375 return true;
376 }
377 bool VisitCharacterLiteral(const CharacterLiteral *E) {
378 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
379 Result = E->getValue();
380 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
381 return true;
382 }
383 bool VisitTypesCompatibleExpr(const TypesCompatibleExpr *E) {
384 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
Daniel Dunbarac620de2008-10-24 08:07:57 +0000385 // Per gcc docs "this built-in function ignores top level
386 // qualifiers". We need to use the canonical version to properly
387 // be able to strip CRV qualifiers from the type.
388 QualType T0 = Info.Ctx.getCanonicalType(E->getArgType1());
389 QualType T1 = Info.Ctx.getCanonicalType(E->getArgType2());
390 Result = Info.Ctx.typesAreCompatible(T0.getUnqualifiedType(),
391 T1.getUnqualifiedType());
Chris Lattner4c4867e2008-07-12 00:38:25 +0000392 return true;
393 }
394 bool VisitDeclRefExpr(const DeclRefExpr *E);
395 bool VisitCallExpr(const CallExpr *E);
Chris Lattnerb542afe2008-07-11 19:10:17 +0000396 bool VisitBinaryOperator(const BinaryOperator *E);
397 bool VisitUnaryOperator(const UnaryOperator *E);
Nuno Lopesca7c2ea2008-11-16 19:28:31 +0000398 bool VisitConditionalOperator(const ConditionalOperator *E);
Anders Carlsson06a36752008-07-08 05:49:43 +0000399
Chris Lattner732b2232008-07-12 01:15:53 +0000400 bool VisitCastExpr(CastExpr* E) {
Chris Lattner732b2232008-07-12 01:15:53 +0000401 return HandleCast(E->getLocStart(), E->getSubExpr(), E->getType());
Anders Carlsson650c92f2008-07-08 15:34:11 +0000402 }
Sebastian Redl05189992008-11-11 17:56:53 +0000403 bool VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E);
404
Anders Carlsson3068d112008-11-16 19:01:22 +0000405 bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
Anders Carlsson529569e2008-11-16 22:46:56 +0000406 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
Anders Carlsson3068d112008-11-16 19:01:22 +0000407 Result = E->getValue();
408 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
409 return true;
410 }
411
412 bool VisitCXXZeroInitValueExpr(const CXXZeroInitValueExpr *E) {
413 Result = APSInt::getNullValue(getIntTypeSizeInBits(E->getType()));
414 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
415 return true;
416 }
417
Chris Lattnerfcee0012008-07-11 21:24:13 +0000418private:
Chris Lattner732b2232008-07-12 01:15:53 +0000419 bool HandleCast(SourceLocation CastLoc, Expr *SubExpr, QualType DestType);
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000420};
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000421} // end anonymous namespace
Anders Carlsson650c92f2008-07-08 15:34:11 +0000422
Chris Lattner87eae5e2008-07-11 22:52:41 +0000423static bool EvaluateInteger(const Expr* E, APSInt &Result, EvalInfo &Info) {
424 return IntExprEvaluator(Info, Result).Visit(const_cast<Expr*>(E));
Anders Carlsson650c92f2008-07-08 15:34:11 +0000425}
Anders Carlsson650c92f2008-07-08 15:34:11 +0000426
Chris Lattner4c4867e2008-07-12 00:38:25 +0000427bool IntExprEvaluator::VisitDeclRefExpr(const DeclRefExpr *E) {
428 // Enums are integer constant exprs.
429 if (const EnumConstantDecl *D = dyn_cast<EnumConstantDecl>(E->getDecl())) {
430 Result = D->getInitVal();
431 return true;
432 }
433
434 // Otherwise, random variable references are not constants.
Chris Lattner32fea9d2008-11-12 07:43:42 +0000435 return Error(E->getLocStart(), diag::err_expr_not_constant, E->getType());
Chris Lattner4c4867e2008-07-12 00:38:25 +0000436}
437
Chris Lattnera4d55d82008-10-06 06:40:35 +0000438/// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way
439/// as GCC.
440static int EvaluateBuiltinClassifyType(const CallExpr *E) {
441 // The following enum mimics the values returned by GCC.
442 enum gcc_type_class {
443 no_type_class = -1,
444 void_type_class, integer_type_class, char_type_class,
445 enumeral_type_class, boolean_type_class,
446 pointer_type_class, reference_type_class, offset_type_class,
447 real_type_class, complex_type_class,
448 function_type_class, method_type_class,
449 record_type_class, union_type_class,
450 array_type_class, string_type_class,
451 lang_type_class
452 };
453
454 // If no argument was supplied, default to "no_type_class". This isn't
455 // ideal, however it is what gcc does.
456 if (E->getNumArgs() == 0)
457 return no_type_class;
458
459 QualType ArgTy = E->getArg(0)->getType();
460 if (ArgTy->isVoidType())
461 return void_type_class;
462 else if (ArgTy->isEnumeralType())
463 return enumeral_type_class;
464 else if (ArgTy->isBooleanType())
465 return boolean_type_class;
466 else if (ArgTy->isCharType())
467 return string_type_class; // gcc doesn't appear to use char_type_class
468 else if (ArgTy->isIntegerType())
469 return integer_type_class;
470 else if (ArgTy->isPointerType())
471 return pointer_type_class;
472 else if (ArgTy->isReferenceType())
473 return reference_type_class;
474 else if (ArgTy->isRealType())
475 return real_type_class;
476 else if (ArgTy->isComplexType())
477 return complex_type_class;
478 else if (ArgTy->isFunctionType())
479 return function_type_class;
480 else if (ArgTy->isStructureType())
481 return record_type_class;
482 else if (ArgTy->isUnionType())
483 return union_type_class;
484 else if (ArgTy->isArrayType())
485 return array_type_class;
486 else if (ArgTy->isUnionType())
487 return union_type_class;
488 else // FIXME: offset_type_class, method_type_class, & lang_type_class?
489 assert(0 && "CallExpr::isBuiltinClassifyType(): unimplemented type");
490 return -1;
491}
492
Chris Lattner4c4867e2008-07-12 00:38:25 +0000493bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) {
494 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
Chris Lattner4c4867e2008-07-12 00:38:25 +0000495
Chris Lattner019f4e82008-10-06 05:28:25 +0000496 switch (E->isBuiltinCall()) {
497 default:
Chris Lattner32fea9d2008-11-12 07:43:42 +0000498 return Error(E->getLocStart(), diag::err_expr_not_constant, E->getType());
Chris Lattner019f4e82008-10-06 05:28:25 +0000499 case Builtin::BI__builtin_classify_type:
Chris Lattnera4d55d82008-10-06 06:40:35 +0000500 Result.setIsSigned(true);
501 Result = EvaluateBuiltinClassifyType(E);
Chris Lattner019f4e82008-10-06 05:28:25 +0000502 return true;
503
Anders Carlsson4bbc0e02008-11-24 04:21:33 +0000504 case Builtin::BI__builtin_constant_p:
Chris Lattner019f4e82008-10-06 05:28:25 +0000505 // __builtin_constant_p always has one operand: it returns true if that
506 // operand can be folded, false otherwise.
Anders Carlsson4bbc0e02008-11-24 04:21:33 +0000507 Result = E->getArg(0)->isEvaluatable(Info.Ctx);
Chris Lattner019f4e82008-10-06 05:28:25 +0000508 return true;
509 }
Chris Lattner4c4867e2008-07-12 00:38:25 +0000510}
Anders Carlsson650c92f2008-07-08 15:34:11 +0000511
Chris Lattnerb542afe2008-07-11 19:10:17 +0000512bool IntExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
Eli Friedmana6afa762008-11-13 06:09:17 +0000513 if (E->getOpcode() == BinaryOperator::Comma) {
514 // Evaluate the side that actually matters; this needs to be
515 // handled specially because calling Visit() on the LHS can
516 // have strange results when it doesn't have an integral type.
Nuno Lopesf9ef0c62008-11-16 20:09:07 +0000517 if (Visit(E->getRHS()))
518 return true;
Eli Friedmana6afa762008-11-13 06:09:17 +0000519
520 // Check for isEvaluated; the idea is that this might eventually
521 // be useful for isICE and other similar uses that care about
522 // whether a comma is evaluated. This isn't really used yet, though,
523 // and I'm not sure it really works as intended.
524 if (!Info.isEvaluated)
Nuno Lopesf9ef0c62008-11-16 20:09:07 +0000525 return Extension(E->getOperatorLoc(), diag::ext_comma_in_constant_expr);
Eli Friedmana6afa762008-11-13 06:09:17 +0000526
Nuno Lopesf9ef0c62008-11-16 20:09:07 +0000527 return false;
Eli Friedmana6afa762008-11-13 06:09:17 +0000528 }
529
530 if (E->isLogicalOp()) {
531 // These need to be handled specially because the operands aren't
532 // necessarily integral
Anders Carlssonfcb4d092008-11-30 16:51:17 +0000533 bool lhsResult, rhsResult;
Anders Carlsson51fe9962008-11-22 21:04:56 +0000534
Anders Carlssonfcb4d092008-11-30 16:51:17 +0000535 if (HandleConversionToBool(E->getLHS(), lhsResult, Info)) {
Anders Carlsson51fe9962008-11-22 21:04:56 +0000536 // We were able to evaluate the LHS, see if we can get away with not
537 // evaluating the RHS: 0 && X -> 0, 1 || X -> 1
Anders Carlssonfcb4d092008-11-30 16:51:17 +0000538 if (lhsResult == (E->getOpcode() == BinaryOperator::LOr) ||
539 !lhsResult == (E->getOpcode() == BinaryOperator::LAnd)) {
Anders Carlsson4bbc0e02008-11-24 04:21:33 +0000540 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
541 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
Anders Carlssonfcb4d092008-11-30 16:51:17 +0000542 Result = lhsResult;
Anders Carlsson4bbc0e02008-11-24 04:21:33 +0000543
Anders Carlssonfcb4d092008-11-30 16:51:17 +0000544 bool rhsEvaluated = HandleConversionToBool(E->getRHS(), rhsResult, Info);
545
546 if (rhsEvaluated)
547 return true;
548
549 // FIXME: Return an extension warning saying that the RHS could not be
550 // evaluated.
Anders Carlsson4bbc0e02008-11-24 04:21:33 +0000551 return true;
Eli Friedmana6afa762008-11-13 06:09:17 +0000552 }
Anders Carlsson4bbc0e02008-11-24 04:21:33 +0000553
Anders Carlssonfcb4d092008-11-30 16:51:17 +0000554 if (HandleConversionToBool(E->getRHS(), rhsResult, Info)) {
Anders Carlsson4bbc0e02008-11-24 04:21:33 +0000555 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
556 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
557 if (E->getOpcode() == BinaryOperator::LOr)
Anders Carlssonfcb4d092008-11-30 16:51:17 +0000558 Result = lhsResult || rhsResult;
Anders Carlsson4bbc0e02008-11-24 04:21:33 +0000559 else
Anders Carlssonfcb4d092008-11-30 16:51:17 +0000560 Result = lhsResult && rhsResult;
Anders Carlsson4bbc0e02008-11-24 04:21:33 +0000561 return true;
562 }
563 } else {
Anders Carlssonfcb4d092008-11-30 16:51:17 +0000564 if (HandleConversionToBool(E->getRHS(), rhsResult, Info)) {
Anders Carlsson4bbc0e02008-11-24 04:21:33 +0000565 // We can't evaluate the LHS; however, sometimes the result
566 // is determined by the RHS: X && 0 -> 0, X || 1 -> 1.
Anders Carlssonfcb4d092008-11-30 16:51:17 +0000567 if (rhsResult == (E->getOpcode() == BinaryOperator::LOr) ||
568 !rhsResult == (E->getOpcode() == BinaryOperator::LAnd)) {
Anders Carlsson4bbc0e02008-11-24 04:21:33 +0000569 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
570 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
Anders Carlssonfcb4d092008-11-30 16:51:17 +0000571 Result = rhsResult;
572
573 // Since we werent able to evaluate the left hand side, it
574 // must have had side effects.
575 Info.EvalResult.HasSideEffects = true;
576
Anders Carlsson4bbc0e02008-11-24 04:21:33 +0000577 return true;
578 }
579 }
Anders Carlsson51fe9962008-11-22 21:04:56 +0000580 }
Eli Friedmana6afa762008-11-13 06:09:17 +0000581
Eli Friedmana6afa762008-11-13 06:09:17 +0000582 return false;
583 }
584
Anders Carlsson286f85e2008-11-16 07:17:21 +0000585 QualType LHSTy = E->getLHS()->getType();
586 QualType RHSTy = E->getRHS()->getType();
587
588 if (LHSTy->isRealFloatingType() &&
589 RHSTy->isRealFloatingType()) {
590 APFloat RHS(0.0), LHS(0.0);
591
592 if (!EvaluateFloat(E->getRHS(), RHS, Info))
593 return false;
594
595 if (!EvaluateFloat(E->getLHS(), LHS, Info))
596 return false;
597
598 APFloat::cmpResult CR = LHS.compare(RHS);
Anders Carlsson529569e2008-11-16 22:46:56 +0000599
600 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
601
Anders Carlsson286f85e2008-11-16 07:17:21 +0000602 switch (E->getOpcode()) {
603 default:
604 assert(0 && "Invalid binary operator!");
605 case BinaryOperator::LT:
606 Result = CR == APFloat::cmpLessThan;
607 break;
608 case BinaryOperator::GT:
609 Result = CR == APFloat::cmpGreaterThan;
610 break;
611 case BinaryOperator::LE:
612 Result = CR == APFloat::cmpLessThan || CR == APFloat::cmpEqual;
613 break;
614 case BinaryOperator::GE:
615 Result = CR == APFloat::cmpGreaterThan || CR == APFloat::cmpEqual;
616 break;
617 case BinaryOperator::EQ:
618 Result = CR == APFloat::cmpEqual;
619 break;
620 case BinaryOperator::NE:
621 Result = CR == APFloat::cmpGreaterThan || CR == APFloat::cmpLessThan;
622 break;
623 }
624
Anders Carlsson286f85e2008-11-16 07:17:21 +0000625 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
626 return true;
627 }
628
Anders Carlsson3068d112008-11-16 19:01:22 +0000629 if (E->getOpcode() == BinaryOperator::Sub) {
Anders Carlsson529569e2008-11-16 22:46:56 +0000630 if (LHSTy->isPointerType() && RHSTy->isPointerType()) {
Anders Carlsson3068d112008-11-16 19:01:22 +0000631 APValue LHSValue;
632 if (!EvaluatePointer(E->getLHS(), LHSValue, Info))
633 return false;
634
635 APValue RHSValue;
636 if (!EvaluatePointer(E->getRHS(), RHSValue, Info))
637 return false;
638
639 // FIXME: Is this correct? What if only one of the operands has a base?
640 if (LHSValue.getLValueBase() || RHSValue.getLValueBase())
641 return false;
642
643 const QualType Type = E->getLHS()->getType();
644 const QualType ElementType = Type->getAsPointerType()->getPointeeType();
645
646 uint64_t D = LHSValue.getLValueOffset() - RHSValue.getLValueOffset();
647 D /= Info.Ctx.getTypeSize(ElementType) / 8;
648
Anders Carlsson3068d112008-11-16 19:01:22 +0000649 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
Anders Carlsson529569e2008-11-16 22:46:56 +0000650 Result = D;
Anders Carlsson3068d112008-11-16 19:01:22 +0000651 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
652
653 return true;
654 }
655 }
Anders Carlsson286f85e2008-11-16 07:17:21 +0000656 if (!LHSTy->isIntegralType() ||
657 !RHSTy->isIntegralType()) {
Eli Friedmana6afa762008-11-13 06:09:17 +0000658 // We can't continue from here for non-integral types, and they
659 // could potentially confuse the following operations.
660 // FIXME: Deal with EQ and friends.
661 return false;
662 }
663
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000664 // The LHS of a constant expr is always evaluated and needed.
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000665 llvm::APSInt RHS(32);
Chris Lattnerc8cc9cc2008-11-12 07:04:29 +0000666 if (!Visit(E->getLHS())) {
Chris Lattner54176fd2008-07-12 00:14:42 +0000667 return false; // error in subexpression.
Chris Lattnerc8cc9cc2008-11-12 07:04:29 +0000668 }
Eli Friedmand9f4bcd2008-07-27 05:46:18 +0000669
Eli Friedmand9f4bcd2008-07-27 05:46:18 +0000670
671 // FIXME Maybe we want to succeed even where we can't evaluate the
672 // right side of LAnd/LOr?
673 // For example, see http://llvm.org/bugs/show_bug.cgi?id=2525
Chris Lattner54176fd2008-07-12 00:14:42 +0000674 if (!EvaluateInteger(E->getRHS(), RHS, Info))
Chris Lattnerb542afe2008-07-11 19:10:17 +0000675 return false;
Eli Friedmana6afa762008-11-13 06:09:17 +0000676
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000677 switch (E->getOpcode()) {
Chris Lattner32fea9d2008-11-12 07:43:42 +0000678 default:
679 return Error(E->getOperatorLoc(), diag::err_expr_not_constant,E->getType());
Chris Lattner54176fd2008-07-12 00:14:42 +0000680 case BinaryOperator::Mul: Result *= RHS; return true;
681 case BinaryOperator::Add: Result += RHS; return true;
682 case BinaryOperator::Sub: Result -= RHS; return true;
683 case BinaryOperator::And: Result &= RHS; return true;
684 case BinaryOperator::Xor: Result ^= RHS; return true;
685 case BinaryOperator::Or: Result |= RHS; return true;
Chris Lattner75a48812008-07-11 22:15:16 +0000686 case BinaryOperator::Div:
Chris Lattner54176fd2008-07-12 00:14:42 +0000687 if (RHS == 0)
Chris Lattner32fea9d2008-11-12 07:43:42 +0000688 return Error(E->getOperatorLoc(), diag::err_expr_divide_by_zero,
689 E->getType());
Chris Lattner75a48812008-07-11 22:15:16 +0000690 Result /= RHS;
Chris Lattner32fea9d2008-11-12 07:43:42 +0000691 break;
Chris Lattner75a48812008-07-11 22:15:16 +0000692 case BinaryOperator::Rem:
Chris Lattner54176fd2008-07-12 00:14:42 +0000693 if (RHS == 0)
Chris Lattner32fea9d2008-11-12 07:43:42 +0000694 return Error(E->getOperatorLoc(), diag::err_expr_divide_by_zero,
695 E->getType());
Chris Lattner75a48812008-07-11 22:15:16 +0000696 Result %= RHS;
Chris Lattner32fea9d2008-11-12 07:43:42 +0000697 break;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000698 case BinaryOperator::Shl:
Chris Lattner54176fd2008-07-12 00:14:42 +0000699 // FIXME: Warn about out of range shift amounts!
Chris Lattnerb542afe2008-07-11 19:10:17 +0000700 Result <<= (unsigned)RHS.getLimitedValue(Result.getBitWidth()-1);
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000701 break;
702 case BinaryOperator::Shr:
Chris Lattnerb542afe2008-07-11 19:10:17 +0000703 Result >>= (unsigned)RHS.getLimitedValue(Result.getBitWidth()-1);
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000704 break;
Chris Lattnerb542afe2008-07-11 19:10:17 +0000705
Chris Lattnerac7cb602008-07-11 19:29:32 +0000706 case BinaryOperator::LT:
707 Result = Result < RHS;
708 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
709 break;
710 case BinaryOperator::GT:
711 Result = Result > RHS;
712 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
713 break;
714 case BinaryOperator::LE:
715 Result = Result <= RHS;
716 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
717 break;
718 case BinaryOperator::GE:
719 Result = Result >= RHS;
720 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
721 break;
722 case BinaryOperator::EQ:
723 Result = Result == RHS;
724 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
725 break;
726 case BinaryOperator::NE:
727 Result = Result != RHS;
728 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
729 break;
Chris Lattner54176fd2008-07-12 00:14:42 +0000730 case BinaryOperator::LAnd:
731 Result = Result != 0 && RHS != 0;
732 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
733 break;
734 case BinaryOperator::LOr:
735 Result = Result != 0 || RHS != 0;
736 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
737 break;
Eli Friedmanb11e7782008-11-13 02:13:11 +0000738 }
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000739
740 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
Chris Lattnerb542afe2008-07-11 19:10:17 +0000741 return true;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000742}
743
Nuno Lopesca7c2ea2008-11-16 19:28:31 +0000744bool IntExprEvaluator::VisitConditionalOperator(const ConditionalOperator *E) {
Nuno Lopesa25bd552008-11-16 22:06:39 +0000745 bool Cond;
746 if (!HandleConversionToBool(E->getCond(), Cond, Info))
Nuno Lopesca7c2ea2008-11-16 19:28:31 +0000747 return false;
748
Nuno Lopesa25bd552008-11-16 22:06:39 +0000749 return Visit(Cond ? E->getTrueExpr() : E->getFalseExpr());
Nuno Lopesca7c2ea2008-11-16 19:28:31 +0000750}
751
Sebastian Redl05189992008-11-11 17:56:53 +0000752/// VisitSizeAlignOfExpr - Evaluate a sizeof or alignof with a result as the
753/// expression's type.
754bool IntExprEvaluator::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) {
755 QualType DstTy = E->getType();
Chris Lattnerfcee0012008-07-11 21:24:13 +0000756 // Return the result in the right width.
757 Result.zextOrTrunc(getIntTypeSizeInBits(DstTy));
758 Result.setIsUnsigned(DstTy->isUnsignedIntegerType());
759
Sebastian Redl05189992008-11-11 17:56:53 +0000760 QualType SrcTy = E->getTypeOfArgument();
761
Chris Lattnerfcee0012008-07-11 21:24:13 +0000762 // sizeof(void) and __alignof__(void) = 1 as a gcc extension.
Eli Friedman4efaa272008-11-12 09:44:48 +0000763 if (SrcTy->isVoidType()) {
Chris Lattnerfcee0012008-07-11 21:24:13 +0000764 Result = 1;
Eli Friedman4efaa272008-11-12 09:44:48 +0000765 return true;
766 }
Chris Lattnerfcee0012008-07-11 21:24:13 +0000767
768 // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
Eli Friedman4efaa272008-11-12 09:44:48 +0000769 // FIXME: But alignof(vla) is!
Chris Lattnerfcee0012008-07-11 21:24:13 +0000770 if (!SrcTy->isConstantSizeType()) {
771 // FIXME: Should we attempt to evaluate this?
772 return false;
773 }
Sebastian Redl05189992008-11-11 17:56:53 +0000774
775 bool isSizeOf = E->isSizeOf();
Chris Lattnerfcee0012008-07-11 21:24:13 +0000776
777 // GCC extension: sizeof(function) = 1.
778 if (SrcTy->isFunctionType()) {
779 // FIXME: AlignOf shouldn't be unconditionally 4!
780 Result = isSizeOf ? 1 : 4;
781 return true;
782 }
783
784 // Get information about the size or align.
Chris Lattner87eae5e2008-07-11 22:52:41 +0000785 unsigned CharSize = Info.Ctx.Target.getCharWidth();
Chris Lattnerfcee0012008-07-11 21:24:13 +0000786 if (isSizeOf)
Eli Friedman4efaa272008-11-12 09:44:48 +0000787 Result = Info.Ctx.getTypeSize(SrcTy) / CharSize;
Chris Lattnerfcee0012008-07-11 21:24:13 +0000788 else
Chris Lattner87eae5e2008-07-11 22:52:41 +0000789 Result = Info.Ctx.getTypeAlign(SrcTy) / CharSize;
Chris Lattnerfcee0012008-07-11 21:24:13 +0000790 return true;
791}
792
Chris Lattnerb542afe2008-07-11 19:10:17 +0000793bool IntExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
Chris Lattner4c4867e2008-07-12 00:38:25 +0000794 // Special case unary operators that do not need their subexpression
795 // evaluated. offsetof/sizeof/alignof are all special.
Chris Lattner75a48812008-07-11 22:15:16 +0000796 if (E->isOffsetOfOp()) {
Chris Lattner4c4867e2008-07-12 00:38:25 +0000797 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
Chris Lattner87eae5e2008-07-11 22:52:41 +0000798 Result = E->evaluateOffsetOf(Info.Ctx);
Chris Lattner75a48812008-07-11 22:15:16 +0000799 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
800 return true;
801 }
Eli Friedmana6afa762008-11-13 06:09:17 +0000802
803 if (E->getOpcode() == UnaryOperator::LNot) {
804 // LNot's operand isn't necessarily an integer, so we handle it specially.
805 bool bres;
806 if (!HandleConversionToBool(E->getSubExpr(), bres, Info))
807 return false;
808 Result.zextOrTrunc(getIntTypeSizeInBits(E->getType()));
809 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
810 Result = !bres;
811 return true;
812 }
813
Chris Lattner87eae5e2008-07-11 22:52:41 +0000814 // Get the operand value into 'Result'.
815 if (!Visit(E->getSubExpr()))
Chris Lattner75a48812008-07-11 22:15:16 +0000816 return false;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000817
Chris Lattner75a48812008-07-11 22:15:16 +0000818 switch (E->getOpcode()) {
Chris Lattner4c4867e2008-07-12 00:38:25 +0000819 default:
Chris Lattner75a48812008-07-11 22:15:16 +0000820 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
821 // See C99 6.6p3.
Chris Lattner32fea9d2008-11-12 07:43:42 +0000822 return Error(E->getOperatorLoc(), diag::err_expr_not_constant,
823 E->getType());
Chris Lattner75a48812008-07-11 22:15:16 +0000824 case UnaryOperator::Extension:
Chris Lattner4c4867e2008-07-12 00:38:25 +0000825 // FIXME: Should extension allow i-c-e extension expressions in its scope?
826 // If so, we could clear the diagnostic ID.
Chris Lattner75a48812008-07-11 22:15:16 +0000827 case UnaryOperator::Plus:
Chris Lattner4c4867e2008-07-12 00:38:25 +0000828 // The result is always just the subexpr.
Chris Lattner75a48812008-07-11 22:15:16 +0000829 break;
830 case UnaryOperator::Minus:
831 Result = -Result;
832 break;
833 case UnaryOperator::Not:
834 Result = ~Result;
835 break;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000836 }
837
838 Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
Chris Lattnerb542afe2008-07-11 19:10:17 +0000839 return true;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000840}
841
Chris Lattner732b2232008-07-12 01:15:53 +0000842/// HandleCast - This is used to evaluate implicit or explicit casts where the
843/// result type is integer.
844bool IntExprEvaluator::HandleCast(SourceLocation CastLoc,
845 Expr *SubExpr, QualType DestType) {
Chris Lattner7a767782008-07-11 19:24:49 +0000846 unsigned DestWidth = getIntTypeSizeInBits(DestType);
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000847
Eli Friedman4efaa272008-11-12 09:44:48 +0000848 if (DestType->isBooleanType()) {
849 bool BoolResult;
850 if (!HandleConversionToBool(SubExpr, BoolResult, Info))
851 return false;
852 Result.zextOrTrunc(DestWidth);
853 Result.setIsUnsigned(DestType->isUnsignedIntegerType());
854 Result = BoolResult;
855 return true;
856 }
857
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000858 // Handle simple integer->integer casts.
Eli Friedmana6afa762008-11-13 06:09:17 +0000859 if (SubExpr->getType()->isIntegralType()) {
Chris Lattner732b2232008-07-12 01:15:53 +0000860 if (!Visit(SubExpr))
Chris Lattnerb542afe2008-07-11 19:10:17 +0000861 return false;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000862
863 // Figure out if this is a truncate, extend or noop cast.
864 // If the input is signed, do a sign extend, noop, or truncate.
Eli Friedman4efaa272008-11-12 09:44:48 +0000865 Result.extOrTrunc(DestWidth);
Chris Lattner732b2232008-07-12 01:15:53 +0000866 Result.setIsUnsigned(DestType->isUnsignedIntegerType());
867 return true;
868 }
869
870 // FIXME: Clean this up!
871 if (SubExpr->getType()->isPointerType()) {
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000872 APValue LV;
Chris Lattner87eae5e2008-07-11 22:52:41 +0000873 if (!EvaluatePointer(SubExpr, LV, Info))
Chris Lattnerb542afe2008-07-11 19:10:17 +0000874 return false;
Eli Friedman4efaa272008-11-12 09:44:48 +0000875
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000876 if (LV.getLValueBase())
Chris Lattnerb542afe2008-07-11 19:10:17 +0000877 return false;
Eli Friedman4efaa272008-11-12 09:44:48 +0000878
Anders Carlsson559e56b2008-07-08 16:49:00 +0000879 Result.extOrTrunc(DestWidth);
880 Result = LV.getLValueOffset();
Chris Lattner732b2232008-07-12 01:15:53 +0000881 Result.setIsUnsigned(DestType->isUnsignedIntegerType());
882 return true;
Anders Carlsson2bad1682008-07-08 14:30:00 +0000883 }
Eli Friedman4efaa272008-11-12 09:44:48 +0000884
Chris Lattner732b2232008-07-12 01:15:53 +0000885 if (!SubExpr->getType()->isRealFloatingType())
Chris Lattner32fea9d2008-11-12 07:43:42 +0000886 return Error(CastLoc, diag::err_expr_not_constant, DestType);
Chris Lattner732b2232008-07-12 01:15:53 +0000887
Eli Friedmand8bfe7f2008-08-22 00:06:13 +0000888 APFloat F(0.0);
889 if (!EvaluateFloat(SubExpr, F, Info))
Chris Lattner32fea9d2008-11-12 07:43:42 +0000890 return Error(CastLoc, diag::err_expr_not_constant, DestType);
Chris Lattner732b2232008-07-12 01:15:53 +0000891
892 // Determine whether we are converting to unsigned or signed.
893 bool DestSigned = DestType->isSignedIntegerType();
894
895 // FIXME: Warning for overflow.
Dale Johannesenee5a7002008-10-09 23:02:32 +0000896 uint64_t Space[4];
897 bool ignored;
Eli Friedmand8bfe7f2008-08-22 00:06:13 +0000898 (void)F.convertToInteger(Space, DestWidth, DestSigned,
Dale Johannesenee5a7002008-10-09 23:02:32 +0000899 llvm::APFloat::rmTowardZero, &ignored);
Chris Lattner732b2232008-07-12 01:15:53 +0000900 Result = llvm::APInt(DestWidth, 4, Space);
901 Result.setIsUnsigned(!DestSigned);
Chris Lattnerb542afe2008-07-11 19:10:17 +0000902 return true;
Anders Carlssona25ae3d2008-07-08 14:35:21 +0000903}
Anders Carlsson2bad1682008-07-08 14:30:00 +0000904
Chris Lattnerf5eeb052008-07-11 18:11:29 +0000905//===----------------------------------------------------------------------===//
Eli Friedmand8bfe7f2008-08-22 00:06:13 +0000906// Float Evaluation
907//===----------------------------------------------------------------------===//
908
909namespace {
910class VISIBILITY_HIDDEN FloatExprEvaluator
911 : public StmtVisitor<FloatExprEvaluator, bool> {
912 EvalInfo &Info;
913 APFloat &Result;
914public:
915 FloatExprEvaluator(EvalInfo &info, APFloat &result)
916 : Info(info), Result(result) {}
917
918 bool VisitStmt(Stmt *S) {
919 return false;
920 }
921
922 bool VisitParenExpr(ParenExpr *E) { return Visit(E->getSubExpr()); }
Chris Lattner019f4e82008-10-06 05:28:25 +0000923 bool VisitCallExpr(const CallExpr *E);
Eli Friedmand8bfe7f2008-08-22 00:06:13 +0000924
Daniel Dunbar5db4b3f2008-10-16 03:51:50 +0000925 bool VisitUnaryOperator(const UnaryOperator *E);
Eli Friedmand8bfe7f2008-08-22 00:06:13 +0000926 bool VisitBinaryOperator(const BinaryOperator *E);
927 bool VisitFloatingLiteral(const FloatingLiteral *E);
Eli Friedman4efaa272008-11-12 09:44:48 +0000928 bool VisitCastExpr(CastExpr *E);
929 bool VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E);
Eli Friedmand8bfe7f2008-08-22 00:06:13 +0000930};
931} // end anonymous namespace
932
933static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
934 return FloatExprEvaluator(Info, Result).Visit(const_cast<Expr*>(E));
935}
936
Chris Lattner019f4e82008-10-06 05:28:25 +0000937bool FloatExprEvaluator::VisitCallExpr(const CallExpr *E) {
Chris Lattner019f4e82008-10-06 05:28:25 +0000938 switch (E->isBuiltinCall()) {
Chris Lattner34a74ab2008-10-06 05:53:16 +0000939 default: return false;
Chris Lattner019f4e82008-10-06 05:28:25 +0000940 case Builtin::BI__builtin_huge_val:
941 case Builtin::BI__builtin_huge_valf:
942 case Builtin::BI__builtin_huge_vall:
943 case Builtin::BI__builtin_inf:
944 case Builtin::BI__builtin_inff:
Daniel Dunbar7cbed032008-10-14 05:41:12 +0000945 case Builtin::BI__builtin_infl: {
946 const llvm::fltSemantics &Sem =
947 Info.Ctx.getFloatTypeSemantics(E->getType());
Chris Lattner34a74ab2008-10-06 05:53:16 +0000948 Result = llvm::APFloat::getInf(Sem);
949 return true;
Daniel Dunbar7cbed032008-10-14 05:41:12 +0000950 }
Chris Lattner9e621712008-10-06 06:31:58 +0000951
952 case Builtin::BI__builtin_nan:
953 case Builtin::BI__builtin_nanf:
954 case Builtin::BI__builtin_nanl:
955 // If this is __builtin_nan("") turn this into a simple nan, otherwise we
956 // can't constant fold it.
957 if (const StringLiteral *S =
958 dyn_cast<StringLiteral>(E->getArg(0)->IgnoreParenCasts())) {
959 if (!S->isWide() && S->getByteLength() == 0) { // empty string.
Daniel Dunbar7cbed032008-10-14 05:41:12 +0000960 const llvm::fltSemantics &Sem =
961 Info.Ctx.getFloatTypeSemantics(E->getType());
Chris Lattner9e621712008-10-06 06:31:58 +0000962 Result = llvm::APFloat::getNaN(Sem);
963 return true;
964 }
965 }
966 return false;
Daniel Dunbar5db4b3f2008-10-16 03:51:50 +0000967
968 case Builtin::BI__builtin_fabs:
969 case Builtin::BI__builtin_fabsf:
970 case Builtin::BI__builtin_fabsl:
971 if (!EvaluateFloat(E->getArg(0), Result, Info))
972 return false;
973
974 if (Result.isNegative())
975 Result.changeSign();
976 return true;
977
978 case Builtin::BI__builtin_copysign:
979 case Builtin::BI__builtin_copysignf:
980 case Builtin::BI__builtin_copysignl: {
981 APFloat RHS(0.);
982 if (!EvaluateFloat(E->getArg(0), Result, Info) ||
983 !EvaluateFloat(E->getArg(1), RHS, Info))
984 return false;
985 Result.copySign(RHS);
986 return true;
987 }
Chris Lattner019f4e82008-10-06 05:28:25 +0000988 }
989}
990
Daniel Dunbar5db4b3f2008-10-16 03:51:50 +0000991bool FloatExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
Nuno Lopesa468d342008-11-19 17:44:31 +0000992 if (E->getOpcode() == UnaryOperator::Deref)
993 return false;
994
Daniel Dunbar5db4b3f2008-10-16 03:51:50 +0000995 if (!EvaluateFloat(E->getSubExpr(), Result, Info))
996 return false;
997
998 switch (E->getOpcode()) {
999 default: return false;
1000 case UnaryOperator::Plus:
1001 return true;
1002 case UnaryOperator::Minus:
1003 Result.changeSign();
1004 return true;
1005 }
1006}
Chris Lattner019f4e82008-10-06 05:28:25 +00001007
Eli Friedmand8bfe7f2008-08-22 00:06:13 +00001008bool FloatExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
1009 // FIXME: Diagnostics? I really don't understand how the warnings
1010 // and errors are supposed to work.
Daniel Dunbar5db4b3f2008-10-16 03:51:50 +00001011 APFloat RHS(0.0);
Eli Friedmand8bfe7f2008-08-22 00:06:13 +00001012 if (!EvaluateFloat(E->getLHS(), Result, Info))
1013 return false;
1014 if (!EvaluateFloat(E->getRHS(), RHS, Info))
1015 return false;
1016
1017 switch (E->getOpcode()) {
1018 default: return false;
1019 case BinaryOperator::Mul:
1020 Result.multiply(RHS, APFloat::rmNearestTiesToEven);
1021 return true;
1022 case BinaryOperator::Add:
1023 Result.add(RHS, APFloat::rmNearestTiesToEven);
1024 return true;
1025 case BinaryOperator::Sub:
1026 Result.subtract(RHS, APFloat::rmNearestTiesToEven);
1027 return true;
1028 case BinaryOperator::Div:
1029 Result.divide(RHS, APFloat::rmNearestTiesToEven);
1030 return true;
1031 case BinaryOperator::Rem:
1032 Result.mod(RHS, APFloat::rmNearestTiesToEven);
1033 return true;
1034 }
1035}
1036
1037bool FloatExprEvaluator::VisitFloatingLiteral(const FloatingLiteral *E) {
1038 Result = E->getValue();
1039 return true;
1040}
1041
Eli Friedman4efaa272008-11-12 09:44:48 +00001042bool FloatExprEvaluator::VisitCastExpr(CastExpr *E) {
1043 Expr* SubExpr = E->getSubExpr();
1044 const llvm::fltSemantics& destSemantics =
1045 Info.Ctx.getFloatTypeSemantics(E->getType());
1046 if (SubExpr->getType()->isIntegralType()) {
1047 APSInt IntResult;
1048 if (!EvaluateInteger(E, IntResult, Info))
1049 return false;
1050 Result = APFloat(destSemantics, 1);
1051 Result.convertFromAPInt(IntResult, IntResult.isSigned(),
1052 APFloat::rmNearestTiesToEven);
1053 return true;
1054 }
1055 if (SubExpr->getType()->isRealFloatingType()) {
1056 if (!Visit(SubExpr))
1057 return false;
1058 bool ignored;
1059 Result.convert(destSemantics, APFloat::rmNearestTiesToEven, &ignored);
1060 return true;
1061 }
1062
1063 return false;
1064}
1065
1066bool FloatExprEvaluator::VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) {
1067 Result = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(E->getType()));
1068 return true;
1069}
1070
Eli Friedmand8bfe7f2008-08-22 00:06:13 +00001071//===----------------------------------------------------------------------===//
Anders Carlsson9ad16ae2008-11-16 20:27:53 +00001072// Complex Float Evaluation
1073//===----------------------------------------------------------------------===//
1074
1075namespace {
1076class VISIBILITY_HIDDEN ComplexFloatExprEvaluator
1077 : public StmtVisitor<ComplexFloatExprEvaluator, APValue> {
1078 EvalInfo &Info;
1079
1080public:
1081 ComplexFloatExprEvaluator(EvalInfo &info) : Info(info) {}
1082
1083 //===--------------------------------------------------------------------===//
1084 // Visitor Methods
1085 //===--------------------------------------------------------------------===//
1086
1087 APValue VisitStmt(Stmt *S) {
Anders Carlsson9ad16ae2008-11-16 20:27:53 +00001088 return APValue();
1089 }
1090
1091 APValue VisitParenExpr(ParenExpr *E) { return Visit(E->getSubExpr()); }
1092
1093 APValue VisitImaginaryLiteral(ImaginaryLiteral *E) {
1094 APFloat Result(0.0);
1095 if (!EvaluateFloat(E->getSubExpr(), Result, Info))
1096 return APValue();
1097
1098 return APValue(APFloat(0.0), Result);
1099 }
1100
Anders Carlssonccc3fce2008-11-16 21:51:21 +00001101 APValue VisitCastExpr(CastExpr *E) {
1102 Expr* SubExpr = E->getSubExpr();
1103
1104 if (SubExpr->getType()->isRealFloatingType()) {
1105 APFloat Result(0.0);
1106
1107 if (!EvaluateFloat(SubExpr, Result, Info))
1108 return APValue();
1109
1110 return APValue(Result, APFloat(0.0));
1111 }
1112
1113 // FIXME: Handle more casts.
1114 return APValue();
1115 }
1116
1117 APValue VisitBinaryOperator(const BinaryOperator *E);
1118
Anders Carlsson9ad16ae2008-11-16 20:27:53 +00001119};
1120} // end anonymous namespace
1121
1122static bool EvaluateComplexFloat(const Expr *E, APValue &Result, EvalInfo &Info)
1123{
1124 Result = ComplexFloatExprEvaluator(Info).Visit(const_cast<Expr*>(E));
1125 return Result.isComplexFloat();
1126}
1127
Anders Carlssonccc3fce2008-11-16 21:51:21 +00001128APValue ComplexFloatExprEvaluator::VisitBinaryOperator(const BinaryOperator *E)
1129{
1130 APValue Result, RHS;
1131
1132 if (!EvaluateComplexFloat(E->getLHS(), Result, Info))
1133 return APValue();
1134
1135 if (!EvaluateComplexFloat(E->getRHS(), RHS, Info))
1136 return APValue();
1137
1138 switch (E->getOpcode()) {
1139 default: return APValue();
1140 case BinaryOperator::Add:
1141 Result.getComplexFloatReal().add(RHS.getComplexFloatReal(),
1142 APFloat::rmNearestTiesToEven);
1143 Result.getComplexFloatImag().add(RHS.getComplexFloatImag(),
1144 APFloat::rmNearestTiesToEven);
1145 case BinaryOperator::Sub:
1146 Result.getComplexFloatReal().subtract(RHS.getComplexFloatReal(),
1147 APFloat::rmNearestTiesToEven);
1148 Result.getComplexFloatImag().subtract(RHS.getComplexFloatImag(),
1149 APFloat::rmNearestTiesToEven);
1150 }
1151
1152 return Result;
1153}
1154
Anders Carlsson9ad16ae2008-11-16 20:27:53 +00001155//===----------------------------------------------------------------------===//
Chris Lattner6ee7aa12008-11-16 21:24:15 +00001156// Top level Expr::Evaluate method.
Chris Lattnerf5eeb052008-07-11 18:11:29 +00001157//===----------------------------------------------------------------------===//
1158
Chris Lattner6ee7aa12008-11-16 21:24:15 +00001159/// Evaluate - Return true if this is a constant which we can fold using
Chris Lattner019f4e82008-10-06 05:28:25 +00001160/// any crazy technique (that has nothing to do with language standards) that
1161/// we want to. If this function returns true, it returns the folded constant
1162/// in Result.
Anders Carlsson5b45d4e2008-11-30 16:58:53 +00001163bool Expr::Evaluate(EvalResult &Result, ASTContext &Ctx) const {
1164 EvalInfo Info(Ctx, Result);
Anders Carlsson54da0492008-11-30 16:38:33 +00001165
Anders Carlsson06a36752008-07-08 05:49:43 +00001166 if (getType()->isIntegerType()) {
Eli Friedmand8bfe7f2008-08-22 00:06:13 +00001167 llvm::APSInt sInt(32);
Anders Carlsson6dde0d52008-11-22 21:50:49 +00001168 if (!EvaluateInteger(this, sInt, Info))
1169 return false;
1170
Anders Carlsson5b45d4e2008-11-30 16:58:53 +00001171 Result.Val = APValue(sInt);
Eli Friedmand8bfe7f2008-08-22 00:06:13 +00001172 } else if (getType()->isPointerType()) {
Anders Carlsson5b45d4e2008-11-30 16:58:53 +00001173 if (!EvaluatePointer(this, Result.Val, Info))
Anders Carlsson6dde0d52008-11-22 21:50:49 +00001174 return false;
Eli Friedmand8bfe7f2008-08-22 00:06:13 +00001175 } else if (getType()->isRealFloatingType()) {
1176 llvm::APFloat f(0.0);
Anders Carlsson6dde0d52008-11-22 21:50:49 +00001177 if (!EvaluateFloat(this, f, Info))
1178 return false;
1179
Anders Carlsson5b45d4e2008-11-30 16:58:53 +00001180 Result.Val = APValue(f);
Anders Carlsson9ad16ae2008-11-16 20:27:53 +00001181 } else if (getType()->isComplexType()) {
Anders Carlsson5b45d4e2008-11-30 16:58:53 +00001182 if (!EvaluateComplexFloat(this, Result.Val, Info))
Anders Carlsson6dde0d52008-11-22 21:50:49 +00001183 return false;
Anders Carlsson9d4c1572008-11-22 22:56:32 +00001184 } else
1185 return false;
Anders Carlsson6dde0d52008-11-22 21:50:49 +00001186
Anders Carlsson5b45d4e2008-11-30 16:58:53 +00001187 return true;
1188}
1189
1190bool Expr::Evaluate(APValue &Result, ASTContext &Ctx, bool *isEvaluated) const {
1191 EvalResult EvalResult;
1192
1193 if (!Evaluate(EvalResult, Ctx))
1194 return false;
1195
1196 Result = EvalResult.Val;
Anders Carlsson6dde0d52008-11-22 21:50:49 +00001197 if (isEvaluated)
Anders Carlssonfcb4d092008-11-30 16:51:17 +00001198 *isEvaluated = !EvalResult.HasSideEffects;
Anders Carlsson5b45d4e2008-11-30 16:58:53 +00001199
Anders Carlsson6dde0d52008-11-22 21:50:49 +00001200 return true;
Anders Carlssonc44eec62008-07-03 04:20:39 +00001201}
Chris Lattner45b6b9d2008-10-06 06:49:02 +00001202
Chris Lattner6ee7aa12008-11-16 21:24:15 +00001203/// isEvaluatable - Call Evaluate to see if this expression can be constant
Chris Lattner45b6b9d2008-10-06 06:49:02 +00001204/// folded, but discard the result.
1205bool Expr::isEvaluatable(ASTContext &Ctx) const {
1206 APValue V;
Chris Lattner6ee7aa12008-11-16 21:24:15 +00001207 return Evaluate(V, Ctx);
Chris Lattner45b6b9d2008-10-06 06:49:02 +00001208}
Anders Carlsson51fe9962008-11-22 21:04:56 +00001209
1210APSInt Expr::EvaluateAsInt(ASTContext &Ctx) const {
1211 APValue V;
1212 bool Result = Evaluate(V, Ctx);
1213 assert(Result && "Could not evaluate expression");
1214 assert(V.isInt() && "Expression did not evaluate to integer");
1215
1216 return V.getInt();
1217}