blob: 58dadb0801961b07451dc26fe09b4ad3f8e66f14 [file] [log] [blame]
Chris Lattner4b009652007-07-25 00:24:17 +00001//===--- Expr.cpp - Expression AST Node Implementation --------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner959e5be2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner4b009652007-07-25 00:24:17 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Expr class and subclasses.
11//
12//===----------------------------------------------------------------------===//
13
Steve Naroff9ed3e772008-05-29 21:12:08 +000014#include "clang/AST/ExprObjC.h"
Chris Lattner4b009652007-07-25 00:24:17 +000015#include "clang/AST/ASTContext.h"
16#include "clang/AST/StmtVisitor.h"
Chris Lattner2fd1c652007-10-07 08:58:51 +000017#include "clang/Basic/IdentifierTable.h"
Chris Lattnerd9ffbc92007-11-27 18:22:04 +000018#include "clang/Basic/TargetInfo.h"
Chris Lattner4b009652007-07-25 00:24:17 +000019using namespace clang;
20
21//===----------------------------------------------------------------------===//
22// Primary Expressions.
23//===----------------------------------------------------------------------===//
24
Chris Lattnere0391b22008-06-07 22:13:43 +000025/// getValueAsApproximateDouble - This returns the value as an inaccurate
26/// double. Note that this may cause loss of precision, but is useful for
27/// debugging dumps, etc.
28double FloatingLiteral::getValueAsApproximateDouble() const {
29 llvm::APFloat V = getValue();
30 V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven);
31 return V.convertToDouble();
32}
33
34
Chris Lattner4b009652007-07-25 00:24:17 +000035StringLiteral::StringLiteral(const char *strData, unsigned byteLength,
36 bool Wide, QualType t, SourceLocation firstLoc,
37 SourceLocation lastLoc) :
38 Expr(StringLiteralClass, t) {
39 // OPTIMIZE: could allocate this appended to the StringLiteral.
40 char *AStrData = new char[byteLength];
41 memcpy(AStrData, strData, byteLength);
42 StrData = AStrData;
43 ByteLength = byteLength;
44 IsWide = Wide;
45 firstTokLoc = firstLoc;
46 lastTokLoc = lastLoc;
47}
48
49StringLiteral::~StringLiteral() {
50 delete[] StrData;
51}
52
53bool UnaryOperator::isPostfix(Opcode Op) {
54 switch (Op) {
55 case PostInc:
56 case PostDec:
57 return true;
58 default:
59 return false;
60 }
61}
62
63/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
64/// corresponds to, e.g. "sizeof" or "[pre]++".
65const char *UnaryOperator::getOpcodeStr(Opcode Op) {
66 switch (Op) {
67 default: assert(0 && "Unknown unary operator");
68 case PostInc: return "++";
69 case PostDec: return "--";
70 case PreInc: return "++";
71 case PreDec: return "--";
72 case AddrOf: return "&";
73 case Deref: return "*";
74 case Plus: return "+";
75 case Minus: return "-";
76 case Not: return "~";
77 case LNot: return "!";
78 case Real: return "__real";
79 case Imag: return "__imag";
80 case SizeOf: return "sizeof";
81 case AlignOf: return "alignof";
82 case Extension: return "__extension__";
Chris Lattner0d9bcea2007-08-30 17:45:32 +000083 case OffsetOf: return "__builtin_offsetof";
Chris Lattner4b009652007-07-25 00:24:17 +000084 }
85}
86
87//===----------------------------------------------------------------------===//
88// Postfix Operators.
89//===----------------------------------------------------------------------===//
90
Nate Begeman9f3bfb72008-01-17 17:46:27 +000091
Chris Lattner4b009652007-07-25 00:24:17 +000092CallExpr::CallExpr(Expr *fn, Expr **args, unsigned numargs, QualType t,
93 SourceLocation rparenloc)
Ted Kremeneke4acb9c2007-08-24 18:13:47 +000094 : Expr(CallExprClass, t), NumArgs(numargs) {
Ted Kremenek2719e982008-06-17 02:43:46 +000095 SubExprs = new Stmt*[numargs+1];
Ted Kremeneke4acb9c2007-08-24 18:13:47 +000096 SubExprs[FN] = fn;
Chris Lattner4b009652007-07-25 00:24:17 +000097 for (unsigned i = 0; i != numargs; ++i)
Ted Kremeneke4acb9c2007-08-24 18:13:47 +000098 SubExprs[i+ARGS_START] = args[i];
Chris Lattner4b009652007-07-25 00:24:17 +000099 RParenLoc = rparenloc;
100}
101
Chris Lattnerc257c0d2007-12-28 05:25:02 +0000102/// setNumArgs - This changes the number of arguments present in this call.
103/// Any orphaned expressions are deleted by this, and any new operands are set
104/// to null.
105void CallExpr::setNumArgs(unsigned NumArgs) {
106 // No change, just return.
107 if (NumArgs == getNumArgs()) return;
108
109 // If shrinking # arguments, just delete the extras and forgot them.
110 if (NumArgs < getNumArgs()) {
111 for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i)
112 delete getArg(i);
113 this->NumArgs = NumArgs;
114 return;
115 }
116
117 // Otherwise, we are growing the # arguments. New an bigger argument array.
Ted Kremenek2719e982008-06-17 02:43:46 +0000118 Stmt **NewSubExprs = new Stmt*[NumArgs+1];
Chris Lattnerc257c0d2007-12-28 05:25:02 +0000119 // Copy over args.
120 for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i)
121 NewSubExprs[i] = SubExprs[i];
122 // Null out new args.
123 for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i)
124 NewSubExprs[i] = 0;
125
126 delete[] SubExprs;
127 SubExprs = NewSubExprs;
128 this->NumArgs = NumArgs;
129}
130
Steve Naroff44aec4c2008-01-31 01:07:12 +0000131bool CallExpr::isBuiltinConstantExpr() const {
132 // All simple function calls (e.g. func()) are implicitly cast to pointer to
133 // function. As a result, we try and obtain the DeclRefExpr from the
134 // ImplicitCastExpr.
135 const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
136 if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
137 return false;
138
139 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
140 if (!DRE)
141 return false;
142
Anders Carlsson2ed959f2008-01-31 02:13:57 +0000143 const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
144 if (!FDecl)
145 return false;
146
147 unsigned builtinID = FDecl->getIdentifier()->getBuiltinID();
148 if (!builtinID)
149 return false;
150
151 // We have a builtin that is a constant expression
Eli Friedman8845a812008-05-16 13:28:37 +0000152 return builtinID == Builtin::BI__builtin___CFStringMakeConstantString ||
153 builtinID == Builtin::BI__builtin_classify_type;
Steve Naroff44aec4c2008-01-31 01:07:12 +0000154}
Chris Lattnerc257c0d2007-12-28 05:25:02 +0000155
Steve Naroff8d3b1702007-08-08 22:15:55 +0000156bool CallExpr::isBuiltinClassifyType(llvm::APSInt &Result) const {
157 // The following enum mimics gcc's internal "typeclass.h" file.
158 enum gcc_type_class {
159 no_type_class = -1,
160 void_type_class, integer_type_class, char_type_class,
161 enumeral_type_class, boolean_type_class,
162 pointer_type_class, reference_type_class, offset_type_class,
163 real_type_class, complex_type_class,
164 function_type_class, method_type_class,
165 record_type_class, union_type_class,
166 array_type_class, string_type_class,
167 lang_type_class
168 };
169 Result.setIsSigned(true);
170
171 // All simple function calls (e.g. func()) are implicitly cast to pointer to
172 // function. As a result, we try and obtain the DeclRefExpr from the
173 // ImplicitCastExpr.
174 const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
175 if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
176 return false;
177 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
178 if (!DRE)
179 return false;
180
181 // We have a DeclRefExpr.
182 if (strcmp(DRE->getDecl()->getName(), "__builtin_classify_type") == 0) {
183 // If no argument was supplied, default to "no_type_class". This isn't
184 // ideal, however it's what gcc does.
185 Result = static_cast<uint64_t>(no_type_class);
186 if (NumArgs >= 1) {
187 QualType argType = getArg(0)->getType();
188
189 if (argType->isVoidType())
190 Result = void_type_class;
191 else if (argType->isEnumeralType())
192 Result = enumeral_type_class;
193 else if (argType->isBooleanType())
194 Result = boolean_type_class;
195 else if (argType->isCharType())
196 Result = string_type_class; // gcc doesn't appear to use char_type_class
197 else if (argType->isIntegerType())
198 Result = integer_type_class;
199 else if (argType->isPointerType())
200 Result = pointer_type_class;
201 else if (argType->isReferenceType())
202 Result = reference_type_class;
203 else if (argType->isRealType())
204 Result = real_type_class;
205 else if (argType->isComplexType())
206 Result = complex_type_class;
207 else if (argType->isFunctionType())
208 Result = function_type_class;
209 else if (argType->isStructureType())
210 Result = record_type_class;
211 else if (argType->isUnionType())
212 Result = union_type_class;
213 else if (argType->isArrayType())
214 Result = array_type_class;
215 else if (argType->isUnionType())
216 Result = union_type_class;
217 else // FIXME: offset_type_class, method_type_class, & lang_type_class?
Chris Lattner19b8f1a2007-11-08 17:56:40 +0000218 assert(0 && "CallExpr::isBuiltinClassifyType(): unimplemented type");
Steve Naroff8d3b1702007-08-08 22:15:55 +0000219 }
220 return true;
221 }
222 return false;
223}
224
Chris Lattner4b009652007-07-25 00:24:17 +0000225/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
226/// corresponds to, e.g. "<<=".
227const char *BinaryOperator::getOpcodeStr(Opcode Op) {
228 switch (Op) {
229 default: assert(0 && "Unknown binary operator");
230 case Mul: return "*";
231 case Div: return "/";
232 case Rem: return "%";
233 case Add: return "+";
234 case Sub: return "-";
235 case Shl: return "<<";
236 case Shr: return ">>";
237 case LT: return "<";
238 case GT: return ">";
239 case LE: return "<=";
240 case GE: return ">=";
241 case EQ: return "==";
242 case NE: return "!=";
243 case And: return "&";
244 case Xor: return "^";
245 case Or: return "|";
246 case LAnd: return "&&";
247 case LOr: return "||";
248 case Assign: return "=";
249 case MulAssign: return "*=";
250 case DivAssign: return "/=";
251 case RemAssign: return "%=";
252 case AddAssign: return "+=";
253 case SubAssign: return "-=";
254 case ShlAssign: return "<<=";
255 case ShrAssign: return ">>=";
256 case AndAssign: return "&=";
257 case XorAssign: return "^=";
258 case OrAssign: return "|=";
259 case Comma: return ",";
260 }
261}
262
Anders Carlsson762b7c72007-08-31 04:56:16 +0000263InitListExpr::InitListExpr(SourceLocation lbraceloc,
264 Expr **initexprs, unsigned numinits,
265 SourceLocation rbraceloc)
Steve Naroff2e335472008-05-01 02:04:18 +0000266 : Expr(InitListExprClass, QualType()),
267 LBraceLoc(lbraceloc), RBraceLoc(rbraceloc)
Anders Carlsson762b7c72007-08-31 04:56:16 +0000268{
Anders Carlsson762b7c72007-08-31 04:56:16 +0000269 for (unsigned i = 0; i != numinits; i++)
Steve Naroff2e335472008-05-01 02:04:18 +0000270 InitExprs.push_back(initexprs[i]);
Anders Carlsson762b7c72007-08-31 04:56:16 +0000271}
Chris Lattner4b009652007-07-25 00:24:17 +0000272
273//===----------------------------------------------------------------------===//
274// Generic Expression Routines
275//===----------------------------------------------------------------------===//
276
277/// hasLocalSideEffect - Return true if this immediate expression has side
278/// effects, not counting any sub-expressions.
279bool Expr::hasLocalSideEffect() const {
280 switch (getStmtClass()) {
281 default:
282 return false;
283 case ParenExprClass:
284 return cast<ParenExpr>(this)->getSubExpr()->hasLocalSideEffect();
285 case UnaryOperatorClass: {
286 const UnaryOperator *UO = cast<UnaryOperator>(this);
287
288 switch (UO->getOpcode()) {
289 default: return false;
290 case UnaryOperator::PostInc:
291 case UnaryOperator::PostDec:
292 case UnaryOperator::PreInc:
293 case UnaryOperator::PreDec:
294 return true; // ++/--
295
296 case UnaryOperator::Deref:
297 // Dereferencing a volatile pointer is a side-effect.
298 return getType().isVolatileQualified();
299 case UnaryOperator::Real:
300 case UnaryOperator::Imag:
301 // accessing a piece of a volatile complex is a side-effect.
302 return UO->getSubExpr()->getType().isVolatileQualified();
303
304 case UnaryOperator::Extension:
305 return UO->getSubExpr()->hasLocalSideEffect();
306 }
307 }
Chris Lattneref95ffd2007-12-01 06:07:34 +0000308 case BinaryOperatorClass: {
309 const BinaryOperator *BinOp = cast<BinaryOperator>(this);
310 // Consider comma to have side effects if the LHS and RHS both do.
311 if (BinOp->getOpcode() == BinaryOperator::Comma)
312 return BinOp->getLHS()->hasLocalSideEffect() &&
313 BinOp->getRHS()->hasLocalSideEffect();
314
315 return BinOp->isAssignmentOp();
316 }
Chris Lattner06078d22007-08-25 02:00:02 +0000317 case CompoundAssignOperatorClass:
Chris Lattner9c0da3b2007-08-25 01:55:00 +0000318 return true;
Chris Lattner4b009652007-07-25 00:24:17 +0000319
Fariborz Jahanian363c59b2007-12-01 19:58:28 +0000320 case ConditionalOperatorClass: {
321 const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
322 return Exp->getCond()->hasLocalSideEffect()
323 || (Exp->getLHS() && Exp->getLHS()->hasLocalSideEffect())
324 || (Exp->getRHS() && Exp->getRHS()->hasLocalSideEffect());
325 }
326
Chris Lattner4b009652007-07-25 00:24:17 +0000327 case MemberExprClass:
328 case ArraySubscriptExprClass:
329 // If the base pointer or element is to a volatile pointer/field, accessing
330 // if is a side effect.
331 return getType().isVolatileQualified();
Eli Friedman21fd0292008-05-27 15:24:04 +0000332
Chris Lattner4b009652007-07-25 00:24:17 +0000333 case CallExprClass:
334 // TODO: check attributes for pure/const. "void foo() { strlen("bar"); }"
335 // should warn.
336 return true;
Chris Lattner99f5f0b2007-09-26 22:06:30 +0000337 case ObjCMessageExprClass:
338 return true;
Eli Friedman21fd0292008-05-27 15:24:04 +0000339 case StmtExprClass:
340 // TODO: check the inside of the statement expression
341 return true;
342
Chris Lattner4b009652007-07-25 00:24:17 +0000343 case CastExprClass:
344 // 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 Lattner3e254fb2008-04-08 04:40:51 +0000349
Eli Friedmanb924c7f2008-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 Lattner3e254fb2008-04-08 04:40:51 +0000354 case CXXDefaultArgExprClass:
355 return cast<CXXDefaultArgExpr>(this)->getExpr()->hasLocalSideEffect();
Chris Lattner4b009652007-07-25 00:24:17 +0000356 }
357}
358
359/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an
360/// incomplete type other than void. Nonarray expressions that can be lvalues:
361/// - name, where name must be a variable
362/// - e[i]
363/// - (e), where e must be an lvalue
364/// - e.name, where e must be an lvalue
365/// - e->name
366/// - *e, the type of e cannot be a function type
367/// - string-constant
Chris Lattner5bf72022007-10-30 22:53:42 +0000368/// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension]
Chris Lattner4b009652007-07-25 00:24:17 +0000369/// - reference type [C++ [expr]]
370///
371Expr::isLvalueResult Expr::isLvalue() const {
372 // first, check the type (C99 6.3.2.1)
373 if (TR->isFunctionType()) // from isObjectType()
374 return LV_NotObjectType;
375
Steve Naroffec7736d2008-02-10 01:39:04 +0000376 // Allow qualified void which is an incomplete type other than void (yuck).
Chris Lattner35fef522008-02-20 20:55:12 +0000377 if (TR->isVoidType() && !TR.getCanonicalType().getCVRQualifiers())
Steve Naroffec7736d2008-02-10 01:39:04 +0000378 return LV_IncompleteVoidType;
379
Chris Lattner4b009652007-07-25 00:24:17 +0000380 if (TR->isReferenceType()) // C++ [expr]
381 return LV_Valid;
382
383 // the type looks fine, now check the expression
384 switch (getStmtClass()) {
385 case StringLiteralClass: // C99 6.5.1p4
Anders Carlsson9e933a22007-11-30 22:47:59 +0000386 return LV_Valid;
Chris Lattner4b009652007-07-25 00:24:17 +0000387 case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2))))
388 // For vectors, make sure base is an lvalue (i.e. not a function call).
389 if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType())
390 return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue();
391 return LV_Valid;
Chris Lattner8c7c6a12008-06-17 18:05:57 +0000392 case DeclRefExprClass: { // C99 6.5.1p2
393 const Decl *RefdDecl = cast<DeclRefExpr>(this)->getDecl();
394 if (isa<VarDecl>(RefdDecl) || isa<ImplicitParamDecl>(RefdDecl))
Chris Lattner4b009652007-07-25 00:24:17 +0000395 return LV_Valid;
396 break;
Chris Lattner8c7c6a12008-06-17 18:05:57 +0000397 }
Chris Lattner4b009652007-07-25 00:24:17 +0000398 case MemberExprClass: { // C99 6.5.2.3p4
399 const MemberExpr *m = cast<MemberExpr>(this);
400 return m->isArrow() ? LV_Valid : m->getBase()->isLvalue();
401 }
Chris Lattner5bf72022007-10-30 22:53:42 +0000402 case UnaryOperatorClass:
Chris Lattner4b009652007-07-25 00:24:17 +0000403 if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref)
Chris Lattner5bf72022007-10-30 22:53:42 +0000404 return LV_Valid; // C99 6.5.3p4
405
406 if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real ||
407 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag)
408 return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(); // GNU.
Chris Lattner4b009652007-07-25 00:24:17 +0000409 break;
410 case ParenExprClass: // C99 6.5.1p5
411 return cast<ParenExpr>(this)->getSubExpr()->isLvalue();
Steve Naroffc7c66532007-12-05 04:00:10 +0000412 case CompoundLiteralExprClass: // C99 6.5.2.5p5
413 return LV_Valid;
Nate Begemanaf6ed502008-04-18 23:10:10 +0000414 case ExtVectorElementExprClass:
415 if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements())
Steve Naroffba67f692007-07-30 03:29:09 +0000416 return LV_DuplicateVectorComponents;
417 return LV_Valid;
Steve Naroff46f18f22007-11-12 14:34:27 +0000418 case ObjCIvarRefExprClass: // ObjC instance variables are lvalues.
419 return LV_Valid;
Steve Naroff8fff8ce2008-05-30 23:23:16 +0000420 case ObjCPropertyRefExprClass: // FIXME: check if read-only property.
421 return LV_Valid;
Chris Lattner7e637512008-01-12 08:14:25 +0000422 case PreDefinedExprClass:
Argiris Kirtzidis38f16712008-07-01 10:37:29 +0000423 return (cast<PreDefinedExpr>(this)->getIdentType() == PreDefinedExpr::CXXThis
424 ? LV_InvalidExpression
425 : LV_Valid);
Chris Lattner3e254fb2008-04-08 04:40:51 +0000426 case CXXDefaultArgExprClass:
427 return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue();
Chris Lattner4b009652007-07-25 00:24:17 +0000428 default:
429 break;
430 }
431 return LV_InvalidExpression;
432}
433
434/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type,
435/// does not have an incomplete type, does not have a const-qualified type, and
436/// if it is a structure or union, does not have any member (including,
437/// recursively, any member or element of all contained aggregates or unions)
438/// with a const-qualified type.
439Expr::isModifiableLvalueResult Expr::isModifiableLvalue() const {
440 isLvalueResult lvalResult = isLvalue();
441
442 switch (lvalResult) {
443 case LV_Valid: break;
444 case LV_NotObjectType: return MLV_NotObjectType;
445 case LV_IncompleteVoidType: return MLV_IncompleteVoidType;
Steve Naroffba67f692007-07-30 03:29:09 +0000446 case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents;
Chris Lattner4b009652007-07-25 00:24:17 +0000447 case LV_InvalidExpression: return MLV_InvalidExpression;
448 }
449 if (TR.isConstQualified())
450 return MLV_ConstQualified;
451 if (TR->isArrayType())
452 return MLV_ArrayType;
453 if (TR->isIncompleteType())
454 return MLV_IncompleteType;
455
456 if (const RecordType *r = dyn_cast<RecordType>(TR.getCanonicalType())) {
457 if (r->hasConstFields())
458 return MLV_ConstQualified;
459 }
460 return MLV_Valid;
461}
462
Ted Kremenek5778d622008-02-27 18:39:48 +0000463/// hasGlobalStorage - Return true if this expression has static storage
Chris Lattner743ec372007-11-27 21:35:27 +0000464/// duration. This means that the address of this expression is a link-time
465/// constant.
Ted Kremenek5778d622008-02-27 18:39:48 +0000466bool Expr::hasGlobalStorage() const {
Chris Lattnerba3ddb22007-11-13 18:05:45 +0000467 switch (getStmtClass()) {
468 default:
469 return false;
Chris Lattner743ec372007-11-27 21:35:27 +0000470 case ParenExprClass:
Ted Kremenek5778d622008-02-27 18:39:48 +0000471 return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage();
Chris Lattner743ec372007-11-27 21:35:27 +0000472 case ImplicitCastExprClass:
Ted Kremenek5778d622008-02-27 18:39:48 +0000473 return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage();
Steve Naroffbe37fc02008-01-14 18:19:28 +0000474 case CompoundLiteralExprClass:
475 return cast<CompoundLiteralExpr>(this)->isFileScope();
Chris Lattnerba3ddb22007-11-13 18:05:45 +0000476 case DeclRefExprClass: {
477 const Decl *D = cast<DeclRefExpr>(this)->getDecl();
478 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
Ted Kremenek5778d622008-02-27 18:39:48 +0000479 return VD->hasGlobalStorage();
Seo Sanghyeone330ae72008-04-04 09:45:30 +0000480 if (isa<FunctionDecl>(D))
481 return true;
Chris Lattnerba3ddb22007-11-13 18:05:45 +0000482 return false;
483 }
Chris Lattnerdb586bf2007-11-28 04:30:09 +0000484 case MemberExprClass: {
Chris Lattnerba3ddb22007-11-13 18:05:45 +0000485 const MemberExpr *M = cast<MemberExpr>(this);
Ted Kremenek5778d622008-02-27 18:39:48 +0000486 return !M->isArrow() && M->getBase()->hasGlobalStorage();
Chris Lattnerdb586bf2007-11-28 04:30:09 +0000487 }
Chris Lattner743ec372007-11-27 21:35:27 +0000488 case ArraySubscriptExprClass:
Ted Kremenek5778d622008-02-27 18:39:48 +0000489 return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage();
Chris Lattner7e637512008-01-12 08:14:25 +0000490 case PreDefinedExprClass:
491 return true;
Chris Lattner3e254fb2008-04-08 04:40:51 +0000492 case CXXDefaultArgExprClass:
493 return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage();
Chris Lattnerba3ddb22007-11-13 18:05:45 +0000494 }
495}
496
Ted Kremenek87e30c52008-01-17 16:57:34 +0000497Expr* Expr::IgnoreParens() {
498 Expr* E = this;
499 while (ParenExpr* P = dyn_cast<ParenExpr>(E))
500 E = P->getSubExpr();
501
502 return E;
503}
504
Chris Lattner7a48d9c2008-02-13 01:02:39 +0000505/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr
506/// or CastExprs or ImplicitCastExprs, returning their operand.
507Expr *Expr::IgnoreParenCasts() {
508 Expr *E = this;
509 while (true) {
510 if (ParenExpr *P = dyn_cast<ParenExpr>(E))
511 E = P->getSubExpr();
512 else if (CastExpr *P = dyn_cast<CastExpr>(E))
513 E = P->getSubExpr();
514 else if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E))
515 E = P->getSubExpr();
516 else
517 return E;
518 }
519}
520
521
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000522bool Expr::isConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const {
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000523 switch (getStmtClass()) {
524 default:
525 if (Loc) *Loc = getLocStart();
526 return false;
527 case ParenExprClass:
528 return cast<ParenExpr>(this)->getSubExpr()->isConstantExpr(Ctx, Loc);
529 case StringLiteralClass:
Steve Naroff4fdea132007-11-09 15:00:03 +0000530 case ObjCStringLiteralClass:
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000531 case FloatingLiteralClass:
532 case IntegerLiteralClass:
533 case CharacterLiteralClass:
534 case ImaginaryLiteralClass:
Anders Carlsson855d78d2007-10-17 00:52:43 +0000535 case TypesCompatibleExprClass:
536 case CXXBoolLiteralExprClass:
Chris Lattner06db6132007-10-18 00:20:32 +0000537 return true;
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000538 case CallExprClass: {
539 const CallExpr *CE = cast<CallExpr>(this);
Steve Naroff44aec4c2008-01-31 01:07:12 +0000540 if (CE->isBuiltinConstantExpr())
541 return true;
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000542 if (Loc) *Loc = getLocStart();
543 return false;
544 }
Chris Lattner42e86b62007-11-01 02:45:17 +0000545 case DeclRefExprClass: {
546 const Decl *D = cast<DeclRefExpr>(this)->getDecl();
547 // Accept address of function.
548 if (isa<EnumConstantDecl>(D) || isa<FunctionDecl>(D))
Chris Lattner06db6132007-10-18 00:20:32 +0000549 return true;
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000550 if (Loc) *Loc = getLocStart();
Chris Lattnerba3ddb22007-11-13 18:05:45 +0000551 if (isa<VarDecl>(D))
552 return TR->isArrayType();
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000553 return false;
Chris Lattner42e86b62007-11-01 02:45:17 +0000554 }
Steve Narofff91f9722008-01-09 00:05:37 +0000555 case CompoundLiteralExprClass:
556 if (Loc) *Loc = getLocStart();
557 // Allow "(int []){2,4}", since the array will be converted to a pointer.
Nate Begemanc4e28e42008-01-25 05:34:48 +0000558 // Allow "(vector type){2,4}" since the elements are all constant.
559 return TR->isArrayType() || TR->isVectorType();
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000560 case UnaryOperatorClass: {
561 const UnaryOperator *Exp = cast<UnaryOperator>(this);
562
Chris Lattnerba3ddb22007-11-13 18:05:45 +0000563 // C99 6.6p9
Chris Lattner35b662f2007-12-11 23:11:17 +0000564 if (Exp->getOpcode() == UnaryOperator::AddrOf) {
Ted Kremenek5778d622008-02-27 18:39:48 +0000565 if (!Exp->getSubExpr()->hasGlobalStorage()) {
Chris Lattner35b662f2007-12-11 23:11:17 +0000566 if (Loc) *Loc = getLocStart();
567 return false;
568 }
569 return true;
570 }
Chris Lattnerba3ddb22007-11-13 18:05:45 +0000571
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000572 // Get the operand value. If this is sizeof/alignof, do not evalute the
573 // operand. This affects C99 6.6p3.
Steve Narofff0b23542008-01-10 22:15:12 +0000574 if (!Exp->isSizeOfAlignOfOp() &&
575 Exp->getOpcode() != UnaryOperator::OffsetOf &&
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000576 !Exp->getSubExpr()->isConstantExpr(Ctx, Loc))
577 return false;
578
579 switch (Exp->getOpcode()) {
580 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
581 // See C99 6.6p3.
582 default:
583 if (Loc) *Loc = Exp->getOperatorLoc();
584 return false;
585 case UnaryOperator::Extension:
586 return true; // FIXME: this is wrong.
587 case UnaryOperator::SizeOf:
588 case UnaryOperator::AlignOf:
Steve Narofff0b23542008-01-10 22:15:12 +0000589 case UnaryOperator::OffsetOf:
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000590 // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
Eli Friedman62f67fd2008-02-15 12:20:59 +0000591 if (!Exp->getSubExpr()->getType()->isConstantSizeType()) {
Chris Lattnerb3ff0822007-12-18 07:15:40 +0000592 if (Loc) *Loc = Exp->getOperatorLoc();
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000593 return false;
Chris Lattnerb3ff0822007-12-18 07:15:40 +0000594 }
Chris Lattner06db6132007-10-18 00:20:32 +0000595 return true;
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000596 case UnaryOperator::LNot:
597 case UnaryOperator::Plus:
598 case UnaryOperator::Minus:
599 case UnaryOperator::Not:
Chris Lattner06db6132007-10-18 00:20:32 +0000600 return true;
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000601 }
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000602 }
603 case SizeOfAlignOfTypeExprClass: {
604 const SizeOfAlignOfTypeExpr *Exp = cast<SizeOfAlignOfTypeExpr>(this);
605 // alignof always evaluates to a constant.
Chris Lattner20515462008-02-21 05:45:29 +0000606 if (Exp->isSizeOf() && !Exp->getArgumentType()->isVoidType() &&
607 !Exp->getArgumentType()->isConstantSizeType()) {
Chris Lattnerb3ff0822007-12-18 07:15:40 +0000608 if (Loc) *Loc = Exp->getOperatorLoc();
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000609 return false;
Chris Lattnerb3ff0822007-12-18 07:15:40 +0000610 }
Chris Lattner06db6132007-10-18 00:20:32 +0000611 return true;
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000612 }
613 case BinaryOperatorClass: {
614 const BinaryOperator *Exp = cast<BinaryOperator>(this);
615
616 // The LHS of a constant expr is always evaluated and needed.
617 if (!Exp->getLHS()->isConstantExpr(Ctx, Loc))
618 return false;
619
620 if (!Exp->getRHS()->isConstantExpr(Ctx, Loc))
621 return false;
Chris Lattner06db6132007-10-18 00:20:32 +0000622 return true;
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000623 }
624 case ImplicitCastExprClass:
625 case CastExprClass: {
626 const Expr *SubExpr;
627 SourceLocation CastLoc;
628 if (const CastExpr *C = dyn_cast<CastExpr>(this)) {
629 SubExpr = C->getSubExpr();
630 CastLoc = C->getLParenLoc();
631 } else {
632 SubExpr = cast<ImplicitCastExpr>(this)->getSubExpr();
633 CastLoc = getLocStart();
634 }
635 if (!SubExpr->isConstantExpr(Ctx, Loc)) {
636 if (Loc) *Loc = SubExpr->getLocStart();
637 return false;
638 }
Chris Lattner06db6132007-10-18 00:20:32 +0000639 return true;
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000640 }
641 case ConditionalOperatorClass: {
642 const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
Chris Lattner06db6132007-10-18 00:20:32 +0000643 if (!Exp->getCond()->isConstantExpr(Ctx, Loc) ||
Anders Carlsson37365fc2007-11-30 19:04:31 +0000644 // Handle the GNU extension for missing LHS.
645 !(Exp->getLHS() && Exp->getLHS()->isConstantExpr(Ctx, Loc)) ||
Chris Lattner06db6132007-10-18 00:20:32 +0000646 !Exp->getRHS()->isConstantExpr(Ctx, Loc))
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000647 return false;
Chris Lattner06db6132007-10-18 00:20:32 +0000648 return true;
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000649 }
Steve Narofff0b23542008-01-10 22:15:12 +0000650 case InitListExprClass: {
651 const InitListExpr *Exp = cast<InitListExpr>(this);
652 unsigned numInits = Exp->getNumInits();
653 for (unsigned i = 0; i < numInits; i++) {
654 if (!Exp->getInit(i)->isConstantExpr(Ctx, Loc)) {
655 if (Loc) *Loc = Exp->getInit(i)->getLocStart();
656 return false;
657 }
658 }
659 return true;
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000660 }
Chris Lattner3e254fb2008-04-08 04:40:51 +0000661 case CXXDefaultArgExprClass:
662 return cast<CXXDefaultArgExpr>(this)->getExpr()->isConstantExpr(Ctx, Loc);
Steve Narofff0b23542008-01-10 22:15:12 +0000663 }
Steve Naroff7c9d72d2007-09-02 20:30:18 +0000664}
665
Chris Lattner4b009652007-07-25 00:24:17 +0000666/// isIntegerConstantExpr - this recursive routine will test if an expression is
667/// an integer constant expression. Note: With the introduction of VLA's in
668/// C99 the result of the sizeof operator is no longer always a constant
669/// expression. The generalization of the wording to include any subexpression
670/// that is not evaluated (C99 6.6p3) means that nonconstant subexpressions
671/// can appear as operands to other operators (e.g. &&, ||, ?:). For instance,
672/// "0 || f()" can be treated as a constant expression. In C90 this expression,
673/// occurring in a context requiring a constant, would have been a constraint
674/// violation. FIXME: This routine currently implements C90 semantics.
675/// To properly implement C99 semantics this routine will need to evaluate
676/// expressions involving operators previously mentioned.
677
678/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero,
679/// comma, etc
680///
681/// FIXME: This should ext-warn on overflow during evaluation! ISO C does not
Chris Lattner9d020b32007-09-26 00:47:26 +0000682/// permit this. This includes things like (int)1e1000
Chris Lattner4b009652007-07-25 00:24:17 +0000683///
684/// FIXME: Handle offsetof. Two things to do: Handle GCC's __builtin_offsetof
685/// to support gcc 4.0+ and handle the idiom GCC recognizes with a null pointer
686/// cast+dereference.
687bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
688 SourceLocation *Loc, bool isEvaluated) const {
689 switch (getStmtClass()) {
690 default:
691 if (Loc) *Loc = getLocStart();
692 return false;
693 case ParenExprClass:
694 return cast<ParenExpr>(this)->getSubExpr()->
695 isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated);
696 case IntegerLiteralClass:
697 Result = cast<IntegerLiteral>(this)->getValue();
698 break;
699 case CharacterLiteralClass: {
700 const CharacterLiteral *CL = cast<CharacterLiteral>(this);
Chris Lattner8cd0e932008-03-05 18:54:05 +0000701 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Chris Lattner4b009652007-07-25 00:24:17 +0000702 Result = CL->getValue();
703 Result.setIsUnsigned(!getType()->isSignedIntegerType());
704 break;
705 }
Steve Naroffc6f0fd32007-08-02 04:09:23 +0000706 case TypesCompatibleExprClass: {
707 const TypesCompatibleExpr *TCE = cast<TypesCompatibleExpr>(this);
Chris Lattner8cd0e932008-03-05 18:54:05 +0000708 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Steve Naroff85f0dc52007-10-15 20:41:53 +0000709 Result = Ctx.typesAreCompatible(TCE->getArgType1(), TCE->getArgType2());
Steve Naroff1200b5a2007-08-02 00:13:27 +0000710 break;
Steve Naroffc6f0fd32007-08-02 04:09:23 +0000711 }
Steve Naroff8d3b1702007-08-08 22:15:55 +0000712 case CallExprClass: {
713 const CallExpr *CE = cast<CallExpr>(this);
Chris Lattner8cd0e932008-03-05 18:54:05 +0000714 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Steve Naroff8d3b1702007-08-08 22:15:55 +0000715 if (CE->isBuiltinClassifyType(Result))
716 break;
717 if (Loc) *Loc = getLocStart();
718 return false;
719 }
Chris Lattner4b009652007-07-25 00:24:17 +0000720 case DeclRefExprClass:
721 if (const EnumConstantDecl *D =
722 dyn_cast<EnumConstantDecl>(cast<DeclRefExpr>(this)->getDecl())) {
723 Result = D->getInitVal();
724 break;
725 }
726 if (Loc) *Loc = getLocStart();
727 return false;
728 case UnaryOperatorClass: {
729 const UnaryOperator *Exp = cast<UnaryOperator>(this);
730
731 // Get the operand value. If this is sizeof/alignof, do not evalute the
732 // operand. This affects C99 6.6p3.
Anders Carlsson52774ad2008-01-29 15:56:48 +0000733 if (!Exp->isSizeOfAlignOfOp() && !Exp->isOffsetOfOp() &&
Chris Lattner5a9b6242007-08-23 21:42:50 +0000734 !Exp->getSubExpr()->isIntegerConstantExpr(Result, Ctx, Loc,isEvaluated))
Chris Lattner4b009652007-07-25 00:24:17 +0000735 return false;
736
737 switch (Exp->getOpcode()) {
738 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
739 // See C99 6.6p3.
740 default:
741 if (Loc) *Loc = Exp->getOperatorLoc();
742 return false;
743 case UnaryOperator::Extension:
744 return true; // FIXME: this is wrong.
745 case UnaryOperator::SizeOf:
746 case UnaryOperator::AlignOf:
Chris Lattner20515462008-02-21 05:45:29 +0000747 // Return the result in the right width.
Chris Lattner8cd0e932008-03-05 18:54:05 +0000748 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Chris Lattner20515462008-02-21 05:45:29 +0000749
750 // sizeof(void) and __alignof__(void) = 1 as a gcc extension.
751 if (Exp->getSubExpr()->getType()->isVoidType()) {
752 Result = 1;
753 break;
754 }
755
Chris Lattner4b009652007-07-25 00:24:17 +0000756 // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
Eli Friedman62f67fd2008-02-15 12:20:59 +0000757 if (!Exp->getSubExpr()->getType()->isConstantSizeType()) {
Chris Lattnerb3ff0822007-12-18 07:15:40 +0000758 if (Loc) *Loc = Exp->getOperatorLoc();
Chris Lattner4b009652007-07-25 00:24:17 +0000759 return false;
Chris Lattnerb3ff0822007-12-18 07:15:40 +0000760 }
Chris Lattner4b009652007-07-25 00:24:17 +0000761
Chris Lattner4b009652007-07-25 00:24:17 +0000762 // Get information about the size or align.
Chris Lattnerd4dc2672008-01-02 21:54:09 +0000763 if (Exp->getSubExpr()->getType()->isFunctionType()) {
764 // GCC extension: sizeof(function) = 1.
765 Result = Exp->getOpcode() == UnaryOperator::AlignOf ? 4 : 1;
Chris Lattnerd9ffbc92007-11-27 18:22:04 +0000766 } else {
Chris Lattner8cd0e932008-03-05 18:54:05 +0000767 unsigned CharSize = Ctx.Target.getCharWidth();
Anders Carlsson1f86b032008-02-18 07:10:45 +0000768 if (Exp->getOpcode() == UnaryOperator::AlignOf)
Chris Lattner8cd0e932008-03-05 18:54:05 +0000769 Result = Ctx.getTypeAlign(Exp->getSubExpr()->getType()) / CharSize;
Anders Carlsson1f86b032008-02-18 07:10:45 +0000770 else
Chris Lattner8cd0e932008-03-05 18:54:05 +0000771 Result = Ctx.getTypeSize(Exp->getSubExpr()->getType()) / CharSize;
Chris Lattnerd9ffbc92007-11-27 18:22:04 +0000772 }
Chris Lattner4b009652007-07-25 00:24:17 +0000773 break;
774 case UnaryOperator::LNot: {
Chris Lattnerf00fdc02008-01-25 19:16:19 +0000775 bool Val = Result == 0;
Chris Lattner8cd0e932008-03-05 18:54:05 +0000776 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Chris Lattner4b009652007-07-25 00:24:17 +0000777 Result = Val;
778 break;
779 }
780 case UnaryOperator::Plus:
781 break;
782 case UnaryOperator::Minus:
783 Result = -Result;
784 break;
785 case UnaryOperator::Not:
786 Result = ~Result;
787 break;
Anders Carlsson52774ad2008-01-29 15:56:48 +0000788 case UnaryOperator::OffsetOf:
789 Result = Exp->evaluateOffsetOf(Ctx);
Chris Lattner4b009652007-07-25 00:24:17 +0000790 }
791 break;
792 }
793 case SizeOfAlignOfTypeExprClass: {
794 const SizeOfAlignOfTypeExpr *Exp = cast<SizeOfAlignOfTypeExpr>(this);
Chris Lattner20515462008-02-21 05:45:29 +0000795
796 // Return the result in the right width.
Chris Lattner8cd0e932008-03-05 18:54:05 +0000797 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Chris Lattner20515462008-02-21 05:45:29 +0000798
799 // sizeof(void) and __alignof__(void) = 1 as a gcc extension.
800 if (Exp->getArgumentType()->isVoidType()) {
801 Result = 1;
802 break;
803 }
804
805 // alignof always evaluates to a constant, sizeof does if arg is not VLA.
Eli Friedman62f67fd2008-02-15 12:20:59 +0000806 if (Exp->isSizeOf() && !Exp->getArgumentType()->isConstantSizeType()) {
Chris Lattnerb3ff0822007-12-18 07:15:40 +0000807 if (Loc) *Loc = Exp->getOperatorLoc();
Chris Lattner4b009652007-07-25 00:24:17 +0000808 return false;
Chris Lattnerb3ff0822007-12-18 07:15:40 +0000809 }
Chris Lattner4b009652007-07-25 00:24:17 +0000810
Chris Lattner4b009652007-07-25 00:24:17 +0000811 // Get information about the size or align.
Chris Lattnerd4dc2672008-01-02 21:54:09 +0000812 if (Exp->getArgumentType()->isFunctionType()) {
813 // GCC extension: sizeof(function) = 1.
814 Result = Exp->isSizeOf() ? 1 : 4;
Anders Carlsson8d2b2b72008-02-16 01:20:23 +0000815 } else {
Chris Lattner8cd0e932008-03-05 18:54:05 +0000816 unsigned CharSize = Ctx.Target.getCharWidth();
Anders Carlsson8d2b2b72008-02-16 01:20:23 +0000817 if (Exp->isSizeOf())
Chris Lattner8cd0e932008-03-05 18:54:05 +0000818 Result = Ctx.getTypeSize(Exp->getArgumentType()) / CharSize;
Anders Carlsson8d2b2b72008-02-16 01:20:23 +0000819 else
Chris Lattner8cd0e932008-03-05 18:54:05 +0000820 Result = Ctx.getTypeAlign(Exp->getArgumentType()) / CharSize;
Ted Kremeneka9d0fd92007-12-17 17:38:43 +0000821 }
Chris Lattner4b009652007-07-25 00:24:17 +0000822 break;
823 }
824 case BinaryOperatorClass: {
825 const BinaryOperator *Exp = cast<BinaryOperator>(this);
826
827 // The LHS of a constant expr is always evaluated and needed.
828 if (!Exp->getLHS()->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
829 return false;
830
831 llvm::APSInt RHS(Result);
832
833 // The short-circuiting &&/|| operators don't necessarily evaluate their
834 // RHS. Make sure to pass isEvaluated down correctly.
835 if (Exp->isLogicalOp()) {
836 bool RHSEval;
837 if (Exp->getOpcode() == BinaryOperator::LAnd)
838 RHSEval = Result != 0;
839 else {
840 assert(Exp->getOpcode() == BinaryOperator::LOr &&"Unexpected logical");
841 RHSEval = Result == 0;
842 }
843
844 if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc,
845 isEvaluated & RHSEval))
846 return false;
847 } else {
848 if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc, isEvaluated))
849 return false;
850 }
851
852 switch (Exp->getOpcode()) {
853 default:
854 if (Loc) *Loc = getLocStart();
855 return false;
856 case BinaryOperator::Mul:
857 Result *= RHS;
858 break;
859 case BinaryOperator::Div:
860 if (RHS == 0) {
861 if (!isEvaluated) break;
862 if (Loc) *Loc = getLocStart();
863 return false;
864 }
865 Result /= RHS;
866 break;
867 case BinaryOperator::Rem:
868 if (RHS == 0) {
869 if (!isEvaluated) break;
870 if (Loc) *Loc = getLocStart();
871 return false;
872 }
873 Result %= RHS;
874 break;
875 case BinaryOperator::Add: Result += RHS; break;
876 case BinaryOperator::Sub: Result -= RHS; break;
877 case BinaryOperator::Shl:
Chris Lattner3496d522007-09-04 02:45:27 +0000878 Result <<=
879 static_cast<uint32_t>(RHS.getLimitedValue(Result.getBitWidth()-1));
Chris Lattner4b009652007-07-25 00:24:17 +0000880 break;
881 case BinaryOperator::Shr:
Chris Lattner3496d522007-09-04 02:45:27 +0000882 Result >>=
883 static_cast<uint32_t>(RHS.getLimitedValue(Result.getBitWidth()-1));
Chris Lattner4b009652007-07-25 00:24:17 +0000884 break;
885 case BinaryOperator::LT: Result = Result < RHS; break;
886 case BinaryOperator::GT: Result = Result > RHS; break;
887 case BinaryOperator::LE: Result = Result <= RHS; break;
888 case BinaryOperator::GE: Result = Result >= RHS; break;
889 case BinaryOperator::EQ: Result = Result == RHS; break;
890 case BinaryOperator::NE: Result = Result != RHS; break;
891 case BinaryOperator::And: Result &= RHS; break;
892 case BinaryOperator::Xor: Result ^= RHS; break;
893 case BinaryOperator::Or: Result |= RHS; break;
894 case BinaryOperator::LAnd:
895 Result = Result != 0 && RHS != 0;
896 break;
897 case BinaryOperator::LOr:
898 Result = Result != 0 || RHS != 0;
899 break;
900
901 case BinaryOperator::Comma:
902 // C99 6.6p3: "shall not contain assignment, ..., or comma operators,
903 // *except* when they are contained within a subexpression that is not
904 // evaluated". Note that Assignment can never happen due to constraints
905 // on the LHS subexpr, so we don't need to check it here.
906 if (isEvaluated) {
907 if (Loc) *Loc = getLocStart();
908 return false;
909 }
910
911 // The result of the constant expr is the RHS.
912 Result = RHS;
913 return true;
914 }
915
916 assert(!Exp->isAssignmentOp() && "LHS can't be a constant expr!");
917 break;
918 }
919 case ImplicitCastExprClass:
920 case CastExprClass: {
921 const Expr *SubExpr;
922 SourceLocation CastLoc;
923 if (const CastExpr *C = dyn_cast<CastExpr>(this)) {
924 SubExpr = C->getSubExpr();
925 CastLoc = C->getLParenLoc();
926 } else {
927 SubExpr = cast<ImplicitCastExpr>(this)->getSubExpr();
928 CastLoc = getLocStart();
929 }
930
931 // C99 6.6p6: shall only convert arithmetic types to integer types.
932 if (!SubExpr->getType()->isArithmeticType() ||
933 !getType()->isIntegerType()) {
934 if (Loc) *Loc = SubExpr->getLocStart();
Steve Naroff6e7c3b72008-06-03 22:06:04 +0000935 // GCC accepts pointers as an extension.
936 // FIXME: check getLangOptions().NoExtensions. At the moment, it doesn't
937 // appear possible to get langOptions() from the Expr.
938 if (SubExpr->getType()->isPointerType()) // && !NoExtensions
939 return true;
Chris Lattner4b009652007-07-25 00:24:17 +0000940 return false;
941 }
Chris Lattner76a0c1b2007-09-22 19:04:13 +0000942
Chris Lattner8cd0e932008-03-05 18:54:05 +0000943 uint32_t DestWidth = static_cast<uint32_t>(Ctx.getTypeSize(getType()));
Chris Lattner76a0c1b2007-09-22 19:04:13 +0000944
Chris Lattner4b009652007-07-25 00:24:17 +0000945 // Handle simple integer->integer casts.
946 if (SubExpr->getType()->isIntegerType()) {
947 if (!SubExpr->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
948 return false;
949
950 // Figure out if this is a truncate, extend or noop cast.
Chris Lattner4b009652007-07-25 00:24:17 +0000951 // If the input is signed, do a sign extend, noop, or truncate.
Chris Lattner000c4102008-01-09 18:59:34 +0000952 if (getType()->isBooleanType()) {
953 // Conversion to bool compares against zero.
954 Result = Result != 0;
955 Result.zextOrTrunc(DestWidth);
956 } else if (SubExpr->getType()->isSignedIntegerType())
Chris Lattner4b009652007-07-25 00:24:17 +0000957 Result.sextOrTrunc(DestWidth);
958 else // If the input is unsigned, do a zero extend, noop, or truncate.
959 Result.zextOrTrunc(DestWidth);
960 break;
961 }
962
963 // Allow floating constants that are the immediate operands of casts or that
964 // are parenthesized.
965 const Expr *Operand = SubExpr;
966 while (const ParenExpr *PE = dyn_cast<ParenExpr>(Operand))
967 Operand = PE->getSubExpr();
Chris Lattner76a0c1b2007-09-22 19:04:13 +0000968
969 // If this isn't a floating literal, we can't handle it.
970 const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(Operand);
971 if (!FL) {
972 if (Loc) *Loc = Operand->getLocStart();
973 return false;
Chris Lattner4b009652007-07-25 00:24:17 +0000974 }
Chris Lattner000c4102008-01-09 18:59:34 +0000975
976 // If the destination is boolean, compare against zero.
977 if (getType()->isBooleanType()) {
978 Result = !FL->getValue().isZero();
979 Result.zextOrTrunc(DestWidth);
980 break;
981 }
Chris Lattner76a0c1b2007-09-22 19:04:13 +0000982
983 // Determine whether we are converting to unsigned or signed.
984 bool DestSigned = getType()->isSignedIntegerType();
Chris Lattner9d020b32007-09-26 00:47:26 +0000985
986 // TODO: Warn on overflow, but probably not here: isIntegerConstantExpr can
987 // be called multiple times per AST.
Chris Lattner76a0c1b2007-09-22 19:04:13 +0000988 uint64_t Space[4];
Chris Lattner9d020b32007-09-26 00:47:26 +0000989 (void)FL->getValue().convertToInteger(Space, DestWidth, DestSigned,
990 llvm::APFloat::rmTowardZero);
Chris Lattner76a0c1b2007-09-22 19:04:13 +0000991 Result = llvm::APInt(DestWidth, 4, Space);
992 break;
Chris Lattner4b009652007-07-25 00:24:17 +0000993 }
994 case ConditionalOperatorClass: {
995 const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
996
997 if (!Exp->getCond()->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
998 return false;
999
1000 const Expr *TrueExp = Exp->getLHS();
1001 const Expr *FalseExp = Exp->getRHS();
1002 if (Result == 0) std::swap(TrueExp, FalseExp);
1003
1004 // Evaluate the false one first, discard the result.
Anders Carlsson37365fc2007-11-30 19:04:31 +00001005 if (FalseExp && !FalseExp->isIntegerConstantExpr(Result, Ctx, Loc, false))
Chris Lattner4b009652007-07-25 00:24:17 +00001006 return false;
1007 // Evalute the true one, capture the result.
Anders Carlsson37365fc2007-11-30 19:04:31 +00001008 if (TrueExp &&
1009 !TrueExp->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
Chris Lattner4b009652007-07-25 00:24:17 +00001010 return false;
1011 break;
1012 }
Chris Lattner3e254fb2008-04-08 04:40:51 +00001013 case CXXDefaultArgExprClass:
1014 return cast<CXXDefaultArgExpr>(this)
1015 ->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated);
Chris Lattner4b009652007-07-25 00:24:17 +00001016 }
1017
1018 // Cases that are valid constant exprs fall through to here.
1019 Result.setIsUnsigned(getType()->isUnsignedIntegerType());
1020 return true;
1021}
1022
Chris Lattner4b009652007-07-25 00:24:17 +00001023/// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an
1024/// integer constant expression with the value zero, or if this is one that is
1025/// cast to void*.
1026bool Expr::isNullPointerConstant(ASTContext &Ctx) const {
Steve Naroffa2e53222008-01-14 16:10:57 +00001027 // Strip off a cast to void*, if it exists.
1028 if (const CastExpr *CE = dyn_cast<CastExpr>(this)) {
1029 // Check that it is a cast to void*.
Eli Friedmand899dbe2008-02-13 17:29:58 +00001030 if (const PointerType *PT = CE->getType()->getAsPointerType()) {
Chris Lattner4b009652007-07-25 00:24:17 +00001031 QualType Pointee = PT->getPointeeType();
Chris Lattner35fef522008-02-20 20:55:12 +00001032 if (Pointee.getCVRQualifiers() == 0 &&
1033 Pointee->isVoidType() && // to void*
Steve Naroffa2e53222008-01-14 16:10:57 +00001034 CE->getSubExpr()->getType()->isIntegerType()) // from int.
1035 return CE->getSubExpr()->isNullPointerConstant(Ctx);
Chris Lattner4b009652007-07-25 00:24:17 +00001036 }
Steve Naroffa2e53222008-01-14 16:10:57 +00001037 } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
1038 // Ignore the ImplicitCastExpr type entirely.
1039 return ICE->getSubExpr()->isNullPointerConstant(Ctx);
1040 } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
1041 // Accept ((void*)0) as a null pointer constant, as many other
1042 // implementations do.
1043 return PE->getSubExpr()->isNullPointerConstant(Ctx);
Chris Lattner97316c02008-04-10 02:22:51 +00001044 } else if (const CXXDefaultArgExpr *DefaultArg
1045 = dyn_cast<CXXDefaultArgExpr>(this)) {
Chris Lattner3e254fb2008-04-08 04:40:51 +00001046 // See through default argument expressions
1047 return DefaultArg->getExpr()->isNullPointerConstant(Ctx);
Steve Narofff33a9852008-01-14 02:53:34 +00001048 }
Steve Naroffa2e53222008-01-14 16:10:57 +00001049
1050 // This expression must be an integer type.
1051 if (!getType()->isIntegerType())
1052 return false;
1053
Chris Lattner4b009652007-07-25 00:24:17 +00001054 // If we have an integer constant expression, we need to *evaluate* it and
1055 // test for the value 0.
1056 llvm::APSInt Val(32);
Steve Naroffa2e53222008-01-14 16:10:57 +00001057 return isIntegerConstantExpr(Val, Ctx, 0, true) && Val == 0;
Chris Lattner4b009652007-07-25 00:24:17 +00001058}
Steve Naroffc11705f2007-07-28 23:10:27 +00001059
Nate Begemanaf6ed502008-04-18 23:10:10 +00001060unsigned ExtVectorElementExpr::getNumElements() const {
Nate Begemanc8e51f82008-05-09 06:41:27 +00001061 if (const VectorType *VT = getType()->getAsVectorType())
1062 return VT->getNumElements();
1063 return 1;
Chris Lattner50547852007-08-03 16:00:20 +00001064}
1065
Nate Begemanc8e51f82008-05-09 06:41:27 +00001066/// containsDuplicateElements - Return true if any element access is repeated.
Nate Begemanaf6ed502008-04-18 23:10:10 +00001067bool ExtVectorElementExpr::containsDuplicateElements() const {
Steve Naroffba67f692007-07-30 03:29:09 +00001068 const char *compStr = Accessor.getName();
1069 unsigned length = strlen(compStr);
1070
1071 for (unsigned i = 0; i < length-1; i++) {
1072 const char *s = compStr+i;
1073 for (const char c = *s++; *s; s++)
1074 if (c == *s)
1075 return true;
1076 }
1077 return false;
1078}
Chris Lattner42158e72007-08-02 23:36:59 +00001079
Nate Begemanc8e51f82008-05-09 06:41:27 +00001080/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
Nate Begemana1ae7442008-05-13 21:03:02 +00001081void ExtVectorElementExpr::getEncodedElementAccess(
1082 llvm::SmallVectorImpl<unsigned> &Elts) const {
Chris Lattner42158e72007-08-02 23:36:59 +00001083 const char *compStr = Accessor.getName();
Nate Begemanc8e51f82008-05-09 06:41:27 +00001084
1085 bool isHi = !strcmp(compStr, "hi");
1086 bool isLo = !strcmp(compStr, "lo");
1087 bool isEven = !strcmp(compStr, "e");
1088 bool isOdd = !strcmp(compStr, "o");
1089
1090 for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
1091 uint64_t Index;
1092
1093 if (isHi)
1094 Index = e + i;
1095 else if (isLo)
1096 Index = i;
1097 else if (isEven)
1098 Index = 2 * i;
1099 else if (isOdd)
1100 Index = 2 * i + 1;
1101 else
1102 Index = ExtVectorType::getAccessorIdx(compStr[i]);
Chris Lattner42158e72007-08-02 23:36:59 +00001103
Nate Begemana1ae7442008-05-13 21:03:02 +00001104 Elts.push_back(Index);
Chris Lattner42158e72007-08-02 23:36:59 +00001105 }
Nate Begemanc8e51f82008-05-09 06:41:27 +00001106}
1107
Steve Naroff4ed9d662007-09-27 14:38:14 +00001108// constructor for instance messages.
Steve Naroff6cb1d362007-09-28 22:22:11 +00001109ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo,
Ted Kremenek42730c52008-01-07 19:49:32 +00001110 QualType retType, ObjCMethodDecl *mproto,
Steve Naroff1e1c3912007-11-03 16:37:59 +00001111 SourceLocation LBrac, SourceLocation RBrac,
Steve Naroff9f176d12007-11-15 13:05:42 +00001112 Expr **ArgExprs, unsigned nargs)
Steve Naroff1e1c3912007-11-03 16:37:59 +00001113 : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
Ted Kremenekd029a6f2008-05-01 17:26:20 +00001114 MethodProto(mproto) {
Steve Naroff9f176d12007-11-15 13:05:42 +00001115 NumArgs = nargs;
Ted Kremenek2719e982008-06-17 02:43:46 +00001116 SubExprs = new Stmt*[NumArgs+1];
Steve Naroff4ed9d662007-09-27 14:38:14 +00001117 SubExprs[RECEIVER] = receiver;
Steve Naroff9f176d12007-11-15 13:05:42 +00001118 if (NumArgs) {
1119 for (unsigned i = 0; i != NumArgs; ++i)
Steve Naroff4ed9d662007-09-27 14:38:14 +00001120 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1121 }
Steve Naroffc39ca262007-09-18 23:55:05 +00001122 LBracloc = LBrac;
1123 RBracloc = RBrac;
1124}
1125
Steve Naroff4ed9d662007-09-27 14:38:14 +00001126// constructor for class messages.
1127// FIXME: clsName should be typed to ObjCInterfaceType
Steve Naroff6cb1d362007-09-28 22:22:11 +00001128ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo,
Ted Kremenek42730c52008-01-07 19:49:32 +00001129 QualType retType, ObjCMethodDecl *mproto,
Steve Naroff1e1c3912007-11-03 16:37:59 +00001130 SourceLocation LBrac, SourceLocation RBrac,
Steve Naroff9f176d12007-11-15 13:05:42 +00001131 Expr **ArgExprs, unsigned nargs)
Steve Naroff1e1c3912007-11-03 16:37:59 +00001132 : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
Ted Kremenekd029a6f2008-05-01 17:26:20 +00001133 MethodProto(mproto) {
Steve Naroff9f176d12007-11-15 13:05:42 +00001134 NumArgs = nargs;
Ted Kremenek2719e982008-06-17 02:43:46 +00001135 SubExprs = new Stmt*[NumArgs+1];
Ted Kremenekee2c9fd2008-06-24 15:50:53 +00001136 SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown);
Steve Naroff9f176d12007-11-15 13:05:42 +00001137 if (NumArgs) {
1138 for (unsigned i = 0; i != NumArgs; ++i)
Steve Naroff4ed9d662007-09-27 14:38:14 +00001139 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1140 }
Steve Naroffc39ca262007-09-18 23:55:05 +00001141 LBracloc = LBrac;
1142 RBracloc = RBrac;
1143}
1144
Ted Kremenekee2c9fd2008-06-24 15:50:53 +00001145// constructor for class messages.
1146ObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo,
1147 QualType retType, ObjCMethodDecl *mproto,
1148 SourceLocation LBrac, SourceLocation RBrac,
1149 Expr **ArgExprs, unsigned nargs)
1150: Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1151MethodProto(mproto) {
1152 NumArgs = nargs;
1153 SubExprs = new Stmt*[NumArgs+1];
1154 SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown);
1155 if (NumArgs) {
1156 for (unsigned i = 0; i != NumArgs; ++i)
1157 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1158 }
1159 LBracloc = LBrac;
1160 RBracloc = RBrac;
1161}
1162
1163ObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const {
1164 uintptr_t x = (uintptr_t) SubExprs[RECEIVER];
1165 switch (x & Flags) {
1166 default:
1167 assert(false && "Invalid ObjCMessageExpr.");
1168 case IsInstMeth:
1169 return ClassInfo(0, 0);
1170 case IsClsMethDeclUnknown:
1171 return ClassInfo(0, (IdentifierInfo*) (x & ~Flags));
1172 case IsClsMethDeclKnown: {
1173 ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags);
1174 return ClassInfo(D, D->getIdentifier());
1175 }
1176 }
1177}
1178
Chris Lattnerf624cd22007-10-25 00:29:32 +00001179bool ChooseExpr::isConditionTrue(ASTContext &C) const {
1180 llvm::APSInt CondVal(32);
1181 bool IsConst = getCond()->isIntegerConstantExpr(CondVal, C);
1182 assert(IsConst && "Condition of choose expr must be i-c-e"); IsConst=IsConst;
1183 return CondVal != 0;
1184}
1185
Anders Carlsson52774ad2008-01-29 15:56:48 +00001186static int64_t evaluateOffsetOf(ASTContext& C, const Expr *E)
1187{
1188 if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
1189 QualType Ty = ME->getBase()->getType();
1190
1191 RecordDecl *RD = Ty->getAsRecordType()->getDecl();
Chris Lattner8cd0e932008-03-05 18:54:05 +00001192 const ASTRecordLayout &RL = C.getASTRecordLayout(RD);
Anders Carlsson52774ad2008-01-29 15:56:48 +00001193 FieldDecl *FD = ME->getMemberDecl();
1194
1195 // FIXME: This is linear time.
1196 unsigned i = 0, e = 0;
1197 for (i = 0, e = RD->getNumMembers(); i != e; i++) {
1198 if (RD->getMember(i) == FD)
1199 break;
1200 }
1201
1202 return RL.getFieldOffset(i) + evaluateOffsetOf(C, ME->getBase());
1203 } else if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) {
1204 const Expr *Base = ASE->getBase();
1205 llvm::APSInt Idx(32);
1206 bool ICE = ASE->getIdx()->isIntegerConstantExpr(Idx, C);
1207 assert(ICE && "Array index is not a constant integer!");
1208
Chris Lattner8cd0e932008-03-05 18:54:05 +00001209 int64_t size = C.getTypeSize(ASE->getType());
Anders Carlsson52774ad2008-01-29 15:56:48 +00001210 size *= Idx.getSExtValue();
1211
1212 return size + evaluateOffsetOf(C, Base);
1213 } else if (isa<CompoundLiteralExpr>(E))
1214 return 0;
1215
1216 assert(0 && "Unknown offsetof subexpression!");
1217 return 0;
1218}
1219
1220int64_t UnaryOperator::evaluateOffsetOf(ASTContext& C) const
1221{
1222 assert(Opc == OffsetOf && "Unary operator not offsetof!");
1223
Chris Lattner8cd0e932008-03-05 18:54:05 +00001224 unsigned CharSize = C.Target.getCharWidth();
Ted Kremenek2719e982008-06-17 02:43:46 +00001225 return ::evaluateOffsetOf(C, cast<Expr>(Val)) / CharSize;
Anders Carlsson52774ad2008-01-29 15:56:48 +00001226}
1227
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001228//===----------------------------------------------------------------------===//
1229// Child Iterators for iterating over subexpressions/substatements
1230//===----------------------------------------------------------------------===//
1231
1232// DeclRefExpr
Ted Kremeneka6478552007-10-18 23:28:49 +00001233Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); }
1234Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001235
Steve Naroff5eb2a4a2007-11-12 14:29:37 +00001236// ObjCIvarRefExpr
Ted Kremenek2719e982008-06-17 02:43:46 +00001237Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
1238Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
Steve Naroff5eb2a4a2007-11-12 14:29:37 +00001239
Steve Naroff6f786252008-06-02 23:03:37 +00001240// ObjCPropertyRefExpr
Ted Kremenek2719e982008-06-17 02:43:46 +00001241Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; }
1242Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; }
Steve Naroff05391d22008-05-30 00:40:33 +00001243
Steve Naroff6f786252008-06-02 23:03:37 +00001244// ObjCSuperRefExpr
1245Stmt::child_iterator ObjCSuperRefExpr::child_begin() { return child_iterator();}
1246Stmt::child_iterator ObjCSuperRefExpr::child_end() { return child_iterator(); }
1247
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001248// PreDefinedExpr
Ted Kremeneka6478552007-10-18 23:28:49 +00001249Stmt::child_iterator PreDefinedExpr::child_begin() { return child_iterator(); }
1250Stmt::child_iterator PreDefinedExpr::child_end() { return child_iterator(); }
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001251
1252// IntegerLiteral
Ted Kremeneka6478552007-10-18 23:28:49 +00001253Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); }
1254Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); }
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001255
1256// CharacterLiteral
Ted Kremeneka6478552007-10-18 23:28:49 +00001257Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator(); }
1258Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); }
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001259
1260// FloatingLiteral
Ted Kremeneka6478552007-10-18 23:28:49 +00001261Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); }
1262Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001263
Chris Lattner1de66eb2007-08-26 03:42:43 +00001264// ImaginaryLiteral
Ted Kremenek2719e982008-06-17 02:43:46 +00001265Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
1266Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
Chris Lattner1de66eb2007-08-26 03:42:43 +00001267
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001268// StringLiteral
Ted Kremeneka6478552007-10-18 23:28:49 +00001269Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
1270Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001271
1272// ParenExpr
Ted Kremenek2719e982008-06-17 02:43:46 +00001273Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
1274Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001275
1276// UnaryOperator
Ted Kremenek2719e982008-06-17 02:43:46 +00001277Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
1278Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001279
1280// SizeOfAlignOfTypeExpr
Ted Kremeneka6478552007-10-18 23:28:49 +00001281Stmt::child_iterator SizeOfAlignOfTypeExpr::child_begin() {
Ted Kremenekb7cf0952007-12-14 22:52:23 +00001282 // If the type is a VLA type (and not a typedef), the size expression of the
1283 // VLA needs to be treated as an executable expression.
1284 if (VariableArrayType* T = dyn_cast<VariableArrayType>(Ty.getTypePtr()))
1285 return child_iterator(T);
1286 else
1287 return child_iterator();
Ted Kremeneka6478552007-10-18 23:28:49 +00001288}
1289Stmt::child_iterator SizeOfAlignOfTypeExpr::child_end() {
Ted Kremenekb7cf0952007-12-14 22:52:23 +00001290 return child_iterator();
Ted Kremeneka6478552007-10-18 23:28:49 +00001291}
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001292
1293// ArraySubscriptExpr
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001294Stmt::child_iterator ArraySubscriptExpr::child_begin() {
Ted Kremenek2719e982008-06-17 02:43:46 +00001295 return &SubExprs[0];
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001296}
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001297Stmt::child_iterator ArraySubscriptExpr::child_end() {
Ted Kremenek2719e982008-06-17 02:43:46 +00001298 return &SubExprs[0]+END_EXPR;
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001299}
1300
1301// CallExpr
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001302Stmt::child_iterator CallExpr::child_begin() {
Ted Kremenek2719e982008-06-17 02:43:46 +00001303 return &SubExprs[0];
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001304}
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001305Stmt::child_iterator CallExpr::child_end() {
Ted Kremenek2719e982008-06-17 02:43:46 +00001306 return &SubExprs[0]+NumArgs+ARGS_START;
Ted Kremeneke4acb9c2007-08-24 18:13:47 +00001307}
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001308
1309// MemberExpr
Ted Kremenek2719e982008-06-17 02:43:46 +00001310Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
1311Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001312
Nate Begemanaf6ed502008-04-18 23:10:10 +00001313// ExtVectorElementExpr
Ted Kremenek2719e982008-06-17 02:43:46 +00001314Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
1315Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001316
1317// CompoundLiteralExpr
Ted Kremenek2719e982008-06-17 02:43:46 +00001318Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
1319Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001320
1321// ImplicitCastExpr
Ted Kremenek2719e982008-06-17 02:43:46 +00001322Stmt::child_iterator ImplicitCastExpr::child_begin() { return &Op; }
1323Stmt::child_iterator ImplicitCastExpr::child_end() { return &Op+1; }
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001324
1325// CastExpr
Ted Kremenek2719e982008-06-17 02:43:46 +00001326Stmt::child_iterator CastExpr::child_begin() { return &Op; }
1327Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001328
1329// BinaryOperator
1330Stmt::child_iterator BinaryOperator::child_begin() {
Ted Kremenek2719e982008-06-17 02:43:46 +00001331 return &SubExprs[0];
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001332}
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001333Stmt::child_iterator BinaryOperator::child_end() {
Ted Kremenek2719e982008-06-17 02:43:46 +00001334 return &SubExprs[0]+END_EXPR;
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001335}
1336
1337// ConditionalOperator
1338Stmt::child_iterator ConditionalOperator::child_begin() {
Ted Kremenek2719e982008-06-17 02:43:46 +00001339 return &SubExprs[0];
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001340}
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001341Stmt::child_iterator ConditionalOperator::child_end() {
Ted Kremenek2719e982008-06-17 02:43:46 +00001342 return &SubExprs[0]+END_EXPR;
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001343}
1344
1345// AddrLabelExpr
Ted Kremeneka6478552007-10-18 23:28:49 +00001346Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); }
1347Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001348
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001349// StmtExpr
Ted Kremenek2719e982008-06-17 02:43:46 +00001350Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
1351Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001352
1353// TypesCompatibleExpr
Ted Kremeneka6478552007-10-18 23:28:49 +00001354Stmt::child_iterator TypesCompatibleExpr::child_begin() {
1355 return child_iterator();
1356}
1357
1358Stmt::child_iterator TypesCompatibleExpr::child_end() {
1359 return child_iterator();
1360}
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001361
1362// ChooseExpr
Ted Kremenek2719e982008-06-17 02:43:46 +00001363Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
1364Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001365
Nate Begeman9f3bfb72008-01-17 17:46:27 +00001366// OverloadExpr
Ted Kremenek2719e982008-06-17 02:43:46 +00001367Stmt::child_iterator OverloadExpr::child_begin() { return &SubExprs[0]; }
1368Stmt::child_iterator OverloadExpr::child_end() { return &SubExprs[0]+NumExprs; }
Nate Begeman9f3bfb72008-01-17 17:46:27 +00001369
Eli Friedmand0e9d092008-05-14 19:38:39 +00001370// ShuffleVectorExpr
1371Stmt::child_iterator ShuffleVectorExpr::child_begin() {
Ted Kremenek2719e982008-06-17 02:43:46 +00001372 return &SubExprs[0];
Eli Friedmand0e9d092008-05-14 19:38:39 +00001373}
1374Stmt::child_iterator ShuffleVectorExpr::child_end() {
Ted Kremenek2719e982008-06-17 02:43:46 +00001375 return &SubExprs[0]+NumExprs;
Eli Friedmand0e9d092008-05-14 19:38:39 +00001376}
1377
Anders Carlsson36760332007-10-15 20:28:48 +00001378// VAArgExpr
Ted Kremenek2719e982008-06-17 02:43:46 +00001379Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
1380Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
Anders Carlsson36760332007-10-15 20:28:48 +00001381
Anders Carlsson762b7c72007-08-31 04:56:16 +00001382// InitListExpr
1383Stmt::child_iterator InitListExpr::child_begin() {
Ted Kremenek2719e982008-06-17 02:43:46 +00001384 return InitExprs.size() ? &InitExprs[0] : 0;
Anders Carlsson762b7c72007-08-31 04:56:16 +00001385}
1386Stmt::child_iterator InitListExpr::child_end() {
Ted Kremenek2719e982008-06-17 02:43:46 +00001387 return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
Anders Carlsson762b7c72007-08-31 04:56:16 +00001388}
1389
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001390// ObjCStringLiteral
Ted Kremeneka6478552007-10-18 23:28:49 +00001391Stmt::child_iterator ObjCStringLiteral::child_begin() {
1392 return child_iterator();
1393}
1394Stmt::child_iterator ObjCStringLiteral::child_end() {
1395 return child_iterator();
1396}
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001397
1398// ObjCEncodeExpr
Ted Kremeneka6478552007-10-18 23:28:49 +00001399Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); }
1400Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); }
Ted Kremenek9fdc8a92007-08-24 20:06:47 +00001401
Fariborz Jahanianf807c202007-10-16 20:40:23 +00001402// ObjCSelectorExpr
Ted Kremeneka6478552007-10-18 23:28:49 +00001403Stmt::child_iterator ObjCSelectorExpr::child_begin() {
1404 return child_iterator();
1405}
1406Stmt::child_iterator ObjCSelectorExpr::child_end() {
1407 return child_iterator();
1408}
Fariborz Jahanianf807c202007-10-16 20:40:23 +00001409
Fariborz Jahanianb391e6e2007-10-17 16:58:11 +00001410// ObjCProtocolExpr
Ted Kremeneka6478552007-10-18 23:28:49 +00001411Stmt::child_iterator ObjCProtocolExpr::child_begin() {
1412 return child_iterator();
1413}
1414Stmt::child_iterator ObjCProtocolExpr::child_end() {
1415 return child_iterator();
1416}
Fariborz Jahanianb391e6e2007-10-17 16:58:11 +00001417
Steve Naroffc39ca262007-09-18 23:55:05 +00001418// ObjCMessageExpr
Ted Kremenekd029a6f2008-05-01 17:26:20 +00001419Stmt::child_iterator ObjCMessageExpr::child_begin() {
Ted Kremenek2719e982008-06-17 02:43:46 +00001420 return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START;
Steve Naroffc39ca262007-09-18 23:55:05 +00001421}
1422Stmt::child_iterator ObjCMessageExpr::child_end() {
Ted Kremenek2719e982008-06-17 02:43:46 +00001423 return &SubExprs[0]+ARGS_START+getNumArgs();
Steve Naroffc39ca262007-09-18 23:55:05 +00001424}
1425