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