blob: 3b288ec8b7fb8251a8a24e6c17dad76d74f66b28 [file] [log] [blame]
Chris Lattnere13042c2008-07-11 19:10:17 +00001//===--- ExprConstant.cpp - Expression Constant Evaluator -----------------===//
Anders Carlsson7a241ba2008-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"
Ken Dyck40775002010-01-11 17:06:35 +000016#include "clang/AST/CharUnits.h"
Anders Carlsson15b73de2009-07-18 19:43:29 +000017#include "clang/AST/RecordLayout.h"
Seo Sanghyeon1904f442008-07-08 07:23:12 +000018#include "clang/AST/StmtVisitor.h"
Douglas Gregor882211c2010-04-28 22:16:22 +000019#include "clang/AST/TypeLoc.h"
Chris Lattner60f36222009-01-29 05:15:15 +000020#include "clang/AST/ASTDiagnostic.h"
Douglas Gregor882211c2010-04-28 22:16:22 +000021#include "clang/AST/Expr.h"
Chris Lattner15ba9492009-06-14 01:54:56 +000022#include "clang/Basic/Builtins.h"
Anders Carlsson374b93d2008-07-08 05:49:43 +000023#include "clang/Basic/TargetInfo.h"
Mike Stumpb807c9c2009-05-30 14:43:18 +000024#include "llvm/ADT/SmallString.h"
Mike Stump2346cd22009-05-30 03:56:50 +000025#include <cstring>
26
Anders Carlsson7a241ba2008-07-03 04:20:39 +000027using namespace clang;
Chris Lattner05706e882008-07-11 18:11:29 +000028using llvm::APSInt;
Eli Friedman24c01542008-08-22 00:06:13 +000029using llvm::APFloat;
Anders Carlsson7a241ba2008-07-03 04:20:39 +000030
Chris Lattnercdf34e72008-07-11 22:52:41 +000031/// EvalInfo - This is a private struct used by the evaluator to capture
32/// information about a subexpression as it is folded. It retains information
33/// about the AST context, but also maintains information about the folded
34/// expression.
35///
36/// If an expression could be evaluated, it is still possible it is not a C
37/// "integer constant expression" or constant expression. If not, this struct
38/// captures information about how and why not.
39///
40/// One bit of information passed *into* the request for constant folding
41/// indicates whether the subexpression is "evaluated" or not according to C
42/// rules. For example, the RHS of (0 && foo()) is not evaluated. We can
43/// evaluate the expression regardless of what the RHS is, but C only allows
44/// certain things in certain situations.
45struct EvalInfo {
46 ASTContext &Ctx;
Mike Stump11289f42009-09-09 15:08:12 +000047
Anders Carlssonbd1df8e2008-11-30 16:38:33 +000048 /// EvalResult - Contains information about the evaluation.
49 Expr::EvalResult &EvalResult;
Anders Carlsson58620012008-11-30 18:26:25 +000050
John McCall95007602010-05-10 23:27:23 +000051 EvalInfo(ASTContext &ctx, Expr::EvalResult& evalresult)
52 : Ctx(ctx), EvalResult(evalresult) {}
Chris Lattnercdf34e72008-07-11 22:52:41 +000053};
54
John McCall93d91dc2010-05-07 17:22:02 +000055namespace {
56 struct ComplexValue {
57 private:
58 bool IsInt;
59
60 public:
61 APSInt IntReal, IntImag;
62 APFloat FloatReal, FloatImag;
63
64 ComplexValue() : FloatReal(APFloat::Bogus), FloatImag(APFloat::Bogus) {}
65
66 void makeComplexFloat() { IsInt = false; }
67 bool isComplexFloat() const { return !IsInt; }
68 APFloat &getComplexFloatReal() { return FloatReal; }
69 APFloat &getComplexFloatImag() { return FloatImag; }
70
71 void makeComplexInt() { IsInt = true; }
72 bool isComplexInt() const { return IsInt; }
73 APSInt &getComplexIntReal() { return IntReal; }
74 APSInt &getComplexIntImag() { return IntImag; }
75
76 void moveInto(APValue &v) {
77 if (isComplexFloat())
78 v = APValue(FloatReal, FloatImag);
79 else
80 v = APValue(IntReal, IntImag);
81 }
82 };
John McCall45d55e42010-05-07 21:00:08 +000083
84 struct LValue {
85 Expr *Base;
86 CharUnits Offset;
87
88 Expr *getLValueBase() { return Base; }
89 CharUnits getLValueOffset() { return Offset; }
90
91 void moveInto(APValue &v) {
92 v = APValue(Base, Offset);
93 }
94 };
John McCall93d91dc2010-05-07 17:22:02 +000095}
Chris Lattnercdf34e72008-07-11 22:52:41 +000096
John McCall45d55e42010-05-07 21:00:08 +000097static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info);
98static bool EvaluatePointer(const Expr *E, LValue &Result, EvalInfo &Info);
Chris Lattnercdf34e72008-07-11 22:52:41 +000099static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info);
Chris Lattner6c4d2552009-10-28 23:59:40 +0000100static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
101 EvalInfo &Info);
Eli Friedman24c01542008-08-22 00:06:13 +0000102static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info);
John McCall93d91dc2010-05-07 17:22:02 +0000103static bool EvaluateComplex(const Expr *E, ComplexValue &Res, EvalInfo &Info);
Chris Lattner05706e882008-07-11 18:11:29 +0000104
105//===----------------------------------------------------------------------===//
Eli Friedman9a156e52008-11-12 09:44:48 +0000106// Misc utilities
107//===----------------------------------------------------------------------===//
108
Abramo Bagnaraf8199452010-05-14 17:07:14 +0000109static bool IsGlobalLValue(const Expr* E) {
John McCall95007602010-05-10 23:27:23 +0000110 if (!E) return true;
111
112 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
113 if (isa<FunctionDecl>(DRE->getDecl()))
114 return true;
115 if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl()))
116 return VD->hasGlobalStorage();
117 return false;
118 }
119
120 if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(E))
121 return CLE->isFileScope();
122
123 return true;
124}
125
John McCall45d55e42010-05-07 21:00:08 +0000126static bool EvalPointerValueAsBool(LValue& Value, bool& Result) {
127 const Expr* Base = Value.Base;
Rafael Espindolaa1f9cc12010-05-07 15:18:43 +0000128
John McCalleb3e4f32010-05-07 21:34:32 +0000129 // A null base expression indicates a null pointer. These are always
130 // evaluatable, and they are false unless the offset is zero.
131 if (!Base) {
132 Result = !Value.Offset.isZero();
133 return true;
134 }
Rafael Espindolaa1f9cc12010-05-07 15:18:43 +0000135
John McCall95007602010-05-10 23:27:23 +0000136 // Require the base expression to be a global l-value.
Abramo Bagnaraf8199452010-05-14 17:07:14 +0000137 if (!IsGlobalLValue(Base)) return false;
John McCall95007602010-05-10 23:27:23 +0000138
John McCalleb3e4f32010-05-07 21:34:32 +0000139 // We have a non-null base expression. These are generally known to
140 // be true, but if it'a decl-ref to a weak symbol it can be null at
141 // runtime.
John McCalleb3e4f32010-05-07 21:34:32 +0000142 Result = true;
143
144 const DeclRefExpr* DeclRef = dyn_cast<DeclRefExpr>(Base);
Rafael Espindolaa1f9cc12010-05-07 15:18:43 +0000145 if (!DeclRef)
146 return true;
147
John McCalleb3e4f32010-05-07 21:34:32 +0000148 // If it's a weak symbol, it isn't constant-evaluable.
Rafael Espindolaa1f9cc12010-05-07 15:18:43 +0000149 const ValueDecl* Decl = DeclRef->getDecl();
150 if (Decl->hasAttr<WeakAttr>() ||
151 Decl->hasAttr<WeakRefAttr>() ||
152 Decl->hasAttr<WeakImportAttr>())
153 return false;
154
Eli Friedman334046a2009-06-14 02:17:33 +0000155 return true;
156}
157
John McCall1be1c632010-01-05 23:42:56 +0000158static bool HandleConversionToBool(const Expr* E, bool& Result,
159 EvalInfo &Info) {
Douglas Gregorb90df602010-06-16 00:17:44 +0000160 if (E->getType()->isIntegralOrEnumerationType()) {
Eli Friedman9a156e52008-11-12 09:44:48 +0000161 APSInt IntResult;
162 if (!EvaluateInteger(E, IntResult, Info))
163 return false;
164 Result = IntResult != 0;
165 return true;
166 } else if (E->getType()->isRealFloatingType()) {
167 APFloat FloatResult(0.0);
168 if (!EvaluateFloat(E, FloatResult, Info))
169 return false;
170 Result = !FloatResult.isZero();
171 return true;
Eli Friedman64004332009-03-23 04:38:34 +0000172 } else if (E->getType()->hasPointerRepresentation()) {
John McCall45d55e42010-05-07 21:00:08 +0000173 LValue PointerResult;
Eli Friedman9a156e52008-11-12 09:44:48 +0000174 if (!EvaluatePointer(E, PointerResult, Info))
175 return false;
Eli Friedman334046a2009-06-14 02:17:33 +0000176 return EvalPointerValueAsBool(PointerResult, Result);
Eli Friedman64004332009-03-23 04:38:34 +0000177 } else if (E->getType()->isAnyComplexType()) {
John McCall93d91dc2010-05-07 17:22:02 +0000178 ComplexValue ComplexResult;
Eli Friedman64004332009-03-23 04:38:34 +0000179 if (!EvaluateComplex(E, ComplexResult, Info))
180 return false;
181 if (ComplexResult.isComplexFloat()) {
182 Result = !ComplexResult.getComplexFloatReal().isZero() ||
183 !ComplexResult.getComplexFloatImag().isZero();
184 } else {
185 Result = ComplexResult.getComplexIntReal().getBoolValue() ||
186 ComplexResult.getComplexIntImag().getBoolValue();
187 }
188 return true;
Eli Friedman9a156e52008-11-12 09:44:48 +0000189 }
190
191 return false;
192}
193
Mike Stump11289f42009-09-09 15:08:12 +0000194static APSInt HandleFloatToIntCast(QualType DestType, QualType SrcType,
Daniel Dunbarb6f953e2009-01-29 06:16:07 +0000195 APFloat &Value, ASTContext &Ctx) {
196 unsigned DestWidth = Ctx.getIntWidth(DestType);
197 // Determine whether we are converting to unsigned or signed.
198 bool DestSigned = DestType->isSignedIntegerType();
Mike Stump11289f42009-09-09 15:08:12 +0000199
Daniel Dunbarb6f953e2009-01-29 06:16:07 +0000200 // FIXME: Warning for overflow.
201 uint64_t Space[4];
202 bool ignored;
203 (void)Value.convertToInteger(Space, DestWidth, DestSigned,
204 llvm::APFloat::rmTowardZero, &ignored);
205 return APSInt(llvm::APInt(DestWidth, 4, Space), !DestSigned);
206}
207
Mike Stump11289f42009-09-09 15:08:12 +0000208static APFloat HandleFloatToFloatCast(QualType DestType, QualType SrcType,
Daniel Dunbarb6f953e2009-01-29 06:16:07 +0000209 APFloat &Value, ASTContext &Ctx) {
210 bool ignored;
211 APFloat Result = Value;
Mike Stump11289f42009-09-09 15:08:12 +0000212 Result.convert(Ctx.getFloatTypeSemantics(DestType),
Daniel Dunbarb6f953e2009-01-29 06:16:07 +0000213 APFloat::rmNearestTiesToEven, &ignored);
214 return Result;
215}
216
Mike Stump11289f42009-09-09 15:08:12 +0000217static APSInt HandleIntToIntCast(QualType DestType, QualType SrcType,
Daniel Dunbarb6f953e2009-01-29 06:16:07 +0000218 APSInt &Value, ASTContext &Ctx) {
219 unsigned DestWidth = Ctx.getIntWidth(DestType);
220 APSInt Result = Value;
221 // Figure out if this is a truncate, extend or noop cast.
222 // If the input is signed, do a sign extend, noop, or truncate.
223 Result.extOrTrunc(DestWidth);
224 Result.setIsUnsigned(DestType->isUnsignedIntegerType());
225 return Result;
226}
227
Mike Stump11289f42009-09-09 15:08:12 +0000228static APFloat HandleIntToFloatCast(QualType DestType, QualType SrcType,
Daniel Dunbarb6f953e2009-01-29 06:16:07 +0000229 APSInt &Value, ASTContext &Ctx) {
230
231 APFloat Result(Ctx.getFloatTypeSemantics(DestType), 1);
232 Result.convertFromAPInt(Value, Value.isSigned(),
233 APFloat::rmNearestTiesToEven);
234 return Result;
235}
236
Mike Stump876387b2009-10-27 22:09:17 +0000237namespace {
Benjamin Kramer26222b62009-11-28 19:03:38 +0000238class HasSideEffect
Mike Stump876387b2009-10-27 22:09:17 +0000239 : public StmtVisitor<HasSideEffect, bool> {
240 EvalInfo &Info;
241public:
242
243 HasSideEffect(EvalInfo &info) : Info(info) {}
244
245 // Unhandled nodes conservatively default to having side effects.
246 bool VisitStmt(Stmt *S) {
247 return true;
248 }
249
250 bool VisitParenExpr(ParenExpr *E) { return Visit(E->getSubExpr()); }
251 bool VisitDeclRefExpr(DeclRefExpr *E) {
Mike Stump53f9ded2009-11-03 23:25:48 +0000252 if (Info.Ctx.getCanonicalType(E->getType()).isVolatileQualified())
Mike Stump876387b2009-10-27 22:09:17 +0000253 return true;
254 return false;
255 }
256 // We don't want to evaluate BlockExprs multiple times, as they generate
257 // a ton of code.
258 bool VisitBlockExpr(BlockExpr *E) { return true; }
259 bool VisitPredefinedExpr(PredefinedExpr *E) { return false; }
260 bool VisitCompoundLiteralExpr(CompoundLiteralExpr *E)
261 { return Visit(E->getInitializer()); }
262 bool VisitMemberExpr(MemberExpr *E) { return Visit(E->getBase()); }
263 bool VisitIntegerLiteral(IntegerLiteral *E) { return false; }
264 bool VisitFloatingLiteral(FloatingLiteral *E) { return false; }
265 bool VisitStringLiteral(StringLiteral *E) { return false; }
266 bool VisitCharacterLiteral(CharacterLiteral *E) { return false; }
267 bool VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { return false; }
268 bool VisitArraySubscriptExpr(ArraySubscriptExpr *E)
Mike Stumpfa502902009-10-29 20:48:09 +0000269 { return Visit(E->getLHS()) || Visit(E->getRHS()); }
Mike Stump876387b2009-10-27 22:09:17 +0000270 bool VisitChooseExpr(ChooseExpr *E)
271 { return Visit(E->getChosenSubExpr(Info.Ctx)); }
272 bool VisitCastExpr(CastExpr *E) { return Visit(E->getSubExpr()); }
273 bool VisitBinAssign(BinaryOperator *E) { return true; }
Mike Stumpf3eb5ec2009-10-29 23:34:20 +0000274 bool VisitCompoundAssignOperator(BinaryOperator *E) { return true; }
Mike Stumpfa502902009-10-29 20:48:09 +0000275 bool VisitBinaryOperator(BinaryOperator *E)
276 { return Visit(E->getLHS()) || Visit(E->getRHS()); }
Mike Stump876387b2009-10-27 22:09:17 +0000277 bool VisitUnaryPreInc(UnaryOperator *E) { return true; }
278 bool VisitUnaryPostInc(UnaryOperator *E) { return true; }
279 bool VisitUnaryPreDec(UnaryOperator *E) { return true; }
280 bool VisitUnaryPostDec(UnaryOperator *E) { return true; }
281 bool VisitUnaryDeref(UnaryOperator *E) {
Mike Stump53f9ded2009-11-03 23:25:48 +0000282 if (Info.Ctx.getCanonicalType(E->getType()).isVolatileQualified())
Mike Stump876387b2009-10-27 22:09:17 +0000283 return true;
Mike Stumpfa502902009-10-29 20:48:09 +0000284 return Visit(E->getSubExpr());
Mike Stump876387b2009-10-27 22:09:17 +0000285 }
286 bool VisitUnaryOperator(UnaryOperator *E) { return Visit(E->getSubExpr()); }
Chris Lattnera0679422010-04-13 17:34:23 +0000287
288 // Has side effects if any element does.
289 bool VisitInitListExpr(InitListExpr *E) {
290 for (unsigned i = 0, e = E->getNumInits(); i != e; ++i)
291 if (Visit(E->getInit(i))) return true;
292 return false;
293 }
Mike Stump876387b2009-10-27 22:09:17 +0000294};
295
Mike Stump876387b2009-10-27 22:09:17 +0000296} // end anonymous namespace
297
Eli Friedman9a156e52008-11-12 09:44:48 +0000298//===----------------------------------------------------------------------===//
299// LValue Evaluation
300//===----------------------------------------------------------------------===//
301namespace {
Benjamin Kramer26222b62009-11-28 19:03:38 +0000302class LValueExprEvaluator
John McCall45d55e42010-05-07 21:00:08 +0000303 : public StmtVisitor<LValueExprEvaluator, bool> {
Eli Friedman9a156e52008-11-12 09:44:48 +0000304 EvalInfo &Info;
John McCall45d55e42010-05-07 21:00:08 +0000305 LValue &Result;
306
307 bool Success(Expr *E) {
308 Result.Base = E;
309 Result.Offset = CharUnits::Zero();
310 return true;
311 }
Eli Friedman9a156e52008-11-12 09:44:48 +0000312public:
Mike Stump11289f42009-09-09 15:08:12 +0000313
John McCall45d55e42010-05-07 21:00:08 +0000314 LValueExprEvaluator(EvalInfo &info, LValue &Result) :
315 Info(info), Result(Result) {}
Eli Friedman9a156e52008-11-12 09:44:48 +0000316
John McCall45d55e42010-05-07 21:00:08 +0000317 bool VisitStmt(Stmt *S) {
318 return false;
Eli Friedman9a156e52008-11-12 09:44:48 +0000319 }
Douglas Gregor882211c2010-04-28 22:16:22 +0000320
John McCall45d55e42010-05-07 21:00:08 +0000321 bool VisitParenExpr(ParenExpr *E) { return Visit(E->getSubExpr()); }
322 bool VisitDeclRefExpr(DeclRefExpr *E);
323 bool VisitPredefinedExpr(PredefinedExpr *E) { return Success(E); }
324 bool VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
325 bool VisitMemberExpr(MemberExpr *E);
326 bool VisitStringLiteral(StringLiteral *E) { return Success(E); }
327 bool VisitObjCEncodeExpr(ObjCEncodeExpr *E) { return Success(E); }
328 bool VisitArraySubscriptExpr(ArraySubscriptExpr *E);
329 bool VisitUnaryDeref(UnaryOperator *E);
330 bool VisitUnaryExtension(const UnaryOperator *E)
Eli Friedman449fe542009-03-23 04:56:01 +0000331 { return Visit(E->getSubExpr()); }
John McCall45d55e42010-05-07 21:00:08 +0000332 bool VisitChooseExpr(const ChooseExpr *E)
Eli Friedman449fe542009-03-23 04:56:01 +0000333 { return Visit(E->getChosenSubExpr(Info.Ctx)); }
Anders Carlssonde55f642009-10-03 16:30:22 +0000334
John McCall45d55e42010-05-07 21:00:08 +0000335 bool VisitCastExpr(CastExpr *E) {
Anders Carlssonde55f642009-10-03 16:30:22 +0000336 switch (E->getCastKind()) {
337 default:
John McCall45d55e42010-05-07 21:00:08 +0000338 return false;
Anders Carlssonde55f642009-10-03 16:30:22 +0000339
340 case CastExpr::CK_NoOp:
341 return Visit(E->getSubExpr());
342 }
343 }
Eli Friedman449fe542009-03-23 04:56:01 +0000344 // FIXME: Missing: __real__, __imag__
Eli Friedman9a156e52008-11-12 09:44:48 +0000345};
346} // end anonymous namespace
347
John McCall45d55e42010-05-07 21:00:08 +0000348static bool EvaluateLValue(const Expr* E, LValue& Result, EvalInfo &Info) {
349 return LValueExprEvaluator(Info, Result).Visit(const_cast<Expr*>(E));
Eli Friedman9a156e52008-11-12 09:44:48 +0000350}
351
John McCall45d55e42010-05-07 21:00:08 +0000352bool LValueExprEvaluator::VisitDeclRefExpr(DeclRefExpr *E) {
Eli Friedman751aa72b72009-05-27 06:04:58 +0000353 if (isa<FunctionDecl>(E->getDecl())) {
John McCall45d55e42010-05-07 21:00:08 +0000354 return Success(E);
Eli Friedman751aa72b72009-05-27 06:04:58 +0000355 } else if (VarDecl* VD = dyn_cast<VarDecl>(E->getDecl())) {
356 if (!VD->getType()->isReferenceType())
John McCall45d55e42010-05-07 21:00:08 +0000357 return Success(E);
Chandler Carruthe299ba62010-05-16 09:32:51 +0000358 // Reference parameters can refer to anything even if they have an
359 // "initializer" in the form of a default argument.
360 if (isa<ParmVarDecl>(VD))
361 return false;
Eli Friedman9ab03192009-08-29 19:09:59 +0000362 // FIXME: Check whether VD might be overridden!
Sebastian Redl5ca79842010-02-01 20:16:42 +0000363 if (const Expr *Init = VD->getAnyInitializer())
Douglas Gregor0840cc02009-11-01 20:32:48 +0000364 return Visit(const_cast<Expr *>(Init));
Eli Friedman751aa72b72009-05-27 06:04:58 +0000365 }
366
John McCall45d55e42010-05-07 21:00:08 +0000367 return false;
Anders Carlssona42ee442008-11-24 04:41:22 +0000368}
369
John McCall45d55e42010-05-07 21:00:08 +0000370bool LValueExprEvaluator::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
John McCall45d55e42010-05-07 21:00:08 +0000371 return Success(E);
Eli Friedman9a156e52008-11-12 09:44:48 +0000372}
373
John McCall45d55e42010-05-07 21:00:08 +0000374bool LValueExprEvaluator::VisitMemberExpr(MemberExpr *E) {
Eli Friedman9a156e52008-11-12 09:44:48 +0000375 QualType Ty;
376 if (E->isArrow()) {
John McCall45d55e42010-05-07 21:00:08 +0000377 if (!EvaluatePointer(E->getBase(), Result, Info))
378 return false;
Ted Kremenekc23c7e62009-07-29 21:53:49 +0000379 Ty = E->getBase()->getType()->getAs<PointerType>()->getPointeeType();
Eli Friedman9a156e52008-11-12 09:44:48 +0000380 } else {
John McCall45d55e42010-05-07 21:00:08 +0000381 if (!Visit(E->getBase()))
382 return false;
Eli Friedman9a156e52008-11-12 09:44:48 +0000383 Ty = E->getBase()->getType();
384 }
385
Ted Kremenekc23c7e62009-07-29 21:53:49 +0000386 RecordDecl *RD = Ty->getAs<RecordType>()->getDecl();
Eli Friedman9a156e52008-11-12 09:44:48 +0000387 const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
Douglas Gregor2eedc3a2008-12-20 23:49:58 +0000388
389 FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl());
390 if (!FD) // FIXME: deal with other kinds of member expressions
John McCall45d55e42010-05-07 21:00:08 +0000391 return false;
Eli Friedmanf7f9f682009-05-30 21:09:44 +0000392
393 if (FD->getType()->isReferenceType())
John McCall45d55e42010-05-07 21:00:08 +0000394 return false;
Eli Friedmanf7f9f682009-05-30 21:09:44 +0000395
Eli Friedman9a156e52008-11-12 09:44:48 +0000396 // FIXME: This is linear time.
Douglas Gregor91f84212008-12-11 16:49:14 +0000397 unsigned i = 0;
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +0000398 for (RecordDecl::field_iterator Field = RD->field_begin(),
399 FieldEnd = RD->field_end();
Douglas Gregor91f84212008-12-11 16:49:14 +0000400 Field != FieldEnd; (void)++Field, ++i) {
401 if (*Field == FD)
Eli Friedman9a156e52008-11-12 09:44:48 +0000402 break;
403 }
404
John McCall45d55e42010-05-07 21:00:08 +0000405 Result.Offset += CharUnits::fromQuantity(RL.getFieldOffset(i) / 8);
406 return true;
Eli Friedman9a156e52008-11-12 09:44:48 +0000407}
408
John McCall45d55e42010-05-07 21:00:08 +0000409bool LValueExprEvaluator::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
Anders Carlsson9f9e4242008-11-16 19:01:22 +0000410 if (!EvaluatePointer(E->getBase(), Result, Info))
John McCall45d55e42010-05-07 21:00:08 +0000411 return false;
Mike Stump11289f42009-09-09 15:08:12 +0000412
Anders Carlsson9f9e4242008-11-16 19:01:22 +0000413 APSInt Index;
414 if (!EvaluateInteger(E->getIdx(), Index, Info))
John McCall45d55e42010-05-07 21:00:08 +0000415 return false;
Anders Carlsson9f9e4242008-11-16 19:01:22 +0000416
Ken Dyck40775002010-01-11 17:06:35 +0000417 CharUnits ElementSize = Info.Ctx.getTypeSizeInChars(E->getType());
John McCall45d55e42010-05-07 21:00:08 +0000418 Result.Offset += Index.getSExtValue() * ElementSize;
419 return true;
Anders Carlsson9f9e4242008-11-16 19:01:22 +0000420}
Eli Friedman9a156e52008-11-12 09:44:48 +0000421
John McCall45d55e42010-05-07 21:00:08 +0000422bool LValueExprEvaluator::VisitUnaryDeref(UnaryOperator *E) {
423 return EvaluatePointer(E->getSubExpr(), Result, Info);
Eli Friedman0b8337c2009-02-20 01:57:15 +0000424}
425
Eli Friedman9a156e52008-11-12 09:44:48 +0000426//===----------------------------------------------------------------------===//
Chris Lattner05706e882008-07-11 18:11:29 +0000427// Pointer Evaluation
428//===----------------------------------------------------------------------===//
429
Anders Carlsson0a1707c2008-07-08 05:13:58 +0000430namespace {
Benjamin Kramer26222b62009-11-28 19:03:38 +0000431class PointerExprEvaluator
John McCall45d55e42010-05-07 21:00:08 +0000432 : public StmtVisitor<PointerExprEvaluator, bool> {
Chris Lattnercdf34e72008-07-11 22:52:41 +0000433 EvalInfo &Info;
John McCall45d55e42010-05-07 21:00:08 +0000434 LValue &Result;
435
436 bool Success(Expr *E) {
437 Result.Base = E;
438 Result.Offset = CharUnits::Zero();
439 return true;
440 }
Anders Carlssonb5ad0212008-07-08 14:30:00 +0000441public:
Mike Stump11289f42009-09-09 15:08:12 +0000442
John McCall45d55e42010-05-07 21:00:08 +0000443 PointerExprEvaluator(EvalInfo &info, LValue &Result)
444 : Info(info), Result(Result) {}
Chris Lattner05706e882008-07-11 18:11:29 +0000445
John McCall45d55e42010-05-07 21:00:08 +0000446 bool VisitStmt(Stmt *S) {
447 return false;
Anders Carlssonb5ad0212008-07-08 14:30:00 +0000448 }
449
John McCall45d55e42010-05-07 21:00:08 +0000450 bool VisitParenExpr(ParenExpr *E) { return Visit(E->getSubExpr()); }
Anders Carlssonb5ad0212008-07-08 14:30:00 +0000451
John McCall45d55e42010-05-07 21:00:08 +0000452 bool VisitBinaryOperator(const BinaryOperator *E);
453 bool VisitCastExpr(CastExpr* E);
454 bool VisitUnaryExtension(const UnaryOperator *E)
Eli Friedmanc2b50172009-02-22 11:46:18 +0000455 { return Visit(E->getSubExpr()); }
John McCall45d55e42010-05-07 21:00:08 +0000456 bool VisitUnaryAddrOf(const UnaryOperator *E);
457 bool VisitObjCStringLiteral(ObjCStringLiteral *E)
458 { return Success(E); }
459 bool VisitAddrLabelExpr(AddrLabelExpr *E)
460 { return Success(E); }
461 bool VisitCallExpr(CallExpr *E);
462 bool VisitBlockExpr(BlockExpr *E) {
Mike Stumpa6703322009-02-19 22:01:56 +0000463 if (!E->hasBlockDeclRefExprs())
John McCall45d55e42010-05-07 21:00:08 +0000464 return Success(E);
465 return false;
Mike Stumpa6703322009-02-19 22:01:56 +0000466 }
John McCall45d55e42010-05-07 21:00:08 +0000467 bool VisitImplicitValueInitExpr(ImplicitValueInitExpr *E)
468 { return Success((Expr*)0); }
469 bool VisitConditionalOperator(ConditionalOperator *E);
470 bool VisitChooseExpr(ChooseExpr *E)
Sebastian Redl576fd422009-05-10 18:38:11 +0000471 { return Visit(E->getChosenSubExpr(Info.Ctx)); }
John McCall45d55e42010-05-07 21:00:08 +0000472 bool VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E)
473 { return Success((Expr*)0); }
Eli Friedman449fe542009-03-23 04:56:01 +0000474 // FIXME: Missing: @protocol, @selector
Anders Carlsson4a3585b2008-07-08 15:34:11 +0000475};
Chris Lattner05706e882008-07-11 18:11:29 +0000476} // end anonymous namespace
Anders Carlsson4a3585b2008-07-08 15:34:11 +0000477
John McCall45d55e42010-05-07 21:00:08 +0000478static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info) {
John McCallf0c4f352010-05-07 05:46:35 +0000479 assert(E->getType()->hasPointerRepresentation());
John McCall45d55e42010-05-07 21:00:08 +0000480 return PointerExprEvaluator(Info, Result).Visit(const_cast<Expr*>(E));
Chris Lattner05706e882008-07-11 18:11:29 +0000481}
482
John McCall45d55e42010-05-07 21:00:08 +0000483bool PointerExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
Chris Lattner05706e882008-07-11 18:11:29 +0000484 if (E->getOpcode() != BinaryOperator::Add &&
485 E->getOpcode() != BinaryOperator::Sub)
John McCall45d55e42010-05-07 21:00:08 +0000486 return false;
Mike Stump11289f42009-09-09 15:08:12 +0000487
Chris Lattner05706e882008-07-11 18:11:29 +0000488 const Expr *PExp = E->getLHS();
489 const Expr *IExp = E->getRHS();
490 if (IExp->getType()->isPointerType())
491 std::swap(PExp, IExp);
Mike Stump11289f42009-09-09 15:08:12 +0000492
John McCall45d55e42010-05-07 21:00:08 +0000493 if (!EvaluatePointer(PExp, Result, Info))
494 return false;
Mike Stump11289f42009-09-09 15:08:12 +0000495
John McCall45d55e42010-05-07 21:00:08 +0000496 llvm::APSInt Offset;
497 if (!EvaluateInteger(IExp, Offset, Info))
498 return false;
499 int64_t AdditionalOffset
500 = Offset.isSigned() ? Offset.getSExtValue()
501 : static_cast<int64_t>(Offset.getZExtValue());
Chris Lattner05706e882008-07-11 18:11:29 +0000502
Daniel Dunbar4c43e312010-03-20 05:53:45 +0000503 // Compute the new offset in the appropriate width.
504
505 QualType PointeeType =
506 PExp->getType()->getAs<PointerType>()->getPointeeType();
John McCall45d55e42010-05-07 21:00:08 +0000507 CharUnits SizeOfPointee;
Mike Stump11289f42009-09-09 15:08:12 +0000508
Anders Carlssonef56fba2009-02-19 04:55:58 +0000509 // Explicitly handle GNU void* and function pointer arithmetic extensions.
510 if (PointeeType->isVoidType() || PointeeType->isFunctionType())
John McCall45d55e42010-05-07 21:00:08 +0000511 SizeOfPointee = CharUnits::One();
Anders Carlssonef56fba2009-02-19 04:55:58 +0000512 else
John McCall45d55e42010-05-07 21:00:08 +0000513 SizeOfPointee = Info.Ctx.getTypeSizeInChars(PointeeType);
Eli Friedman9a156e52008-11-12 09:44:48 +0000514
Chris Lattner05706e882008-07-11 18:11:29 +0000515 if (E->getOpcode() == BinaryOperator::Add)
John McCall45d55e42010-05-07 21:00:08 +0000516 Result.Offset += AdditionalOffset * SizeOfPointee;
Chris Lattner05706e882008-07-11 18:11:29 +0000517 else
John McCall45d55e42010-05-07 21:00:08 +0000518 Result.Offset -= AdditionalOffset * SizeOfPointee;
Eli Friedman9a156e52008-11-12 09:44:48 +0000519
John McCall45d55e42010-05-07 21:00:08 +0000520 return true;
Chris Lattner05706e882008-07-11 18:11:29 +0000521}
Eli Friedman9a156e52008-11-12 09:44:48 +0000522
John McCall45d55e42010-05-07 21:00:08 +0000523bool PointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) {
524 return EvaluateLValue(E->getSubExpr(), Result, Info);
Eli Friedman9a156e52008-11-12 09:44:48 +0000525}
Mike Stump11289f42009-09-09 15:08:12 +0000526
Chris Lattner05706e882008-07-11 18:11:29 +0000527
John McCall45d55e42010-05-07 21:00:08 +0000528bool PointerExprEvaluator::VisitCastExpr(CastExpr* E) {
Eli Friedman847a2bc2009-12-27 05:43:15 +0000529 Expr* SubExpr = E->getSubExpr();
Chris Lattner05706e882008-07-11 18:11:29 +0000530
Eli Friedman847a2bc2009-12-27 05:43:15 +0000531 switch (E->getCastKind()) {
532 default:
533 break;
534
535 case CastExpr::CK_Unknown: {
536 // FIXME: The handling for CK_Unknown is ugly/shouldn't be necessary!
537
538 // Check for pointer->pointer cast
539 if (SubExpr->getType()->isPointerType() ||
540 SubExpr->getType()->isObjCObjectPointerType() ||
541 SubExpr->getType()->isNullPtrType() ||
542 SubExpr->getType()->isBlockPointerType())
543 return Visit(SubExpr);
544
Douglas Gregorb90df602010-06-16 00:17:44 +0000545 if (SubExpr->getType()->isIntegralOrEnumerationType()) {
John McCall45d55e42010-05-07 21:00:08 +0000546 APValue Value;
547 if (!EvaluateIntegerOrLValue(SubExpr, Value, Info))
Eli Friedman847a2bc2009-12-27 05:43:15 +0000548 break;
549
John McCall45d55e42010-05-07 21:00:08 +0000550 if (Value.isInt()) {
551 Value.getInt().extOrTrunc((unsigned)Info.Ctx.getTypeSize(E->getType()));
552 Result.Base = 0;
553 Result.Offset = CharUnits::fromQuantity(Value.getInt().getZExtValue());
554 return true;
555 } else {
556 Result.Base = Value.getLValueBase();
557 Result.Offset = Value.getLValueOffset();
558 return true;
Eli Friedman847a2bc2009-12-27 05:43:15 +0000559 }
Eli Friedman847a2bc2009-12-27 05:43:15 +0000560 }
561 break;
Chris Lattner05706e882008-07-11 18:11:29 +0000562 }
Mike Stump11289f42009-09-09 15:08:12 +0000563
Eli Friedman847a2bc2009-12-27 05:43:15 +0000564 case CastExpr::CK_NoOp:
565 case CastExpr::CK_BitCast:
Douglas Gregor51954272010-07-13 23:17:26 +0000566 case CastExpr::CK_LValueBitCast:
Eli Friedman847a2bc2009-12-27 05:43:15 +0000567 case CastExpr::CK_AnyPointerToObjCPointerCast:
568 case CastExpr::CK_AnyPointerToBlockPointerCast:
569 return Visit(SubExpr);
570
571 case CastExpr::CK_IntegralToPointer: {
John McCall45d55e42010-05-07 21:00:08 +0000572 APValue Value;
573 if (!EvaluateIntegerOrLValue(SubExpr, Value, Info))
Eli Friedman847a2bc2009-12-27 05:43:15 +0000574 break;
Daniel Dunbarce399542009-02-20 18:22:23 +0000575
John McCall45d55e42010-05-07 21:00:08 +0000576 if (Value.isInt()) {
577 Value.getInt().extOrTrunc((unsigned)Info.Ctx.getTypeSize(E->getType()));
578 Result.Base = 0;
579 Result.Offset = CharUnits::fromQuantity(Value.getInt().getZExtValue());
580 return true;
581 } else {
582 // Cast is of an lvalue, no need to change value.
583 Result.Base = Value.getLValueBase();
584 Result.Offset = Value.getLValueOffset();
585 return true;
Chris Lattner05706e882008-07-11 18:11:29 +0000586 }
587 }
Eli Friedman847a2bc2009-12-27 05:43:15 +0000588 case CastExpr::CK_ArrayToPointerDecay:
John McCall45d55e42010-05-07 21:00:08 +0000589 case CastExpr::CK_FunctionToPointerDecay:
590 return EvaluateLValue(SubExpr, Result, Info);
Eli Friedman9a156e52008-11-12 09:44:48 +0000591 }
592
John McCall45d55e42010-05-07 21:00:08 +0000593 return false;
Mike Stump11289f42009-09-09 15:08:12 +0000594}
Chris Lattner05706e882008-07-11 18:11:29 +0000595
John McCall45d55e42010-05-07 21:00:08 +0000596bool PointerExprEvaluator::VisitCallExpr(CallExpr *E) {
Mike Stump11289f42009-09-09 15:08:12 +0000597 if (E->isBuiltinCall(Info.Ctx) ==
David Chisnall481e3a82010-01-23 02:40:42 +0000598 Builtin::BI__builtin___CFStringMakeConstantString ||
599 E->isBuiltinCall(Info.Ctx) ==
600 Builtin::BI__builtin___NSStringMakeConstantString)
John McCall45d55e42010-05-07 21:00:08 +0000601 return Success(E);
602 return false;
Eli Friedmanc69d4542009-01-25 01:54:01 +0000603}
604
John McCall45d55e42010-05-07 21:00:08 +0000605bool PointerExprEvaluator::VisitConditionalOperator(ConditionalOperator *E) {
Eli Friedman9a156e52008-11-12 09:44:48 +0000606 bool BoolResult;
607 if (!HandleConversionToBool(E->getCond(), BoolResult, Info))
John McCall45d55e42010-05-07 21:00:08 +0000608 return false;
Eli Friedman9a156e52008-11-12 09:44:48 +0000609
610 Expr* EvalExpr = BoolResult ? E->getTrueExpr() : E->getFalseExpr();
John McCall45d55e42010-05-07 21:00:08 +0000611 return Visit(EvalExpr);
Eli Friedman9a156e52008-11-12 09:44:48 +0000612}
Chris Lattner05706e882008-07-11 18:11:29 +0000613
614//===----------------------------------------------------------------------===//
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000615// Vector Evaluation
616//===----------------------------------------------------------------------===//
617
618namespace {
Benjamin Kramer26222b62009-11-28 19:03:38 +0000619 class VectorExprEvaluator
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000620 : public StmtVisitor<VectorExprEvaluator, APValue> {
621 EvalInfo &Info;
Eli Friedman3ae59112009-02-23 04:23:56 +0000622 APValue GetZeroVector(QualType VecType);
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000623 public:
Mike Stump11289f42009-09-09 15:08:12 +0000624
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000625 VectorExprEvaluator(EvalInfo &info) : Info(info) {}
Mike Stump11289f42009-09-09 15:08:12 +0000626
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000627 APValue VisitStmt(Stmt *S) {
628 return APValue();
629 }
Mike Stump11289f42009-09-09 15:08:12 +0000630
Eli Friedman3ae59112009-02-23 04:23:56 +0000631 APValue VisitParenExpr(ParenExpr *E)
632 { return Visit(E->getSubExpr()); }
633 APValue VisitUnaryExtension(const UnaryOperator *E)
634 { return Visit(E->getSubExpr()); }
635 APValue VisitUnaryPlus(const UnaryOperator *E)
636 { return Visit(E->getSubExpr()); }
637 APValue VisitUnaryReal(const UnaryOperator *E)
638 { return Visit(E->getSubExpr()); }
639 APValue VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E)
640 { return GetZeroVector(E->getType()); }
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000641 APValue VisitCastExpr(const CastExpr* E);
642 APValue VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
643 APValue VisitInitListExpr(const InitListExpr *E);
Eli Friedman3ae59112009-02-23 04:23:56 +0000644 APValue VisitConditionalOperator(const ConditionalOperator *E);
Eli Friedman449fe542009-03-23 04:56:01 +0000645 APValue VisitChooseExpr(const ChooseExpr *E)
646 { return Visit(E->getChosenSubExpr(Info.Ctx)); }
Eli Friedman3ae59112009-02-23 04:23:56 +0000647 APValue VisitUnaryImag(const UnaryOperator *E);
648 // FIXME: Missing: unary -, unary ~, binary add/sub/mul/div,
Eli Friedmanc2b50172009-02-22 11:46:18 +0000649 // binary comparisons, binary and/or/xor,
Eli Friedman3ae59112009-02-23 04:23:56 +0000650 // shufflevector, ExtVectorElementExpr
651 // (Note that these require implementing conversions
652 // between vector types.)
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000653 };
654} // end anonymous namespace
655
656static bool EvaluateVector(const Expr* E, APValue& Result, EvalInfo &Info) {
657 if (!E->getType()->isVectorType())
658 return false;
659 Result = VectorExprEvaluator(Info).Visit(const_cast<Expr*>(E));
660 return !Result.isUninit();
661}
662
663APValue VectorExprEvaluator::VisitCastExpr(const CastExpr* E) {
John McCall9dd450b2009-09-21 23:43:11 +0000664 const VectorType *VTy = E->getType()->getAs<VectorType>();
Nate Begemanef1a7fa2009-07-01 07:50:47 +0000665 QualType EltTy = VTy->getElementType();
666 unsigned NElts = VTy->getNumElements();
667 unsigned EltWidth = Info.Ctx.getTypeSize(EltTy);
Mike Stump11289f42009-09-09 15:08:12 +0000668
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000669 const Expr* SE = E->getSubExpr();
Nate Begeman2ffd3842009-06-26 18:22:18 +0000670 QualType SETy = SE->getType();
671 APValue Result = APValue();
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000672
Nate Begeman2ffd3842009-06-26 18:22:18 +0000673 // Check for vector->vector bitcast and scalar->vector splat.
674 if (SETy->isVectorType()) {
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000675 return this->Visit(const_cast<Expr*>(SE));
Nate Begeman2ffd3842009-06-26 18:22:18 +0000676 } else if (SETy->isIntegerType()) {
677 APSInt IntResult;
Daniel Dunbardf4a58e2009-07-01 20:37:45 +0000678 if (!EvaluateInteger(SE, IntResult, Info))
679 return APValue();
680 Result = APValue(IntResult);
Nate Begeman2ffd3842009-06-26 18:22:18 +0000681 } else if (SETy->isRealFloatingType()) {
682 APFloat F(0.0);
Daniel Dunbardf4a58e2009-07-01 20:37:45 +0000683 if (!EvaluateFloat(SE, F, Info))
684 return APValue();
685 Result = APValue(F);
686 } else
Nate Begemanef1a7fa2009-07-01 07:50:47 +0000687 return APValue();
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000688
Nate Begemanef1a7fa2009-07-01 07:50:47 +0000689 // For casts of a scalar to ExtVector, convert the scalar to the element type
690 // and splat it to all elements.
691 if (E->getType()->isExtVectorType()) {
692 if (EltTy->isIntegerType() && Result.isInt())
693 Result = APValue(HandleIntToIntCast(EltTy, SETy, Result.getInt(),
694 Info.Ctx));
695 else if (EltTy->isIntegerType())
696 Result = APValue(HandleFloatToIntCast(EltTy, SETy, Result.getFloat(),
697 Info.Ctx));
698 else if (EltTy->isRealFloatingType() && Result.isInt())
699 Result = APValue(HandleIntToFloatCast(EltTy, SETy, Result.getInt(),
700 Info.Ctx));
701 else if (EltTy->isRealFloatingType())
702 Result = APValue(HandleFloatToFloatCast(EltTy, SETy, Result.getFloat(),
703 Info.Ctx));
704 else
705 return APValue();
706
707 // Splat and create vector APValue.
708 llvm::SmallVector<APValue, 4> Elts(NElts, Result);
709 return APValue(&Elts[0], Elts.size());
Nate Begeman2ffd3842009-06-26 18:22:18 +0000710 }
Nate Begemanef1a7fa2009-07-01 07:50:47 +0000711
712 // For casts of a scalar to regular gcc-style vector type, bitcast the scalar
713 // to the vector. To construct the APValue vector initializer, bitcast the
714 // initializing value to an APInt, and shift out the bits pertaining to each
715 // element.
716 APSInt Init;
717 Init = Result.isInt() ? Result.getInt() : Result.getFloat().bitcastToAPInt();
Mike Stump11289f42009-09-09 15:08:12 +0000718
Nate Begemanef1a7fa2009-07-01 07:50:47 +0000719 llvm::SmallVector<APValue, 4> Elts;
720 for (unsigned i = 0; i != NElts; ++i) {
721 APSInt Tmp = Init;
722 Tmp.extOrTrunc(EltWidth);
Mike Stump11289f42009-09-09 15:08:12 +0000723
Nate Begemanef1a7fa2009-07-01 07:50:47 +0000724 if (EltTy->isIntegerType())
725 Elts.push_back(APValue(Tmp));
726 else if (EltTy->isRealFloatingType())
727 Elts.push_back(APValue(APFloat(Tmp)));
728 else
729 return APValue();
730
731 Init >>= EltWidth;
732 }
733 return APValue(&Elts[0], Elts.size());
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000734}
735
Mike Stump11289f42009-09-09 15:08:12 +0000736APValue
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000737VectorExprEvaluator::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
738 return this->Visit(const_cast<Expr*>(E->getInitializer()));
739}
740
Mike Stump11289f42009-09-09 15:08:12 +0000741APValue
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000742VectorExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
John McCall9dd450b2009-09-21 23:43:11 +0000743 const VectorType *VT = E->getType()->getAs<VectorType>();
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000744 unsigned NumInits = E->getNumInits();
Eli Friedman3ae59112009-02-23 04:23:56 +0000745 unsigned NumElements = VT->getNumElements();
Mike Stump11289f42009-09-09 15:08:12 +0000746
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000747 QualType EltTy = VT->getElementType();
748 llvm::SmallVector<APValue, 4> Elements;
749
John McCall875679e2010-06-11 17:54:15 +0000750 // If a vector is initialized with a single element, that value
751 // becomes every element of the vector, not just the first.
752 // This is the behavior described in the IBM AltiVec documentation.
753 if (NumInits == 1) {
754 APValue InitValue;
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000755 if (EltTy->isIntegerType()) {
756 llvm::APSInt sInt(32);
John McCall875679e2010-06-11 17:54:15 +0000757 if (!EvaluateInteger(E->getInit(0), sInt, Info))
758 return APValue();
759 InitValue = APValue(sInt);
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000760 } else {
761 llvm::APFloat f(0.0);
John McCall875679e2010-06-11 17:54:15 +0000762 if (!EvaluateFloat(E->getInit(0), f, Info))
763 return APValue();
764 InitValue = APValue(f);
765 }
766 for (unsigned i = 0; i < NumElements; i++) {
767 Elements.push_back(InitValue);
768 }
769 } else {
770 for (unsigned i = 0; i < NumElements; i++) {
771 if (EltTy->isIntegerType()) {
772 llvm::APSInt sInt(32);
773 if (i < NumInits) {
774 if (!EvaluateInteger(E->getInit(i), sInt, Info))
775 return APValue();
776 } else {
777 sInt = Info.Ctx.MakeIntValue(0, EltTy);
778 }
779 Elements.push_back(APValue(sInt));
Eli Friedman3ae59112009-02-23 04:23:56 +0000780 } else {
John McCall875679e2010-06-11 17:54:15 +0000781 llvm::APFloat f(0.0);
782 if (i < NumInits) {
783 if (!EvaluateFloat(E->getInit(i), f, Info))
784 return APValue();
785 } else {
786 f = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy));
787 }
788 Elements.push_back(APValue(f));
Eli Friedman3ae59112009-02-23 04:23:56 +0000789 }
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000790 }
791 }
792 return APValue(&Elements[0], Elements.size());
793}
794
Mike Stump11289f42009-09-09 15:08:12 +0000795APValue
Eli Friedman3ae59112009-02-23 04:23:56 +0000796VectorExprEvaluator::GetZeroVector(QualType T) {
John McCall9dd450b2009-09-21 23:43:11 +0000797 const VectorType *VT = T->getAs<VectorType>();
Eli Friedman3ae59112009-02-23 04:23:56 +0000798 QualType EltTy = VT->getElementType();
799 APValue ZeroElement;
800 if (EltTy->isIntegerType())
801 ZeroElement = APValue(Info.Ctx.MakeIntValue(0, EltTy));
802 else
803 ZeroElement =
804 APValue(APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy)));
805
806 llvm::SmallVector<APValue, 4> Elements(VT->getNumElements(), ZeroElement);
807 return APValue(&Elements[0], Elements.size());
808}
809
810APValue VectorExprEvaluator::VisitConditionalOperator(const ConditionalOperator *E) {
811 bool BoolResult;
812 if (!HandleConversionToBool(E->getCond(), BoolResult, Info))
813 return APValue();
814
815 Expr* EvalExpr = BoolResult ? E->getTrueExpr() : E->getFalseExpr();
816
817 APValue Result;
818 if (EvaluateVector(EvalExpr, Result, Info))
819 return Result;
820 return APValue();
821}
822
Eli Friedman3ae59112009-02-23 04:23:56 +0000823APValue VectorExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
824 if (!E->getSubExpr()->isEvaluatable(Info.Ctx))
825 Info.EvalResult.HasSideEffects = true;
826 return GetZeroVector(E->getType());
827}
828
Nate Begeman2f2bdeb2009-01-18 03:20:47 +0000829//===----------------------------------------------------------------------===//
Chris Lattner05706e882008-07-11 18:11:29 +0000830// Integer Evaluation
831//===----------------------------------------------------------------------===//
Chris Lattner05706e882008-07-11 18:11:29 +0000832
833namespace {
Benjamin Kramer26222b62009-11-28 19:03:38 +0000834class IntExprEvaluator
Chris Lattnere13042c2008-07-11 19:10:17 +0000835 : public StmtVisitor<IntExprEvaluator, bool> {
Chris Lattnercdf34e72008-07-11 22:52:41 +0000836 EvalInfo &Info;
Daniel Dunbarca097ad2009-02-19 20:17:33 +0000837 APValue &Result;
Anders Carlsson0a1707c2008-07-08 05:13:58 +0000838public:
Daniel Dunbarca097ad2009-02-19 20:17:33 +0000839 IntExprEvaluator(EvalInfo &info, APValue &result)
Chris Lattnercdf34e72008-07-11 22:52:41 +0000840 : Info(info), Result(result) {}
Chris Lattner05706e882008-07-11 18:11:29 +0000841
Daniel Dunbare3c92bc2009-02-19 18:37:50 +0000842 bool Success(const llvm::APSInt &SI, const Expr *E) {
Douglas Gregorb90df602010-06-16 00:17:44 +0000843 assert(E->getType()->isIntegralOrEnumerationType() &&
844 "Invalid evaluation result.");
Daniel Dunbarca097ad2009-02-19 20:17:33 +0000845 assert(SI.isSigned() == E->getType()->isSignedIntegerType() &&
Daniel Dunbare3c92bc2009-02-19 18:37:50 +0000846 "Invalid evaluation result.");
Daniel Dunbarca097ad2009-02-19 20:17:33 +0000847 assert(SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
Daniel Dunbare3c92bc2009-02-19 18:37:50 +0000848 "Invalid evaluation result.");
Daniel Dunbarca097ad2009-02-19 20:17:33 +0000849 Result = APValue(SI);
Daniel Dunbare3c92bc2009-02-19 18:37:50 +0000850 return true;
851 }
852
Daniel Dunbar8aafc892009-02-19 09:06:44 +0000853 bool Success(const llvm::APInt &I, const Expr *E) {
Douglas Gregorb90df602010-06-16 00:17:44 +0000854 assert(E->getType()->isIntegralOrEnumerationType() &&
855 "Invalid evaluation result.");
Daniel Dunbarca097ad2009-02-19 20:17:33 +0000856 assert(I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
Daniel Dunbare3c92bc2009-02-19 18:37:50 +0000857 "Invalid evaluation result.");
Daniel Dunbarca097ad2009-02-19 20:17:33 +0000858 Result = APValue(APSInt(I));
859 Result.getInt().setIsUnsigned(E->getType()->isUnsignedIntegerType());
Daniel Dunbar8aafc892009-02-19 09:06:44 +0000860 return true;
861 }
862
863 bool Success(uint64_t Value, const Expr *E) {
Douglas Gregorb90df602010-06-16 00:17:44 +0000864 assert(E->getType()->isIntegralOrEnumerationType() &&
865 "Invalid evaluation result.");
Daniel Dunbarca097ad2009-02-19 20:17:33 +0000866 Result = APValue(Info.Ctx.MakeIntValue(Value, E->getType()));
Daniel Dunbar8aafc892009-02-19 09:06:44 +0000867 return true;
868 }
869
Anders Carlsson27b8c5c2008-11-30 18:14:57 +0000870 bool Error(SourceLocation L, diag::kind D, const Expr *E) {
Chris Lattnerfac05ae2008-11-12 07:43:42 +0000871 // Take the first error.
Anders Carlssonbd1df8e2008-11-30 16:38:33 +0000872 if (Info.EvalResult.Diag == 0) {
873 Info.EvalResult.DiagLoc = L;
874 Info.EvalResult.Diag = D;
Anders Carlsson27b8c5c2008-11-30 18:14:57 +0000875 Info.EvalResult.DiagExpr = E;
Chris Lattnerfac05ae2008-11-12 07:43:42 +0000876 }
Chris Lattner99415702008-07-12 00:14:42 +0000877 return false;
Chris Lattnerae8cc152008-07-11 19:24:49 +0000878 }
Mike Stump11289f42009-09-09 15:08:12 +0000879
Anders Carlsson0a1707c2008-07-08 05:13:58 +0000880 //===--------------------------------------------------------------------===//
881 // Visitor Methods
882 //===--------------------------------------------------------------------===//
Mike Stump11289f42009-09-09 15:08:12 +0000883
Chris Lattnerfac05ae2008-11-12 07:43:42 +0000884 bool VisitStmt(Stmt *) {
885 assert(0 && "This should be called on integers, stmts are not integers");
886 return false;
887 }
Mike Stump11289f42009-09-09 15:08:12 +0000888
Chris Lattnerfac05ae2008-11-12 07:43:42 +0000889 bool VisitExpr(Expr *E) {
Anders Carlssonb33d6c82008-11-30 18:37:00 +0000890 return Error(E->getLocStart(), diag::note_invalid_subexpr_in_ice, E);
Anders Carlsson0a1707c2008-07-08 05:13:58 +0000891 }
Mike Stump11289f42009-09-09 15:08:12 +0000892
Chris Lattnere13042c2008-07-11 19:10:17 +0000893 bool VisitParenExpr(ParenExpr *E) { return Visit(E->getSubExpr()); }
Anders Carlsson0a1707c2008-07-08 05:13:58 +0000894
Chris Lattner7174bf32008-07-12 00:38:25 +0000895 bool VisitIntegerLiteral(const IntegerLiteral *E) {
Daniel Dunbar8aafc892009-02-19 09:06:44 +0000896 return Success(E->getValue(), E);
Chris Lattner7174bf32008-07-12 00:38:25 +0000897 }
898 bool VisitCharacterLiteral(const CharacterLiteral *E) {
Daniel Dunbar8aafc892009-02-19 09:06:44 +0000899 return Success(E->getValue(), E);
Chris Lattner7174bf32008-07-12 00:38:25 +0000900 }
901 bool VisitTypesCompatibleExpr(const TypesCompatibleExpr *E) {
Daniel Dunbard7be95d2008-10-24 08:07:57 +0000902 // Per gcc docs "this built-in function ignores top level
903 // qualifiers". We need to use the canonical version to properly
904 // be able to strip CRV qualifiers from the type.
905 QualType T0 = Info.Ctx.getCanonicalType(E->getArgType1());
906 QualType T1 = Info.Ctx.getCanonicalType(E->getArgType2());
Mike Stump11289f42009-09-09 15:08:12 +0000907 return Success(Info.Ctx.typesAreCompatible(T0.getUnqualifiedType(),
Daniel Dunbar8aafc892009-02-19 09:06:44 +0000908 T1.getUnqualifiedType()),
909 E);
Chris Lattner7174bf32008-07-12 00:38:25 +0000910 }
Eli Friedmanfb8a93f2009-11-24 05:28:59 +0000911
912 bool CheckReferencedDecl(const Expr *E, const Decl *D);
913 bool VisitDeclRefExpr(const DeclRefExpr *E) {
914 return CheckReferencedDecl(E, E->getDecl());
915 }
916 bool VisitMemberExpr(const MemberExpr *E) {
917 if (CheckReferencedDecl(E, E->getMemberDecl())) {
918 // Conservatively assume a MemberExpr will have side-effects
919 Info.EvalResult.HasSideEffects = true;
920 return true;
921 }
922 return false;
923 }
924
Eli Friedmand5c93992010-02-13 00:10:10 +0000925 bool VisitCallExpr(CallExpr *E);
Chris Lattnere13042c2008-07-11 19:10:17 +0000926 bool VisitBinaryOperator(const BinaryOperator *E);
Douglas Gregor882211c2010-04-28 22:16:22 +0000927 bool VisitOffsetOfExpr(const OffsetOfExpr *E);
Chris Lattnere13042c2008-07-11 19:10:17 +0000928 bool VisitUnaryOperator(const UnaryOperator *E);
Nuno Lopes42042612008-11-16 19:28:31 +0000929 bool VisitConditionalOperator(const ConditionalOperator *E);
Anders Carlsson374b93d2008-07-08 05:49:43 +0000930
Daniel Dunbarb6f953e2009-01-29 06:16:07 +0000931 bool VisitCastExpr(CastExpr* E);
Sebastian Redl6f282892008-11-11 17:56:53 +0000932 bool VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E);
933
Anders Carlsson9f9e4242008-11-16 19:01:22 +0000934 bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
Daniel Dunbar8aafc892009-02-19 09:06:44 +0000935 return Success(E->getValue(), E);
Anders Carlsson9f9e4242008-11-16 19:01:22 +0000936 }
Mike Stump11289f42009-09-09 15:08:12 +0000937
Anders Carlsson39def3a2008-12-21 22:39:40 +0000938 bool VisitGNUNullExpr(const GNUNullExpr *E) {
Daniel Dunbar8aafc892009-02-19 09:06:44 +0000939 return Success(0, E);
Anders Carlsson39def3a2008-12-21 22:39:40 +0000940 }
Mike Stump11289f42009-09-09 15:08:12 +0000941
Douglas Gregor747eb782010-07-08 06:14:04 +0000942 bool VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) {
Daniel Dunbar8aafc892009-02-19 09:06:44 +0000943 return Success(0, E);
Anders Carlsson9f9e4242008-11-16 19:01:22 +0000944 }
945
Eli Friedman4e7a2412009-02-27 04:45:43 +0000946 bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
947 return Success(0, E);
948 }
949
Sebastian Redlbaad4e72009-01-05 20:52:13 +0000950 bool VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E) {
Douglas Gregor79f83ed2009-07-23 23:49:00 +0000951 return Success(E->EvaluateTrait(Info.Ctx), E);
Sebastian Redlbaad4e72009-01-05 20:52:13 +0000952 }
953
Eli Friedman449fe542009-03-23 04:56:01 +0000954 bool VisitChooseExpr(const ChooseExpr *E) {
955 return Visit(E->getChosenSubExpr(Info.Ctx));
956 }
957
Eli Friedmana1c7b6c2009-02-28 03:59:05 +0000958 bool VisitUnaryReal(const UnaryOperator *E);
Eli Friedman4e7a2412009-02-27 04:45:43 +0000959 bool VisitUnaryImag(const UnaryOperator *E);
960
Chris Lattnerf8d7f722008-07-11 21:24:13 +0000961private:
Ken Dyck160146e2010-01-27 17:10:57 +0000962 CharUnits GetAlignOfExpr(const Expr *E);
963 CharUnits GetAlignOfType(QualType T);
John McCall95007602010-05-10 23:27:23 +0000964 static QualType GetObjectType(const Expr *E);
965 bool TryEvaluateBuiltinObjectSize(CallExpr *E);
Eli Friedman4e7a2412009-02-27 04:45:43 +0000966 // FIXME: Missing: array subscript of vector, member of vector
Anders Carlsson9c181652008-07-08 14:35:21 +0000967};
Chris Lattner05706e882008-07-11 18:11:29 +0000968} // end anonymous namespace
Anders Carlsson4a3585b2008-07-08 15:34:11 +0000969
Daniel Dunbarce399542009-02-20 18:22:23 +0000970static bool EvaluateIntegerOrLValue(const Expr* E, APValue &Result, EvalInfo &Info) {
Douglas Gregorb90df602010-06-16 00:17:44 +0000971 assert(E->getType()->isIntegralOrEnumerationType());
Daniel Dunbarce399542009-02-20 18:22:23 +0000972 return IntExprEvaluator(Info, Result).Visit(const_cast<Expr*>(E));
973}
Daniel Dunbarca097ad2009-02-19 20:17:33 +0000974
Daniel Dunbarce399542009-02-20 18:22:23 +0000975static bool EvaluateInteger(const Expr* E, APSInt &Result, EvalInfo &Info) {
Douglas Gregorb90df602010-06-16 00:17:44 +0000976 assert(E->getType()->isIntegralOrEnumerationType());
John McCallf0c4f352010-05-07 05:46:35 +0000977
Daniel Dunbarce399542009-02-20 18:22:23 +0000978 APValue Val;
979 if (!EvaluateIntegerOrLValue(E, Val, Info) || !Val.isInt())
980 return false;
Daniel Dunbarca097ad2009-02-19 20:17:33 +0000981 Result = Val.getInt();
982 return true;
Anders Carlsson4a3585b2008-07-08 15:34:11 +0000983}
Anders Carlsson4a3585b2008-07-08 15:34:11 +0000984
Eli Friedmanfb8a93f2009-11-24 05:28:59 +0000985bool IntExprEvaluator::CheckReferencedDecl(const Expr* E, const Decl* D) {
Chris Lattner7174bf32008-07-12 00:38:25 +0000986 // Enums are integer constant exprs.
Eli Friedmanee275c82009-12-10 22:29:29 +0000987 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D))
988 return Success(ECD->getInitVal(), E);
Sebastian Redlc9ab3d42009-02-08 15:51:17 +0000989
990 // In C++, const, non-volatile integers initialized with ICEs are ICEs.
Eli Friedman29f80c32009-03-30 23:39:01 +0000991 // In C, they can also be folded, although they are not ICEs.
Douglas Gregor0840cc02009-11-01 20:32:48 +0000992 if (Info.Ctx.getCanonicalType(E->getType()).getCVRQualifiers()
993 == Qualifiers::Const) {
Anders Carlssonb0695ef2010-02-03 21:58:41 +0000994
995 if (isa<ParmVarDecl>(D))
996 return Error(E->getLocStart(), diag::note_invalid_subexpr_in_ice, E);
997
Eli Friedmanfb8a93f2009-11-24 05:28:59 +0000998 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
Sebastian Redl5ca79842010-02-01 20:16:42 +0000999 if (const Expr *Init = VD->getAnyInitializer()) {
Eli Friedman1d6fb162009-12-03 20:31:57 +00001000 if (APValue *V = VD->getEvaluatedValue()) {
1001 if (V->isInt())
1002 return Success(V->getInt(), E);
1003 return Error(E->getLocStart(), diag::note_invalid_subexpr_in_ice, E);
1004 }
1005
1006 if (VD->isEvaluatingValue())
1007 return Error(E->getLocStart(), diag::note_invalid_subexpr_in_ice, E);
1008
1009 VD->setEvaluatingValue();
1010
Douglas Gregor31cf12c2009-05-26 18:54:04 +00001011 if (Visit(const_cast<Expr*>(Init))) {
1012 // Cache the evaluated value in the variable declaration.
Eli Friedman1d6fb162009-12-03 20:31:57 +00001013 VD->setEvaluatedValue(Result);
Douglas Gregor31cf12c2009-05-26 18:54:04 +00001014 return true;
1015 }
1016
Eli Friedman1d6fb162009-12-03 20:31:57 +00001017 VD->setEvaluatedValue(APValue());
Douglas Gregor31cf12c2009-05-26 18:54:04 +00001018 return false;
1019 }
Sebastian Redlc9ab3d42009-02-08 15:51:17 +00001020 }
1021 }
1022
Chris Lattner7174bf32008-07-12 00:38:25 +00001023 // Otherwise, random variable references are not constants.
Anders Carlssonb33d6c82008-11-30 18:37:00 +00001024 return Error(E->getLocStart(), diag::note_invalid_subexpr_in_ice, E);
Chris Lattner7174bf32008-07-12 00:38:25 +00001025}
1026
Chris Lattner86ee2862008-10-06 06:40:35 +00001027/// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way
1028/// as GCC.
1029static int EvaluateBuiltinClassifyType(const CallExpr *E) {
1030 // The following enum mimics the values returned by GCC.
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00001031 // FIXME: Does GCC differ between lvalue and rvalue references here?
Chris Lattner86ee2862008-10-06 06:40:35 +00001032 enum gcc_type_class {
1033 no_type_class = -1,
1034 void_type_class, integer_type_class, char_type_class,
1035 enumeral_type_class, boolean_type_class,
1036 pointer_type_class, reference_type_class, offset_type_class,
1037 real_type_class, complex_type_class,
1038 function_type_class, method_type_class,
1039 record_type_class, union_type_class,
1040 array_type_class, string_type_class,
1041 lang_type_class
1042 };
Mike Stump11289f42009-09-09 15:08:12 +00001043
1044 // If no argument was supplied, default to "no_type_class". This isn't
Chris Lattner86ee2862008-10-06 06:40:35 +00001045 // ideal, however it is what gcc does.
1046 if (E->getNumArgs() == 0)
1047 return no_type_class;
Mike Stump11289f42009-09-09 15:08:12 +00001048
Chris Lattner86ee2862008-10-06 06:40:35 +00001049 QualType ArgTy = E->getArg(0)->getType();
1050 if (ArgTy->isVoidType())
1051 return void_type_class;
1052 else if (ArgTy->isEnumeralType())
1053 return enumeral_type_class;
1054 else if (ArgTy->isBooleanType())
1055 return boolean_type_class;
1056 else if (ArgTy->isCharType())
1057 return string_type_class; // gcc doesn't appear to use char_type_class
1058 else if (ArgTy->isIntegerType())
1059 return integer_type_class;
1060 else if (ArgTy->isPointerType())
1061 return pointer_type_class;
1062 else if (ArgTy->isReferenceType())
1063 return reference_type_class;
1064 else if (ArgTy->isRealType())
1065 return real_type_class;
1066 else if (ArgTy->isComplexType())
1067 return complex_type_class;
1068 else if (ArgTy->isFunctionType())
1069 return function_type_class;
Douglas Gregor8385a062010-04-26 21:31:17 +00001070 else if (ArgTy->isStructureOrClassType())
Chris Lattner86ee2862008-10-06 06:40:35 +00001071 return record_type_class;
1072 else if (ArgTy->isUnionType())
1073 return union_type_class;
1074 else if (ArgTy->isArrayType())
1075 return array_type_class;
1076 else if (ArgTy->isUnionType())
1077 return union_type_class;
1078 else // FIXME: offset_type_class, method_type_class, & lang_type_class?
1079 assert(0 && "CallExpr::isBuiltinClassifyType(): unimplemented type");
1080 return -1;
1081}
1082
John McCall95007602010-05-10 23:27:23 +00001083/// Retrieves the "underlying object type" of the given expression,
1084/// as used by __builtin_object_size.
1085QualType IntExprEvaluator::GetObjectType(const Expr *E) {
1086 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
1087 if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl()))
1088 return VD->getType();
1089 } else if (isa<CompoundLiteralExpr>(E)) {
1090 return E->getType();
1091 }
1092
1093 return QualType();
1094}
1095
1096bool IntExprEvaluator::TryEvaluateBuiltinObjectSize(CallExpr *E) {
1097 // TODO: Perhaps we should let LLVM lower this?
1098 LValue Base;
1099 if (!EvaluatePointer(E->getArg(0), Base, Info))
1100 return false;
1101
1102 // If we can prove the base is null, lower to zero now.
1103 const Expr *LVBase = Base.getLValueBase();
1104 if (!LVBase) return Success(0, E);
1105
1106 QualType T = GetObjectType(LVBase);
1107 if (T.isNull() ||
1108 T->isIncompleteType() ||
Eli Friedmana170cd62010-08-05 02:49:48 +00001109 T->isFunctionType() ||
John McCall95007602010-05-10 23:27:23 +00001110 T->isVariablyModifiedType() ||
1111 T->isDependentType())
1112 return false;
1113
1114 CharUnits Size = Info.Ctx.getTypeSizeInChars(T);
1115 CharUnits Offset = Base.getLValueOffset();
1116
1117 if (!Offset.isNegative() && Offset <= Size)
1118 Size -= Offset;
1119 else
1120 Size = CharUnits::Zero();
1121 return Success(Size.getQuantity(), E);
1122}
1123
Eli Friedmand5c93992010-02-13 00:10:10 +00001124bool IntExprEvaluator::VisitCallExpr(CallExpr *E) {
Douglas Gregore711f702009-02-14 18:57:46 +00001125 switch (E->isBuiltinCall(Info.Ctx)) {
Chris Lattner4deaa4e2008-10-06 05:28:25 +00001126 default:
Anders Carlssonb33d6c82008-11-30 18:37:00 +00001127 return Error(E->getLocStart(), diag::note_invalid_subexpr_in_ice, E);
Mike Stump722cedf2009-10-26 18:35:08 +00001128
1129 case Builtin::BI__builtin_object_size: {
John McCall95007602010-05-10 23:27:23 +00001130 if (TryEvaluateBuiltinObjectSize(E))
1131 return true;
Mike Stump722cedf2009-10-26 18:35:08 +00001132
Eric Christopher99469702010-01-19 22:58:35 +00001133 // If evaluating the argument has side-effects we can't determine
1134 // the size of the object and lower it to unknown now.
Fariborz Jahanian4127b8e2009-11-05 18:03:03 +00001135 if (E->getArg(0)->HasSideEffects(Info.Ctx)) {
Benjamin Kramer0128f662010-01-03 18:18:37 +00001136 if (E->getArg(1)->EvaluateAsInt(Info.Ctx).getZExtValue() <= 1)
Chris Lattner4f105592009-11-03 19:48:51 +00001137 return Success(-1ULL, E);
Mike Stump722cedf2009-10-26 18:35:08 +00001138 return Success(0, E);
1139 }
Mike Stump876387b2009-10-27 22:09:17 +00001140
Mike Stump722cedf2009-10-26 18:35:08 +00001141 return Error(E->getLocStart(), diag::note_invalid_subexpr_in_ice, E);
1142 }
1143
Chris Lattner4deaa4e2008-10-06 05:28:25 +00001144 case Builtin::BI__builtin_classify_type:
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001145 return Success(EvaluateBuiltinClassifyType(E), E);
Mike Stump11289f42009-09-09 15:08:12 +00001146
Anders Carlsson4c76e932008-11-24 04:21:33 +00001147 case Builtin::BI__builtin_constant_p:
Chris Lattner4deaa4e2008-10-06 05:28:25 +00001148 // __builtin_constant_p always has one operand: it returns true if that
1149 // operand can be folded, false otherwise.
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001150 return Success(E->getArg(0)->isEvaluatable(Info.Ctx), E);
Chris Lattnerd545ad12009-09-23 06:06:36 +00001151
1152 case Builtin::BI__builtin_eh_return_data_regno: {
1153 int Operand = E->getArg(0)->EvaluateAsInt(Info.Ctx).getZExtValue();
1154 Operand = Info.Ctx.Target.getEHDataRegisterNumber(Operand);
1155 return Success(Operand, E);
1156 }
Eli Friedmand5c93992010-02-13 00:10:10 +00001157
1158 case Builtin::BI__builtin_expect:
1159 return Visit(E->getArg(0));
Chris Lattner4deaa4e2008-10-06 05:28:25 +00001160 }
Chris Lattner7174bf32008-07-12 00:38:25 +00001161}
Anders Carlsson4a3585b2008-07-08 15:34:11 +00001162
Chris Lattnere13042c2008-07-11 19:10:17 +00001163bool IntExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
Eli Friedman5a332ea2008-11-13 06:09:17 +00001164 if (E->getOpcode() == BinaryOperator::Comma) {
Anders Carlsson564730a2008-12-01 02:07:06 +00001165 if (!Visit(E->getRHS()))
1166 return false;
Anders Carlsson5b3638b2008-12-01 06:44:05 +00001167
Eli Friedman9cb9ff42009-02-26 10:19:36 +00001168 // If we can't evaluate the LHS, it might have side effects;
1169 // conservatively mark it.
1170 if (!E->getLHS()->isEvaluatable(Info.Ctx))
1171 Info.EvalResult.HasSideEffects = true;
Eli Friedman5a332ea2008-11-13 06:09:17 +00001172
Anders Carlsson564730a2008-12-01 02:07:06 +00001173 return true;
Eli Friedman5a332ea2008-11-13 06:09:17 +00001174 }
1175
1176 if (E->isLogicalOp()) {
1177 // These need to be handled specially because the operands aren't
1178 // necessarily integral
Anders Carlssonf50de0c2008-11-30 16:51:17 +00001179 bool lhsResult, rhsResult;
Mike Stump11289f42009-09-09 15:08:12 +00001180
Anders Carlssonf50de0c2008-11-30 16:51:17 +00001181 if (HandleConversionToBool(E->getLHS(), lhsResult, Info)) {
Anders Carlsson59689ed2008-11-22 21:04:56 +00001182 // We were able to evaluate the LHS, see if we can get away with not
1183 // evaluating the RHS: 0 && X -> 0, 1 || X -> 1
Eli Friedman9cb9ff42009-02-26 10:19:36 +00001184 if (lhsResult == (E->getOpcode() == BinaryOperator::LOr))
Daniel Dunbare3c92bc2009-02-19 18:37:50 +00001185 return Success(lhsResult, E);
Anders Carlsson4c76e932008-11-24 04:21:33 +00001186
Anders Carlssonf50de0c2008-11-30 16:51:17 +00001187 if (HandleConversionToBool(E->getRHS(), rhsResult, Info)) {
Anders Carlsson4c76e932008-11-24 04:21:33 +00001188 if (E->getOpcode() == BinaryOperator::LOr)
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001189 return Success(lhsResult || rhsResult, E);
Anders Carlsson4c76e932008-11-24 04:21:33 +00001190 else
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001191 return Success(lhsResult && rhsResult, E);
Anders Carlsson4c76e932008-11-24 04:21:33 +00001192 }
1193 } else {
Anders Carlssonf50de0c2008-11-30 16:51:17 +00001194 if (HandleConversionToBool(E->getRHS(), rhsResult, Info)) {
Anders Carlsson4c76e932008-11-24 04:21:33 +00001195 // We can't evaluate the LHS; however, sometimes the result
1196 // is determined by the RHS: X && 0 -> 0, X || 1 -> 1.
Mike Stump11289f42009-09-09 15:08:12 +00001197 if (rhsResult == (E->getOpcode() == BinaryOperator::LOr) ||
Anders Carlssonf50de0c2008-11-30 16:51:17 +00001198 !rhsResult == (E->getOpcode() == BinaryOperator::LAnd)) {
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001199 // Since we weren't able to evaluate the left hand side, it
Anders Carlssonf50de0c2008-11-30 16:51:17 +00001200 // must have had side effects.
1201 Info.EvalResult.HasSideEffects = true;
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001202
1203 return Success(rhsResult, E);
Anders Carlsson4c76e932008-11-24 04:21:33 +00001204 }
1205 }
Anders Carlsson59689ed2008-11-22 21:04:56 +00001206 }
Eli Friedman5a332ea2008-11-13 06:09:17 +00001207
Eli Friedman5a332ea2008-11-13 06:09:17 +00001208 return false;
1209 }
1210
Anders Carlssonacc79812008-11-16 07:17:21 +00001211 QualType LHSTy = E->getLHS()->getType();
1212 QualType RHSTy = E->getRHS()->getType();
Daniel Dunbar74f2425b2009-01-29 06:43:41 +00001213
1214 if (LHSTy->isAnyComplexType()) {
1215 assert(RHSTy->isAnyComplexType() && "Invalid comparison");
John McCall93d91dc2010-05-07 17:22:02 +00001216 ComplexValue LHS, RHS;
Daniel Dunbar74f2425b2009-01-29 06:43:41 +00001217
1218 if (!EvaluateComplex(E->getLHS(), LHS, Info))
1219 return false;
1220
1221 if (!EvaluateComplex(E->getRHS(), RHS, Info))
1222 return false;
1223
1224 if (LHS.isComplexFloat()) {
Mike Stump11289f42009-09-09 15:08:12 +00001225 APFloat::cmpResult CR_r =
Daniel Dunbar74f2425b2009-01-29 06:43:41 +00001226 LHS.getComplexFloatReal().compare(RHS.getComplexFloatReal());
Mike Stump11289f42009-09-09 15:08:12 +00001227 APFloat::cmpResult CR_i =
Daniel Dunbar74f2425b2009-01-29 06:43:41 +00001228 LHS.getComplexFloatImag().compare(RHS.getComplexFloatImag());
1229
Daniel Dunbar74f2425b2009-01-29 06:43:41 +00001230 if (E->getOpcode() == BinaryOperator::EQ)
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001231 return Success((CR_r == APFloat::cmpEqual &&
1232 CR_i == APFloat::cmpEqual), E);
1233 else {
1234 assert(E->getOpcode() == BinaryOperator::NE &&
1235 "Invalid complex comparison.");
Mike Stump11289f42009-09-09 15:08:12 +00001236 return Success(((CR_r == APFloat::cmpGreaterThan ||
Mon P Wang75c645c2010-04-29 05:53:29 +00001237 CR_r == APFloat::cmpLessThan ||
1238 CR_r == APFloat::cmpUnordered) ||
Mike Stump11289f42009-09-09 15:08:12 +00001239 (CR_i == APFloat::cmpGreaterThan ||
Mon P Wang75c645c2010-04-29 05:53:29 +00001240 CR_i == APFloat::cmpLessThan ||
1241 CR_i == APFloat::cmpUnordered)), E);
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001242 }
Daniel Dunbar74f2425b2009-01-29 06:43:41 +00001243 } else {
Daniel Dunbar74f2425b2009-01-29 06:43:41 +00001244 if (E->getOpcode() == BinaryOperator::EQ)
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001245 return Success((LHS.getComplexIntReal() == RHS.getComplexIntReal() &&
1246 LHS.getComplexIntImag() == RHS.getComplexIntImag()), E);
1247 else {
1248 assert(E->getOpcode() == BinaryOperator::NE &&
1249 "Invalid compex comparison.");
1250 return Success((LHS.getComplexIntReal() != RHS.getComplexIntReal() ||
1251 LHS.getComplexIntImag() != RHS.getComplexIntImag()), E);
1252 }
Daniel Dunbar74f2425b2009-01-29 06:43:41 +00001253 }
1254 }
Mike Stump11289f42009-09-09 15:08:12 +00001255
Anders Carlssonacc79812008-11-16 07:17:21 +00001256 if (LHSTy->isRealFloatingType() &&
1257 RHSTy->isRealFloatingType()) {
1258 APFloat RHS(0.0), LHS(0.0);
Mike Stump11289f42009-09-09 15:08:12 +00001259
Anders Carlssonacc79812008-11-16 07:17:21 +00001260 if (!EvaluateFloat(E->getRHS(), RHS, Info))
1261 return false;
Mike Stump11289f42009-09-09 15:08:12 +00001262
Anders Carlssonacc79812008-11-16 07:17:21 +00001263 if (!EvaluateFloat(E->getLHS(), LHS, Info))
1264 return false;
Mike Stump11289f42009-09-09 15:08:12 +00001265
Anders Carlssonacc79812008-11-16 07:17:21 +00001266 APFloat::cmpResult CR = LHS.compare(RHS);
Anders Carlsson899c7052008-11-16 22:46:56 +00001267
Anders Carlssonacc79812008-11-16 07:17:21 +00001268 switch (E->getOpcode()) {
1269 default:
1270 assert(0 && "Invalid binary operator!");
1271 case BinaryOperator::LT:
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001272 return Success(CR == APFloat::cmpLessThan, E);
Anders Carlssonacc79812008-11-16 07:17:21 +00001273 case BinaryOperator::GT:
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001274 return Success(CR == APFloat::cmpGreaterThan, E);
Anders Carlssonacc79812008-11-16 07:17:21 +00001275 case BinaryOperator::LE:
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001276 return Success(CR == APFloat::cmpLessThan || CR == APFloat::cmpEqual, E);
Anders Carlssonacc79812008-11-16 07:17:21 +00001277 case BinaryOperator::GE:
Mike Stump11289f42009-09-09 15:08:12 +00001278 return Success(CR == APFloat::cmpGreaterThan || CR == APFloat::cmpEqual,
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001279 E);
Anders Carlssonacc79812008-11-16 07:17:21 +00001280 case BinaryOperator::EQ:
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001281 return Success(CR == APFloat::cmpEqual, E);
Anders Carlssonacc79812008-11-16 07:17:21 +00001282 case BinaryOperator::NE:
Mike Stump11289f42009-09-09 15:08:12 +00001283 return Success(CR == APFloat::cmpGreaterThan
Mon P Wang75c645c2010-04-29 05:53:29 +00001284 || CR == APFloat::cmpLessThan
1285 || CR == APFloat::cmpUnordered, E);
Anders Carlssonacc79812008-11-16 07:17:21 +00001286 }
Anders Carlssonacc79812008-11-16 07:17:21 +00001287 }
Mike Stump11289f42009-09-09 15:08:12 +00001288
Eli Friedmana38da572009-04-28 19:17:36 +00001289 if (LHSTy->isPointerType() && RHSTy->isPointerType()) {
1290 if (E->getOpcode() == BinaryOperator::Sub || E->isEqualityOp()) {
John McCall45d55e42010-05-07 21:00:08 +00001291 LValue LHSValue;
Anders Carlsson9f9e4242008-11-16 19:01:22 +00001292 if (!EvaluatePointer(E->getLHS(), LHSValue, Info))
1293 return false;
Eli Friedman64004332009-03-23 04:38:34 +00001294
John McCall45d55e42010-05-07 21:00:08 +00001295 LValue RHSValue;
Anders Carlsson9f9e4242008-11-16 19:01:22 +00001296 if (!EvaluatePointer(E->getRHS(), RHSValue, Info))
1297 return false;
Eli Friedman64004332009-03-23 04:38:34 +00001298
Eli Friedman334046a2009-06-14 02:17:33 +00001299 // Reject any bases from the normal codepath; we special-case comparisons
1300 // to null.
1301 if (LHSValue.getLValueBase()) {
1302 if (!E->isEqualityOp())
1303 return false;
Ken Dyck02990832010-01-15 12:37:54 +00001304 if (RHSValue.getLValueBase() || !RHSValue.getLValueOffset().isZero())
Eli Friedman334046a2009-06-14 02:17:33 +00001305 return false;
1306 bool bres;
1307 if (!EvalPointerValueAsBool(LHSValue, bres))
1308 return false;
1309 return Success(bres ^ (E->getOpcode() == BinaryOperator::EQ), E);
1310 } else if (RHSValue.getLValueBase()) {
1311 if (!E->isEqualityOp())
1312 return false;
Ken Dyck02990832010-01-15 12:37:54 +00001313 if (LHSValue.getLValueBase() || !LHSValue.getLValueOffset().isZero())
Eli Friedman334046a2009-06-14 02:17:33 +00001314 return false;
1315 bool bres;
1316 if (!EvalPointerValueAsBool(RHSValue, bres))
1317 return false;
1318 return Success(bres ^ (E->getOpcode() == BinaryOperator::EQ), E);
1319 }
Eli Friedman64004332009-03-23 04:38:34 +00001320
Eli Friedmana38da572009-04-28 19:17:36 +00001321 if (E->getOpcode() == BinaryOperator::Sub) {
Chris Lattner882bdf22010-04-20 17:13:14 +00001322 QualType Type = E->getLHS()->getType();
1323 QualType ElementType = Type->getAs<PointerType>()->getPointeeType();
Anders Carlsson9f9e4242008-11-16 19:01:22 +00001324
Ken Dyck02990832010-01-15 12:37:54 +00001325 CharUnits ElementSize = CharUnits::One();
Eli Friedmanfa90b152009-06-04 20:23:20 +00001326 if (!ElementType->isVoidType() && !ElementType->isFunctionType())
Ken Dyck02990832010-01-15 12:37:54 +00001327 ElementSize = Info.Ctx.getTypeSizeInChars(ElementType);
Eli Friedman64004332009-03-23 04:38:34 +00001328
Ken Dyck02990832010-01-15 12:37:54 +00001329 CharUnits Diff = LHSValue.getLValueOffset() -
1330 RHSValue.getLValueOffset();
1331 return Success(Diff / ElementSize, E);
Eli Friedmana38da572009-04-28 19:17:36 +00001332 }
1333 bool Result;
1334 if (E->getOpcode() == BinaryOperator::EQ) {
1335 Result = LHSValue.getLValueOffset() == RHSValue.getLValueOffset();
Eli Friedman8b171f62009-04-29 20:29:43 +00001336 } else {
Eli Friedmana38da572009-04-28 19:17:36 +00001337 Result = LHSValue.getLValueOffset() != RHSValue.getLValueOffset();
1338 }
1339 return Success(Result, E);
Anders Carlsson9f9e4242008-11-16 19:01:22 +00001340 }
1341 }
Douglas Gregorb90df602010-06-16 00:17:44 +00001342 if (!LHSTy->isIntegralOrEnumerationType() ||
1343 !RHSTy->isIntegralOrEnumerationType()) {
Eli Friedman5a332ea2008-11-13 06:09:17 +00001344 // We can't continue from here for non-integral types, and they
1345 // could potentially confuse the following operations.
Eli Friedman5a332ea2008-11-13 06:09:17 +00001346 return false;
1347 }
1348
Anders Carlsson9c181652008-07-08 14:35:21 +00001349 // The LHS of a constant expr is always evaluated and needed.
Daniel Dunbarca097ad2009-02-19 20:17:33 +00001350 if (!Visit(E->getLHS()))
Chris Lattner99415702008-07-12 00:14:42 +00001351 return false; // error in subexpression.
Eli Friedmanbd840592008-07-27 05:46:18 +00001352
Eli Friedman94c25c62009-03-24 01:14:50 +00001353 APValue RHSVal;
1354 if (!EvaluateIntegerOrLValue(E->getRHS(), RHSVal, Info))
Daniel Dunbarca097ad2009-02-19 20:17:33 +00001355 return false;
Eli Friedman94c25c62009-03-24 01:14:50 +00001356
1357 // Handle cases like (unsigned long)&a + 4.
1358 if (E->isAdditiveOp() && Result.isLValue() && RHSVal.isInt()) {
Ken Dyck02990832010-01-15 12:37:54 +00001359 CharUnits Offset = Result.getLValueOffset();
1360 CharUnits AdditionalOffset = CharUnits::fromQuantity(
1361 RHSVal.getInt().getZExtValue());
Eli Friedman94c25c62009-03-24 01:14:50 +00001362 if (E->getOpcode() == BinaryOperator::Add)
Ken Dyck02990832010-01-15 12:37:54 +00001363 Offset += AdditionalOffset;
Eli Friedman94c25c62009-03-24 01:14:50 +00001364 else
Ken Dyck02990832010-01-15 12:37:54 +00001365 Offset -= AdditionalOffset;
1366 Result = APValue(Result.getLValueBase(), Offset);
Eli Friedman94c25c62009-03-24 01:14:50 +00001367 return true;
1368 }
1369
1370 // Handle cases like 4 + (unsigned long)&a
1371 if (E->getOpcode() == BinaryOperator::Add &&
1372 RHSVal.isLValue() && Result.isInt()) {
Ken Dyck02990832010-01-15 12:37:54 +00001373 CharUnits Offset = RHSVal.getLValueOffset();
1374 Offset += CharUnits::fromQuantity(Result.getInt().getZExtValue());
1375 Result = APValue(RHSVal.getLValueBase(), Offset);
Eli Friedman94c25c62009-03-24 01:14:50 +00001376 return true;
1377 }
1378
1379 // All the following cases expect both operands to be an integer
1380 if (!Result.isInt() || !RHSVal.isInt())
Chris Lattnere13042c2008-07-11 19:10:17 +00001381 return false;
Eli Friedman5a332ea2008-11-13 06:09:17 +00001382
Eli Friedman94c25c62009-03-24 01:14:50 +00001383 APSInt& RHS = RHSVal.getInt();
1384
Anders Carlsson9c181652008-07-08 14:35:21 +00001385 switch (E->getOpcode()) {
Chris Lattnerfac05ae2008-11-12 07:43:42 +00001386 default:
Anders Carlssonb33d6c82008-11-30 18:37:00 +00001387 return Error(E->getOperatorLoc(), diag::note_invalid_subexpr_in_ice, E);
Daniel Dunbarca097ad2009-02-19 20:17:33 +00001388 case BinaryOperator::Mul: return Success(Result.getInt() * RHS, E);
1389 case BinaryOperator::Add: return Success(Result.getInt() + RHS, E);
1390 case BinaryOperator::Sub: return Success(Result.getInt() - RHS, E);
1391 case BinaryOperator::And: return Success(Result.getInt() & RHS, E);
1392 case BinaryOperator::Xor: return Success(Result.getInt() ^ RHS, E);
1393 case BinaryOperator::Or: return Success(Result.getInt() | RHS, E);
Chris Lattnerf09ad162008-07-11 22:15:16 +00001394 case BinaryOperator::Div:
Chris Lattner99415702008-07-12 00:14:42 +00001395 if (RHS == 0)
Anders Carlssonb33d6c82008-11-30 18:37:00 +00001396 return Error(E->getOperatorLoc(), diag::note_expr_divide_by_zero, E);
Daniel Dunbarca097ad2009-02-19 20:17:33 +00001397 return Success(Result.getInt() / RHS, E);
Chris Lattnerf09ad162008-07-11 22:15:16 +00001398 case BinaryOperator::Rem:
Chris Lattner99415702008-07-12 00:14:42 +00001399 if (RHS == 0)
Anders Carlssonb33d6c82008-11-30 18:37:00 +00001400 return Error(E->getOperatorLoc(), diag::note_expr_divide_by_zero, E);
Daniel Dunbarca097ad2009-02-19 20:17:33 +00001401 return Success(Result.getInt() % RHS, E);
Daniel Dunbare3c92bc2009-02-19 18:37:50 +00001402 case BinaryOperator::Shl: {
Chris Lattner99415702008-07-12 00:14:42 +00001403 // FIXME: Warn about out of range shift amounts!
Mike Stump11289f42009-09-09 15:08:12 +00001404 unsigned SA =
Daniel Dunbarca097ad2009-02-19 20:17:33 +00001405 (unsigned) RHS.getLimitedValue(Result.getInt().getBitWidth()-1);
1406 return Success(Result.getInt() << SA, E);
Daniel Dunbare3c92bc2009-02-19 18:37:50 +00001407 }
1408 case BinaryOperator::Shr: {
Mike Stump11289f42009-09-09 15:08:12 +00001409 unsigned SA =
Daniel Dunbarca097ad2009-02-19 20:17:33 +00001410 (unsigned) RHS.getLimitedValue(Result.getInt().getBitWidth()-1);
1411 return Success(Result.getInt() >> SA, E);
Daniel Dunbare3c92bc2009-02-19 18:37:50 +00001412 }
Mike Stump11289f42009-09-09 15:08:12 +00001413
Daniel Dunbarca097ad2009-02-19 20:17:33 +00001414 case BinaryOperator::LT: return Success(Result.getInt() < RHS, E);
1415 case BinaryOperator::GT: return Success(Result.getInt() > RHS, E);
1416 case BinaryOperator::LE: return Success(Result.getInt() <= RHS, E);
1417 case BinaryOperator::GE: return Success(Result.getInt() >= RHS, E);
1418 case BinaryOperator::EQ: return Success(Result.getInt() == RHS, E);
1419 case BinaryOperator::NE: return Success(Result.getInt() != RHS, E);
Eli Friedman8553a982008-11-13 02:13:11 +00001420 }
Anders Carlsson9c181652008-07-08 14:35:21 +00001421}
1422
Nuno Lopes42042612008-11-16 19:28:31 +00001423bool IntExprEvaluator::VisitConditionalOperator(const ConditionalOperator *E) {
Nuno Lopes527b5a62008-11-16 22:06:39 +00001424 bool Cond;
1425 if (!HandleConversionToBool(E->getCond(), Cond, Info))
Nuno Lopes42042612008-11-16 19:28:31 +00001426 return false;
1427
Nuno Lopes527b5a62008-11-16 22:06:39 +00001428 return Visit(Cond ? E->getTrueExpr() : E->getFalseExpr());
Nuno Lopes42042612008-11-16 19:28:31 +00001429}
1430
Ken Dyck160146e2010-01-27 17:10:57 +00001431CharUnits IntExprEvaluator::GetAlignOfType(QualType T) {
Sebastian Redl22e2e5c2009-11-23 17:18:46 +00001432 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type,
1433 // the result is the size of the referenced type."
1434 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the
1435 // result shall be the alignment of the referenced type."
1436 if (const ReferenceType *Ref = T->getAs<ReferenceType>())
1437 T = Ref->getPointeeType();
1438
Chris Lattner24aeeab2009-01-24 21:09:06 +00001439 // Get information about the alignment.
1440 unsigned CharSize = Info.Ctx.Target.getCharWidth();
Douglas Gregoref462e62009-04-30 17:32:17 +00001441
Eli Friedmanf7f9f682009-05-30 21:09:44 +00001442 // __alignof is defined to return the preferred alignment.
Ken Dyck160146e2010-01-27 17:10:57 +00001443 return CharUnits::fromQuantity(
1444 Info.Ctx.getPreferredTypeAlign(T.getTypePtr()) / CharSize);
Chris Lattner24aeeab2009-01-24 21:09:06 +00001445}
1446
Ken Dyck160146e2010-01-27 17:10:57 +00001447CharUnits IntExprEvaluator::GetAlignOfExpr(const Expr *E) {
Chris Lattner68061312009-01-24 21:53:27 +00001448 E = E->IgnoreParens();
1449
1450 // alignof decl is always accepted, even if it doesn't make sense: we default
Mike Stump11289f42009-09-09 15:08:12 +00001451 // to 1 in those cases.
Chris Lattner68061312009-01-24 21:53:27 +00001452 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
Ken Dyck160146e2010-01-27 17:10:57 +00001453 return Info.Ctx.getDeclAlign(DRE->getDecl(),
1454 /*RefAsPointee*/true);
Eli Friedman64004332009-03-23 04:38:34 +00001455
Chris Lattner68061312009-01-24 21:53:27 +00001456 if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
Ken Dyck160146e2010-01-27 17:10:57 +00001457 return Info.Ctx.getDeclAlign(ME->getMemberDecl(),
1458 /*RefAsPointee*/true);
Chris Lattner68061312009-01-24 21:53:27 +00001459
Chris Lattner24aeeab2009-01-24 21:09:06 +00001460 return GetAlignOfType(E->getType());
1461}
1462
1463
Sebastian Redl6f282892008-11-11 17:56:53 +00001464/// VisitSizeAlignOfExpr - Evaluate a sizeof or alignof with a result as the
1465/// expression's type.
1466bool IntExprEvaluator::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) {
Chris Lattner24aeeab2009-01-24 21:09:06 +00001467 // Handle alignof separately.
1468 if (!E->isSizeOf()) {
1469 if (E->isArgumentType())
Ken Dyck160146e2010-01-27 17:10:57 +00001470 return Success(GetAlignOfType(E->getArgumentType()).getQuantity(), E);
Chris Lattner24aeeab2009-01-24 21:09:06 +00001471 else
Ken Dyck160146e2010-01-27 17:10:57 +00001472 return Success(GetAlignOfExpr(E->getArgumentExpr()).getQuantity(), E);
Chris Lattner24aeeab2009-01-24 21:09:06 +00001473 }
Eli Friedman64004332009-03-23 04:38:34 +00001474
Sebastian Redl6f282892008-11-11 17:56:53 +00001475 QualType SrcTy = E->getTypeOfArgument();
Sebastian Redl22e2e5c2009-11-23 17:18:46 +00001476 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type,
1477 // the result is the size of the referenced type."
1478 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the
1479 // result shall be the alignment of the referenced type."
1480 if (const ReferenceType *Ref = SrcTy->getAs<ReferenceType>())
1481 SrcTy = Ref->getPointeeType();
Sebastian Redl6f282892008-11-11 17:56:53 +00001482
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001483 // sizeof(void), __alignof__(void), sizeof(function) = 1 as a gcc
1484 // extension.
1485 if (SrcTy->isVoidType() || SrcTy->isFunctionType())
1486 return Success(1, E);
Eli Friedman64004332009-03-23 04:38:34 +00001487
Chris Lattnerf8d7f722008-07-11 21:24:13 +00001488 // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
Chris Lattner24aeeab2009-01-24 21:09:06 +00001489 if (!SrcTy->isConstantSizeType())
Chris Lattnerf8d7f722008-07-11 21:24:13 +00001490 return false;
Eli Friedman2aa38fe2009-01-24 22:19:05 +00001491
Chris Lattner24aeeab2009-01-24 21:09:06 +00001492 // Get information about the size.
Ken Dyck40775002010-01-11 17:06:35 +00001493 return Success(Info.Ctx.getTypeSizeInChars(SrcTy).getQuantity(), E);
Chris Lattnerf8d7f722008-07-11 21:24:13 +00001494}
1495
Douglas Gregor882211c2010-04-28 22:16:22 +00001496bool IntExprEvaluator::VisitOffsetOfExpr(const OffsetOfExpr *E) {
1497 CharUnits Result;
1498 unsigned n = E->getNumComponents();
1499 OffsetOfExpr* OOE = const_cast<OffsetOfExpr*>(E);
1500 if (n == 0)
1501 return false;
1502 QualType CurrentType = E->getTypeSourceInfo()->getType();
1503 for (unsigned i = 0; i != n; ++i) {
1504 OffsetOfExpr::OffsetOfNode ON = OOE->getComponent(i);
1505 switch (ON.getKind()) {
1506 case OffsetOfExpr::OffsetOfNode::Array: {
1507 Expr *Idx = OOE->getIndexExpr(ON.getArrayExprIndex());
1508 APSInt IdxResult;
1509 if (!EvaluateInteger(Idx, IdxResult, Info))
1510 return false;
1511 const ArrayType *AT = Info.Ctx.getAsArrayType(CurrentType);
1512 if (!AT)
1513 return false;
1514 CurrentType = AT->getElementType();
1515 CharUnits ElementSize = Info.Ctx.getTypeSizeInChars(CurrentType);
1516 Result += IdxResult.getSExtValue() * ElementSize;
1517 break;
1518 }
1519
1520 case OffsetOfExpr::OffsetOfNode::Field: {
1521 FieldDecl *MemberDecl = ON.getField();
1522 const RecordType *RT = CurrentType->getAs<RecordType>();
1523 if (!RT)
1524 return false;
1525 RecordDecl *RD = RT->getDecl();
1526 const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
1527 unsigned i = 0;
1528 // FIXME: It would be nice if we didn't have to loop here!
1529 for (RecordDecl::field_iterator Field = RD->field_begin(),
1530 FieldEnd = RD->field_end();
1531 Field != FieldEnd; (void)++Field, ++i) {
1532 if (*Field == MemberDecl)
1533 break;
1534 }
Douglas Gregord1702062010-04-29 00:18:15 +00001535 assert(i < RL.getFieldCount() && "offsetof field in wrong type");
1536 Result += CharUnits::fromQuantity(
1537 RL.getFieldOffset(i) / Info.Ctx.getCharWidth());
Douglas Gregor882211c2010-04-28 22:16:22 +00001538 CurrentType = MemberDecl->getType().getNonReferenceType();
1539 break;
1540 }
1541
1542 case OffsetOfExpr::OffsetOfNode::Identifier:
1543 llvm_unreachable("dependent __builtin_offsetof");
Douglas Gregord1702062010-04-29 00:18:15 +00001544 return false;
1545
1546 case OffsetOfExpr::OffsetOfNode::Base: {
1547 CXXBaseSpecifier *BaseSpec = ON.getBase();
1548 if (BaseSpec->isVirtual())
1549 return false;
1550
1551 // Find the layout of the class whose base we are looking into.
1552 const RecordType *RT = CurrentType->getAs<RecordType>();
1553 if (!RT)
1554 return false;
1555 RecordDecl *RD = RT->getDecl();
1556 const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
1557
1558 // Find the base class itself.
1559 CurrentType = BaseSpec->getType();
1560 const RecordType *BaseRT = CurrentType->getAs<RecordType>();
1561 if (!BaseRT)
1562 return false;
1563
1564 // Add the offset to the base.
1565 Result += CharUnits::fromQuantity(
1566 RL.getBaseClassOffset(cast<CXXRecordDecl>(BaseRT->getDecl()))
1567 / Info.Ctx.getCharWidth());
1568 break;
1569 }
Douglas Gregor882211c2010-04-28 22:16:22 +00001570 }
1571 }
1572 return Success(Result.getQuantity(), E);
1573}
1574
Chris Lattnere13042c2008-07-11 19:10:17 +00001575bool IntExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
Eli Friedman5a332ea2008-11-13 06:09:17 +00001576 if (E->getOpcode() == UnaryOperator::LNot) {
1577 // LNot's operand isn't necessarily an integer, so we handle it specially.
1578 bool bres;
1579 if (!HandleConversionToBool(E->getSubExpr(), bres, Info))
1580 return false;
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001581 return Success(!bres, E);
Eli Friedman5a332ea2008-11-13 06:09:17 +00001582 }
1583
Daniel Dunbar79e042a2009-02-21 18:14:20 +00001584 // Only handle integral operations...
Douglas Gregorb90df602010-06-16 00:17:44 +00001585 if (!E->getSubExpr()->getType()->isIntegralOrEnumerationType())
Daniel Dunbar79e042a2009-02-21 18:14:20 +00001586 return false;
1587
Chris Lattnercdf34e72008-07-11 22:52:41 +00001588 // Get the operand value into 'Result'.
1589 if (!Visit(E->getSubExpr()))
Chris Lattnerf09ad162008-07-11 22:15:16 +00001590 return false;
Anders Carlsson9c181652008-07-08 14:35:21 +00001591
Chris Lattnerf09ad162008-07-11 22:15:16 +00001592 switch (E->getOpcode()) {
Chris Lattner7174bf32008-07-12 00:38:25 +00001593 default:
Chris Lattnerf09ad162008-07-11 22:15:16 +00001594 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
1595 // See C99 6.6p3.
Anders Carlssonb33d6c82008-11-30 18:37:00 +00001596 return Error(E->getOperatorLoc(), diag::note_invalid_subexpr_in_ice, E);
Chris Lattnerf09ad162008-07-11 22:15:16 +00001597 case UnaryOperator::Extension:
Chris Lattner7174bf32008-07-12 00:38:25 +00001598 // FIXME: Should extension allow i-c-e extension expressions in its scope?
1599 // If so, we could clear the diagnostic ID.
Daniel Dunbare3c92bc2009-02-19 18:37:50 +00001600 return true;
Chris Lattnerf09ad162008-07-11 22:15:16 +00001601 case UnaryOperator::Plus:
Mike Stump11289f42009-09-09 15:08:12 +00001602 // The result is always just the subexpr.
Daniel Dunbare3c92bc2009-02-19 18:37:50 +00001603 return true;
Chris Lattnerf09ad162008-07-11 22:15:16 +00001604 case UnaryOperator::Minus:
Daniel Dunbarca097ad2009-02-19 20:17:33 +00001605 if (!Result.isInt()) return false;
1606 return Success(-Result.getInt(), E);
Chris Lattnerf09ad162008-07-11 22:15:16 +00001607 case UnaryOperator::Not:
Daniel Dunbarca097ad2009-02-19 20:17:33 +00001608 if (!Result.isInt()) return false;
1609 return Success(~Result.getInt(), E);
Anders Carlsson9c181652008-07-08 14:35:21 +00001610 }
Anders Carlsson9c181652008-07-08 14:35:21 +00001611}
Mike Stump11289f42009-09-09 15:08:12 +00001612
Chris Lattner477c4be2008-07-12 01:15:53 +00001613/// HandleCast - This is used to evaluate implicit or explicit casts where the
1614/// result type is integer.
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00001615bool IntExprEvaluator::VisitCastExpr(CastExpr *E) {
Anders Carlsson27b8c5c2008-11-30 18:14:57 +00001616 Expr *SubExpr = E->getSubExpr();
1617 QualType DestType = E->getType();
Daniel Dunbarcf04aa12009-02-19 22:16:29 +00001618 QualType SrcType = SubExpr->getType();
Anders Carlsson27b8c5c2008-11-30 18:14:57 +00001619
Eli Friedman9a156e52008-11-12 09:44:48 +00001620 if (DestType->isBooleanType()) {
1621 bool BoolResult;
1622 if (!HandleConversionToBool(SubExpr, BoolResult, Info))
1623 return false;
Daniel Dunbar8aafc892009-02-19 09:06:44 +00001624 return Success(BoolResult, E);
Eli Friedman9a156e52008-11-12 09:44:48 +00001625 }
1626
Anders Carlsson9c181652008-07-08 14:35:21 +00001627 // Handle simple integer->integer casts.
Douglas Gregorb90df602010-06-16 00:17:44 +00001628 if (SrcType->isIntegralOrEnumerationType()) {
Chris Lattner477c4be2008-07-12 01:15:53 +00001629 if (!Visit(SubExpr))
Chris Lattnere13042c2008-07-11 19:10:17 +00001630 return false;
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00001631
Eli Friedman742421e2009-02-20 01:15:07 +00001632 if (!Result.isInt()) {
1633 // Only allow casts of lvalues if they are lossless.
1634 return Info.Ctx.getTypeSize(DestType) == Info.Ctx.getTypeSize(SrcType);
1635 }
Daniel Dunbarca097ad2009-02-19 20:17:33 +00001636
Daniel Dunbar1c8560d2009-02-19 22:24:01 +00001637 return Success(HandleIntToIntCast(DestType, SrcType,
Daniel Dunbarca097ad2009-02-19 20:17:33 +00001638 Result.getInt(), Info.Ctx), E);
Chris Lattner477c4be2008-07-12 01:15:53 +00001639 }
Mike Stump11289f42009-09-09 15:08:12 +00001640
Chris Lattner477c4be2008-07-12 01:15:53 +00001641 // FIXME: Clean this up!
Daniel Dunbarcf04aa12009-02-19 22:16:29 +00001642 if (SrcType->isPointerType()) {
John McCall45d55e42010-05-07 21:00:08 +00001643 LValue LV;
Chris Lattnercdf34e72008-07-11 22:52:41 +00001644 if (!EvaluatePointer(SubExpr, LV, Info))
Chris Lattnere13042c2008-07-11 19:10:17 +00001645 return false;
Eli Friedman9a156e52008-11-12 09:44:48 +00001646
Daniel Dunbar1c8560d2009-02-19 22:24:01 +00001647 if (LV.getLValueBase()) {
1648 // Only allow based lvalue casts if they are lossless.
1649 if (Info.Ctx.getTypeSize(DestType) != Info.Ctx.getTypeSize(SrcType))
1650 return false;
Eli Friedman9a156e52008-11-12 09:44:48 +00001651
John McCall45d55e42010-05-07 21:00:08 +00001652 LV.moveInto(Result);
Daniel Dunbar1c8560d2009-02-19 22:24:01 +00001653 return true;
1654 }
1655
Ken Dyck02990832010-01-15 12:37:54 +00001656 APSInt AsInt = Info.Ctx.MakeIntValue(LV.getLValueOffset().getQuantity(),
1657 SrcType);
Daniel Dunbar1c8560d2009-02-19 22:24:01 +00001658 return Success(HandleIntToIntCast(DestType, SrcType, AsInt, Info.Ctx), E);
Anders Carlssonb5ad0212008-07-08 14:30:00 +00001659 }
Eli Friedman9a156e52008-11-12 09:44:48 +00001660
Eli Friedman742421e2009-02-20 01:15:07 +00001661 if (SrcType->isArrayType() || SrcType->isFunctionType()) {
1662 // This handles double-conversion cases, where there's both
1663 // an l-value promotion and an implicit conversion to int.
John McCall45d55e42010-05-07 21:00:08 +00001664 LValue LV;
Eli Friedman742421e2009-02-20 01:15:07 +00001665 if (!EvaluateLValue(SubExpr, LV, Info))
1666 return false;
1667
1668 if (Info.Ctx.getTypeSize(DestType) != Info.Ctx.getTypeSize(Info.Ctx.VoidPtrTy))
1669 return false;
1670
John McCall45d55e42010-05-07 21:00:08 +00001671 LV.moveInto(Result);
Eli Friedman742421e2009-02-20 01:15:07 +00001672 return true;
1673 }
1674
Eli Friedmand3a5a9d2009-04-22 19:23:09 +00001675 if (SrcType->isAnyComplexType()) {
John McCall93d91dc2010-05-07 17:22:02 +00001676 ComplexValue C;
Eli Friedmand3a5a9d2009-04-22 19:23:09 +00001677 if (!EvaluateComplex(SubExpr, C, Info))
1678 return false;
1679 if (C.isComplexFloat())
1680 return Success(HandleFloatToIntCast(DestType, SrcType,
1681 C.getComplexFloatReal(), Info.Ctx),
1682 E);
1683 else
1684 return Success(HandleIntToIntCast(DestType, SrcType,
1685 C.getComplexIntReal(), Info.Ctx), E);
1686 }
Eli Friedmanc2b50172009-02-22 11:46:18 +00001687 // FIXME: Handle vectors
1688
Daniel Dunbarcf04aa12009-02-19 22:16:29 +00001689 if (!SrcType->isRealFloatingType())
Anders Carlssonb33d6c82008-11-30 18:37:00 +00001690 return Error(E->getExprLoc(), diag::note_invalid_subexpr_in_ice, E);
Chris Lattner477c4be2008-07-12 01:15:53 +00001691
Eli Friedman24c01542008-08-22 00:06:13 +00001692 APFloat F(0.0);
1693 if (!EvaluateFloat(SubExpr, F, Info))
Anders Carlssonb33d6c82008-11-30 18:37:00 +00001694 return Error(E->getExprLoc(), diag::note_invalid_subexpr_in_ice, E);
Mike Stump11289f42009-09-09 15:08:12 +00001695
Daniel Dunbarcf04aa12009-02-19 22:16:29 +00001696 return Success(HandleFloatToIntCast(DestType, SrcType, F, Info.Ctx), E);
Anders Carlsson9c181652008-07-08 14:35:21 +00001697}
Anders Carlssonb5ad0212008-07-08 14:30:00 +00001698
Eli Friedmana1c7b6c2009-02-28 03:59:05 +00001699bool IntExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
1700 if (E->getSubExpr()->getType()->isAnyComplexType()) {
John McCall93d91dc2010-05-07 17:22:02 +00001701 ComplexValue LV;
Eli Friedmana1c7b6c2009-02-28 03:59:05 +00001702 if (!EvaluateComplex(E->getSubExpr(), LV, Info) || !LV.isComplexInt())
1703 return Error(E->getExprLoc(), diag::note_invalid_subexpr_in_ice, E);
1704 return Success(LV.getComplexIntReal(), E);
1705 }
1706
1707 return Visit(E->getSubExpr());
1708}
1709
Eli Friedman4e7a2412009-02-27 04:45:43 +00001710bool IntExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
Eli Friedmana1c7b6c2009-02-28 03:59:05 +00001711 if (E->getSubExpr()->getType()->isComplexIntegerType()) {
John McCall93d91dc2010-05-07 17:22:02 +00001712 ComplexValue LV;
Eli Friedmana1c7b6c2009-02-28 03:59:05 +00001713 if (!EvaluateComplex(E->getSubExpr(), LV, Info) || !LV.isComplexInt())
1714 return Error(E->getExprLoc(), diag::note_invalid_subexpr_in_ice, E);
1715 return Success(LV.getComplexIntImag(), E);
1716 }
1717
Eli Friedman4e7a2412009-02-27 04:45:43 +00001718 if (!E->getSubExpr()->isEvaluatable(Info.Ctx))
1719 Info.EvalResult.HasSideEffects = true;
1720 return Success(0, E);
1721}
1722
Chris Lattner05706e882008-07-11 18:11:29 +00001723//===----------------------------------------------------------------------===//
Eli Friedman24c01542008-08-22 00:06:13 +00001724// Float Evaluation
1725//===----------------------------------------------------------------------===//
1726
1727namespace {
Benjamin Kramer26222b62009-11-28 19:03:38 +00001728class FloatExprEvaluator
Eli Friedman24c01542008-08-22 00:06:13 +00001729 : public StmtVisitor<FloatExprEvaluator, bool> {
1730 EvalInfo &Info;
1731 APFloat &Result;
1732public:
1733 FloatExprEvaluator(EvalInfo &info, APFloat &result)
1734 : Info(info), Result(result) {}
1735
1736 bool VisitStmt(Stmt *S) {
1737 return false;
1738 }
1739
1740 bool VisitParenExpr(ParenExpr *E) { return Visit(E->getSubExpr()); }
Chris Lattner4deaa4e2008-10-06 05:28:25 +00001741 bool VisitCallExpr(const CallExpr *E);
Eli Friedman24c01542008-08-22 00:06:13 +00001742
Daniel Dunbarc3d79cf2008-10-16 03:51:50 +00001743 bool VisitUnaryOperator(const UnaryOperator *E);
Eli Friedman24c01542008-08-22 00:06:13 +00001744 bool VisitBinaryOperator(const BinaryOperator *E);
1745 bool VisitFloatingLiteral(const FloatingLiteral *E);
Eli Friedman9a156e52008-11-12 09:44:48 +00001746 bool VisitCastExpr(CastExpr *E);
Douglas Gregor747eb782010-07-08 06:14:04 +00001747 bool VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
Eli Friedmanf3da3342009-12-04 02:12:53 +00001748 bool VisitConditionalOperator(ConditionalOperator *E);
Eli Friedmanc2b50172009-02-22 11:46:18 +00001749
Eli Friedman449fe542009-03-23 04:56:01 +00001750 bool VisitChooseExpr(const ChooseExpr *E)
1751 { return Visit(E->getChosenSubExpr(Info.Ctx)); }
1752 bool VisitUnaryExtension(const UnaryOperator *E)
1753 { return Visit(E->getSubExpr()); }
John McCallb1fb0d32010-05-07 22:08:54 +00001754 bool VisitUnaryReal(const UnaryOperator *E);
1755 bool VisitUnaryImag(const UnaryOperator *E);
Eli Friedman449fe542009-03-23 04:56:01 +00001756
John McCallb1fb0d32010-05-07 22:08:54 +00001757 // FIXME: Missing: array subscript of vector, member of vector,
1758 // ImplicitValueInitExpr
Eli Friedman24c01542008-08-22 00:06:13 +00001759};
1760} // end anonymous namespace
1761
1762static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
John McCallf0c4f352010-05-07 05:46:35 +00001763 assert(E->getType()->isRealFloatingType());
Eli Friedman24c01542008-08-22 00:06:13 +00001764 return FloatExprEvaluator(Info, Result).Visit(const_cast<Expr*>(E));
1765}
1766
John McCall16291492010-02-28 13:00:19 +00001767static bool TryEvaluateBuiltinNaN(ASTContext &Context,
1768 QualType ResultTy,
1769 const Expr *Arg,
1770 bool SNaN,
1771 llvm::APFloat &Result) {
1772 const StringLiteral *S = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());
1773 if (!S) return false;
1774
1775 const llvm::fltSemantics &Sem = Context.getFloatTypeSemantics(ResultTy);
1776
1777 llvm::APInt fill;
1778
1779 // Treat empty strings as if they were zero.
1780 if (S->getString().empty())
1781 fill = llvm::APInt(32, 0);
1782 else if (S->getString().getAsInteger(0, fill))
1783 return false;
1784
1785 if (SNaN)
1786 Result = llvm::APFloat::getSNaN(Sem, false, &fill);
1787 else
1788 Result = llvm::APFloat::getQNaN(Sem, false, &fill);
1789 return true;
1790}
1791
Chris Lattner4deaa4e2008-10-06 05:28:25 +00001792bool FloatExprEvaluator::VisitCallExpr(const CallExpr *E) {
Douglas Gregore711f702009-02-14 18:57:46 +00001793 switch (E->isBuiltinCall(Info.Ctx)) {
Chris Lattner37346e02008-10-06 05:53:16 +00001794 default: return false;
Chris Lattner4deaa4e2008-10-06 05:28:25 +00001795 case Builtin::BI__builtin_huge_val:
1796 case Builtin::BI__builtin_huge_valf:
1797 case Builtin::BI__builtin_huge_vall:
1798 case Builtin::BI__builtin_inf:
1799 case Builtin::BI__builtin_inff:
Daniel Dunbar1be9f882008-10-14 05:41:12 +00001800 case Builtin::BI__builtin_infl: {
1801 const llvm::fltSemantics &Sem =
1802 Info.Ctx.getFloatTypeSemantics(E->getType());
Chris Lattner37346e02008-10-06 05:53:16 +00001803 Result = llvm::APFloat::getInf(Sem);
1804 return true;
Daniel Dunbar1be9f882008-10-14 05:41:12 +00001805 }
Mike Stump11289f42009-09-09 15:08:12 +00001806
John McCall16291492010-02-28 13:00:19 +00001807 case Builtin::BI__builtin_nans:
1808 case Builtin::BI__builtin_nansf:
1809 case Builtin::BI__builtin_nansl:
1810 return TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
1811 true, Result);
1812
Chris Lattner0b7282e2008-10-06 06:31:58 +00001813 case Builtin::BI__builtin_nan:
1814 case Builtin::BI__builtin_nanf:
1815 case Builtin::BI__builtin_nanl:
Mike Stump2346cd22009-05-30 03:56:50 +00001816 // If this is __builtin_nan() turn this into a nan, otherwise we
Chris Lattner0b7282e2008-10-06 06:31:58 +00001817 // can't constant fold it.
John McCall16291492010-02-28 13:00:19 +00001818 return TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
1819 false, Result);
Daniel Dunbarc3d79cf2008-10-16 03:51:50 +00001820
1821 case Builtin::BI__builtin_fabs:
1822 case Builtin::BI__builtin_fabsf:
1823 case Builtin::BI__builtin_fabsl:
1824 if (!EvaluateFloat(E->getArg(0), Result, Info))
1825 return false;
Mike Stump11289f42009-09-09 15:08:12 +00001826
Daniel Dunbarc3d79cf2008-10-16 03:51:50 +00001827 if (Result.isNegative())
1828 Result.changeSign();
1829 return true;
1830
Mike Stump11289f42009-09-09 15:08:12 +00001831 case Builtin::BI__builtin_copysign:
1832 case Builtin::BI__builtin_copysignf:
Daniel Dunbarc3d79cf2008-10-16 03:51:50 +00001833 case Builtin::BI__builtin_copysignl: {
1834 APFloat RHS(0.);
1835 if (!EvaluateFloat(E->getArg(0), Result, Info) ||
1836 !EvaluateFloat(E->getArg(1), RHS, Info))
1837 return false;
1838 Result.copySign(RHS);
1839 return true;
1840 }
Chris Lattner4deaa4e2008-10-06 05:28:25 +00001841 }
1842}
1843
John McCallb1fb0d32010-05-07 22:08:54 +00001844bool FloatExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
Eli Friedman95719532010-08-14 20:52:13 +00001845 if (E->getSubExpr()->getType()->isAnyComplexType()) {
1846 ComplexValue CV;
1847 if (!EvaluateComplex(E->getSubExpr(), CV, Info))
1848 return false;
1849 Result = CV.FloatReal;
1850 return true;
1851 }
1852
1853 return Visit(E->getSubExpr());
John McCallb1fb0d32010-05-07 22:08:54 +00001854}
1855
1856bool FloatExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
Eli Friedman95719532010-08-14 20:52:13 +00001857 if (E->getSubExpr()->getType()->isAnyComplexType()) {
1858 ComplexValue CV;
1859 if (!EvaluateComplex(E->getSubExpr(), CV, Info))
1860 return false;
1861 Result = CV.FloatImag;
1862 return true;
1863 }
1864
1865 if (!E->getSubExpr()->isEvaluatable(Info.Ctx))
1866 Info.EvalResult.HasSideEffects = true;
1867 const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(E->getType());
1868 Result = llvm::APFloat::getZero(Sem);
John McCallb1fb0d32010-05-07 22:08:54 +00001869 return true;
1870}
1871
Daniel Dunbarc3d79cf2008-10-16 03:51:50 +00001872bool FloatExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
Nuno Lopes0e33c682008-11-19 17:44:31 +00001873 if (E->getOpcode() == UnaryOperator::Deref)
1874 return false;
1875
Daniel Dunbarc3d79cf2008-10-16 03:51:50 +00001876 if (!EvaluateFloat(E->getSubExpr(), Result, Info))
1877 return false;
1878
1879 switch (E->getOpcode()) {
1880 default: return false;
Mike Stump11289f42009-09-09 15:08:12 +00001881 case UnaryOperator::Plus:
Daniel Dunbarc3d79cf2008-10-16 03:51:50 +00001882 return true;
1883 case UnaryOperator::Minus:
1884 Result.changeSign();
1885 return true;
1886 }
1887}
Chris Lattner4deaa4e2008-10-06 05:28:25 +00001888
Eli Friedman24c01542008-08-22 00:06:13 +00001889bool FloatExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
Eli Friedman141fbf32009-11-16 04:25:37 +00001890 if (E->getOpcode() == BinaryOperator::Comma) {
1891 if (!EvaluateFloat(E->getRHS(), Result, Info))
1892 return false;
1893
1894 // If we can't evaluate the LHS, it might have side effects;
1895 // conservatively mark it.
1896 if (!E->getLHS()->isEvaluatable(Info.Ctx))
1897 Info.EvalResult.HasSideEffects = true;
1898
1899 return true;
1900 }
1901
Eli Friedman24c01542008-08-22 00:06:13 +00001902 // FIXME: Diagnostics? I really don't understand how the warnings
1903 // and errors are supposed to work.
Daniel Dunbarc3d79cf2008-10-16 03:51:50 +00001904 APFloat RHS(0.0);
Eli Friedman24c01542008-08-22 00:06:13 +00001905 if (!EvaluateFloat(E->getLHS(), Result, Info))
1906 return false;
1907 if (!EvaluateFloat(E->getRHS(), RHS, Info))
1908 return false;
1909
1910 switch (E->getOpcode()) {
1911 default: return false;
1912 case BinaryOperator::Mul:
1913 Result.multiply(RHS, APFloat::rmNearestTiesToEven);
1914 return true;
1915 case BinaryOperator::Add:
1916 Result.add(RHS, APFloat::rmNearestTiesToEven);
1917 return true;
1918 case BinaryOperator::Sub:
1919 Result.subtract(RHS, APFloat::rmNearestTiesToEven);
1920 return true;
1921 case BinaryOperator::Div:
1922 Result.divide(RHS, APFloat::rmNearestTiesToEven);
1923 return true;
Eli Friedman24c01542008-08-22 00:06:13 +00001924 }
1925}
1926
1927bool FloatExprEvaluator::VisitFloatingLiteral(const FloatingLiteral *E) {
1928 Result = E->getValue();
1929 return true;
1930}
1931
Eli Friedman9a156e52008-11-12 09:44:48 +00001932bool FloatExprEvaluator::VisitCastExpr(CastExpr *E) {
1933 Expr* SubExpr = E->getSubExpr();
Mike Stump11289f42009-09-09 15:08:12 +00001934
Douglas Gregorb90df602010-06-16 00:17:44 +00001935 if (SubExpr->getType()->isIntegralOrEnumerationType()) {
Eli Friedman9a156e52008-11-12 09:44:48 +00001936 APSInt IntResult;
Daniel Dunbare3c92bc2009-02-19 18:37:50 +00001937 if (!EvaluateInteger(SubExpr, IntResult, Info))
Eli Friedman9a156e52008-11-12 09:44:48 +00001938 return false;
Mike Stump11289f42009-09-09 15:08:12 +00001939 Result = HandleIntToFloatCast(E->getType(), SubExpr->getType(),
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00001940 IntResult, Info.Ctx);
Eli Friedman9a156e52008-11-12 09:44:48 +00001941 return true;
1942 }
1943 if (SubExpr->getType()->isRealFloatingType()) {
1944 if (!Visit(SubExpr))
1945 return false;
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00001946 Result = HandleFloatToFloatCast(E->getType(), SubExpr->getType(),
1947 Result, Info.Ctx);
Eli Friedman9a156e52008-11-12 09:44:48 +00001948 return true;
1949 }
Eli Friedmanc2b50172009-02-22 11:46:18 +00001950 // FIXME: Handle complex types
Eli Friedman9a156e52008-11-12 09:44:48 +00001951
1952 return false;
1953}
1954
Douglas Gregor747eb782010-07-08 06:14:04 +00001955bool FloatExprEvaluator::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
Eli Friedman9a156e52008-11-12 09:44:48 +00001956 Result = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(E->getType()));
1957 return true;
1958}
1959
Eli Friedmanf3da3342009-12-04 02:12:53 +00001960bool FloatExprEvaluator::VisitConditionalOperator(ConditionalOperator *E) {
1961 bool Cond;
1962 if (!HandleConversionToBool(E->getCond(), Cond, Info))
1963 return false;
1964
1965 return Visit(Cond ? E->getTrueExpr() : E->getFalseExpr());
1966}
1967
Eli Friedman24c01542008-08-22 00:06:13 +00001968//===----------------------------------------------------------------------===//
Daniel Dunbarf50e60b2009-01-28 22:24:07 +00001969// Complex Evaluation (for float and integer)
Anders Carlsson537969c2008-11-16 20:27:53 +00001970//===----------------------------------------------------------------------===//
1971
1972namespace {
Benjamin Kramer26222b62009-11-28 19:03:38 +00001973class ComplexExprEvaluator
John McCall93d91dc2010-05-07 17:22:02 +00001974 : public StmtVisitor<ComplexExprEvaluator, bool> {
Anders Carlsson537969c2008-11-16 20:27:53 +00001975 EvalInfo &Info;
John McCall93d91dc2010-05-07 17:22:02 +00001976 ComplexValue &Result;
Mike Stump11289f42009-09-09 15:08:12 +00001977
Anders Carlsson537969c2008-11-16 20:27:53 +00001978public:
John McCall93d91dc2010-05-07 17:22:02 +00001979 ComplexExprEvaluator(EvalInfo &info, ComplexValue &Result)
1980 : Info(info), Result(Result) {}
Mike Stump11289f42009-09-09 15:08:12 +00001981
Anders Carlsson537969c2008-11-16 20:27:53 +00001982 //===--------------------------------------------------------------------===//
1983 // Visitor Methods
1984 //===--------------------------------------------------------------------===//
1985
John McCall93d91dc2010-05-07 17:22:02 +00001986 bool VisitStmt(Stmt *S) {
1987 return false;
Anders Carlsson537969c2008-11-16 20:27:53 +00001988 }
Mike Stump11289f42009-09-09 15:08:12 +00001989
John McCall93d91dc2010-05-07 17:22:02 +00001990 bool VisitParenExpr(ParenExpr *E) { return Visit(E->getSubExpr()); }
Anders Carlsson537969c2008-11-16 20:27:53 +00001991
John McCall93d91dc2010-05-07 17:22:02 +00001992 bool VisitImaginaryLiteral(ImaginaryLiteral *E) {
Daniel Dunbarf50e60b2009-01-28 22:24:07 +00001993 Expr* SubExpr = E->getSubExpr();
1994
1995 if (SubExpr->getType()->isRealFloatingType()) {
John McCall93d91dc2010-05-07 17:22:02 +00001996 Result.makeComplexFloat();
1997 APFloat &Imag = Result.FloatImag;
1998 if (!EvaluateFloat(SubExpr, Imag, Info))
1999 return false;
Daniel Dunbarf50e60b2009-01-28 22:24:07 +00002000
John McCall93d91dc2010-05-07 17:22:02 +00002001 Result.FloatReal = APFloat(Imag.getSemantics());
2002 return true;
Daniel Dunbarf50e60b2009-01-28 22:24:07 +00002003 } else {
Mike Stump11289f42009-09-09 15:08:12 +00002004 assert(SubExpr->getType()->isIntegerType() &&
Daniel Dunbarf50e60b2009-01-28 22:24:07 +00002005 "Unexpected imaginary literal.");
2006
John McCall93d91dc2010-05-07 17:22:02 +00002007 Result.makeComplexInt();
2008 APSInt &Imag = Result.IntImag;
2009 if (!EvaluateInteger(SubExpr, Imag, Info))
2010 return false;
Mike Stump11289f42009-09-09 15:08:12 +00002011
John McCall93d91dc2010-05-07 17:22:02 +00002012 Result.IntReal = APSInt(Imag.getBitWidth(), !Imag.isSigned());
2013 return true;
Daniel Dunbarf50e60b2009-01-28 22:24:07 +00002014 }
Anders Carlsson537969c2008-11-16 20:27:53 +00002015 }
2016
John McCall93d91dc2010-05-07 17:22:02 +00002017 bool VisitCastExpr(CastExpr *E) {
Anders Carlsson9ddf7be2008-11-16 21:51:21 +00002018 Expr* SubExpr = E->getSubExpr();
John McCall9dd450b2009-09-21 23:43:11 +00002019 QualType EltType = E->getType()->getAs<ComplexType>()->getElementType();
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00002020 QualType SubType = SubExpr->getType();
Anders Carlsson9ddf7be2008-11-16 21:51:21 +00002021
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00002022 if (SubType->isRealFloatingType()) {
John McCall93d91dc2010-05-07 17:22:02 +00002023 APFloat &Real = Result.FloatReal;
2024 if (!EvaluateFloat(SubExpr, Real, Info))
2025 return false;
Eli Friedmand3a5a9d2009-04-22 19:23:09 +00002026
2027 if (EltType->isRealFloatingType()) {
John McCall93d91dc2010-05-07 17:22:02 +00002028 Result.makeComplexFloat();
2029 Real = HandleFloatToFloatCast(EltType, SubType, Real, Info.Ctx);
2030 Result.FloatImag = APFloat(Real.getSemantics());
2031 return true;
Eli Friedmand3a5a9d2009-04-22 19:23:09 +00002032 } else {
John McCall93d91dc2010-05-07 17:22:02 +00002033 Result.makeComplexInt();
2034 Result.IntReal = HandleFloatToIntCast(EltType, SubType, Real, Info.Ctx);
2035 Result.IntImag = APSInt(Result.IntReal.getBitWidth(),
2036 !Result.IntReal.isSigned());
2037 return true;
Eli Friedmand3a5a9d2009-04-22 19:23:09 +00002038 }
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00002039 } else if (SubType->isIntegerType()) {
John McCall93d91dc2010-05-07 17:22:02 +00002040 APSInt &Real = Result.IntReal;
2041 if (!EvaluateInteger(SubExpr, Real, Info))
2042 return false;
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00002043
Eli Friedmand3a5a9d2009-04-22 19:23:09 +00002044 if (EltType->isRealFloatingType()) {
John McCall93d91dc2010-05-07 17:22:02 +00002045 Result.makeComplexFloat();
2046 Result.FloatReal
2047 = HandleIntToFloatCast(EltType, SubType, Real, Info.Ctx);
2048 Result.FloatImag = APFloat(Result.FloatReal.getSemantics());
2049 return true;
Eli Friedmand3a5a9d2009-04-22 19:23:09 +00002050 } else {
John McCall93d91dc2010-05-07 17:22:02 +00002051 Result.makeComplexInt();
2052 Real = HandleIntToIntCast(EltType, SubType, Real, Info.Ctx);
2053 Result.IntImag = APSInt(Real.getBitWidth(), !Real.isSigned());
2054 return true;
Eli Friedmand3a5a9d2009-04-22 19:23:09 +00002055 }
John McCall9dd450b2009-09-21 23:43:11 +00002056 } else if (const ComplexType *CT = SubType->getAs<ComplexType>()) {
John McCall93d91dc2010-05-07 17:22:02 +00002057 if (!Visit(SubExpr))
2058 return false;
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00002059
2060 QualType SrcType = CT->getElementType();
2061
John McCall93d91dc2010-05-07 17:22:02 +00002062 if (Result.isComplexFloat()) {
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00002063 if (EltType->isRealFloatingType()) {
John McCall93d91dc2010-05-07 17:22:02 +00002064 Result.makeComplexFloat();
2065 Result.FloatReal = HandleFloatToFloatCast(EltType, SrcType,
2066 Result.FloatReal,
2067 Info.Ctx);
2068 Result.FloatImag = HandleFloatToFloatCast(EltType, SrcType,
2069 Result.FloatImag,
2070 Info.Ctx);
2071 return true;
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00002072 } else {
John McCall93d91dc2010-05-07 17:22:02 +00002073 Result.makeComplexInt();
2074 Result.IntReal = HandleFloatToIntCast(EltType, SrcType,
2075 Result.FloatReal,
2076 Info.Ctx);
2077 Result.IntImag = HandleFloatToIntCast(EltType, SrcType,
2078 Result.FloatImag,
2079 Info.Ctx);
2080 return true;
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00002081 }
2082 } else {
John McCall93d91dc2010-05-07 17:22:02 +00002083 assert(Result.isComplexInt() && "Invalid evaluate result.");
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00002084 if (EltType->isRealFloatingType()) {
John McCall93d91dc2010-05-07 17:22:02 +00002085 Result.makeComplexFloat();
2086 Result.FloatReal = HandleIntToFloatCast(EltType, SrcType,
2087 Result.IntReal,
2088 Info.Ctx);
2089 Result.FloatImag = HandleIntToFloatCast(EltType, SrcType,
2090 Result.IntImag,
2091 Info.Ctx);
2092 return true;
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00002093 } else {
John McCall93d91dc2010-05-07 17:22:02 +00002094 Result.makeComplexInt();
2095 Result.IntReal = HandleIntToIntCast(EltType, SrcType,
2096 Result.IntReal,
2097 Info.Ctx);
2098 Result.IntImag = HandleIntToIntCast(EltType, SrcType,
2099 Result.IntImag,
2100 Info.Ctx);
2101 return true;
Daniel Dunbarb6f953e2009-01-29 06:16:07 +00002102 }
2103 }
Anders Carlsson9ddf7be2008-11-16 21:51:21 +00002104 }
2105
2106 // FIXME: Handle more casts.
John McCall93d91dc2010-05-07 17:22:02 +00002107 return false;
Anders Carlsson9ddf7be2008-11-16 21:51:21 +00002108 }
Mike Stump11289f42009-09-09 15:08:12 +00002109
John McCall93d91dc2010-05-07 17:22:02 +00002110 bool VisitBinaryOperator(const BinaryOperator *E);
2111 bool VisitChooseExpr(const ChooseExpr *E)
Eli Friedman449fe542009-03-23 04:56:01 +00002112 { return Visit(E->getChosenSubExpr(Info.Ctx)); }
John McCall93d91dc2010-05-07 17:22:02 +00002113 bool VisitUnaryExtension(const UnaryOperator *E)
Eli Friedman449fe542009-03-23 04:56:01 +00002114 { return Visit(E->getSubExpr()); }
2115 // FIXME Missing: unary +/-/~, binary div, ImplicitValueInitExpr,
Eli Friedmanc2b50172009-02-22 11:46:18 +00002116 // conditional ?:, comma
Anders Carlsson537969c2008-11-16 20:27:53 +00002117};
2118} // end anonymous namespace
2119
John McCall93d91dc2010-05-07 17:22:02 +00002120static bool EvaluateComplex(const Expr *E, ComplexValue &Result,
2121 EvalInfo &Info) {
John McCallf0c4f352010-05-07 05:46:35 +00002122 assert(E->getType()->isAnyComplexType());
John McCall93d91dc2010-05-07 17:22:02 +00002123 return ComplexExprEvaluator(Info, Result).Visit(const_cast<Expr*>(E));
Anders Carlsson537969c2008-11-16 20:27:53 +00002124}
2125
John McCall93d91dc2010-05-07 17:22:02 +00002126bool ComplexExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
2127 if (!Visit(E->getLHS()))
2128 return false;
Mike Stump11289f42009-09-09 15:08:12 +00002129
John McCall93d91dc2010-05-07 17:22:02 +00002130 ComplexValue RHS;
Daniel Dunbarf50e60b2009-01-28 22:24:07 +00002131 if (!EvaluateComplex(E->getRHS(), RHS, Info))
John McCall93d91dc2010-05-07 17:22:02 +00002132 return false;
Daniel Dunbarf50e60b2009-01-28 22:24:07 +00002133
Daniel Dunbar0aa26062009-01-29 01:32:56 +00002134 assert(Result.isComplexFloat() == RHS.isComplexFloat() &&
2135 "Invalid operands to binary operator.");
Anders Carlsson9ddf7be2008-11-16 21:51:21 +00002136 switch (E->getOpcode()) {
John McCall93d91dc2010-05-07 17:22:02 +00002137 default: return false;
Anders Carlsson9ddf7be2008-11-16 21:51:21 +00002138 case BinaryOperator::Add:
Daniel Dunbarf50e60b2009-01-28 22:24:07 +00002139 if (Result.isComplexFloat()) {
2140 Result.getComplexFloatReal().add(RHS.getComplexFloatReal(),
2141 APFloat::rmNearestTiesToEven);
2142 Result.getComplexFloatImag().add(RHS.getComplexFloatImag(),
2143 APFloat::rmNearestTiesToEven);
2144 } else {
2145 Result.getComplexIntReal() += RHS.getComplexIntReal();
2146 Result.getComplexIntImag() += RHS.getComplexIntImag();
2147 }
Daniel Dunbar0aa26062009-01-29 01:32:56 +00002148 break;
Anders Carlsson9ddf7be2008-11-16 21:51:21 +00002149 case BinaryOperator::Sub:
Daniel Dunbarf50e60b2009-01-28 22:24:07 +00002150 if (Result.isComplexFloat()) {
2151 Result.getComplexFloatReal().subtract(RHS.getComplexFloatReal(),
2152 APFloat::rmNearestTiesToEven);
2153 Result.getComplexFloatImag().subtract(RHS.getComplexFloatImag(),
2154 APFloat::rmNearestTiesToEven);
2155 } else {
2156 Result.getComplexIntReal() -= RHS.getComplexIntReal();
2157 Result.getComplexIntImag() -= RHS.getComplexIntImag();
2158 }
Daniel Dunbar0aa26062009-01-29 01:32:56 +00002159 break;
2160 case BinaryOperator::Mul:
2161 if (Result.isComplexFloat()) {
John McCall93d91dc2010-05-07 17:22:02 +00002162 ComplexValue LHS = Result;
Daniel Dunbar0aa26062009-01-29 01:32:56 +00002163 APFloat &LHS_r = LHS.getComplexFloatReal();
2164 APFloat &LHS_i = LHS.getComplexFloatImag();
2165 APFloat &RHS_r = RHS.getComplexFloatReal();
2166 APFloat &RHS_i = RHS.getComplexFloatImag();
Mike Stump11289f42009-09-09 15:08:12 +00002167
Daniel Dunbar0aa26062009-01-29 01:32:56 +00002168 APFloat Tmp = LHS_r;
2169 Tmp.multiply(RHS_r, APFloat::rmNearestTiesToEven);
2170 Result.getComplexFloatReal() = Tmp;
2171 Tmp = LHS_i;
2172 Tmp.multiply(RHS_i, APFloat::rmNearestTiesToEven);
2173 Result.getComplexFloatReal().subtract(Tmp, APFloat::rmNearestTiesToEven);
2174
2175 Tmp = LHS_r;
2176 Tmp.multiply(RHS_i, APFloat::rmNearestTiesToEven);
2177 Result.getComplexFloatImag() = Tmp;
2178 Tmp = LHS_i;
2179 Tmp.multiply(RHS_r, APFloat::rmNearestTiesToEven);
2180 Result.getComplexFloatImag().add(Tmp, APFloat::rmNearestTiesToEven);
2181 } else {
John McCall93d91dc2010-05-07 17:22:02 +00002182 ComplexValue LHS = Result;
Mike Stump11289f42009-09-09 15:08:12 +00002183 Result.getComplexIntReal() =
Daniel Dunbar0aa26062009-01-29 01:32:56 +00002184 (LHS.getComplexIntReal() * RHS.getComplexIntReal() -
2185 LHS.getComplexIntImag() * RHS.getComplexIntImag());
Mike Stump11289f42009-09-09 15:08:12 +00002186 Result.getComplexIntImag() =
Daniel Dunbar0aa26062009-01-29 01:32:56 +00002187 (LHS.getComplexIntReal() * RHS.getComplexIntImag() +
2188 LHS.getComplexIntImag() * RHS.getComplexIntReal());
2189 }
2190 break;
Anders Carlsson9ddf7be2008-11-16 21:51:21 +00002191 }
2192
John McCall93d91dc2010-05-07 17:22:02 +00002193 return true;
Anders Carlsson9ddf7be2008-11-16 21:51:21 +00002194}
2195
Anders Carlsson537969c2008-11-16 20:27:53 +00002196//===----------------------------------------------------------------------===//
Chris Lattner67d7b922008-11-16 21:24:15 +00002197// Top level Expr::Evaluate method.
Chris Lattner05706e882008-07-11 18:11:29 +00002198//===----------------------------------------------------------------------===//
2199
John McCall95007602010-05-10 23:27:23 +00002200/// Evaluate - Return true if this is a constant which we can fold using
2201/// any crazy technique (that has nothing to do with language standards) that
2202/// we want to. If this function returns true, it returns the folded constant
2203/// in Result.
2204bool Expr::Evaluate(EvalResult &Result, ASTContext &Ctx) const {
2205 const Expr *E = this;
2206 EvalInfo Info(Ctx, Result);
John McCall45d55e42010-05-07 21:00:08 +00002207 if (E->getType()->isVectorType()) {
2208 if (!EvaluateVector(E, Info.EvalResult.Val, Info))
Nate Begeman2f2bdeb2009-01-18 03:20:47 +00002209 return false;
John McCall45d55e42010-05-07 21:00:08 +00002210 } else if (E->getType()->isIntegerType()) {
2211 if (!IntExprEvaluator(Info, Info.EvalResult.Val).Visit(const_cast<Expr*>(E)))
Anders Carlsson475f4bc2008-11-22 21:50:49 +00002212 return false;
John McCall11086fc2010-07-07 05:08:32 +00002213 if (Result.Val.isLValue() && !IsGlobalLValue(Result.Val.getLValueBase()))
2214 return false;
John McCall45d55e42010-05-07 21:00:08 +00002215 } else if (E->getType()->hasPointerRepresentation()) {
2216 LValue LV;
2217 if (!EvaluatePointer(E, LV, Info))
Anders Carlsson475f4bc2008-11-22 21:50:49 +00002218 return false;
Abramo Bagnaraf8199452010-05-14 17:07:14 +00002219 if (!IsGlobalLValue(LV.Base))
John McCall95007602010-05-10 23:27:23 +00002220 return false;
John McCall45d55e42010-05-07 21:00:08 +00002221 LV.moveInto(Info.EvalResult.Val);
2222 } else if (E->getType()->isRealFloatingType()) {
2223 llvm::APFloat F(0.0);
2224 if (!EvaluateFloat(E, F, Info))
Anders Carlsson475f4bc2008-11-22 21:50:49 +00002225 return false;
Mike Stump11289f42009-09-09 15:08:12 +00002226
John McCall45d55e42010-05-07 21:00:08 +00002227 Info.EvalResult.Val = APValue(F);
2228 } else if (E->getType()->isAnyComplexType()) {
2229 ComplexValue C;
2230 if (!EvaluateComplex(E, C, Info))
Anders Carlsson475f4bc2008-11-22 21:50:49 +00002231 return false;
John McCall45d55e42010-05-07 21:00:08 +00002232 C.moveInto(Info.EvalResult.Val);
Daniel Dunbarf50e60b2009-01-28 22:24:07 +00002233 } else
Anders Carlsson7c282e42008-11-22 22:56:32 +00002234 return false;
Anders Carlsson475f4bc2008-11-22 21:50:49 +00002235
Anders Carlsson7b6f0af2008-11-30 16:58:53 +00002236 return true;
2237}
2238
John McCall1be1c632010-01-05 23:42:56 +00002239bool Expr::EvaluateAsBooleanCondition(bool &Result, ASTContext &Ctx) const {
2240 EvalResult Scratch;
2241 EvalInfo Info(Ctx, Scratch);
2242
2243 return HandleConversionToBool(this, Result, Info);
2244}
2245
Anders Carlsson43168122009-04-10 04:54:13 +00002246bool Expr::EvaluateAsLValue(EvalResult &Result, ASTContext &Ctx) const {
2247 EvalInfo Info(Ctx, Result);
2248
John McCall45d55e42010-05-07 21:00:08 +00002249 LValue LV;
John McCall95007602010-05-10 23:27:23 +00002250 if (EvaluateLValue(this, LV, Info) &&
2251 !Result.HasSideEffects &&
Abramo Bagnaraf8199452010-05-14 17:07:14 +00002252 IsGlobalLValue(LV.Base)) {
2253 LV.moveInto(Result.Val);
2254 return true;
2255 }
2256 return false;
2257}
2258
2259bool Expr::EvaluateAsAnyLValue(EvalResult &Result, ASTContext &Ctx) const {
2260 EvalInfo Info(Ctx, Result);
2261
2262 LValue LV;
2263 if (EvaluateLValue(this, LV, Info)) {
John McCall45d55e42010-05-07 21:00:08 +00002264 LV.moveInto(Result.Val);
2265 return true;
2266 }
2267 return false;
Eli Friedman7d45c482009-09-13 10:17:44 +00002268}
2269
Chris Lattner67d7b922008-11-16 21:24:15 +00002270/// isEvaluatable - Call Evaluate to see if this expression can be constant
Chris Lattnercb136912008-10-06 06:49:02 +00002271/// folded, but discard the result.
2272bool Expr::isEvaluatable(ASTContext &Ctx) const {
Anders Carlsson5b3638b2008-12-01 06:44:05 +00002273 EvalResult Result;
2274 return Evaluate(Result, Ctx) && !Result.HasSideEffects;
Chris Lattnercb136912008-10-06 06:49:02 +00002275}
Anders Carlsson59689ed2008-11-22 21:04:56 +00002276
Fariborz Jahanian4127b8e2009-11-05 18:03:03 +00002277bool Expr::HasSideEffects(ASTContext &Ctx) const {
2278 Expr::EvalResult Result;
2279 EvalInfo Info(Ctx, Result);
2280 return HasSideEffect(Info).Visit(const_cast<Expr*>(this));
2281}
2282
Anders Carlsson59689ed2008-11-22 21:04:56 +00002283APSInt Expr::EvaluateAsInt(ASTContext &Ctx) const {
Anders Carlsson6736d1a22008-12-19 20:58:05 +00002284 EvalResult EvalResult;
2285 bool Result = Evaluate(EvalResult, Ctx);
Daniel Dunbar435bbe02009-01-15 18:32:35 +00002286 Result = Result;
Anders Carlsson59689ed2008-11-22 21:04:56 +00002287 assert(Result && "Could not evaluate expression");
Anders Carlsson6736d1a22008-12-19 20:58:05 +00002288 assert(EvalResult.Val.isInt() && "Expression did not evaluate to integer");
Anders Carlsson59689ed2008-11-22 21:04:56 +00002289
Anders Carlsson6736d1a22008-12-19 20:58:05 +00002290 return EvalResult.Val.getInt();
Anders Carlsson59689ed2008-11-22 21:04:56 +00002291}
John McCall864e3962010-05-07 05:32:02 +00002292
Abramo Bagnaraf8199452010-05-14 17:07:14 +00002293 bool Expr::EvalResult::isGlobalLValue() const {
2294 assert(Val.isLValue());
2295 return IsGlobalLValue(Val.getLValueBase());
2296 }
2297
2298
John McCall864e3962010-05-07 05:32:02 +00002299/// isIntegerConstantExpr - this recursive routine will test if an expression is
2300/// an integer constant expression.
2301
2302/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero,
2303/// comma, etc
2304///
2305/// FIXME: Handle offsetof. Two things to do: Handle GCC's __builtin_offsetof
2306/// to support gcc 4.0+ and handle the idiom GCC recognizes with a null pointer
2307/// cast+dereference.
2308
2309// CheckICE - This function does the fundamental ICE checking: the returned
2310// ICEDiag contains a Val of 0, 1, or 2, and a possibly null SourceLocation.
2311// Note that to reduce code duplication, this helper does no evaluation
2312// itself; the caller checks whether the expression is evaluatable, and
2313// in the rare cases where CheckICE actually cares about the evaluated
2314// value, it calls into Evalute.
2315//
2316// Meanings of Val:
2317// 0: This expression is an ICE if it can be evaluated by Evaluate.
2318// 1: This expression is not an ICE, but if it isn't evaluated, it's
2319// a legal subexpression for an ICE. This return value is used to handle
2320// the comma operator in C99 mode.
2321// 2: This expression is not an ICE, and is not a legal subexpression for one.
2322
Dan Gohman28ade552010-07-26 21:25:24 +00002323namespace {
2324
John McCall864e3962010-05-07 05:32:02 +00002325struct ICEDiag {
2326 unsigned Val;
2327 SourceLocation Loc;
2328
2329 public:
2330 ICEDiag(unsigned v, SourceLocation l) : Val(v), Loc(l) {}
2331 ICEDiag() : Val(0) {}
2332};
2333
Dan Gohman28ade552010-07-26 21:25:24 +00002334}
2335
2336static ICEDiag NoDiag() { return ICEDiag(); }
John McCall864e3962010-05-07 05:32:02 +00002337
2338static ICEDiag CheckEvalInICE(const Expr* E, ASTContext &Ctx) {
2339 Expr::EvalResult EVResult;
2340 if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects ||
2341 !EVResult.Val.isInt()) {
2342 return ICEDiag(2, E->getLocStart());
2343 }
2344 return NoDiag();
2345}
2346
2347static ICEDiag CheckICE(const Expr* E, ASTContext &Ctx) {
2348 assert(!E->isValueDependent() && "Should not see value dependent exprs!");
Douglas Gregorb90df602010-06-16 00:17:44 +00002349 if (!E->getType()->isIntegralOrEnumerationType()) {
John McCall864e3962010-05-07 05:32:02 +00002350 return ICEDiag(2, E->getLocStart());
2351 }
2352
2353 switch (E->getStmtClass()) {
2354#define STMT(Node, Base) case Expr::Node##Class:
2355#define EXPR(Node, Base)
2356#include "clang/AST/StmtNodes.inc"
2357 case Expr::PredefinedExprClass:
2358 case Expr::FloatingLiteralClass:
2359 case Expr::ImaginaryLiteralClass:
2360 case Expr::StringLiteralClass:
2361 case Expr::ArraySubscriptExprClass:
2362 case Expr::MemberExprClass:
2363 case Expr::CompoundAssignOperatorClass:
2364 case Expr::CompoundLiteralExprClass:
2365 case Expr::ExtVectorElementExprClass:
2366 case Expr::InitListExprClass:
2367 case Expr::DesignatedInitExprClass:
2368 case Expr::ImplicitValueInitExprClass:
2369 case Expr::ParenListExprClass:
2370 case Expr::VAArgExprClass:
2371 case Expr::AddrLabelExprClass:
2372 case Expr::StmtExprClass:
2373 case Expr::CXXMemberCallExprClass:
2374 case Expr::CXXDynamicCastExprClass:
2375 case Expr::CXXTypeidExprClass:
2376 case Expr::CXXNullPtrLiteralExprClass:
2377 case Expr::CXXThisExprClass:
2378 case Expr::CXXThrowExprClass:
2379 case Expr::CXXNewExprClass:
2380 case Expr::CXXDeleteExprClass:
2381 case Expr::CXXPseudoDestructorExprClass:
2382 case Expr::UnresolvedLookupExprClass:
2383 case Expr::DependentScopeDeclRefExprClass:
2384 case Expr::CXXConstructExprClass:
2385 case Expr::CXXBindTemporaryExprClass:
2386 case Expr::CXXBindReferenceExprClass:
2387 case Expr::CXXExprWithTemporariesClass:
2388 case Expr::CXXTemporaryObjectExprClass:
2389 case Expr::CXXUnresolvedConstructExprClass:
2390 case Expr::CXXDependentScopeMemberExprClass:
2391 case Expr::UnresolvedMemberExprClass:
2392 case Expr::ObjCStringLiteralClass:
2393 case Expr::ObjCEncodeExprClass:
2394 case Expr::ObjCMessageExprClass:
2395 case Expr::ObjCSelectorExprClass:
2396 case Expr::ObjCProtocolExprClass:
2397 case Expr::ObjCIvarRefExprClass:
2398 case Expr::ObjCPropertyRefExprClass:
2399 case Expr::ObjCImplicitSetterGetterRefExprClass:
2400 case Expr::ObjCSuperExprClass:
2401 case Expr::ObjCIsaExprClass:
2402 case Expr::ShuffleVectorExprClass:
2403 case Expr::BlockExprClass:
2404 case Expr::BlockDeclRefExprClass:
2405 case Expr::NoStmtClass:
2406 return ICEDiag(2, E->getLocStart());
2407
2408 case Expr::GNUNullExprClass:
2409 // GCC considers the GNU __null value to be an integral constant expression.
2410 return NoDiag();
2411
2412 case Expr::ParenExprClass:
2413 return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx);
2414 case Expr::IntegerLiteralClass:
2415 case Expr::CharacterLiteralClass:
2416 case Expr::CXXBoolLiteralExprClass:
Douglas Gregor747eb782010-07-08 06:14:04 +00002417 case Expr::CXXScalarValueInitExprClass:
John McCall864e3962010-05-07 05:32:02 +00002418 case Expr::TypesCompatibleExprClass:
2419 case Expr::UnaryTypeTraitExprClass:
2420 return NoDiag();
2421 case Expr::CallExprClass:
2422 case Expr::CXXOperatorCallExprClass: {
2423 const CallExpr *CE = cast<CallExpr>(E);
2424 if (CE->isBuiltinCall(Ctx))
2425 return CheckEvalInICE(E, Ctx);
2426 return ICEDiag(2, E->getLocStart());
2427 }
2428 case Expr::DeclRefExprClass:
2429 if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl()))
2430 return NoDiag();
2431 if (Ctx.getLangOptions().CPlusPlus &&
2432 E->getType().getCVRQualifiers() == Qualifiers::Const) {
2433 const NamedDecl *D = cast<DeclRefExpr>(E)->getDecl();
2434
2435 // Parameter variables are never constants. Without this check,
2436 // getAnyInitializer() can find a default argument, which leads
2437 // to chaos.
2438 if (isa<ParmVarDecl>(D))
2439 return ICEDiag(2, cast<DeclRefExpr>(E)->getLocation());
2440
2441 // C++ 7.1.5.1p2
2442 // A variable of non-volatile const-qualified integral or enumeration
2443 // type initialized by an ICE can be used in ICEs.
2444 if (const VarDecl *Dcl = dyn_cast<VarDecl>(D)) {
2445 Qualifiers Quals = Ctx.getCanonicalType(Dcl->getType()).getQualifiers();
2446 if (Quals.hasVolatile() || !Quals.hasConst())
2447 return ICEDiag(2, cast<DeclRefExpr>(E)->getLocation());
2448
2449 // Look for a declaration of this variable that has an initializer.
2450 const VarDecl *ID = 0;
2451 const Expr *Init = Dcl->getAnyInitializer(ID);
2452 if (Init) {
2453 if (ID->isInitKnownICE()) {
2454 // We have already checked whether this subexpression is an
2455 // integral constant expression.
2456 if (ID->isInitICE())
2457 return NoDiag();
2458 else
2459 return ICEDiag(2, cast<DeclRefExpr>(E)->getLocation());
2460 }
2461
2462 // It's an ICE whether or not the definition we found is
2463 // out-of-line. See DR 721 and the discussion in Clang PR
2464 // 6206 for details.
2465
2466 if (Dcl->isCheckingICE()) {
2467 return ICEDiag(2, cast<DeclRefExpr>(E)->getLocation());
2468 }
2469
2470 Dcl->setCheckingICE();
2471 ICEDiag Result = CheckICE(Init, Ctx);
2472 // Cache the result of the ICE test.
2473 Dcl->setInitKnownICE(Result.Val == 0);
2474 return Result;
2475 }
2476 }
2477 }
2478 return ICEDiag(2, E->getLocStart());
2479 case Expr::UnaryOperatorClass: {
2480 const UnaryOperator *Exp = cast<UnaryOperator>(E);
2481 switch (Exp->getOpcode()) {
2482 case UnaryOperator::PostInc:
2483 case UnaryOperator::PostDec:
2484 case UnaryOperator::PreInc:
2485 case UnaryOperator::PreDec:
2486 case UnaryOperator::AddrOf:
2487 case UnaryOperator::Deref:
2488 return ICEDiag(2, E->getLocStart());
2489 case UnaryOperator::Extension:
2490 case UnaryOperator::LNot:
2491 case UnaryOperator::Plus:
2492 case UnaryOperator::Minus:
2493 case UnaryOperator::Not:
2494 case UnaryOperator::Real:
2495 case UnaryOperator::Imag:
2496 return CheckICE(Exp->getSubExpr(), Ctx);
John McCall864e3962010-05-07 05:32:02 +00002497 }
2498
2499 // OffsetOf falls through here.
2500 }
2501 case Expr::OffsetOfExprClass: {
2502 // Note that per C99, offsetof must be an ICE. And AFAIK, using
2503 // Evaluate matches the proposed gcc behavior for cases like
2504 // "offsetof(struct s{int x[4];}, x[!.0])". This doesn't affect
2505 // compliance: we should warn earlier for offsetof expressions with
2506 // array subscripts that aren't ICEs, and if the array subscripts
2507 // are ICEs, the value of the offsetof must be an integer constant.
2508 return CheckEvalInICE(E, Ctx);
2509 }
2510 case Expr::SizeOfAlignOfExprClass: {
2511 const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(E);
2512 if (Exp->isSizeOf() && Exp->getTypeOfArgument()->isVariableArrayType())
2513 return ICEDiag(2, E->getLocStart());
2514 return NoDiag();
2515 }
2516 case Expr::BinaryOperatorClass: {
2517 const BinaryOperator *Exp = cast<BinaryOperator>(E);
2518 switch (Exp->getOpcode()) {
2519 case BinaryOperator::PtrMemD:
2520 case BinaryOperator::PtrMemI:
2521 case BinaryOperator::Assign:
2522 case BinaryOperator::MulAssign:
2523 case BinaryOperator::DivAssign:
2524 case BinaryOperator::RemAssign:
2525 case BinaryOperator::AddAssign:
2526 case BinaryOperator::SubAssign:
2527 case BinaryOperator::ShlAssign:
2528 case BinaryOperator::ShrAssign:
2529 case BinaryOperator::AndAssign:
2530 case BinaryOperator::XorAssign:
2531 case BinaryOperator::OrAssign:
2532 return ICEDiag(2, E->getLocStart());
2533
2534 case BinaryOperator::Mul:
2535 case BinaryOperator::Div:
2536 case BinaryOperator::Rem:
2537 case BinaryOperator::Add:
2538 case BinaryOperator::Sub:
2539 case BinaryOperator::Shl:
2540 case BinaryOperator::Shr:
2541 case BinaryOperator::LT:
2542 case BinaryOperator::GT:
2543 case BinaryOperator::LE:
2544 case BinaryOperator::GE:
2545 case BinaryOperator::EQ:
2546 case BinaryOperator::NE:
2547 case BinaryOperator::And:
2548 case BinaryOperator::Xor:
2549 case BinaryOperator::Or:
2550 case BinaryOperator::Comma: {
2551 ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
2552 ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
2553 if (Exp->getOpcode() == BinaryOperator::Div ||
2554 Exp->getOpcode() == BinaryOperator::Rem) {
2555 // Evaluate gives an error for undefined Div/Rem, so make sure
2556 // we don't evaluate one.
2557 if (LHSResult.Val != 2 && RHSResult.Val != 2) {
2558 llvm::APSInt REval = Exp->getRHS()->EvaluateAsInt(Ctx);
2559 if (REval == 0)
2560 return ICEDiag(1, E->getLocStart());
2561 if (REval.isSigned() && REval.isAllOnesValue()) {
2562 llvm::APSInt LEval = Exp->getLHS()->EvaluateAsInt(Ctx);
2563 if (LEval.isMinSignedValue())
2564 return ICEDiag(1, E->getLocStart());
2565 }
2566 }
2567 }
2568 if (Exp->getOpcode() == BinaryOperator::Comma) {
2569 if (Ctx.getLangOptions().C99) {
2570 // C99 6.6p3 introduces a strange edge case: comma can be in an ICE
2571 // if it isn't evaluated.
2572 if (LHSResult.Val == 0 && RHSResult.Val == 0)
2573 return ICEDiag(1, E->getLocStart());
2574 } else {
2575 // In both C89 and C++, commas in ICEs are illegal.
2576 return ICEDiag(2, E->getLocStart());
2577 }
2578 }
2579 if (LHSResult.Val >= RHSResult.Val)
2580 return LHSResult;
2581 return RHSResult;
2582 }
2583 case BinaryOperator::LAnd:
2584 case BinaryOperator::LOr: {
2585 ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
2586 ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
2587 if (LHSResult.Val == 0 && RHSResult.Val == 1) {
2588 // Rare case where the RHS has a comma "side-effect"; we need
2589 // to actually check the condition to see whether the side
2590 // with the comma is evaluated.
2591 if ((Exp->getOpcode() == BinaryOperator::LAnd) !=
2592 (Exp->getLHS()->EvaluateAsInt(Ctx) == 0))
2593 return RHSResult;
2594 return NoDiag();
2595 }
2596
2597 if (LHSResult.Val >= RHSResult.Val)
2598 return LHSResult;
2599 return RHSResult;
2600 }
2601 }
2602 }
2603 case Expr::ImplicitCastExprClass:
2604 case Expr::CStyleCastExprClass:
2605 case Expr::CXXFunctionalCastExprClass:
2606 case Expr::CXXStaticCastExprClass:
2607 case Expr::CXXReinterpretCastExprClass:
2608 case Expr::CXXConstCastExprClass: {
2609 const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr();
Douglas Gregorb90df602010-06-16 00:17:44 +00002610 if (SubExpr->getType()->isIntegralOrEnumerationType())
John McCall864e3962010-05-07 05:32:02 +00002611 return CheckICE(SubExpr, Ctx);
2612 if (isa<FloatingLiteral>(SubExpr->IgnoreParens()))
2613 return NoDiag();
2614 return ICEDiag(2, E->getLocStart());
2615 }
2616 case Expr::ConditionalOperatorClass: {
2617 const ConditionalOperator *Exp = cast<ConditionalOperator>(E);
2618 // If the condition (ignoring parens) is a __builtin_constant_p call,
2619 // then only the true side is actually considered in an integer constant
2620 // expression, and it is fully evaluated. This is an important GNU
2621 // extension. See GCC PR38377 for discussion.
2622 if (const CallExpr *CallCE
2623 = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts()))
2624 if (CallCE->isBuiltinCall(Ctx) == Builtin::BI__builtin_constant_p) {
2625 Expr::EvalResult EVResult;
2626 if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects ||
2627 !EVResult.Val.isInt()) {
2628 return ICEDiag(2, E->getLocStart());
2629 }
2630 return NoDiag();
2631 }
2632 ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx);
2633 ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx);
2634 ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
2635 if (CondResult.Val == 2)
2636 return CondResult;
2637 if (TrueResult.Val == 2)
2638 return TrueResult;
2639 if (FalseResult.Val == 2)
2640 return FalseResult;
2641 if (CondResult.Val == 1)
2642 return CondResult;
2643 if (TrueResult.Val == 0 && FalseResult.Val == 0)
2644 return NoDiag();
2645 // Rare case where the diagnostics depend on which side is evaluated
2646 // Note that if we get here, CondResult is 0, and at least one of
2647 // TrueResult and FalseResult is non-zero.
2648 if (Exp->getCond()->EvaluateAsInt(Ctx) == 0) {
2649 return FalseResult;
2650 }
2651 return TrueResult;
2652 }
2653 case Expr::CXXDefaultArgExprClass:
2654 return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx);
2655 case Expr::ChooseExprClass: {
2656 return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(Ctx), Ctx);
2657 }
2658 }
2659
2660 // Silence a GCC warning
2661 return ICEDiag(2, E->getLocStart());
2662}
2663
2664bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
2665 SourceLocation *Loc, bool isEvaluated) const {
2666 ICEDiag d = CheckICE(this, Ctx);
2667 if (d.Val != 0) {
2668 if (Loc) *Loc = d.Loc;
2669 return false;
2670 }
2671 EvalResult EvalResult;
2672 if (!Evaluate(EvalResult, Ctx))
2673 llvm_unreachable("ICE cannot be evaluated!");
2674 assert(!EvalResult.HasSideEffects && "ICE with side effects!");
2675 assert(EvalResult.Val.isInt() && "ICE that isn't integer!");
2676 Result = EvalResult.Val.getInt();
2677 return true;
2678}