1 //===--- ExprCXX.cpp - (C++) 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 subclesses of Expr class declared in ExprCXX.h 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/AST/ASTContext.h" 15 #include "clang/AST/Attr.h" 16 #include "clang/AST/DeclCXX.h" 17 #include "clang/AST/DeclTemplate.h" 18 #include "clang/AST/ExprCXX.h" 19 #include "clang/AST/TypeLoc.h" 20 #include "clang/Basic/IdentifierTable.h" 21 using namespace clang; 22 23 24 //===----------------------------------------------------------------------===// 25 // Child Iterators for iterating over subexpressions/substatements 26 //===----------------------------------------------------------------------===// 27 28 bool CXXTypeidExpr::isPotentiallyEvaluated() const { 29 if (isTypeOperand()) 30 return false; 31 32 // C++11 [expr.typeid]p3: 33 // When typeid is applied to an expression other than a glvalue of 34 // polymorphic class type, [...] the expression is an unevaluated operand. 35 const Expr *E = getExprOperand(); 36 if (const CXXRecordDecl *RD = E->getType()->getAsCXXRecordDecl()) 37 if (RD->isPolymorphic() && E->isGLValue()) 38 return true; 39 40 return false; 41 } 42 43 QualType CXXTypeidExpr::getTypeOperand(ASTContext &Context) const { 44 assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)"); 45 Qualifiers Quals; 46 return Context.getUnqualifiedArrayType( 47 Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType(), Quals); 48 } 49 50 QualType CXXUuidofExpr::getTypeOperand(ASTContext &Context) const { 51 assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)"); 52 Qualifiers Quals; 53 return Context.getUnqualifiedArrayType( 54 Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType(), Quals); 55 } 56 57 // static 58 UuidAttr *CXXUuidofExpr::GetUuidAttrOfType(QualType QT, 59 bool *RDHasMultipleGUIDsPtr) { 60 // Optionally remove one level of pointer, reference or array indirection. 61 const Type *Ty = QT.getTypePtr(); 62 if (QT->isPointerType() || QT->isReferenceType()) 63 Ty = QT->getPointeeType().getTypePtr(); 64 else if (QT->isArrayType()) 65 Ty = Ty->getBaseElementTypeUnsafe(); 66 67 // Loop all record redeclaration looking for an uuid attribute. 68 CXXRecordDecl *RD = Ty->getAsCXXRecordDecl(); 69 if (!RD) 70 return nullptr; 71 72 // __uuidof can grab UUIDs from template arguments. 73 if (ClassTemplateSpecializationDecl *CTSD = 74 dyn_cast<ClassTemplateSpecializationDecl>(RD)) { 75 const TemplateArgumentList &TAL = CTSD->getTemplateArgs(); 76 UuidAttr *UuidForRD = nullptr; 77 78 for (unsigned I = 0, N = TAL.size(); I != N; ++I) { 79 const TemplateArgument &TA = TAL[I]; 80 bool SeenMultipleGUIDs = false; 81 82 UuidAttr *UuidForTA = nullptr; 83 if (TA.getKind() == TemplateArgument::Type) 84 UuidForTA = GetUuidAttrOfType(TA.getAsType(), &SeenMultipleGUIDs); 85 else if (TA.getKind() == TemplateArgument::Declaration) 86 UuidForTA = 87 GetUuidAttrOfType(TA.getAsDecl()->getType(), &SeenMultipleGUIDs); 88 89 // If the template argument has a UUID, there are three cases: 90 // - This is the first UUID seen for this RecordDecl. 91 // - This is a different UUID than previously seen for this RecordDecl. 92 // - This is the same UUID than previously seen for this RecordDecl. 93 if (UuidForTA) { 94 if (!UuidForRD) 95 UuidForRD = UuidForTA; 96 else if (UuidForRD != UuidForTA) 97 SeenMultipleGUIDs = true; 98 } 99 100 // Seeing multiple UUIDs means that we couldn't find a UUID 101 if (SeenMultipleGUIDs) { 102 if (RDHasMultipleGUIDsPtr) 103 *RDHasMultipleGUIDsPtr = true; 104 return nullptr; 105 } 106 } 107 108 return UuidForRD; 109 } 110 111 for (auto I : RD->redecls()) 112 if (auto Uuid = I->getAttr<UuidAttr>()) 113 return Uuid; 114 115 return nullptr; 116 } 117 118 StringRef CXXUuidofExpr::getUuidAsStringRef(ASTContext &Context) const { 119 StringRef Uuid; 120 if (isTypeOperand()) 121 Uuid = CXXUuidofExpr::GetUuidAttrOfType(getTypeOperand(Context))->getGuid(); 122 else { 123 // Special case: __uuidof(0) means an all-zero GUID. 124 Expr *Op = getExprOperand(); 125 if (!Op->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) 126 Uuid = CXXUuidofExpr::GetUuidAttrOfType(Op->getType())->getGuid(); 127 else 128 Uuid = "00000000-0000-0000-0000-000000000000"; 129 } 130 return Uuid; 131 } 132 133 // CXXScalarValueInitExpr 134 SourceLocation CXXScalarValueInitExpr::getLocStart() const { 135 return TypeInfo ? TypeInfo->getTypeLoc().getBeginLoc() : RParenLoc; 136 } 137 138 // CXXNewExpr 139 CXXNewExpr::CXXNewExpr(const ASTContext &C, bool globalNew, 140 FunctionDecl *operatorNew, FunctionDecl *operatorDelete, 141 bool usualArrayDeleteWantsSize, 142 ArrayRef<Expr*> placementArgs, 143 SourceRange typeIdParens, Expr *arraySize, 144 InitializationStyle initializationStyle, 145 Expr *initializer, QualType ty, 146 TypeSourceInfo *allocatedTypeInfo, 147 SourceRange Range, SourceRange directInitRange) 148 : Expr(CXXNewExprClass, ty, VK_RValue, OK_Ordinary, 149 ty->isDependentType(), ty->isDependentType(), 150 ty->isInstantiationDependentType(), 151 ty->containsUnexpandedParameterPack()), 152 SubExprs(nullptr), OperatorNew(operatorNew), OperatorDelete(operatorDelete), 153 AllocatedTypeInfo(allocatedTypeInfo), TypeIdParens(typeIdParens), 154 Range(Range), DirectInitRange(directInitRange), 155 GlobalNew(globalNew), UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize) { 156 assert((initializer != nullptr || initializationStyle == NoInit) && 157 "Only NoInit can have no initializer."); 158 StoredInitializationStyle = initializer ? initializationStyle + 1 : 0; 159 AllocateArgsArray(C, arraySize != nullptr, placementArgs.size(), 160 initializer != nullptr); 161 unsigned i = 0; 162 if (Array) { 163 if (arraySize->isInstantiationDependent()) 164 ExprBits.InstantiationDependent = true; 165 166 if (arraySize->containsUnexpandedParameterPack()) 167 ExprBits.ContainsUnexpandedParameterPack = true; 168 169 SubExprs[i++] = arraySize; 170 } 171 172 if (initializer) { 173 if (initializer->isInstantiationDependent()) 174 ExprBits.InstantiationDependent = true; 175 176 if (initializer->containsUnexpandedParameterPack()) 177 ExprBits.ContainsUnexpandedParameterPack = true; 178 179 SubExprs[i++] = initializer; 180 } 181 182 for (unsigned j = 0; j != placementArgs.size(); ++j) { 183 if (placementArgs[j]->isInstantiationDependent()) 184 ExprBits.InstantiationDependent = true; 185 if (placementArgs[j]->containsUnexpandedParameterPack()) 186 ExprBits.ContainsUnexpandedParameterPack = true; 187 188 SubExprs[i++] = placementArgs[j]; 189 } 190 191 switch (getInitializationStyle()) { 192 case CallInit: 193 this->Range.setEnd(DirectInitRange.getEnd()); break; 194 case ListInit: 195 this->Range.setEnd(getInitializer()->getSourceRange().getEnd()); break; 196 default: 197 if (TypeIdParens.isValid()) 198 this->Range.setEnd(TypeIdParens.getEnd()); 199 break; 200 } 201 } 202 203 void CXXNewExpr::AllocateArgsArray(const ASTContext &C, bool isArray, 204 unsigned numPlaceArgs, bool hasInitializer){ 205 assert(SubExprs == nullptr && "SubExprs already allocated"); 206 Array = isArray; 207 NumPlacementArgs = numPlaceArgs; 208 209 unsigned TotalSize = Array + hasInitializer + NumPlacementArgs; 210 SubExprs = new (C) Stmt*[TotalSize]; 211 } 212 213 bool CXXNewExpr::shouldNullCheckAllocation(const ASTContext &Ctx) const { 214 return getOperatorNew()->getType()-> 215 castAs<FunctionProtoType>()->isNothrow(Ctx); 216 } 217 218 // CXXDeleteExpr 219 QualType CXXDeleteExpr::getDestroyedType() const { 220 const Expr *Arg = getArgument(); 221 // The type-to-delete may not be a pointer if it's a dependent type. 222 const QualType ArgType = Arg->getType(); 223 224 if (ArgType->isDependentType() && !ArgType->isPointerType()) 225 return QualType(); 226 227 return ArgType->getAs<PointerType>()->getPointeeType(); 228 } 229 230 // CXXPseudoDestructorExpr 231 PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info) 232 : Type(Info) 233 { 234 Location = Info->getTypeLoc().getLocalSourceRange().getBegin(); 235 } 236 237 CXXPseudoDestructorExpr::CXXPseudoDestructorExpr(const ASTContext &Context, 238 Expr *Base, bool isArrow, SourceLocation OperatorLoc, 239 NestedNameSpecifierLoc QualifierLoc, TypeSourceInfo *ScopeType, 240 SourceLocation ColonColonLoc, SourceLocation TildeLoc, 241 PseudoDestructorTypeStorage DestroyedType) 242 : Expr(CXXPseudoDestructorExprClass, 243 Context.getPointerType(Context.getFunctionType( 244 Context.VoidTy, None, 245 FunctionProtoType::ExtProtoInfo( 246 Context.getDefaultCallingConvention(false, true)))), 247 VK_RValue, OK_Ordinary, 248 /*isTypeDependent=*/(Base->isTypeDependent() || 249 (DestroyedType.getTypeSourceInfo() && 250 DestroyedType.getTypeSourceInfo()->getType()->isDependentType())), 251 /*isValueDependent=*/Base->isValueDependent(), 252 (Base->isInstantiationDependent() || 253 (QualifierLoc && 254 QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent()) || 255 (ScopeType && 256 ScopeType->getType()->isInstantiationDependentType()) || 257 (DestroyedType.getTypeSourceInfo() && 258 DestroyedType.getTypeSourceInfo()->getType() 259 ->isInstantiationDependentType())), 260 // ContainsUnexpandedParameterPack 261 (Base->containsUnexpandedParameterPack() || 262 (QualifierLoc && 263 QualifierLoc.getNestedNameSpecifier() 264 ->containsUnexpandedParameterPack()) || 265 (ScopeType && 266 ScopeType->getType()->containsUnexpandedParameterPack()) || 267 (DestroyedType.getTypeSourceInfo() && 268 DestroyedType.getTypeSourceInfo()->getType() 269 ->containsUnexpandedParameterPack()))), 270 Base(static_cast<Stmt *>(Base)), IsArrow(isArrow), 271 OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), 272 ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc), 273 DestroyedType(DestroyedType) { } 274 275 QualType CXXPseudoDestructorExpr::getDestroyedType() const { 276 if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo()) 277 return TInfo->getType(); 278 279 return QualType(); 280 } 281 282 SourceLocation CXXPseudoDestructorExpr::getLocEnd() const { 283 SourceLocation End = DestroyedType.getLocation(); 284 if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo()) 285 End = TInfo->getTypeLoc().getLocalSourceRange().getEnd(); 286 return End; 287 } 288 289 // UnresolvedLookupExpr 290 UnresolvedLookupExpr * 291 UnresolvedLookupExpr::Create(const ASTContext &C, 292 CXXRecordDecl *NamingClass, 293 NestedNameSpecifierLoc QualifierLoc, 294 SourceLocation TemplateKWLoc, 295 const DeclarationNameInfo &NameInfo, 296 bool ADL, 297 const TemplateArgumentListInfo *Args, 298 UnresolvedSetIterator Begin, 299 UnresolvedSetIterator End) 300 { 301 assert(Args || TemplateKWLoc.isValid()); 302 unsigned num_args = Args ? Args->size() : 0; 303 void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) + 304 ASTTemplateKWAndArgsInfo::sizeFor(num_args)); 305 return new (Mem) UnresolvedLookupExpr(C, NamingClass, QualifierLoc, 306 TemplateKWLoc, NameInfo, 307 ADL, /*Overload*/ true, Args, 308 Begin, End); 309 } 310 311 UnresolvedLookupExpr * 312 UnresolvedLookupExpr::CreateEmpty(const ASTContext &C, 313 bool HasTemplateKWAndArgsInfo, 314 unsigned NumTemplateArgs) { 315 std::size_t size = sizeof(UnresolvedLookupExpr); 316 if (HasTemplateKWAndArgsInfo) 317 size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 318 319 void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedLookupExpr>()); 320 UnresolvedLookupExpr *E = new (Mem) UnresolvedLookupExpr(EmptyShell()); 321 E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo; 322 return E; 323 } 324 325 OverloadExpr::OverloadExpr(StmtClass K, const ASTContext &C, 326 NestedNameSpecifierLoc QualifierLoc, 327 SourceLocation TemplateKWLoc, 328 const DeclarationNameInfo &NameInfo, 329 const TemplateArgumentListInfo *TemplateArgs, 330 UnresolvedSetIterator Begin, 331 UnresolvedSetIterator End, 332 bool KnownDependent, 333 bool KnownInstantiationDependent, 334 bool KnownContainsUnexpandedParameterPack) 335 : Expr(K, C.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent, 336 KnownDependent, 337 (KnownInstantiationDependent || 338 NameInfo.isInstantiationDependent() || 339 (QualifierLoc && 340 QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())), 341 (KnownContainsUnexpandedParameterPack || 342 NameInfo.containsUnexpandedParameterPack() || 343 (QualifierLoc && 344 QualifierLoc.getNestedNameSpecifier() 345 ->containsUnexpandedParameterPack()))), 346 NameInfo(NameInfo), QualifierLoc(QualifierLoc), 347 Results(nullptr), NumResults(End - Begin), 348 HasTemplateKWAndArgsInfo(TemplateArgs != nullptr || 349 TemplateKWLoc.isValid()) { 350 NumResults = End - Begin; 351 if (NumResults) { 352 // Determine whether this expression is type-dependent. 353 for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) { 354 if ((*I)->getDeclContext()->isDependentContext() || 355 isa<UnresolvedUsingValueDecl>(*I)) { 356 ExprBits.TypeDependent = true; 357 ExprBits.ValueDependent = true; 358 ExprBits.InstantiationDependent = true; 359 } 360 } 361 362 Results = static_cast<DeclAccessPair *>( 363 C.Allocate(sizeof(DeclAccessPair) * NumResults, 364 llvm::alignOf<DeclAccessPair>())); 365 memcpy(Results, &*Begin.getIterator(), 366 NumResults * sizeof(DeclAccessPair)); 367 } 368 369 // If we have explicit template arguments, check for dependent 370 // template arguments and whether they contain any unexpanded pack 371 // expansions. 372 if (TemplateArgs) { 373 bool Dependent = false; 374 bool InstantiationDependent = false; 375 bool ContainsUnexpandedParameterPack = false; 376 getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs, 377 Dependent, 378 InstantiationDependent, 379 ContainsUnexpandedParameterPack); 380 381 if (Dependent) { 382 ExprBits.TypeDependent = true; 383 ExprBits.ValueDependent = true; 384 } 385 if (InstantiationDependent) 386 ExprBits.InstantiationDependent = true; 387 if (ContainsUnexpandedParameterPack) 388 ExprBits.ContainsUnexpandedParameterPack = true; 389 } else if (TemplateKWLoc.isValid()) { 390 getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 391 } 392 393 if (isTypeDependent()) 394 setType(C.DependentTy); 395 } 396 397 void OverloadExpr::initializeResults(const ASTContext &C, 398 UnresolvedSetIterator Begin, 399 UnresolvedSetIterator End) { 400 assert(!Results && "Results already initialized!"); 401 NumResults = End - Begin; 402 if (NumResults) { 403 Results = static_cast<DeclAccessPair *>( 404 C.Allocate(sizeof(DeclAccessPair) * NumResults, 405 406 llvm::alignOf<DeclAccessPair>())); 407 memcpy(Results, &*Begin.getIterator(), 408 NumResults * sizeof(DeclAccessPair)); 409 } 410 } 411 412 CXXRecordDecl *OverloadExpr::getNamingClass() const { 413 if (isa<UnresolvedLookupExpr>(this)) 414 return cast<UnresolvedLookupExpr>(this)->getNamingClass(); 415 else 416 return cast<UnresolvedMemberExpr>(this)->getNamingClass(); 417 } 418 419 // DependentScopeDeclRefExpr 420 DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(QualType T, 421 NestedNameSpecifierLoc QualifierLoc, 422 SourceLocation TemplateKWLoc, 423 const DeclarationNameInfo &NameInfo, 424 const TemplateArgumentListInfo *Args) 425 : Expr(DependentScopeDeclRefExprClass, T, VK_LValue, OK_Ordinary, 426 true, true, 427 (NameInfo.isInstantiationDependent() || 428 (QualifierLoc && 429 QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())), 430 (NameInfo.containsUnexpandedParameterPack() || 431 (QualifierLoc && 432 QualifierLoc.getNestedNameSpecifier() 433 ->containsUnexpandedParameterPack()))), 434 QualifierLoc(QualifierLoc), NameInfo(NameInfo), 435 HasTemplateKWAndArgsInfo(Args != nullptr || TemplateKWLoc.isValid()) 436 { 437 if (Args) { 438 bool Dependent = true; 439 bool InstantiationDependent = true; 440 bool ContainsUnexpandedParameterPack 441 = ExprBits.ContainsUnexpandedParameterPack; 442 getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *Args, 443 Dependent, 444 InstantiationDependent, 445 ContainsUnexpandedParameterPack); 446 ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack; 447 } else if (TemplateKWLoc.isValid()) { 448 getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 449 } 450 } 451 452 DependentScopeDeclRefExpr * 453 DependentScopeDeclRefExpr::Create(const ASTContext &C, 454 NestedNameSpecifierLoc QualifierLoc, 455 SourceLocation TemplateKWLoc, 456 const DeclarationNameInfo &NameInfo, 457 const TemplateArgumentListInfo *Args) { 458 assert(QualifierLoc && "should be created for dependent qualifiers"); 459 std::size_t size = sizeof(DependentScopeDeclRefExpr); 460 if (Args) 461 size += ASTTemplateKWAndArgsInfo::sizeFor(Args->size()); 462 else if (TemplateKWLoc.isValid()) 463 size += ASTTemplateKWAndArgsInfo::sizeFor(0); 464 void *Mem = C.Allocate(size); 465 return new (Mem) DependentScopeDeclRefExpr(C.DependentTy, QualifierLoc, 466 TemplateKWLoc, NameInfo, Args); 467 } 468 469 DependentScopeDeclRefExpr * 470 DependentScopeDeclRefExpr::CreateEmpty(const ASTContext &C, 471 bool HasTemplateKWAndArgsInfo, 472 unsigned NumTemplateArgs) { 473 std::size_t size = sizeof(DependentScopeDeclRefExpr); 474 if (HasTemplateKWAndArgsInfo) 475 size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 476 void *Mem = C.Allocate(size); 477 DependentScopeDeclRefExpr *E 478 = new (Mem) DependentScopeDeclRefExpr(QualType(), NestedNameSpecifierLoc(), 479 SourceLocation(), 480 DeclarationNameInfo(), nullptr); 481 E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo; 482 return E; 483 } 484 485 SourceLocation CXXConstructExpr::getLocStart() const { 486 if (isa<CXXTemporaryObjectExpr>(this)) 487 return cast<CXXTemporaryObjectExpr>(this)->getLocStart(); 488 return Loc; 489 } 490 491 SourceLocation CXXConstructExpr::getLocEnd() const { 492 if (isa<CXXTemporaryObjectExpr>(this)) 493 return cast<CXXTemporaryObjectExpr>(this)->getLocEnd(); 494 495 if (ParenOrBraceRange.isValid()) 496 return ParenOrBraceRange.getEnd(); 497 498 SourceLocation End = Loc; 499 for (unsigned I = getNumArgs(); I > 0; --I) { 500 const Expr *Arg = getArg(I-1); 501 if (!Arg->isDefaultArgument()) { 502 SourceLocation NewEnd = Arg->getLocEnd(); 503 if (NewEnd.isValid()) { 504 End = NewEnd; 505 break; 506 } 507 } 508 } 509 510 return End; 511 } 512 513 SourceRange CXXOperatorCallExpr::getSourceRangeImpl() const { 514 OverloadedOperatorKind Kind = getOperator(); 515 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) { 516 if (getNumArgs() == 1) 517 // Prefix operator 518 return SourceRange(getOperatorLoc(), getArg(0)->getLocEnd()); 519 else 520 // Postfix operator 521 return SourceRange(getArg(0)->getLocStart(), getOperatorLoc()); 522 } else if (Kind == OO_Arrow) { 523 return getArg(0)->getSourceRange(); 524 } else if (Kind == OO_Call) { 525 return SourceRange(getArg(0)->getLocStart(), getRParenLoc()); 526 } else if (Kind == OO_Subscript) { 527 return SourceRange(getArg(0)->getLocStart(), getRParenLoc()); 528 } else if (getNumArgs() == 1) { 529 return SourceRange(getOperatorLoc(), getArg(0)->getLocEnd()); 530 } else if (getNumArgs() == 2) { 531 return SourceRange(getArg(0)->getLocStart(), getArg(1)->getLocEnd()); 532 } else { 533 return getOperatorLoc(); 534 } 535 } 536 537 Expr *CXXMemberCallExpr::getImplicitObjectArgument() const { 538 const Expr *Callee = getCallee()->IgnoreParens(); 539 if (const MemberExpr *MemExpr = dyn_cast<MemberExpr>(Callee)) 540 return MemExpr->getBase(); 541 if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(Callee)) 542 if (BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI) 543 return BO->getLHS(); 544 545 // FIXME: Will eventually need to cope with member pointers. 546 return nullptr; 547 } 548 549 CXXMethodDecl *CXXMemberCallExpr::getMethodDecl() const { 550 if (const MemberExpr *MemExpr = 551 dyn_cast<MemberExpr>(getCallee()->IgnoreParens())) 552 return cast<CXXMethodDecl>(MemExpr->getMemberDecl()); 553 554 // FIXME: Will eventually need to cope with member pointers. 555 return nullptr; 556 } 557 558 559 CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() const { 560 Expr* ThisArg = getImplicitObjectArgument(); 561 if (!ThisArg) 562 return nullptr; 563 564 if (ThisArg->getType()->isAnyPointerType()) 565 return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl(); 566 567 return ThisArg->getType()->getAsCXXRecordDecl(); 568 } 569 570 571 //===----------------------------------------------------------------------===// 572 // Named casts 573 //===----------------------------------------------------------------------===// 574 575 /// getCastName - Get the name of the C++ cast being used, e.g., 576 /// "static_cast", "dynamic_cast", "reinterpret_cast", or 577 /// "const_cast". The returned pointer must not be freed. 578 const char *CXXNamedCastExpr::getCastName() const { 579 switch (getStmtClass()) { 580 case CXXStaticCastExprClass: return "static_cast"; 581 case CXXDynamicCastExprClass: return "dynamic_cast"; 582 case CXXReinterpretCastExprClass: return "reinterpret_cast"; 583 case CXXConstCastExprClass: return "const_cast"; 584 default: return "<invalid cast>"; 585 } 586 } 587 588 CXXStaticCastExpr *CXXStaticCastExpr::Create(const ASTContext &C, QualType T, 589 ExprValueKind VK, 590 CastKind K, Expr *Op, 591 const CXXCastPath *BasePath, 592 TypeSourceInfo *WrittenTy, 593 SourceLocation L, 594 SourceLocation RParenLoc, 595 SourceRange AngleBrackets) { 596 unsigned PathSize = (BasePath ? BasePath->size() : 0); 597 void *Buffer = C.Allocate(sizeof(CXXStaticCastExpr) 598 + PathSize * sizeof(CXXBaseSpecifier*)); 599 CXXStaticCastExpr *E = 600 new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 601 RParenLoc, AngleBrackets); 602 if (PathSize) E->setCastPath(*BasePath); 603 return E; 604 } 605 606 CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(const ASTContext &C, 607 unsigned PathSize) { 608 void *Buffer = 609 C.Allocate(sizeof(CXXStaticCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 610 return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize); 611 } 612 613 CXXDynamicCastExpr *CXXDynamicCastExpr::Create(const ASTContext &C, QualType T, 614 ExprValueKind VK, 615 CastKind K, Expr *Op, 616 const CXXCastPath *BasePath, 617 TypeSourceInfo *WrittenTy, 618 SourceLocation L, 619 SourceLocation RParenLoc, 620 SourceRange AngleBrackets) { 621 unsigned PathSize = (BasePath ? BasePath->size() : 0); 622 void *Buffer = C.Allocate(sizeof(CXXDynamicCastExpr) 623 + PathSize * sizeof(CXXBaseSpecifier*)); 624 CXXDynamicCastExpr *E = 625 new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 626 RParenLoc, AngleBrackets); 627 if (PathSize) E->setCastPath(*BasePath); 628 return E; 629 } 630 631 CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(const ASTContext &C, 632 unsigned PathSize) { 633 void *Buffer = 634 C.Allocate(sizeof(CXXDynamicCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 635 return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize); 636 } 637 638 /// isAlwaysNull - Return whether the result of the dynamic_cast is proven 639 /// to always be null. For example: 640 /// 641 /// struct A { }; 642 /// struct B final : A { }; 643 /// struct C { }; 644 /// 645 /// C *f(B* b) { return dynamic_cast<C*>(b); } 646 bool CXXDynamicCastExpr::isAlwaysNull() const 647 { 648 QualType SrcType = getSubExpr()->getType(); 649 QualType DestType = getType(); 650 651 if (const PointerType *SrcPTy = SrcType->getAs<PointerType>()) { 652 SrcType = SrcPTy->getPointeeType(); 653 DestType = DestType->castAs<PointerType>()->getPointeeType(); 654 } 655 656 if (DestType->isVoidType()) 657 return false; 658 659 const CXXRecordDecl *SrcRD = 660 cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl()); 661 662 if (!SrcRD->hasAttr<FinalAttr>()) 663 return false; 664 665 const CXXRecordDecl *DestRD = 666 cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl()); 667 668 return !DestRD->isDerivedFrom(SrcRD); 669 } 670 671 CXXReinterpretCastExpr * 672 CXXReinterpretCastExpr::Create(const ASTContext &C, QualType T, 673 ExprValueKind VK, CastKind K, Expr *Op, 674 const CXXCastPath *BasePath, 675 TypeSourceInfo *WrittenTy, SourceLocation L, 676 SourceLocation RParenLoc, 677 SourceRange AngleBrackets) { 678 unsigned PathSize = (BasePath ? BasePath->size() : 0); 679 void *Buffer = 680 C.Allocate(sizeof(CXXReinterpretCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 681 CXXReinterpretCastExpr *E = 682 new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 683 RParenLoc, AngleBrackets); 684 if (PathSize) E->setCastPath(*BasePath); 685 return E; 686 } 687 688 CXXReinterpretCastExpr * 689 CXXReinterpretCastExpr::CreateEmpty(const ASTContext &C, unsigned PathSize) { 690 void *Buffer = C.Allocate(sizeof(CXXReinterpretCastExpr) 691 + PathSize * sizeof(CXXBaseSpecifier*)); 692 return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize); 693 } 694 695 CXXConstCastExpr *CXXConstCastExpr::Create(const ASTContext &C, QualType T, 696 ExprValueKind VK, Expr *Op, 697 TypeSourceInfo *WrittenTy, 698 SourceLocation L, 699 SourceLocation RParenLoc, 700 SourceRange AngleBrackets) { 701 return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc, AngleBrackets); 702 } 703 704 CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(const ASTContext &C) { 705 return new (C) CXXConstCastExpr(EmptyShell()); 706 } 707 708 CXXFunctionalCastExpr * 709 CXXFunctionalCastExpr::Create(const ASTContext &C, QualType T, ExprValueKind VK, 710 TypeSourceInfo *Written, CastKind K, Expr *Op, 711 const CXXCastPath *BasePath, 712 SourceLocation L, SourceLocation R) { 713 unsigned PathSize = (BasePath ? BasePath->size() : 0); 714 void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr) 715 + PathSize * sizeof(CXXBaseSpecifier*)); 716 CXXFunctionalCastExpr *E = 717 new (Buffer) CXXFunctionalCastExpr(T, VK, Written, K, Op, PathSize, L, R); 718 if (PathSize) E->setCastPath(*BasePath); 719 return E; 720 } 721 722 CXXFunctionalCastExpr * 723 CXXFunctionalCastExpr::CreateEmpty(const ASTContext &C, unsigned PathSize) { 724 void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr) 725 + PathSize * sizeof(CXXBaseSpecifier*)); 726 return new (Buffer) CXXFunctionalCastExpr(EmptyShell(), PathSize); 727 } 728 729 SourceLocation CXXFunctionalCastExpr::getLocStart() const { 730 return getTypeInfoAsWritten()->getTypeLoc().getLocStart(); 731 } 732 733 SourceLocation CXXFunctionalCastExpr::getLocEnd() const { 734 return RParenLoc.isValid() ? RParenLoc : getSubExpr()->getLocEnd(); 735 } 736 737 UserDefinedLiteral::LiteralOperatorKind 738 UserDefinedLiteral::getLiteralOperatorKind() const { 739 if (getNumArgs() == 0) 740 return LOK_Template; 741 if (getNumArgs() == 2) 742 return LOK_String; 743 744 assert(getNumArgs() == 1 && "unexpected #args in literal operator call"); 745 QualType ParamTy = 746 cast<FunctionDecl>(getCalleeDecl())->getParamDecl(0)->getType(); 747 if (ParamTy->isPointerType()) 748 return LOK_Raw; 749 if (ParamTy->isAnyCharacterType()) 750 return LOK_Character; 751 if (ParamTy->isIntegerType()) 752 return LOK_Integer; 753 if (ParamTy->isFloatingType()) 754 return LOK_Floating; 755 756 llvm_unreachable("unknown kind of literal operator"); 757 } 758 759 Expr *UserDefinedLiteral::getCookedLiteral() { 760 #ifndef NDEBUG 761 LiteralOperatorKind LOK = getLiteralOperatorKind(); 762 assert(LOK != LOK_Template && LOK != LOK_Raw && "not a cooked literal"); 763 #endif 764 return getArg(0); 765 } 766 767 const IdentifierInfo *UserDefinedLiteral::getUDSuffix() const { 768 return cast<FunctionDecl>(getCalleeDecl())->getLiteralIdentifier(); 769 } 770 771 CXXDefaultArgExpr * 772 CXXDefaultArgExpr::Create(const ASTContext &C, SourceLocation Loc, 773 ParmVarDecl *Param, Expr *SubExpr) { 774 void *Mem = C.Allocate(sizeof(CXXDefaultArgExpr) + sizeof(Stmt *)); 775 return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param, 776 SubExpr); 777 } 778 779 CXXDefaultInitExpr::CXXDefaultInitExpr(const ASTContext &C, SourceLocation Loc, 780 FieldDecl *Field, QualType T) 781 : Expr(CXXDefaultInitExprClass, T.getNonLValueExprType(C), 782 T->isLValueReferenceType() ? VK_LValue : T->isRValueReferenceType() 783 ? VK_XValue 784 : VK_RValue, 785 /*FIXME*/ OK_Ordinary, false, false, false, false), 786 Field(Field), Loc(Loc) { 787 assert(Field->hasInClassInitializer()); 788 } 789 790 CXXTemporary *CXXTemporary::Create(const ASTContext &C, 791 const CXXDestructorDecl *Destructor) { 792 return new (C) CXXTemporary(Destructor); 793 } 794 795 CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(const ASTContext &C, 796 CXXTemporary *Temp, 797 Expr* SubExpr) { 798 assert((SubExpr->getType()->isRecordType() || 799 SubExpr->getType()->isArrayType()) && 800 "Expression bound to a temporary must have record or array type!"); 801 802 return new (C) CXXBindTemporaryExpr(Temp, SubExpr); 803 } 804 805 CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(const ASTContext &C, 806 CXXConstructorDecl *Cons, 807 TypeSourceInfo *Type, 808 ArrayRef<Expr*> Args, 809 SourceRange ParenOrBraceRange, 810 bool HadMultipleCandidates, 811 bool ListInitialization, 812 bool ZeroInitialization) 813 : CXXConstructExpr(C, CXXTemporaryObjectExprClass, 814 Type->getType().getNonReferenceType(), 815 Type->getTypeLoc().getBeginLoc(), 816 Cons, false, Args, 817 HadMultipleCandidates, 818 ListInitialization, ZeroInitialization, 819 CXXConstructExpr::CK_Complete, ParenOrBraceRange), 820 Type(Type) { 821 } 822 823 SourceLocation CXXTemporaryObjectExpr::getLocStart() const { 824 return Type->getTypeLoc().getBeginLoc(); 825 } 826 827 SourceLocation CXXTemporaryObjectExpr::getLocEnd() const { 828 SourceLocation Loc = getParenOrBraceRange().getEnd(); 829 if (Loc.isInvalid() && getNumArgs()) 830 Loc = getArg(getNumArgs()-1)->getLocEnd(); 831 return Loc; 832 } 833 834 CXXConstructExpr *CXXConstructExpr::Create(const ASTContext &C, QualType T, 835 SourceLocation Loc, 836 CXXConstructorDecl *D, bool Elidable, 837 ArrayRef<Expr*> Args, 838 bool HadMultipleCandidates, 839 bool ListInitialization, 840 bool ZeroInitialization, 841 ConstructionKind ConstructKind, 842 SourceRange ParenOrBraceRange) { 843 return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D, 844 Elidable, Args, 845 HadMultipleCandidates, ListInitialization, 846 ZeroInitialization, ConstructKind, 847 ParenOrBraceRange); 848 } 849 850 CXXConstructExpr::CXXConstructExpr(const ASTContext &C, StmtClass SC, 851 QualType T, SourceLocation Loc, 852 CXXConstructorDecl *D, bool elidable, 853 ArrayRef<Expr*> args, 854 bool HadMultipleCandidates, 855 bool ListInitialization, 856 bool ZeroInitialization, 857 ConstructionKind ConstructKind, 858 SourceRange ParenOrBraceRange) 859 : Expr(SC, T, VK_RValue, OK_Ordinary, 860 T->isDependentType(), T->isDependentType(), 861 T->isInstantiationDependentType(), 862 T->containsUnexpandedParameterPack()), 863 Constructor(D), Loc(Loc), ParenOrBraceRange(ParenOrBraceRange), 864 NumArgs(args.size()), 865 Elidable(elidable), HadMultipleCandidates(HadMultipleCandidates), 866 ListInitialization(ListInitialization), 867 ZeroInitialization(ZeroInitialization), 868 ConstructKind(ConstructKind), Args(nullptr) 869 { 870 if (NumArgs) { 871 Args = new (C) Stmt*[args.size()]; 872 873 for (unsigned i = 0; i != args.size(); ++i) { 874 assert(args[i] && "NULL argument in CXXConstructExpr"); 875 876 if (args[i]->isValueDependent()) 877 ExprBits.ValueDependent = true; 878 if (args[i]->isInstantiationDependent()) 879 ExprBits.InstantiationDependent = true; 880 if (args[i]->containsUnexpandedParameterPack()) 881 ExprBits.ContainsUnexpandedParameterPack = true; 882 883 Args[i] = args[i]; 884 } 885 } 886 } 887 888 LambdaCapture::LambdaCapture(SourceLocation Loc, bool Implicit, 889 LambdaCaptureKind Kind, VarDecl *Var, 890 SourceLocation EllipsisLoc) 891 : DeclAndBits(Var, 0), Loc(Loc), EllipsisLoc(EllipsisLoc) 892 { 893 unsigned Bits = 0; 894 if (Implicit) 895 Bits |= Capture_Implicit; 896 897 switch (Kind) { 898 case LCK_This: 899 assert(!Var && "'this' capture cannot have a variable!"); 900 break; 901 902 case LCK_ByCopy: 903 Bits |= Capture_ByCopy; 904 // Fall through 905 case LCK_ByRef: 906 assert(Var && "capture must have a variable!"); 907 break; 908 } 909 DeclAndBits.setInt(Bits); 910 } 911 912 LambdaCaptureKind LambdaCapture::getCaptureKind() const { 913 Decl *D = DeclAndBits.getPointer(); 914 if (!D) 915 return LCK_This; 916 917 return (DeclAndBits.getInt() & Capture_ByCopy) ? LCK_ByCopy : LCK_ByRef; 918 } 919 920 LambdaExpr::LambdaExpr(QualType T, 921 SourceRange IntroducerRange, 922 LambdaCaptureDefault CaptureDefault, 923 SourceLocation CaptureDefaultLoc, 924 ArrayRef<Capture> Captures, 925 bool ExplicitParams, 926 bool ExplicitResultType, 927 ArrayRef<Expr *> CaptureInits, 928 ArrayRef<VarDecl *> ArrayIndexVars, 929 ArrayRef<unsigned> ArrayIndexStarts, 930 SourceLocation ClosingBrace, 931 bool ContainsUnexpandedParameterPack) 932 : Expr(LambdaExprClass, T, VK_RValue, OK_Ordinary, 933 T->isDependentType(), T->isDependentType(), T->isDependentType(), 934 ContainsUnexpandedParameterPack), 935 IntroducerRange(IntroducerRange), 936 CaptureDefaultLoc(CaptureDefaultLoc), 937 NumCaptures(Captures.size()), 938 CaptureDefault(CaptureDefault), 939 ExplicitParams(ExplicitParams), 940 ExplicitResultType(ExplicitResultType), 941 ClosingBrace(ClosingBrace) 942 { 943 assert(CaptureInits.size() == Captures.size() && "Wrong number of arguments"); 944 CXXRecordDecl *Class = getLambdaClass(); 945 CXXRecordDecl::LambdaDefinitionData &Data = Class->getLambdaData(); 946 947 // FIXME: Propagate "has unexpanded parameter pack" bit. 948 949 // Copy captures. 950 const ASTContext &Context = Class->getASTContext(); 951 Data.NumCaptures = NumCaptures; 952 Data.NumExplicitCaptures = 0; 953 Data.Captures = (Capture *)Context.Allocate(sizeof(Capture) * NumCaptures); 954 Capture *ToCapture = Data.Captures; 955 for (unsigned I = 0, N = Captures.size(); I != N; ++I) { 956 if (Captures[I].isExplicit()) 957 ++Data.NumExplicitCaptures; 958 959 *ToCapture++ = Captures[I]; 960 } 961 962 // Copy initialization expressions for the non-static data members. 963 Stmt **Stored = getStoredStmts(); 964 for (unsigned I = 0, N = CaptureInits.size(); I != N; ++I) 965 *Stored++ = CaptureInits[I]; 966 967 // Copy the body of the lambda. 968 *Stored++ = getCallOperator()->getBody(); 969 970 // Copy the array index variables, if any. 971 HasArrayIndexVars = !ArrayIndexVars.empty(); 972 if (HasArrayIndexVars) { 973 assert(ArrayIndexStarts.size() == NumCaptures); 974 memcpy(getArrayIndexVars(), ArrayIndexVars.data(), 975 sizeof(VarDecl *) * ArrayIndexVars.size()); 976 memcpy(getArrayIndexStarts(), ArrayIndexStarts.data(), 977 sizeof(unsigned) * Captures.size()); 978 getArrayIndexStarts()[Captures.size()] = ArrayIndexVars.size(); 979 } 980 } 981 982 LambdaExpr *LambdaExpr::Create(const ASTContext &Context, 983 CXXRecordDecl *Class, 984 SourceRange IntroducerRange, 985 LambdaCaptureDefault CaptureDefault, 986 SourceLocation CaptureDefaultLoc, 987 ArrayRef<Capture> Captures, 988 bool ExplicitParams, 989 bool ExplicitResultType, 990 ArrayRef<Expr *> CaptureInits, 991 ArrayRef<VarDecl *> ArrayIndexVars, 992 ArrayRef<unsigned> ArrayIndexStarts, 993 SourceLocation ClosingBrace, 994 bool ContainsUnexpandedParameterPack) { 995 // Determine the type of the expression (i.e., the type of the 996 // function object we're creating). 997 QualType T = Context.getTypeDeclType(Class); 998 999 unsigned Size = sizeof(LambdaExpr) + sizeof(Stmt *) * (Captures.size() + 1); 1000 if (!ArrayIndexVars.empty()) { 1001 Size += sizeof(unsigned) * (Captures.size() + 1); 1002 // Realign for following VarDecl array. 1003 Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<VarDecl*>()); 1004 Size += sizeof(VarDecl *) * ArrayIndexVars.size(); 1005 } 1006 void *Mem = Context.Allocate(Size); 1007 return new (Mem) LambdaExpr(T, IntroducerRange, 1008 CaptureDefault, CaptureDefaultLoc, Captures, 1009 ExplicitParams, ExplicitResultType, 1010 CaptureInits, ArrayIndexVars, ArrayIndexStarts, 1011 ClosingBrace, ContainsUnexpandedParameterPack); 1012 } 1013 1014 LambdaExpr *LambdaExpr::CreateDeserialized(const ASTContext &C, 1015 unsigned NumCaptures, 1016 unsigned NumArrayIndexVars) { 1017 unsigned Size = sizeof(LambdaExpr) + sizeof(Stmt *) * (NumCaptures + 1); 1018 if (NumArrayIndexVars) 1019 Size += sizeof(VarDecl) * NumArrayIndexVars 1020 + sizeof(unsigned) * (NumCaptures + 1); 1021 void *Mem = C.Allocate(Size); 1022 return new (Mem) LambdaExpr(EmptyShell(), NumCaptures, NumArrayIndexVars > 0); 1023 } 1024 1025 LambdaExpr::capture_iterator LambdaExpr::capture_begin() const { 1026 return getLambdaClass()->getLambdaData().Captures; 1027 } 1028 1029 LambdaExpr::capture_iterator LambdaExpr::capture_end() const { 1030 return capture_begin() + NumCaptures; 1031 } 1032 1033 LambdaExpr::capture_range LambdaExpr::captures() const { 1034 return capture_range(capture_begin(), capture_end()); 1035 } 1036 1037 LambdaExpr::capture_iterator LambdaExpr::explicit_capture_begin() const { 1038 return capture_begin(); 1039 } 1040 1041 LambdaExpr::capture_iterator LambdaExpr::explicit_capture_end() const { 1042 struct CXXRecordDecl::LambdaDefinitionData &Data 1043 = getLambdaClass()->getLambdaData(); 1044 return Data.Captures + Data.NumExplicitCaptures; 1045 } 1046 1047 LambdaExpr::capture_range LambdaExpr::explicit_captures() const { 1048 return capture_range(explicit_capture_begin(), explicit_capture_end()); 1049 } 1050 1051 LambdaExpr::capture_iterator LambdaExpr::implicit_capture_begin() const { 1052 return explicit_capture_end(); 1053 } 1054 1055 LambdaExpr::capture_iterator LambdaExpr::implicit_capture_end() const { 1056 return capture_end(); 1057 } 1058 1059 LambdaExpr::capture_range LambdaExpr::implicit_captures() const { 1060 return capture_range(implicit_capture_begin(), implicit_capture_end()); 1061 } 1062 1063 ArrayRef<VarDecl *> 1064 LambdaExpr::getCaptureInitIndexVars(capture_init_iterator Iter) const { 1065 assert(HasArrayIndexVars && "No array index-var data?"); 1066 1067 unsigned Index = Iter - capture_init_begin(); 1068 assert(Index < getLambdaClass()->getLambdaData().NumCaptures && 1069 "Capture index out-of-range"); 1070 VarDecl **IndexVars = getArrayIndexVars(); 1071 unsigned *IndexStarts = getArrayIndexStarts(); 1072 return ArrayRef<VarDecl *>(IndexVars + IndexStarts[Index], 1073 IndexVars + IndexStarts[Index + 1]); 1074 } 1075 1076 CXXRecordDecl *LambdaExpr::getLambdaClass() const { 1077 return getType()->getAsCXXRecordDecl(); 1078 } 1079 1080 CXXMethodDecl *LambdaExpr::getCallOperator() const { 1081 CXXRecordDecl *Record = getLambdaClass(); 1082 return Record->getLambdaCallOperator(); 1083 } 1084 1085 TemplateParameterList *LambdaExpr::getTemplateParameterList() const { 1086 CXXRecordDecl *Record = getLambdaClass(); 1087 return Record->getGenericLambdaTemplateParameterList(); 1088 1089 } 1090 1091 CompoundStmt *LambdaExpr::getBody() const { 1092 if (!getStoredStmts()[NumCaptures]) 1093 getStoredStmts()[NumCaptures] = getCallOperator()->getBody(); 1094 1095 return reinterpret_cast<CompoundStmt *>(getStoredStmts()[NumCaptures]); 1096 } 1097 1098 bool LambdaExpr::isMutable() const { 1099 return !getCallOperator()->isConst(); 1100 } 1101 1102 ExprWithCleanups::ExprWithCleanups(Expr *subexpr, 1103 ArrayRef<CleanupObject> objects) 1104 : Expr(ExprWithCleanupsClass, subexpr->getType(), 1105 subexpr->getValueKind(), subexpr->getObjectKind(), 1106 subexpr->isTypeDependent(), subexpr->isValueDependent(), 1107 subexpr->isInstantiationDependent(), 1108 subexpr->containsUnexpandedParameterPack()), 1109 SubExpr(subexpr) { 1110 ExprWithCleanupsBits.NumObjects = objects.size(); 1111 for (unsigned i = 0, e = objects.size(); i != e; ++i) 1112 getObjectsBuffer()[i] = objects[i]; 1113 } 1114 1115 ExprWithCleanups *ExprWithCleanups::Create(const ASTContext &C, Expr *subexpr, 1116 ArrayRef<CleanupObject> objects) { 1117 size_t size = sizeof(ExprWithCleanups) 1118 + objects.size() * sizeof(CleanupObject); 1119 void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>()); 1120 return new (buffer) ExprWithCleanups(subexpr, objects); 1121 } 1122 1123 ExprWithCleanups::ExprWithCleanups(EmptyShell empty, unsigned numObjects) 1124 : Expr(ExprWithCleanupsClass, empty) { 1125 ExprWithCleanupsBits.NumObjects = numObjects; 1126 } 1127 1128 ExprWithCleanups *ExprWithCleanups::Create(const ASTContext &C, 1129 EmptyShell empty, 1130 unsigned numObjects) { 1131 size_t size = sizeof(ExprWithCleanups) + numObjects * sizeof(CleanupObject); 1132 void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>()); 1133 return new (buffer) ExprWithCleanups(empty, numObjects); 1134 } 1135 1136 CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *Type, 1137 SourceLocation LParenLoc, 1138 ArrayRef<Expr*> Args, 1139 SourceLocation RParenLoc) 1140 : Expr(CXXUnresolvedConstructExprClass, 1141 Type->getType().getNonReferenceType(), 1142 (Type->getType()->isLValueReferenceType() ? VK_LValue 1143 :Type->getType()->isRValueReferenceType()? VK_XValue 1144 :VK_RValue), 1145 OK_Ordinary, 1146 Type->getType()->isDependentType(), true, true, 1147 Type->getType()->containsUnexpandedParameterPack()), 1148 Type(Type), 1149 LParenLoc(LParenLoc), 1150 RParenLoc(RParenLoc), 1151 NumArgs(Args.size()) { 1152 Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1); 1153 for (unsigned I = 0; I != Args.size(); ++I) { 1154 if (Args[I]->containsUnexpandedParameterPack()) 1155 ExprBits.ContainsUnexpandedParameterPack = true; 1156 1157 StoredArgs[I] = Args[I]; 1158 } 1159 } 1160 1161 CXXUnresolvedConstructExpr * 1162 CXXUnresolvedConstructExpr::Create(const ASTContext &C, 1163 TypeSourceInfo *Type, 1164 SourceLocation LParenLoc, 1165 ArrayRef<Expr*> Args, 1166 SourceLocation RParenLoc) { 1167 void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) + 1168 sizeof(Expr *) * Args.size()); 1169 return new (Mem) CXXUnresolvedConstructExpr(Type, LParenLoc, Args, RParenLoc); 1170 } 1171 1172 CXXUnresolvedConstructExpr * 1173 CXXUnresolvedConstructExpr::CreateEmpty(const ASTContext &C, unsigned NumArgs) { 1174 Stmt::EmptyShell Empty; 1175 void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) + 1176 sizeof(Expr *) * NumArgs); 1177 return new (Mem) CXXUnresolvedConstructExpr(Empty, NumArgs); 1178 } 1179 1180 SourceLocation CXXUnresolvedConstructExpr::getLocStart() const { 1181 return Type->getTypeLoc().getBeginLoc(); 1182 } 1183 1184 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(const ASTContext &C, 1185 Expr *Base, QualType BaseType, 1186 bool IsArrow, 1187 SourceLocation OperatorLoc, 1188 NestedNameSpecifierLoc QualifierLoc, 1189 SourceLocation TemplateKWLoc, 1190 NamedDecl *FirstQualifierFoundInScope, 1191 DeclarationNameInfo MemberNameInfo, 1192 const TemplateArgumentListInfo *TemplateArgs) 1193 : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, 1194 VK_LValue, OK_Ordinary, true, true, true, 1195 ((Base && Base->containsUnexpandedParameterPack()) || 1196 (QualifierLoc && 1197 QualifierLoc.getNestedNameSpecifier() 1198 ->containsUnexpandedParameterPack()) || 1199 MemberNameInfo.containsUnexpandedParameterPack())), 1200 Base(Base), BaseType(BaseType), IsArrow(IsArrow), 1201 HasTemplateKWAndArgsInfo(TemplateArgs != nullptr || 1202 TemplateKWLoc.isValid()), 1203 OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), 1204 FirstQualifierFoundInScope(FirstQualifierFoundInScope), 1205 MemberNameInfo(MemberNameInfo) { 1206 if (TemplateArgs) { 1207 bool Dependent = true; 1208 bool InstantiationDependent = true; 1209 bool ContainsUnexpandedParameterPack = false; 1210 getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs, 1211 Dependent, 1212 InstantiationDependent, 1213 ContainsUnexpandedParameterPack); 1214 if (ContainsUnexpandedParameterPack) 1215 ExprBits.ContainsUnexpandedParameterPack = true; 1216 } else if (TemplateKWLoc.isValid()) { 1217 getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 1218 } 1219 } 1220 1221 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(const ASTContext &C, 1222 Expr *Base, QualType BaseType, 1223 bool IsArrow, 1224 SourceLocation OperatorLoc, 1225 NestedNameSpecifierLoc QualifierLoc, 1226 NamedDecl *FirstQualifierFoundInScope, 1227 DeclarationNameInfo MemberNameInfo) 1228 : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, 1229 VK_LValue, OK_Ordinary, true, true, true, 1230 ((Base && Base->containsUnexpandedParameterPack()) || 1231 (QualifierLoc && 1232 QualifierLoc.getNestedNameSpecifier()-> 1233 containsUnexpandedParameterPack()) || 1234 MemberNameInfo.containsUnexpandedParameterPack())), 1235 Base(Base), BaseType(BaseType), IsArrow(IsArrow), 1236 HasTemplateKWAndArgsInfo(false), 1237 OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), 1238 FirstQualifierFoundInScope(FirstQualifierFoundInScope), 1239 MemberNameInfo(MemberNameInfo) { } 1240 1241 CXXDependentScopeMemberExpr * 1242 CXXDependentScopeMemberExpr::Create(const ASTContext &C, 1243 Expr *Base, QualType BaseType, bool IsArrow, 1244 SourceLocation OperatorLoc, 1245 NestedNameSpecifierLoc QualifierLoc, 1246 SourceLocation TemplateKWLoc, 1247 NamedDecl *FirstQualifierFoundInScope, 1248 DeclarationNameInfo MemberNameInfo, 1249 const TemplateArgumentListInfo *TemplateArgs) { 1250 if (!TemplateArgs && !TemplateKWLoc.isValid()) 1251 return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType, 1252 IsArrow, OperatorLoc, 1253 QualifierLoc, 1254 FirstQualifierFoundInScope, 1255 MemberNameInfo); 1256 1257 unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->size() : 0; 1258 std::size_t size = sizeof(CXXDependentScopeMemberExpr) 1259 + ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 1260 1261 void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>()); 1262 return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType, 1263 IsArrow, OperatorLoc, 1264 QualifierLoc, 1265 TemplateKWLoc, 1266 FirstQualifierFoundInScope, 1267 MemberNameInfo, TemplateArgs); 1268 } 1269 1270 CXXDependentScopeMemberExpr * 1271 CXXDependentScopeMemberExpr::CreateEmpty(const ASTContext &C, 1272 bool HasTemplateKWAndArgsInfo, 1273 unsigned NumTemplateArgs) { 1274 if (!HasTemplateKWAndArgsInfo) 1275 return new (C) CXXDependentScopeMemberExpr(C, nullptr, QualType(), 1276 0, SourceLocation(), 1277 NestedNameSpecifierLoc(), 1278 nullptr, DeclarationNameInfo()); 1279 1280 std::size_t size = sizeof(CXXDependentScopeMemberExpr) + 1281 ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 1282 void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>()); 1283 CXXDependentScopeMemberExpr *E 1284 = new (Mem) CXXDependentScopeMemberExpr(C, nullptr, QualType(), 1285 0, SourceLocation(), 1286 NestedNameSpecifierLoc(), 1287 SourceLocation(), nullptr, 1288 DeclarationNameInfo(), nullptr); 1289 E->HasTemplateKWAndArgsInfo = true; 1290 return E; 1291 } 1292 1293 bool CXXDependentScopeMemberExpr::isImplicitAccess() const { 1294 if (!Base) 1295 return true; 1296 1297 return cast<Expr>(Base)->isImplicitCXXThis(); 1298 } 1299 1300 static bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin, 1301 UnresolvedSetIterator end) { 1302 do { 1303 NamedDecl *decl = *begin; 1304 if (isa<UnresolvedUsingValueDecl>(decl)) 1305 return false; 1306 1307 // Unresolved member expressions should only contain methods and 1308 // method templates. 1309 if (cast<CXXMethodDecl>(decl->getUnderlyingDecl()->getAsFunction()) 1310 ->isStatic()) 1311 return false; 1312 } while (++begin != end); 1313 1314 return true; 1315 } 1316 1317 UnresolvedMemberExpr::UnresolvedMemberExpr(const ASTContext &C, 1318 bool HasUnresolvedUsing, 1319 Expr *Base, QualType BaseType, 1320 bool IsArrow, 1321 SourceLocation OperatorLoc, 1322 NestedNameSpecifierLoc QualifierLoc, 1323 SourceLocation TemplateKWLoc, 1324 const DeclarationNameInfo &MemberNameInfo, 1325 const TemplateArgumentListInfo *TemplateArgs, 1326 UnresolvedSetIterator Begin, 1327 UnresolvedSetIterator End) 1328 : OverloadExpr(UnresolvedMemberExprClass, C, QualifierLoc, TemplateKWLoc, 1329 MemberNameInfo, TemplateArgs, Begin, End, 1330 // Dependent 1331 ((Base && Base->isTypeDependent()) || 1332 BaseType->isDependentType()), 1333 ((Base && Base->isInstantiationDependent()) || 1334 BaseType->isInstantiationDependentType()), 1335 // Contains unexpanded parameter pack 1336 ((Base && Base->containsUnexpandedParameterPack()) || 1337 BaseType->containsUnexpandedParameterPack())), 1338 IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing), 1339 Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) { 1340 1341 // Check whether all of the members are non-static member functions, 1342 // and if so, mark give this bound-member type instead of overload type. 1343 if (hasOnlyNonStaticMemberFunctions(Begin, End)) 1344 setType(C.BoundMemberTy); 1345 } 1346 1347 bool UnresolvedMemberExpr::isImplicitAccess() const { 1348 if (!Base) 1349 return true; 1350 1351 return cast<Expr>(Base)->isImplicitCXXThis(); 1352 } 1353 1354 UnresolvedMemberExpr * 1355 UnresolvedMemberExpr::Create(const ASTContext &C, bool HasUnresolvedUsing, 1356 Expr *Base, QualType BaseType, bool IsArrow, 1357 SourceLocation OperatorLoc, 1358 NestedNameSpecifierLoc QualifierLoc, 1359 SourceLocation TemplateKWLoc, 1360 const DeclarationNameInfo &MemberNameInfo, 1361 const TemplateArgumentListInfo *TemplateArgs, 1362 UnresolvedSetIterator Begin, 1363 UnresolvedSetIterator End) { 1364 std::size_t size = sizeof(UnresolvedMemberExpr); 1365 if (TemplateArgs) 1366 size += ASTTemplateKWAndArgsInfo::sizeFor(TemplateArgs->size()); 1367 else if (TemplateKWLoc.isValid()) 1368 size += ASTTemplateKWAndArgsInfo::sizeFor(0); 1369 1370 void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>()); 1371 return new (Mem) UnresolvedMemberExpr(C, 1372 HasUnresolvedUsing, Base, BaseType, 1373 IsArrow, OperatorLoc, QualifierLoc, TemplateKWLoc, 1374 MemberNameInfo, TemplateArgs, Begin, End); 1375 } 1376 1377 UnresolvedMemberExpr * 1378 UnresolvedMemberExpr::CreateEmpty(const ASTContext &C, 1379 bool HasTemplateKWAndArgsInfo, 1380 unsigned NumTemplateArgs) { 1381 std::size_t size = sizeof(UnresolvedMemberExpr); 1382 if (HasTemplateKWAndArgsInfo) 1383 size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 1384 1385 void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>()); 1386 UnresolvedMemberExpr *E = new (Mem) UnresolvedMemberExpr(EmptyShell()); 1387 E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo; 1388 return E; 1389 } 1390 1391 CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const { 1392 // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this. 1393 1394 // If there was a nested name specifier, it names the naming class. 1395 // It can't be dependent: after all, we were actually able to do the 1396 // lookup. 1397 CXXRecordDecl *Record = nullptr; 1398 if (getQualifier()) { 1399 const Type *T = getQualifier()->getAsType(); 1400 assert(T && "qualifier in member expression does not name type"); 1401 Record = T->getAsCXXRecordDecl(); 1402 assert(Record && "qualifier in member expression does not name record"); 1403 } 1404 // Otherwise the naming class must have been the base class. 1405 else { 1406 QualType BaseType = getBaseType().getNonReferenceType(); 1407 if (isArrow()) { 1408 const PointerType *PT = BaseType->getAs<PointerType>(); 1409 assert(PT && "base of arrow member access is not pointer"); 1410 BaseType = PT->getPointeeType(); 1411 } 1412 1413 Record = BaseType->getAsCXXRecordDecl(); 1414 assert(Record && "base of member expression does not name record"); 1415 } 1416 1417 return Record; 1418 } 1419 1420 SubstNonTypeTemplateParmPackExpr:: 1421 SubstNonTypeTemplateParmPackExpr(QualType T, 1422 NonTypeTemplateParmDecl *Param, 1423 SourceLocation NameLoc, 1424 const TemplateArgument &ArgPack) 1425 : Expr(SubstNonTypeTemplateParmPackExprClass, T, VK_RValue, OK_Ordinary, 1426 true, true, true, true), 1427 Param(Param), Arguments(ArgPack.pack_begin()), 1428 NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) { } 1429 1430 TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const { 1431 return TemplateArgument(Arguments, NumArguments); 1432 } 1433 1434 FunctionParmPackExpr::FunctionParmPackExpr(QualType T, ParmVarDecl *ParamPack, 1435 SourceLocation NameLoc, 1436 unsigned NumParams, 1437 Decl * const *Params) 1438 : Expr(FunctionParmPackExprClass, T, VK_LValue, OK_Ordinary, 1439 true, true, true, true), 1440 ParamPack(ParamPack), NameLoc(NameLoc), NumParameters(NumParams) { 1441 if (Params) 1442 std::uninitialized_copy(Params, Params + NumParams, 1443 reinterpret_cast<Decl**>(this+1)); 1444 } 1445 1446 FunctionParmPackExpr * 1447 FunctionParmPackExpr::Create(const ASTContext &Context, QualType T, 1448 ParmVarDecl *ParamPack, SourceLocation NameLoc, 1449 ArrayRef<Decl *> Params) { 1450 return new (Context.Allocate(sizeof(FunctionParmPackExpr) + 1451 sizeof(ParmVarDecl*) * Params.size())) 1452 FunctionParmPackExpr(T, ParamPack, NameLoc, Params.size(), Params.data()); 1453 } 1454 1455 FunctionParmPackExpr * 1456 FunctionParmPackExpr::CreateEmpty(const ASTContext &Context, 1457 unsigned NumParams) { 1458 return new (Context.Allocate(sizeof(FunctionParmPackExpr) + 1459 sizeof(ParmVarDecl*) * NumParams)) 1460 FunctionParmPackExpr(QualType(), nullptr, SourceLocation(), 0, nullptr); 1461 } 1462 1463 void MaterializeTemporaryExpr::setExtendingDecl(const ValueDecl *ExtendedBy, 1464 unsigned ManglingNumber) { 1465 // We only need extra state if we have to remember more than just the Stmt. 1466 if (!ExtendedBy) 1467 return; 1468 1469 // We may need to allocate extra storage for the mangling number and the 1470 // extended-by ValueDecl. 1471 if (!State.is<ExtraState *>()) { 1472 auto ES = new (ExtendedBy->getASTContext()) ExtraState; 1473 ES->Temporary = State.get<Stmt *>(); 1474 State = ES; 1475 } 1476 1477 auto ES = State.get<ExtraState *>(); 1478 ES->ExtendingDecl = ExtendedBy; 1479 ES->ManglingNumber = ManglingNumber; 1480 } 1481 1482 TypeTraitExpr::TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind, 1483 ArrayRef<TypeSourceInfo *> Args, 1484 SourceLocation RParenLoc, 1485 bool Value) 1486 : Expr(TypeTraitExprClass, T, VK_RValue, OK_Ordinary, 1487 /*TypeDependent=*/false, 1488 /*ValueDependent=*/false, 1489 /*InstantiationDependent=*/false, 1490 /*ContainsUnexpandedParameterPack=*/false), 1491 Loc(Loc), RParenLoc(RParenLoc) 1492 { 1493 TypeTraitExprBits.Kind = Kind; 1494 TypeTraitExprBits.Value = Value; 1495 TypeTraitExprBits.NumArgs = Args.size(); 1496 1497 TypeSourceInfo **ToArgs = getTypeSourceInfos(); 1498 1499 for (unsigned I = 0, N = Args.size(); I != N; ++I) { 1500 if (Args[I]->getType()->isDependentType()) 1501 setValueDependent(true); 1502 if (Args[I]->getType()->isInstantiationDependentType()) 1503 setInstantiationDependent(true); 1504 if (Args[I]->getType()->containsUnexpandedParameterPack()) 1505 setContainsUnexpandedParameterPack(true); 1506 1507 ToArgs[I] = Args[I]; 1508 } 1509 } 1510 1511 TypeTraitExpr *TypeTraitExpr::Create(const ASTContext &C, QualType T, 1512 SourceLocation Loc, 1513 TypeTrait Kind, 1514 ArrayRef<TypeSourceInfo *> Args, 1515 SourceLocation RParenLoc, 1516 bool Value) { 1517 unsigned Size = sizeof(TypeTraitExpr) + sizeof(TypeSourceInfo*) * Args.size(); 1518 void *Mem = C.Allocate(Size); 1519 return new (Mem) TypeTraitExpr(T, Loc, Kind, Args, RParenLoc, Value); 1520 } 1521 1522 TypeTraitExpr *TypeTraitExpr::CreateDeserialized(const ASTContext &C, 1523 unsigned NumArgs) { 1524 unsigned Size = sizeof(TypeTraitExpr) + sizeof(TypeSourceInfo*) * NumArgs; 1525 void *Mem = C.Allocate(Size); 1526 return new (Mem) TypeTraitExpr(EmptyShell()); 1527 } 1528 1529 void ArrayTypeTraitExpr::anchor() { } 1530