Expr.cpp revision e3e9add4fd788927df6f545570e7838db59c01d7
1//===--- Expr.cpp - Expression AST Node Implementation --------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Expr class and subclasses. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/AST/ExprObjC.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/StmtVisitor.h" 17#include "clang/Basic/IdentifierTable.h" 18#include "clang/Basic/TargetInfo.h" 19using namespace clang; 20 21//===----------------------------------------------------------------------===// 22// Primary Expressions. 23//===----------------------------------------------------------------------===// 24 25StringLiteral::StringLiteral(const char *strData, unsigned byteLength, 26 bool Wide, QualType t, SourceLocation firstLoc, 27 SourceLocation lastLoc) : 28 Expr(StringLiteralClass, t) { 29 // OPTIMIZE: could allocate this appended to the StringLiteral. 30 char *AStrData = new char[byteLength]; 31 memcpy(AStrData, strData, byteLength); 32 StrData = AStrData; 33 ByteLength = byteLength; 34 IsWide = Wide; 35 firstTokLoc = firstLoc; 36 lastTokLoc = lastLoc; 37} 38 39StringLiteral::~StringLiteral() { 40 delete[] StrData; 41} 42 43bool UnaryOperator::isPostfix(Opcode Op) { 44 switch (Op) { 45 case PostInc: 46 case PostDec: 47 return true; 48 default: 49 return false; 50 } 51} 52 53/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 54/// corresponds to, e.g. "sizeof" or "[pre]++". 55const char *UnaryOperator::getOpcodeStr(Opcode Op) { 56 switch (Op) { 57 default: assert(0 && "Unknown unary operator"); 58 case PostInc: return "++"; 59 case PostDec: return "--"; 60 case PreInc: return "++"; 61 case PreDec: return "--"; 62 case AddrOf: return "&"; 63 case Deref: return "*"; 64 case Plus: return "+"; 65 case Minus: return "-"; 66 case Not: return "~"; 67 case LNot: return "!"; 68 case Real: return "__real"; 69 case Imag: return "__imag"; 70 case SizeOf: return "sizeof"; 71 case AlignOf: return "alignof"; 72 case Extension: return "__extension__"; 73 case OffsetOf: return "__builtin_offsetof"; 74 } 75} 76 77//===----------------------------------------------------------------------===// 78// Postfix Operators. 79//===----------------------------------------------------------------------===// 80 81 82CallExpr::CallExpr(Expr *fn, Expr **args, unsigned numargs, QualType t, 83 SourceLocation rparenloc) 84 : Expr(CallExprClass, t), NumArgs(numargs) { 85 SubExprs = new Expr*[numargs+1]; 86 SubExprs[FN] = fn; 87 for (unsigned i = 0; i != numargs; ++i) 88 SubExprs[i+ARGS_START] = args[i]; 89 RParenLoc = rparenloc; 90} 91 92/// setNumArgs - This changes the number of arguments present in this call. 93/// Any orphaned expressions are deleted by this, and any new operands are set 94/// to null. 95void CallExpr::setNumArgs(unsigned NumArgs) { 96 // No change, just return. 97 if (NumArgs == getNumArgs()) return; 98 99 // If shrinking # arguments, just delete the extras and forgot them. 100 if (NumArgs < getNumArgs()) { 101 for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i) 102 delete getArg(i); 103 this->NumArgs = NumArgs; 104 return; 105 } 106 107 // Otherwise, we are growing the # arguments. New an bigger argument array. 108 Expr **NewSubExprs = new Expr*[NumArgs+1]; 109 // Copy over args. 110 for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i) 111 NewSubExprs[i] = SubExprs[i]; 112 // Null out new args. 113 for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i) 114 NewSubExprs[i] = 0; 115 116 delete[] SubExprs; 117 SubExprs = NewSubExprs; 118 this->NumArgs = NumArgs; 119} 120 121bool CallExpr::isBuiltinConstantExpr() const { 122 // All simple function calls (e.g. func()) are implicitly cast to pointer to 123 // function. As a result, we try and obtain the DeclRefExpr from the 124 // ImplicitCastExpr. 125 const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 126 if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 127 return false; 128 129 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 130 if (!DRE) 131 return false; 132 133 const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 134 if (!FDecl) 135 return false; 136 137 unsigned builtinID = FDecl->getIdentifier()->getBuiltinID(); 138 if (!builtinID) 139 return false; 140 141 // We have a builtin that is a constant expression 142 return builtinID == Builtin::BI__builtin___CFStringMakeConstantString || 143 builtinID == Builtin::BI__builtin_classify_type; 144} 145 146bool CallExpr::isBuiltinClassifyType(llvm::APSInt &Result) const { 147 // The following enum mimics gcc's internal "typeclass.h" file. 148 enum gcc_type_class { 149 no_type_class = -1, 150 void_type_class, integer_type_class, char_type_class, 151 enumeral_type_class, boolean_type_class, 152 pointer_type_class, reference_type_class, offset_type_class, 153 real_type_class, complex_type_class, 154 function_type_class, method_type_class, 155 record_type_class, union_type_class, 156 array_type_class, string_type_class, 157 lang_type_class 158 }; 159 Result.setIsSigned(true); 160 161 // All simple function calls (e.g. func()) are implicitly cast to pointer to 162 // function. As a result, we try and obtain the DeclRefExpr from the 163 // ImplicitCastExpr. 164 const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 165 if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 166 return false; 167 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 168 if (!DRE) 169 return false; 170 171 // We have a DeclRefExpr. 172 if (strcmp(DRE->getDecl()->getName(), "__builtin_classify_type") == 0) { 173 // If no argument was supplied, default to "no_type_class". This isn't 174 // ideal, however it's what gcc does. 175 Result = static_cast<uint64_t>(no_type_class); 176 if (NumArgs >= 1) { 177 QualType argType = getArg(0)->getType(); 178 179 if (argType->isVoidType()) 180 Result = void_type_class; 181 else if (argType->isEnumeralType()) 182 Result = enumeral_type_class; 183 else if (argType->isBooleanType()) 184 Result = boolean_type_class; 185 else if (argType->isCharType()) 186 Result = string_type_class; // gcc doesn't appear to use char_type_class 187 else if (argType->isIntegerType()) 188 Result = integer_type_class; 189 else if (argType->isPointerType()) 190 Result = pointer_type_class; 191 else if (argType->isReferenceType()) 192 Result = reference_type_class; 193 else if (argType->isRealType()) 194 Result = real_type_class; 195 else if (argType->isComplexType()) 196 Result = complex_type_class; 197 else if (argType->isFunctionType()) 198 Result = function_type_class; 199 else if (argType->isStructureType()) 200 Result = record_type_class; 201 else if (argType->isUnionType()) 202 Result = union_type_class; 203 else if (argType->isArrayType()) 204 Result = array_type_class; 205 else if (argType->isUnionType()) 206 Result = union_type_class; 207 else // FIXME: offset_type_class, method_type_class, & lang_type_class? 208 assert(0 && "CallExpr::isBuiltinClassifyType(): unimplemented type"); 209 } 210 return true; 211 } 212 return false; 213} 214 215/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 216/// corresponds to, e.g. "<<=". 217const char *BinaryOperator::getOpcodeStr(Opcode Op) { 218 switch (Op) { 219 default: assert(0 && "Unknown binary operator"); 220 case Mul: return "*"; 221 case Div: return "/"; 222 case Rem: return "%"; 223 case Add: return "+"; 224 case Sub: return "-"; 225 case Shl: return "<<"; 226 case Shr: return ">>"; 227 case LT: return "<"; 228 case GT: return ">"; 229 case LE: return "<="; 230 case GE: return ">="; 231 case EQ: return "=="; 232 case NE: return "!="; 233 case And: return "&"; 234 case Xor: return "^"; 235 case Or: return "|"; 236 case LAnd: return "&&"; 237 case LOr: return "||"; 238 case Assign: return "="; 239 case MulAssign: return "*="; 240 case DivAssign: return "/="; 241 case RemAssign: return "%="; 242 case AddAssign: return "+="; 243 case SubAssign: return "-="; 244 case ShlAssign: return "<<="; 245 case ShrAssign: return ">>="; 246 case AndAssign: return "&="; 247 case XorAssign: return "^="; 248 case OrAssign: return "|="; 249 case Comma: return ","; 250 } 251} 252 253InitListExpr::InitListExpr(SourceLocation lbraceloc, 254 Expr **initexprs, unsigned numinits, 255 SourceLocation rbraceloc) 256 : Expr(InitListExprClass, QualType()), 257 LBraceLoc(lbraceloc), RBraceLoc(rbraceloc) 258{ 259 for (unsigned i = 0; i != numinits; i++) 260 InitExprs.push_back(initexprs[i]); 261} 262 263//===----------------------------------------------------------------------===// 264// Generic Expression Routines 265//===----------------------------------------------------------------------===// 266 267/// hasLocalSideEffect - Return true if this immediate expression has side 268/// effects, not counting any sub-expressions. 269bool Expr::hasLocalSideEffect() const { 270 switch (getStmtClass()) { 271 default: 272 return false; 273 case ParenExprClass: 274 return cast<ParenExpr>(this)->getSubExpr()->hasLocalSideEffect(); 275 case UnaryOperatorClass: { 276 const UnaryOperator *UO = cast<UnaryOperator>(this); 277 278 switch (UO->getOpcode()) { 279 default: return false; 280 case UnaryOperator::PostInc: 281 case UnaryOperator::PostDec: 282 case UnaryOperator::PreInc: 283 case UnaryOperator::PreDec: 284 return true; // ++/-- 285 286 case UnaryOperator::Deref: 287 // Dereferencing a volatile pointer is a side-effect. 288 return getType().isVolatileQualified(); 289 case UnaryOperator::Real: 290 case UnaryOperator::Imag: 291 // accessing a piece of a volatile complex is a side-effect. 292 return UO->getSubExpr()->getType().isVolatileQualified(); 293 294 case UnaryOperator::Extension: 295 return UO->getSubExpr()->hasLocalSideEffect(); 296 } 297 } 298 case BinaryOperatorClass: { 299 const BinaryOperator *BinOp = cast<BinaryOperator>(this); 300 // Consider comma to have side effects if the LHS and RHS both do. 301 if (BinOp->getOpcode() == BinaryOperator::Comma) 302 return BinOp->getLHS()->hasLocalSideEffect() && 303 BinOp->getRHS()->hasLocalSideEffect(); 304 305 return BinOp->isAssignmentOp(); 306 } 307 case CompoundAssignOperatorClass: 308 return true; 309 310 case ConditionalOperatorClass: { 311 const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 312 return Exp->getCond()->hasLocalSideEffect() 313 || (Exp->getLHS() && Exp->getLHS()->hasLocalSideEffect()) 314 || (Exp->getRHS() && Exp->getRHS()->hasLocalSideEffect()); 315 } 316 317 case MemberExprClass: 318 case ArraySubscriptExprClass: 319 // If the base pointer or element is to a volatile pointer/field, accessing 320 // if is a side effect. 321 return getType().isVolatileQualified(); 322 323 case CallExprClass: 324 // TODO: check attributes for pure/const. "void foo() { strlen("bar"); }" 325 // should warn. 326 return true; 327 case ObjCMessageExprClass: 328 return true; 329 case StmtExprClass: 330 // TODO: check the inside of the statement expression 331 return true; 332 333 case CastExprClass: 334 // If this is a cast to void, check the operand. Otherwise, the result of 335 // the cast is unused. 336 if (getType()->isVoidType()) 337 return cast<CastExpr>(this)->getSubExpr()->hasLocalSideEffect(); 338 return false; 339 340 case ImplicitCastExprClass: 341 // Check the operand, since implicit casts are inserted by Sema 342 return cast<ImplicitCastExpr>(this)->getSubExpr()->hasLocalSideEffect(); 343 344 case CXXDefaultArgExprClass: 345 return cast<CXXDefaultArgExpr>(this)->getExpr()->hasLocalSideEffect(); 346 } 347} 348 349/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an 350/// incomplete type other than void. Nonarray expressions that can be lvalues: 351/// - name, where name must be a variable 352/// - e[i] 353/// - (e), where e must be an lvalue 354/// - e.name, where e must be an lvalue 355/// - e->name 356/// - *e, the type of e cannot be a function type 357/// - string-constant 358/// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension] 359/// - reference type [C++ [expr]] 360/// 361Expr::isLvalueResult Expr::isLvalue() const { 362 // first, check the type (C99 6.3.2.1) 363 if (TR->isFunctionType()) // from isObjectType() 364 return LV_NotObjectType; 365 366 // Allow qualified void which is an incomplete type other than void (yuck). 367 if (TR->isVoidType() && !TR.getCanonicalType().getCVRQualifiers()) 368 return LV_IncompleteVoidType; 369 370 if (TR->isReferenceType()) // C++ [expr] 371 return LV_Valid; 372 373 // the type looks fine, now check the expression 374 switch (getStmtClass()) { 375 case StringLiteralClass: // C99 6.5.1p4 376 return LV_Valid; 377 case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2)))) 378 // For vectors, make sure base is an lvalue (i.e. not a function call). 379 if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType()) 380 return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(); 381 return LV_Valid; 382 case DeclRefExprClass: // C99 6.5.1p2 383 if (isa<VarDecl>(cast<DeclRefExpr>(this)->getDecl())) 384 return LV_Valid; 385 break; 386 case MemberExprClass: { // C99 6.5.2.3p4 387 const MemberExpr *m = cast<MemberExpr>(this); 388 return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(); 389 } 390 case UnaryOperatorClass: 391 if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref) 392 return LV_Valid; // C99 6.5.3p4 393 394 if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real || 395 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag) 396 return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(); // GNU. 397 break; 398 case ParenExprClass: // C99 6.5.1p5 399 return cast<ParenExpr>(this)->getSubExpr()->isLvalue(); 400 case CompoundLiteralExprClass: // C99 6.5.2.5p5 401 return LV_Valid; 402 case ExtVectorElementExprClass: 403 if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements()) 404 return LV_DuplicateVectorComponents; 405 return LV_Valid; 406 case ObjCIvarRefExprClass: // ObjC instance variables are lvalues. 407 return LV_Valid; 408 case ObjCPropertyRefExprClass: // FIXME: check if read-only property. 409 return LV_Valid; 410 case PreDefinedExprClass: 411 return LV_Valid; 412 case CXXDefaultArgExprClass: 413 return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(); 414 default: 415 break; 416 } 417 return LV_InvalidExpression; 418} 419 420/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, 421/// does not have an incomplete type, does not have a const-qualified type, and 422/// if it is a structure or union, does not have any member (including, 423/// recursively, any member or element of all contained aggregates or unions) 424/// with a const-qualified type. 425Expr::isModifiableLvalueResult Expr::isModifiableLvalue() const { 426 isLvalueResult lvalResult = isLvalue(); 427 428 switch (lvalResult) { 429 case LV_Valid: break; 430 case LV_NotObjectType: return MLV_NotObjectType; 431 case LV_IncompleteVoidType: return MLV_IncompleteVoidType; 432 case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents; 433 case LV_InvalidExpression: return MLV_InvalidExpression; 434 } 435 if (TR.isConstQualified()) 436 return MLV_ConstQualified; 437 if (TR->isArrayType()) 438 return MLV_ArrayType; 439 if (TR->isIncompleteType()) 440 return MLV_IncompleteType; 441 442 if (const RecordType *r = dyn_cast<RecordType>(TR.getCanonicalType())) { 443 if (r->hasConstFields()) 444 return MLV_ConstQualified; 445 } 446 return MLV_Valid; 447} 448 449/// hasGlobalStorage - Return true if this expression has static storage 450/// duration. This means that the address of this expression is a link-time 451/// constant. 452bool Expr::hasGlobalStorage() const { 453 switch (getStmtClass()) { 454 default: 455 return false; 456 case ParenExprClass: 457 return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage(); 458 case ImplicitCastExprClass: 459 return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage(); 460 case CompoundLiteralExprClass: 461 return cast<CompoundLiteralExpr>(this)->isFileScope(); 462 case DeclRefExprClass: { 463 const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 464 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 465 return VD->hasGlobalStorage(); 466 if (isa<FunctionDecl>(D)) 467 return true; 468 return false; 469 } 470 case MemberExprClass: { 471 const MemberExpr *M = cast<MemberExpr>(this); 472 return !M->isArrow() && M->getBase()->hasGlobalStorage(); 473 } 474 case ArraySubscriptExprClass: 475 return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage(); 476 case PreDefinedExprClass: 477 return true; 478 case CXXDefaultArgExprClass: 479 return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage(); 480 } 481} 482 483Expr* Expr::IgnoreParens() { 484 Expr* E = this; 485 while (ParenExpr* P = dyn_cast<ParenExpr>(E)) 486 E = P->getSubExpr(); 487 488 return E; 489} 490 491/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr 492/// or CastExprs or ImplicitCastExprs, returning their operand. 493Expr *Expr::IgnoreParenCasts() { 494 Expr *E = this; 495 while (true) { 496 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) 497 E = P->getSubExpr(); 498 else if (CastExpr *P = dyn_cast<CastExpr>(E)) 499 E = P->getSubExpr(); 500 else if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E)) 501 E = P->getSubExpr(); 502 else 503 return E; 504 } 505} 506 507 508bool Expr::isConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const { 509 switch (getStmtClass()) { 510 default: 511 if (Loc) *Loc = getLocStart(); 512 return false; 513 case ParenExprClass: 514 return cast<ParenExpr>(this)->getSubExpr()->isConstantExpr(Ctx, Loc); 515 case StringLiteralClass: 516 case ObjCStringLiteralClass: 517 case FloatingLiteralClass: 518 case IntegerLiteralClass: 519 case CharacterLiteralClass: 520 case ImaginaryLiteralClass: 521 case TypesCompatibleExprClass: 522 case CXXBoolLiteralExprClass: 523 return true; 524 case CallExprClass: { 525 const CallExpr *CE = cast<CallExpr>(this); 526 if (CE->isBuiltinConstantExpr()) 527 return true; 528 if (Loc) *Loc = getLocStart(); 529 return false; 530 } 531 case DeclRefExprClass: { 532 const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 533 // Accept address of function. 534 if (isa<EnumConstantDecl>(D) || isa<FunctionDecl>(D)) 535 return true; 536 if (Loc) *Loc = getLocStart(); 537 if (isa<VarDecl>(D)) 538 return TR->isArrayType(); 539 return false; 540 } 541 case CompoundLiteralExprClass: 542 if (Loc) *Loc = getLocStart(); 543 // Allow "(int []){2,4}", since the array will be converted to a pointer. 544 // Allow "(vector type){2,4}" since the elements are all constant. 545 return TR->isArrayType() || TR->isVectorType(); 546 case UnaryOperatorClass: { 547 const UnaryOperator *Exp = cast<UnaryOperator>(this); 548 549 // C99 6.6p9 550 if (Exp->getOpcode() == UnaryOperator::AddrOf) { 551 if (!Exp->getSubExpr()->hasGlobalStorage()) { 552 if (Loc) *Loc = getLocStart(); 553 return false; 554 } 555 return true; 556 } 557 558 // Get the operand value. If this is sizeof/alignof, do not evalute the 559 // operand. This affects C99 6.6p3. 560 if (!Exp->isSizeOfAlignOfOp() && 561 Exp->getOpcode() != UnaryOperator::OffsetOf && 562 !Exp->getSubExpr()->isConstantExpr(Ctx, Loc)) 563 return false; 564 565 switch (Exp->getOpcode()) { 566 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs. 567 // See C99 6.6p3. 568 default: 569 if (Loc) *Loc = Exp->getOperatorLoc(); 570 return false; 571 case UnaryOperator::Extension: 572 return true; // FIXME: this is wrong. 573 case UnaryOperator::SizeOf: 574 case UnaryOperator::AlignOf: 575 case UnaryOperator::OffsetOf: 576 // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2. 577 if (!Exp->getSubExpr()->getType()->isConstantSizeType()) { 578 if (Loc) *Loc = Exp->getOperatorLoc(); 579 return false; 580 } 581 return true; 582 case UnaryOperator::LNot: 583 case UnaryOperator::Plus: 584 case UnaryOperator::Minus: 585 case UnaryOperator::Not: 586 return true; 587 } 588 } 589 case SizeOfAlignOfTypeExprClass: { 590 const SizeOfAlignOfTypeExpr *Exp = cast<SizeOfAlignOfTypeExpr>(this); 591 // alignof always evaluates to a constant. 592 if (Exp->isSizeOf() && !Exp->getArgumentType()->isVoidType() && 593 !Exp->getArgumentType()->isConstantSizeType()) { 594 if (Loc) *Loc = Exp->getOperatorLoc(); 595 return false; 596 } 597 return true; 598 } 599 case BinaryOperatorClass: { 600 const BinaryOperator *Exp = cast<BinaryOperator>(this); 601 602 // The LHS of a constant expr is always evaluated and needed. 603 if (!Exp->getLHS()->isConstantExpr(Ctx, Loc)) 604 return false; 605 606 if (!Exp->getRHS()->isConstantExpr(Ctx, Loc)) 607 return false; 608 return true; 609 } 610 case ImplicitCastExprClass: 611 case CastExprClass: { 612 const Expr *SubExpr; 613 SourceLocation CastLoc; 614 if (const CastExpr *C = dyn_cast<CastExpr>(this)) { 615 SubExpr = C->getSubExpr(); 616 CastLoc = C->getLParenLoc(); 617 } else { 618 SubExpr = cast<ImplicitCastExpr>(this)->getSubExpr(); 619 CastLoc = getLocStart(); 620 } 621 if (!SubExpr->isConstantExpr(Ctx, Loc)) { 622 if (Loc) *Loc = SubExpr->getLocStart(); 623 return false; 624 } 625 return true; 626 } 627 case ConditionalOperatorClass: { 628 const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 629 if (!Exp->getCond()->isConstantExpr(Ctx, Loc) || 630 // Handle the GNU extension for missing LHS. 631 !(Exp->getLHS() && Exp->getLHS()->isConstantExpr(Ctx, Loc)) || 632 !Exp->getRHS()->isConstantExpr(Ctx, Loc)) 633 return false; 634 return true; 635 } 636 case InitListExprClass: { 637 const InitListExpr *Exp = cast<InitListExpr>(this); 638 unsigned numInits = Exp->getNumInits(); 639 for (unsigned i = 0; i < numInits; i++) { 640 if (!Exp->getInit(i)->isConstantExpr(Ctx, Loc)) { 641 if (Loc) *Loc = Exp->getInit(i)->getLocStart(); 642 return false; 643 } 644 } 645 return true; 646 } 647 case CXXDefaultArgExprClass: 648 return cast<CXXDefaultArgExpr>(this)->getExpr()->isConstantExpr(Ctx, Loc); 649 } 650} 651 652/// isIntegerConstantExpr - this recursive routine will test if an expression is 653/// an integer constant expression. Note: With the introduction of VLA's in 654/// C99 the result of the sizeof operator is no longer always a constant 655/// expression. The generalization of the wording to include any subexpression 656/// that is not evaluated (C99 6.6p3) means that nonconstant subexpressions 657/// can appear as operands to other operators (e.g. &&, ||, ?:). For instance, 658/// "0 || f()" can be treated as a constant expression. In C90 this expression, 659/// occurring in a context requiring a constant, would have been a constraint 660/// violation. FIXME: This routine currently implements C90 semantics. 661/// To properly implement C99 semantics this routine will need to evaluate 662/// expressions involving operators previously mentioned. 663 664/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero, 665/// comma, etc 666/// 667/// FIXME: This should ext-warn on overflow during evaluation! ISO C does not 668/// permit this. This includes things like (int)1e1000 669/// 670/// FIXME: Handle offsetof. Two things to do: Handle GCC's __builtin_offsetof 671/// to support gcc 4.0+ and handle the idiom GCC recognizes with a null pointer 672/// cast+dereference. 673bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, 674 SourceLocation *Loc, bool isEvaluated) const { 675 switch (getStmtClass()) { 676 default: 677 if (Loc) *Loc = getLocStart(); 678 return false; 679 case ParenExprClass: 680 return cast<ParenExpr>(this)->getSubExpr()-> 681 isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated); 682 case IntegerLiteralClass: 683 Result = cast<IntegerLiteral>(this)->getValue(); 684 break; 685 case CharacterLiteralClass: { 686 const CharacterLiteral *CL = cast<CharacterLiteral>(this); 687 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 688 Result = CL->getValue(); 689 Result.setIsUnsigned(!getType()->isSignedIntegerType()); 690 break; 691 } 692 case TypesCompatibleExprClass: { 693 const TypesCompatibleExpr *TCE = cast<TypesCompatibleExpr>(this); 694 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 695 Result = Ctx.typesAreCompatible(TCE->getArgType1(), TCE->getArgType2()); 696 break; 697 } 698 case CallExprClass: { 699 const CallExpr *CE = cast<CallExpr>(this); 700 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 701 if (CE->isBuiltinClassifyType(Result)) 702 break; 703 if (Loc) *Loc = getLocStart(); 704 return false; 705 } 706 case DeclRefExprClass: 707 if (const EnumConstantDecl *D = 708 dyn_cast<EnumConstantDecl>(cast<DeclRefExpr>(this)->getDecl())) { 709 Result = D->getInitVal(); 710 break; 711 } 712 if (Loc) *Loc = getLocStart(); 713 return false; 714 case UnaryOperatorClass: { 715 const UnaryOperator *Exp = cast<UnaryOperator>(this); 716 717 // Get the operand value. If this is sizeof/alignof, do not evalute the 718 // operand. This affects C99 6.6p3. 719 if (!Exp->isSizeOfAlignOfOp() && !Exp->isOffsetOfOp() && 720 !Exp->getSubExpr()->isIntegerConstantExpr(Result, Ctx, Loc,isEvaluated)) 721 return false; 722 723 switch (Exp->getOpcode()) { 724 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs. 725 // See C99 6.6p3. 726 default: 727 if (Loc) *Loc = Exp->getOperatorLoc(); 728 return false; 729 case UnaryOperator::Extension: 730 return true; // FIXME: this is wrong. 731 case UnaryOperator::SizeOf: 732 case UnaryOperator::AlignOf: 733 // Return the result in the right width. 734 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 735 736 // sizeof(void) and __alignof__(void) = 1 as a gcc extension. 737 if (Exp->getSubExpr()->getType()->isVoidType()) { 738 Result = 1; 739 break; 740 } 741 742 // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2. 743 if (!Exp->getSubExpr()->getType()->isConstantSizeType()) { 744 if (Loc) *Loc = Exp->getOperatorLoc(); 745 return false; 746 } 747 748 // Get information about the size or align. 749 if (Exp->getSubExpr()->getType()->isFunctionType()) { 750 // GCC extension: sizeof(function) = 1. 751 Result = Exp->getOpcode() == UnaryOperator::AlignOf ? 4 : 1; 752 } else { 753 unsigned CharSize = Ctx.Target.getCharWidth(); 754 if (Exp->getOpcode() == UnaryOperator::AlignOf) 755 Result = Ctx.getTypeAlign(Exp->getSubExpr()->getType()) / CharSize; 756 else 757 Result = Ctx.getTypeSize(Exp->getSubExpr()->getType()) / CharSize; 758 } 759 break; 760 case UnaryOperator::LNot: { 761 bool Val = Result == 0; 762 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 763 Result = Val; 764 break; 765 } 766 case UnaryOperator::Plus: 767 break; 768 case UnaryOperator::Minus: 769 Result = -Result; 770 break; 771 case UnaryOperator::Not: 772 Result = ~Result; 773 break; 774 case UnaryOperator::OffsetOf: 775 Result = Exp->evaluateOffsetOf(Ctx); 776 } 777 break; 778 } 779 case SizeOfAlignOfTypeExprClass: { 780 const SizeOfAlignOfTypeExpr *Exp = cast<SizeOfAlignOfTypeExpr>(this); 781 782 // Return the result in the right width. 783 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 784 785 // sizeof(void) and __alignof__(void) = 1 as a gcc extension. 786 if (Exp->getArgumentType()->isVoidType()) { 787 Result = 1; 788 break; 789 } 790 791 // alignof always evaluates to a constant, sizeof does if arg is not VLA. 792 if (Exp->isSizeOf() && !Exp->getArgumentType()->isConstantSizeType()) { 793 if (Loc) *Loc = Exp->getOperatorLoc(); 794 return false; 795 } 796 797 // Get information about the size or align. 798 if (Exp->getArgumentType()->isFunctionType()) { 799 // GCC extension: sizeof(function) = 1. 800 Result = Exp->isSizeOf() ? 1 : 4; 801 } else { 802 unsigned CharSize = Ctx.Target.getCharWidth(); 803 if (Exp->isSizeOf()) 804 Result = Ctx.getTypeSize(Exp->getArgumentType()) / CharSize; 805 else 806 Result = Ctx.getTypeAlign(Exp->getArgumentType()) / CharSize; 807 } 808 break; 809 } 810 case BinaryOperatorClass: { 811 const BinaryOperator *Exp = cast<BinaryOperator>(this); 812 813 // The LHS of a constant expr is always evaluated and needed. 814 if (!Exp->getLHS()->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 815 return false; 816 817 llvm::APSInt RHS(Result); 818 819 // The short-circuiting &&/|| operators don't necessarily evaluate their 820 // RHS. Make sure to pass isEvaluated down correctly. 821 if (Exp->isLogicalOp()) { 822 bool RHSEval; 823 if (Exp->getOpcode() == BinaryOperator::LAnd) 824 RHSEval = Result != 0; 825 else { 826 assert(Exp->getOpcode() == BinaryOperator::LOr &&"Unexpected logical"); 827 RHSEval = Result == 0; 828 } 829 830 if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc, 831 isEvaluated & RHSEval)) 832 return false; 833 } else { 834 if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc, isEvaluated)) 835 return false; 836 } 837 838 switch (Exp->getOpcode()) { 839 default: 840 if (Loc) *Loc = getLocStart(); 841 return false; 842 case BinaryOperator::Mul: 843 Result *= RHS; 844 break; 845 case BinaryOperator::Div: 846 if (RHS == 0) { 847 if (!isEvaluated) break; 848 if (Loc) *Loc = getLocStart(); 849 return false; 850 } 851 Result /= RHS; 852 break; 853 case BinaryOperator::Rem: 854 if (RHS == 0) { 855 if (!isEvaluated) break; 856 if (Loc) *Loc = getLocStart(); 857 return false; 858 } 859 Result %= RHS; 860 break; 861 case BinaryOperator::Add: Result += RHS; break; 862 case BinaryOperator::Sub: Result -= RHS; break; 863 case BinaryOperator::Shl: 864 Result <<= 865 static_cast<uint32_t>(RHS.getLimitedValue(Result.getBitWidth()-1)); 866 break; 867 case BinaryOperator::Shr: 868 Result >>= 869 static_cast<uint32_t>(RHS.getLimitedValue(Result.getBitWidth()-1)); 870 break; 871 case BinaryOperator::LT: Result = Result < RHS; break; 872 case BinaryOperator::GT: Result = Result > RHS; break; 873 case BinaryOperator::LE: Result = Result <= RHS; break; 874 case BinaryOperator::GE: Result = Result >= RHS; break; 875 case BinaryOperator::EQ: Result = Result == RHS; break; 876 case BinaryOperator::NE: Result = Result != RHS; break; 877 case BinaryOperator::And: Result &= RHS; break; 878 case BinaryOperator::Xor: Result ^= RHS; break; 879 case BinaryOperator::Or: Result |= RHS; break; 880 case BinaryOperator::LAnd: 881 Result = Result != 0 && RHS != 0; 882 break; 883 case BinaryOperator::LOr: 884 Result = Result != 0 || RHS != 0; 885 break; 886 887 case BinaryOperator::Comma: 888 // C99 6.6p3: "shall not contain assignment, ..., or comma operators, 889 // *except* when they are contained within a subexpression that is not 890 // evaluated". Note that Assignment can never happen due to constraints 891 // on the LHS subexpr, so we don't need to check it here. 892 if (isEvaluated) { 893 if (Loc) *Loc = getLocStart(); 894 return false; 895 } 896 897 // The result of the constant expr is the RHS. 898 Result = RHS; 899 return true; 900 } 901 902 assert(!Exp->isAssignmentOp() && "LHS can't be a constant expr!"); 903 break; 904 } 905 case ImplicitCastExprClass: 906 case CastExprClass: { 907 const Expr *SubExpr; 908 SourceLocation CastLoc; 909 if (const CastExpr *C = dyn_cast<CastExpr>(this)) { 910 SubExpr = C->getSubExpr(); 911 CastLoc = C->getLParenLoc(); 912 } else { 913 SubExpr = cast<ImplicitCastExpr>(this)->getSubExpr(); 914 CastLoc = getLocStart(); 915 } 916 917 // C99 6.6p6: shall only convert arithmetic types to integer types. 918 if (!SubExpr->getType()->isArithmeticType() || 919 !getType()->isIntegerType()) { 920 if (Loc) *Loc = SubExpr->getLocStart(); 921 return false; 922 } 923 924 uint32_t DestWidth = static_cast<uint32_t>(Ctx.getTypeSize(getType())); 925 926 // Handle simple integer->integer casts. 927 if (SubExpr->getType()->isIntegerType()) { 928 if (!SubExpr->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 929 return false; 930 931 // Figure out if this is a truncate, extend or noop cast. 932 // If the input is signed, do a sign extend, noop, or truncate. 933 if (getType()->isBooleanType()) { 934 // Conversion to bool compares against zero. 935 Result = Result != 0; 936 Result.zextOrTrunc(DestWidth); 937 } else if (SubExpr->getType()->isSignedIntegerType()) 938 Result.sextOrTrunc(DestWidth); 939 else // If the input is unsigned, do a zero extend, noop, or truncate. 940 Result.zextOrTrunc(DestWidth); 941 break; 942 } 943 944 // Allow floating constants that are the immediate operands of casts or that 945 // are parenthesized. 946 const Expr *Operand = SubExpr; 947 while (const ParenExpr *PE = dyn_cast<ParenExpr>(Operand)) 948 Operand = PE->getSubExpr(); 949 950 // If this isn't a floating literal, we can't handle it. 951 const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(Operand); 952 if (!FL) { 953 if (Loc) *Loc = Operand->getLocStart(); 954 return false; 955 } 956 957 // If the destination is boolean, compare against zero. 958 if (getType()->isBooleanType()) { 959 Result = !FL->getValue().isZero(); 960 Result.zextOrTrunc(DestWidth); 961 break; 962 } 963 964 // Determine whether we are converting to unsigned or signed. 965 bool DestSigned = getType()->isSignedIntegerType(); 966 967 // TODO: Warn on overflow, but probably not here: isIntegerConstantExpr can 968 // be called multiple times per AST. 969 uint64_t Space[4]; 970 (void)FL->getValue().convertToInteger(Space, DestWidth, DestSigned, 971 llvm::APFloat::rmTowardZero); 972 Result = llvm::APInt(DestWidth, 4, Space); 973 break; 974 } 975 case ConditionalOperatorClass: { 976 const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 977 978 if (!Exp->getCond()->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 979 return false; 980 981 const Expr *TrueExp = Exp->getLHS(); 982 const Expr *FalseExp = Exp->getRHS(); 983 if (Result == 0) std::swap(TrueExp, FalseExp); 984 985 // Evaluate the false one first, discard the result. 986 if (FalseExp && !FalseExp->isIntegerConstantExpr(Result, Ctx, Loc, false)) 987 return false; 988 // Evalute the true one, capture the result. 989 if (TrueExp && 990 !TrueExp->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 991 return false; 992 break; 993 } 994 case CXXDefaultArgExprClass: 995 return cast<CXXDefaultArgExpr>(this) 996 ->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated); 997 } 998 999 // Cases that are valid constant exprs fall through to here. 1000 Result.setIsUnsigned(getType()->isUnsignedIntegerType()); 1001 return true; 1002} 1003 1004/// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an 1005/// integer constant expression with the value zero, or if this is one that is 1006/// cast to void*. 1007bool Expr::isNullPointerConstant(ASTContext &Ctx) const { 1008 // Strip off a cast to void*, if it exists. 1009 if (const CastExpr *CE = dyn_cast<CastExpr>(this)) { 1010 // Check that it is a cast to void*. 1011 if (const PointerType *PT = CE->getType()->getAsPointerType()) { 1012 QualType Pointee = PT->getPointeeType(); 1013 if (Pointee.getCVRQualifiers() == 0 && 1014 Pointee->isVoidType() && // to void* 1015 CE->getSubExpr()->getType()->isIntegerType()) // from int. 1016 return CE->getSubExpr()->isNullPointerConstant(Ctx); 1017 } 1018 } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) { 1019 // Ignore the ImplicitCastExpr type entirely. 1020 return ICE->getSubExpr()->isNullPointerConstant(Ctx); 1021 } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) { 1022 // Accept ((void*)0) as a null pointer constant, as many other 1023 // implementations do. 1024 return PE->getSubExpr()->isNullPointerConstant(Ctx); 1025 } else if (const CXXDefaultArgExpr *DefaultArg 1026 = dyn_cast<CXXDefaultArgExpr>(this)) { 1027 // See through default argument expressions 1028 return DefaultArg->getExpr()->isNullPointerConstant(Ctx); 1029 } 1030 1031 // This expression must be an integer type. 1032 if (!getType()->isIntegerType()) 1033 return false; 1034 1035 // If we have an integer constant expression, we need to *evaluate* it and 1036 // test for the value 0. 1037 llvm::APSInt Val(32); 1038 return isIntegerConstantExpr(Val, Ctx, 0, true) && Val == 0; 1039} 1040 1041unsigned ExtVectorElementExpr::getNumElements() const { 1042 if (const VectorType *VT = getType()->getAsVectorType()) 1043 return VT->getNumElements(); 1044 return 1; 1045} 1046 1047/// containsDuplicateElements - Return true if any element access is repeated. 1048bool ExtVectorElementExpr::containsDuplicateElements() const { 1049 const char *compStr = Accessor.getName(); 1050 unsigned length = strlen(compStr); 1051 1052 for (unsigned i = 0; i < length-1; i++) { 1053 const char *s = compStr+i; 1054 for (const char c = *s++; *s; s++) 1055 if (c == *s) 1056 return true; 1057 } 1058 return false; 1059} 1060 1061/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 1062void ExtVectorElementExpr::getEncodedElementAccess( 1063 llvm::SmallVectorImpl<unsigned> &Elts) const { 1064 const char *compStr = Accessor.getName(); 1065 1066 bool isHi = !strcmp(compStr, "hi"); 1067 bool isLo = !strcmp(compStr, "lo"); 1068 bool isEven = !strcmp(compStr, "e"); 1069 bool isOdd = !strcmp(compStr, "o"); 1070 1071 for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 1072 uint64_t Index; 1073 1074 if (isHi) 1075 Index = e + i; 1076 else if (isLo) 1077 Index = i; 1078 else if (isEven) 1079 Index = 2 * i; 1080 else if (isOdd) 1081 Index = 2 * i + 1; 1082 else 1083 Index = ExtVectorType::getAccessorIdx(compStr[i]); 1084 1085 Elts.push_back(Index); 1086 } 1087} 1088 1089// constructor for instance messages. 1090ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo, 1091 QualType retType, ObjCMethodDecl *mproto, 1092 SourceLocation LBrac, SourceLocation RBrac, 1093 Expr **ArgExprs, unsigned nargs) 1094 : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1095 MethodProto(mproto) { 1096 NumArgs = nargs; 1097 SubExprs = new Expr*[NumArgs+1]; 1098 SubExprs[RECEIVER] = receiver; 1099 if (NumArgs) { 1100 for (unsigned i = 0; i != NumArgs; ++i) 1101 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 1102 } 1103 LBracloc = LBrac; 1104 RBracloc = RBrac; 1105} 1106 1107// constructor for class messages. 1108// FIXME: clsName should be typed to ObjCInterfaceType 1109ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo, 1110 QualType retType, ObjCMethodDecl *mproto, 1111 SourceLocation LBrac, SourceLocation RBrac, 1112 Expr **ArgExprs, unsigned nargs) 1113 : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1114 MethodProto(mproto) { 1115 NumArgs = nargs; 1116 SubExprs = new Expr*[NumArgs+1]; 1117 SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | 0x1); 1118 if (NumArgs) { 1119 for (unsigned i = 0; i != NumArgs; ++i) 1120 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 1121 } 1122 LBracloc = LBrac; 1123 RBracloc = RBrac; 1124} 1125 1126bool ChooseExpr::isConditionTrue(ASTContext &C) const { 1127 llvm::APSInt CondVal(32); 1128 bool IsConst = getCond()->isIntegerConstantExpr(CondVal, C); 1129 assert(IsConst && "Condition of choose expr must be i-c-e"); IsConst=IsConst; 1130 return CondVal != 0; 1131} 1132 1133static int64_t evaluateOffsetOf(ASTContext& C, const Expr *E) 1134{ 1135 if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 1136 QualType Ty = ME->getBase()->getType(); 1137 1138 RecordDecl *RD = Ty->getAsRecordType()->getDecl(); 1139 const ASTRecordLayout &RL = C.getASTRecordLayout(RD); 1140 FieldDecl *FD = ME->getMemberDecl(); 1141 1142 // FIXME: This is linear time. 1143 unsigned i = 0, e = 0; 1144 for (i = 0, e = RD->getNumMembers(); i != e; i++) { 1145 if (RD->getMember(i) == FD) 1146 break; 1147 } 1148 1149 return RL.getFieldOffset(i) + evaluateOffsetOf(C, ME->getBase()); 1150 } else if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) { 1151 const Expr *Base = ASE->getBase(); 1152 llvm::APSInt Idx(32); 1153 bool ICE = ASE->getIdx()->isIntegerConstantExpr(Idx, C); 1154 assert(ICE && "Array index is not a constant integer!"); 1155 1156 int64_t size = C.getTypeSize(ASE->getType()); 1157 size *= Idx.getSExtValue(); 1158 1159 return size + evaluateOffsetOf(C, Base); 1160 } else if (isa<CompoundLiteralExpr>(E)) 1161 return 0; 1162 1163 assert(0 && "Unknown offsetof subexpression!"); 1164 return 0; 1165} 1166 1167int64_t UnaryOperator::evaluateOffsetOf(ASTContext& C) const 1168{ 1169 assert(Opc == OffsetOf && "Unary operator not offsetof!"); 1170 1171 unsigned CharSize = C.Target.getCharWidth(); 1172 return ::evaluateOffsetOf(C, Val) / CharSize; 1173} 1174 1175//===----------------------------------------------------------------------===// 1176// Child Iterators for iterating over subexpressions/substatements 1177//===----------------------------------------------------------------------===// 1178 1179// DeclRefExpr 1180Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); } 1181Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); } 1182 1183// ObjCIvarRefExpr 1184Stmt::child_iterator ObjCIvarRefExpr::child_begin() { 1185 return reinterpret_cast<Stmt**>(&Base); 1186} 1187 1188Stmt::child_iterator ObjCIvarRefExpr::child_end() { 1189 return reinterpret_cast<Stmt**>(&Base)+1; 1190} 1191 1192// ObjCPropertyRefExpr 1193Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { 1194 return reinterpret_cast<Stmt**>(&Base); 1195} 1196 1197Stmt::child_iterator ObjCPropertyRefExpr::child_end() { 1198 return reinterpret_cast<Stmt**>(&Base)+1; 1199} 1200 1201// ObjCSuperRefExpr 1202Stmt::child_iterator ObjCSuperRefExpr::child_begin() { return child_iterator();} 1203Stmt::child_iterator ObjCSuperRefExpr::child_end() { return child_iterator(); } 1204 1205// PreDefinedExpr 1206Stmt::child_iterator PreDefinedExpr::child_begin() { return child_iterator(); } 1207Stmt::child_iterator PreDefinedExpr::child_end() { return child_iterator(); } 1208 1209// IntegerLiteral 1210Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); } 1211Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); } 1212 1213// CharacterLiteral 1214Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator(); } 1215Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); } 1216 1217// FloatingLiteral 1218Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); } 1219Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); } 1220 1221// ImaginaryLiteral 1222Stmt::child_iterator ImaginaryLiteral::child_begin() { 1223 return reinterpret_cast<Stmt**>(&Val); 1224} 1225Stmt::child_iterator ImaginaryLiteral::child_end() { 1226 return reinterpret_cast<Stmt**>(&Val)+1; 1227} 1228 1229// StringLiteral 1230Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); } 1231Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); } 1232 1233// ParenExpr 1234Stmt::child_iterator ParenExpr::child_begin() { 1235 return reinterpret_cast<Stmt**>(&Val); 1236} 1237Stmt::child_iterator ParenExpr::child_end() { 1238 return reinterpret_cast<Stmt**>(&Val)+1; 1239} 1240 1241// UnaryOperator 1242Stmt::child_iterator UnaryOperator::child_begin() { 1243 return reinterpret_cast<Stmt**>(&Val); 1244} 1245Stmt::child_iterator UnaryOperator::child_end() { 1246 return reinterpret_cast<Stmt**>(&Val+1); 1247} 1248 1249// SizeOfAlignOfTypeExpr 1250Stmt::child_iterator SizeOfAlignOfTypeExpr::child_begin() { 1251 // If the type is a VLA type (and not a typedef), the size expression of the 1252 // VLA needs to be treated as an executable expression. 1253 if (VariableArrayType* T = dyn_cast<VariableArrayType>(Ty.getTypePtr())) 1254 return child_iterator(T); 1255 else 1256 return child_iterator(); 1257} 1258Stmt::child_iterator SizeOfAlignOfTypeExpr::child_end() { 1259 return child_iterator(); 1260} 1261 1262// ArraySubscriptExpr 1263Stmt::child_iterator ArraySubscriptExpr::child_begin() { 1264 return reinterpret_cast<Stmt**>(&SubExprs); 1265} 1266Stmt::child_iterator ArraySubscriptExpr::child_end() { 1267 return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR; 1268} 1269 1270// CallExpr 1271Stmt::child_iterator CallExpr::child_begin() { 1272 return reinterpret_cast<Stmt**>(&SubExprs[0]); 1273} 1274Stmt::child_iterator CallExpr::child_end() { 1275 return reinterpret_cast<Stmt**>(&SubExprs[NumArgs+ARGS_START]); 1276} 1277 1278// MemberExpr 1279Stmt::child_iterator MemberExpr::child_begin() { 1280 return reinterpret_cast<Stmt**>(&Base); 1281} 1282Stmt::child_iterator MemberExpr::child_end() { 1283 return reinterpret_cast<Stmt**>(&Base)+1; 1284} 1285 1286// ExtVectorElementExpr 1287Stmt::child_iterator ExtVectorElementExpr::child_begin() { 1288 return reinterpret_cast<Stmt**>(&Base); 1289} 1290Stmt::child_iterator ExtVectorElementExpr::child_end() { 1291 return reinterpret_cast<Stmt**>(&Base)+1; 1292} 1293 1294// CompoundLiteralExpr 1295Stmt::child_iterator CompoundLiteralExpr::child_begin() { 1296 return reinterpret_cast<Stmt**>(&Init); 1297} 1298Stmt::child_iterator CompoundLiteralExpr::child_end() { 1299 return reinterpret_cast<Stmt**>(&Init)+1; 1300} 1301 1302// ImplicitCastExpr 1303Stmt::child_iterator ImplicitCastExpr::child_begin() { 1304 return reinterpret_cast<Stmt**>(&Op); 1305} 1306Stmt::child_iterator ImplicitCastExpr::child_end() { 1307 return reinterpret_cast<Stmt**>(&Op)+1; 1308} 1309 1310// CastExpr 1311Stmt::child_iterator CastExpr::child_begin() { 1312 return reinterpret_cast<Stmt**>(&Op); 1313} 1314Stmt::child_iterator CastExpr::child_end() { 1315 return reinterpret_cast<Stmt**>(&Op)+1; 1316} 1317 1318// BinaryOperator 1319Stmt::child_iterator BinaryOperator::child_begin() { 1320 return reinterpret_cast<Stmt**>(&SubExprs); 1321} 1322Stmt::child_iterator BinaryOperator::child_end() { 1323 return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR; 1324} 1325 1326// ConditionalOperator 1327Stmt::child_iterator ConditionalOperator::child_begin() { 1328 return reinterpret_cast<Stmt**>(&SubExprs); 1329} 1330Stmt::child_iterator ConditionalOperator::child_end() { 1331 return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR; 1332} 1333 1334// AddrLabelExpr 1335Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); } 1336Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); } 1337 1338// StmtExpr 1339Stmt::child_iterator StmtExpr::child_begin() { 1340 return reinterpret_cast<Stmt**>(&SubStmt); 1341} 1342Stmt::child_iterator StmtExpr::child_end() { 1343 return reinterpret_cast<Stmt**>(&SubStmt)+1; 1344} 1345 1346// TypesCompatibleExpr 1347Stmt::child_iterator TypesCompatibleExpr::child_begin() { 1348 return child_iterator(); 1349} 1350 1351Stmt::child_iterator TypesCompatibleExpr::child_end() { 1352 return child_iterator(); 1353} 1354 1355// ChooseExpr 1356Stmt::child_iterator ChooseExpr::child_begin() { 1357 return reinterpret_cast<Stmt**>(&SubExprs); 1358} 1359 1360Stmt::child_iterator ChooseExpr::child_end() { 1361 return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR; 1362} 1363 1364// OverloadExpr 1365Stmt::child_iterator OverloadExpr::child_begin() { 1366 return reinterpret_cast<Stmt**>(&SubExprs[0]); 1367} 1368Stmt::child_iterator OverloadExpr::child_end() { 1369 return reinterpret_cast<Stmt**>(&SubExprs[NumExprs]); 1370} 1371 1372// ShuffleVectorExpr 1373Stmt::child_iterator ShuffleVectorExpr::child_begin() { 1374 return reinterpret_cast<Stmt**>(&SubExprs[0]); 1375} 1376Stmt::child_iterator ShuffleVectorExpr::child_end() { 1377 return reinterpret_cast<Stmt**>(&SubExprs[NumExprs]); 1378} 1379 1380// VAArgExpr 1381Stmt::child_iterator VAArgExpr::child_begin() { 1382 return reinterpret_cast<Stmt**>(&Val); 1383} 1384 1385Stmt::child_iterator VAArgExpr::child_end() { 1386 return reinterpret_cast<Stmt**>(&Val)+1; 1387} 1388 1389// InitListExpr 1390Stmt::child_iterator InitListExpr::child_begin() { 1391 return reinterpret_cast<Stmt**>(InitExprs.size() ? 1392 &InitExprs[0] : 0); 1393} 1394Stmt::child_iterator InitListExpr::child_end() { 1395 return reinterpret_cast<Stmt**>(InitExprs.size() ? 1396 &InitExprs[0] + InitExprs.size() : 0); 1397} 1398 1399// ObjCStringLiteral 1400Stmt::child_iterator ObjCStringLiteral::child_begin() { 1401 return child_iterator(); 1402} 1403Stmt::child_iterator ObjCStringLiteral::child_end() { 1404 return child_iterator(); 1405} 1406 1407// ObjCEncodeExpr 1408Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); } 1409Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); } 1410 1411// ObjCSelectorExpr 1412Stmt::child_iterator ObjCSelectorExpr::child_begin() { 1413 return child_iterator(); 1414} 1415Stmt::child_iterator ObjCSelectorExpr::child_end() { 1416 return child_iterator(); 1417} 1418 1419// ObjCProtocolExpr 1420Stmt::child_iterator ObjCProtocolExpr::child_begin() { 1421 return child_iterator(); 1422} 1423Stmt::child_iterator ObjCProtocolExpr::child_end() { 1424 return child_iterator(); 1425} 1426 1427// ObjCMessageExpr 1428Stmt::child_iterator ObjCMessageExpr::child_begin() { 1429 return reinterpret_cast<Stmt**>(&SubExprs[ getReceiver() ? 0 : ARGS_START ]); 1430} 1431Stmt::child_iterator ObjCMessageExpr::child_end() { 1432 return reinterpret_cast<Stmt**>(&SubExprs[getNumArgs()+ARGS_START]); 1433} 1434 1435