blob: ed73bfae27b29cd818fba02f97c025caf2e03a3c [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- Expr.cpp - Expression AST Node Implementation --------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Expr class and subclasses.
11//
12//===----------------------------------------------------------------------===//
13
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000014#include "clang/AST/Expr.h"
Chris Lattnera4d55d82008-10-06 06:40:35 +000015#include "clang/AST/APValue.h"
Chris Lattner2eadfb62007-07-15 23:32:58 +000016#include "clang/AST/ASTContext.h"
Chris Lattnera4d55d82008-10-06 06:40:35 +000017#include "clang/AST/DeclObjC.h"
Douglas Gregor98cd5992008-10-21 23:43:52 +000018#include "clang/AST/DeclCXX.h"
Daniel Dunbare91593e2008-08-11 04:54:23 +000019#include "clang/AST/RecordLayout.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000020#include "clang/AST/StmtVisitor.h"
Chris Lattnerda5a6b62007-11-27 18:22:04 +000021#include "clang/Basic/TargetInfo.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000022using namespace clang;
23
24//===----------------------------------------------------------------------===//
25// Primary Expressions.
26//===----------------------------------------------------------------------===//
27
Chris Lattnerda8249e2008-06-07 22:13:43 +000028/// getValueAsApproximateDouble - This returns the value as an inaccurate
29/// double. Note that this may cause loss of precision, but is useful for
30/// debugging dumps, etc.
31double FloatingLiteral::getValueAsApproximateDouble() const {
32 llvm::APFloat V = getValue();
Dale Johannesenee5a7002008-10-09 23:02:32 +000033 bool ignored;
34 V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven,
35 &ignored);
Chris Lattnerda8249e2008-06-07 22:13:43 +000036 return V.convertToDouble();
37}
38
39
Reid Spencer5f016e22007-07-11 17:01:13 +000040StringLiteral::StringLiteral(const char *strData, unsigned byteLength,
41 bool Wide, QualType t, SourceLocation firstLoc,
42 SourceLocation lastLoc) :
43 Expr(StringLiteralClass, t) {
44 // OPTIMIZE: could allocate this appended to the StringLiteral.
45 char *AStrData = new char[byteLength];
46 memcpy(AStrData, strData, byteLength);
47 StrData = AStrData;
48 ByteLength = byteLength;
49 IsWide = Wide;
50 firstTokLoc = firstLoc;
51 lastTokLoc = lastLoc;
52}
53
54StringLiteral::~StringLiteral() {
55 delete[] StrData;
56}
57
58bool UnaryOperator::isPostfix(Opcode Op) {
59 switch (Op) {
60 case PostInc:
61 case PostDec:
62 return true;
63 default:
64 return false;
65 }
66}
67
Ted Kremenek5a56ac32008-07-23 22:18:43 +000068bool UnaryOperator::isPrefix(Opcode Op) {
69 switch (Op) {
70 case PreInc:
71 case PreDec:
72 return true;
73 default:
74 return false;
75 }
76}
77
Reid Spencer5f016e22007-07-11 17:01:13 +000078/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
79/// corresponds to, e.g. "sizeof" or "[pre]++".
80const char *UnaryOperator::getOpcodeStr(Opcode Op) {
81 switch (Op) {
82 default: assert(0 && "Unknown unary operator");
83 case PostInc: return "++";
84 case PostDec: return "--";
85 case PreInc: return "++";
86 case PreDec: return "--";
87 case AddrOf: return "&";
88 case Deref: return "*";
89 case Plus: return "+";
90 case Minus: return "-";
91 case Not: return "~";
92 case LNot: return "!";
93 case Real: return "__real";
94 case Imag: return "__imag";
Reid Spencer5f016e22007-07-11 17:01:13 +000095 case Extension: return "__extension__";
Chris Lattner73d0d4f2007-08-30 17:45:32 +000096 case OffsetOf: return "__builtin_offsetof";
Reid Spencer5f016e22007-07-11 17:01:13 +000097 }
98}
99
100//===----------------------------------------------------------------------===//
101// Postfix Operators.
102//===----------------------------------------------------------------------===//
103
Douglas Gregorb4609802008-11-14 16:09:21 +0000104CallExpr::CallExpr(StmtClass SC, Expr *fn, Expr **args, unsigned numargs,
105 QualType t, SourceLocation rparenloc)
Douglas Gregor898574e2008-12-05 23:32:09 +0000106 : Expr(SC, t,
107 fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs),
108 fn->isValueDependent() || hasAnyValueDependentArguments(args, numargs)),
109 NumArgs(numargs) {
Douglas Gregorb4609802008-11-14 16:09:21 +0000110 SubExprs = new Stmt*[numargs+1];
111 SubExprs[FN] = fn;
112 for (unsigned i = 0; i != numargs; ++i)
113 SubExprs[i+ARGS_START] = args[i];
114 RParenLoc = rparenloc;
115}
Nate Begemane2ce1d92008-01-17 17:46:27 +0000116
Reid Spencer5f016e22007-07-11 17:01:13 +0000117CallExpr::CallExpr(Expr *fn, Expr **args, unsigned numargs, QualType t,
118 SourceLocation rparenloc)
Douglas Gregor898574e2008-12-05 23:32:09 +0000119 : Expr(CallExprClass, t,
120 fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs),
121 fn->isValueDependent() || hasAnyValueDependentArguments(args, numargs)),
122 NumArgs(numargs) {
Ted Kremenek55499762008-06-17 02:43:46 +0000123 SubExprs = new Stmt*[numargs+1];
Ted Kremenek77ed8e42007-08-24 18:13:47 +0000124 SubExprs[FN] = fn;
Reid Spencer5f016e22007-07-11 17:01:13 +0000125 for (unsigned i = 0; i != numargs; ++i)
Ted Kremenek77ed8e42007-08-24 18:13:47 +0000126 SubExprs[i+ARGS_START] = args[i];
Reid Spencer5f016e22007-07-11 17:01:13 +0000127 RParenLoc = rparenloc;
128}
129
Chris Lattnerd18b3292007-12-28 05:25:02 +0000130/// setNumArgs - This changes the number of arguments present in this call.
131/// Any orphaned expressions are deleted by this, and any new operands are set
132/// to null.
133void CallExpr::setNumArgs(unsigned NumArgs) {
134 // No change, just return.
135 if (NumArgs == getNumArgs()) return;
136
137 // If shrinking # arguments, just delete the extras and forgot them.
138 if (NumArgs < getNumArgs()) {
139 for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i)
140 delete getArg(i);
141 this->NumArgs = NumArgs;
142 return;
143 }
144
145 // Otherwise, we are growing the # arguments. New an bigger argument array.
Ted Kremenek55499762008-06-17 02:43:46 +0000146 Stmt **NewSubExprs = new Stmt*[NumArgs+1];
Chris Lattnerd18b3292007-12-28 05:25:02 +0000147 // Copy over args.
148 for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i)
149 NewSubExprs[i] = SubExprs[i];
150 // Null out new args.
151 for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i)
152 NewSubExprs[i] = 0;
153
154 delete[] SubExprs;
155 SubExprs = NewSubExprs;
156 this->NumArgs = NumArgs;
157}
158
Chris Lattnercb888962008-10-06 05:00:53 +0000159/// isBuiltinCall - If this is a call to a builtin, return the builtin ID. If
160/// not, return 0.
161unsigned CallExpr::isBuiltinCall() const {
Steve Naroffc4f8e8b2008-01-31 01:07:12 +0000162 // All simple function calls (e.g. func()) are implicitly cast to pointer to
163 // function. As a result, we try and obtain the DeclRefExpr from the
164 // ImplicitCastExpr.
165 const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
166 if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
Chris Lattnercb888962008-10-06 05:00:53 +0000167 return 0;
168
Steve Naroffc4f8e8b2008-01-31 01:07:12 +0000169 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
170 if (!DRE)
Chris Lattnercb888962008-10-06 05:00:53 +0000171 return 0;
172
Anders Carlssonbcba2012008-01-31 02:13:57 +0000173 const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
174 if (!FDecl)
Chris Lattnercb888962008-10-06 05:00:53 +0000175 return 0;
176
Douglas Gregor4fcd3992008-11-21 15:30:19 +0000177 if (!FDecl->getIdentifier())
178 return 0;
179
Chris Lattnercb888962008-10-06 05:00:53 +0000180 return FDecl->getIdentifier()->getBuiltinID();
181}
Anders Carlssonbcba2012008-01-31 02:13:57 +0000182
Chris Lattnercb888962008-10-06 05:00:53 +0000183
Reid Spencer5f016e22007-07-11 17:01:13 +0000184/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
185/// corresponds to, e.g. "<<=".
186const char *BinaryOperator::getOpcodeStr(Opcode Op) {
187 switch (Op) {
188 default: assert(0 && "Unknown binary operator");
189 case Mul: return "*";
190 case Div: return "/";
191 case Rem: return "%";
192 case Add: return "+";
193 case Sub: return "-";
194 case Shl: return "<<";
195 case Shr: return ">>";
196 case LT: return "<";
197 case GT: return ">";
198 case LE: return "<=";
199 case GE: return ">=";
200 case EQ: return "==";
201 case NE: return "!=";
202 case And: return "&";
203 case Xor: return "^";
204 case Or: return "|";
205 case LAnd: return "&&";
206 case LOr: return "||";
207 case Assign: return "=";
208 case MulAssign: return "*=";
209 case DivAssign: return "/=";
210 case RemAssign: return "%=";
211 case AddAssign: return "+=";
212 case SubAssign: return "-=";
213 case ShlAssign: return "<<=";
214 case ShrAssign: return ">>=";
215 case AndAssign: return "&=";
216 case XorAssign: return "^=";
217 case OrAssign: return "|=";
218 case Comma: return ",";
219 }
220}
221
Anders Carlsson66b5a8a2007-08-31 04:56:16 +0000222InitListExpr::InitListExpr(SourceLocation lbraceloc,
Chris Lattner418f6c72008-10-26 23:43:26 +0000223 Expr **initExprs, unsigned numInits,
Douglas Gregor4c678342009-01-28 21:54:33 +0000224 SourceLocation rbraceloc)
Steve Naroffc5ae8992008-05-01 02:04:18 +0000225 : Expr(InitListExprClass, QualType()),
Douglas Gregor4c678342009-01-28 21:54:33 +0000226 LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0) {
Chris Lattner418f6c72008-10-26 23:43:26 +0000227
228 InitExprs.insert(InitExprs.end(), initExprs, initExprs+numInits);
Anders Carlsson66b5a8a2007-08-31 04:56:16 +0000229}
Reid Spencer5f016e22007-07-11 17:01:13 +0000230
Douglas Gregor4c678342009-01-28 21:54:33 +0000231void InitListExpr::resizeInits(ASTContext &Context, unsigned NumInits) {
232 for (unsigned Idx = NumInits, LastIdx = InitExprs.size(); Idx < LastIdx; ++Idx)
233 delete InitExprs[Idx];
234 InitExprs.resize(NumInits, 0);
235}
236
237Expr *InitListExpr::updateInit(unsigned Init, Expr *expr) {
238 if (Init >= InitExprs.size()) {
239 InitExprs.insert(InitExprs.end(), Init - InitExprs.size() + 1, 0);
240 InitExprs.back() = expr;
241 return 0;
242 }
243
244 Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
245 InitExprs[Init] = expr;
246 return Result;
247}
248
Steve Naroffbfdcae62008-09-04 15:31:07 +0000249/// getFunctionType - Return the underlying function type for this block.
Steve Naroff4eb206b2008-09-03 18:15:37 +0000250///
251const FunctionType *BlockExpr::getFunctionType() const {
252 return getType()->getAsBlockPointerType()->
253 getPointeeType()->getAsFunctionType();
254}
255
Steve Naroff56ee6892008-10-08 17:01:13 +0000256SourceLocation BlockExpr::getCaretLocation() const {
257 return TheBlock->getCaretLocation();
258}
259const Stmt *BlockExpr::getBody() const { return TheBlock->getBody(); }
260Stmt *BlockExpr::getBody() { return TheBlock->getBody(); }
261
262
Reid Spencer5f016e22007-07-11 17:01:13 +0000263//===----------------------------------------------------------------------===//
264// Generic Expression Routines
265//===----------------------------------------------------------------------===//
266
267/// hasLocalSideEffect - Return true if this immediate expression has side
268/// effects, not counting any sub-expressions.
269bool Expr::hasLocalSideEffect() const {
270 switch (getStmtClass()) {
271 default:
272 return false;
273 case ParenExprClass:
274 return cast<ParenExpr>(this)->getSubExpr()->hasLocalSideEffect();
275 case UnaryOperatorClass: {
276 const UnaryOperator *UO = cast<UnaryOperator>(this);
277
278 switch (UO->getOpcode()) {
279 default: return false;
280 case UnaryOperator::PostInc:
281 case UnaryOperator::PostDec:
282 case UnaryOperator::PreInc:
283 case UnaryOperator::PreDec:
284 return true; // ++/--
285
286 case UnaryOperator::Deref:
287 // Dereferencing a volatile pointer is a side-effect.
288 return getType().isVolatileQualified();
289 case UnaryOperator::Real:
290 case UnaryOperator::Imag:
291 // accessing a piece of a volatile complex is a side-effect.
292 return UO->getSubExpr()->getType().isVolatileQualified();
293
294 case UnaryOperator::Extension:
295 return UO->getSubExpr()->hasLocalSideEffect();
296 }
297 }
Chris Lattnere7716e62007-12-01 06:07:34 +0000298 case BinaryOperatorClass: {
299 const BinaryOperator *BinOp = cast<BinaryOperator>(this);
300 // Consider comma to have side effects if the LHS and RHS both do.
301 if (BinOp->getOpcode() == BinaryOperator::Comma)
302 return BinOp->getLHS()->hasLocalSideEffect() &&
303 BinOp->getRHS()->hasLocalSideEffect();
304
305 return BinOp->isAssignmentOp();
306 }
Chris Lattnereb14fe82007-08-25 02:00:02 +0000307 case CompoundAssignOperatorClass:
Chris Lattner1f683e92007-08-25 01:55:00 +0000308 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +0000309
Fariborz Jahanianab38e4b2007-12-01 19:58:28 +0000310 case ConditionalOperatorClass: {
311 const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
312 return Exp->getCond()->hasLocalSideEffect()
313 || (Exp->getLHS() && Exp->getLHS()->hasLocalSideEffect())
314 || (Exp->getRHS() && Exp->getRHS()->hasLocalSideEffect());
315 }
316
Reid Spencer5f016e22007-07-11 17:01:13 +0000317 case MemberExprClass:
318 case ArraySubscriptExprClass:
319 // If the base pointer or element is to a volatile pointer/field, accessing
320 // if is a side effect.
321 return getType().isVolatileQualified();
Eli Friedman211f6ad2008-05-27 15:24:04 +0000322
Reid Spencer5f016e22007-07-11 17:01:13 +0000323 case CallExprClass:
Douglas Gregorb4609802008-11-14 16:09:21 +0000324 case CXXOperatorCallExprClass:
Reid Spencer5f016e22007-07-11 17:01:13 +0000325 // TODO: check attributes for pure/const. "void foo() { strlen("bar"); }"
326 // should warn.
327 return true;
Chris Lattnera9c01022007-09-26 22:06:30 +0000328 case ObjCMessageExprClass:
329 return true;
Chris Lattner611b2ec2008-07-26 19:51:01 +0000330 case StmtExprClass: {
331 // Statement exprs don't logically have side effects themselves, but are
332 // sometimes used in macros in ways that give them a type that is unused.
333 // For example ({ blah; foo(); }) will end up with a type if foo has a type.
334 // however, if the result of the stmt expr is dead, we don't want to emit a
335 // warning.
336 const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
337 if (!CS->body_empty())
338 if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
339 return E->hasLocalSideEffect();
340 return false;
341 }
Douglas Gregor6eec8e82008-10-28 15:36:24 +0000342 case CStyleCastExprClass:
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000343 case CXXFunctionalCastExprClass:
Reid Spencer5f016e22007-07-11 17:01:13 +0000344 // If this is a cast to void, check the operand. Otherwise, the result of
345 // the cast is unused.
346 if (getType()->isVoidType())
347 return cast<CastExpr>(this)->getSubExpr()->hasLocalSideEffect();
348 return false;
Chris Lattner04421082008-04-08 04:40:51 +0000349
Eli Friedman4be1f472008-05-19 21:24:43 +0000350 case ImplicitCastExprClass:
351 // Check the operand, since implicit casts are inserted by Sema
352 return cast<ImplicitCastExpr>(this)->getSubExpr()->hasLocalSideEffect();
353
Chris Lattner04421082008-04-08 04:40:51 +0000354 case CXXDefaultArgExprClass:
355 return cast<CXXDefaultArgExpr>(this)->getExpr()->hasLocalSideEffect();
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000356
357 case CXXNewExprClass:
358 // FIXME: In theory, there might be new expressions that don't have side
359 // effects (e.g. a placement new with an uninitialized POD).
360 case CXXDeleteExprClass:
361 return true;
362 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000363}
364
Douglas Gregorba7e2102008-10-22 15:04:37 +0000365/// DeclCanBeLvalue - Determine whether the given declaration can be
366/// an lvalue. This is a helper routine for isLvalue.
367static bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) {
Douglas Gregor72c3f312008-12-05 18:15:24 +0000368 // C++ [temp.param]p6:
369 // A non-type non-reference template-parameter is not an lvalue.
370 if (const NonTypeTemplateParmDecl *NTTParm
371 = dyn_cast<NonTypeTemplateParmDecl>(Decl))
372 return NTTParm->getType()->isReferenceType();
373
Douglas Gregor44b43212008-12-11 16:49:14 +0000374 return isa<VarDecl>(Decl) || isa<FieldDecl>(Decl) ||
Douglas Gregorba7e2102008-10-22 15:04:37 +0000375 // C++ 3.10p2: An lvalue refers to an object or function.
376 (Ctx.getLangOptions().CPlusPlus &&
377 (isa<FunctionDecl>(Decl) || isa<OverloadedFunctionDecl>(Decl)));
378}
379
Reid Spencer5f016e22007-07-11 17:01:13 +0000380/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an
381/// incomplete type other than void. Nonarray expressions that can be lvalues:
382/// - name, where name must be a variable
383/// - e[i]
384/// - (e), where e must be an lvalue
385/// - e.name, where e must be an lvalue
386/// - e->name
387/// - *e, the type of e cannot be a function type
388/// - string-constant
Chris Lattner7da36f62007-10-30 22:53:42 +0000389/// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension]
Bill Wendling08ad47c2007-07-17 03:52:31 +0000390/// - reference type [C++ [expr]]
Reid Spencer5f016e22007-07-11 17:01:13 +0000391///
Chris Lattner28be73f2008-07-26 21:30:36 +0000392Expr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const {
Douglas Gregor98cd5992008-10-21 23:43:52 +0000393 // first, check the type (C99 6.3.2.1). Expressions with function
394 // type in C are not lvalues, but they can be lvalues in C++.
395 if (!Ctx.getLangOptions().CPlusPlus && TR->isFunctionType())
Reid Spencer5f016e22007-07-11 17:01:13 +0000396 return LV_NotObjectType;
397
Steve Naroffacb818a2008-02-10 01:39:04 +0000398 // Allow qualified void which is an incomplete type other than void (yuck).
Chris Lattner28be73f2008-07-26 21:30:36 +0000399 if (TR->isVoidType() && !Ctx.getCanonicalType(TR).getCVRQualifiers())
Steve Naroffacb818a2008-02-10 01:39:04 +0000400 return LV_IncompleteVoidType;
401
Douglas Gregor98cd5992008-10-21 23:43:52 +0000402 /// FIXME: Expressions can't have reference type, so the following
403 /// isn't needed.
Chris Lattnercb4f9a62007-07-21 05:33:26 +0000404 if (TR->isReferenceType()) // C++ [expr]
Bill Wendling08ad47c2007-07-17 03:52:31 +0000405 return LV_Valid;
406
Reid Spencer5f016e22007-07-11 17:01:13 +0000407 // the type looks fine, now check the expression
408 switch (getStmtClass()) {
409 case StringLiteralClass: // C99 6.5.1p4
Anders Carlsson7323a622007-11-30 22:47:59 +0000410 return LV_Valid;
Reid Spencer5f016e22007-07-11 17:01:13 +0000411 case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2))))
412 // For vectors, make sure base is an lvalue (i.e. not a function call).
413 if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType())
Chris Lattner28be73f2008-07-26 21:30:36 +0000414 return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx);
Reid Spencer5f016e22007-07-11 17:01:13 +0000415 return LV_Valid;
Douglas Gregor1a49af92009-01-06 05:10:23 +0000416 case DeclRefExprClass:
417 case QualifiedDeclRefExprClass: { // C99 6.5.1p2
Douglas Gregorba7e2102008-10-22 15:04:37 +0000418 const NamedDecl *RefdDecl = cast<DeclRefExpr>(this)->getDecl();
419 if (DeclCanBeLvalue(RefdDecl, Ctx))
Reid Spencer5f016e22007-07-11 17:01:13 +0000420 return LV_Valid;
421 break;
Chris Lattner41110242008-06-17 18:05:57 +0000422 }
Steve Naroffdd972f22008-09-05 22:11:13 +0000423 case BlockDeclRefExprClass: {
424 const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this);
Steve Naroff4f6a7d72008-09-26 14:41:28 +0000425 if (isa<VarDecl>(BDR->getDecl()))
Steve Naroffdd972f22008-09-05 22:11:13 +0000426 return LV_Valid;
427 break;
428 }
Douglas Gregor86f19402008-12-20 23:49:58 +0000429 case MemberExprClass: {
Reid Spencer5f016e22007-07-11 17:01:13 +0000430 const MemberExpr *m = cast<MemberExpr>(this);
Douglas Gregor86f19402008-12-20 23:49:58 +0000431 if (Ctx.getLangOptions().CPlusPlus) { // C++ [expr.ref]p4:
432 NamedDecl *Member = m->getMemberDecl();
433 // C++ [expr.ref]p4:
434 // If E2 is declared to have type "reference to T", then E1.E2
435 // is an lvalue.
436 if (ValueDecl *Value = dyn_cast<ValueDecl>(Member))
437 if (Value->getType()->isReferenceType())
438 return LV_Valid;
439
440 // -- If E2 is a static data member [...] then E1.E2 is an lvalue.
441 if (isa<CXXClassVarDecl>(Member))
442 return LV_Valid;
443
444 // -- If E2 is a non-static data member [...]. If E1 is an
445 // lvalue, then E1.E2 is an lvalue.
446 if (isa<FieldDecl>(Member))
447 return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx);
448
449 // -- If it refers to a static member function [...], then
450 // E1.E2 is an lvalue.
451 // -- Otherwise, if E1.E2 refers to a non-static member
452 // function [...], then E1.E2 is not an lvalue.
453 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member))
454 return Method->isStatic()? LV_Valid : LV_MemberFunction;
455
456 // -- If E2 is a member enumerator [...], the expression E1.E2
457 // is not an lvalue.
458 if (isa<EnumConstantDecl>(Member))
459 return LV_InvalidExpression;
460
461 // Not an lvalue.
462 return LV_InvalidExpression;
463 }
464
465 // C99 6.5.2.3p4
Chris Lattner28be73f2008-07-26 21:30:36 +0000466 return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx);
Anton Korobeynikovfdd75662007-07-12 15:26:50 +0000467 }
Chris Lattner7da36f62007-10-30 22:53:42 +0000468 case UnaryOperatorClass:
Reid Spencer5f016e22007-07-11 17:01:13 +0000469 if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref)
Chris Lattner7da36f62007-10-30 22:53:42 +0000470 return LV_Valid; // C99 6.5.3p4
471
472 if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real ||
Chris Lattnerbaf0d662008-07-25 18:07:19 +0000473 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag ||
474 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension)
Chris Lattner28be73f2008-07-26 21:30:36 +0000475 return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx); // GNU.
Douglas Gregor74253732008-11-19 15:42:04 +0000476
477 if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.pre.incr]p1
478 (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreInc ||
479 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreDec))
480 return LV_Valid;
Reid Spencer5f016e22007-07-11 17:01:13 +0000481 break;
Douglas Gregoreb8f3062008-11-12 17:17:38 +0000482 case ImplicitCastExprClass:
483 return cast<ImplicitCastExpr>(this)->isLvalueCast()? LV_Valid
484 : LV_InvalidExpression;
Reid Spencer5f016e22007-07-11 17:01:13 +0000485 case ParenExprClass: // C99 6.5.1p5
Chris Lattner28be73f2008-07-26 21:30:36 +0000486 return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx);
Douglas Gregoreb8f3062008-11-12 17:17:38 +0000487 case BinaryOperatorClass:
488 case CompoundAssignOperatorClass: {
489 const BinaryOperator *BinOp = cast<BinaryOperator>(this);
Douglas Gregor337c6b92008-11-19 17:17:41 +0000490
491 if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.comma]p1
492 BinOp->getOpcode() == BinaryOperator::Comma)
493 return BinOp->getRHS()->isLvalue(Ctx);
494
Douglas Gregorbf3af052008-11-13 20:12:29 +0000495 if (!BinOp->isAssignmentOp())
Douglas Gregoreb8f3062008-11-12 17:17:38 +0000496 return LV_InvalidExpression;
497
Douglas Gregorbf3af052008-11-13 20:12:29 +0000498 if (Ctx.getLangOptions().CPlusPlus)
499 // C++ [expr.ass]p1:
500 // The result of an assignment operation [...] is an lvalue.
501 return LV_Valid;
502
503
504 // C99 6.5.16:
505 // An assignment expression [...] is not an lvalue.
506 return LV_InvalidExpression;
Douglas Gregoreb8f3062008-11-12 17:17:38 +0000507 }
Nate Begeman59b5da62009-01-18 03:20:47 +0000508 // FIXME: OverloadExprClass
Douglas Gregorb4609802008-11-14 16:09:21 +0000509 case CallExprClass:
Douglas Gregor88a35142008-12-22 05:46:06 +0000510 case CXXOperatorCallExprClass:
511 case CXXMemberCallExprClass: {
Douglas Gregor9d293df2008-10-28 00:22:11 +0000512 // C++ [expr.call]p10:
513 // A function call is an lvalue if and only if the result type
514 // is a reference.
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000515 QualType CalleeType = cast<CallExpr>(this)->getCallee()->getType();
Douglas Gregor9d293df2008-10-28 00:22:11 +0000516 if (const PointerType *FnTypePtr = CalleeType->getAsPointerType())
Douglas Gregor88a35142008-12-22 05:46:06 +0000517 CalleeType = FnTypePtr->getPointeeType();
518 if (const FunctionType *FnType = CalleeType->getAsFunctionType())
519 if (FnType->getResultType()->isReferenceType())
520 return LV_Valid;
Douglas Gregor9d293df2008-10-28 00:22:11 +0000521
522 break;
523 }
Steve Naroffe6386392007-12-05 04:00:10 +0000524 case CompoundLiteralExprClass: // C99 6.5.2.5p5
525 return LV_Valid;
Chris Lattner670a62c2008-12-12 05:35:08 +0000526 case ChooseExprClass:
527 // __builtin_choose_expr is an lvalue if the selected operand is.
528 if (cast<ChooseExpr>(this)->isConditionTrue(Ctx))
529 return cast<ChooseExpr>(this)->getLHS()->isLvalue(Ctx);
530 else
531 return cast<ChooseExpr>(this)->getRHS()->isLvalue(Ctx);
532
Nate Begeman213541a2008-04-18 23:10:10 +0000533 case ExtVectorElementExprClass:
534 if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements())
Steve Narofffec0b492007-07-30 03:29:09 +0000535 return LV_DuplicateVectorComponents;
536 return LV_Valid;
Steve Naroff027282d2007-11-12 14:34:27 +0000537 case ObjCIvarRefExprClass: // ObjC instance variables are lvalues.
538 return LV_Valid;
Steve Naroff799a6a62008-05-30 23:23:16 +0000539 case ObjCPropertyRefExprClass: // FIXME: check if read-only property.
540 return LV_Valid;
Fariborz Jahanian5daf5702008-11-22 18:39:36 +0000541 case ObjCKVCRefExprClass: // FIXME: check if read-only property.
Chris Lattner670a62c2008-12-12 05:35:08 +0000542 return LV_Valid;
Chris Lattnerd9f69102008-08-10 01:53:14 +0000543 case PredefinedExprClass:
Douglas Gregor796da182008-11-04 14:32:21 +0000544 return LV_Valid;
Douglas Gregor9d293df2008-10-28 00:22:11 +0000545 case VAArgExprClass:
546 return LV_Valid;
Chris Lattner04421082008-04-08 04:40:51 +0000547 case CXXDefaultArgExprClass:
Chris Lattner28be73f2008-07-26 21:30:36 +0000548 return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx);
Argyrios Kyrtzidis24b41fa2008-09-11 04:22:26 +0000549 case CXXConditionDeclExprClass:
550 return LV_Valid;
Douglas Gregor6eec8e82008-10-28 15:36:24 +0000551 case CStyleCastExprClass:
Douglas Gregor9d293df2008-10-28 00:22:11 +0000552 case CXXFunctionalCastExprClass:
553 case CXXStaticCastExprClass:
554 case CXXDynamicCastExprClass:
555 case CXXReinterpretCastExprClass:
556 case CXXConstCastExprClass:
557 // The result of an explicit cast is an lvalue if the type we are
558 // casting to is a reference type. See C++ [expr.cast]p1,
559 // C++ [expr.static.cast]p2, C++ [expr.dynamic.cast]p2,
560 // C++ [expr.reinterpret.cast]p1, C++ [expr.const.cast]p1.
561 if (cast<ExplicitCastExpr>(this)->getTypeAsWritten()->isReferenceType())
562 return LV_Valid;
563 break;
Sebastian Redlc42e1182008-11-11 11:37:55 +0000564 case CXXTypeidExprClass:
565 // C++ 5.2.8p1: The result of a typeid expression is an lvalue of ...
566 return LV_Valid;
Reid Spencer5f016e22007-07-11 17:01:13 +0000567 default:
568 break;
569 }
570 return LV_InvalidExpression;
571}
572
573/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type,
574/// does not have an incomplete type, does not have a const-qualified type, and
575/// if it is a structure or union, does not have any member (including,
576/// recursively, any member or element of all contained aggregates or unions)
577/// with a const-qualified type.
Chris Lattner28be73f2008-07-26 21:30:36 +0000578Expr::isModifiableLvalueResult Expr::isModifiableLvalue(ASTContext &Ctx) const {
579 isLvalueResult lvalResult = isLvalue(Ctx);
Reid Spencer5f016e22007-07-11 17:01:13 +0000580
581 switch (lvalResult) {
Douglas Gregorae8d4672008-10-22 00:03:08 +0000582 case LV_Valid:
583 // C++ 3.10p11: Functions cannot be modified, but pointers to
584 // functions can be modifiable.
585 if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType())
586 return MLV_NotObjectType;
587 break;
588
Reid Spencer5f016e22007-07-11 17:01:13 +0000589 case LV_NotObjectType: return MLV_NotObjectType;
590 case LV_IncompleteVoidType: return MLV_IncompleteVoidType;
Steve Narofffec0b492007-07-30 03:29:09 +0000591 case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents;
Chris Lattnerca354fa2008-11-17 19:51:54 +0000592 case LV_InvalidExpression:
593 // If the top level is a C-style cast, and the subexpression is a valid
594 // lvalue, then this is probably a use of the old-school "cast as lvalue"
595 // GCC extension. We don't support it, but we want to produce good
596 // diagnostics when it happens so that the user knows why.
597 if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(this))
598 if (CE->getSubExpr()->isLvalue(Ctx) == LV_Valid)
599 return MLV_LValueCast;
600 return MLV_InvalidExpression;
Douglas Gregor86f19402008-12-20 23:49:58 +0000601 case LV_MemberFunction: return MLV_MemberFunction;
Reid Spencer5f016e22007-07-11 17:01:13 +0000602 }
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000603
604 QualType CT = Ctx.getCanonicalType(getType());
605
606 if (CT.isConstQualified())
Reid Spencer5f016e22007-07-11 17:01:13 +0000607 return MLV_ConstQualified;
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000608 if (CT->isArrayType())
Reid Spencer5f016e22007-07-11 17:01:13 +0000609 return MLV_ArrayType;
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000610 if (CT->isIncompleteType())
Reid Spencer5f016e22007-07-11 17:01:13 +0000611 return MLV_IncompleteType;
612
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000613 if (const RecordType *r = CT->getAsRecordType()) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000614 if (r->hasConstFields())
615 return MLV_ConstQualified;
616 }
Steve Naroff4f6a7d72008-09-26 14:41:28 +0000617 // The following is illegal:
618 // void takeclosure(void (^C)(void));
619 // void func() { int x = 1; takeclosure(^{ x = 7 }); }
620 //
621 if (getStmtClass() == BlockDeclRefExprClass) {
622 const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this);
623 if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl()))
624 return MLV_NotBlockQualified;
625 }
Fariborz Jahaniand1fa6442009-01-12 19:55:42 +0000626
Fariborz Jahanianba8d2d62008-11-22 20:25:50 +0000627 // Assigning to an 'implicit' property?
Fariborz Jahanian6669db92008-11-25 17:56:43 +0000628 else if (getStmtClass() == ObjCKVCRefExprClass) {
Fariborz Jahanianba8d2d62008-11-22 20:25:50 +0000629 const ObjCKVCRefExpr* KVCExpr = cast<ObjCKVCRefExpr>(this);
630 if (KVCExpr->getSetterMethod() == 0)
631 return MLV_NoSetterProperty;
632 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000633 return MLV_Valid;
634}
635
Ted Kremenek2e5f54a2008-02-27 18:39:48 +0000636/// hasGlobalStorage - Return true if this expression has static storage
Chris Lattner4cc62712007-11-27 21:35:27 +0000637/// duration. This means that the address of this expression is a link-time
638/// constant.
Ted Kremenek2e5f54a2008-02-27 18:39:48 +0000639bool Expr::hasGlobalStorage() const {
Chris Lattner1d09ecc2007-11-13 18:05:45 +0000640 switch (getStmtClass()) {
641 default:
642 return false;
Chris Lattner4cc62712007-11-27 21:35:27 +0000643 case ParenExprClass:
Ted Kremenek2e5f54a2008-02-27 18:39:48 +0000644 return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage();
Chris Lattner4cc62712007-11-27 21:35:27 +0000645 case ImplicitCastExprClass:
Ted Kremenek2e5f54a2008-02-27 18:39:48 +0000646 return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage();
Steve Naroffe9b12192008-01-14 18:19:28 +0000647 case CompoundLiteralExprClass:
648 return cast<CompoundLiteralExpr>(this)->isFileScope();
Douglas Gregor1a49af92009-01-06 05:10:23 +0000649 case DeclRefExprClass:
650 case QualifiedDeclRefExprClass: {
Chris Lattner1d09ecc2007-11-13 18:05:45 +0000651 const Decl *D = cast<DeclRefExpr>(this)->getDecl();
652 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
Ted Kremenek2e5f54a2008-02-27 18:39:48 +0000653 return VD->hasGlobalStorage();
Seo Sanghyeon63f067f2008-04-04 09:45:30 +0000654 if (isa<FunctionDecl>(D))
655 return true;
Chris Lattner1d09ecc2007-11-13 18:05:45 +0000656 return false;
657 }
Chris Lattnerfb708062007-11-28 04:30:09 +0000658 case MemberExprClass: {
Chris Lattner1d09ecc2007-11-13 18:05:45 +0000659 const MemberExpr *M = cast<MemberExpr>(this);
Ted Kremenek2e5f54a2008-02-27 18:39:48 +0000660 return !M->isArrow() && M->getBase()->hasGlobalStorage();
Chris Lattnerfb708062007-11-28 04:30:09 +0000661 }
Chris Lattner4cc62712007-11-27 21:35:27 +0000662 case ArraySubscriptExprClass:
Ted Kremenek2e5f54a2008-02-27 18:39:48 +0000663 return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage();
Chris Lattnerd9f69102008-08-10 01:53:14 +0000664 case PredefinedExprClass:
Chris Lattnerfa28b302008-01-12 08:14:25 +0000665 return true;
Chris Lattner04421082008-04-08 04:40:51 +0000666 case CXXDefaultArgExprClass:
667 return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage();
Chris Lattner1d09ecc2007-11-13 18:05:45 +0000668 }
669}
670
Ted Kremenek4e99a5f2008-01-17 16:57:34 +0000671Expr* Expr::IgnoreParens() {
672 Expr* E = this;
673 while (ParenExpr* P = dyn_cast<ParenExpr>(E))
674 E = P->getSubExpr();
675
676 return E;
677}
678
Chris Lattner56f34942008-02-13 01:02:39 +0000679/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr
680/// or CastExprs or ImplicitCastExprs, returning their operand.
681Expr *Expr::IgnoreParenCasts() {
682 Expr *E = this;
683 while (true) {
684 if (ParenExpr *P = dyn_cast<ParenExpr>(E))
685 E = P->getSubExpr();
686 else if (CastExpr *P = dyn_cast<CastExpr>(E))
687 E = P->getSubExpr();
Chris Lattner56f34942008-02-13 01:02:39 +0000688 else
689 return E;
690 }
691}
692
Douglas Gregor898574e2008-12-05 23:32:09 +0000693/// hasAnyTypeDependentArguments - Determines if any of the expressions
694/// in Exprs is type-dependent.
695bool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) {
696 for (unsigned I = 0; I < NumExprs; ++I)
697 if (Exprs[I]->isTypeDependent())
698 return true;
699
700 return false;
701}
702
703/// hasAnyValueDependentArguments - Determines if any of the expressions
704/// in Exprs is value-dependent.
705bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) {
706 for (unsigned I = 0; I < NumExprs; ++I)
707 if (Exprs[I]->isValueDependent())
708 return true;
709
710 return false;
711}
712
Eli Friedmanc9e8f602009-01-25 02:32:41 +0000713bool Expr::isConstantInitializer(ASTContext &Ctx) const {
Eli Friedmanc39dc9a2009-01-25 03:12:18 +0000714 // This function is attempting whether an expression is an initializer
715 // which can be evaluated at compile-time. isEvaluatable handles most
716 // of the cases, but it can't deal with some initializer-specific
717 // expressions, and it can't deal with aggregates; we deal with those here,
718 // and fall back to isEvaluatable for the other cases.
719
Anders Carlssone8a32b82008-11-24 05:23:59 +0000720 switch (getStmtClass()) {
Eli Friedmanc39dc9a2009-01-25 03:12:18 +0000721 default: break;
Anders Carlssone8a32b82008-11-24 05:23:59 +0000722 case StringLiteralClass:
Anders Carlssone8a32b82008-11-24 05:23:59 +0000723 return true;
Nate Begeman59b5da62009-01-18 03:20:47 +0000724 case CompoundLiteralExprClass: {
725 const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
Eli Friedmanc9e8f602009-01-25 02:32:41 +0000726 return Exp->isConstantInitializer(Ctx);
Nate Begeman59b5da62009-01-18 03:20:47 +0000727 }
Anders Carlssone8a32b82008-11-24 05:23:59 +0000728 case InitListExprClass: {
729 const InitListExpr *Exp = cast<InitListExpr>(this);
730 unsigned numInits = Exp->getNumInits();
731 for (unsigned i = 0; i < numInits; i++) {
Eli Friedmanc9e8f602009-01-25 02:32:41 +0000732 if (!Exp->getInit(i)->isConstantInitializer(Ctx))
Anders Carlssone8a32b82008-11-24 05:23:59 +0000733 return false;
734 }
Eli Friedmanc39dc9a2009-01-25 03:12:18 +0000735 return true;
Anders Carlssone8a32b82008-11-24 05:23:59 +0000736 }
Eli Friedmanc39dc9a2009-01-25 03:12:18 +0000737 case ParenExprClass: {
738 return cast<ParenExpr>(this)->getSubExpr()->isConstantInitializer(Ctx);
739 }
740 case UnaryOperatorClass: {
741 const UnaryOperator* Exp = cast<UnaryOperator>(this);
742 if (Exp->getOpcode() == UnaryOperator::Extension)
743 return Exp->getSubExpr()->isConstantInitializer(Ctx);
744 break;
745 }
746 case CStyleCastExprClass:
747 // Handle casts with a destination that's a struct or union; this
748 // deals with both the gcc no-op struct cast extension and the
749 // cast-to-union extension.
750 if (getType()->isRecordType())
751 return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx);
752 break;
Eli Friedman32a311e2009-01-25 03:27:40 +0000753 case DesignatedInitExprClass:
Sebastian Redl4e716e02009-01-25 13:34:47 +0000754 return cast<DesignatedInitExpr>(this)->
755 getInit()->isConstantInitializer(Ctx);
Anders Carlssone8a32b82008-11-24 05:23:59 +0000756 }
757
Eli Friedmanc39dc9a2009-01-25 03:12:18 +0000758 return isEvaluatable(Ctx);
Steve Naroff38374b02007-09-02 20:30:18 +0000759}
760
Douglas Gregor4c678342009-01-28 21:54:33 +0000761bool Expr::hasSideEffects(ASTContext &Ctx) const {
762 EvalResult Result;
763 Evaluate(Result, Ctx);
764 return Result.HasSideEffects;
765}
766
Reid Spencer5f016e22007-07-11 17:01:13 +0000767/// isIntegerConstantExpr - this recursive routine will test if an expression is
768/// an integer constant expression. Note: With the introduction of VLA's in
769/// C99 the result of the sizeof operator is no longer always a constant
770/// expression. The generalization of the wording to include any subexpression
771/// that is not evaluated (C99 6.6p3) means that nonconstant subexpressions
772/// can appear as operands to other operators (e.g. &&, ||, ?:). For instance,
Nuno Lopes5f6b6322008-07-08 21:13:06 +0000773/// "0 || f()" can be treated as a constant expression. In C90 this expression,
Reid Spencer5f016e22007-07-11 17:01:13 +0000774/// occurring in a context requiring a constant, would have been a constraint
775/// violation. FIXME: This routine currently implements C90 semantics.
776/// To properly implement C99 semantics this routine will need to evaluate
777/// expressions involving operators previously mentioned.
778
779/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero,
780/// comma, etc
781///
782/// FIXME: This should ext-warn on overflow during evaluation! ISO C does not
Chris Lattnerccc213f2007-09-26 00:47:26 +0000783/// permit this. This includes things like (int)1e1000
Chris Lattnerce0afc02007-07-18 05:21:20 +0000784///
785/// FIXME: Handle offsetof. Two things to do: Handle GCC's __builtin_offsetof
786/// to support gcc 4.0+ and handle the idiom GCC recognizes with a null pointer
787/// cast+dereference.
Chris Lattner590b6642007-07-15 23:26:56 +0000788bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
789 SourceLocation *Loc, bool isEvaluated) const {
Eli Friedmana6afa762008-11-13 06:09:17 +0000790 // Pretest for integral type; some parts of the code crash for types that
791 // can't be sized.
792 if (!getType()->isIntegralType()) {
793 if (Loc) *Loc = getLocStart();
794 return false;
795 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000796 switch (getStmtClass()) {
797 default:
798 if (Loc) *Loc = getLocStart();
799 return false;
Reid Spencer5f016e22007-07-11 17:01:13 +0000800 case ParenExprClass:
801 return cast<ParenExpr>(this)->getSubExpr()->
Chris Lattner590b6642007-07-15 23:26:56 +0000802 isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated);
Reid Spencer5f016e22007-07-11 17:01:13 +0000803 case IntegerLiteralClass:
804 Result = cast<IntegerLiteral>(this)->getValue();
805 break;
Chris Lattner2eadfb62007-07-15 23:32:58 +0000806 case CharacterLiteralClass: {
807 const CharacterLiteral *CL = cast<CharacterLiteral>(this);
Chris Lattner98be4942008-03-05 18:54:05 +0000808 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Chris Lattner2eadfb62007-07-15 23:32:58 +0000809 Result = CL->getValue();
Chris Lattnerf0fbcb32007-07-16 21:04:56 +0000810 Result.setIsUnsigned(!getType()->isSignedIntegerType());
Reid Spencer5f016e22007-07-11 17:01:13 +0000811 break;
Chris Lattner2eadfb62007-07-15 23:32:58 +0000812 }
Anders Carlssonb88d45e2008-08-23 21:12:35 +0000813 case CXXBoolLiteralExprClass: {
814 const CXXBoolLiteralExpr *BL = cast<CXXBoolLiteralExpr>(this);
815 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
816 Result = BL->getValue();
817 Result.setIsUnsigned(!getType()->isSignedIntegerType());
818 break;
819 }
Argyrios Kyrtzidis7267f782008-08-23 19:35:47 +0000820 case CXXZeroInitValueExprClass:
821 Result.clear();
822 break;
Steve Naroff7b658aa2007-08-02 04:09:23 +0000823 case TypesCompatibleExprClass: {
824 const TypesCompatibleExpr *TCE = cast<TypesCompatibleExpr>(this);
Chris Lattner98be4942008-03-05 18:54:05 +0000825 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Daniel Dunbarac620de2008-10-24 08:07:57 +0000826 // Per gcc docs "this built-in function ignores top level
827 // qualifiers". We need to use the canonical version to properly
828 // be able to strip CRV qualifiers from the type.
829 QualType T0 = Ctx.getCanonicalType(TCE->getArgType1());
830 QualType T1 = Ctx.getCanonicalType(TCE->getArgType2());
831 Result = Ctx.typesAreCompatible(T0.getUnqualifiedType(),
832 T1.getUnqualifiedType());
Steve Naroff389cecc2007-08-02 00:13:27 +0000833 break;
Steve Naroff7b658aa2007-08-02 04:09:23 +0000834 }
Douglas Gregorb4609802008-11-14 16:09:21 +0000835 case CallExprClass:
836 case CXXOperatorCallExprClass: {
Steve Naroff13b7c5f2007-08-08 22:15:55 +0000837 const CallExpr *CE = cast<CallExpr>(this);
Chris Lattner98be4942008-03-05 18:54:05 +0000838 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Chris Lattnera4d55d82008-10-06 06:40:35 +0000839
840 // If this is a call to a builtin function, constant fold it otherwise
841 // reject it.
842 if (CE->isBuiltinCall()) {
Anders Carlsson1c0cfd42008-12-19 20:58:05 +0000843 EvalResult EvalResult;
844 if (CE->Evaluate(EvalResult, Ctx)) {
845 assert(!EvalResult.HasSideEffects &&
846 "Foldable builtin call should not have side effects!");
847 Result = EvalResult.Val.getInt();
Chris Lattnera4d55d82008-10-06 06:40:35 +0000848 break; // It is a constant, expand it.
849 }
850 }
851
Steve Naroff13b7c5f2007-08-08 22:15:55 +0000852 if (Loc) *Loc = getLocStart();
853 return false;
854 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000855 case DeclRefExprClass:
Douglas Gregor1a49af92009-01-06 05:10:23 +0000856 case QualifiedDeclRefExprClass:
Reid Spencer5f016e22007-07-11 17:01:13 +0000857 if (const EnumConstantDecl *D =
858 dyn_cast<EnumConstantDecl>(cast<DeclRefExpr>(this)->getDecl())) {
859 Result = D->getInitVal();
860 break;
861 }
862 if (Loc) *Loc = getLocStart();
863 return false;
864 case UnaryOperatorClass: {
865 const UnaryOperator *Exp = cast<UnaryOperator>(this);
866
Sebastian Redl05189992008-11-11 17:56:53 +0000867 // Get the operand value. If this is offsetof, do not evalute the
Reid Spencer5f016e22007-07-11 17:01:13 +0000868 // operand. This affects C99 6.6p3.
Sebastian Redl05189992008-11-11 17:56:53 +0000869 if (!Exp->isOffsetOfOp() && !Exp->getSubExpr()->
870 isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
Reid Spencer5f016e22007-07-11 17:01:13 +0000871 return false;
872
873 switch (Exp->getOpcode()) {
874 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
875 // See C99 6.6p3.
876 default:
877 if (Loc) *Loc = Exp->getOperatorLoc();
878 return false;
879 case UnaryOperator::Extension:
Chris Lattner76e773a2007-07-18 18:38:36 +0000880 return true; // FIXME: this is wrong.
Reid Spencer5f016e22007-07-11 17:01:13 +0000881 case UnaryOperator::LNot: {
Chris Lattnerbf755382008-01-25 19:16:19 +0000882 bool Val = Result == 0;
Chris Lattner98be4942008-03-05 18:54:05 +0000883 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Reid Spencer5f016e22007-07-11 17:01:13 +0000884 Result = Val;
885 break;
886 }
887 case UnaryOperator::Plus:
Reid Spencer5f016e22007-07-11 17:01:13 +0000888 break;
889 case UnaryOperator::Minus:
Reid Spencer5f016e22007-07-11 17:01:13 +0000890 Result = -Result;
891 break;
892 case UnaryOperator::Not:
Reid Spencer5f016e22007-07-11 17:01:13 +0000893 Result = ~Result;
894 break;
Anders Carlsson5a1deb82008-01-29 15:56:48 +0000895 case UnaryOperator::OffsetOf:
Daniel Dunbaraa1f9f12008-08-28 18:42:20 +0000896 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Anders Carlsson5a1deb82008-01-29 15:56:48 +0000897 Result = Exp->evaluateOffsetOf(Ctx);
Reid Spencer5f016e22007-07-11 17:01:13 +0000898 }
899 break;
900 }
Sebastian Redl05189992008-11-11 17:56:53 +0000901 case SizeOfAlignOfExprClass: {
902 const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(this);
Chris Lattnera269ebf2008-02-21 05:45:29 +0000903
904 // Return the result in the right width.
Chris Lattner98be4942008-03-05 18:54:05 +0000905 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Chris Lattnera269ebf2008-02-21 05:45:29 +0000906
Sebastian Redl05189992008-11-11 17:56:53 +0000907 QualType ArgTy = Exp->getTypeOfArgument();
Chris Lattnera269ebf2008-02-21 05:45:29 +0000908 // sizeof(void) and __alignof__(void) = 1 as a gcc extension.
Sebastian Redl05189992008-11-11 17:56:53 +0000909 if (ArgTy->isVoidType()) {
Chris Lattnera269ebf2008-02-21 05:45:29 +0000910 Result = 1;
911 break;
912 }
913
914 // alignof always evaluates to a constant, sizeof does if arg is not VLA.
Sebastian Redl05189992008-11-11 17:56:53 +0000915 if (Exp->isSizeOf() && !ArgTy->isConstantSizeType()) {
Chris Lattner65383472007-12-18 07:15:40 +0000916 if (Loc) *Loc = Exp->getOperatorLoc();
Reid Spencer5f016e22007-07-11 17:01:13 +0000917 return false;
Chris Lattner65383472007-12-18 07:15:40 +0000918 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000919
Chris Lattner76e773a2007-07-18 18:38:36 +0000920 // Get information about the size or align.
Sebastian Redl05189992008-11-11 17:56:53 +0000921 if (ArgTy->isFunctionType()) {
Chris Lattnerefdd1572008-01-02 21:54:09 +0000922 // GCC extension: sizeof(function) = 1.
923 Result = Exp->isSizeOf() ? 1 : 4;
Anders Carlsson6a24acb2008-02-16 01:20:23 +0000924 } else {
Chris Lattner98be4942008-03-05 18:54:05 +0000925 unsigned CharSize = Ctx.Target.getCharWidth();
Anders Carlsson6a24acb2008-02-16 01:20:23 +0000926 if (Exp->isSizeOf())
Sebastian Redl05189992008-11-11 17:56:53 +0000927 Result = Ctx.getTypeSize(ArgTy) / CharSize;
Anders Carlsson6a24acb2008-02-16 01:20:23 +0000928 else
Sebastian Redl05189992008-11-11 17:56:53 +0000929 Result = Ctx.getTypeAlign(ArgTy) / CharSize;
Ted Kremenek060e4702007-12-17 17:38:43 +0000930 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000931 break;
932 }
933 case BinaryOperatorClass: {
934 const BinaryOperator *Exp = cast<BinaryOperator>(this);
Daniel Dunbare1226d22008-09-22 23:53:24 +0000935 llvm::APSInt LHS, RHS;
936
937 // Initialize result to have correct signedness and width.
938 Result = llvm::APSInt(static_cast<uint32_t>(Ctx.getTypeSize(getType())),
Eli Friedmanb11e7782008-11-13 02:13:11 +0000939 !getType()->isSignedIntegerType());
940
Reid Spencer5f016e22007-07-11 17:01:13 +0000941 // The LHS of a constant expr is always evaluated and needed.
Daniel Dunbare1226d22008-09-22 23:53:24 +0000942 if (!Exp->getLHS()->isIntegerConstantExpr(LHS, Ctx, Loc, isEvaluated))
Reid Spencer5f016e22007-07-11 17:01:13 +0000943 return false;
944
Reid Spencer5f016e22007-07-11 17:01:13 +0000945 // The short-circuiting &&/|| operators don't necessarily evaluate their
946 // RHS. Make sure to pass isEvaluated down correctly.
947 if (Exp->isLogicalOp()) {
948 bool RHSEval;
949 if (Exp->getOpcode() == BinaryOperator::LAnd)
Daniel Dunbare1226d22008-09-22 23:53:24 +0000950 RHSEval = LHS != 0;
Reid Spencer5f016e22007-07-11 17:01:13 +0000951 else {
952 assert(Exp->getOpcode() == BinaryOperator::LOr &&"Unexpected logical");
Daniel Dunbare1226d22008-09-22 23:53:24 +0000953 RHSEval = LHS == 0;
Reid Spencer5f016e22007-07-11 17:01:13 +0000954 }
955
Chris Lattner590b6642007-07-15 23:26:56 +0000956 if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc,
Reid Spencer5f016e22007-07-11 17:01:13 +0000957 isEvaluated & RHSEval))
958 return false;
959 } else {
Chris Lattner590b6642007-07-15 23:26:56 +0000960 if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc, isEvaluated))
Reid Spencer5f016e22007-07-11 17:01:13 +0000961 return false;
962 }
963
Reid Spencer5f016e22007-07-11 17:01:13 +0000964 switch (Exp->getOpcode()) {
965 default:
966 if (Loc) *Loc = getLocStart();
967 return false;
968 case BinaryOperator::Mul:
Daniel Dunbare1226d22008-09-22 23:53:24 +0000969 Result = LHS * RHS;
Reid Spencer5f016e22007-07-11 17:01:13 +0000970 break;
971 case BinaryOperator::Div:
972 if (RHS == 0) {
973 if (!isEvaluated) break;
974 if (Loc) *Loc = getLocStart();
975 return false;
976 }
Daniel Dunbare1226d22008-09-22 23:53:24 +0000977 Result = LHS / RHS;
Reid Spencer5f016e22007-07-11 17:01:13 +0000978 break;
979 case BinaryOperator::Rem:
980 if (RHS == 0) {
981 if (!isEvaluated) break;
982 if (Loc) *Loc = getLocStart();
983 return false;
984 }
Daniel Dunbare1226d22008-09-22 23:53:24 +0000985 Result = LHS % RHS;
Reid Spencer5f016e22007-07-11 17:01:13 +0000986 break;
Daniel Dunbare1226d22008-09-22 23:53:24 +0000987 case BinaryOperator::Add: Result = LHS + RHS; break;
988 case BinaryOperator::Sub: Result = LHS - RHS; break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000989 case BinaryOperator::Shl:
Daniel Dunbare1226d22008-09-22 23:53:24 +0000990 Result = LHS <<
991 static_cast<uint32_t>(RHS.getLimitedValue(LHS.getBitWidth()-1));
992 break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000993 case BinaryOperator::Shr:
Daniel Dunbare1226d22008-09-22 23:53:24 +0000994 Result = LHS >>
995 static_cast<uint32_t>(RHS.getLimitedValue(LHS.getBitWidth()-1));
Reid Spencer5f016e22007-07-11 17:01:13 +0000996 break;
Daniel Dunbare1226d22008-09-22 23:53:24 +0000997 case BinaryOperator::LT: Result = LHS < RHS; break;
998 case BinaryOperator::GT: Result = LHS > RHS; break;
999 case BinaryOperator::LE: Result = LHS <= RHS; break;
1000 case BinaryOperator::GE: Result = LHS >= RHS; break;
1001 case BinaryOperator::EQ: Result = LHS == RHS; break;
1002 case BinaryOperator::NE: Result = LHS != RHS; break;
1003 case BinaryOperator::And: Result = LHS & RHS; break;
1004 case BinaryOperator::Xor: Result = LHS ^ RHS; break;
1005 case BinaryOperator::Or: Result = LHS | RHS; break;
Reid Spencer5f016e22007-07-11 17:01:13 +00001006 case BinaryOperator::LAnd:
Daniel Dunbare1226d22008-09-22 23:53:24 +00001007 Result = LHS != 0 && RHS != 0;
Reid Spencer5f016e22007-07-11 17:01:13 +00001008 break;
1009 case BinaryOperator::LOr:
Daniel Dunbare1226d22008-09-22 23:53:24 +00001010 Result = LHS != 0 || RHS != 0;
Reid Spencer5f016e22007-07-11 17:01:13 +00001011 break;
Eli Friedmanb11e7782008-11-13 02:13:11 +00001012
1013 case BinaryOperator::Comma:
1014 // C99 6.6p3: "shall not contain assignment, ..., or comma operators,
1015 // *except* when they are contained within a subexpression that is not
1016 // evaluated". Note that Assignment can never happen due to constraints
1017 // on the LHS subexpr, so we don't need to check it here.
1018 if (isEvaluated) {
1019 if (Loc) *Loc = getLocStart();
1020 return false;
1021 }
1022
1023 // The result of the constant expr is the RHS.
1024 Result = RHS;
1025 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00001026 }
1027
1028 assert(!Exp->isAssignmentOp() && "LHS can't be a constant expr!");
1029 break;
1030 }
Chris Lattner26dc7b32007-07-15 23:54:50 +00001031 case ImplicitCastExprClass:
Douglas Gregor6eec8e82008-10-28 15:36:24 +00001032 case CStyleCastExprClass:
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001033 case CXXFunctionalCastExprClass: {
Argyrios Kyrtzidis0835a3c2008-08-18 23:01:59 +00001034 const Expr *SubExpr = cast<CastExpr>(this)->getSubExpr();
1035 SourceLocation CastLoc = getLocStart();
Chris Lattner26dc7b32007-07-15 23:54:50 +00001036
Reid Spencer5f016e22007-07-11 17:01:13 +00001037 // C99 6.6p6: shall only convert arithmetic types to integer types.
Chris Lattner26dc7b32007-07-15 23:54:50 +00001038 if (!SubExpr->getType()->isArithmeticType() ||
1039 !getType()->isIntegerType()) {
1040 if (Loc) *Loc = SubExpr->getLocStart();
Reid Spencer5f016e22007-07-11 17:01:13 +00001041 return false;
1042 }
Chris Lattner987b15d2007-09-22 19:04:13 +00001043
Chris Lattner98be4942008-03-05 18:54:05 +00001044 uint32_t DestWidth = static_cast<uint32_t>(Ctx.getTypeSize(getType()));
Chris Lattner987b15d2007-09-22 19:04:13 +00001045
Reid Spencer5f016e22007-07-11 17:01:13 +00001046 // Handle simple integer->integer casts.
Chris Lattner26dc7b32007-07-15 23:54:50 +00001047 if (SubExpr->getType()->isIntegerType()) {
1048 if (!SubExpr->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
Reid Spencer5f016e22007-07-11 17:01:13 +00001049 return false;
Chris Lattner26dc7b32007-07-15 23:54:50 +00001050
1051 // Figure out if this is a truncate, extend or noop cast.
Chris Lattner26dc7b32007-07-15 23:54:50 +00001052 // If the input is signed, do a sign extend, noop, or truncate.
Chris Lattnerc0a356b2008-01-09 18:59:34 +00001053 if (getType()->isBooleanType()) {
1054 // Conversion to bool compares against zero.
1055 Result = Result != 0;
1056 Result.zextOrTrunc(DestWidth);
1057 } else if (SubExpr->getType()->isSignedIntegerType())
Chris Lattner26dc7b32007-07-15 23:54:50 +00001058 Result.sextOrTrunc(DestWidth);
1059 else // If the input is unsigned, do a zero extend, noop, or truncate.
1060 Result.zextOrTrunc(DestWidth);
Reid Spencer5f016e22007-07-11 17:01:13 +00001061 break;
1062 }
1063
1064 // Allow floating constants that are the immediate operands of casts or that
1065 // are parenthesized.
Chris Lattner26dc7b32007-07-15 23:54:50 +00001066 const Expr *Operand = SubExpr;
Reid Spencer5f016e22007-07-11 17:01:13 +00001067 while (const ParenExpr *PE = dyn_cast<ParenExpr>(Operand))
1068 Operand = PE->getSubExpr();
Chris Lattner987b15d2007-09-22 19:04:13 +00001069
1070 // If this isn't a floating literal, we can't handle it.
1071 const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(Operand);
1072 if (!FL) {
1073 if (Loc) *Loc = Operand->getLocStart();
1074 return false;
Reid Spencer5f016e22007-07-11 17:01:13 +00001075 }
Chris Lattnerc0a356b2008-01-09 18:59:34 +00001076
1077 // If the destination is boolean, compare against zero.
1078 if (getType()->isBooleanType()) {
1079 Result = !FL->getValue().isZero();
1080 Result.zextOrTrunc(DestWidth);
1081 break;
1082 }
Chris Lattner987b15d2007-09-22 19:04:13 +00001083
1084 // Determine whether we are converting to unsigned or signed.
1085 bool DestSigned = getType()->isSignedIntegerType();
Chris Lattnerccc213f2007-09-26 00:47:26 +00001086
1087 // TODO: Warn on overflow, but probably not here: isIntegerConstantExpr can
1088 // be called multiple times per AST.
Dale Johannesenee5a7002008-10-09 23:02:32 +00001089 uint64_t Space[4];
1090 bool ignored;
Chris Lattnerccc213f2007-09-26 00:47:26 +00001091 (void)FL->getValue().convertToInteger(Space, DestWidth, DestSigned,
Dale Johannesenee5a7002008-10-09 23:02:32 +00001092 llvm::APFloat::rmTowardZero,
1093 &ignored);
Chris Lattner987b15d2007-09-22 19:04:13 +00001094 Result = llvm::APInt(DestWidth, 4, Space);
1095 break;
Reid Spencer5f016e22007-07-11 17:01:13 +00001096 }
1097 case ConditionalOperatorClass: {
1098 const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
1099
Chris Lattner28daa532008-12-12 06:55:44 +00001100 const Expr *Cond = Exp->getCond();
1101
1102 if (!Cond->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
Reid Spencer5f016e22007-07-11 17:01:13 +00001103 return false;
1104
1105 const Expr *TrueExp = Exp->getLHS();
1106 const Expr *FalseExp = Exp->getRHS();
1107 if (Result == 0) std::swap(TrueExp, FalseExp);
1108
Chris Lattner28daa532008-12-12 06:55:44 +00001109 // If the condition (ignoring parens) is a __builtin_constant_p call,
1110 // then only the true side is actually considered in an integer constant
Chris Lattner42b83dd2008-12-12 18:00:51 +00001111 // expression, and it is fully evaluated. This is an important GNU
1112 // extension. See GCC PR38377 for discussion.
Chris Lattner28daa532008-12-12 06:55:44 +00001113 if (const CallExpr *CallCE = dyn_cast<CallExpr>(Cond->IgnoreParenCasts()))
Chris Lattner42b83dd2008-12-12 18:00:51 +00001114 if (CallCE->isBuiltinCall() == Builtin::BI__builtin_constant_p) {
1115 EvalResult EVResult;
1116 if (!Evaluate(EVResult, Ctx) || EVResult.HasSideEffects)
1117 return false;
1118 assert(EVResult.Val.isInt() && "FP conditional expr not expected");
1119 Result = EVResult.Val.getInt();
1120 if (Loc) *Loc = EVResult.DiagLoc;
1121 return true;
1122 }
Chris Lattner28daa532008-12-12 06:55:44 +00001123
Reid Spencer5f016e22007-07-11 17:01:13 +00001124 // Evaluate the false one first, discard the result.
Anders Carlsson39073232007-11-30 19:04:31 +00001125 if (FalseExp && !FalseExp->isIntegerConstantExpr(Result, Ctx, Loc, false))
Reid Spencer5f016e22007-07-11 17:01:13 +00001126 return false;
1127 // Evalute the true one, capture the result.
Anders Carlsson39073232007-11-30 19:04:31 +00001128 if (TrueExp &&
1129 !TrueExp->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
Reid Spencer5f016e22007-07-11 17:01:13 +00001130 return false;
Reid Spencer5f016e22007-07-11 17:01:13 +00001131 break;
1132 }
Chris Lattner04421082008-04-08 04:40:51 +00001133 case CXXDefaultArgExprClass:
1134 return cast<CXXDefaultArgExpr>(this)
1135 ->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated);
Sebastian Redl64b45f72009-01-05 20:52:13 +00001136
1137 case UnaryTypeTraitExprClass:
1138 Result = cast<UnaryTypeTraitExpr>(this)->Evaluate();
1139 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00001140 }
1141
1142 // Cases that are valid constant exprs fall through to here.
1143 Result.setIsUnsigned(getType()->isUnsignedIntegerType());
1144 return true;
1145}
1146
Reid Spencer5f016e22007-07-11 17:01:13 +00001147/// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an
1148/// integer constant expression with the value zero, or if this is one that is
1149/// cast to void*.
Anders Carlssonefa9b382008-12-01 02:13:57 +00001150bool Expr::isNullPointerConstant(ASTContext &Ctx) const
1151{
Sebastian Redl07779722008-10-31 14:43:28 +00001152 // Strip off a cast to void*, if it exists. Except in C++.
Argyrios Kyrtzidis0835a3c2008-08-18 23:01:59 +00001153 if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
Sebastian Redl6215dee2008-11-04 11:45:54 +00001154 if (!Ctx.getLangOptions().CPlusPlus) {
Sebastian Redl07779722008-10-31 14:43:28 +00001155 // Check that it is a cast to void*.
1156 if (const PointerType *PT = CE->getType()->getAsPointerType()) {
1157 QualType Pointee = PT->getPointeeType();
1158 if (Pointee.getCVRQualifiers() == 0 &&
1159 Pointee->isVoidType() && // to void*
1160 CE->getSubExpr()->getType()->isIntegerType()) // from int.
Anders Carlssond2652772008-12-01 06:28:23 +00001161 return CE->getSubExpr()->isNullPointerConstant(Ctx);
Sebastian Redl07779722008-10-31 14:43:28 +00001162 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001163 }
Steve Naroffaa58f002008-01-14 16:10:57 +00001164 } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
1165 // Ignore the ImplicitCastExpr type entirely.
Anders Carlssond2652772008-12-01 06:28:23 +00001166 return ICE->getSubExpr()->isNullPointerConstant(Ctx);
Steve Naroffaa58f002008-01-14 16:10:57 +00001167 } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
1168 // Accept ((void*)0) as a null pointer constant, as many other
1169 // implementations do.
Anders Carlssond2652772008-12-01 06:28:23 +00001170 return PE->getSubExpr()->isNullPointerConstant(Ctx);
Chris Lattner8123a952008-04-10 02:22:51 +00001171 } else if (const CXXDefaultArgExpr *DefaultArg
1172 = dyn_cast<CXXDefaultArgExpr>(this)) {
Chris Lattner04421082008-04-08 04:40:51 +00001173 // See through default argument expressions
Anders Carlssond2652772008-12-01 06:28:23 +00001174 return DefaultArg->getExpr()->isNullPointerConstant(Ctx);
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001175 } else if (isa<GNUNullExpr>(this)) {
1176 // The GNU __null extension is always a null pointer constant.
1177 return true;
Steve Naroffaaffbf72008-01-14 02:53:34 +00001178 }
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001179
Steve Naroffaa58f002008-01-14 16:10:57 +00001180 // This expression must be an integer type.
1181 if (!getType()->isIntegerType())
1182 return false;
1183
Reid Spencer5f016e22007-07-11 17:01:13 +00001184 // If we have an integer constant expression, we need to *evaluate* it and
1185 // test for the value 0.
Anders Carlssond2652772008-12-01 06:28:23 +00001186 // FIXME: We should probably return false if we're compiling in strict mode
1187 // and Diag is not null (this indicates that the value was foldable but not
1188 // an ICE.
1189 EvalResult Result;
Anders Carlssonefa9b382008-12-01 02:13:57 +00001190 return Evaluate(Result, Ctx) && !Result.HasSideEffects &&
Anders Carlssond2652772008-12-01 06:28:23 +00001191 Result.Val.isInt() && Result.Val.getInt() == 0;
Reid Spencer5f016e22007-07-11 17:01:13 +00001192}
Steve Naroff31a45842007-07-28 23:10:27 +00001193
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001194/// isBitField - Return true if this expression is a bit-field.
1195bool Expr::isBitField() {
1196 Expr *E = this->IgnoreParenCasts();
1197 if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
Douglas Gregor86f19402008-12-20 23:49:58 +00001198 if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
1199 return Field->isBitField();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001200 return false;
1201}
1202
Nate Begeman213541a2008-04-18 23:10:10 +00001203unsigned ExtVectorElementExpr::getNumElements() const {
Nate Begeman8a997642008-05-09 06:41:27 +00001204 if (const VectorType *VT = getType()->getAsVectorType())
1205 return VT->getNumElements();
1206 return 1;
Chris Lattner4d0ac882007-08-03 16:00:20 +00001207}
1208
Nate Begeman8a997642008-05-09 06:41:27 +00001209/// containsDuplicateElements - Return true if any element access is repeated.
Nate Begeman213541a2008-04-18 23:10:10 +00001210bool ExtVectorElementExpr::containsDuplicateElements() const {
Steve Narofffec0b492007-07-30 03:29:09 +00001211 const char *compStr = Accessor.getName();
Chris Lattner7e3e9b12008-11-19 07:55:04 +00001212 unsigned length = Accessor.getLength();
Nate Begeman190d6a22009-01-18 02:01:21 +00001213
1214 // Halving swizzles do not contain duplicate elements.
1215 if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
1216 !strcmp(compStr, "even") || !strcmp(compStr, "odd"))
1217 return false;
1218
1219 // Advance past s-char prefix on hex swizzles.
1220 if (*compStr == 's') {
1221 compStr++;
1222 length--;
1223 }
Steve Narofffec0b492007-07-30 03:29:09 +00001224
Chris Lattner7e3e9b12008-11-19 07:55:04 +00001225 for (unsigned i = 0; i != length-1; i++) {
Steve Narofffec0b492007-07-30 03:29:09 +00001226 const char *s = compStr+i;
1227 for (const char c = *s++; *s; s++)
1228 if (c == *s)
1229 return true;
1230 }
1231 return false;
1232}
Chris Lattnerb8f849d2007-08-02 23:36:59 +00001233
Nate Begeman8a997642008-05-09 06:41:27 +00001234/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
Nate Begeman3b8d1162008-05-13 21:03:02 +00001235void ExtVectorElementExpr::getEncodedElementAccess(
1236 llvm::SmallVectorImpl<unsigned> &Elts) const {
Chris Lattner7e3e9b12008-11-19 07:55:04 +00001237 const char *compStr = Accessor.getName();
Nate Begeman353417a2009-01-18 01:47:54 +00001238 if (*compStr == 's')
1239 compStr++;
1240
1241 bool isHi = !strcmp(compStr, "hi");
1242 bool isLo = !strcmp(compStr, "lo");
1243 bool isEven = !strcmp(compStr, "even");
1244 bool isOdd = !strcmp(compStr, "odd");
1245
Nate Begeman8a997642008-05-09 06:41:27 +00001246 for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
1247 uint64_t Index;
1248
1249 if (isHi)
1250 Index = e + i;
1251 else if (isLo)
1252 Index = i;
1253 else if (isEven)
1254 Index = 2 * i;
1255 else if (isOdd)
1256 Index = 2 * i + 1;
1257 else
1258 Index = ExtVectorType::getAccessorIdx(compStr[i]);
Chris Lattnerb8f849d2007-08-02 23:36:59 +00001259
Nate Begeman3b8d1162008-05-13 21:03:02 +00001260 Elts.push_back(Index);
Chris Lattnerb8f849d2007-08-02 23:36:59 +00001261 }
Nate Begeman8a997642008-05-09 06:41:27 +00001262}
1263
Steve Naroff68d331a2007-09-27 14:38:14 +00001264// constructor for instance messages.
Steve Naroffbcfb06a2007-09-28 22:22:11 +00001265ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo,
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001266 QualType retType, ObjCMethodDecl *mproto,
Steve Naroffdb611d52007-11-03 16:37:59 +00001267 SourceLocation LBrac, SourceLocation RBrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00001268 Expr **ArgExprs, unsigned nargs)
Steve Naroffdb611d52007-11-03 16:37:59 +00001269 : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
Ted Kremenekea958e572008-05-01 17:26:20 +00001270 MethodProto(mproto) {
Steve Naroff49f109c2007-11-15 13:05:42 +00001271 NumArgs = nargs;
Ted Kremenek55499762008-06-17 02:43:46 +00001272 SubExprs = new Stmt*[NumArgs+1];
Steve Naroff68d331a2007-09-27 14:38:14 +00001273 SubExprs[RECEIVER] = receiver;
Steve Naroff49f109c2007-11-15 13:05:42 +00001274 if (NumArgs) {
1275 for (unsigned i = 0; i != NumArgs; ++i)
Steve Naroff68d331a2007-09-27 14:38:14 +00001276 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1277 }
Steve Naroff563477d2007-09-18 23:55:05 +00001278 LBracloc = LBrac;
1279 RBracloc = RBrac;
1280}
1281
Steve Naroff68d331a2007-09-27 14:38:14 +00001282// constructor for class messages.
1283// FIXME: clsName should be typed to ObjCInterfaceType
Steve Naroffbcfb06a2007-09-28 22:22:11 +00001284ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo,
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001285 QualType retType, ObjCMethodDecl *mproto,
Steve Naroffdb611d52007-11-03 16:37:59 +00001286 SourceLocation LBrac, SourceLocation RBrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00001287 Expr **ArgExprs, unsigned nargs)
Steve Naroffdb611d52007-11-03 16:37:59 +00001288 : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
Ted Kremenekea958e572008-05-01 17:26:20 +00001289 MethodProto(mproto) {
Steve Naroff49f109c2007-11-15 13:05:42 +00001290 NumArgs = nargs;
Ted Kremenek55499762008-06-17 02:43:46 +00001291 SubExprs = new Stmt*[NumArgs+1];
Ted Kremenek4df728e2008-06-24 15:50:53 +00001292 SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown);
Steve Naroff49f109c2007-11-15 13:05:42 +00001293 if (NumArgs) {
1294 for (unsigned i = 0; i != NumArgs; ++i)
Steve Naroff68d331a2007-09-27 14:38:14 +00001295 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1296 }
Steve Naroff563477d2007-09-18 23:55:05 +00001297 LBracloc = LBrac;
1298 RBracloc = RBrac;
1299}
1300
Ted Kremenek4df728e2008-06-24 15:50:53 +00001301// constructor for class messages.
1302ObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo,
1303 QualType retType, ObjCMethodDecl *mproto,
1304 SourceLocation LBrac, SourceLocation RBrac,
1305 Expr **ArgExprs, unsigned nargs)
1306: Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1307MethodProto(mproto) {
1308 NumArgs = nargs;
1309 SubExprs = new Stmt*[NumArgs+1];
1310 SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown);
1311 if (NumArgs) {
1312 for (unsigned i = 0; i != NumArgs; ++i)
1313 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1314 }
1315 LBracloc = LBrac;
1316 RBracloc = RBrac;
1317}
1318
1319ObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const {
1320 uintptr_t x = (uintptr_t) SubExprs[RECEIVER];
1321 switch (x & Flags) {
1322 default:
1323 assert(false && "Invalid ObjCMessageExpr.");
1324 case IsInstMeth:
1325 return ClassInfo(0, 0);
1326 case IsClsMethDeclUnknown:
1327 return ClassInfo(0, (IdentifierInfo*) (x & ~Flags));
1328 case IsClsMethDeclKnown: {
1329 ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags);
1330 return ClassInfo(D, D->getIdentifier());
1331 }
1332 }
1333}
1334
Chris Lattner27437ca2007-10-25 00:29:32 +00001335bool ChooseExpr::isConditionTrue(ASTContext &C) const {
Daniel Dunbar32442bb2008-08-13 23:47:13 +00001336 return getCond()->getIntegerConstantExprValue(C) != 0;
Chris Lattner27437ca2007-10-25 00:29:32 +00001337}
1338
Chris Lattner670a62c2008-12-12 05:35:08 +00001339static int64_t evaluateOffsetOf(ASTContext& C, const Expr *E) {
Anders Carlsson5a1deb82008-01-29 15:56:48 +00001340 if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
1341 QualType Ty = ME->getBase()->getType();
1342
1343 RecordDecl *RD = Ty->getAsRecordType()->getDecl();
Chris Lattner98be4942008-03-05 18:54:05 +00001344 const ASTRecordLayout &RL = C.getASTRecordLayout(RD);
Douglas Gregor86f19402008-12-20 23:49:58 +00001345 if (FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
1346 // FIXME: This is linear time. And the fact that we're indexing
1347 // into the layout by position in the record means that we're
1348 // either stuck numbering the fields in the AST or we have to keep
1349 // the linear search (yuck and yuck).
1350 unsigned i = 0;
1351 for (RecordDecl::field_iterator Field = RD->field_begin(),
1352 FieldEnd = RD->field_end();
1353 Field != FieldEnd; (void)++Field, ++i) {
1354 if (*Field == FD)
1355 break;
1356 }
1357
1358 return RL.getFieldOffset(i) + evaluateOffsetOf(C, ME->getBase());
Anders Carlsson5a1deb82008-01-29 15:56:48 +00001359 }
Anders Carlsson5a1deb82008-01-29 15:56:48 +00001360 } else if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) {
1361 const Expr *Base = ASE->getBase();
Anders Carlsson5a1deb82008-01-29 15:56:48 +00001362
Chris Lattner98be4942008-03-05 18:54:05 +00001363 int64_t size = C.getTypeSize(ASE->getType());
Daniel Dunbar32442bb2008-08-13 23:47:13 +00001364 size *= ASE->getIdx()->getIntegerConstantExprValue(C).getSExtValue();
Anders Carlsson5a1deb82008-01-29 15:56:48 +00001365
1366 return size + evaluateOffsetOf(C, Base);
1367 } else if (isa<CompoundLiteralExpr>(E))
1368 return 0;
1369
1370 assert(0 && "Unknown offsetof subexpression!");
1371 return 0;
1372}
1373
1374int64_t UnaryOperator::evaluateOffsetOf(ASTContext& C) const
1375{
1376 assert(Opc == OffsetOf && "Unary operator not offsetof!");
1377
Chris Lattner98be4942008-03-05 18:54:05 +00001378 unsigned CharSize = C.Target.getCharWidth();
Ted Kremenek55499762008-06-17 02:43:46 +00001379 return ::evaluateOffsetOf(C, cast<Expr>(Val)) / CharSize;
Anders Carlsson5a1deb82008-01-29 15:56:48 +00001380}
1381
Sebastian Redl05189992008-11-11 17:56:53 +00001382void SizeOfAlignOfExpr::Destroy(ASTContext& C) {
1383 // Override default behavior of traversing children. If this has a type
1384 // operand and the type is a variable-length array, the child iteration
1385 // will iterate over the size expression. However, this expression belongs
1386 // to the type, not to this, so we don't want to delete it.
1387 // We still want to delete this expression.
1388 // FIXME: Same as in Stmt::Destroy - will be eventually in ASTContext's
1389 // pool allocator.
1390 if (isArgumentType())
1391 delete this;
1392 else
1393 Expr::Destroy(C);
Daniel Dunbar90488912008-08-28 18:02:04 +00001394}
1395
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001396//===----------------------------------------------------------------------===//
Douglas Gregor05c13a32009-01-22 00:58:24 +00001397// DesignatedInitExpr
1398//===----------------------------------------------------------------------===//
1399
1400IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() {
1401 assert(Kind == FieldDesignator && "Only valid on a field designator");
1402 if (Field.NameOrField & 0x01)
1403 return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
1404 else
1405 return getField()->getIdentifier();
1406}
1407
1408DesignatedInitExpr *
1409DesignatedInitExpr::Create(ASTContext &C, Designator *Designators,
1410 unsigned NumDesignators,
1411 Expr **IndexExprs, unsigned NumIndexExprs,
1412 SourceLocation ColonOrEqualLoc,
1413 bool UsesColonSyntax, Expr *Init) {
Steve Naroffc0ac4922009-01-27 23:20:32 +00001414 void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
1415 sizeof(Designator) * NumDesignators +
1416 sizeof(Stmt *) * (NumIndexExprs + 1), 8);
Douglas Gregor05c13a32009-01-22 00:58:24 +00001417 DesignatedInitExpr *DIE
1418 = new (Mem) DesignatedInitExpr(C.VoidTy, NumDesignators,
1419 ColonOrEqualLoc, UsesColonSyntax,
1420 NumIndexExprs + 1);
1421
1422 // Fill in the designators
1423 unsigned ExpectedNumSubExprs = 0;
1424 designators_iterator Desig = DIE->designators_begin();
1425 for (unsigned Idx = 0; Idx < NumDesignators; ++Idx, ++Desig) {
1426 new (static_cast<void*>(Desig)) Designator(Designators[Idx]);
1427 if (Designators[Idx].isArrayDesignator())
1428 ++ExpectedNumSubExprs;
1429 else if (Designators[Idx].isArrayRangeDesignator())
1430 ExpectedNumSubExprs += 2;
1431 }
1432 assert(ExpectedNumSubExprs == NumIndexExprs && "Wrong number of indices!");
1433
1434 // Fill in the subexpressions, including the initializer expression.
1435 child_iterator Child = DIE->child_begin();
1436 *Child++ = Init;
1437 for (unsigned Idx = 0; Idx < NumIndexExprs; ++Idx, ++Child)
1438 *Child = IndexExprs[Idx];
1439
1440 return DIE;
1441}
1442
1443SourceRange DesignatedInitExpr::getSourceRange() const {
1444 SourceLocation StartLoc;
1445 Designator &First = *const_cast<DesignatedInitExpr*>(this)->designators_begin();
1446 if (First.isFieldDesignator()) {
1447 if (UsesColonSyntax)
1448 StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
1449 else
1450 StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
1451 } else
1452 StartLoc = SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
1453 return SourceRange(StartLoc, getInit()->getSourceRange().getEnd());
1454}
1455
1456DesignatedInitExpr::designators_iterator DesignatedInitExpr::designators_begin() {
1457 char* Ptr = static_cast<char*>(static_cast<void *>(this));
1458 Ptr += sizeof(DesignatedInitExpr);
1459 return static_cast<Designator*>(static_cast<void*>(Ptr));
1460}
1461
1462DesignatedInitExpr::designators_iterator DesignatedInitExpr::designators_end() {
1463 return designators_begin() + NumDesignators;
1464}
1465
1466Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) {
1467 assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
1468 char* Ptr = static_cast<char*>(static_cast<void *>(this));
1469 Ptr += sizeof(DesignatedInitExpr);
1470 Ptr += sizeof(Designator) * NumDesignators;
1471 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1472 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
1473}
1474
1475Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) {
1476 assert(D.Kind == Designator::ArrayRangeDesignator &&
1477 "Requires array range designator");
1478 char* Ptr = static_cast<char*>(static_cast<void *>(this));
1479 Ptr += sizeof(DesignatedInitExpr);
1480 Ptr += sizeof(Designator) * NumDesignators;
1481 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1482 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
1483}
1484
1485Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) {
1486 assert(D.Kind == Designator::ArrayRangeDesignator &&
1487 "Requires array range designator");
1488 char* Ptr = static_cast<char*>(static_cast<void *>(this));
1489 Ptr += sizeof(DesignatedInitExpr);
1490 Ptr += sizeof(Designator) * NumDesignators;
1491 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1492 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
1493}
1494
1495//===----------------------------------------------------------------------===//
Ted Kremenekce2fc3a2008-10-27 18:40:21 +00001496// ExprIterator.
1497//===----------------------------------------------------------------------===//
1498
1499Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
1500Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
1501Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
1502const Expr* ConstExprIterator::operator[](size_t idx) const {
1503 return cast<Expr>(I[idx]);
1504}
1505const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
1506const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
1507
1508//===----------------------------------------------------------------------===//
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001509// Child Iterators for iterating over subexpressions/substatements
1510//===----------------------------------------------------------------------===//
1511
1512// DeclRefExpr
Ted Kremenek9ac59282007-10-18 23:28:49 +00001513Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); }
1514Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001515
Steve Naroff7779db42007-11-12 14:29:37 +00001516// ObjCIvarRefExpr
Ted Kremenek55499762008-06-17 02:43:46 +00001517Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
1518Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
Steve Naroff7779db42007-11-12 14:29:37 +00001519
Steve Naroffe3e9add2008-06-02 23:03:37 +00001520// ObjCPropertyRefExpr
Ted Kremenek55499762008-06-17 02:43:46 +00001521Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; }
1522Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; }
Steve Naroffae784072008-05-30 00:40:33 +00001523
Fariborz Jahanian5daf5702008-11-22 18:39:36 +00001524// ObjCKVCRefExpr
1525Stmt::child_iterator ObjCKVCRefExpr::child_begin() { return &Base; }
1526Stmt::child_iterator ObjCKVCRefExpr::child_end() { return &Base+1; }
1527
Douglas Gregorcd9b46e2008-11-04 14:56:14 +00001528// ObjCSuperExpr
1529Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); }
1530Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); }
1531
Chris Lattnerd9f69102008-08-10 01:53:14 +00001532// PredefinedExpr
1533Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); }
1534Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); }
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001535
1536// IntegerLiteral
Ted Kremenek9ac59282007-10-18 23:28:49 +00001537Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); }
1538Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); }
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001539
1540// CharacterLiteral
Ted Kremenek9ac59282007-10-18 23:28:49 +00001541Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator(); }
1542Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); }
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001543
1544// FloatingLiteral
Ted Kremenek9ac59282007-10-18 23:28:49 +00001545Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); }
1546Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001547
Chris Lattner5d661452007-08-26 03:42:43 +00001548// ImaginaryLiteral
Ted Kremenek55499762008-06-17 02:43:46 +00001549Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
1550Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
Chris Lattner5d661452007-08-26 03:42:43 +00001551
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001552// StringLiteral
Ted Kremenek9ac59282007-10-18 23:28:49 +00001553Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
1554Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001555
1556// ParenExpr
Ted Kremenek55499762008-06-17 02:43:46 +00001557Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
1558Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001559
1560// UnaryOperator
Ted Kremenek55499762008-06-17 02:43:46 +00001561Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
1562Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001563
Sebastian Redl05189992008-11-11 17:56:53 +00001564// SizeOfAlignOfExpr
1565Stmt::child_iterator SizeOfAlignOfExpr::child_begin() {
1566 // If this is of a type and the type is a VLA type (and not a typedef), the
1567 // size expression of the VLA needs to be treated as an executable expression.
1568 // Why isn't this weirdness documented better in StmtIterator?
1569 if (isArgumentType()) {
1570 if (VariableArrayType* T = dyn_cast<VariableArrayType>(
1571 getArgumentType().getTypePtr()))
1572 return child_iterator(T);
1573 return child_iterator();
1574 }
Sebastian Redld4575892008-12-03 23:17:54 +00001575 return child_iterator(&Argument.Ex);
Ted Kremenek9ac59282007-10-18 23:28:49 +00001576}
Sebastian Redl05189992008-11-11 17:56:53 +00001577Stmt::child_iterator SizeOfAlignOfExpr::child_end() {
1578 if (isArgumentType())
1579 return child_iterator();
Sebastian Redld4575892008-12-03 23:17:54 +00001580 return child_iterator(&Argument.Ex + 1);
Ted Kremenek9ac59282007-10-18 23:28:49 +00001581}
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001582
1583// ArraySubscriptExpr
Ted Kremenek1237c672007-08-24 20:06:47 +00001584Stmt::child_iterator ArraySubscriptExpr::child_begin() {
Ted Kremenek55499762008-06-17 02:43:46 +00001585 return &SubExprs[0];
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001586}
Ted Kremenek1237c672007-08-24 20:06:47 +00001587Stmt::child_iterator ArraySubscriptExpr::child_end() {
Ted Kremenek55499762008-06-17 02:43:46 +00001588 return &SubExprs[0]+END_EXPR;
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001589}
1590
1591// CallExpr
Ted Kremenek1237c672007-08-24 20:06:47 +00001592Stmt::child_iterator CallExpr::child_begin() {
Ted Kremenek55499762008-06-17 02:43:46 +00001593 return &SubExprs[0];
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001594}
Ted Kremenek1237c672007-08-24 20:06:47 +00001595Stmt::child_iterator CallExpr::child_end() {
Ted Kremenek55499762008-06-17 02:43:46 +00001596 return &SubExprs[0]+NumArgs+ARGS_START;
Ted Kremenek77ed8e42007-08-24 18:13:47 +00001597}
Ted Kremenek1237c672007-08-24 20:06:47 +00001598
1599// MemberExpr
Ted Kremenek55499762008-06-17 02:43:46 +00001600Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
1601Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
Ted Kremenek1237c672007-08-24 20:06:47 +00001602
Nate Begeman213541a2008-04-18 23:10:10 +00001603// ExtVectorElementExpr
Ted Kremenek55499762008-06-17 02:43:46 +00001604Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
1605Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
Ted Kremenek1237c672007-08-24 20:06:47 +00001606
1607// CompoundLiteralExpr
Ted Kremenek55499762008-06-17 02:43:46 +00001608Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
1609Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
Ted Kremenek1237c672007-08-24 20:06:47 +00001610
Ted Kremenek1237c672007-08-24 20:06:47 +00001611// CastExpr
Ted Kremenek55499762008-06-17 02:43:46 +00001612Stmt::child_iterator CastExpr::child_begin() { return &Op; }
1613Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
Ted Kremenek1237c672007-08-24 20:06:47 +00001614
1615// BinaryOperator
1616Stmt::child_iterator BinaryOperator::child_begin() {
Ted Kremenek55499762008-06-17 02:43:46 +00001617 return &SubExprs[0];
Ted Kremenek1237c672007-08-24 20:06:47 +00001618}
Ted Kremenek1237c672007-08-24 20:06:47 +00001619Stmt::child_iterator BinaryOperator::child_end() {
Ted Kremenek55499762008-06-17 02:43:46 +00001620 return &SubExprs[0]+END_EXPR;
Ted Kremenek1237c672007-08-24 20:06:47 +00001621}
1622
1623// ConditionalOperator
1624Stmt::child_iterator ConditionalOperator::child_begin() {
Ted Kremenek55499762008-06-17 02:43:46 +00001625 return &SubExprs[0];
Ted Kremenek1237c672007-08-24 20:06:47 +00001626}
Ted Kremenek1237c672007-08-24 20:06:47 +00001627Stmt::child_iterator ConditionalOperator::child_end() {
Ted Kremenek55499762008-06-17 02:43:46 +00001628 return &SubExprs[0]+END_EXPR;
Ted Kremenek1237c672007-08-24 20:06:47 +00001629}
1630
1631// AddrLabelExpr
Ted Kremenek9ac59282007-10-18 23:28:49 +00001632Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); }
1633Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
Ted Kremenek1237c672007-08-24 20:06:47 +00001634
Ted Kremenek1237c672007-08-24 20:06:47 +00001635// StmtExpr
Ted Kremenek55499762008-06-17 02:43:46 +00001636Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
1637Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
Ted Kremenek1237c672007-08-24 20:06:47 +00001638
1639// TypesCompatibleExpr
Ted Kremenek9ac59282007-10-18 23:28:49 +00001640Stmt::child_iterator TypesCompatibleExpr::child_begin() {
1641 return child_iterator();
1642}
1643
1644Stmt::child_iterator TypesCompatibleExpr::child_end() {
1645 return child_iterator();
1646}
Ted Kremenek1237c672007-08-24 20:06:47 +00001647
1648// ChooseExpr
Ted Kremenek55499762008-06-17 02:43:46 +00001649Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
1650Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
Ted Kremenek1237c672007-08-24 20:06:47 +00001651
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001652// GNUNullExpr
1653Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); }
1654Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); }
1655
Nate Begemane2ce1d92008-01-17 17:46:27 +00001656// OverloadExpr
Ted Kremenek55499762008-06-17 02:43:46 +00001657Stmt::child_iterator OverloadExpr::child_begin() { return &SubExprs[0]; }
1658Stmt::child_iterator OverloadExpr::child_end() { return &SubExprs[0]+NumExprs; }
Nate Begemane2ce1d92008-01-17 17:46:27 +00001659
Eli Friedmand38617c2008-05-14 19:38:39 +00001660// ShuffleVectorExpr
1661Stmt::child_iterator ShuffleVectorExpr::child_begin() {
Ted Kremenek55499762008-06-17 02:43:46 +00001662 return &SubExprs[0];
Eli Friedmand38617c2008-05-14 19:38:39 +00001663}
1664Stmt::child_iterator ShuffleVectorExpr::child_end() {
Ted Kremenek55499762008-06-17 02:43:46 +00001665 return &SubExprs[0]+NumExprs;
Eli Friedmand38617c2008-05-14 19:38:39 +00001666}
1667
Anders Carlsson7c50aca2007-10-15 20:28:48 +00001668// VAArgExpr
Ted Kremenek55499762008-06-17 02:43:46 +00001669Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
1670Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
Anders Carlsson7c50aca2007-10-15 20:28:48 +00001671
Anders Carlsson66b5a8a2007-08-31 04:56:16 +00001672// InitListExpr
1673Stmt::child_iterator InitListExpr::child_begin() {
Ted Kremenek55499762008-06-17 02:43:46 +00001674 return InitExprs.size() ? &InitExprs[0] : 0;
Anders Carlsson66b5a8a2007-08-31 04:56:16 +00001675}
1676Stmt::child_iterator InitListExpr::child_end() {
Ted Kremenek55499762008-06-17 02:43:46 +00001677 return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
Anders Carlsson66b5a8a2007-08-31 04:56:16 +00001678}
1679
Douglas Gregor05c13a32009-01-22 00:58:24 +00001680/// DesignatedInitExpr
1681Stmt::child_iterator DesignatedInitExpr::child_begin() {
1682 char* Ptr = static_cast<char*>(static_cast<void *>(this));
1683 Ptr += sizeof(DesignatedInitExpr);
1684 Ptr += sizeof(Designator) * NumDesignators;
1685 return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1686}
1687Stmt::child_iterator DesignatedInitExpr::child_end() {
1688 return child_iterator(&*child_begin() + NumSubExprs);
1689}
1690
Ted Kremenek1237c672007-08-24 20:06:47 +00001691// ObjCStringLiteral
Ted Kremenek9ac59282007-10-18 23:28:49 +00001692Stmt::child_iterator ObjCStringLiteral::child_begin() {
1693 return child_iterator();
1694}
1695Stmt::child_iterator ObjCStringLiteral::child_end() {
1696 return child_iterator();
1697}
Ted Kremenek1237c672007-08-24 20:06:47 +00001698
1699// ObjCEncodeExpr
Ted Kremenek9ac59282007-10-18 23:28:49 +00001700Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); }
1701Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); }
Ted Kremenek1237c672007-08-24 20:06:47 +00001702
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00001703// ObjCSelectorExpr
Ted Kremenek9ac59282007-10-18 23:28:49 +00001704Stmt::child_iterator ObjCSelectorExpr::child_begin() {
1705 return child_iterator();
1706}
1707Stmt::child_iterator ObjCSelectorExpr::child_end() {
1708 return child_iterator();
1709}
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00001710
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00001711// ObjCProtocolExpr
Ted Kremenek9ac59282007-10-18 23:28:49 +00001712Stmt::child_iterator ObjCProtocolExpr::child_begin() {
1713 return child_iterator();
1714}
1715Stmt::child_iterator ObjCProtocolExpr::child_end() {
1716 return child_iterator();
1717}
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00001718
Steve Naroff563477d2007-09-18 23:55:05 +00001719// ObjCMessageExpr
Ted Kremenekea958e572008-05-01 17:26:20 +00001720Stmt::child_iterator ObjCMessageExpr::child_begin() {
Ted Kremenek55499762008-06-17 02:43:46 +00001721 return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START;
Steve Naroff563477d2007-09-18 23:55:05 +00001722}
1723Stmt::child_iterator ObjCMessageExpr::child_end() {
Ted Kremenek55499762008-06-17 02:43:46 +00001724 return &SubExprs[0]+ARGS_START+getNumArgs();
Steve Naroff563477d2007-09-18 23:55:05 +00001725}
1726
Steve Naroff4eb206b2008-09-03 18:15:37 +00001727// Blocks
Steve Naroff56ee6892008-10-08 17:01:13 +00001728Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); }
1729Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); }
Steve Naroff4eb206b2008-09-03 18:15:37 +00001730
Ted Kremenek9da13f92008-09-26 23:24:14 +00001731Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();}
1732Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); }