Expr.cpp revision d38617c8a50f9729c254ab76cd359af797c6739b
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" 20#include "llvm/DerivedTypes.h" 21using namespace clang; 22 23//===----------------------------------------------------------------------===// 24// Primary Expressions. 25//===----------------------------------------------------------------------===// 26 27StringLiteral::StringLiteral(const char *strData, unsigned byteLength, 28 bool Wide, QualType t, SourceLocation firstLoc, 29 SourceLocation lastLoc) : 30 Expr(StringLiteralClass, t) { 31 // OPTIMIZE: could allocate this appended to the StringLiteral. 32 char *AStrData = new char[byteLength]; 33 memcpy(AStrData, strData, byteLength); 34 StrData = AStrData; 35 ByteLength = byteLength; 36 IsWide = Wide; 37 firstTokLoc = firstLoc; 38 lastTokLoc = lastLoc; 39} 40 41StringLiteral::~StringLiteral() { 42 delete[] StrData; 43} 44 45bool UnaryOperator::isPostfix(Opcode Op) { 46 switch (Op) { 47 case PostInc: 48 case PostDec: 49 return true; 50 default: 51 return false; 52 } 53} 54 55/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 56/// corresponds to, e.g. "sizeof" or "[pre]++". 57const char *UnaryOperator::getOpcodeStr(Opcode Op) { 58 switch (Op) { 59 default: assert(0 && "Unknown unary operator"); 60 case PostInc: return "++"; 61 case PostDec: return "--"; 62 case PreInc: return "++"; 63 case PreDec: return "--"; 64 case AddrOf: return "&"; 65 case Deref: return "*"; 66 case Plus: return "+"; 67 case Minus: return "-"; 68 case Not: return "~"; 69 case LNot: return "!"; 70 case Real: return "__real"; 71 case Imag: return "__imag"; 72 case SizeOf: return "sizeof"; 73 case AlignOf: return "alignof"; 74 case Extension: return "__extension__"; 75 case OffsetOf: return "__builtin_offsetof"; 76 } 77} 78 79//===----------------------------------------------------------------------===// 80// Postfix Operators. 81//===----------------------------------------------------------------------===// 82 83 84CallExpr::CallExpr(Expr *fn, Expr **args, unsigned numargs, QualType t, 85 SourceLocation rparenloc) 86 : Expr(CallExprClass, t), NumArgs(numargs) { 87 SubExprs = new Expr*[numargs+1]; 88 SubExprs[FN] = fn; 89 for (unsigned i = 0; i != numargs; ++i) 90 SubExprs[i+ARGS_START] = args[i]; 91 RParenLoc = rparenloc; 92} 93 94/// setNumArgs - This changes the number of arguments present in this call. 95/// Any orphaned expressions are deleted by this, and any new operands are set 96/// to null. 97void CallExpr::setNumArgs(unsigned NumArgs) { 98 // No change, just return. 99 if (NumArgs == getNumArgs()) return; 100 101 // If shrinking # arguments, just delete the extras and forgot them. 102 if (NumArgs < getNumArgs()) { 103 for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i) 104 delete getArg(i); 105 this->NumArgs = NumArgs; 106 return; 107 } 108 109 // Otherwise, we are growing the # arguments. New an bigger argument array. 110 Expr **NewSubExprs = new Expr*[NumArgs+1]; 111 // Copy over args. 112 for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i) 113 NewSubExprs[i] = SubExprs[i]; 114 // Null out new args. 115 for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i) 116 NewSubExprs[i] = 0; 117 118 delete[] SubExprs; 119 SubExprs = NewSubExprs; 120 this->NumArgs = NumArgs; 121} 122 123bool CallExpr::isBuiltinConstantExpr() const { 124 // All simple function calls (e.g. func()) are implicitly cast to pointer to 125 // function. As a result, we try and obtain the DeclRefExpr from the 126 // ImplicitCastExpr. 127 const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 128 if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 129 return false; 130 131 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 132 if (!DRE) 133 return false; 134 135 const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 136 if (!FDecl) 137 return false; 138 139 unsigned builtinID = FDecl->getIdentifier()->getBuiltinID(); 140 if (!builtinID) 141 return false; 142 143 // We have a builtin that is a constant expression 144 if (builtinID == Builtin::BI__builtin___CFStringMakeConstantString) 145 return true; 146 return false; 147} 148 149bool CallExpr::isBuiltinClassifyType(llvm::APSInt &Result) const { 150 // The following enum mimics gcc's internal "typeclass.h" file. 151 enum gcc_type_class { 152 no_type_class = -1, 153 void_type_class, integer_type_class, char_type_class, 154 enumeral_type_class, boolean_type_class, 155 pointer_type_class, reference_type_class, offset_type_class, 156 real_type_class, complex_type_class, 157 function_type_class, method_type_class, 158 record_type_class, union_type_class, 159 array_type_class, string_type_class, 160 lang_type_class 161 }; 162 Result.setIsSigned(true); 163 164 // All simple function calls (e.g. func()) are implicitly cast to pointer to 165 // function. As a result, we try and obtain the DeclRefExpr from the 166 // ImplicitCastExpr. 167 const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 168 if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 169 return false; 170 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 171 if (!DRE) 172 return false; 173 174 // We have a DeclRefExpr. 175 if (strcmp(DRE->getDecl()->getName(), "__builtin_classify_type") == 0) { 176 // If no argument was supplied, default to "no_type_class". This isn't 177 // ideal, however it's what gcc does. 178 Result = static_cast<uint64_t>(no_type_class); 179 if (NumArgs >= 1) { 180 QualType argType = getArg(0)->getType(); 181 182 if (argType->isVoidType()) 183 Result = void_type_class; 184 else if (argType->isEnumeralType()) 185 Result = enumeral_type_class; 186 else if (argType->isBooleanType()) 187 Result = boolean_type_class; 188 else if (argType->isCharType()) 189 Result = string_type_class; // gcc doesn't appear to use char_type_class 190 else if (argType->isIntegerType()) 191 Result = integer_type_class; 192 else if (argType->isPointerType()) 193 Result = pointer_type_class; 194 else if (argType->isReferenceType()) 195 Result = reference_type_class; 196 else if (argType->isRealType()) 197 Result = real_type_class; 198 else if (argType->isComplexType()) 199 Result = complex_type_class; 200 else if (argType->isFunctionType()) 201 Result = function_type_class; 202 else if (argType->isStructureType()) 203 Result = record_type_class; 204 else if (argType->isUnionType()) 205 Result = union_type_class; 206 else if (argType->isArrayType()) 207 Result = array_type_class; 208 else if (argType->isUnionType()) 209 Result = union_type_class; 210 else // FIXME: offset_type_class, method_type_class, & lang_type_class? 211 assert(0 && "CallExpr::isBuiltinClassifyType(): unimplemented type"); 212 } 213 return true; 214 } 215 return false; 216} 217 218/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 219/// corresponds to, e.g. "<<=". 220const char *BinaryOperator::getOpcodeStr(Opcode Op) { 221 switch (Op) { 222 default: assert(0 && "Unknown binary operator"); 223 case Mul: return "*"; 224 case Div: return "/"; 225 case Rem: return "%"; 226 case Add: return "+"; 227 case Sub: return "-"; 228 case Shl: return "<<"; 229 case Shr: return ">>"; 230 case LT: return "<"; 231 case GT: return ">"; 232 case LE: return "<="; 233 case GE: return ">="; 234 case EQ: return "=="; 235 case NE: return "!="; 236 case And: return "&"; 237 case Xor: return "^"; 238 case Or: return "|"; 239 case LAnd: return "&&"; 240 case LOr: return "||"; 241 case Assign: return "="; 242 case MulAssign: return "*="; 243 case DivAssign: return "/="; 244 case RemAssign: return "%="; 245 case AddAssign: return "+="; 246 case SubAssign: return "-="; 247 case ShlAssign: return "<<="; 248 case ShrAssign: return ">>="; 249 case AndAssign: return "&="; 250 case XorAssign: return "^="; 251 case OrAssign: return "|="; 252 case Comma: return ","; 253 } 254} 255 256InitListExpr::InitListExpr(SourceLocation lbraceloc, 257 Expr **initexprs, unsigned numinits, 258 SourceLocation rbraceloc) 259 : Expr(InitListExprClass, QualType()), 260 LBraceLoc(lbraceloc), RBraceLoc(rbraceloc) 261{ 262 for (unsigned i = 0; i != numinits; i++) 263 InitExprs.push_back(initexprs[i]); 264} 265 266//===----------------------------------------------------------------------===// 267// Generic Expression Routines 268//===----------------------------------------------------------------------===// 269 270/// hasLocalSideEffect - Return true if this immediate expression has side 271/// effects, not counting any sub-expressions. 272bool Expr::hasLocalSideEffect() const { 273 switch (getStmtClass()) { 274 default: 275 return false; 276 case ParenExprClass: 277 return cast<ParenExpr>(this)->getSubExpr()->hasLocalSideEffect(); 278 case UnaryOperatorClass: { 279 const UnaryOperator *UO = cast<UnaryOperator>(this); 280 281 switch (UO->getOpcode()) { 282 default: return false; 283 case UnaryOperator::PostInc: 284 case UnaryOperator::PostDec: 285 case UnaryOperator::PreInc: 286 case UnaryOperator::PreDec: 287 return true; // ++/-- 288 289 case UnaryOperator::Deref: 290 // Dereferencing a volatile pointer is a side-effect. 291 return getType().isVolatileQualified(); 292 case UnaryOperator::Real: 293 case UnaryOperator::Imag: 294 // accessing a piece of a volatile complex is a side-effect. 295 return UO->getSubExpr()->getType().isVolatileQualified(); 296 297 case UnaryOperator::Extension: 298 return UO->getSubExpr()->hasLocalSideEffect(); 299 } 300 } 301 case BinaryOperatorClass: { 302 const BinaryOperator *BinOp = cast<BinaryOperator>(this); 303 // Consider comma to have side effects if the LHS and RHS both do. 304 if (BinOp->getOpcode() == BinaryOperator::Comma) 305 return BinOp->getLHS()->hasLocalSideEffect() && 306 BinOp->getRHS()->hasLocalSideEffect(); 307 308 return BinOp->isAssignmentOp(); 309 } 310 case CompoundAssignOperatorClass: 311 return true; 312 313 case ConditionalOperatorClass: { 314 const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 315 return Exp->getCond()->hasLocalSideEffect() 316 || (Exp->getLHS() && Exp->getLHS()->hasLocalSideEffect()) 317 || (Exp->getRHS() && Exp->getRHS()->hasLocalSideEffect()); 318 } 319 320 case MemberExprClass: 321 case ArraySubscriptExprClass: 322 // If the base pointer or element is to a volatile pointer/field, accessing 323 // if is a side effect. 324 return getType().isVolatileQualified(); 325 326 case CallExprClass: 327 // TODO: check attributes for pure/const. "void foo() { strlen("bar"); }" 328 // should warn. 329 return true; 330 case ObjCMessageExprClass: 331 return true; 332 333 case CastExprClass: 334 // If this is a cast to void, check the operand. Otherwise, the result of 335 // the cast is unused. 336 if (getType()->isVoidType()) 337 return cast<CastExpr>(this)->getSubExpr()->hasLocalSideEffect(); 338 return false; 339 340 case CXXDefaultArgExprClass: 341 return cast<CXXDefaultArgExpr>(this)->getExpr()->hasLocalSideEffect(); 342 } 343} 344 345/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an 346/// incomplete type other than void. Nonarray expressions that can be lvalues: 347/// - name, where name must be a variable 348/// - e[i] 349/// - (e), where e must be an lvalue 350/// - e.name, where e must be an lvalue 351/// - e->name 352/// - *e, the type of e cannot be a function type 353/// - string-constant 354/// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension] 355/// - reference type [C++ [expr]] 356/// 357Expr::isLvalueResult Expr::isLvalue() const { 358 // first, check the type (C99 6.3.2.1) 359 if (TR->isFunctionType()) // from isObjectType() 360 return LV_NotObjectType; 361 362 // Allow qualified void which is an incomplete type other than void (yuck). 363 if (TR->isVoidType() && !TR.getCanonicalType().getCVRQualifiers()) 364 return LV_IncompleteVoidType; 365 366 if (TR->isReferenceType()) // C++ [expr] 367 return LV_Valid; 368 369 // the type looks fine, now check the expression 370 switch (getStmtClass()) { 371 case StringLiteralClass: // C99 6.5.1p4 372 return LV_Valid; 373 case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2)))) 374 // For vectors, make sure base is an lvalue (i.e. not a function call). 375 if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType()) 376 return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(); 377 return LV_Valid; 378 case DeclRefExprClass: // C99 6.5.1p2 379 if (isa<VarDecl>(cast<DeclRefExpr>(this)->getDecl())) 380 return LV_Valid; 381 break; 382 case MemberExprClass: { // C99 6.5.2.3p4 383 const MemberExpr *m = cast<MemberExpr>(this); 384 return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(); 385 } 386 case UnaryOperatorClass: 387 if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref) 388 return LV_Valid; // C99 6.5.3p4 389 390 if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real || 391 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag) 392 return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(); // GNU. 393 break; 394 case ParenExprClass: // C99 6.5.1p5 395 return cast<ParenExpr>(this)->getSubExpr()->isLvalue(); 396 case CompoundLiteralExprClass: // C99 6.5.2.5p5 397 return LV_Valid; 398 case ExtVectorElementExprClass: 399 if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements()) 400 return LV_DuplicateVectorComponents; 401 return LV_Valid; 402 case ObjCIvarRefExprClass: // ObjC instance variables are lvalues. 403 return LV_Valid; 404 case PreDefinedExprClass: 405 return LV_Valid; 406 case CXXDefaultArgExprClass: 407 return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(); 408 default: 409 break; 410 } 411 return LV_InvalidExpression; 412} 413 414/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, 415/// does not have an incomplete type, does not have a const-qualified type, and 416/// if it is a structure or union, does not have any member (including, 417/// recursively, any member or element of all contained aggregates or unions) 418/// with a const-qualified type. 419Expr::isModifiableLvalueResult Expr::isModifiableLvalue() const { 420 isLvalueResult lvalResult = isLvalue(); 421 422 switch (lvalResult) { 423 case LV_Valid: break; 424 case LV_NotObjectType: return MLV_NotObjectType; 425 case LV_IncompleteVoidType: return MLV_IncompleteVoidType; 426 case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents; 427 case LV_InvalidExpression: return MLV_InvalidExpression; 428 } 429 if (TR.isConstQualified()) 430 return MLV_ConstQualified; 431 if (TR->isArrayType()) 432 return MLV_ArrayType; 433 if (TR->isIncompleteType()) 434 return MLV_IncompleteType; 435 436 if (const RecordType *r = dyn_cast<RecordType>(TR.getCanonicalType())) { 437 if (r->hasConstFields()) 438 return MLV_ConstQualified; 439 } 440 return MLV_Valid; 441} 442 443/// hasGlobalStorage - Return true if this expression has static storage 444/// duration. This means that the address of this expression is a link-time 445/// constant. 446bool Expr::hasGlobalStorage() const { 447 switch (getStmtClass()) { 448 default: 449 return false; 450 case ParenExprClass: 451 return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage(); 452 case ImplicitCastExprClass: 453 return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage(); 454 case CompoundLiteralExprClass: 455 return cast<CompoundLiteralExpr>(this)->isFileScope(); 456 case DeclRefExprClass: { 457 const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 458 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 459 return VD->hasGlobalStorage(); 460 if (isa<FunctionDecl>(D)) 461 return true; 462 return false; 463 } 464 case MemberExprClass: { 465 const MemberExpr *M = cast<MemberExpr>(this); 466 return !M->isArrow() && M->getBase()->hasGlobalStorage(); 467 } 468 case ArraySubscriptExprClass: 469 return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage(); 470 case PreDefinedExprClass: 471 return true; 472 case CXXDefaultArgExprClass: 473 return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage(); 474 } 475} 476 477Expr* Expr::IgnoreParens() { 478 Expr* E = this; 479 while (ParenExpr* P = dyn_cast<ParenExpr>(E)) 480 E = P->getSubExpr(); 481 482 return E; 483} 484 485/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr 486/// or CastExprs or ImplicitCastExprs, returning their operand. 487Expr *Expr::IgnoreParenCasts() { 488 Expr *E = this; 489 while (true) { 490 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) 491 E = P->getSubExpr(); 492 else if (CastExpr *P = dyn_cast<CastExpr>(E)) 493 E = P->getSubExpr(); 494 else if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E)) 495 E = P->getSubExpr(); 496 else 497 return E; 498 } 499} 500 501 502bool Expr::isConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const { 503 return true; 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 if (const VectorType *VT = getType()->getAsVectorType()) 1042 return VT->getNumElements(); 1043 return 1; 1044} 1045 1046/// containsDuplicateElements - Return true if any element access is repeated. 1047bool ExtVectorElementExpr::containsDuplicateElements() const { 1048 const char *compStr = Accessor.getName(); 1049 unsigned length = strlen(compStr); 1050 1051 for (unsigned i = 0; i < length-1; i++) { 1052 const char *s = compStr+i; 1053 for (const char c = *s++; *s; s++) 1054 if (c == *s) 1055 return true; 1056 } 1057 return false; 1058} 1059 1060/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 1061void ExtVectorElementExpr::getEncodedElementAccess( 1062 llvm::SmallVectorImpl<unsigned> &Elts) const { 1063 const char *compStr = Accessor.getName(); 1064 1065 bool isHi = !strcmp(compStr, "hi"); 1066 bool isLo = !strcmp(compStr, "lo"); 1067 bool isEven = !strcmp(compStr, "e"); 1068 bool isOdd = !strcmp(compStr, "o"); 1069 1070 for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 1071 uint64_t Index; 1072 1073 if (isHi) 1074 Index = e + i; 1075 else if (isLo) 1076 Index = i; 1077 else if (isEven) 1078 Index = 2 * i; 1079 else if (isOdd) 1080 Index = 2 * i + 1; 1081 else 1082 Index = ExtVectorType::getAccessorIdx(compStr[i]); 1083 1084 Elts.push_back(Index); 1085 } 1086} 1087 1088unsigned 1089ExtVectorElementExpr::getAccessedFieldNo(unsigned Idx, 1090 const llvm::Constant *Elts) { 1091 if (isa<llvm::ConstantAggregateZero>(Elts)) 1092 return 0; 1093 1094 return cast<llvm::ConstantInt>(Elts->getOperand(Idx))->getZExtValue(); 1095} 1096 1097// constructor for instance messages. 1098ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo, 1099 QualType retType, ObjCMethodDecl *mproto, 1100 SourceLocation LBrac, SourceLocation RBrac, 1101 Expr **ArgExprs, unsigned nargs) 1102 : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1103 MethodProto(mproto) { 1104 NumArgs = nargs; 1105 SubExprs = new Expr*[NumArgs+1]; 1106 SubExprs[RECEIVER] = receiver; 1107 if (NumArgs) { 1108 for (unsigned i = 0; i != NumArgs; ++i) 1109 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 1110 } 1111 LBracloc = LBrac; 1112 RBracloc = RBrac; 1113} 1114 1115// constructor for class messages. 1116// FIXME: clsName should be typed to ObjCInterfaceType 1117ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo, 1118 QualType retType, ObjCMethodDecl *mproto, 1119 SourceLocation LBrac, SourceLocation RBrac, 1120 Expr **ArgExprs, unsigned nargs) 1121 : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1122 MethodProto(mproto) { 1123 NumArgs = nargs; 1124 SubExprs = new Expr*[NumArgs+1]; 1125 SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | 0x1); 1126 if (NumArgs) { 1127 for (unsigned i = 0; i != NumArgs; ++i) 1128 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 1129 } 1130 LBracloc = LBrac; 1131 RBracloc = RBrac; 1132} 1133 1134bool ChooseExpr::isConditionTrue(ASTContext &C) const { 1135 llvm::APSInt CondVal(32); 1136 bool IsConst = getCond()->isIntegerConstantExpr(CondVal, C); 1137 assert(IsConst && "Condition of choose expr must be i-c-e"); IsConst=IsConst; 1138 return CondVal != 0; 1139} 1140 1141static int64_t evaluateOffsetOf(ASTContext& C, const Expr *E) 1142{ 1143 if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 1144 QualType Ty = ME->getBase()->getType(); 1145 1146 RecordDecl *RD = Ty->getAsRecordType()->getDecl(); 1147 const ASTRecordLayout &RL = C.getASTRecordLayout(RD); 1148 FieldDecl *FD = ME->getMemberDecl(); 1149 1150 // FIXME: This is linear time. 1151 unsigned i = 0, e = 0; 1152 for (i = 0, e = RD->getNumMembers(); i != e; i++) { 1153 if (RD->getMember(i) == FD) 1154 break; 1155 } 1156 1157 return RL.getFieldOffset(i) + evaluateOffsetOf(C, ME->getBase()); 1158 } else if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) { 1159 const Expr *Base = ASE->getBase(); 1160 llvm::APSInt Idx(32); 1161 bool ICE = ASE->getIdx()->isIntegerConstantExpr(Idx, C); 1162 assert(ICE && "Array index is not a constant integer!"); 1163 1164 int64_t size = C.getTypeSize(ASE->getType()); 1165 size *= Idx.getSExtValue(); 1166 1167 return size + evaluateOffsetOf(C, Base); 1168 } else if (isa<CompoundLiteralExpr>(E)) 1169 return 0; 1170 1171 assert(0 && "Unknown offsetof subexpression!"); 1172 return 0; 1173} 1174 1175int64_t UnaryOperator::evaluateOffsetOf(ASTContext& C) const 1176{ 1177 assert(Opc == OffsetOf && "Unary operator not offsetof!"); 1178 1179 unsigned CharSize = C.Target.getCharWidth(); 1180 return ::evaluateOffsetOf(C, Val) / CharSize; 1181} 1182 1183//===----------------------------------------------------------------------===// 1184// Child Iterators for iterating over subexpressions/substatements 1185//===----------------------------------------------------------------------===// 1186 1187// DeclRefExpr 1188Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); } 1189Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); } 1190 1191// ObjCIvarRefExpr 1192Stmt::child_iterator ObjCIvarRefExpr::child_begin() { 1193 return reinterpret_cast<Stmt**>(&Base); 1194} 1195 1196Stmt::child_iterator ObjCIvarRefExpr::child_end() { 1197 return reinterpret_cast<Stmt**>(&Base)+1; 1198} 1199 1200// PreDefinedExpr 1201Stmt::child_iterator PreDefinedExpr::child_begin() { return child_iterator(); } 1202Stmt::child_iterator PreDefinedExpr::child_end() { return child_iterator(); } 1203 1204// IntegerLiteral 1205Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); } 1206Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); } 1207 1208// CharacterLiteral 1209Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator(); } 1210Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); } 1211 1212// FloatingLiteral 1213Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); } 1214Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); } 1215 1216// ImaginaryLiteral 1217Stmt::child_iterator ImaginaryLiteral::child_begin() { 1218 return reinterpret_cast<Stmt**>(&Val); 1219} 1220Stmt::child_iterator ImaginaryLiteral::child_end() { 1221 return reinterpret_cast<Stmt**>(&Val)+1; 1222} 1223 1224// StringLiteral 1225Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); } 1226Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); } 1227 1228// ParenExpr 1229Stmt::child_iterator ParenExpr::child_begin() { 1230 return reinterpret_cast<Stmt**>(&Val); 1231} 1232Stmt::child_iterator ParenExpr::child_end() { 1233 return reinterpret_cast<Stmt**>(&Val)+1; 1234} 1235 1236// UnaryOperator 1237Stmt::child_iterator UnaryOperator::child_begin() { 1238 return reinterpret_cast<Stmt**>(&Val); 1239} 1240Stmt::child_iterator UnaryOperator::child_end() { 1241 return reinterpret_cast<Stmt**>(&Val+1); 1242} 1243 1244// SizeOfAlignOfTypeExpr 1245Stmt::child_iterator SizeOfAlignOfTypeExpr::child_begin() { 1246 // If the type is a VLA type (and not a typedef), the size expression of the 1247 // VLA needs to be treated as an executable expression. 1248 if (VariableArrayType* T = dyn_cast<VariableArrayType>(Ty.getTypePtr())) 1249 return child_iterator(T); 1250 else 1251 return child_iterator(); 1252} 1253Stmt::child_iterator SizeOfAlignOfTypeExpr::child_end() { 1254 return child_iterator(); 1255} 1256 1257// ArraySubscriptExpr 1258Stmt::child_iterator ArraySubscriptExpr::child_begin() { 1259 return reinterpret_cast<Stmt**>(&SubExprs); 1260} 1261Stmt::child_iterator ArraySubscriptExpr::child_end() { 1262 return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR; 1263} 1264 1265// CallExpr 1266Stmt::child_iterator CallExpr::child_begin() { 1267 return reinterpret_cast<Stmt**>(&SubExprs[0]); 1268} 1269Stmt::child_iterator CallExpr::child_end() { 1270 return reinterpret_cast<Stmt**>(&SubExprs[NumArgs+ARGS_START]); 1271} 1272 1273// MemberExpr 1274Stmt::child_iterator MemberExpr::child_begin() { 1275 return reinterpret_cast<Stmt**>(&Base); 1276} 1277Stmt::child_iterator MemberExpr::child_end() { 1278 return reinterpret_cast<Stmt**>(&Base)+1; 1279} 1280 1281// ExtVectorElementExpr 1282Stmt::child_iterator ExtVectorElementExpr::child_begin() { 1283 return reinterpret_cast<Stmt**>(&Base); 1284} 1285Stmt::child_iterator ExtVectorElementExpr::child_end() { 1286 return reinterpret_cast<Stmt**>(&Base)+1; 1287} 1288 1289// CompoundLiteralExpr 1290Stmt::child_iterator CompoundLiteralExpr::child_begin() { 1291 return reinterpret_cast<Stmt**>(&Init); 1292} 1293Stmt::child_iterator CompoundLiteralExpr::child_end() { 1294 return reinterpret_cast<Stmt**>(&Init)+1; 1295} 1296 1297// ImplicitCastExpr 1298Stmt::child_iterator ImplicitCastExpr::child_begin() { 1299 return reinterpret_cast<Stmt**>(&Op); 1300} 1301Stmt::child_iterator ImplicitCastExpr::child_end() { 1302 return reinterpret_cast<Stmt**>(&Op)+1; 1303} 1304 1305// CastExpr 1306Stmt::child_iterator CastExpr::child_begin() { 1307 return reinterpret_cast<Stmt**>(&Op); 1308} 1309Stmt::child_iterator CastExpr::child_end() { 1310 return reinterpret_cast<Stmt**>(&Op)+1; 1311} 1312 1313// BinaryOperator 1314Stmt::child_iterator BinaryOperator::child_begin() { 1315 return reinterpret_cast<Stmt**>(&SubExprs); 1316} 1317Stmt::child_iterator BinaryOperator::child_end() { 1318 return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR; 1319} 1320 1321// ConditionalOperator 1322Stmt::child_iterator ConditionalOperator::child_begin() { 1323 return reinterpret_cast<Stmt**>(&SubExprs); 1324} 1325Stmt::child_iterator ConditionalOperator::child_end() { 1326 return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR; 1327} 1328 1329// AddrLabelExpr 1330Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); } 1331Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); } 1332 1333// StmtExpr 1334Stmt::child_iterator StmtExpr::child_begin() { 1335 return reinterpret_cast<Stmt**>(&SubStmt); 1336} 1337Stmt::child_iterator StmtExpr::child_end() { 1338 return reinterpret_cast<Stmt**>(&SubStmt)+1; 1339} 1340 1341// TypesCompatibleExpr 1342Stmt::child_iterator TypesCompatibleExpr::child_begin() { 1343 return child_iterator(); 1344} 1345 1346Stmt::child_iterator TypesCompatibleExpr::child_end() { 1347 return child_iterator(); 1348} 1349 1350// ChooseExpr 1351Stmt::child_iterator ChooseExpr::child_begin() { 1352 return reinterpret_cast<Stmt**>(&SubExprs); 1353} 1354 1355Stmt::child_iterator ChooseExpr::child_end() { 1356 return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR; 1357} 1358 1359// OverloadExpr 1360Stmt::child_iterator OverloadExpr::child_begin() { 1361 return reinterpret_cast<Stmt**>(&SubExprs[0]); 1362} 1363Stmt::child_iterator OverloadExpr::child_end() { 1364 return reinterpret_cast<Stmt**>(&SubExprs[NumExprs]); 1365} 1366 1367// ShuffleVectorExpr 1368Stmt::child_iterator ShuffleVectorExpr::child_begin() { 1369 return reinterpret_cast<Stmt**>(&SubExprs[0]); 1370} 1371Stmt::child_iterator ShuffleVectorExpr::child_end() { 1372 return reinterpret_cast<Stmt**>(&SubExprs[NumExprs]); 1373} 1374 1375// VAArgExpr 1376Stmt::child_iterator VAArgExpr::child_begin() { 1377 return reinterpret_cast<Stmt**>(&Val); 1378} 1379 1380Stmt::child_iterator VAArgExpr::child_end() { 1381 return reinterpret_cast<Stmt**>(&Val)+1; 1382} 1383 1384// InitListExpr 1385Stmt::child_iterator InitListExpr::child_begin() { 1386 return reinterpret_cast<Stmt**>(InitExprs.size() ? 1387 &InitExprs[0] : 0); 1388} 1389Stmt::child_iterator InitListExpr::child_end() { 1390 return reinterpret_cast<Stmt**>(InitExprs.size() ? 1391 &InitExprs[0] + InitExprs.size() : 0); 1392} 1393 1394// ObjCStringLiteral 1395Stmt::child_iterator ObjCStringLiteral::child_begin() { 1396 return child_iterator(); 1397} 1398Stmt::child_iterator ObjCStringLiteral::child_end() { 1399 return child_iterator(); 1400} 1401 1402// ObjCEncodeExpr 1403Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); } 1404Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); } 1405 1406// ObjCSelectorExpr 1407Stmt::child_iterator ObjCSelectorExpr::child_begin() { 1408 return child_iterator(); 1409} 1410Stmt::child_iterator ObjCSelectorExpr::child_end() { 1411 return child_iterator(); 1412} 1413 1414// ObjCProtocolExpr 1415Stmt::child_iterator ObjCProtocolExpr::child_begin() { 1416 return child_iterator(); 1417} 1418Stmt::child_iterator ObjCProtocolExpr::child_end() { 1419 return child_iterator(); 1420} 1421 1422// ObjCMessageExpr 1423Stmt::child_iterator ObjCMessageExpr::child_begin() { 1424 return reinterpret_cast<Stmt**>(&SubExprs[ getReceiver() ? 0 : ARGS_START ]); 1425} 1426Stmt::child_iterator ObjCMessageExpr::child_end() { 1427 return reinterpret_cast<Stmt**>(&SubExprs[getNumArgs()+ARGS_START]); 1428} 1429 1430