Expr.cpp revision bef0efd11bc4430a3ee437a3213cec5c18af855a
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/ExprCXX.h" 16#include "clang/AST/APValue.h" 17#include "clang/AST/ASTContext.h" 18#include "clang/AST/DeclObjC.h" 19#include "clang/AST/DeclCXX.h" 20#include "clang/AST/DeclTemplate.h" 21#include "clang/AST/RecordLayout.h" 22#include "clang/AST/StmtVisitor.h" 23#include "clang/Basic/Builtins.h" 24#include "clang/Basic/TargetInfo.h" 25#include "llvm/Support/ErrorHandling.h" 26#include "llvm/Support/raw_ostream.h" 27#include <algorithm> 28using namespace clang; 29 30void Expr::ANCHOR() {} // key function for Expr class. 31 32/// isKnownToHaveBooleanValue - Return true if this is an integer expression 33/// that is known to return 0 or 1. This happens for _Bool/bool expressions 34/// but also int expressions which are produced by things like comparisons in 35/// C. 36bool Expr::isKnownToHaveBooleanValue() const { 37 // If this value has _Bool type, it is obvious 0/1. 38 if (getType()->isBooleanType()) return true; 39 // If this is a non-scalar-integer type, we don't care enough to try. 40 if (!getType()->isIntegralType()) return false; 41 42 if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) 43 return PE->getSubExpr()->isKnownToHaveBooleanValue(); 44 45 if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(this)) { 46 switch (UO->getOpcode()) { 47 case UnaryOperator::Plus: 48 case UnaryOperator::Extension: 49 return UO->getSubExpr()->isKnownToHaveBooleanValue(); 50 default: 51 return false; 52 } 53 } 54 55 if (const CastExpr *CE = dyn_cast<CastExpr>(this)) 56 return CE->getSubExpr()->isKnownToHaveBooleanValue(); 57 58 if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(this)) { 59 switch (BO->getOpcode()) { 60 default: return false; 61 case BinaryOperator::LT: // Relational operators. 62 case BinaryOperator::GT: 63 case BinaryOperator::LE: 64 case BinaryOperator::GE: 65 case BinaryOperator::EQ: // Equality operators. 66 case BinaryOperator::NE: 67 case BinaryOperator::LAnd: // AND operator. 68 case BinaryOperator::LOr: // Logical OR operator. 69 return true; 70 71 case BinaryOperator::And: // Bitwise AND operator. 72 case BinaryOperator::Xor: // Bitwise XOR operator. 73 case BinaryOperator::Or: // Bitwise OR operator. 74 // Handle things like (x==2)|(y==12). 75 return BO->getLHS()->isKnownToHaveBooleanValue() && 76 BO->getRHS()->isKnownToHaveBooleanValue(); 77 78 case BinaryOperator::Comma: 79 case BinaryOperator::Assign: 80 return BO->getRHS()->isKnownToHaveBooleanValue(); 81 } 82 } 83 84 if (const ConditionalOperator *CO = dyn_cast<ConditionalOperator>(this)) 85 return CO->getTrueExpr()->isKnownToHaveBooleanValue() && 86 CO->getFalseExpr()->isKnownToHaveBooleanValue(); 87 88 return false; 89} 90 91//===----------------------------------------------------------------------===// 92// Primary Expressions. 93//===----------------------------------------------------------------------===// 94 95void ExplicitTemplateArgumentList::initializeFrom( 96 const TemplateArgumentListInfo &Info) { 97 LAngleLoc = Info.getLAngleLoc(); 98 RAngleLoc = Info.getRAngleLoc(); 99 NumTemplateArgs = Info.size(); 100 101 TemplateArgumentLoc *ArgBuffer = getTemplateArgs(); 102 for (unsigned i = 0; i != NumTemplateArgs; ++i) 103 new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]); 104} 105 106void ExplicitTemplateArgumentList::copyInto( 107 TemplateArgumentListInfo &Info) const { 108 Info.setLAngleLoc(LAngleLoc); 109 Info.setRAngleLoc(RAngleLoc); 110 for (unsigned I = 0; I != NumTemplateArgs; ++I) 111 Info.addArgument(getTemplateArgs()[I]); 112} 113 114std::size_t ExplicitTemplateArgumentList::sizeFor( 115 const TemplateArgumentListInfo &Info) { 116 return sizeof(ExplicitTemplateArgumentList) + 117 sizeof(TemplateArgumentLoc) * Info.size(); 118} 119 120void DeclRefExpr::computeDependence() { 121 TypeDependent = false; 122 ValueDependent = false; 123 124 NamedDecl *D = getDecl(); 125 126 // (TD) C++ [temp.dep.expr]p3: 127 // An id-expression is type-dependent if it contains: 128 // 129 // and 130 // 131 // (VD) C++ [temp.dep.constexpr]p2: 132 // An identifier is value-dependent if it is: 133 134 // (TD) - an identifier that was declared with dependent type 135 // (VD) - a name declared with a dependent type, 136 if (getType()->isDependentType()) { 137 TypeDependent = true; 138 ValueDependent = true; 139 } 140 // (TD) - a conversion-function-id that specifies a dependent type 141 else if (D->getDeclName().getNameKind() 142 == DeclarationName::CXXConversionFunctionName && 143 D->getDeclName().getCXXNameType()->isDependentType()) { 144 TypeDependent = true; 145 ValueDependent = true; 146 } 147 // (TD) - a template-id that is dependent, 148 else if (hasExplicitTemplateArgumentList() && 149 TemplateSpecializationType::anyDependentTemplateArguments( 150 getTemplateArgs(), 151 getNumTemplateArgs())) { 152 TypeDependent = true; 153 ValueDependent = true; 154 } 155 // (VD) - the name of a non-type template parameter, 156 else if (isa<NonTypeTemplateParmDecl>(D)) 157 ValueDependent = true; 158 // (VD) - a constant with integral or enumeration type and is 159 // initialized with an expression that is value-dependent. 160 else if (VarDecl *Var = dyn_cast<VarDecl>(D)) { 161 if (Var->getType()->isIntegralType() && 162 Var->getType().getCVRQualifiers() == Qualifiers::Const) { 163 if (const Expr *Init = Var->getAnyInitializer()) 164 if (Init->isValueDependent()) 165 ValueDependent = true; 166 } 167 // (VD) - FIXME: Missing from the standard: 168 // - a member function or a static data member of the current 169 // instantiation 170 else if (Var->isStaticDataMember() && 171 Var->getDeclContext()->isDependentContext()) 172 ValueDependent = true; 173 } 174 // (VD) - FIXME: Missing from the standard: 175 // - a member function or a static data member of the current 176 // instantiation 177 else if (isa<CXXMethodDecl>(D) && D->getDeclContext()->isDependentContext()) 178 ValueDependent = true; 179 // (TD) - a nested-name-specifier or a qualified-id that names a 180 // member of an unknown specialization. 181 // (handled by DependentScopeDeclRefExpr) 182} 183 184DeclRefExpr::DeclRefExpr(NestedNameSpecifier *Qualifier, 185 SourceRange QualifierRange, 186 ValueDecl *D, SourceLocation NameLoc, 187 const TemplateArgumentListInfo *TemplateArgs, 188 QualType T) 189 : Expr(DeclRefExprClass, T, false, false), 190 DecoratedD(D, 191 (Qualifier? HasQualifierFlag : 0) | 192 (TemplateArgs ? HasExplicitTemplateArgumentListFlag : 0)), 193 Loc(NameLoc) { 194 if (Qualifier) { 195 NameQualifier *NQ = getNameQualifier(); 196 NQ->NNS = Qualifier; 197 NQ->Range = QualifierRange; 198 } 199 200 if (TemplateArgs) 201 getExplicitTemplateArgumentList()->initializeFrom(*TemplateArgs); 202 203 computeDependence(); 204} 205 206DeclRefExpr *DeclRefExpr::Create(ASTContext &Context, 207 NestedNameSpecifier *Qualifier, 208 SourceRange QualifierRange, 209 ValueDecl *D, 210 SourceLocation NameLoc, 211 QualType T, 212 const TemplateArgumentListInfo *TemplateArgs) { 213 std::size_t Size = sizeof(DeclRefExpr); 214 if (Qualifier != 0) 215 Size += sizeof(NameQualifier); 216 217 if (TemplateArgs) 218 Size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs); 219 220 void *Mem = Context.Allocate(Size, llvm::alignof<DeclRefExpr>()); 221 return new (Mem) DeclRefExpr(Qualifier, QualifierRange, D, NameLoc, 222 TemplateArgs, T); 223} 224 225SourceRange DeclRefExpr::getSourceRange() const { 226 // FIXME: Does not handle multi-token names well, e.g., operator[]. 227 SourceRange R(Loc); 228 229 if (hasQualifier()) 230 R.setBegin(getQualifierRange().getBegin()); 231 if (hasExplicitTemplateArgumentList()) 232 R.setEnd(getRAngleLoc()); 233 return R; 234} 235 236// FIXME: Maybe this should use DeclPrinter with a special "print predefined 237// expr" policy instead. 238std::string PredefinedExpr::ComputeName(IdentType IT, const Decl *CurrentDecl) { 239 ASTContext &Context = CurrentDecl->getASTContext(); 240 241 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) { 242 if (IT != PrettyFunction && IT != PrettyFunctionNoVirtual) 243 return FD->getNameAsString(); 244 245 llvm::SmallString<256> Name; 246 llvm::raw_svector_ostream Out(Name); 247 248 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 249 if (MD->isVirtual() && IT != PrettyFunctionNoVirtual) 250 Out << "virtual "; 251 if (MD->isStatic()) 252 Out << "static "; 253 } 254 255 PrintingPolicy Policy(Context.getLangOptions()); 256 257 std::string Proto = FD->getQualifiedNameAsString(Policy); 258 259 const FunctionType *AFT = FD->getType()->getAs<FunctionType>(); 260 const FunctionProtoType *FT = 0; 261 if (FD->hasWrittenPrototype()) 262 FT = dyn_cast<FunctionProtoType>(AFT); 263 264 Proto += "("; 265 if (FT) { 266 llvm::raw_string_ostream POut(Proto); 267 for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) { 268 if (i) POut << ", "; 269 std::string Param; 270 FD->getParamDecl(i)->getType().getAsStringInternal(Param, Policy); 271 POut << Param; 272 } 273 274 if (FT->isVariadic()) { 275 if (FD->getNumParams()) POut << ", "; 276 POut << "..."; 277 } 278 } 279 Proto += ")"; 280 281 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 282 Qualifiers ThisQuals = Qualifiers::fromCVRMask(MD->getTypeQualifiers()); 283 if (ThisQuals.hasConst()) 284 Proto += " const"; 285 if (ThisQuals.hasVolatile()) 286 Proto += " volatile"; 287 } 288 289 if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD)) 290 AFT->getResultType().getAsStringInternal(Proto, Policy); 291 292 Out << Proto; 293 294 Out.flush(); 295 return Name.str().str(); 296 } 297 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) { 298 llvm::SmallString<256> Name; 299 llvm::raw_svector_ostream Out(Name); 300 Out << (MD->isInstanceMethod() ? '-' : '+'); 301 Out << '['; 302 303 // For incorrect code, there might not be an ObjCInterfaceDecl. Do 304 // a null check to avoid a crash. 305 if (const ObjCInterfaceDecl *ID = MD->getClassInterface()) 306 Out << ID; 307 308 if (const ObjCCategoryImplDecl *CID = 309 dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext())) 310 Out << '(' << CID << ')'; 311 312 Out << ' '; 313 Out << MD->getSelector().getAsString(); 314 Out << ']'; 315 316 Out.flush(); 317 return Name.str().str(); 318 } 319 if (isa<TranslationUnitDecl>(CurrentDecl) && IT == PrettyFunction) { 320 // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string. 321 return "top level"; 322 } 323 return ""; 324} 325 326/// getValueAsApproximateDouble - This returns the value as an inaccurate 327/// double. Note that this may cause loss of precision, but is useful for 328/// debugging dumps, etc. 329double FloatingLiteral::getValueAsApproximateDouble() const { 330 llvm::APFloat V = getValue(); 331 bool ignored; 332 V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven, 333 &ignored); 334 return V.convertToDouble(); 335} 336 337StringLiteral *StringLiteral::Create(ASTContext &C, const char *StrData, 338 unsigned ByteLength, bool Wide, 339 QualType Ty, 340 const SourceLocation *Loc, 341 unsigned NumStrs) { 342 // Allocate enough space for the StringLiteral plus an array of locations for 343 // any concatenated string tokens. 344 void *Mem = C.Allocate(sizeof(StringLiteral)+ 345 sizeof(SourceLocation)*(NumStrs-1), 346 llvm::alignof<StringLiteral>()); 347 StringLiteral *SL = new (Mem) StringLiteral(Ty); 348 349 // OPTIMIZE: could allocate this appended to the StringLiteral. 350 char *AStrData = new (C, 1) char[ByteLength]; 351 memcpy(AStrData, StrData, ByteLength); 352 SL->StrData = AStrData; 353 SL->ByteLength = ByteLength; 354 SL->IsWide = Wide; 355 SL->TokLocs[0] = Loc[0]; 356 SL->NumConcatenated = NumStrs; 357 358 if (NumStrs != 1) 359 memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1)); 360 return SL; 361} 362 363StringLiteral *StringLiteral::CreateEmpty(ASTContext &C, unsigned NumStrs) { 364 void *Mem = C.Allocate(sizeof(StringLiteral)+ 365 sizeof(SourceLocation)*(NumStrs-1), 366 llvm::alignof<StringLiteral>()); 367 StringLiteral *SL = new (Mem) StringLiteral(QualType()); 368 SL->StrData = 0; 369 SL->ByteLength = 0; 370 SL->NumConcatenated = NumStrs; 371 return SL; 372} 373 374void StringLiteral::DoDestroy(ASTContext &C) { 375 C.Deallocate(const_cast<char*>(StrData)); 376 Expr::DoDestroy(C); 377} 378 379void StringLiteral::setString(ASTContext &C, llvm::StringRef Str) { 380 if (StrData) 381 C.Deallocate(const_cast<char*>(StrData)); 382 383 char *AStrData = new (C, 1) char[Str.size()]; 384 memcpy(AStrData, Str.data(), Str.size()); 385 StrData = AStrData; 386 ByteLength = Str.size(); 387} 388 389/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 390/// corresponds to, e.g. "sizeof" or "[pre]++". 391const char *UnaryOperator::getOpcodeStr(Opcode Op) { 392 switch (Op) { 393 default: assert(0 && "Unknown unary operator"); 394 case PostInc: return "++"; 395 case PostDec: return "--"; 396 case PreInc: return "++"; 397 case PreDec: return "--"; 398 case AddrOf: return "&"; 399 case Deref: return "*"; 400 case Plus: return "+"; 401 case Minus: return "-"; 402 case Not: return "~"; 403 case LNot: return "!"; 404 case Real: return "__real"; 405 case Imag: return "__imag"; 406 case Extension: return "__extension__"; 407 case OffsetOf: return "__builtin_offsetof"; 408 } 409} 410 411UnaryOperator::Opcode 412UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) { 413 switch (OO) { 414 default: assert(false && "No unary operator for overloaded function"); 415 case OO_PlusPlus: return Postfix ? PostInc : PreInc; 416 case OO_MinusMinus: return Postfix ? PostDec : PreDec; 417 case OO_Amp: return AddrOf; 418 case OO_Star: return Deref; 419 case OO_Plus: return Plus; 420 case OO_Minus: return Minus; 421 case OO_Tilde: return Not; 422 case OO_Exclaim: return LNot; 423 } 424} 425 426OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) { 427 switch (Opc) { 428 case PostInc: case PreInc: return OO_PlusPlus; 429 case PostDec: case PreDec: return OO_MinusMinus; 430 case AddrOf: return OO_Amp; 431 case Deref: return OO_Star; 432 case Plus: return OO_Plus; 433 case Minus: return OO_Minus; 434 case Not: return OO_Tilde; 435 case LNot: return OO_Exclaim; 436 default: return OO_None; 437 } 438} 439 440 441//===----------------------------------------------------------------------===// 442// Postfix Operators. 443//===----------------------------------------------------------------------===// 444 445CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args, 446 unsigned numargs, QualType t, SourceLocation rparenloc) 447 : Expr(SC, t, 448 fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs), 449 fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)), 450 NumArgs(numargs) { 451 452 SubExprs = new (C) Stmt*[numargs+1]; 453 SubExprs[FN] = fn; 454 for (unsigned i = 0; i != numargs; ++i) 455 SubExprs[i+ARGS_START] = args[i]; 456 457 RParenLoc = rparenloc; 458} 459 460CallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs, 461 QualType t, SourceLocation rparenloc) 462 : Expr(CallExprClass, t, 463 fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs), 464 fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)), 465 NumArgs(numargs) { 466 467 SubExprs = new (C) Stmt*[numargs+1]; 468 SubExprs[FN] = fn; 469 for (unsigned i = 0; i != numargs; ++i) 470 SubExprs[i+ARGS_START] = args[i]; 471 472 RParenLoc = rparenloc; 473} 474 475CallExpr::CallExpr(ASTContext &C, StmtClass SC, EmptyShell Empty) 476 : Expr(SC, Empty), SubExprs(0), NumArgs(0) { 477 SubExprs = new (C) Stmt*[1]; 478} 479 480void CallExpr::DoDestroy(ASTContext& C) { 481 DestroyChildren(C); 482 if (SubExprs) C.Deallocate(SubExprs); 483 this->~CallExpr(); 484 C.Deallocate(this); 485} 486 487Decl *CallExpr::getCalleeDecl() { 488 Expr *CEE = getCallee()->IgnoreParenCasts(); 489 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE)) 490 return DRE->getDecl(); 491 if (MemberExpr *ME = dyn_cast<MemberExpr>(CEE)) 492 return ME->getMemberDecl(); 493 494 return 0; 495} 496 497FunctionDecl *CallExpr::getDirectCallee() { 498 return dyn_cast_or_null<FunctionDecl>(getCalleeDecl()); 499} 500 501/// setNumArgs - This changes the number of arguments present in this call. 502/// Any orphaned expressions are deleted by this, and any new operands are set 503/// to null. 504void CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) { 505 // No change, just return. 506 if (NumArgs == getNumArgs()) return; 507 508 // If shrinking # arguments, just delete the extras and forgot them. 509 if (NumArgs < getNumArgs()) { 510 for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i) 511 getArg(i)->Destroy(C); 512 this->NumArgs = NumArgs; 513 return; 514 } 515 516 // Otherwise, we are growing the # arguments. New an bigger argument array. 517 Stmt **NewSubExprs = new (C) Stmt*[NumArgs+1]; 518 // Copy over args. 519 for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i) 520 NewSubExprs[i] = SubExprs[i]; 521 // Null out new args. 522 for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i) 523 NewSubExprs[i] = 0; 524 525 if (SubExprs) C.Deallocate(SubExprs); 526 SubExprs = NewSubExprs; 527 this->NumArgs = NumArgs; 528} 529 530/// isBuiltinCall - If this is a call to a builtin, return the builtin ID. If 531/// not, return 0. 532unsigned CallExpr::isBuiltinCall(ASTContext &Context) const { 533 // All simple function calls (e.g. func()) are implicitly cast to pointer to 534 // function. As a result, we try and obtain the DeclRefExpr from the 535 // ImplicitCastExpr. 536 const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 537 if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 538 return 0; 539 540 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 541 if (!DRE) 542 return 0; 543 544 const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 545 if (!FDecl) 546 return 0; 547 548 if (!FDecl->getIdentifier()) 549 return 0; 550 551 return FDecl->getBuiltinID(); 552} 553 554QualType CallExpr::getCallReturnType() const { 555 QualType CalleeType = getCallee()->getType(); 556 if (const PointerType *FnTypePtr = CalleeType->getAs<PointerType>()) 557 CalleeType = FnTypePtr->getPointeeType(); 558 else if (const BlockPointerType *BPT = CalleeType->getAs<BlockPointerType>()) 559 CalleeType = BPT->getPointeeType(); 560 561 const FunctionType *FnType = CalleeType->getAs<FunctionType>(); 562 return FnType->getResultType(); 563} 564 565OffsetOfExpr *OffsetOfExpr::Create(ASTContext &C, QualType type, 566 SourceLocation OperatorLoc, 567 TypeSourceInfo *tsi, 568 OffsetOfNode* compsPtr, unsigned numComps, 569 Expr** exprsPtr, unsigned numExprs, 570 SourceLocation RParenLoc) { 571 void *Mem = C.Allocate(sizeof(OffsetOfExpr) + 572 sizeof(OffsetOfNode) * numComps + 573 sizeof(Expr*) * numExprs); 574 575 return new (Mem) OffsetOfExpr(C, type, OperatorLoc, tsi, compsPtr, numComps, 576 exprsPtr, numExprs, RParenLoc); 577} 578 579OffsetOfExpr *OffsetOfExpr::CreateEmpty(ASTContext &C, 580 unsigned numComps, unsigned numExprs) { 581 void *Mem = C.Allocate(sizeof(OffsetOfExpr) + 582 sizeof(OffsetOfNode) * numComps + 583 sizeof(Expr*) * numExprs); 584 return new (Mem) OffsetOfExpr(numComps, numExprs); 585} 586 587OffsetOfExpr::OffsetOfExpr(ASTContext &C, QualType type, 588 SourceLocation OperatorLoc, TypeSourceInfo *tsi, 589 OffsetOfNode* compsPtr, unsigned numComps, 590 Expr** exprsPtr, unsigned numExprs, 591 SourceLocation RParenLoc) 592 : Expr(OffsetOfExprClass, type, /*TypeDependent=*/false, 593 /*ValueDependent=*/tsi->getType()->isDependentType() || 594 hasAnyTypeDependentArguments(exprsPtr, numExprs) || 595 hasAnyValueDependentArguments(exprsPtr, numExprs)), 596 OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi), 597 NumComps(numComps), NumExprs(numExprs) 598{ 599 for(unsigned i = 0; i < numComps; ++i) { 600 setComponent(i, compsPtr[i]); 601 } 602 603 for(unsigned i = 0; i < numExprs; ++i) { 604 setIndexExpr(i, exprsPtr[i]); 605 } 606} 607 608IdentifierInfo *OffsetOfExpr::OffsetOfNode::getFieldName() const { 609 assert(getKind() == Field || getKind() == Identifier); 610 if (getKind() == Field) 611 return getField()->getIdentifier(); 612 613 return reinterpret_cast<IdentifierInfo *> (Data & ~(uintptr_t)Mask); 614} 615 616MemberExpr *MemberExpr::Create(ASTContext &C, Expr *base, bool isarrow, 617 NestedNameSpecifier *qual, 618 SourceRange qualrange, 619 ValueDecl *memberdecl, 620 DeclAccessPair founddecl, 621 SourceLocation l, 622 const TemplateArgumentListInfo *targs, 623 QualType ty) { 624 std::size_t Size = sizeof(MemberExpr); 625 626 bool hasQualOrFound = (qual != 0 || 627 founddecl.getDecl() != memberdecl || 628 founddecl.getAccess() != memberdecl->getAccess()); 629 if (hasQualOrFound) 630 Size += sizeof(MemberNameQualifier); 631 632 if (targs) 633 Size += ExplicitTemplateArgumentList::sizeFor(*targs); 634 635 void *Mem = C.Allocate(Size, llvm::alignof<MemberExpr>()); 636 MemberExpr *E = new (Mem) MemberExpr(base, isarrow, memberdecl, l, ty); 637 638 if (hasQualOrFound) { 639 if (qual && qual->isDependent()) { 640 E->setValueDependent(true); 641 E->setTypeDependent(true); 642 } 643 E->HasQualifierOrFoundDecl = true; 644 645 MemberNameQualifier *NQ = E->getMemberQualifier(); 646 NQ->NNS = qual; 647 NQ->Range = qualrange; 648 NQ->FoundDecl = founddecl; 649 } 650 651 if (targs) { 652 E->HasExplicitTemplateArgumentList = true; 653 E->getExplicitTemplateArgumentList()->initializeFrom(*targs); 654 } 655 656 return E; 657} 658 659const char *CastExpr::getCastKindName() const { 660 switch (getCastKind()) { 661 case CastExpr::CK_Unknown: 662 return "Unknown"; 663 case CastExpr::CK_BitCast: 664 return "BitCast"; 665 case CastExpr::CK_NoOp: 666 return "NoOp"; 667 case CastExpr::CK_BaseToDerived: 668 return "BaseToDerived"; 669 case CastExpr::CK_DerivedToBase: 670 return "DerivedToBase"; 671 case CastExpr::CK_UncheckedDerivedToBase: 672 return "UncheckedDerivedToBase"; 673 case CastExpr::CK_Dynamic: 674 return "Dynamic"; 675 case CastExpr::CK_ToUnion: 676 return "ToUnion"; 677 case CastExpr::CK_ArrayToPointerDecay: 678 return "ArrayToPointerDecay"; 679 case CastExpr::CK_FunctionToPointerDecay: 680 return "FunctionToPointerDecay"; 681 case CastExpr::CK_NullToMemberPointer: 682 return "NullToMemberPointer"; 683 case CastExpr::CK_BaseToDerivedMemberPointer: 684 return "BaseToDerivedMemberPointer"; 685 case CastExpr::CK_DerivedToBaseMemberPointer: 686 return "DerivedToBaseMemberPointer"; 687 case CastExpr::CK_UserDefinedConversion: 688 return "UserDefinedConversion"; 689 case CastExpr::CK_ConstructorConversion: 690 return "ConstructorConversion"; 691 case CastExpr::CK_IntegralToPointer: 692 return "IntegralToPointer"; 693 case CastExpr::CK_PointerToIntegral: 694 return "PointerToIntegral"; 695 case CastExpr::CK_ToVoid: 696 return "ToVoid"; 697 case CastExpr::CK_VectorSplat: 698 return "VectorSplat"; 699 case CastExpr::CK_IntegralCast: 700 return "IntegralCast"; 701 case CastExpr::CK_IntegralToFloating: 702 return "IntegralToFloating"; 703 case CastExpr::CK_FloatingToIntegral: 704 return "FloatingToIntegral"; 705 case CastExpr::CK_FloatingCast: 706 return "FloatingCast"; 707 case CastExpr::CK_MemberPointerToBoolean: 708 return "MemberPointerToBoolean"; 709 case CastExpr::CK_AnyPointerToObjCPointerCast: 710 return "AnyPointerToObjCPointerCast"; 711 case CastExpr::CK_AnyPointerToBlockPointerCast: 712 return "AnyPointerToBlockPointerCast"; 713 } 714 715 assert(0 && "Unhandled cast kind!"); 716 return 0; 717} 718 719void CastExpr::DoDestroy(ASTContext &C) 720{ 721 BasePath.Destroy(); 722 Expr::DoDestroy(C); 723} 724 725Expr *CastExpr::getSubExprAsWritten() { 726 Expr *SubExpr = 0; 727 CastExpr *E = this; 728 do { 729 SubExpr = E->getSubExpr(); 730 731 // Skip any temporary bindings; they're implicit. 732 if (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(SubExpr)) 733 SubExpr = Binder->getSubExpr(); 734 735 // Conversions by constructor and conversion functions have a 736 // subexpression describing the call; strip it off. 737 if (E->getCastKind() == CastExpr::CK_ConstructorConversion) 738 SubExpr = cast<CXXConstructExpr>(SubExpr)->getArg(0); 739 else if (E->getCastKind() == CastExpr::CK_UserDefinedConversion) 740 SubExpr = cast<CXXMemberCallExpr>(SubExpr)->getImplicitObjectArgument(); 741 742 // If the subexpression we're left with is an implicit cast, look 743 // through that, too. 744 } while ((E = dyn_cast<ImplicitCastExpr>(SubExpr))); 745 746 return SubExpr; 747} 748 749/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 750/// corresponds to, e.g. "<<=". 751const char *BinaryOperator::getOpcodeStr(Opcode Op) { 752 switch (Op) { 753 case PtrMemD: return ".*"; 754 case PtrMemI: return "->*"; 755 case Mul: return "*"; 756 case Div: return "/"; 757 case Rem: return "%"; 758 case Add: return "+"; 759 case Sub: return "-"; 760 case Shl: return "<<"; 761 case Shr: return ">>"; 762 case LT: return "<"; 763 case GT: return ">"; 764 case LE: return "<="; 765 case GE: return ">="; 766 case EQ: return "=="; 767 case NE: return "!="; 768 case And: return "&"; 769 case Xor: return "^"; 770 case Or: return "|"; 771 case LAnd: return "&&"; 772 case LOr: return "||"; 773 case Assign: return "="; 774 case MulAssign: return "*="; 775 case DivAssign: return "/="; 776 case RemAssign: return "%="; 777 case AddAssign: return "+="; 778 case SubAssign: return "-="; 779 case ShlAssign: return "<<="; 780 case ShrAssign: return ">>="; 781 case AndAssign: return "&="; 782 case XorAssign: return "^="; 783 case OrAssign: return "|="; 784 case Comma: return ","; 785 } 786 787 return ""; 788} 789 790BinaryOperator::Opcode 791BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) { 792 switch (OO) { 793 default: assert(false && "Not an overloadable binary operator"); 794 case OO_Plus: return Add; 795 case OO_Minus: return Sub; 796 case OO_Star: return Mul; 797 case OO_Slash: return Div; 798 case OO_Percent: return Rem; 799 case OO_Caret: return Xor; 800 case OO_Amp: return And; 801 case OO_Pipe: return Or; 802 case OO_Equal: return Assign; 803 case OO_Less: return LT; 804 case OO_Greater: return GT; 805 case OO_PlusEqual: return AddAssign; 806 case OO_MinusEqual: return SubAssign; 807 case OO_StarEqual: return MulAssign; 808 case OO_SlashEqual: return DivAssign; 809 case OO_PercentEqual: return RemAssign; 810 case OO_CaretEqual: return XorAssign; 811 case OO_AmpEqual: return AndAssign; 812 case OO_PipeEqual: return OrAssign; 813 case OO_LessLess: return Shl; 814 case OO_GreaterGreater: return Shr; 815 case OO_LessLessEqual: return ShlAssign; 816 case OO_GreaterGreaterEqual: return ShrAssign; 817 case OO_EqualEqual: return EQ; 818 case OO_ExclaimEqual: return NE; 819 case OO_LessEqual: return LE; 820 case OO_GreaterEqual: return GE; 821 case OO_AmpAmp: return LAnd; 822 case OO_PipePipe: return LOr; 823 case OO_Comma: return Comma; 824 case OO_ArrowStar: return PtrMemI; 825 } 826} 827 828OverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) { 829 static const OverloadedOperatorKind OverOps[] = { 830 /* .* Cannot be overloaded */OO_None, OO_ArrowStar, 831 OO_Star, OO_Slash, OO_Percent, 832 OO_Plus, OO_Minus, 833 OO_LessLess, OO_GreaterGreater, 834 OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual, 835 OO_EqualEqual, OO_ExclaimEqual, 836 OO_Amp, 837 OO_Caret, 838 OO_Pipe, 839 OO_AmpAmp, 840 OO_PipePipe, 841 OO_Equal, OO_StarEqual, 842 OO_SlashEqual, OO_PercentEqual, 843 OO_PlusEqual, OO_MinusEqual, 844 OO_LessLessEqual, OO_GreaterGreaterEqual, 845 OO_AmpEqual, OO_CaretEqual, 846 OO_PipeEqual, 847 OO_Comma 848 }; 849 return OverOps[Opc]; 850} 851 852InitListExpr::InitListExpr(ASTContext &C, SourceLocation lbraceloc, 853 Expr **initExprs, unsigned numInits, 854 SourceLocation rbraceloc) 855 : Expr(InitListExprClass, QualType(), false, false), 856 InitExprs(C, numInits), 857 LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0), 858 UnionFieldInit(0), HadArrayRangeDesignator(false) 859{ 860 for (unsigned I = 0; I != numInits; ++I) { 861 if (initExprs[I]->isTypeDependent()) 862 TypeDependent = true; 863 if (initExprs[I]->isValueDependent()) 864 ValueDependent = true; 865 } 866 867 InitExprs.insert(C, InitExprs.end(), initExprs, initExprs+numInits); 868} 869 870void InitListExpr::reserveInits(ASTContext &C, unsigned NumInits) { 871 if (NumInits > InitExprs.size()) 872 InitExprs.reserve(C, NumInits); 873} 874 875void InitListExpr::resizeInits(ASTContext &C, unsigned NumInits) { 876 for (unsigned Idx = NumInits, LastIdx = InitExprs.size(); 877 Idx < LastIdx; ++Idx) 878 InitExprs[Idx]->Destroy(C); 879 InitExprs.resize(C, NumInits, 0); 880} 881 882Expr *InitListExpr::updateInit(ASTContext &C, unsigned Init, Expr *expr) { 883 if (Init >= InitExprs.size()) { 884 InitExprs.insert(C, InitExprs.end(), Init - InitExprs.size() + 1, 0); 885 InitExprs.back() = expr; 886 return 0; 887 } 888 889 Expr *Result = cast_or_null<Expr>(InitExprs[Init]); 890 InitExprs[Init] = expr; 891 return Result; 892} 893 894/// getFunctionType - Return the underlying function type for this block. 895/// 896const FunctionType *BlockExpr::getFunctionType() const { 897 return getType()->getAs<BlockPointerType>()-> 898 getPointeeType()->getAs<FunctionType>(); 899} 900 901SourceLocation BlockExpr::getCaretLocation() const { 902 return TheBlock->getCaretLocation(); 903} 904const Stmt *BlockExpr::getBody() const { 905 return TheBlock->getBody(); 906} 907Stmt *BlockExpr::getBody() { 908 return TheBlock->getBody(); 909} 910 911 912//===----------------------------------------------------------------------===// 913// Generic Expression Routines 914//===----------------------------------------------------------------------===// 915 916/// isUnusedResultAWarning - Return true if this immediate expression should 917/// be warned about if the result is unused. If so, fill in Loc and Ranges 918/// with location to warn on and the source range[s] to report with the 919/// warning. 920bool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1, 921 SourceRange &R2, ASTContext &Ctx) const { 922 // Don't warn if the expr is type dependent. The type could end up 923 // instantiating to void. 924 if (isTypeDependent()) 925 return false; 926 927 switch (getStmtClass()) { 928 default: 929 if (getType()->isVoidType()) 930 return false; 931 Loc = getExprLoc(); 932 R1 = getSourceRange(); 933 return true; 934 case ParenExprClass: 935 return cast<ParenExpr>(this)->getSubExpr()-> 936 isUnusedResultAWarning(Loc, R1, R2, Ctx); 937 case UnaryOperatorClass: { 938 const UnaryOperator *UO = cast<UnaryOperator>(this); 939 940 switch (UO->getOpcode()) { 941 default: break; 942 case UnaryOperator::PostInc: 943 case UnaryOperator::PostDec: 944 case UnaryOperator::PreInc: 945 case UnaryOperator::PreDec: // ++/-- 946 return false; // Not a warning. 947 case UnaryOperator::Deref: 948 // Dereferencing a volatile pointer is a side-effect. 949 if (Ctx.getCanonicalType(getType()).isVolatileQualified()) 950 return false; 951 break; 952 case UnaryOperator::Real: 953 case UnaryOperator::Imag: 954 // accessing a piece of a volatile complex is a side-effect. 955 if (Ctx.getCanonicalType(UO->getSubExpr()->getType()) 956 .isVolatileQualified()) 957 return false; 958 break; 959 case UnaryOperator::Extension: 960 return UO->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx); 961 } 962 Loc = UO->getOperatorLoc(); 963 R1 = UO->getSubExpr()->getSourceRange(); 964 return true; 965 } 966 case BinaryOperatorClass: { 967 const BinaryOperator *BO = cast<BinaryOperator>(this); 968 switch (BO->getOpcode()) { 969 default: 970 break; 971 // Consider ',', '||', '&&' to have side effects if the LHS or RHS does. 972 case BinaryOperator::Comma: 973 // ((foo = <blah>), 0) is an idiom for hiding the result (and 974 // lvalue-ness) of an assignment written in a macro. 975 if (IntegerLiteral *IE = 976 dyn_cast<IntegerLiteral>(BO->getRHS()->IgnoreParens())) 977 if (IE->getValue() == 0) 978 return false; 979 case BinaryOperator::LAnd: 980 case BinaryOperator::LOr: 981 return (BO->getLHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx) || 982 BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx)); 983 } 984 if (BO->isAssignmentOp()) 985 return false; 986 Loc = BO->getOperatorLoc(); 987 R1 = BO->getLHS()->getSourceRange(); 988 R2 = BO->getRHS()->getSourceRange(); 989 return true; 990 } 991 case CompoundAssignOperatorClass: 992 case VAArgExprClass: 993 return false; 994 995 case ConditionalOperatorClass: { 996 // The condition must be evaluated, but if either the LHS or RHS is a 997 // warning, warn about them. 998 const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 999 if (Exp->getLHS() && 1000 Exp->getLHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx)) 1001 return true; 1002 return Exp->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx); 1003 } 1004 1005 case MemberExprClass: 1006 // If the base pointer or element is to a volatile pointer/field, accessing 1007 // it is a side effect. 1008 if (Ctx.getCanonicalType(getType()).isVolatileQualified()) 1009 return false; 1010 Loc = cast<MemberExpr>(this)->getMemberLoc(); 1011 R1 = SourceRange(Loc, Loc); 1012 R2 = cast<MemberExpr>(this)->getBase()->getSourceRange(); 1013 return true; 1014 1015 case ArraySubscriptExprClass: 1016 // If the base pointer or element is to a volatile pointer/field, accessing 1017 // it is a side effect. 1018 if (Ctx.getCanonicalType(getType()).isVolatileQualified()) 1019 return false; 1020 Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc(); 1021 R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange(); 1022 R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange(); 1023 return true; 1024 1025 case CallExprClass: 1026 case CXXOperatorCallExprClass: 1027 case CXXMemberCallExprClass: { 1028 // If this is a direct call, get the callee. 1029 const CallExpr *CE = cast<CallExpr>(this); 1030 if (const Decl *FD = CE->getCalleeDecl()) { 1031 // If the callee has attribute pure, const, or warn_unused_result, warn 1032 // about it. void foo() { strlen("bar"); } should warn. 1033 // 1034 // Note: If new cases are added here, DiagnoseUnusedExprResult should be 1035 // updated to match for QoI. 1036 if (FD->getAttr<WarnUnusedResultAttr>() || 1037 FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) { 1038 Loc = CE->getCallee()->getLocStart(); 1039 R1 = CE->getCallee()->getSourceRange(); 1040 1041 if (unsigned NumArgs = CE->getNumArgs()) 1042 R2 = SourceRange(CE->getArg(0)->getLocStart(), 1043 CE->getArg(NumArgs-1)->getLocEnd()); 1044 return true; 1045 } 1046 } 1047 return false; 1048 } 1049 1050 case CXXTemporaryObjectExprClass: 1051 case CXXConstructExprClass: 1052 return false; 1053 1054 case ObjCMessageExprClass: { 1055 const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this); 1056 const ObjCMethodDecl *MD = ME->getMethodDecl(); 1057 if (MD && MD->getAttr<WarnUnusedResultAttr>()) { 1058 Loc = getExprLoc(); 1059 return true; 1060 } 1061 return false; 1062 } 1063 1064 case ObjCImplicitSetterGetterRefExprClass: { // Dot syntax for message send. 1065#if 0 1066 const ObjCImplicitSetterGetterRefExpr *Ref = 1067 cast<ObjCImplicitSetterGetterRefExpr>(this); 1068 // FIXME: We really want the location of the '.' here. 1069 Loc = Ref->getLocation(); 1070 R1 = SourceRange(Ref->getLocation(), Ref->getLocation()); 1071 if (Ref->getBase()) 1072 R2 = Ref->getBase()->getSourceRange(); 1073#else 1074 Loc = getExprLoc(); 1075 R1 = getSourceRange(); 1076#endif 1077 return true; 1078 } 1079 case StmtExprClass: { 1080 // Statement exprs don't logically have side effects themselves, but are 1081 // sometimes used in macros in ways that give them a type that is unused. 1082 // For example ({ blah; foo(); }) will end up with a type if foo has a type. 1083 // however, if the result of the stmt expr is dead, we don't want to emit a 1084 // warning. 1085 const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt(); 1086 if (!CS->body_empty()) 1087 if (const Expr *E = dyn_cast<Expr>(CS->body_back())) 1088 return E->isUnusedResultAWarning(Loc, R1, R2, Ctx); 1089 1090 if (getType()->isVoidType()) 1091 return false; 1092 Loc = cast<StmtExpr>(this)->getLParenLoc(); 1093 R1 = getSourceRange(); 1094 return true; 1095 } 1096 case CStyleCastExprClass: 1097 // If this is an explicit cast to void, allow it. People do this when they 1098 // think they know what they're doing :). 1099 if (getType()->isVoidType()) 1100 return false; 1101 Loc = cast<CStyleCastExpr>(this)->getLParenLoc(); 1102 R1 = cast<CStyleCastExpr>(this)->getSubExpr()->getSourceRange(); 1103 return true; 1104 case CXXFunctionalCastExprClass: { 1105 if (getType()->isVoidType()) 1106 return false; 1107 const CastExpr *CE = cast<CastExpr>(this); 1108 1109 // If this is a cast to void or a constructor conversion, check the operand. 1110 // Otherwise, the result of the cast is unused. 1111 if (CE->getCastKind() == CastExpr::CK_ToVoid || 1112 CE->getCastKind() == CastExpr::CK_ConstructorConversion) 1113 return (cast<CastExpr>(this)->getSubExpr() 1114 ->isUnusedResultAWarning(Loc, R1, R2, Ctx)); 1115 Loc = cast<CXXFunctionalCastExpr>(this)->getTypeBeginLoc(); 1116 R1 = cast<CXXFunctionalCastExpr>(this)->getSubExpr()->getSourceRange(); 1117 return true; 1118 } 1119 1120 case ImplicitCastExprClass: 1121 // Check the operand, since implicit casts are inserted by Sema 1122 return (cast<ImplicitCastExpr>(this) 1123 ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx)); 1124 1125 case CXXDefaultArgExprClass: 1126 return (cast<CXXDefaultArgExpr>(this) 1127 ->getExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx)); 1128 1129 case CXXNewExprClass: 1130 // FIXME: In theory, there might be new expressions that don't have side 1131 // effects (e.g. a placement new with an uninitialized POD). 1132 case CXXDeleteExprClass: 1133 return false; 1134 case CXXBindTemporaryExprClass: 1135 return (cast<CXXBindTemporaryExpr>(this) 1136 ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx)); 1137 case CXXExprWithTemporariesClass: 1138 return (cast<CXXExprWithTemporaries>(this) 1139 ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx)); 1140 } 1141} 1142 1143/// DeclCanBeLvalue - Determine whether the given declaration can be 1144/// an lvalue. This is a helper routine for isLvalue. 1145static bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) { 1146 // C++ [temp.param]p6: 1147 // A non-type non-reference template-parameter is not an lvalue. 1148 if (const NonTypeTemplateParmDecl *NTTParm 1149 = dyn_cast<NonTypeTemplateParmDecl>(Decl)) 1150 return NTTParm->getType()->isReferenceType(); 1151 1152 return isa<VarDecl>(Decl) || isa<FieldDecl>(Decl) || 1153 // C++ 3.10p2: An lvalue refers to an object or function. 1154 (Ctx.getLangOptions().CPlusPlus && 1155 (isa<FunctionDecl>(Decl) || isa<FunctionTemplateDecl>(Decl))); 1156} 1157 1158/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an 1159/// incomplete type other than void. Nonarray expressions that can be lvalues: 1160/// - name, where name must be a variable 1161/// - e[i] 1162/// - (e), where e must be an lvalue 1163/// - e.name, where e must be an lvalue 1164/// - e->name 1165/// - *e, the type of e cannot be a function type 1166/// - string-constant 1167/// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension] 1168/// - reference type [C++ [expr]] 1169/// 1170Expr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const { 1171 assert(!TR->isReferenceType() && "Expressions can't have reference type."); 1172 1173 isLvalueResult Res = isLvalueInternal(Ctx); 1174 if (Res != LV_Valid || Ctx.getLangOptions().CPlusPlus) 1175 return Res; 1176 1177 // first, check the type (C99 6.3.2.1). Expressions with function 1178 // type in C are not lvalues, but they can be lvalues in C++. 1179 if (TR->isFunctionType() || TR == Ctx.OverloadTy) 1180 return LV_NotObjectType; 1181 1182 // Allow qualified void which is an incomplete type other than void (yuck). 1183 if (TR->isVoidType() && !Ctx.getCanonicalType(TR).hasQualifiers()) 1184 return LV_IncompleteVoidType; 1185 1186 return LV_Valid; 1187} 1188 1189// Check whether the expression can be sanely treated like an l-value 1190Expr::isLvalueResult Expr::isLvalueInternal(ASTContext &Ctx) const { 1191 switch (getStmtClass()) { 1192 case ObjCIsaExprClass: 1193 case StringLiteralClass: // C99 6.5.1p4 1194 case ObjCEncodeExprClass: // @encode behaves like its string in every way. 1195 return LV_Valid; 1196 case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2)))) 1197 // For vectors, make sure base is an lvalue (i.e. not a function call). 1198 if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType()) 1199 return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx); 1200 return LV_Valid; 1201 case DeclRefExprClass: { // C99 6.5.1p2 1202 const NamedDecl *RefdDecl = cast<DeclRefExpr>(this)->getDecl(); 1203 if (DeclCanBeLvalue(RefdDecl, Ctx)) 1204 return LV_Valid; 1205 break; 1206 } 1207 case BlockDeclRefExprClass: { 1208 const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 1209 if (isa<VarDecl>(BDR->getDecl())) 1210 return LV_Valid; 1211 break; 1212 } 1213 case MemberExprClass: { 1214 const MemberExpr *m = cast<MemberExpr>(this); 1215 if (Ctx.getLangOptions().CPlusPlus) { // C++ [expr.ref]p4: 1216 NamedDecl *Member = m->getMemberDecl(); 1217 // C++ [expr.ref]p4: 1218 // If E2 is declared to have type "reference to T", then E1.E2 1219 // is an lvalue. 1220 if (ValueDecl *Value = dyn_cast<ValueDecl>(Member)) 1221 if (Value->getType()->isReferenceType()) 1222 return LV_Valid; 1223 1224 // -- If E2 is a static data member [...] then E1.E2 is an lvalue. 1225 if (isa<VarDecl>(Member) && Member->getDeclContext()->isRecord()) 1226 return LV_Valid; 1227 1228 // -- If E2 is a non-static data member [...]. If E1 is an 1229 // lvalue, then E1.E2 is an lvalue. 1230 if (isa<FieldDecl>(Member)) { 1231 if (m->isArrow()) 1232 return LV_Valid; 1233 return m->getBase()->isLvalue(Ctx); 1234 } 1235 1236 // -- If it refers to a static member function [...], then 1237 // E1.E2 is an lvalue. 1238 // -- Otherwise, if E1.E2 refers to a non-static member 1239 // function [...], then E1.E2 is not an lvalue. 1240 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) 1241 return Method->isStatic()? LV_Valid : LV_MemberFunction; 1242 1243 // -- If E2 is a member enumerator [...], the expression E1.E2 1244 // is not an lvalue. 1245 if (isa<EnumConstantDecl>(Member)) 1246 return LV_InvalidExpression; 1247 1248 // Not an lvalue. 1249 return LV_InvalidExpression; 1250 } 1251 1252 // C99 6.5.2.3p4 1253 if (m->isArrow()) 1254 return LV_Valid; 1255 Expr *BaseExp = m->getBase(); 1256 if (BaseExp->getStmtClass() == ObjCPropertyRefExprClass || 1257 BaseExp->getStmtClass() == ObjCImplicitSetterGetterRefExprClass) 1258 return LV_SubObjCPropertySetting; 1259 return 1260 BaseExp->isLvalue(Ctx); 1261 } 1262 case UnaryOperatorClass: 1263 if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref) 1264 return LV_Valid; // C99 6.5.3p4 1265 1266 if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real || 1267 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag || 1268 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension) 1269 return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx); // GNU. 1270 1271 if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.pre.incr]p1 1272 (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreInc || 1273 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreDec)) 1274 return LV_Valid; 1275 break; 1276 case ImplicitCastExprClass: 1277 if (cast<ImplicitCastExpr>(this)->isLvalueCast()) 1278 return LV_Valid; 1279 1280 // If this is a conversion to a class temporary, make a note of 1281 // that. 1282 if (Ctx.getLangOptions().CPlusPlus && getType()->isRecordType()) 1283 return LV_ClassTemporary; 1284 1285 break; 1286 case ParenExprClass: // C99 6.5.1p5 1287 return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx); 1288 case BinaryOperatorClass: 1289 case CompoundAssignOperatorClass: { 1290 const BinaryOperator *BinOp = cast<BinaryOperator>(this); 1291 1292 if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.comma]p1 1293 BinOp->getOpcode() == BinaryOperator::Comma) 1294 return BinOp->getRHS()->isLvalue(Ctx); 1295 1296 // C++ [expr.mptr.oper]p6 1297 // The result of a .* expression is an lvalue only if its first operand is 1298 // an lvalue and its second operand is a pointer to data member. 1299 if (BinOp->getOpcode() == BinaryOperator::PtrMemD && 1300 !BinOp->getType()->isFunctionType()) 1301 return BinOp->getLHS()->isLvalue(Ctx); 1302 1303 // The result of an ->* expression is an lvalue only if its second operand 1304 // is a pointer to data member. 1305 if (BinOp->getOpcode() == BinaryOperator::PtrMemI && 1306 !BinOp->getType()->isFunctionType()) { 1307 QualType Ty = BinOp->getRHS()->getType(); 1308 if (Ty->isMemberPointerType() && !Ty->isMemberFunctionPointerType()) 1309 return LV_Valid; 1310 } 1311 1312 if (!BinOp->isAssignmentOp()) 1313 return LV_InvalidExpression; 1314 1315 if (Ctx.getLangOptions().CPlusPlus) 1316 // C++ [expr.ass]p1: 1317 // The result of an assignment operation [...] is an lvalue. 1318 return LV_Valid; 1319 1320 1321 // C99 6.5.16: 1322 // An assignment expression [...] is not an lvalue. 1323 return LV_InvalidExpression; 1324 } 1325 case CallExprClass: 1326 case CXXOperatorCallExprClass: 1327 case CXXMemberCallExprClass: { 1328 // C++0x [expr.call]p10 1329 // A function call is an lvalue if and only if the result type 1330 // is an lvalue reference. 1331 QualType ReturnType = cast<CallExpr>(this)->getCallReturnType(); 1332 if (ReturnType->isLValueReferenceType()) 1333 return LV_Valid; 1334 1335 // If the function is returning a class temporary, make a note of 1336 // that. 1337 if (Ctx.getLangOptions().CPlusPlus && ReturnType->isRecordType()) 1338 return LV_ClassTemporary; 1339 1340 break; 1341 } 1342 case CompoundLiteralExprClass: // C99 6.5.2.5p5 1343 // FIXME: Is this what we want in C++? 1344 return LV_Valid; 1345 case ChooseExprClass: 1346 // __builtin_choose_expr is an lvalue if the selected operand is. 1347 return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)->isLvalue(Ctx); 1348 case ExtVectorElementExprClass: 1349 if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements()) 1350 return LV_DuplicateVectorComponents; 1351 return LV_Valid; 1352 case ObjCIvarRefExprClass: // ObjC instance variables are lvalues. 1353 return LV_Valid; 1354 case ObjCPropertyRefExprClass: // FIXME: check if read-only property. 1355 return LV_Valid; 1356 case ObjCImplicitSetterGetterRefExprClass: 1357 // FIXME: check if read-only property. 1358 return LV_Valid; 1359 case PredefinedExprClass: 1360 return LV_Valid; 1361 case UnresolvedLookupExprClass: 1362 case UnresolvedMemberExprClass: 1363 return LV_Valid; 1364 case CXXDefaultArgExprClass: 1365 return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx); 1366 case CStyleCastExprClass: 1367 case CXXFunctionalCastExprClass: 1368 case CXXStaticCastExprClass: 1369 case CXXDynamicCastExprClass: 1370 case CXXReinterpretCastExprClass: 1371 case CXXConstCastExprClass: 1372 // The result of an explicit cast is an lvalue if the type we are 1373 // casting to is an lvalue reference type. See C++ [expr.cast]p1, 1374 // C++ [expr.static.cast]p2, C++ [expr.dynamic.cast]p2, 1375 // C++ [expr.reinterpret.cast]p1, C++ [expr.const.cast]p1. 1376 if (cast<ExplicitCastExpr>(this)->getTypeAsWritten()-> 1377 isLValueReferenceType()) 1378 return LV_Valid; 1379 1380 // If this is a conversion to a class temporary, make a note of 1381 // that. 1382 if (Ctx.getLangOptions().CPlusPlus && 1383 cast<ExplicitCastExpr>(this)->getTypeAsWritten()->isRecordType()) 1384 return LV_ClassTemporary; 1385 1386 break; 1387 case CXXTypeidExprClass: 1388 // C++ 5.2.8p1: The result of a typeid expression is an lvalue of ... 1389 return LV_Valid; 1390 case CXXBindTemporaryExprClass: 1391 return cast<CXXBindTemporaryExpr>(this)->getSubExpr()-> 1392 isLvalueInternal(Ctx); 1393 case CXXBindReferenceExprClass: 1394 // Something that's bound to a reference is always an lvalue. 1395 return LV_Valid; 1396 case ConditionalOperatorClass: { 1397 // Complicated handling is only for C++. 1398 if (!Ctx.getLangOptions().CPlusPlus) 1399 return LV_InvalidExpression; 1400 1401 // Sema should have taken care to ensure that a CXXTemporaryObjectExpr is 1402 // everywhere there's an object converted to an rvalue. Also, any other 1403 // casts should be wrapped by ImplicitCastExprs. There's just the special 1404 // case involving throws to work out. 1405 const ConditionalOperator *Cond = cast<ConditionalOperator>(this); 1406 Expr *True = Cond->getTrueExpr(); 1407 Expr *False = Cond->getFalseExpr(); 1408 // C++0x 5.16p2 1409 // If either the second or the third operand has type (cv) void, [...] 1410 // the result [...] is an rvalue. 1411 if (True->getType()->isVoidType() || False->getType()->isVoidType()) 1412 return LV_InvalidExpression; 1413 1414 // Both sides must be lvalues for the result to be an lvalue. 1415 if (True->isLvalue(Ctx) != LV_Valid || False->isLvalue(Ctx) != LV_Valid) 1416 return LV_InvalidExpression; 1417 1418 // That's it. 1419 return LV_Valid; 1420 } 1421 1422 case Expr::CXXExprWithTemporariesClass: 1423 return cast<CXXExprWithTemporaries>(this)->getSubExpr()->isLvalue(Ctx); 1424 1425 case Expr::ObjCMessageExprClass: 1426 if (const ObjCMethodDecl *Method 1427 = cast<ObjCMessageExpr>(this)->getMethodDecl()) 1428 if (Method->getResultType()->isLValueReferenceType()) 1429 return LV_Valid; 1430 break; 1431 1432 case Expr::CXXConstructExprClass: 1433 case Expr::CXXTemporaryObjectExprClass: 1434 case Expr::CXXZeroInitValueExprClass: 1435 return LV_ClassTemporary; 1436 1437 default: 1438 break; 1439 } 1440 return LV_InvalidExpression; 1441} 1442 1443/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, 1444/// does not have an incomplete type, does not have a const-qualified type, and 1445/// if it is a structure or union, does not have any member (including, 1446/// recursively, any member or element of all contained aggregates or unions) 1447/// with a const-qualified type. 1448Expr::isModifiableLvalueResult 1449Expr::isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc) const { 1450 isLvalueResult lvalResult = isLvalue(Ctx); 1451 1452 switch (lvalResult) { 1453 case LV_Valid: 1454 // C++ 3.10p11: Functions cannot be modified, but pointers to 1455 // functions can be modifiable. 1456 if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType()) 1457 return MLV_NotObjectType; 1458 break; 1459 1460 case LV_NotObjectType: return MLV_NotObjectType; 1461 case LV_IncompleteVoidType: return MLV_IncompleteVoidType; 1462 case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents; 1463 case LV_InvalidExpression: 1464 // If the top level is a C-style cast, and the subexpression is a valid 1465 // lvalue, then this is probably a use of the old-school "cast as lvalue" 1466 // GCC extension. We don't support it, but we want to produce good 1467 // diagnostics when it happens so that the user knows why. 1468 if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(IgnoreParens())) { 1469 if (CE->getSubExpr()->isLvalue(Ctx) == LV_Valid) { 1470 if (Loc) 1471 *Loc = CE->getLParenLoc(); 1472 return MLV_LValueCast; 1473 } 1474 } 1475 return MLV_InvalidExpression; 1476 case LV_MemberFunction: return MLV_MemberFunction; 1477 case LV_SubObjCPropertySetting: return MLV_SubObjCPropertySetting; 1478 case LV_ClassTemporary: 1479 return MLV_ClassTemporary; 1480 } 1481 1482 // The following is illegal: 1483 // void takeclosure(void (^C)(void)); 1484 // void func() { int x = 1; takeclosure(^{ x = 7; }); } 1485 // 1486 if (const BlockDeclRefExpr *BDR = dyn_cast<BlockDeclRefExpr>(this)) { 1487 if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl())) 1488 return MLV_NotBlockQualified; 1489 } 1490 1491 // Assigning to an 'implicit' property? 1492 if (const ObjCImplicitSetterGetterRefExpr* Expr = 1493 dyn_cast<ObjCImplicitSetterGetterRefExpr>(this)) { 1494 if (Expr->getSetterMethod() == 0) 1495 return MLV_NoSetterProperty; 1496 } 1497 1498 QualType CT = Ctx.getCanonicalType(getType()); 1499 1500 if (CT.isConstQualified()) 1501 return MLV_ConstQualified; 1502 if (CT->isArrayType()) 1503 return MLV_ArrayType; 1504 if (CT->isIncompleteType()) 1505 return MLV_IncompleteType; 1506 1507 if (const RecordType *r = CT->getAs<RecordType>()) { 1508 if (r->hasConstFields()) 1509 return MLV_ConstQualified; 1510 } 1511 1512 return MLV_Valid; 1513} 1514 1515/// isOBJCGCCandidate - Check if an expression is objc gc'able. 1516/// returns true, if it is; false otherwise. 1517bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const { 1518 switch (getStmtClass()) { 1519 default: 1520 return false; 1521 case ObjCIvarRefExprClass: 1522 return true; 1523 case Expr::UnaryOperatorClass: 1524 return cast<UnaryOperator>(this)->getSubExpr()->isOBJCGCCandidate(Ctx); 1525 case ParenExprClass: 1526 return cast<ParenExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx); 1527 case ImplicitCastExprClass: 1528 return cast<ImplicitCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx); 1529 case CStyleCastExprClass: 1530 return cast<CStyleCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx); 1531 case DeclRefExprClass: { 1532 const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 1533 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1534 if (VD->hasGlobalStorage()) 1535 return true; 1536 QualType T = VD->getType(); 1537 // dereferencing to a pointer is always a gc'able candidate, 1538 // unless it is __weak. 1539 return T->isPointerType() && 1540 (Ctx.getObjCGCAttrKind(T) != Qualifiers::Weak); 1541 } 1542 return false; 1543 } 1544 case MemberExprClass: { 1545 const MemberExpr *M = cast<MemberExpr>(this); 1546 return M->getBase()->isOBJCGCCandidate(Ctx); 1547 } 1548 case ArraySubscriptExprClass: 1549 return cast<ArraySubscriptExpr>(this)->getBase()->isOBJCGCCandidate(Ctx); 1550 } 1551} 1552Expr* Expr::IgnoreParens() { 1553 Expr* E = this; 1554 while (ParenExpr* P = dyn_cast<ParenExpr>(E)) 1555 E = P->getSubExpr(); 1556 1557 return E; 1558} 1559 1560/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr 1561/// or CastExprs or ImplicitCastExprs, returning their operand. 1562Expr *Expr::IgnoreParenCasts() { 1563 Expr *E = this; 1564 while (true) { 1565 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) 1566 E = P->getSubExpr(); 1567 else if (CastExpr *P = dyn_cast<CastExpr>(E)) 1568 E = P->getSubExpr(); 1569 else 1570 return E; 1571 } 1572} 1573 1574Expr *Expr::IgnoreParenImpCasts() { 1575 Expr *E = this; 1576 while (true) { 1577 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) 1578 E = P->getSubExpr(); 1579 else if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E)) 1580 E = P->getSubExpr(); 1581 else 1582 return E; 1583 } 1584} 1585 1586/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the 1587/// value (including ptr->int casts of the same size). Strip off any 1588/// ParenExpr or CastExprs, returning their operand. 1589Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) { 1590 Expr *E = this; 1591 while (true) { 1592 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) { 1593 E = P->getSubExpr(); 1594 continue; 1595 } 1596 1597 if (CastExpr *P = dyn_cast<CastExpr>(E)) { 1598 // We ignore integer <-> casts that are of the same width, ptr<->ptr and 1599 // ptr<->int casts of the same width. We also ignore all identify casts. 1600 Expr *SE = P->getSubExpr(); 1601 1602 if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) { 1603 E = SE; 1604 continue; 1605 } 1606 1607 if ((E->getType()->isPointerType() || E->getType()->isIntegralType()) && 1608 (SE->getType()->isPointerType() || SE->getType()->isIntegralType()) && 1609 Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) { 1610 E = SE; 1611 continue; 1612 } 1613 } 1614 1615 return E; 1616 } 1617} 1618 1619bool Expr::isDefaultArgument() const { 1620 const Expr *E = this; 1621 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 1622 E = ICE->getSubExprAsWritten(); 1623 1624 return isa<CXXDefaultArgExpr>(E); 1625} 1626 1627/// \brief Skip over any no-op casts and any temporary-binding 1628/// expressions. 1629static const Expr *skipTemporaryBindingsAndNoOpCasts(const Expr *E) { 1630 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 1631 if (ICE->getCastKind() == CastExpr::CK_NoOp) 1632 E = ICE->getSubExpr(); 1633 else 1634 break; 1635 } 1636 1637 while (const CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E)) 1638 E = BE->getSubExpr(); 1639 1640 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 1641 if (ICE->getCastKind() == CastExpr::CK_NoOp) 1642 E = ICE->getSubExpr(); 1643 else 1644 break; 1645 } 1646 1647 return E; 1648} 1649 1650const Expr *Expr::getTemporaryObject() const { 1651 const Expr *E = skipTemporaryBindingsAndNoOpCasts(this); 1652 1653 // A cast can produce a temporary object. The object's construction 1654 // is represented as a CXXConstructExpr. 1655 if (const CastExpr *Cast = dyn_cast<CastExpr>(E)) { 1656 // Only user-defined and constructor conversions can produce 1657 // temporary objects. 1658 if (Cast->getCastKind() != CastExpr::CK_ConstructorConversion && 1659 Cast->getCastKind() != CastExpr::CK_UserDefinedConversion) 1660 return 0; 1661 1662 // Strip off temporary bindings and no-op casts. 1663 const Expr *Sub = skipTemporaryBindingsAndNoOpCasts(Cast->getSubExpr()); 1664 1665 // If this is a constructor conversion, see if we have an object 1666 // construction. 1667 if (Cast->getCastKind() == CastExpr::CK_ConstructorConversion) 1668 return dyn_cast<CXXConstructExpr>(Sub); 1669 1670 // If this is a user-defined conversion, see if we have a call to 1671 // a function that itself returns a temporary object. 1672 if (Cast->getCastKind() == CastExpr::CK_UserDefinedConversion) 1673 if (const CallExpr *CE = dyn_cast<CallExpr>(Sub)) 1674 if (CE->getCallReturnType()->isRecordType()) 1675 return CE; 1676 1677 return 0; 1678 } 1679 1680 // A call returning a class type returns a temporary. 1681 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) { 1682 if (CE->getCallReturnType()->isRecordType()) 1683 return CE; 1684 1685 return 0; 1686 } 1687 1688 // Explicit temporary object constructors create temporaries. 1689 return dyn_cast<CXXTemporaryObjectExpr>(E); 1690} 1691 1692/// hasAnyTypeDependentArguments - Determines if any of the expressions 1693/// in Exprs is type-dependent. 1694bool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) { 1695 for (unsigned I = 0; I < NumExprs; ++I) 1696 if (Exprs[I]->isTypeDependent()) 1697 return true; 1698 1699 return false; 1700} 1701 1702/// hasAnyValueDependentArguments - Determines if any of the expressions 1703/// in Exprs is value-dependent. 1704bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) { 1705 for (unsigned I = 0; I < NumExprs; ++I) 1706 if (Exprs[I]->isValueDependent()) 1707 return true; 1708 1709 return false; 1710} 1711 1712bool Expr::isConstantInitializer(ASTContext &Ctx) const { 1713 // This function is attempting whether an expression is an initializer 1714 // which can be evaluated at compile-time. isEvaluatable handles most 1715 // of the cases, but it can't deal with some initializer-specific 1716 // expressions, and it can't deal with aggregates; we deal with those here, 1717 // and fall back to isEvaluatable for the other cases. 1718 1719 // FIXME: This function assumes the variable being assigned to 1720 // isn't a reference type! 1721 1722 switch (getStmtClass()) { 1723 default: break; 1724 case StringLiteralClass: 1725 case ObjCStringLiteralClass: 1726 case ObjCEncodeExprClass: 1727 return true; 1728 case CompoundLiteralExprClass: { 1729 // This handles gcc's extension that allows global initializers like 1730 // "struct x {int x;} x = (struct x) {};". 1731 // FIXME: This accepts other cases it shouldn't! 1732 const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer(); 1733 return Exp->isConstantInitializer(Ctx); 1734 } 1735 case InitListExprClass: { 1736 // FIXME: This doesn't deal with fields with reference types correctly. 1737 // FIXME: This incorrectly allows pointers cast to integers to be assigned 1738 // to bitfields. 1739 const InitListExpr *Exp = cast<InitListExpr>(this); 1740 unsigned numInits = Exp->getNumInits(); 1741 for (unsigned i = 0; i < numInits; i++) { 1742 if (!Exp->getInit(i)->isConstantInitializer(Ctx)) 1743 return false; 1744 } 1745 return true; 1746 } 1747 case ImplicitValueInitExprClass: 1748 return true; 1749 case ParenExprClass: 1750 return cast<ParenExpr>(this)->getSubExpr()->isConstantInitializer(Ctx); 1751 case UnaryOperatorClass: { 1752 const UnaryOperator* Exp = cast<UnaryOperator>(this); 1753 if (Exp->getOpcode() == UnaryOperator::Extension) 1754 return Exp->getSubExpr()->isConstantInitializer(Ctx); 1755 break; 1756 } 1757 case BinaryOperatorClass: { 1758 // Special case &&foo - &&bar. It would be nice to generalize this somehow 1759 // but this handles the common case. 1760 const BinaryOperator *Exp = cast<BinaryOperator>(this); 1761 if (Exp->getOpcode() == BinaryOperator::Sub && 1762 isa<AddrLabelExpr>(Exp->getLHS()->IgnoreParenNoopCasts(Ctx)) && 1763 isa<AddrLabelExpr>(Exp->getRHS()->IgnoreParenNoopCasts(Ctx))) 1764 return true; 1765 break; 1766 } 1767 case ImplicitCastExprClass: 1768 case CStyleCastExprClass: 1769 // Handle casts with a destination that's a struct or union; this 1770 // deals with both the gcc no-op struct cast extension and the 1771 // cast-to-union extension. 1772 if (getType()->isRecordType()) 1773 return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx); 1774 1775 // Integer->integer casts can be handled here, which is important for 1776 // things like (int)(&&x-&&y). Scary but true. 1777 if (getType()->isIntegerType() && 1778 cast<CastExpr>(this)->getSubExpr()->getType()->isIntegerType()) 1779 return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx); 1780 1781 break; 1782 } 1783 return isEvaluatable(Ctx); 1784} 1785 1786/// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an 1787/// integer constant expression with the value zero, or if this is one that is 1788/// cast to void*. 1789bool Expr::isNullPointerConstant(ASTContext &Ctx, 1790 NullPointerConstantValueDependence NPC) const { 1791 if (isValueDependent()) { 1792 switch (NPC) { 1793 case NPC_NeverValueDependent: 1794 assert(false && "Unexpected value dependent expression!"); 1795 // If the unthinkable happens, fall through to the safest alternative. 1796 1797 case NPC_ValueDependentIsNull: 1798 return isTypeDependent() || getType()->isIntegralType(); 1799 1800 case NPC_ValueDependentIsNotNull: 1801 return false; 1802 } 1803 } 1804 1805 // Strip off a cast to void*, if it exists. Except in C++. 1806 if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) { 1807 if (!Ctx.getLangOptions().CPlusPlus) { 1808 // Check that it is a cast to void*. 1809 if (const PointerType *PT = CE->getType()->getAs<PointerType>()) { 1810 QualType Pointee = PT->getPointeeType(); 1811 if (!Pointee.hasQualifiers() && 1812 Pointee->isVoidType() && // to void* 1813 CE->getSubExpr()->getType()->isIntegerType()) // from int. 1814 return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC); 1815 } 1816 } 1817 } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) { 1818 // Ignore the ImplicitCastExpr type entirely. 1819 return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC); 1820 } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) { 1821 // Accept ((void*)0) as a null pointer constant, as many other 1822 // implementations do. 1823 return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC); 1824 } else if (const CXXDefaultArgExpr *DefaultArg 1825 = dyn_cast<CXXDefaultArgExpr>(this)) { 1826 // See through default argument expressions 1827 return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC); 1828 } else if (isa<GNUNullExpr>(this)) { 1829 // The GNU __null extension is always a null pointer constant. 1830 return true; 1831 } 1832 1833 // C++0x nullptr_t is always a null pointer constant. 1834 if (getType()->isNullPtrType()) 1835 return true; 1836 1837 // This expression must be an integer type. 1838 if (!getType()->isIntegerType() || 1839 (Ctx.getLangOptions().CPlusPlus && getType()->isEnumeralType())) 1840 return false; 1841 1842 // If we have an integer constant expression, we need to *evaluate* it and 1843 // test for the value 0. 1844 llvm::APSInt Result; 1845 return isIntegerConstantExpr(Result, Ctx) && Result == 0; 1846} 1847 1848FieldDecl *Expr::getBitField() { 1849 Expr *E = this->IgnoreParens(); 1850 1851 while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 1852 if (ICE->isLvalueCast() && ICE->getCastKind() == CastExpr::CK_NoOp) 1853 E = ICE->getSubExpr()->IgnoreParens(); 1854 else 1855 break; 1856 } 1857 1858 if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E)) 1859 if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl())) 1860 if (Field->isBitField()) 1861 return Field; 1862 1863 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E)) 1864 if (BinOp->isAssignmentOp() && BinOp->getLHS()) 1865 return BinOp->getLHS()->getBitField(); 1866 1867 return 0; 1868} 1869 1870bool Expr::refersToVectorElement() const { 1871 const Expr *E = this->IgnoreParens(); 1872 1873 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 1874 if (ICE->isLvalueCast() && ICE->getCastKind() == CastExpr::CK_NoOp) 1875 E = ICE->getSubExpr()->IgnoreParens(); 1876 else 1877 break; 1878 } 1879 1880 if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) 1881 return ASE->getBase()->getType()->isVectorType(); 1882 1883 if (isa<ExtVectorElementExpr>(E)) 1884 return true; 1885 1886 return false; 1887} 1888 1889/// isArrow - Return true if the base expression is a pointer to vector, 1890/// return false if the base expression is a vector. 1891bool ExtVectorElementExpr::isArrow() const { 1892 return getBase()->getType()->isPointerType(); 1893} 1894 1895unsigned ExtVectorElementExpr::getNumElements() const { 1896 if (const VectorType *VT = getType()->getAs<VectorType>()) 1897 return VT->getNumElements(); 1898 return 1; 1899} 1900 1901/// containsDuplicateElements - Return true if any element access is repeated. 1902bool ExtVectorElementExpr::containsDuplicateElements() const { 1903 // FIXME: Refactor this code to an accessor on the AST node which returns the 1904 // "type" of component access, and share with code below and in Sema. 1905 llvm::StringRef Comp = Accessor->getName(); 1906 1907 // Halving swizzles do not contain duplicate elements. 1908 if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd") 1909 return false; 1910 1911 // Advance past s-char prefix on hex swizzles. 1912 if (Comp[0] == 's' || Comp[0] == 'S') 1913 Comp = Comp.substr(1); 1914 1915 for (unsigned i = 0, e = Comp.size(); i != e; ++i) 1916 if (Comp.substr(i + 1).find(Comp[i]) != llvm::StringRef::npos) 1917 return true; 1918 1919 return false; 1920} 1921 1922/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 1923void ExtVectorElementExpr::getEncodedElementAccess( 1924 llvm::SmallVectorImpl<unsigned> &Elts) const { 1925 llvm::StringRef Comp = Accessor->getName(); 1926 if (Comp[0] == 's' || Comp[0] == 'S') 1927 Comp = Comp.substr(1); 1928 1929 bool isHi = Comp == "hi"; 1930 bool isLo = Comp == "lo"; 1931 bool isEven = Comp == "even"; 1932 bool isOdd = Comp == "odd"; 1933 1934 for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 1935 uint64_t Index; 1936 1937 if (isHi) 1938 Index = e + i; 1939 else if (isLo) 1940 Index = i; 1941 else if (isEven) 1942 Index = 2 * i; 1943 else if (isOdd) 1944 Index = 2 * i + 1; 1945 else 1946 Index = ExtVectorType::getAccessorIdx(Comp[i]); 1947 1948 Elts.push_back(Index); 1949 } 1950} 1951 1952ObjCMessageExpr::ObjCMessageExpr(QualType T, 1953 SourceLocation LBracLoc, 1954 SourceLocation SuperLoc, 1955 bool IsInstanceSuper, 1956 QualType SuperType, 1957 Selector Sel, 1958 ObjCMethodDecl *Method, 1959 Expr **Args, unsigned NumArgs, 1960 SourceLocation RBracLoc) 1961 : Expr(ObjCMessageExprClass, T, /*TypeDependent=*/false, 1962 /*ValueDependent=*/false), 1963 NumArgs(NumArgs), Kind(IsInstanceSuper? SuperInstance : SuperClass), 1964 HasMethod(Method != 0), SuperLoc(SuperLoc), 1965 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method 1966 : Sel.getAsOpaquePtr())), 1967 LBracLoc(LBracLoc), RBracLoc(RBracLoc) 1968{ 1969 setReceiverPointer(SuperType.getAsOpaquePtr()); 1970 if (NumArgs) 1971 memcpy(getArgs(), Args, NumArgs * sizeof(Expr *)); 1972} 1973 1974ObjCMessageExpr::ObjCMessageExpr(QualType T, 1975 SourceLocation LBracLoc, 1976 TypeSourceInfo *Receiver, 1977 Selector Sel, 1978 ObjCMethodDecl *Method, 1979 Expr **Args, unsigned NumArgs, 1980 SourceLocation RBracLoc) 1981 : Expr(ObjCMessageExprClass, T, T->isDependentType(), 1982 (T->isDependentType() || 1983 hasAnyValueDependentArguments(Args, NumArgs))), 1984 NumArgs(NumArgs), Kind(Class), HasMethod(Method != 0), 1985 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method 1986 : Sel.getAsOpaquePtr())), 1987 LBracLoc(LBracLoc), RBracLoc(RBracLoc) 1988{ 1989 setReceiverPointer(Receiver); 1990 if (NumArgs) 1991 memcpy(getArgs(), Args, NumArgs * sizeof(Expr *)); 1992} 1993 1994ObjCMessageExpr::ObjCMessageExpr(QualType T, 1995 SourceLocation LBracLoc, 1996 Expr *Receiver, 1997 Selector Sel, 1998 ObjCMethodDecl *Method, 1999 Expr **Args, unsigned NumArgs, 2000 SourceLocation RBracLoc) 2001 : Expr(ObjCMessageExprClass, T, Receiver->isTypeDependent(), 2002 (Receiver->isTypeDependent() || 2003 hasAnyValueDependentArguments(Args, NumArgs))), 2004 NumArgs(NumArgs), Kind(Instance), HasMethod(Method != 0), 2005 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method 2006 : Sel.getAsOpaquePtr())), 2007 LBracLoc(LBracLoc), RBracLoc(RBracLoc) 2008{ 2009 setReceiverPointer(Receiver); 2010 if (NumArgs) 2011 memcpy(getArgs(), Args, NumArgs * sizeof(Expr *)); 2012} 2013 2014ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T, 2015 SourceLocation LBracLoc, 2016 SourceLocation SuperLoc, 2017 bool IsInstanceSuper, 2018 QualType SuperType, 2019 Selector Sel, 2020 ObjCMethodDecl *Method, 2021 Expr **Args, unsigned NumArgs, 2022 SourceLocation RBracLoc) { 2023 unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) + 2024 NumArgs * sizeof(Expr *); 2025 void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment); 2026 return new (Mem) ObjCMessageExpr(T, LBracLoc, SuperLoc, IsInstanceSuper, 2027 SuperType, Sel, Method, Args, NumArgs, 2028 RBracLoc); 2029} 2030 2031ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T, 2032 SourceLocation LBracLoc, 2033 TypeSourceInfo *Receiver, 2034 Selector Sel, 2035 ObjCMethodDecl *Method, 2036 Expr **Args, unsigned NumArgs, 2037 SourceLocation RBracLoc) { 2038 unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) + 2039 NumArgs * sizeof(Expr *); 2040 void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment); 2041 return new (Mem) ObjCMessageExpr(T, LBracLoc, Receiver, Sel, Method, Args, 2042 NumArgs, RBracLoc); 2043} 2044 2045ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T, 2046 SourceLocation LBracLoc, 2047 Expr *Receiver, 2048 Selector Sel, 2049 ObjCMethodDecl *Method, 2050 Expr **Args, unsigned NumArgs, 2051 SourceLocation RBracLoc) { 2052 unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) + 2053 NumArgs * sizeof(Expr *); 2054 void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment); 2055 return new (Mem) ObjCMessageExpr(T, LBracLoc, Receiver, Sel, Method, Args, 2056 NumArgs, RBracLoc); 2057} 2058 2059ObjCMessageExpr *ObjCMessageExpr::CreateEmpty(ASTContext &Context, 2060 unsigned NumArgs) { 2061 unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) + 2062 NumArgs * sizeof(Expr *); 2063 void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment); 2064 return new (Mem) ObjCMessageExpr(EmptyShell(), NumArgs); 2065} 2066 2067Selector ObjCMessageExpr::getSelector() const { 2068 if (HasMethod) 2069 return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod) 2070 ->getSelector(); 2071 return Selector(SelectorOrMethod); 2072} 2073 2074ObjCInterfaceDecl *ObjCMessageExpr::getReceiverInterface() const { 2075 switch (getReceiverKind()) { 2076 case Instance: 2077 if (const ObjCObjectPointerType *Ptr 2078 = getInstanceReceiver()->getType()->getAs<ObjCObjectPointerType>()) 2079 return Ptr->getInterfaceDecl(); 2080 break; 2081 2082 case Class: 2083 if (const ObjCInterfaceType *Iface 2084 = getClassReceiver()->getAs<ObjCInterfaceType>()) 2085 return Iface->getDecl(); 2086 break; 2087 2088 case SuperInstance: 2089 if (const ObjCObjectPointerType *Ptr 2090 = getSuperType()->getAs<ObjCObjectPointerType>()) 2091 return Ptr->getInterfaceDecl(); 2092 break; 2093 2094 case SuperClass: 2095 if (const ObjCObjectPointerType *Iface 2096 = getSuperType()->getAs<ObjCObjectPointerType>()) 2097 return Iface->getInterfaceDecl(); 2098 break; 2099 } 2100 2101 return 0; 2102} 2103 2104bool ChooseExpr::isConditionTrue(ASTContext &C) const { 2105 return getCond()->EvaluateAsInt(C) != 0; 2106} 2107 2108void ShuffleVectorExpr::setExprs(ASTContext &C, Expr ** Exprs, 2109 unsigned NumExprs) { 2110 if (SubExprs) C.Deallocate(SubExprs); 2111 2112 SubExprs = new (C) Stmt* [NumExprs]; 2113 this->NumExprs = NumExprs; 2114 memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs); 2115} 2116 2117void ShuffleVectorExpr::DoDestroy(ASTContext& C) { 2118 DestroyChildren(C); 2119 if (SubExprs) C.Deallocate(SubExprs); 2120 this->~ShuffleVectorExpr(); 2121 C.Deallocate(this); 2122} 2123 2124void SizeOfAlignOfExpr::DoDestroy(ASTContext& C) { 2125 // Override default behavior of traversing children. If this has a type 2126 // operand and the type is a variable-length array, the child iteration 2127 // will iterate over the size expression. However, this expression belongs 2128 // to the type, not to this, so we don't want to delete it. 2129 // We still want to delete this expression. 2130 if (isArgumentType()) { 2131 this->~SizeOfAlignOfExpr(); 2132 C.Deallocate(this); 2133 } 2134 else 2135 Expr::DoDestroy(C); 2136} 2137 2138//===----------------------------------------------------------------------===// 2139// DesignatedInitExpr 2140//===----------------------------------------------------------------------===// 2141 2142IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() { 2143 assert(Kind == FieldDesignator && "Only valid on a field designator"); 2144 if (Field.NameOrField & 0x01) 2145 return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01); 2146 else 2147 return getField()->getIdentifier(); 2148} 2149 2150DesignatedInitExpr::DesignatedInitExpr(ASTContext &C, QualType Ty, 2151 unsigned NumDesignators, 2152 const Designator *Designators, 2153 SourceLocation EqualOrColonLoc, 2154 bool GNUSyntax, 2155 Expr **IndexExprs, 2156 unsigned NumIndexExprs, 2157 Expr *Init) 2158 : Expr(DesignatedInitExprClass, Ty, 2159 Init->isTypeDependent(), Init->isValueDependent()), 2160 EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax), 2161 NumDesignators(NumDesignators), NumSubExprs(NumIndexExprs + 1) { 2162 this->Designators = new (C) Designator[NumDesignators]; 2163 2164 // Record the initializer itself. 2165 child_iterator Child = child_begin(); 2166 *Child++ = Init; 2167 2168 // Copy the designators and their subexpressions, computing 2169 // value-dependence along the way. 2170 unsigned IndexIdx = 0; 2171 for (unsigned I = 0; I != NumDesignators; ++I) { 2172 this->Designators[I] = Designators[I]; 2173 2174 if (this->Designators[I].isArrayDesignator()) { 2175 // Compute type- and value-dependence. 2176 Expr *Index = IndexExprs[IndexIdx]; 2177 ValueDependent = ValueDependent || 2178 Index->isTypeDependent() || Index->isValueDependent(); 2179 2180 // Copy the index expressions into permanent storage. 2181 *Child++ = IndexExprs[IndexIdx++]; 2182 } else if (this->Designators[I].isArrayRangeDesignator()) { 2183 // Compute type- and value-dependence. 2184 Expr *Start = IndexExprs[IndexIdx]; 2185 Expr *End = IndexExprs[IndexIdx + 1]; 2186 ValueDependent = ValueDependent || 2187 Start->isTypeDependent() || Start->isValueDependent() || 2188 End->isTypeDependent() || End->isValueDependent(); 2189 2190 // Copy the start/end expressions into permanent storage. 2191 *Child++ = IndexExprs[IndexIdx++]; 2192 *Child++ = IndexExprs[IndexIdx++]; 2193 } 2194 } 2195 2196 assert(IndexIdx == NumIndexExprs && "Wrong number of index expressions"); 2197} 2198 2199DesignatedInitExpr * 2200DesignatedInitExpr::Create(ASTContext &C, Designator *Designators, 2201 unsigned NumDesignators, 2202 Expr **IndexExprs, unsigned NumIndexExprs, 2203 SourceLocation ColonOrEqualLoc, 2204 bool UsesColonSyntax, Expr *Init) { 2205 void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 2206 sizeof(Stmt *) * (NumIndexExprs + 1), 8); 2207 return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators, 2208 ColonOrEqualLoc, UsesColonSyntax, 2209 IndexExprs, NumIndexExprs, Init); 2210} 2211 2212DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C, 2213 unsigned NumIndexExprs) { 2214 void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 2215 sizeof(Stmt *) * (NumIndexExprs + 1), 8); 2216 return new (Mem) DesignatedInitExpr(NumIndexExprs + 1); 2217} 2218 2219void DesignatedInitExpr::setDesignators(ASTContext &C, 2220 const Designator *Desigs, 2221 unsigned NumDesigs) { 2222 DestroyDesignators(C); 2223 2224 Designators = new (C) Designator[NumDesigs]; 2225 NumDesignators = NumDesigs; 2226 for (unsigned I = 0; I != NumDesigs; ++I) 2227 Designators[I] = Desigs[I]; 2228} 2229 2230SourceRange DesignatedInitExpr::getSourceRange() const { 2231 SourceLocation StartLoc; 2232 Designator &First = 2233 *const_cast<DesignatedInitExpr*>(this)->designators_begin(); 2234 if (First.isFieldDesignator()) { 2235 if (GNUSyntax) 2236 StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc); 2237 else 2238 StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc); 2239 } else 2240 StartLoc = 2241 SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc); 2242 return SourceRange(StartLoc, getInit()->getSourceRange().getEnd()); 2243} 2244 2245Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) { 2246 assert(D.Kind == Designator::ArrayDesignator && "Requires array designator"); 2247 char* Ptr = static_cast<char*>(static_cast<void *>(this)); 2248 Ptr += sizeof(DesignatedInitExpr); 2249 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 2250 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 2251} 2252 2253Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) { 2254 assert(D.Kind == Designator::ArrayRangeDesignator && 2255 "Requires array range designator"); 2256 char* Ptr = static_cast<char*>(static_cast<void *>(this)); 2257 Ptr += sizeof(DesignatedInitExpr); 2258 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 2259 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 2260} 2261 2262Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) { 2263 assert(D.Kind == Designator::ArrayRangeDesignator && 2264 "Requires array range designator"); 2265 char* Ptr = static_cast<char*>(static_cast<void *>(this)); 2266 Ptr += sizeof(DesignatedInitExpr); 2267 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 2268 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2)); 2269} 2270 2271/// \brief Replaces the designator at index @p Idx with the series 2272/// of designators in [First, Last). 2273void DesignatedInitExpr::ExpandDesignator(ASTContext &C, unsigned Idx, 2274 const Designator *First, 2275 const Designator *Last) { 2276 unsigned NumNewDesignators = Last - First; 2277 if (NumNewDesignators == 0) { 2278 std::copy_backward(Designators + Idx + 1, 2279 Designators + NumDesignators, 2280 Designators + Idx); 2281 --NumNewDesignators; 2282 return; 2283 } else if (NumNewDesignators == 1) { 2284 Designators[Idx] = *First; 2285 return; 2286 } 2287 2288 Designator *NewDesignators 2289 = new (C) Designator[NumDesignators - 1 + NumNewDesignators]; 2290 std::copy(Designators, Designators + Idx, NewDesignators); 2291 std::copy(First, Last, NewDesignators + Idx); 2292 std::copy(Designators + Idx + 1, Designators + NumDesignators, 2293 NewDesignators + Idx + NumNewDesignators); 2294 DestroyDesignators(C); 2295 Designators = NewDesignators; 2296 NumDesignators = NumDesignators - 1 + NumNewDesignators; 2297} 2298 2299void DesignatedInitExpr::DoDestroy(ASTContext &C) { 2300 DestroyDesignators(C); 2301 Expr::DoDestroy(C); 2302} 2303 2304void DesignatedInitExpr::DestroyDesignators(ASTContext &C) { 2305 for (unsigned I = 0; I != NumDesignators; ++I) 2306 Designators[I].~Designator(); 2307 C.Deallocate(Designators); 2308 Designators = 0; 2309} 2310 2311ParenListExpr::ParenListExpr(ASTContext& C, SourceLocation lparenloc, 2312 Expr **exprs, unsigned nexprs, 2313 SourceLocation rparenloc) 2314: Expr(ParenListExprClass, QualType(), 2315 hasAnyTypeDependentArguments(exprs, nexprs), 2316 hasAnyValueDependentArguments(exprs, nexprs)), 2317 NumExprs(nexprs), LParenLoc(lparenloc), RParenLoc(rparenloc) { 2318 2319 Exprs = new (C) Stmt*[nexprs]; 2320 for (unsigned i = 0; i != nexprs; ++i) 2321 Exprs[i] = exprs[i]; 2322} 2323 2324void ParenListExpr::DoDestroy(ASTContext& C) { 2325 DestroyChildren(C); 2326 if (Exprs) C.Deallocate(Exprs); 2327 this->~ParenListExpr(); 2328 C.Deallocate(this); 2329} 2330 2331//===----------------------------------------------------------------------===// 2332// ExprIterator. 2333//===----------------------------------------------------------------------===// 2334 2335Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); } 2336Expr* ExprIterator::operator*() const { return cast<Expr>(*I); } 2337Expr* ExprIterator::operator->() const { return cast<Expr>(*I); } 2338const Expr* ConstExprIterator::operator[](size_t idx) const { 2339 return cast<Expr>(I[idx]); 2340} 2341const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); } 2342const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); } 2343 2344//===----------------------------------------------------------------------===// 2345// Child Iterators for iterating over subexpressions/substatements 2346//===----------------------------------------------------------------------===// 2347 2348// DeclRefExpr 2349Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); } 2350Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); } 2351 2352// ObjCIvarRefExpr 2353Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; } 2354Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; } 2355 2356// ObjCPropertyRefExpr 2357Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; } 2358Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; } 2359 2360// ObjCImplicitSetterGetterRefExpr 2361Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_begin() { 2362 // If this is accessing a class member, skip that entry. 2363 if (Base) return &Base; 2364 return &Base+1; 2365} 2366Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_end() { 2367 return &Base+1; 2368} 2369 2370// ObjCSuperExpr 2371Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); } 2372Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); } 2373 2374// ObjCIsaExpr 2375Stmt::child_iterator ObjCIsaExpr::child_begin() { return &Base; } 2376Stmt::child_iterator ObjCIsaExpr::child_end() { return &Base+1; } 2377 2378// PredefinedExpr 2379Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); } 2380Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); } 2381 2382// IntegerLiteral 2383Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); } 2384Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); } 2385 2386// CharacterLiteral 2387Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();} 2388Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); } 2389 2390// FloatingLiteral 2391Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); } 2392Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); } 2393 2394// ImaginaryLiteral 2395Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; } 2396Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; } 2397 2398// StringLiteral 2399Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); } 2400Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); } 2401 2402// ParenExpr 2403Stmt::child_iterator ParenExpr::child_begin() { return &Val; } 2404Stmt::child_iterator ParenExpr::child_end() { return &Val+1; } 2405 2406// UnaryOperator 2407Stmt::child_iterator UnaryOperator::child_begin() { return &Val; } 2408Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; } 2409 2410// OffsetOfExpr 2411Stmt::child_iterator OffsetOfExpr::child_begin() { 2412 return reinterpret_cast<Stmt **> (reinterpret_cast<OffsetOfNode *> (this + 1) 2413 + NumComps); 2414} 2415Stmt::child_iterator OffsetOfExpr::child_end() { 2416 return child_iterator(&*child_begin() + NumExprs); 2417} 2418 2419// SizeOfAlignOfExpr 2420Stmt::child_iterator SizeOfAlignOfExpr::child_begin() { 2421 // If this is of a type and the type is a VLA type (and not a typedef), the 2422 // size expression of the VLA needs to be treated as an executable expression. 2423 // Why isn't this weirdness documented better in StmtIterator? 2424 if (isArgumentType()) { 2425 if (VariableArrayType* T = dyn_cast<VariableArrayType>( 2426 getArgumentType().getTypePtr())) 2427 return child_iterator(T); 2428 return child_iterator(); 2429 } 2430 return child_iterator(&Argument.Ex); 2431} 2432Stmt::child_iterator SizeOfAlignOfExpr::child_end() { 2433 if (isArgumentType()) 2434 return child_iterator(); 2435 return child_iterator(&Argument.Ex + 1); 2436} 2437 2438// ArraySubscriptExpr 2439Stmt::child_iterator ArraySubscriptExpr::child_begin() { 2440 return &SubExprs[0]; 2441} 2442Stmt::child_iterator ArraySubscriptExpr::child_end() { 2443 return &SubExprs[0]+END_EXPR; 2444} 2445 2446// CallExpr 2447Stmt::child_iterator CallExpr::child_begin() { 2448 return &SubExprs[0]; 2449} 2450Stmt::child_iterator CallExpr::child_end() { 2451 return &SubExprs[0]+NumArgs+ARGS_START; 2452} 2453 2454// MemberExpr 2455Stmt::child_iterator MemberExpr::child_begin() { return &Base; } 2456Stmt::child_iterator MemberExpr::child_end() { return &Base+1; } 2457 2458// ExtVectorElementExpr 2459Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; } 2460Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; } 2461 2462// CompoundLiteralExpr 2463Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; } 2464Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; } 2465 2466// CastExpr 2467Stmt::child_iterator CastExpr::child_begin() { return &Op; } 2468Stmt::child_iterator CastExpr::child_end() { return &Op+1; } 2469 2470// BinaryOperator 2471Stmt::child_iterator BinaryOperator::child_begin() { 2472 return &SubExprs[0]; 2473} 2474Stmt::child_iterator BinaryOperator::child_end() { 2475 return &SubExprs[0]+END_EXPR; 2476} 2477 2478// ConditionalOperator 2479Stmt::child_iterator ConditionalOperator::child_begin() { 2480 return &SubExprs[0]; 2481} 2482Stmt::child_iterator ConditionalOperator::child_end() { 2483 return &SubExprs[0]+END_EXPR; 2484} 2485 2486// AddrLabelExpr 2487Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); } 2488Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); } 2489 2490// StmtExpr 2491Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; } 2492Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; } 2493 2494// TypesCompatibleExpr 2495Stmt::child_iterator TypesCompatibleExpr::child_begin() { 2496 return child_iterator(); 2497} 2498 2499Stmt::child_iterator TypesCompatibleExpr::child_end() { 2500 return child_iterator(); 2501} 2502 2503// ChooseExpr 2504Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; } 2505Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; } 2506 2507// GNUNullExpr 2508Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); } 2509Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); } 2510 2511// ShuffleVectorExpr 2512Stmt::child_iterator ShuffleVectorExpr::child_begin() { 2513 return &SubExprs[0]; 2514} 2515Stmt::child_iterator ShuffleVectorExpr::child_end() { 2516 return &SubExprs[0]+NumExprs; 2517} 2518 2519// VAArgExpr 2520Stmt::child_iterator VAArgExpr::child_begin() { return &Val; } 2521Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; } 2522 2523// InitListExpr 2524Stmt::child_iterator InitListExpr::child_begin() { 2525 return InitExprs.size() ? &InitExprs[0] : 0; 2526} 2527Stmt::child_iterator InitListExpr::child_end() { 2528 return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0; 2529} 2530 2531// DesignatedInitExpr 2532Stmt::child_iterator DesignatedInitExpr::child_begin() { 2533 char* Ptr = static_cast<char*>(static_cast<void *>(this)); 2534 Ptr += sizeof(DesignatedInitExpr); 2535 return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 2536} 2537Stmt::child_iterator DesignatedInitExpr::child_end() { 2538 return child_iterator(&*child_begin() + NumSubExprs); 2539} 2540 2541// ImplicitValueInitExpr 2542Stmt::child_iterator ImplicitValueInitExpr::child_begin() { 2543 return child_iterator(); 2544} 2545 2546Stmt::child_iterator ImplicitValueInitExpr::child_end() { 2547 return child_iterator(); 2548} 2549 2550// ParenListExpr 2551Stmt::child_iterator ParenListExpr::child_begin() { 2552 return &Exprs[0]; 2553} 2554Stmt::child_iterator ParenListExpr::child_end() { 2555 return &Exprs[0]+NumExprs; 2556} 2557 2558// ObjCStringLiteral 2559Stmt::child_iterator ObjCStringLiteral::child_begin() { 2560 return &String; 2561} 2562Stmt::child_iterator ObjCStringLiteral::child_end() { 2563 return &String+1; 2564} 2565 2566// ObjCEncodeExpr 2567Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); } 2568Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); } 2569 2570// ObjCSelectorExpr 2571Stmt::child_iterator ObjCSelectorExpr::child_begin() { 2572 return child_iterator(); 2573} 2574Stmt::child_iterator ObjCSelectorExpr::child_end() { 2575 return child_iterator(); 2576} 2577 2578// ObjCProtocolExpr 2579Stmt::child_iterator ObjCProtocolExpr::child_begin() { 2580 return child_iterator(); 2581} 2582Stmt::child_iterator ObjCProtocolExpr::child_end() { 2583 return child_iterator(); 2584} 2585 2586// ObjCMessageExpr 2587Stmt::child_iterator ObjCMessageExpr::child_begin() { 2588 if (getReceiverKind() == Instance) 2589 return reinterpret_cast<Stmt **>(this + 1); 2590 return getArgs(); 2591} 2592Stmt::child_iterator ObjCMessageExpr::child_end() { 2593 return getArgs() + getNumArgs(); 2594} 2595 2596// Blocks 2597Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); } 2598Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); } 2599 2600Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();} 2601Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); } 2602