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