1 //===--- Expr.cpp - Expression AST Node Implementation --------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Expr class and subclasses.
12 //===----------------------------------------------------------------------===//
14 #include "clang/AST/Expr.h"
15 #include "clang/AST/DeclObjC.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/RecordLayout.h"
18 #include "clang/AST/StmtVisitor.h"
19 #include "clang/Basic/TargetInfo.h"
20 using namespace clang
;
22 //===----------------------------------------------------------------------===//
23 // Primary Expressions.
24 //===----------------------------------------------------------------------===//
26 /// getValueAsApproximateDouble - This returns the value as an inaccurate
27 /// double. Note that this may cause loss of precision, but is useful for
28 /// debugging dumps, etc.
29 double FloatingLiteral::getValueAsApproximateDouble() const {
30 llvm::APFloat V
= getValue();
31 V
.convert(llvm::APFloat::IEEEdouble
, llvm::APFloat::rmNearestTiesToEven
);
32 return V
.convertToDouble();
36 StringLiteral::StringLiteral(const char *strData
, unsigned byteLength
,
37 bool Wide
, QualType t
, SourceLocation firstLoc
,
38 SourceLocation lastLoc
) :
39 Expr(StringLiteralClass
, t
) {
40 // OPTIMIZE: could allocate this appended to the StringLiteral.
41 char *AStrData
= new char[byteLength
];
42 memcpy(AStrData
, strData
, byteLength
);
44 ByteLength
= byteLength
;
46 firstTokLoc
= firstLoc
;
50 StringLiteral::~StringLiteral() {
54 bool UnaryOperator::isPostfix(Opcode Op
) {
64 bool UnaryOperator::isPrefix(Opcode Op
) {
74 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
75 /// corresponds to, e.g. "sizeof" or "[pre]++".
76 const char *UnaryOperator::getOpcodeStr(Opcode Op
) {
78 default: assert(0 && "Unknown unary operator");
79 case PostInc
: return "++";
80 case PostDec
: return "--";
81 case PreInc
: return "++";
82 case PreDec
: return "--";
83 case AddrOf
: return "&";
84 case Deref
: return "*";
85 case Plus
: return "+";
86 case Minus
: return "-";
88 case LNot
: return "!";
89 case Real
: return "__real";
90 case Imag
: return "__imag";
91 case SizeOf
: return "sizeof";
92 case AlignOf
: return "alignof";
93 case Extension
: return "__extension__";
94 case OffsetOf
: return "__builtin_offsetof";
98 //===----------------------------------------------------------------------===//
100 //===----------------------------------------------------------------------===//
103 CallExpr::CallExpr(Expr
*fn
, Expr
**args
, unsigned numargs
, QualType t
,
104 SourceLocation rparenloc
)
105 : Expr(CallExprClass
, t
), NumArgs(numargs
) {
106 SubExprs
= new Stmt
*[numargs
+1];
108 for (unsigned i
= 0; i
!= numargs
; ++i
)
109 SubExprs
[i
+ARGS_START
] = args
[i
];
110 RParenLoc
= rparenloc
;
113 /// setNumArgs - This changes the number of arguments present in this call.
114 /// Any orphaned expressions are deleted by this, and any new operands are set
116 void CallExpr::setNumArgs(unsigned NumArgs
) {
117 // No change, just return.
118 if (NumArgs
== getNumArgs()) return;
120 // If shrinking # arguments, just delete the extras and forgot them.
121 if (NumArgs
< getNumArgs()) {
122 for (unsigned i
= NumArgs
, e
= getNumArgs(); i
!= e
; ++i
)
124 this->NumArgs
= NumArgs
;
128 // Otherwise, we are growing the # arguments. New an bigger argument array.
129 Stmt
**NewSubExprs
= new Stmt
*[NumArgs
+1];
131 for (unsigned i
= 0; i
!= getNumArgs()+ARGS_START
; ++i
)
132 NewSubExprs
[i
] = SubExprs
[i
];
133 // Null out new args.
134 for (unsigned i
= getNumArgs()+ARGS_START
; i
!= NumArgs
+ARGS_START
; ++i
)
138 SubExprs
= NewSubExprs
;
139 this->NumArgs
= NumArgs
;
142 bool CallExpr::isBuiltinConstantExpr() const {
143 // All simple function calls (e.g. func()) are implicitly cast to pointer to
144 // function. As a result, we try and obtain the DeclRefExpr from the
146 const ImplicitCastExpr
*ICE
= dyn_cast
<ImplicitCastExpr
>(getCallee());
147 if (!ICE
) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
150 const DeclRefExpr
*DRE
= dyn_cast
<DeclRefExpr
>(ICE
->getSubExpr());
154 const FunctionDecl
*FDecl
= dyn_cast
<FunctionDecl
>(DRE
->getDecl());
158 unsigned builtinID
= FDecl
->getIdentifier()->getBuiltinID();
162 // We have a builtin that is a constant expression
163 return builtinID
== Builtin::BI__builtin___CFStringMakeConstantString
||
164 builtinID
== Builtin::BI__builtin_classify_type
;
167 bool CallExpr::isBuiltinClassifyType(llvm::APSInt
&Result
) const {
168 // The following enum mimics gcc's internal "typeclass.h" file.
169 enum gcc_type_class
{
171 void_type_class
, integer_type_class
, char_type_class
,
172 enumeral_type_class
, boolean_type_class
,
173 pointer_type_class
, reference_type_class
, offset_type_class
,
174 real_type_class
, complex_type_class
,
175 function_type_class
, method_type_class
,
176 record_type_class
, union_type_class
,
177 array_type_class
, string_type_class
,
180 Result
.setIsSigned(true);
182 // All simple function calls (e.g. func()) are implicitly cast to pointer to
183 // function. As a result, we try and obtain the DeclRefExpr from the
185 const ImplicitCastExpr
*ICE
= dyn_cast
<ImplicitCastExpr
>(getCallee());
186 if (!ICE
) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
188 const DeclRefExpr
*DRE
= dyn_cast
<DeclRefExpr
>(ICE
->getSubExpr());
192 // We have a DeclRefExpr.
193 if (strcmp(DRE
->getDecl()->getName(), "__builtin_classify_type") == 0) {
194 // If no argument was supplied, default to "no_type_class". This isn't
195 // ideal, however it's what gcc does.
196 Result
= static_cast<uint64_t>(no_type_class
);
198 QualType argType
= getArg(0)->getType();
200 if (argType
->isVoidType())
201 Result
= void_type_class
;
202 else if (argType
->isEnumeralType())
203 Result
= enumeral_type_class
;
204 else if (argType
->isBooleanType())
205 Result
= boolean_type_class
;
206 else if (argType
->isCharType())
207 Result
= string_type_class
; // gcc doesn't appear to use char_type_class
208 else if (argType
->isIntegerType())
209 Result
= integer_type_class
;
210 else if (argType
->isPointerType())
211 Result
= pointer_type_class
;
212 else if (argType
->isReferenceType())
213 Result
= reference_type_class
;
214 else if (argType
->isRealType())
215 Result
= real_type_class
;
216 else if (argType
->isComplexType())
217 Result
= complex_type_class
;
218 else if (argType
->isFunctionType())
219 Result
= function_type_class
;
220 else if (argType
->isStructureType())
221 Result
= record_type_class
;
222 else if (argType
->isUnionType())
223 Result
= union_type_class
;
224 else if (argType
->isArrayType())
225 Result
= array_type_class
;
226 else if (argType
->isUnionType())
227 Result
= union_type_class
;
228 else // FIXME: offset_type_class, method_type_class, & lang_type_class?
229 assert(0 && "CallExpr::isBuiltinClassifyType(): unimplemented type");
236 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
237 /// corresponds to, e.g. "<<=".
238 const char *BinaryOperator::getOpcodeStr(Opcode Op
) {
240 default: assert(0 && "Unknown binary operator");
241 case Mul
: return "*";
242 case Div
: return "/";
243 case Rem
: return "%";
244 case Add
: return "+";
245 case Sub
: return "-";
246 case Shl
: return "<<";
247 case Shr
: return ">>";
250 case LE
: return "<=";
251 case GE
: return ">=";
252 case EQ
: return "==";
253 case NE
: return "!=";
254 case And
: return "&";
255 case Xor
: return "^";
257 case LAnd
: return "&&";
258 case LOr
: return "||";
259 case Assign
: return "=";
260 case MulAssign
: return "*=";
261 case DivAssign
: return "/=";
262 case RemAssign
: return "%=";
263 case AddAssign
: return "+=";
264 case SubAssign
: return "-=";
265 case ShlAssign
: return "<<=";
266 case ShrAssign
: return ">>=";
267 case AndAssign
: return "&=";
268 case XorAssign
: return "^=";
269 case OrAssign
: return "|=";
270 case Comma
: return ",";
274 InitListExpr::InitListExpr(SourceLocation lbraceloc
,
275 Expr
**initexprs
, unsigned numinits
,
276 SourceLocation rbraceloc
)
277 : Expr(InitListExprClass
, QualType()),
278 LBraceLoc(lbraceloc
), RBraceLoc(rbraceloc
)
280 for (unsigned i
= 0; i
!= numinits
; i
++)
281 InitExprs
.push_back(initexprs
[i
]);
284 //===----------------------------------------------------------------------===//
285 // Generic Expression Routines
286 //===----------------------------------------------------------------------===//
288 /// hasLocalSideEffect - Return true if this immediate expression has side
289 /// effects, not counting any sub-expressions.
290 bool Expr::hasLocalSideEffect() const {
291 switch (getStmtClass()) {
295 return cast
<ParenExpr
>(this)->getSubExpr()->hasLocalSideEffect();
296 case UnaryOperatorClass
: {
297 const UnaryOperator
*UO
= cast
<UnaryOperator
>(this);
299 switch (UO
->getOpcode()) {
300 default: return false;
301 case UnaryOperator::PostInc
:
302 case UnaryOperator::PostDec
:
303 case UnaryOperator::PreInc
:
304 case UnaryOperator::PreDec
:
305 return true; // ++/--
307 case UnaryOperator::Deref
:
308 // Dereferencing a volatile pointer is a side-effect.
309 return getType().isVolatileQualified();
310 case UnaryOperator::Real
:
311 case UnaryOperator::Imag
:
312 // accessing a piece of a volatile complex is a side-effect.
313 return UO
->getSubExpr()->getType().isVolatileQualified();
315 case UnaryOperator::Extension
:
316 return UO
->getSubExpr()->hasLocalSideEffect();
319 case BinaryOperatorClass
: {
320 const BinaryOperator
*BinOp
= cast
<BinaryOperator
>(this);
321 // Consider comma to have side effects if the LHS and RHS both do.
322 if (BinOp
->getOpcode() == BinaryOperator::Comma
)
323 return BinOp
->getLHS()->hasLocalSideEffect() &&
324 BinOp
->getRHS()->hasLocalSideEffect();
326 return BinOp
->isAssignmentOp();
328 case CompoundAssignOperatorClass
:
331 case ConditionalOperatorClass
: {
332 const ConditionalOperator
*Exp
= cast
<ConditionalOperator
>(this);
333 return Exp
->getCond()->hasLocalSideEffect()
334 || (Exp
->getLHS() && Exp
->getLHS()->hasLocalSideEffect())
335 || (Exp
->getRHS() && Exp
->getRHS()->hasLocalSideEffect());
338 case MemberExprClass
:
339 case ArraySubscriptExprClass
:
340 // If the base pointer or element is to a volatile pointer/field, accessing
341 // if is a side effect.
342 return getType().isVolatileQualified();
345 // TODO: check attributes for pure/const. "void foo() { strlen("bar"); }"
348 case ObjCMessageExprClass
:
350 case StmtExprClass
: {
351 // Statement exprs don't logically have side effects themselves, but are
352 // sometimes used in macros in ways that give them a type that is unused.
353 // For example ({ blah; foo(); }) will end up with a type if foo has a type.
354 // however, if the result of the stmt expr is dead, we don't want to emit a
356 const CompoundStmt
*CS
= cast
<StmtExpr
>(this)->getSubStmt();
357 if (!CS
->body_empty())
358 if (const Expr
*E
= dyn_cast
<Expr
>(CS
->body_back()))
359 return E
->hasLocalSideEffect();
362 case ExplicitCastExprClass
:
363 case CXXFunctionalCastExprClass
:
364 // If this is a cast to void, check the operand. Otherwise, the result of
365 // the cast is unused.
366 if (getType()->isVoidType())
367 return cast
<CastExpr
>(this)->getSubExpr()->hasLocalSideEffect();
370 case ImplicitCastExprClass
:
371 // Check the operand, since implicit casts are inserted by Sema
372 return cast
<ImplicitCastExpr
>(this)->getSubExpr()->hasLocalSideEffect();
374 case CXXDefaultArgExprClass
:
375 return cast
<CXXDefaultArgExpr
>(this)->getExpr()->hasLocalSideEffect();
379 /// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an
380 /// incomplete type other than void. Nonarray expressions that can be lvalues:
381 /// - name, where name must be a variable
383 /// - (e), where e must be an lvalue
384 /// - e.name, where e must be an lvalue
386 /// - *e, the type of e cannot be a function type
387 /// - string-constant
388 /// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension]
389 /// - reference type [C++ [expr]]
391 Expr::isLvalueResult
Expr::isLvalue(ASTContext
&Ctx
) const {
392 // first, check the type (C99 6.3.2.1)
393 if (TR
->isFunctionType()) // from isObjectType()
394 return LV_NotObjectType
;
396 // Allow qualified void which is an incomplete type other than void (yuck).
397 if (TR
->isVoidType() && !Ctx
.getCanonicalType(TR
).getCVRQualifiers())
398 return LV_IncompleteVoidType
;
400 if (TR
->isReferenceType()) // C++ [expr]
403 // the type looks fine, now check the expression
404 switch (getStmtClass()) {
405 case StringLiteralClass
: // C99 6.5.1p4
407 case ArraySubscriptExprClass
: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2))))
408 // For vectors, make sure base is an lvalue (i.e. not a function call).
409 if (cast
<ArraySubscriptExpr
>(this)->getBase()->getType()->isVectorType())
410 return cast
<ArraySubscriptExpr
>(this)->getBase()->isLvalue(Ctx
);
412 case DeclRefExprClass
: { // C99 6.5.1p2
413 const Decl
*RefdDecl
= cast
<DeclRefExpr
>(this)->getDecl();
414 if (isa
<VarDecl
>(RefdDecl
) || isa
<ImplicitParamDecl
>(RefdDecl
))
418 case MemberExprClass
: { // C99 6.5.2.3p4
419 const MemberExpr
*m
= cast
<MemberExpr
>(this);
420 return m
->isArrow() ? LV_Valid
: m
->getBase()->isLvalue(Ctx
);
422 case UnaryOperatorClass
:
423 if (cast
<UnaryOperator
>(this)->getOpcode() == UnaryOperator::Deref
)
424 return LV_Valid
; // C99 6.5.3p4
426 if (cast
<UnaryOperator
>(this)->getOpcode() == UnaryOperator::Real
||
427 cast
<UnaryOperator
>(this)->getOpcode() == UnaryOperator::Imag
||
428 cast
<UnaryOperator
>(this)->getOpcode() == UnaryOperator::Extension
)
429 return cast
<UnaryOperator
>(this)->getSubExpr()->isLvalue(Ctx
); // GNU.
431 case ParenExprClass
: // C99 6.5.1p5
432 return cast
<ParenExpr
>(this)->getSubExpr()->isLvalue(Ctx
);
433 case CompoundLiteralExprClass
: // C99 6.5.2.5p5
435 case ExtVectorElementExprClass
:
436 if (cast
<ExtVectorElementExpr
>(this)->containsDuplicateElements())
437 return LV_DuplicateVectorComponents
;
439 case ObjCIvarRefExprClass
: // ObjC instance variables are lvalues.
441 case ObjCPropertyRefExprClass
: // FIXME: check if read-only property.
443 case PredefinedExprClass
:
444 return (cast
<PredefinedExpr
>(this)->getIdentType()
445 == PredefinedExpr::CXXThis
446 ? LV_InvalidExpression
: LV_Valid
);
447 case CXXDefaultArgExprClass
:
448 return cast
<CXXDefaultArgExpr
>(this)->getExpr()->isLvalue(Ctx
);
452 return LV_InvalidExpression
;
455 /// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type,
456 /// does not have an incomplete type, does not have a const-qualified type, and
457 /// if it is a structure or union, does not have any member (including,
458 /// recursively, any member or element of all contained aggregates or unions)
459 /// with a const-qualified type.
460 Expr::isModifiableLvalueResult
Expr::isModifiableLvalue(ASTContext
&Ctx
) const {
461 isLvalueResult lvalResult
= isLvalue(Ctx
);
463 switch (lvalResult
) {
464 case LV_Valid
: break;
465 case LV_NotObjectType
: return MLV_NotObjectType
;
466 case LV_IncompleteVoidType
: return MLV_IncompleteVoidType
;
467 case LV_DuplicateVectorComponents
: return MLV_DuplicateVectorComponents
;
468 case LV_InvalidExpression
: return MLV_InvalidExpression
;
471 QualType CT
= Ctx
.getCanonicalType(getType());
473 if (CT
.isConstQualified())
474 return MLV_ConstQualified
;
475 if (CT
->isArrayType())
476 return MLV_ArrayType
;
477 if (CT
->isIncompleteType())
478 return MLV_IncompleteType
;
480 if (const RecordType
*r
= CT
->getAsRecordType()) {
481 if (r
->hasConstFields())
482 return MLV_ConstQualified
;
487 /// hasGlobalStorage - Return true if this expression has static storage
488 /// duration. This means that the address of this expression is a link-time
490 bool Expr::hasGlobalStorage() const {
491 switch (getStmtClass()) {
495 return cast
<ParenExpr
>(this)->getSubExpr()->hasGlobalStorage();
496 case ImplicitCastExprClass
:
497 return cast
<ImplicitCastExpr
>(this)->getSubExpr()->hasGlobalStorage();
498 case CompoundLiteralExprClass
:
499 return cast
<CompoundLiteralExpr
>(this)->isFileScope();
500 case DeclRefExprClass
: {
501 const Decl
*D
= cast
<DeclRefExpr
>(this)->getDecl();
502 if (const VarDecl
*VD
= dyn_cast
<VarDecl
>(D
))
503 return VD
->hasGlobalStorage();
504 if (isa
<FunctionDecl
>(D
))
508 case MemberExprClass
: {
509 const MemberExpr
*M
= cast
<MemberExpr
>(this);
510 return !M
->isArrow() && M
->getBase()->hasGlobalStorage();
512 case ArraySubscriptExprClass
:
513 return cast
<ArraySubscriptExpr
>(this)->getBase()->hasGlobalStorage();
514 case PredefinedExprClass
:
516 case CXXDefaultArgExprClass
:
517 return cast
<CXXDefaultArgExpr
>(this)->getExpr()->hasGlobalStorage();
521 Expr
* Expr::IgnoreParens() {
523 while (ParenExpr
* P
= dyn_cast
<ParenExpr
>(E
))
529 /// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr
530 /// or CastExprs or ImplicitCastExprs, returning their operand.
531 Expr
*Expr::IgnoreParenCasts() {
534 if (ParenExpr
*P
= dyn_cast
<ParenExpr
>(E
))
536 else if (CastExpr
*P
= dyn_cast
<CastExpr
>(E
))
544 bool Expr::isConstantExpr(ASTContext
&Ctx
, SourceLocation
*Loc
) const {
545 switch (getStmtClass()) {
547 if (Loc
) *Loc
= getLocStart();
550 return cast
<ParenExpr
>(this)->getSubExpr()->isConstantExpr(Ctx
, Loc
);
551 case StringLiteralClass
:
552 case ObjCStringLiteralClass
:
553 case FloatingLiteralClass
:
554 case IntegerLiteralClass
:
555 case CharacterLiteralClass
:
556 case ImaginaryLiteralClass
:
557 case TypesCompatibleExprClass
:
558 case CXXBoolLiteralExprClass
:
559 case AddrLabelExprClass
:
561 case CallExprClass
: {
562 const CallExpr
*CE
= cast
<CallExpr
>(this);
563 if (CE
->isBuiltinConstantExpr())
565 if (Loc
) *Loc
= getLocStart();
568 case DeclRefExprClass
: {
569 const Decl
*D
= cast
<DeclRefExpr
>(this)->getDecl();
570 // Accept address of function.
571 if (isa
<EnumConstantDecl
>(D
) || isa
<FunctionDecl
>(D
))
573 if (Loc
) *Loc
= getLocStart();
575 return TR
->isArrayType();
578 case CompoundLiteralExprClass
:
579 if (Loc
) *Loc
= getLocStart();
580 // Allow "(int []){2,4}", since the array will be converted to a pointer.
581 // Allow "(vector type){2,4}" since the elements are all constant.
582 return TR
->isArrayType() || TR
->isVectorType();
583 case UnaryOperatorClass
: {
584 const UnaryOperator
*Exp
= cast
<UnaryOperator
>(this);
587 if (Exp
->getOpcode() == UnaryOperator::AddrOf
) {
588 if (!Exp
->getSubExpr()->hasGlobalStorage()) {
589 if (Loc
) *Loc
= getLocStart();
595 // Get the operand value. If this is sizeof/alignof, do not evalute the
596 // operand. This affects C99 6.6p3.
597 if (!Exp
->isSizeOfAlignOfOp() &&
598 Exp
->getOpcode() != UnaryOperator::OffsetOf
&&
599 !Exp
->getSubExpr()->isConstantExpr(Ctx
, Loc
))
602 switch (Exp
->getOpcode()) {
603 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
606 if (Loc
) *Loc
= Exp
->getOperatorLoc();
608 case UnaryOperator::Extension
:
609 return true; // FIXME: this is wrong.
610 case UnaryOperator::SizeOf
:
611 case UnaryOperator::AlignOf
:
612 case UnaryOperator::OffsetOf
:
613 // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
614 if (!Exp
->getSubExpr()->getType()->isConstantSizeType()) {
615 if (Loc
) *Loc
= Exp
->getOperatorLoc();
619 case UnaryOperator::LNot
:
620 case UnaryOperator::Plus
:
621 case UnaryOperator::Minus
:
622 case UnaryOperator::Not
:
626 case SizeOfAlignOfTypeExprClass
: {
627 const SizeOfAlignOfTypeExpr
*Exp
= cast
<SizeOfAlignOfTypeExpr
>(this);
628 // alignof always evaluates to a constant.
629 if (Exp
->isSizeOf() && !Exp
->getArgumentType()->isVoidType() &&
630 !Exp
->getArgumentType()->isConstantSizeType()) {
631 if (Loc
) *Loc
= Exp
->getOperatorLoc();
636 case BinaryOperatorClass
: {
637 const BinaryOperator
*Exp
= cast
<BinaryOperator
>(this);
639 // The LHS of a constant expr is always evaluated and needed.
640 if (!Exp
->getLHS()->isConstantExpr(Ctx
, Loc
))
643 if (!Exp
->getRHS()->isConstantExpr(Ctx
, Loc
))
647 case ImplicitCastExprClass
:
648 case ExplicitCastExprClass
:
649 case CXXFunctionalCastExprClass
: {
650 const Expr
*SubExpr
= cast
<CastExpr
>(this)->getSubExpr();
651 SourceLocation CastLoc
= getLocStart();
652 if (!SubExpr
->isConstantExpr(Ctx
, Loc
)) {
653 if (Loc
) *Loc
= SubExpr
->getLocStart();
658 case ConditionalOperatorClass
: {
659 const ConditionalOperator
*Exp
= cast
<ConditionalOperator
>(this);
660 if (!Exp
->getCond()->isConstantExpr(Ctx
, Loc
) ||
661 // Handle the GNU extension for missing LHS.
662 !(Exp
->getLHS() && Exp
->getLHS()->isConstantExpr(Ctx
, Loc
)) ||
663 !Exp
->getRHS()->isConstantExpr(Ctx
, Loc
))
667 case InitListExprClass
: {
668 const InitListExpr
*Exp
= cast
<InitListExpr
>(this);
669 unsigned numInits
= Exp
->getNumInits();
670 for (unsigned i
= 0; i
< numInits
; i
++) {
671 if (!Exp
->getInit(i
)->isConstantExpr(Ctx
, Loc
)) {
672 if (Loc
) *Loc
= Exp
->getInit(i
)->getLocStart();
678 case CXXDefaultArgExprClass
:
679 return cast
<CXXDefaultArgExpr
>(this)->getExpr()->isConstantExpr(Ctx
, Loc
);
683 /// isIntegerConstantExpr - this recursive routine will test if an expression is
684 /// an integer constant expression. Note: With the introduction of VLA's in
685 /// C99 the result of the sizeof operator is no longer always a constant
686 /// expression. The generalization of the wording to include any subexpression
687 /// that is not evaluated (C99 6.6p3) means that nonconstant subexpressions
688 /// can appear as operands to other operators (e.g. &&, ||, ?:). For instance,
689 /// "0 || f()" can be treated as a constant expression. In C90 this expression,
690 /// occurring in a context requiring a constant, would have been a constraint
691 /// violation. FIXME: This routine currently implements C90 semantics.
692 /// To properly implement C99 semantics this routine will need to evaluate
693 /// expressions involving operators previously mentioned.
695 /// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero,
698 /// FIXME: This should ext-warn on overflow during evaluation! ISO C does not
699 /// permit this. This includes things like (int)1e1000
701 /// FIXME: Handle offsetof. Two things to do: Handle GCC's __builtin_offsetof
702 /// to support gcc 4.0+ and handle the idiom GCC recognizes with a null pointer
703 /// cast+dereference.
704 bool Expr::isIntegerConstantExpr(llvm::APSInt
&Result
, ASTContext
&Ctx
,
705 SourceLocation
*Loc
, bool isEvaluated
) const {
706 switch (getStmtClass()) {
708 if (Loc
) *Loc
= getLocStart();
711 return cast
<ParenExpr
>(this)->getSubExpr()->
712 isIntegerConstantExpr(Result
, Ctx
, Loc
, isEvaluated
);
713 case IntegerLiteralClass
:
714 Result
= cast
<IntegerLiteral
>(this)->getValue();
716 case CharacterLiteralClass
: {
717 const CharacterLiteral
*CL
= cast
<CharacterLiteral
>(this);
718 Result
.zextOrTrunc(static_cast<uint32_t>(Ctx
.getTypeSize(getType())));
719 Result
= CL
->getValue();
720 Result
.setIsUnsigned(!getType()->isSignedIntegerType());
723 case CXXZeroInitValueExprClass
:
726 case TypesCompatibleExprClass
: {
727 const TypesCompatibleExpr
*TCE
= cast
<TypesCompatibleExpr
>(this);
728 Result
.zextOrTrunc(static_cast<uint32_t>(Ctx
.getTypeSize(getType())));
729 Result
= Ctx
.typesAreCompatible(TCE
->getArgType1(), TCE
->getArgType2());
732 case CallExprClass
: {
733 const CallExpr
*CE
= cast
<CallExpr
>(this);
734 Result
.zextOrTrunc(static_cast<uint32_t>(Ctx
.getTypeSize(getType())));
735 if (CE
->isBuiltinClassifyType(Result
))
737 if (Loc
) *Loc
= getLocStart();
740 case DeclRefExprClass
:
741 if (const EnumConstantDecl
*D
=
742 dyn_cast
<EnumConstantDecl
>(cast
<DeclRefExpr
>(this)->getDecl())) {
743 Result
= D
->getInitVal();
746 if (Loc
) *Loc
= getLocStart();
748 case UnaryOperatorClass
: {
749 const UnaryOperator
*Exp
= cast
<UnaryOperator
>(this);
751 // Get the operand value. If this is sizeof/alignof, do not evalute the
752 // operand. This affects C99 6.6p3.
753 if (!Exp
->isSizeOfAlignOfOp() && !Exp
->isOffsetOfOp() &&
754 !Exp
->getSubExpr()->isIntegerConstantExpr(Result
, Ctx
, Loc
,isEvaluated
))
757 switch (Exp
->getOpcode()) {
758 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
761 if (Loc
) *Loc
= Exp
->getOperatorLoc();
763 case UnaryOperator::Extension
:
764 return true; // FIXME: this is wrong.
765 case UnaryOperator::SizeOf
:
766 case UnaryOperator::AlignOf
:
767 // Return the result in the right width.
768 Result
.zextOrTrunc(static_cast<uint32_t>(Ctx
.getTypeSize(getType())));
770 // sizeof(void) and __alignof__(void) = 1 as a gcc extension.
771 if (Exp
->getSubExpr()->getType()->isVoidType()) {
776 // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
777 if (!Exp
->getSubExpr()->getType()->isConstantSizeType()) {
778 if (Loc
) *Loc
= Exp
->getOperatorLoc();
782 // Get information about the size or align.
783 if (Exp
->getSubExpr()->getType()->isFunctionType()) {
784 // GCC extension: sizeof(function) = 1.
785 Result
= Exp
->getOpcode() == UnaryOperator::AlignOf
? 4 : 1;
787 unsigned CharSize
= Ctx
.Target
.getCharWidth();
788 if (Exp
->getOpcode() == UnaryOperator::AlignOf
)
789 Result
= Ctx
.getTypeAlign(Exp
->getSubExpr()->getType()) / CharSize
;
791 Result
= Ctx
.getTypeSize(Exp
->getSubExpr()->getType()) / CharSize
;
794 case UnaryOperator::LNot
: {
795 bool Val
= Result
== 0;
796 Result
.zextOrTrunc(static_cast<uint32_t>(Ctx
.getTypeSize(getType())));
800 case UnaryOperator::Plus
:
802 case UnaryOperator::Minus
:
805 case UnaryOperator::Not
:
808 case UnaryOperator::OffsetOf
:
809 Result
= Exp
->evaluateOffsetOf(Ctx
);
813 case SizeOfAlignOfTypeExprClass
: {
814 const SizeOfAlignOfTypeExpr
*Exp
= cast
<SizeOfAlignOfTypeExpr
>(this);
816 // Return the result in the right width.
817 Result
.zextOrTrunc(static_cast<uint32_t>(Ctx
.getTypeSize(getType())));
819 // sizeof(void) and __alignof__(void) = 1 as a gcc extension.
820 if (Exp
->getArgumentType()->isVoidType()) {
825 // alignof always evaluates to a constant, sizeof does if arg is not VLA.
826 if (Exp
->isSizeOf() && !Exp
->getArgumentType()->isConstantSizeType()) {
827 if (Loc
) *Loc
= Exp
->getOperatorLoc();
831 // Get information about the size or align.
832 if (Exp
->getArgumentType()->isFunctionType()) {
833 // GCC extension: sizeof(function) = 1.
834 Result
= Exp
->isSizeOf() ? 1 : 4;
836 unsigned CharSize
= Ctx
.Target
.getCharWidth();
838 Result
= Ctx
.getTypeSize(Exp
->getArgumentType()) / CharSize
;
840 Result
= Ctx
.getTypeAlign(Exp
->getArgumentType()) / CharSize
;
844 case BinaryOperatorClass
: {
845 const BinaryOperator
*Exp
= cast
<BinaryOperator
>(this);
847 // The LHS of a constant expr is always evaluated and needed.
848 if (!Exp
->getLHS()->isIntegerConstantExpr(Result
, Ctx
, Loc
, isEvaluated
))
851 llvm::APSInt
RHS(Result
);
853 // The short-circuiting &&/|| operators don't necessarily evaluate their
854 // RHS. Make sure to pass isEvaluated down correctly.
855 if (Exp
->isLogicalOp()) {
857 if (Exp
->getOpcode() == BinaryOperator::LAnd
)
858 RHSEval
= Result
!= 0;
860 assert(Exp
->getOpcode() == BinaryOperator::LOr
&&"Unexpected logical");
861 RHSEval
= Result
== 0;
864 if (!Exp
->getRHS()->isIntegerConstantExpr(RHS
, Ctx
, Loc
,
865 isEvaluated
& RHSEval
))
868 if (!Exp
->getRHS()->isIntegerConstantExpr(RHS
, Ctx
, Loc
, isEvaluated
))
872 switch (Exp
->getOpcode()) {
874 if (Loc
) *Loc
= getLocStart();
876 case BinaryOperator::Mul
:
879 case BinaryOperator::Div
:
881 if (!isEvaluated
) break;
882 if (Loc
) *Loc
= getLocStart();
887 case BinaryOperator::Rem
:
889 if (!isEvaluated
) break;
890 if (Loc
) *Loc
= getLocStart();
895 case BinaryOperator::Add
: Result
+= RHS
; break;
896 case BinaryOperator::Sub
: Result
-= RHS
; break;
897 case BinaryOperator::Shl
:
899 static_cast<uint32_t>(RHS
.getLimitedValue(Result
.getBitWidth()-1));
901 case BinaryOperator::Shr
:
903 static_cast<uint32_t>(RHS
.getLimitedValue(Result
.getBitWidth()-1));
905 case BinaryOperator::LT
: Result
= Result
< RHS
; break;
906 case BinaryOperator::GT
: Result
= Result
> RHS
; break;
907 case BinaryOperator::LE
: Result
= Result
<= RHS
; break;
908 case BinaryOperator::GE
: Result
= Result
>= RHS
; break;
909 case BinaryOperator::EQ
: Result
= Result
== RHS
; break;
910 case BinaryOperator::NE
: Result
= Result
!= RHS
; break;
911 case BinaryOperator::And
: Result
&= RHS
; break;
912 case BinaryOperator::Xor
: Result
^= RHS
; break;
913 case BinaryOperator::Or
: Result
|= RHS
; break;
914 case BinaryOperator::LAnd
:
915 Result
= Result
!= 0 && RHS
!= 0;
917 case BinaryOperator::LOr
:
918 Result
= Result
!= 0 || RHS
!= 0;
921 case BinaryOperator::Comma
:
922 // C99 6.6p3: "shall not contain assignment, ..., or comma operators,
923 // *except* when they are contained within a subexpression that is not
924 // evaluated". Note that Assignment can never happen due to constraints
925 // on the LHS subexpr, so we don't need to check it here.
927 if (Loc
) *Loc
= getLocStart();
931 // The result of the constant expr is the RHS.
936 assert(!Exp
->isAssignmentOp() && "LHS can't be a constant expr!");
939 case ImplicitCastExprClass
:
940 case ExplicitCastExprClass
:
941 case CXXFunctionalCastExprClass
: {
942 const Expr
*SubExpr
= cast
<CastExpr
>(this)->getSubExpr();
943 SourceLocation CastLoc
= getLocStart();
945 // C99 6.6p6: shall only convert arithmetic types to integer types.
946 if (!SubExpr
->getType()->isArithmeticType() ||
947 !getType()->isIntegerType()) {
948 if (Loc
) *Loc
= SubExpr
->getLocStart();
952 uint32_t DestWidth
= static_cast<uint32_t>(Ctx
.getTypeSize(getType()));
954 // Handle simple integer->integer casts.
955 if (SubExpr
->getType()->isIntegerType()) {
956 if (!SubExpr
->isIntegerConstantExpr(Result
, Ctx
, Loc
, isEvaluated
))
959 // Figure out if this is a truncate, extend or noop cast.
960 // If the input is signed, do a sign extend, noop, or truncate.
961 if (getType()->isBooleanType()) {
962 // Conversion to bool compares against zero.
963 Result
= Result
!= 0;
964 Result
.zextOrTrunc(DestWidth
);
965 } else if (SubExpr
->getType()->isSignedIntegerType())
966 Result
.sextOrTrunc(DestWidth
);
967 else // If the input is unsigned, do a zero extend, noop, or truncate.
968 Result
.zextOrTrunc(DestWidth
);
972 // Allow floating constants that are the immediate operands of casts or that
973 // are parenthesized.
974 const Expr
*Operand
= SubExpr
;
975 while (const ParenExpr
*PE
= dyn_cast
<ParenExpr
>(Operand
))
976 Operand
= PE
->getSubExpr();
978 // If this isn't a floating literal, we can't handle it.
979 const FloatingLiteral
*FL
= dyn_cast
<FloatingLiteral
>(Operand
);
981 if (Loc
) *Loc
= Operand
->getLocStart();
985 // If the destination is boolean, compare against zero.
986 if (getType()->isBooleanType()) {
987 Result
= !FL
->getValue().isZero();
988 Result
.zextOrTrunc(DestWidth
);
992 // Determine whether we are converting to unsigned or signed.
993 bool DestSigned
= getType()->isSignedIntegerType();
995 // TODO: Warn on overflow, but probably not here: isIntegerConstantExpr can
996 // be called multiple times per AST.
998 (void)FL
->getValue().convertToInteger(Space
, DestWidth
, DestSigned
,
999 llvm::APFloat::rmTowardZero
);
1000 Result
= llvm::APInt(DestWidth
, 4, Space
);
1003 case ConditionalOperatorClass
: {
1004 const ConditionalOperator
*Exp
= cast
<ConditionalOperator
>(this);
1006 if (!Exp
->getCond()->isIntegerConstantExpr(Result
, Ctx
, Loc
, isEvaluated
))
1009 const Expr
*TrueExp
= Exp
->getLHS();
1010 const Expr
*FalseExp
= Exp
->getRHS();
1011 if (Result
== 0) std::swap(TrueExp
, FalseExp
);
1013 // Evaluate the false one first, discard the result.
1014 if (FalseExp
&& !FalseExp
->isIntegerConstantExpr(Result
, Ctx
, Loc
, false))
1016 // Evalute the true one, capture the result.
1018 !TrueExp
->isIntegerConstantExpr(Result
, Ctx
, Loc
, isEvaluated
))
1022 case CXXDefaultArgExprClass
:
1023 return cast
<CXXDefaultArgExpr
>(this)
1024 ->isIntegerConstantExpr(Result
, Ctx
, Loc
, isEvaluated
);
1027 // Cases that are valid constant exprs fall through to here.
1028 Result
.setIsUnsigned(getType()->isUnsignedIntegerType());
1032 /// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an
1033 /// integer constant expression with the value zero, or if this is one that is
1035 bool Expr::isNullPointerConstant(ASTContext
&Ctx
) const {
1036 // Strip off a cast to void*, if it exists.
1037 if (const ExplicitCastExpr
*CE
= dyn_cast
<ExplicitCastExpr
>(this)) {
1038 // Check that it is a cast to void*.
1039 if (const PointerType
*PT
= CE
->getType()->getAsPointerType()) {
1040 QualType Pointee
= PT
->getPointeeType();
1041 if (Pointee
.getCVRQualifiers() == 0 &&
1042 Pointee
->isVoidType() && // to void*
1043 CE
->getSubExpr()->getType()->isIntegerType()) // from int.
1044 return CE
->getSubExpr()->isNullPointerConstant(Ctx
);
1046 } else if (const ImplicitCastExpr
*ICE
= dyn_cast
<ImplicitCastExpr
>(this)) {
1047 // Ignore the ImplicitCastExpr type entirely.
1048 return ICE
->getSubExpr()->isNullPointerConstant(Ctx
);
1049 } else if (const ParenExpr
*PE
= dyn_cast
<ParenExpr
>(this)) {
1050 // Accept ((void*)0) as a null pointer constant, as many other
1051 // implementations do.
1052 return PE
->getSubExpr()->isNullPointerConstant(Ctx
);
1053 } else if (const CXXDefaultArgExpr
*DefaultArg
1054 = dyn_cast
<CXXDefaultArgExpr
>(this)) {
1055 // See through default argument expressions
1056 return DefaultArg
->getExpr()->isNullPointerConstant(Ctx
);
1059 // This expression must be an integer type.
1060 if (!getType()->isIntegerType())
1063 // If we have an integer constant expression, we need to *evaluate* it and
1064 // test for the value 0.
1065 llvm::APSInt
Val(32);
1066 return isIntegerConstantExpr(Val
, Ctx
, 0, true) && Val
== 0;
1069 unsigned ExtVectorElementExpr::getNumElements() const {
1070 if (const VectorType
*VT
= getType()->getAsVectorType())
1071 return VT
->getNumElements();
1075 /// containsDuplicateElements - Return true if any element access is repeated.
1076 bool ExtVectorElementExpr::containsDuplicateElements() const {
1077 const char *compStr
= Accessor
.getName();
1078 unsigned length
= strlen(compStr
);
1080 for (unsigned i
= 0; i
< length
-1; i
++) {
1081 const char *s
= compStr
+i
;
1082 for (const char c
= *s
++; *s
; s
++)
1089 /// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
1090 void ExtVectorElementExpr::getEncodedElementAccess(
1091 llvm::SmallVectorImpl
<unsigned> &Elts
) const {
1092 const char *compStr
= Accessor
.getName();
1094 bool isHi
= !strcmp(compStr
, "hi");
1095 bool isLo
= !strcmp(compStr
, "lo");
1096 bool isEven
= !strcmp(compStr
, "e");
1097 bool isOdd
= !strcmp(compStr
, "o");
1099 for (unsigned i
= 0, e
= getNumElements(); i
!= e
; ++i
) {
1111 Index
= ExtVectorType::getAccessorIdx(compStr
[i
]);
1113 Elts
.push_back(Index
);
1117 // constructor for instance messages.
1118 ObjCMessageExpr::ObjCMessageExpr(Expr
*receiver
, Selector selInfo
,
1119 QualType retType
, ObjCMethodDecl
*mproto
,
1120 SourceLocation LBrac
, SourceLocation RBrac
,
1121 Expr
**ArgExprs
, unsigned nargs
)
1122 : Expr(ObjCMessageExprClass
, retType
), SelName(selInfo
),
1123 MethodProto(mproto
) {
1125 SubExprs
= new Stmt
*[NumArgs
+1];
1126 SubExprs
[RECEIVER
] = receiver
;
1128 for (unsigned i
= 0; i
!= NumArgs
; ++i
)
1129 SubExprs
[i
+ARGS_START
] = static_cast<Expr
*>(ArgExprs
[i
]);
1135 // constructor for class messages.
1136 // FIXME: clsName should be typed to ObjCInterfaceType
1137 ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo
*clsName
, Selector selInfo
,
1138 QualType retType
, ObjCMethodDecl
*mproto
,
1139 SourceLocation LBrac
, SourceLocation RBrac
,
1140 Expr
**ArgExprs
, unsigned nargs
)
1141 : Expr(ObjCMessageExprClass
, retType
), SelName(selInfo
),
1142 MethodProto(mproto
) {
1144 SubExprs
= new Stmt
*[NumArgs
+1];
1145 SubExprs
[RECEIVER
] = (Expr
*) ((uintptr_t) clsName
| IsClsMethDeclUnknown
);
1147 for (unsigned i
= 0; i
!= NumArgs
; ++i
)
1148 SubExprs
[i
+ARGS_START
] = static_cast<Expr
*>(ArgExprs
[i
]);
1154 // constructor for class messages.
1155 ObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl
*cls
, Selector selInfo
,
1156 QualType retType
, ObjCMethodDecl
*mproto
,
1157 SourceLocation LBrac
, SourceLocation RBrac
,
1158 Expr
**ArgExprs
, unsigned nargs
)
1159 : Expr(ObjCMessageExprClass
, retType
), SelName(selInfo
),
1160 MethodProto(mproto
) {
1162 SubExprs
= new Stmt
*[NumArgs
+1];
1163 SubExprs
[RECEIVER
] = (Expr
*) ((uintptr_t) cls
| IsClsMethDeclKnown
);
1165 for (unsigned i
= 0; i
!= NumArgs
; ++i
)
1166 SubExprs
[i
+ARGS_START
] = static_cast<Expr
*>(ArgExprs
[i
]);
1172 ObjCMessageExpr::ClassInfo
ObjCMessageExpr::getClassInfo() const {
1173 uintptr_t x
= (uintptr_t) SubExprs
[RECEIVER
];
1174 switch (x
& Flags
) {
1176 assert(false && "Invalid ObjCMessageExpr.");
1178 return ClassInfo(0, 0);
1179 case IsClsMethDeclUnknown
:
1180 return ClassInfo(0, (IdentifierInfo
*) (x
& ~Flags
));
1181 case IsClsMethDeclKnown
: {
1182 ObjCInterfaceDecl
* D
= (ObjCInterfaceDecl
*) (x
& ~Flags
);
1183 return ClassInfo(D
, D
->getIdentifier());
1188 bool ChooseExpr::isConditionTrue(ASTContext
&C
) const {
1189 return getCond()->getIntegerConstantExprValue(C
) != 0;
1192 static int64_t evaluateOffsetOf(ASTContext
& C
, const Expr
*E
)
1194 if (const MemberExpr
*ME
= dyn_cast
<MemberExpr
>(E
)) {
1195 QualType Ty
= ME
->getBase()->getType();
1197 RecordDecl
*RD
= Ty
->getAsRecordType()->getDecl();
1198 const ASTRecordLayout
&RL
= C
.getASTRecordLayout(RD
);
1199 FieldDecl
*FD
= ME
->getMemberDecl();
1201 // FIXME: This is linear time.
1202 unsigned i
= 0, e
= 0;
1203 for (i
= 0, e
= RD
->getNumMembers(); i
!= e
; i
++) {
1204 if (RD
->getMember(i
) == FD
)
1208 return RL
.getFieldOffset(i
) + evaluateOffsetOf(C
, ME
->getBase());
1209 } else if (const ArraySubscriptExpr
*ASE
= dyn_cast
<ArraySubscriptExpr
>(E
)) {
1210 const Expr
*Base
= ASE
->getBase();
1212 int64_t size
= C
.getTypeSize(ASE
->getType());
1213 size
*= ASE
->getIdx()->getIntegerConstantExprValue(C
).getSExtValue();
1215 return size
+ evaluateOffsetOf(C
, Base
);
1216 } else if (isa
<CompoundLiteralExpr
>(E
))
1219 assert(0 && "Unknown offsetof subexpression!");
1223 int64_t UnaryOperator::evaluateOffsetOf(ASTContext
& C
) const
1225 assert(Opc
== OffsetOf
&& "Unary operator not offsetof!");
1227 unsigned CharSize
= C
.Target
.getCharWidth();
1228 return ::evaluateOffsetOf(C
, cast
<Expr
>(Val
)) / CharSize
;
1231 //===----------------------------------------------------------------------===//
1232 // Child Iterators for iterating over subexpressions/substatements
1233 //===----------------------------------------------------------------------===//
1236 Stmt::child_iterator
DeclRefExpr::child_begin() { return child_iterator(); }
1237 Stmt::child_iterator
DeclRefExpr::child_end() { return child_iterator(); }
1240 Stmt::child_iterator
ObjCIvarRefExpr::child_begin() { return &Base
; }
1241 Stmt::child_iterator
ObjCIvarRefExpr::child_end() { return &Base
+1; }
1243 // ObjCPropertyRefExpr
1244 Stmt::child_iterator
ObjCPropertyRefExpr::child_begin() { return &Base
; }
1245 Stmt::child_iterator
ObjCPropertyRefExpr::child_end() { return &Base
+1; }
1248 Stmt::child_iterator
PredefinedExpr::child_begin() { return child_iterator(); }
1249 Stmt::child_iterator
PredefinedExpr::child_end() { return child_iterator(); }
1252 Stmt::child_iterator
IntegerLiteral::child_begin() { return child_iterator(); }
1253 Stmt::child_iterator
IntegerLiteral::child_end() { return child_iterator(); }
1256 Stmt::child_iterator
CharacterLiteral::child_begin() { return child_iterator(); }
1257 Stmt::child_iterator
CharacterLiteral::child_end() { return child_iterator(); }
1260 Stmt::child_iterator
FloatingLiteral::child_begin() { return child_iterator(); }
1261 Stmt::child_iterator
FloatingLiteral::child_end() { return child_iterator(); }
1264 Stmt::child_iterator
ImaginaryLiteral::child_begin() { return &Val
; }
1265 Stmt::child_iterator
ImaginaryLiteral::child_end() { return &Val
+1; }
1268 Stmt::child_iterator
StringLiteral::child_begin() { return child_iterator(); }
1269 Stmt::child_iterator
StringLiteral::child_end() { return child_iterator(); }
1272 Stmt::child_iterator
ParenExpr::child_begin() { return &Val
; }
1273 Stmt::child_iterator
ParenExpr::child_end() { return &Val
+1; }
1276 Stmt::child_iterator
UnaryOperator::child_begin() { return &Val
; }
1277 Stmt::child_iterator
UnaryOperator::child_end() { return &Val
+1; }
1279 // SizeOfAlignOfTypeExpr
1280 Stmt::child_iterator
SizeOfAlignOfTypeExpr::child_begin() {
1281 // If the type is a VLA type (and not a typedef), the size expression of the
1282 // VLA needs to be treated as an executable expression.
1283 if (VariableArrayType
* T
= dyn_cast
<VariableArrayType
>(Ty
.getTypePtr()))
1284 return child_iterator(T
);
1286 return child_iterator();
1288 Stmt::child_iterator
SizeOfAlignOfTypeExpr::child_end() {
1289 return child_iterator();
1292 // ArraySubscriptExpr
1293 Stmt::child_iterator
ArraySubscriptExpr::child_begin() {
1294 return &SubExprs
[0];
1296 Stmt::child_iterator
ArraySubscriptExpr::child_end() {
1297 return &SubExprs
[0]+END_EXPR
;
1301 Stmt::child_iterator
CallExpr::child_begin() {
1302 return &SubExprs
[0];
1304 Stmt::child_iterator
CallExpr::child_end() {
1305 return &SubExprs
[0]+NumArgs
+ARGS_START
;
1309 Stmt::child_iterator
MemberExpr::child_begin() { return &Base
; }
1310 Stmt::child_iterator
MemberExpr::child_end() { return &Base
+1; }
1312 // ExtVectorElementExpr
1313 Stmt::child_iterator
ExtVectorElementExpr::child_begin() { return &Base
; }
1314 Stmt::child_iterator
ExtVectorElementExpr::child_end() { return &Base
+1; }
1316 // CompoundLiteralExpr
1317 Stmt::child_iterator
CompoundLiteralExpr::child_begin() { return &Init
; }
1318 Stmt::child_iterator
CompoundLiteralExpr::child_end() { return &Init
+1; }
1321 Stmt::child_iterator
CastExpr::child_begin() { return &Op
; }
1322 Stmt::child_iterator
CastExpr::child_end() { return &Op
+1; }
1325 Stmt::child_iterator
BinaryOperator::child_begin() {
1326 return &SubExprs
[0];
1328 Stmt::child_iterator
BinaryOperator::child_end() {
1329 return &SubExprs
[0]+END_EXPR
;
1332 // ConditionalOperator
1333 Stmt::child_iterator
ConditionalOperator::child_begin() {
1334 return &SubExprs
[0];
1336 Stmt::child_iterator
ConditionalOperator::child_end() {
1337 return &SubExprs
[0]+END_EXPR
;
1341 Stmt::child_iterator
AddrLabelExpr::child_begin() { return child_iterator(); }
1342 Stmt::child_iterator
AddrLabelExpr::child_end() { return child_iterator(); }
1345 Stmt::child_iterator
StmtExpr::child_begin() { return &SubStmt
; }
1346 Stmt::child_iterator
StmtExpr::child_end() { return &SubStmt
+1; }
1348 // TypesCompatibleExpr
1349 Stmt::child_iterator
TypesCompatibleExpr::child_begin() {
1350 return child_iterator();
1353 Stmt::child_iterator
TypesCompatibleExpr::child_end() {
1354 return child_iterator();
1358 Stmt::child_iterator
ChooseExpr::child_begin() { return &SubExprs
[0]; }
1359 Stmt::child_iterator
ChooseExpr::child_end() { return &SubExprs
[0]+END_EXPR
; }
1362 Stmt::child_iterator
OverloadExpr::child_begin() { return &SubExprs
[0]; }
1363 Stmt::child_iterator
OverloadExpr::child_end() { return &SubExprs
[0]+NumExprs
; }
1365 // ShuffleVectorExpr
1366 Stmt::child_iterator
ShuffleVectorExpr::child_begin() {
1367 return &SubExprs
[0];
1369 Stmt::child_iterator
ShuffleVectorExpr::child_end() {
1370 return &SubExprs
[0]+NumExprs
;
1374 Stmt::child_iterator
VAArgExpr::child_begin() { return &Val
; }
1375 Stmt::child_iterator
VAArgExpr::child_end() { return &Val
+1; }
1378 Stmt::child_iterator
InitListExpr::child_begin() {
1379 return InitExprs
.size() ? &InitExprs
[0] : 0;
1381 Stmt::child_iterator
InitListExpr::child_end() {
1382 return InitExprs
.size() ? &InitExprs
[0] + InitExprs
.size() : 0;
1385 // ObjCStringLiteral
1386 Stmt::child_iterator
ObjCStringLiteral::child_begin() {
1387 return child_iterator();
1389 Stmt::child_iterator
ObjCStringLiteral::child_end() {
1390 return child_iterator();
1394 Stmt::child_iterator
ObjCEncodeExpr::child_begin() { return child_iterator(); }
1395 Stmt::child_iterator
ObjCEncodeExpr::child_end() { return child_iterator(); }
1398 Stmt::child_iterator
ObjCSelectorExpr::child_begin() {
1399 return child_iterator();
1401 Stmt::child_iterator
ObjCSelectorExpr::child_end() {
1402 return child_iterator();
1406 Stmt::child_iterator
ObjCProtocolExpr::child_begin() {
1407 return child_iterator();
1409 Stmt::child_iterator
ObjCProtocolExpr::child_end() {
1410 return child_iterator();
1414 Stmt::child_iterator
ObjCMessageExpr::child_begin() {
1415 return getReceiver() ? &SubExprs
[0] : &SubExprs
[0] + ARGS_START
;
1417 Stmt::child_iterator
ObjCMessageExpr::child_end() {
1418 return &SubExprs
[0]+ARGS_START
+getNumArgs();