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