1 //===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===// 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 semantic analysis for initializers. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Sema/Initialization.h" 15 #include "clang/AST/ASTContext.h" 16 #include "clang/AST/DeclObjC.h" 17 #include "clang/AST/ExprCXX.h" 18 #include "clang/AST/ExprObjC.h" 19 #include "clang/AST/TypeLoc.h" 20 #include "clang/Basic/TargetInfo.h" 21 #include "clang/Sema/Designator.h" 22 #include "clang/Sema/Lookup.h" 23 #include "clang/Sema/SemaInternal.h" 24 #include "llvm/ADT/APInt.h" 25 #include "llvm/ADT/SmallString.h" 26 #include "llvm/Support/ErrorHandling.h" 27 #include "llvm/Support/raw_ostream.h" 28 #include <map> 29 30 using namespace clang; 31 32 //===----------------------------------------------------------------------===// 33 // Sema Initialization Checking 34 //===----------------------------------------------------------------------===// 35 36 /// \brief Check whether T is compatible with a wide character type (wchar_t, 37 /// char16_t or char32_t). 38 static bool IsWideCharCompatible(QualType T, ASTContext &Context) { 39 if (Context.typesAreCompatible(Context.getWideCharType(), T)) 40 return true; 41 if (Context.getLangOpts().CPlusPlus || Context.getLangOpts().C11) { 42 return Context.typesAreCompatible(Context.Char16Ty, T) || 43 Context.typesAreCompatible(Context.Char32Ty, T); 44 } 45 return false; 46 } 47 48 enum StringInitFailureKind { 49 SIF_None, 50 SIF_NarrowStringIntoWideChar, 51 SIF_WideStringIntoChar, 52 SIF_IncompatWideStringIntoWideChar, 53 SIF_Other 54 }; 55 56 /// \brief Check whether the array of type AT can be initialized by the Init 57 /// expression by means of string initialization. Returns SIF_None if so, 58 /// otherwise returns a StringInitFailureKind that describes why the 59 /// initialization would not work. 60 static StringInitFailureKind IsStringInit(Expr *Init, const ArrayType *AT, 61 ASTContext &Context) { 62 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT)) 63 return SIF_Other; 64 65 // See if this is a string literal or @encode. 66 Init = Init->IgnoreParens(); 67 68 // Handle @encode, which is a narrow string. 69 if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType()) 70 return SIF_None; 71 72 // Otherwise we can only handle string literals. 73 StringLiteral *SL = dyn_cast<StringLiteral>(Init); 74 if (!SL) 75 return SIF_Other; 76 77 const QualType ElemTy = 78 Context.getCanonicalType(AT->getElementType()).getUnqualifiedType(); 79 80 switch (SL->getKind()) { 81 case StringLiteral::Ascii: 82 case StringLiteral::UTF8: 83 // char array can be initialized with a narrow string. 84 // Only allow char x[] = "foo"; not char x[] = L"foo"; 85 if (ElemTy->isCharType()) 86 return SIF_None; 87 if (IsWideCharCompatible(ElemTy, Context)) 88 return SIF_NarrowStringIntoWideChar; 89 return SIF_Other; 90 // C99 6.7.8p15 (with correction from DR343), or C11 6.7.9p15: 91 // "An array with element type compatible with a qualified or unqualified 92 // version of wchar_t, char16_t, or char32_t may be initialized by a wide 93 // string literal with the corresponding encoding prefix (L, u, or U, 94 // respectively), optionally enclosed in braces. 95 case StringLiteral::UTF16: 96 if (Context.typesAreCompatible(Context.Char16Ty, ElemTy)) 97 return SIF_None; 98 if (ElemTy->isCharType()) 99 return SIF_WideStringIntoChar; 100 if (IsWideCharCompatible(ElemTy, Context)) 101 return SIF_IncompatWideStringIntoWideChar; 102 return SIF_Other; 103 case StringLiteral::UTF32: 104 if (Context.typesAreCompatible(Context.Char32Ty, ElemTy)) 105 return SIF_None; 106 if (ElemTy->isCharType()) 107 return SIF_WideStringIntoChar; 108 if (IsWideCharCompatible(ElemTy, Context)) 109 return SIF_IncompatWideStringIntoWideChar; 110 return SIF_Other; 111 case StringLiteral::Wide: 112 if (Context.typesAreCompatible(Context.getWideCharType(), ElemTy)) 113 return SIF_None; 114 if (ElemTy->isCharType()) 115 return SIF_WideStringIntoChar; 116 if (IsWideCharCompatible(ElemTy, Context)) 117 return SIF_IncompatWideStringIntoWideChar; 118 return SIF_Other; 119 } 120 121 llvm_unreachable("missed a StringLiteral kind?"); 122 } 123 124 static StringInitFailureKind IsStringInit(Expr *init, QualType declType, 125 ASTContext &Context) { 126 const ArrayType *arrayType = Context.getAsArrayType(declType); 127 if (!arrayType) 128 return SIF_Other; 129 return IsStringInit(init, arrayType, Context); 130 } 131 132 /// Update the type of a string literal, including any surrounding parentheses, 133 /// to match the type of the object which it is initializing. 134 static void updateStringLiteralType(Expr *E, QualType Ty) { 135 while (true) { 136 E->setType(Ty); 137 if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E)) 138 break; 139 else if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) 140 E = PE->getSubExpr(); 141 else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) 142 E = UO->getSubExpr(); 143 else if (GenericSelectionExpr *GSE = dyn_cast<GenericSelectionExpr>(E)) 144 E = GSE->getResultExpr(); 145 else 146 llvm_unreachable("unexpected expr in string literal init"); 147 } 148 } 149 150 static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT, 151 Sema &S) { 152 // Get the length of the string as parsed. 153 auto *ConstantArrayTy = 154 cast<ConstantArrayType>(Str->getType()->getAsArrayTypeUnsafe()); 155 uint64_t StrLength = ConstantArrayTy->getSize().getZExtValue(); 156 157 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 158 // C99 6.7.8p14. We have an array of character type with unknown size 159 // being initialized to a string literal. 160 llvm::APInt ConstVal(32, StrLength); 161 // Return a new array type (C99 6.7.8p22). 162 DeclT = S.Context.getConstantArrayType(IAT->getElementType(), 163 ConstVal, 164 ArrayType::Normal, 0); 165 updateStringLiteralType(Str, DeclT); 166 return; 167 } 168 169 const ConstantArrayType *CAT = cast<ConstantArrayType>(AT); 170 171 // We have an array of character type with known size. However, 172 // the size may be smaller or larger than the string we are initializing. 173 // FIXME: Avoid truncation for 64-bit length strings. 174 if (S.getLangOpts().CPlusPlus) { 175 if (StringLiteral *SL = dyn_cast<StringLiteral>(Str->IgnoreParens())) { 176 // For Pascal strings it's OK to strip off the terminating null character, 177 // so the example below is valid: 178 // 179 // unsigned char a[2] = "\pa"; 180 if (SL->isPascal()) 181 StrLength--; 182 } 183 184 // [dcl.init.string]p2 185 if (StrLength > CAT->getSize().getZExtValue()) 186 S.Diag(Str->getLocStart(), 187 diag::err_initializer_string_for_char_array_too_long) 188 << Str->getSourceRange(); 189 } else { 190 // C99 6.7.8p14. 191 if (StrLength-1 > CAT->getSize().getZExtValue()) 192 S.Diag(Str->getLocStart(), 193 diag::ext_initializer_string_for_char_array_too_long) 194 << Str->getSourceRange(); 195 } 196 197 // Set the type to the actual size that we are initializing. If we have 198 // something like: 199 // char x[1] = "foo"; 200 // then this will set the string literal's type to char[1]. 201 updateStringLiteralType(Str, DeclT); 202 } 203 204 //===----------------------------------------------------------------------===// 205 // Semantic checking for initializer lists. 206 //===----------------------------------------------------------------------===// 207 208 namespace { 209 210 /// @brief Semantic checking for initializer lists. 211 /// 212 /// The InitListChecker class contains a set of routines that each 213 /// handle the initialization of a certain kind of entity, e.g., 214 /// arrays, vectors, struct/union types, scalars, etc. The 215 /// InitListChecker itself performs a recursive walk of the subobject 216 /// structure of the type to be initialized, while stepping through 217 /// the initializer list one element at a time. The IList and Index 218 /// parameters to each of the Check* routines contain the active 219 /// (syntactic) initializer list and the index into that initializer 220 /// list that represents the current initializer. Each routine is 221 /// responsible for moving that Index forward as it consumes elements. 222 /// 223 /// Each Check* routine also has a StructuredList/StructuredIndex 224 /// arguments, which contains the current "structured" (semantic) 225 /// initializer list and the index into that initializer list where we 226 /// are copying initializers as we map them over to the semantic 227 /// list. Once we have completed our recursive walk of the subobject 228 /// structure, we will have constructed a full semantic initializer 229 /// list. 230 /// 231 /// C99 designators cause changes in the initializer list traversal, 232 /// because they make the initialization "jump" into a specific 233 /// subobject and then continue the initialization from that 234 /// point. CheckDesignatedInitializer() recursively steps into the 235 /// designated subobject and manages backing out the recursion to 236 /// initialize the subobjects after the one designated. 237 class InitListChecker { 238 Sema &SemaRef; 239 bool hadError; 240 bool VerifyOnly; // no diagnostics, no structure building 241 bool TreatUnavailableAsInvalid; // Used only in VerifyOnly mode. 242 llvm::DenseMap<InitListExpr *, InitListExpr *> SyntacticToSemantic; 243 InitListExpr *FullyStructuredList; 244 245 void CheckImplicitInitList(const InitializedEntity &Entity, 246 InitListExpr *ParentIList, QualType T, 247 unsigned &Index, InitListExpr *StructuredList, 248 unsigned &StructuredIndex); 249 void CheckExplicitInitList(const InitializedEntity &Entity, 250 InitListExpr *IList, QualType &T, 251 InitListExpr *StructuredList, 252 bool TopLevelObject = false); 253 void CheckListElementTypes(const InitializedEntity &Entity, 254 InitListExpr *IList, QualType &DeclType, 255 bool SubobjectIsDesignatorContext, 256 unsigned &Index, 257 InitListExpr *StructuredList, 258 unsigned &StructuredIndex, 259 bool TopLevelObject = false); 260 void CheckSubElementType(const InitializedEntity &Entity, 261 InitListExpr *IList, QualType ElemType, 262 unsigned &Index, 263 InitListExpr *StructuredList, 264 unsigned &StructuredIndex); 265 void CheckComplexType(const InitializedEntity &Entity, 266 InitListExpr *IList, QualType DeclType, 267 unsigned &Index, 268 InitListExpr *StructuredList, 269 unsigned &StructuredIndex); 270 void CheckScalarType(const InitializedEntity &Entity, 271 InitListExpr *IList, QualType DeclType, 272 unsigned &Index, 273 InitListExpr *StructuredList, 274 unsigned &StructuredIndex); 275 void CheckReferenceType(const InitializedEntity &Entity, 276 InitListExpr *IList, QualType DeclType, 277 unsigned &Index, 278 InitListExpr *StructuredList, 279 unsigned &StructuredIndex); 280 void CheckVectorType(const InitializedEntity &Entity, 281 InitListExpr *IList, QualType DeclType, unsigned &Index, 282 InitListExpr *StructuredList, 283 unsigned &StructuredIndex); 284 void CheckStructUnionTypes(const InitializedEntity &Entity, 285 InitListExpr *IList, QualType DeclType, 286 CXXRecordDecl::base_class_range Bases, 287 RecordDecl::field_iterator Field, 288 bool SubobjectIsDesignatorContext, unsigned &Index, 289 InitListExpr *StructuredList, 290 unsigned &StructuredIndex, 291 bool TopLevelObject = false); 292 void CheckArrayType(const InitializedEntity &Entity, 293 InitListExpr *IList, QualType &DeclType, 294 llvm::APSInt elementIndex, 295 bool SubobjectIsDesignatorContext, unsigned &Index, 296 InitListExpr *StructuredList, 297 unsigned &StructuredIndex); 298 bool CheckDesignatedInitializer(const InitializedEntity &Entity, 299 InitListExpr *IList, DesignatedInitExpr *DIE, 300 unsigned DesigIdx, 301 QualType &CurrentObjectType, 302 RecordDecl::field_iterator *NextField, 303 llvm::APSInt *NextElementIndex, 304 unsigned &Index, 305 InitListExpr *StructuredList, 306 unsigned &StructuredIndex, 307 bool FinishSubobjectInit, 308 bool TopLevelObject); 309 InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index, 310 QualType CurrentObjectType, 311 InitListExpr *StructuredList, 312 unsigned StructuredIndex, 313 SourceRange InitRange, 314 bool IsFullyOverwritten = false); 315 void UpdateStructuredListElement(InitListExpr *StructuredList, 316 unsigned &StructuredIndex, 317 Expr *expr); 318 int numArrayElements(QualType DeclType); 319 int numStructUnionElements(QualType DeclType); 320 321 static ExprResult PerformEmptyInit(Sema &SemaRef, 322 SourceLocation Loc, 323 const InitializedEntity &Entity, 324 bool VerifyOnly, 325 bool TreatUnavailableAsInvalid); 326 327 // Explanation on the "FillWithNoInit" mode: 328 // 329 // Assume we have the following definitions (Case#1): 330 // struct P { char x[6][6]; } xp = { .x[1] = "bar" }; 331 // struct PP { struct P lp; } l = { .lp = xp, .lp.x[1][2] = 'f' }; 332 // 333 // l.lp.x[1][0..1] should not be filled with implicit initializers because the 334 // "base" initializer "xp" will provide values for them; l.lp.x[1] will be "baf". 335 // 336 // But if we have (Case#2): 337 // struct PP l = { .lp = xp, .lp.x[1] = { [2] = 'f' } }; 338 // 339 // l.lp.x[1][0..1] are implicitly initialized and do not use values from the 340 // "base" initializer; l.lp.x[1] will be "\0\0f\0\0\0". 341 // 342 // To distinguish Case#1 from Case#2, and also to avoid leaving many "holes" 343 // in the InitListExpr, the "holes" in Case#1 are filled not with empty 344 // initializers but with special "NoInitExpr" place holders, which tells the 345 // CodeGen not to generate any initializers for these parts. 346 void FillInEmptyInitForBase(unsigned Init, const CXXBaseSpecifier &Base, 347 const InitializedEntity &ParentEntity, 348 InitListExpr *ILE, bool &RequiresSecondPass, 349 bool FillWithNoInit); 350 void FillInEmptyInitForField(unsigned Init, FieldDecl *Field, 351 const InitializedEntity &ParentEntity, 352 InitListExpr *ILE, bool &RequiresSecondPass, 353 bool FillWithNoInit = false); 354 void FillInEmptyInitializations(const InitializedEntity &Entity, 355 InitListExpr *ILE, bool &RequiresSecondPass, 356 bool FillWithNoInit = false); 357 bool CheckFlexibleArrayInit(const InitializedEntity &Entity, 358 Expr *InitExpr, FieldDecl *Field, 359 bool TopLevelObject); 360 void CheckEmptyInitializable(const InitializedEntity &Entity, 361 SourceLocation Loc); 362 363 public: 364 InitListChecker(Sema &S, const InitializedEntity &Entity, 365 InitListExpr *IL, QualType &T, bool VerifyOnly, 366 bool TreatUnavailableAsInvalid); 367 bool HadError() { return hadError; } 368 369 // @brief Retrieves the fully-structured initializer list used for 370 // semantic analysis and code generation. 371 InitListExpr *getFullyStructuredList() const { return FullyStructuredList; } 372 }; 373 374 } // end anonymous namespace 375 376 ExprResult InitListChecker::PerformEmptyInit(Sema &SemaRef, 377 SourceLocation Loc, 378 const InitializedEntity &Entity, 379 bool VerifyOnly, 380 bool TreatUnavailableAsInvalid) { 381 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc, 382 true); 383 MultiExprArg SubInit; 384 Expr *InitExpr; 385 InitListExpr DummyInitList(SemaRef.Context, Loc, None, Loc); 386 387 // C++ [dcl.init.aggr]p7: 388 // If there are fewer initializer-clauses in the list than there are 389 // members in the aggregate, then each member not explicitly initialized 390 // ... 391 bool EmptyInitList = SemaRef.getLangOpts().CPlusPlus11 && 392 Entity.getType()->getBaseElementTypeUnsafe()->isRecordType(); 393 if (EmptyInitList) { 394 // C++1y / DR1070: 395 // shall be initialized [...] from an empty initializer list. 396 // 397 // We apply the resolution of this DR to C++11 but not C++98, since C++98 398 // does not have useful semantics for initialization from an init list. 399 // We treat this as copy-initialization, because aggregate initialization 400 // always performs copy-initialization on its elements. 401 // 402 // Only do this if we're initializing a class type, to avoid filling in 403 // the initializer list where possible. 404 InitExpr = VerifyOnly ? &DummyInitList : new (SemaRef.Context) 405 InitListExpr(SemaRef.Context, Loc, None, Loc); 406 InitExpr->setType(SemaRef.Context.VoidTy); 407 SubInit = InitExpr; 408 Kind = InitializationKind::CreateCopy(Loc, Loc); 409 } else { 410 // C++03: 411 // shall be value-initialized. 412 } 413 414 InitializationSequence InitSeq(SemaRef, Entity, Kind, SubInit); 415 // libstdc++4.6 marks the vector default constructor as explicit in 416 // _GLIBCXX_DEBUG mode, so recover using the C++03 logic in that case. 417 // stlport does so too. Look for std::__debug for libstdc++, and for 418 // std:: for stlport. This is effectively a compiler-side implementation of 419 // LWG2193. 420 if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() == 421 InitializationSequence::FK_ExplicitConstructor) { 422 OverloadCandidateSet::iterator Best; 423 OverloadingResult O = 424 InitSeq.getFailedCandidateSet() 425 .BestViableFunction(SemaRef, Kind.getLocation(), Best); 426 (void)O; 427 assert(O == OR_Success && "Inconsistent overload resolution"); 428 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function); 429 CXXRecordDecl *R = CtorDecl->getParent(); 430 431 if (CtorDecl->getMinRequiredArguments() == 0 && 432 CtorDecl->isExplicit() && R->getDeclName() && 433 SemaRef.SourceMgr.isInSystemHeader(CtorDecl->getLocation())) { 434 bool IsInStd = false; 435 for (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(R->getDeclContext()); 436 ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) { 437 if (SemaRef.getStdNamespace()->InEnclosingNamespaceSetOf(ND)) 438 IsInStd = true; 439 } 440 441 if (IsInStd && llvm::StringSwitch<bool>(R->getName()) 442 .Cases("basic_string", "deque", "forward_list", true) 443 .Cases("list", "map", "multimap", "multiset", true) 444 .Cases("priority_queue", "queue", "set", "stack", true) 445 .Cases("unordered_map", "unordered_set", "vector", true) 446 .Default(false)) { 447 InitSeq.InitializeFrom( 448 SemaRef, Entity, 449 InitializationKind::CreateValue(Loc, Loc, Loc, true), 450 MultiExprArg(), /*TopLevelOfInitList=*/false, 451 TreatUnavailableAsInvalid); 452 // Emit a warning for this. System header warnings aren't shown 453 // by default, but people working on system headers should see it. 454 if (!VerifyOnly) { 455 SemaRef.Diag(CtorDecl->getLocation(), 456 diag::warn_invalid_initializer_from_system_header); 457 if (Entity.getKind() == InitializedEntity::EK_Member) 458 SemaRef.Diag(Entity.getDecl()->getLocation(), 459 diag::note_used_in_initialization_here); 460 else if (Entity.getKind() == InitializedEntity::EK_ArrayElement) 461 SemaRef.Diag(Loc, diag::note_used_in_initialization_here); 462 } 463 } 464 } 465 } 466 if (!InitSeq) { 467 if (!VerifyOnly) { 468 InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit); 469 if (Entity.getKind() == InitializedEntity::EK_Member) 470 SemaRef.Diag(Entity.getDecl()->getLocation(), 471 diag::note_in_omitted_aggregate_initializer) 472 << /*field*/1 << Entity.getDecl(); 473 else if (Entity.getKind() == InitializedEntity::EK_ArrayElement) 474 SemaRef.Diag(Loc, diag::note_in_omitted_aggregate_initializer) 475 << /*array element*/0 << Entity.getElementIndex(); 476 } 477 return ExprError(); 478 } 479 480 return VerifyOnly ? ExprResult(static_cast<Expr *>(nullptr)) 481 : InitSeq.Perform(SemaRef, Entity, Kind, SubInit); 482 } 483 484 void InitListChecker::CheckEmptyInitializable(const InitializedEntity &Entity, 485 SourceLocation Loc) { 486 assert(VerifyOnly && 487 "CheckEmptyInitializable is only inteded for verification mode."); 488 if (PerformEmptyInit(SemaRef, Loc, Entity, /*VerifyOnly*/true, 489 TreatUnavailableAsInvalid).isInvalid()) 490 hadError = true; 491 } 492 493 void InitListChecker::FillInEmptyInitForBase( 494 unsigned Init, const CXXBaseSpecifier &Base, 495 const InitializedEntity &ParentEntity, InitListExpr *ILE, 496 bool &RequiresSecondPass, bool FillWithNoInit) { 497 assert(Init < ILE->getNumInits() && "should have been expanded"); 498 499 InitializedEntity BaseEntity = InitializedEntity::InitializeBase( 500 SemaRef.Context, &Base, false, &ParentEntity); 501 502 if (!ILE->getInit(Init)) { 503 ExprResult BaseInit = 504 FillWithNoInit ? new (SemaRef.Context) NoInitExpr(Base.getType()) 505 : PerformEmptyInit(SemaRef, ILE->getLocEnd(), BaseEntity, 506 /*VerifyOnly*/ false, 507 TreatUnavailableAsInvalid); 508 if (BaseInit.isInvalid()) { 509 hadError = true; 510 return; 511 } 512 513 ILE->setInit(Init, BaseInit.getAs<Expr>()); 514 } else if (InitListExpr *InnerILE = 515 dyn_cast<InitListExpr>(ILE->getInit(Init))) { 516 FillInEmptyInitializations(BaseEntity, InnerILE, 517 RequiresSecondPass, FillWithNoInit); 518 } else if (DesignatedInitUpdateExpr *InnerDIUE = 519 dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init))) { 520 FillInEmptyInitializations(BaseEntity, InnerDIUE->getUpdater(), 521 RequiresSecondPass, /*FillWithNoInit =*/true); 522 } 523 } 524 525 void InitListChecker::FillInEmptyInitForField(unsigned Init, FieldDecl *Field, 526 const InitializedEntity &ParentEntity, 527 InitListExpr *ILE, 528 bool &RequiresSecondPass, 529 bool FillWithNoInit) { 530 SourceLocation Loc = ILE->getLocEnd(); 531 unsigned NumInits = ILE->getNumInits(); 532 InitializedEntity MemberEntity 533 = InitializedEntity::InitializeMember(Field, &ParentEntity); 534 535 if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) 536 if (!RType->getDecl()->isUnion()) 537 assert(Init < NumInits && "This ILE should have been expanded"); 538 539 if (Init >= NumInits || !ILE->getInit(Init)) { 540 if (FillWithNoInit) { 541 Expr *Filler = new (SemaRef.Context) NoInitExpr(Field->getType()); 542 if (Init < NumInits) 543 ILE->setInit(Init, Filler); 544 else 545 ILE->updateInit(SemaRef.Context, Init, Filler); 546 return; 547 } 548 // C++1y [dcl.init.aggr]p7: 549 // If there are fewer initializer-clauses in the list than there are 550 // members in the aggregate, then each member not explicitly initialized 551 // shall be initialized from its brace-or-equal-initializer [...] 552 if (Field->hasInClassInitializer()) { 553 ExprResult DIE = SemaRef.BuildCXXDefaultInitExpr(Loc, Field); 554 if (DIE.isInvalid()) { 555 hadError = true; 556 return; 557 } 558 if (Init < NumInits) 559 ILE->setInit(Init, DIE.get()); 560 else { 561 ILE->updateInit(SemaRef.Context, Init, DIE.get()); 562 RequiresSecondPass = true; 563 } 564 return; 565 } 566 567 if (Field->getType()->isReferenceType()) { 568 // C++ [dcl.init.aggr]p9: 569 // If an incomplete or empty initializer-list leaves a 570 // member of reference type uninitialized, the program is 571 // ill-formed. 572 SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized) 573 << Field->getType() 574 << ILE->getSyntacticForm()->getSourceRange(); 575 SemaRef.Diag(Field->getLocation(), 576 diag::note_uninit_reference_member); 577 hadError = true; 578 return; 579 } 580 581 ExprResult MemberInit = PerformEmptyInit(SemaRef, Loc, MemberEntity, 582 /*VerifyOnly*/false, 583 TreatUnavailableAsInvalid); 584 if (MemberInit.isInvalid()) { 585 hadError = true; 586 return; 587 } 588 589 if (hadError) { 590 // Do nothing 591 } else if (Init < NumInits) { 592 ILE->setInit(Init, MemberInit.getAs<Expr>()); 593 } else if (!isa<ImplicitValueInitExpr>(MemberInit.get())) { 594 // Empty initialization requires a constructor call, so 595 // extend the initializer list to include the constructor 596 // call and make a note that we'll need to take another pass 597 // through the initializer list. 598 ILE->updateInit(SemaRef.Context, Init, MemberInit.getAs<Expr>()); 599 RequiresSecondPass = true; 600 } 601 } else if (InitListExpr *InnerILE 602 = dyn_cast<InitListExpr>(ILE->getInit(Init))) 603 FillInEmptyInitializations(MemberEntity, InnerILE, 604 RequiresSecondPass, FillWithNoInit); 605 else if (DesignatedInitUpdateExpr *InnerDIUE 606 = dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init))) 607 FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(), 608 RequiresSecondPass, /*FillWithNoInit =*/ true); 609 } 610 611 /// Recursively replaces NULL values within the given initializer list 612 /// with expressions that perform value-initialization of the 613 /// appropriate type. 614 void 615 InitListChecker::FillInEmptyInitializations(const InitializedEntity &Entity, 616 InitListExpr *ILE, 617 bool &RequiresSecondPass, 618 bool FillWithNoInit) { 619 assert((ILE->getType() != SemaRef.Context.VoidTy) && 620 "Should not have void type"); 621 622 if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) { 623 const RecordDecl *RDecl = RType->getDecl(); 624 if (RDecl->isUnion() && ILE->getInitializedFieldInUnion()) 625 FillInEmptyInitForField(0, ILE->getInitializedFieldInUnion(), 626 Entity, ILE, RequiresSecondPass, FillWithNoInit); 627 else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) && 628 cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) { 629 for (auto *Field : RDecl->fields()) { 630 if (Field->hasInClassInitializer()) { 631 FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass, 632 FillWithNoInit); 633 break; 634 } 635 } 636 } else { 637 // The fields beyond ILE->getNumInits() are default initialized, so in 638 // order to leave them uninitialized, the ILE is expanded and the extra 639 // fields are then filled with NoInitExpr. 640 unsigned NumElems = numStructUnionElements(ILE->getType()); 641 if (RDecl->hasFlexibleArrayMember()) 642 ++NumElems; 643 if (ILE->getNumInits() < NumElems) 644 ILE->resizeInits(SemaRef.Context, NumElems); 645 646 unsigned Init = 0; 647 648 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RDecl)) { 649 for (auto &Base : CXXRD->bases()) { 650 if (hadError) 651 return; 652 653 FillInEmptyInitForBase(Init, Base, Entity, ILE, RequiresSecondPass, 654 FillWithNoInit); 655 ++Init; 656 } 657 } 658 659 for (auto *Field : RDecl->fields()) { 660 if (Field->isUnnamedBitfield()) 661 continue; 662 663 if (hadError) 664 return; 665 666 FillInEmptyInitForField(Init, Field, Entity, ILE, RequiresSecondPass, 667 FillWithNoInit); 668 if (hadError) 669 return; 670 671 ++Init; 672 673 // Only look at the first initialization of a union. 674 if (RDecl->isUnion()) 675 break; 676 } 677 } 678 679 return; 680 } 681 682 QualType ElementType; 683 684 InitializedEntity ElementEntity = Entity; 685 unsigned NumInits = ILE->getNumInits(); 686 unsigned NumElements = NumInits; 687 if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) { 688 ElementType = AType->getElementType(); 689 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) 690 NumElements = CAType->getSize().getZExtValue(); 691 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context, 692 0, Entity); 693 } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) { 694 ElementType = VType->getElementType(); 695 NumElements = VType->getNumElements(); 696 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context, 697 0, Entity); 698 } else 699 ElementType = ILE->getType(); 700 701 for (unsigned Init = 0; Init != NumElements; ++Init) { 702 if (hadError) 703 return; 704 705 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement || 706 ElementEntity.getKind() == InitializedEntity::EK_VectorElement) 707 ElementEntity.setElementIndex(Init); 708 709 Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : nullptr); 710 if (!InitExpr && Init < NumInits && ILE->hasArrayFiller()) 711 ILE->setInit(Init, ILE->getArrayFiller()); 712 else if (!InitExpr && !ILE->hasArrayFiller()) { 713 Expr *Filler = nullptr; 714 715 if (FillWithNoInit) 716 Filler = new (SemaRef.Context) NoInitExpr(ElementType); 717 else { 718 ExprResult ElementInit = PerformEmptyInit(SemaRef, ILE->getLocEnd(), 719 ElementEntity, 720 /*VerifyOnly*/false, 721 TreatUnavailableAsInvalid); 722 if (ElementInit.isInvalid()) { 723 hadError = true; 724 return; 725 } 726 727 Filler = ElementInit.getAs<Expr>(); 728 } 729 730 if (hadError) { 731 // Do nothing 732 } else if (Init < NumInits) { 733 // For arrays, just set the expression used for value-initialization 734 // of the "holes" in the array. 735 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) 736 ILE->setArrayFiller(Filler); 737 else 738 ILE->setInit(Init, Filler); 739 } else { 740 // For arrays, just set the expression used for value-initialization 741 // of the rest of elements and exit. 742 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) { 743 ILE->setArrayFiller(Filler); 744 return; 745 } 746 747 if (!isa<ImplicitValueInitExpr>(Filler) && !isa<NoInitExpr>(Filler)) { 748 // Empty initialization requires a constructor call, so 749 // extend the initializer list to include the constructor 750 // call and make a note that we'll need to take another pass 751 // through the initializer list. 752 ILE->updateInit(SemaRef.Context, Init, Filler); 753 RequiresSecondPass = true; 754 } 755 } 756 } else if (InitListExpr *InnerILE 757 = dyn_cast_or_null<InitListExpr>(InitExpr)) 758 FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass, 759 FillWithNoInit); 760 else if (DesignatedInitUpdateExpr *InnerDIUE 761 = dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr)) 762 FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(), 763 RequiresSecondPass, /*FillWithNoInit =*/ true); 764 } 765 } 766 767 InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity, 768 InitListExpr *IL, QualType &T, 769 bool VerifyOnly, 770 bool TreatUnavailableAsInvalid) 771 : SemaRef(S), VerifyOnly(VerifyOnly), 772 TreatUnavailableAsInvalid(TreatUnavailableAsInvalid) { 773 // FIXME: Check that IL isn't already the semantic form of some other 774 // InitListExpr. If it is, we'd create a broken AST. 775 776 hadError = false; 777 778 FullyStructuredList = 779 getStructuredSubobjectInit(IL, 0, T, nullptr, 0, IL->getSourceRange()); 780 CheckExplicitInitList(Entity, IL, T, FullyStructuredList, 781 /*TopLevelObject=*/true); 782 783 if (!hadError && !VerifyOnly) { 784 bool RequiresSecondPass = false; 785 FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass); 786 if (RequiresSecondPass && !hadError) 787 FillInEmptyInitializations(Entity, FullyStructuredList, 788 RequiresSecondPass); 789 } 790 } 791 792 int InitListChecker::numArrayElements(QualType DeclType) { 793 // FIXME: use a proper constant 794 int maxElements = 0x7FFFFFFF; 795 if (const ConstantArrayType *CAT = 796 SemaRef.Context.getAsConstantArrayType(DeclType)) { 797 maxElements = static_cast<int>(CAT->getSize().getZExtValue()); 798 } 799 return maxElements; 800 } 801 802 int InitListChecker::numStructUnionElements(QualType DeclType) { 803 RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl(); 804 int InitializableMembers = 0; 805 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(structDecl)) 806 InitializableMembers += CXXRD->getNumBases(); 807 for (const auto *Field : structDecl->fields()) 808 if (!Field->isUnnamedBitfield()) 809 ++InitializableMembers; 810 811 if (structDecl->isUnion()) 812 return std::min(InitializableMembers, 1); 813 return InitializableMembers - structDecl->hasFlexibleArrayMember(); 814 } 815 816 /// Check whether the range of the initializer \p ParentIList from element 817 /// \p Index onwards can be used to initialize an object of type \p T. Update 818 /// \p Index to indicate how many elements of the list were consumed. 819 /// 820 /// This also fills in \p StructuredList, from element \p StructuredIndex 821 /// onwards, with the fully-braced, desugared form of the initialization. 822 void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity, 823 InitListExpr *ParentIList, 824 QualType T, unsigned &Index, 825 InitListExpr *StructuredList, 826 unsigned &StructuredIndex) { 827 int maxElements = 0; 828 829 if (T->isArrayType()) 830 maxElements = numArrayElements(T); 831 else if (T->isRecordType()) 832 maxElements = numStructUnionElements(T); 833 else if (T->isVectorType()) 834 maxElements = T->getAs<VectorType>()->getNumElements(); 835 else 836 llvm_unreachable("CheckImplicitInitList(): Illegal type"); 837 838 if (maxElements == 0) { 839 if (!VerifyOnly) 840 SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(), 841 diag::err_implicit_empty_initializer); 842 ++Index; 843 hadError = true; 844 return; 845 } 846 847 // Build a structured initializer list corresponding to this subobject. 848 InitListExpr *StructuredSubobjectInitList 849 = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList, 850 StructuredIndex, 851 SourceRange(ParentIList->getInit(Index)->getLocStart(), 852 ParentIList->getSourceRange().getEnd())); 853 unsigned StructuredSubobjectInitIndex = 0; 854 855 // Check the element types and build the structural subobject. 856 unsigned StartIndex = Index; 857 CheckListElementTypes(Entity, ParentIList, T, 858 /*SubobjectIsDesignatorContext=*/false, Index, 859 StructuredSubobjectInitList, 860 StructuredSubobjectInitIndex); 861 862 if (!VerifyOnly) { 863 StructuredSubobjectInitList->setType(T); 864 865 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1); 866 // Update the structured sub-object initializer so that it's ending 867 // range corresponds with the end of the last initializer it used. 868 if (EndIndex < ParentIList->getNumInits() && 869 ParentIList->getInit(EndIndex)) { 870 SourceLocation EndLoc 871 = ParentIList->getInit(EndIndex)->getSourceRange().getEnd(); 872 StructuredSubobjectInitList->setRBraceLoc(EndLoc); 873 } 874 875 // Complain about missing braces. 876 if (T->isArrayType() || T->isRecordType()) { 877 SemaRef.Diag(StructuredSubobjectInitList->getLocStart(), 878 diag::warn_missing_braces) 879 << StructuredSubobjectInitList->getSourceRange() 880 << FixItHint::CreateInsertion( 881 StructuredSubobjectInitList->getLocStart(), "{") 882 << FixItHint::CreateInsertion( 883 SemaRef.getLocForEndOfToken( 884 StructuredSubobjectInitList->getLocEnd()), 885 "}"); 886 } 887 } 888 } 889 890 /// Warn that \p Entity was of scalar type and was initialized by a 891 /// single-element braced initializer list. 892 static void warnBracedScalarInit(Sema &S, const InitializedEntity &Entity, 893 SourceRange Braces) { 894 // Don't warn during template instantiation. If the initialization was 895 // non-dependent, we warned during the initial parse; otherwise, the 896 // type might not be scalar in some uses of the template. 897 if (!S.ActiveTemplateInstantiations.empty()) 898 return; 899 900 unsigned DiagID = 0; 901 902 switch (Entity.getKind()) { 903 case InitializedEntity::EK_VectorElement: 904 case InitializedEntity::EK_ComplexElement: 905 case InitializedEntity::EK_ArrayElement: 906 case InitializedEntity::EK_Parameter: 907 case InitializedEntity::EK_Parameter_CF_Audited: 908 case InitializedEntity::EK_Result: 909 // Extra braces here are suspicious. 910 DiagID = diag::warn_braces_around_scalar_init; 911 break; 912 913 case InitializedEntity::EK_Member: 914 // Warn on aggregate initialization but not on ctor init list or 915 // default member initializer. 916 if (Entity.getParent()) 917 DiagID = diag::warn_braces_around_scalar_init; 918 break; 919 920 case InitializedEntity::EK_Variable: 921 case InitializedEntity::EK_LambdaCapture: 922 // No warning, might be direct-list-initialization. 923 // FIXME: Should we warn for copy-list-initialization in these cases? 924 break; 925 926 case InitializedEntity::EK_New: 927 case InitializedEntity::EK_Temporary: 928 case InitializedEntity::EK_CompoundLiteralInit: 929 // No warning, braces are part of the syntax of the underlying construct. 930 break; 931 932 case InitializedEntity::EK_RelatedResult: 933 // No warning, we already warned when initializing the result. 934 break; 935 936 case InitializedEntity::EK_Exception: 937 case InitializedEntity::EK_Base: 938 case InitializedEntity::EK_Delegating: 939 case InitializedEntity::EK_BlockElement: 940 llvm_unreachable("unexpected braced scalar init"); 941 } 942 943 if (DiagID) { 944 S.Diag(Braces.getBegin(), DiagID) 945 << Braces 946 << FixItHint::CreateRemoval(Braces.getBegin()) 947 << FixItHint::CreateRemoval(Braces.getEnd()); 948 } 949 } 950 951 /// Check whether the initializer \p IList (that was written with explicit 952 /// braces) can be used to initialize an object of type \p T. 953 /// 954 /// This also fills in \p StructuredList with the fully-braced, desugared 955 /// form of the initialization. 956 void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity, 957 InitListExpr *IList, QualType &T, 958 InitListExpr *StructuredList, 959 bool TopLevelObject) { 960 if (!VerifyOnly) { 961 SyntacticToSemantic[IList] = StructuredList; 962 StructuredList->setSyntacticForm(IList); 963 } 964 965 unsigned Index = 0, StructuredIndex = 0; 966 CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true, 967 Index, StructuredList, StructuredIndex, TopLevelObject); 968 if (!VerifyOnly) { 969 QualType ExprTy = T; 970 if (!ExprTy->isArrayType()) 971 ExprTy = ExprTy.getNonLValueExprType(SemaRef.Context); 972 IList->setType(ExprTy); 973 StructuredList->setType(ExprTy); 974 } 975 if (hadError) 976 return; 977 978 if (Index < IList->getNumInits()) { 979 // We have leftover initializers 980 if (VerifyOnly) { 981 if (SemaRef.getLangOpts().CPlusPlus || 982 (SemaRef.getLangOpts().OpenCL && 983 IList->getType()->isVectorType())) { 984 hadError = true; 985 } 986 return; 987 } 988 989 if (StructuredIndex == 1 && 990 IsStringInit(StructuredList->getInit(0), T, SemaRef.Context) == 991 SIF_None) { 992 unsigned DK = diag::ext_excess_initializers_in_char_array_initializer; 993 if (SemaRef.getLangOpts().CPlusPlus) { 994 DK = diag::err_excess_initializers_in_char_array_initializer; 995 hadError = true; 996 } 997 // Special-case 998 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK) 999 << IList->getInit(Index)->getSourceRange(); 1000 } else if (!T->isIncompleteType()) { 1001 // Don't complain for incomplete types, since we'll get an error 1002 // elsewhere 1003 QualType CurrentObjectType = StructuredList->getType(); 1004 int initKind = 1005 CurrentObjectType->isArrayType()? 0 : 1006 CurrentObjectType->isVectorType()? 1 : 1007 CurrentObjectType->isScalarType()? 2 : 1008 CurrentObjectType->isUnionType()? 3 : 1009 4; 1010 1011 unsigned DK = diag::ext_excess_initializers; 1012 if (SemaRef.getLangOpts().CPlusPlus) { 1013 DK = diag::err_excess_initializers; 1014 hadError = true; 1015 } 1016 if (SemaRef.getLangOpts().OpenCL && initKind == 1) { 1017 DK = diag::err_excess_initializers; 1018 hadError = true; 1019 } 1020 1021 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK) 1022 << initKind << IList->getInit(Index)->getSourceRange(); 1023 } 1024 } 1025 1026 if (!VerifyOnly && T->isScalarType() && 1027 IList->getNumInits() == 1 && !isa<InitListExpr>(IList->getInit(0))) 1028 warnBracedScalarInit(SemaRef, Entity, IList->getSourceRange()); 1029 } 1030 1031 void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity, 1032 InitListExpr *IList, 1033 QualType &DeclType, 1034 bool SubobjectIsDesignatorContext, 1035 unsigned &Index, 1036 InitListExpr *StructuredList, 1037 unsigned &StructuredIndex, 1038 bool TopLevelObject) { 1039 if (DeclType->isAnyComplexType() && SubobjectIsDesignatorContext) { 1040 // Explicitly braced initializer for complex type can be real+imaginary 1041 // parts. 1042 CheckComplexType(Entity, IList, DeclType, Index, 1043 StructuredList, StructuredIndex); 1044 } else if (DeclType->isScalarType()) { 1045 CheckScalarType(Entity, IList, DeclType, Index, 1046 StructuredList, StructuredIndex); 1047 } else if (DeclType->isVectorType()) { 1048 CheckVectorType(Entity, IList, DeclType, Index, 1049 StructuredList, StructuredIndex); 1050 } else if (DeclType->isRecordType()) { 1051 assert(DeclType->isAggregateType() && 1052 "non-aggregate records should be handed in CheckSubElementType"); 1053 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl(); 1054 auto Bases = 1055 CXXRecordDecl::base_class_range(CXXRecordDecl::base_class_iterator(), 1056 CXXRecordDecl::base_class_iterator()); 1057 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) 1058 Bases = CXXRD->bases(); 1059 CheckStructUnionTypes(Entity, IList, DeclType, Bases, RD->field_begin(), 1060 SubobjectIsDesignatorContext, Index, StructuredList, 1061 StructuredIndex, TopLevelObject); 1062 } else if (DeclType->isArrayType()) { 1063 llvm::APSInt Zero( 1064 SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()), 1065 false); 1066 CheckArrayType(Entity, IList, DeclType, Zero, 1067 SubobjectIsDesignatorContext, Index, 1068 StructuredList, StructuredIndex); 1069 } else if (DeclType->isVoidType() || DeclType->isFunctionType()) { 1070 // This type is invalid, issue a diagnostic. 1071 ++Index; 1072 if (!VerifyOnly) 1073 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type) 1074 << DeclType; 1075 hadError = true; 1076 } else if (DeclType->isReferenceType()) { 1077 CheckReferenceType(Entity, IList, DeclType, Index, 1078 StructuredList, StructuredIndex); 1079 } else if (DeclType->isObjCObjectType()) { 1080 if (!VerifyOnly) 1081 SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class) 1082 << DeclType; 1083 hadError = true; 1084 } else { 1085 if (!VerifyOnly) 1086 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type) 1087 << DeclType; 1088 hadError = true; 1089 } 1090 } 1091 1092 void InitListChecker::CheckSubElementType(const InitializedEntity &Entity, 1093 InitListExpr *IList, 1094 QualType ElemType, 1095 unsigned &Index, 1096 InitListExpr *StructuredList, 1097 unsigned &StructuredIndex) { 1098 Expr *expr = IList->getInit(Index); 1099 1100 if (ElemType->isReferenceType()) 1101 return CheckReferenceType(Entity, IList, ElemType, Index, 1102 StructuredList, StructuredIndex); 1103 1104 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) { 1105 if (SubInitList->getNumInits() == 1 && 1106 IsStringInit(SubInitList->getInit(0), ElemType, SemaRef.Context) == 1107 SIF_None) { 1108 expr = SubInitList->getInit(0); 1109 } else if (!SemaRef.getLangOpts().CPlusPlus) { 1110 InitListExpr *InnerStructuredList 1111 = getStructuredSubobjectInit(IList, Index, ElemType, 1112 StructuredList, StructuredIndex, 1113 SubInitList->getSourceRange(), true); 1114 CheckExplicitInitList(Entity, SubInitList, ElemType, 1115 InnerStructuredList); 1116 1117 if (!hadError && !VerifyOnly) { 1118 bool RequiresSecondPass = false; 1119 FillInEmptyInitializations(Entity, InnerStructuredList, 1120 RequiresSecondPass); 1121 if (RequiresSecondPass && !hadError) 1122 FillInEmptyInitializations(Entity, InnerStructuredList, 1123 RequiresSecondPass); 1124 } 1125 ++StructuredIndex; 1126 ++Index; 1127 return; 1128 } 1129 // C++ initialization is handled later. 1130 } else if (isa<ImplicitValueInitExpr>(expr)) { 1131 // This happens during template instantiation when we see an InitListExpr 1132 // that we've already checked once. 1133 assert(SemaRef.Context.hasSameType(expr->getType(), ElemType) && 1134 "found implicit initialization for the wrong type"); 1135 if (!VerifyOnly) 1136 UpdateStructuredListElement(StructuredList, StructuredIndex, expr); 1137 ++Index; 1138 return; 1139 } 1140 1141 if (SemaRef.getLangOpts().CPlusPlus) { 1142 // C++ [dcl.init.aggr]p2: 1143 // Each member is copy-initialized from the corresponding 1144 // initializer-clause. 1145 1146 // FIXME: Better EqualLoc? 1147 InitializationKind Kind = 1148 InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation()); 1149 InitializationSequence Seq(SemaRef, Entity, Kind, expr, 1150 /*TopLevelOfInitList*/ true); 1151 1152 // C++14 [dcl.init.aggr]p13: 1153 // If the assignment-expression can initialize a member, the member is 1154 // initialized. Otherwise [...] brace elision is assumed 1155 // 1156 // Brace elision is never performed if the element is not an 1157 // assignment-expression. 1158 if (Seq || isa<InitListExpr>(expr)) { 1159 if (!VerifyOnly) { 1160 ExprResult Result = 1161 Seq.Perform(SemaRef, Entity, Kind, expr); 1162 if (Result.isInvalid()) 1163 hadError = true; 1164 1165 UpdateStructuredListElement(StructuredList, StructuredIndex, 1166 Result.getAs<Expr>()); 1167 } else if (!Seq) 1168 hadError = true; 1169 ++Index; 1170 return; 1171 } 1172 1173 // Fall through for subaggregate initialization 1174 } else if (ElemType->isScalarType() || ElemType->isAtomicType()) { 1175 // FIXME: Need to handle atomic aggregate types with implicit init lists. 1176 return CheckScalarType(Entity, IList, ElemType, Index, 1177 StructuredList, StructuredIndex); 1178 } else if (const ArrayType *arrayType = 1179 SemaRef.Context.getAsArrayType(ElemType)) { 1180 // arrayType can be incomplete if we're initializing a flexible 1181 // array member. There's nothing we can do with the completed 1182 // type here, though. 1183 1184 if (IsStringInit(expr, arrayType, SemaRef.Context) == SIF_None) { 1185 if (!VerifyOnly) { 1186 CheckStringInit(expr, ElemType, arrayType, SemaRef); 1187 UpdateStructuredListElement(StructuredList, StructuredIndex, expr); 1188 } 1189 ++Index; 1190 return; 1191 } 1192 1193 // Fall through for subaggregate initialization. 1194 1195 } else { 1196 assert((ElemType->isRecordType() || ElemType->isVectorType() || 1197 ElemType->isClkEventT()) && "Unexpected type"); 1198 1199 // C99 6.7.8p13: 1200 // 1201 // The initializer for a structure or union object that has 1202 // automatic storage duration shall be either an initializer 1203 // list as described below, or a single expression that has 1204 // compatible structure or union type. In the latter case, the 1205 // initial value of the object, including unnamed members, is 1206 // that of the expression. 1207 ExprResult ExprRes = expr; 1208 if (SemaRef.CheckSingleAssignmentConstraints( 1209 ElemType, ExprRes, !VerifyOnly) != Sema::Incompatible) { 1210 if (ExprRes.isInvalid()) 1211 hadError = true; 1212 else { 1213 ExprRes = SemaRef.DefaultFunctionArrayLvalueConversion(ExprRes.get()); 1214 if (ExprRes.isInvalid()) 1215 hadError = true; 1216 } 1217 UpdateStructuredListElement(StructuredList, StructuredIndex, 1218 ExprRes.getAs<Expr>()); 1219 ++Index; 1220 return; 1221 } 1222 ExprRes.get(); 1223 // Fall through for subaggregate initialization 1224 } 1225 1226 // C++ [dcl.init.aggr]p12: 1227 // 1228 // [...] Otherwise, if the member is itself a non-empty 1229 // subaggregate, brace elision is assumed and the initializer is 1230 // considered for the initialization of the first member of 1231 // the subaggregate. 1232 if (!SemaRef.getLangOpts().OpenCL && 1233 (ElemType->isAggregateType() || ElemType->isVectorType())) { 1234 CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList, 1235 StructuredIndex); 1236 ++StructuredIndex; 1237 } else { 1238 if (!VerifyOnly) { 1239 // We cannot initialize this element, so let 1240 // PerformCopyInitialization produce the appropriate diagnostic. 1241 SemaRef.PerformCopyInitialization(Entity, SourceLocation(), expr, 1242 /*TopLevelOfInitList=*/true); 1243 } 1244 hadError = true; 1245 ++Index; 1246 ++StructuredIndex; 1247 } 1248 } 1249 1250 void InitListChecker::CheckComplexType(const InitializedEntity &Entity, 1251 InitListExpr *IList, QualType DeclType, 1252 unsigned &Index, 1253 InitListExpr *StructuredList, 1254 unsigned &StructuredIndex) { 1255 assert(Index == 0 && "Index in explicit init list must be zero"); 1256 1257 // As an extension, clang supports complex initializers, which initialize 1258 // a complex number component-wise. When an explicit initializer list for 1259 // a complex number contains two two initializers, this extension kicks in: 1260 // it exepcts the initializer list to contain two elements convertible to 1261 // the element type of the complex type. The first element initializes 1262 // the real part, and the second element intitializes the imaginary part. 1263 1264 if (IList->getNumInits() != 2) 1265 return CheckScalarType(Entity, IList, DeclType, Index, StructuredList, 1266 StructuredIndex); 1267 1268 // This is an extension in C. (The builtin _Complex type does not exist 1269 // in the C++ standard.) 1270 if (!SemaRef.getLangOpts().CPlusPlus && !VerifyOnly) 1271 SemaRef.Diag(IList->getLocStart(), diag::ext_complex_component_init) 1272 << IList->getSourceRange(); 1273 1274 // Initialize the complex number. 1275 QualType elementType = DeclType->getAs<ComplexType>()->getElementType(); 1276 InitializedEntity ElementEntity = 1277 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity); 1278 1279 for (unsigned i = 0; i < 2; ++i) { 1280 ElementEntity.setElementIndex(Index); 1281 CheckSubElementType(ElementEntity, IList, elementType, Index, 1282 StructuredList, StructuredIndex); 1283 } 1284 } 1285 1286 void InitListChecker::CheckScalarType(const InitializedEntity &Entity, 1287 InitListExpr *IList, QualType DeclType, 1288 unsigned &Index, 1289 InitListExpr *StructuredList, 1290 unsigned &StructuredIndex) { 1291 if (Index >= IList->getNumInits()) { 1292 if (!VerifyOnly) 1293 SemaRef.Diag(IList->getLocStart(), 1294 SemaRef.getLangOpts().CPlusPlus11 ? 1295 diag::warn_cxx98_compat_empty_scalar_initializer : 1296 diag::err_empty_scalar_initializer) 1297 << IList->getSourceRange(); 1298 hadError = !SemaRef.getLangOpts().CPlusPlus11; 1299 ++Index; 1300 ++StructuredIndex; 1301 return; 1302 } 1303 1304 Expr *expr = IList->getInit(Index); 1305 if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) { 1306 // FIXME: This is invalid, and accepting it causes overload resolution 1307 // to pick the wrong overload in some corner cases. 1308 if (!VerifyOnly) 1309 SemaRef.Diag(SubIList->getLocStart(), 1310 diag::ext_many_braces_around_scalar_init) 1311 << SubIList->getSourceRange(); 1312 1313 CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList, 1314 StructuredIndex); 1315 return; 1316 } else if (isa<DesignatedInitExpr>(expr)) { 1317 if (!VerifyOnly) 1318 SemaRef.Diag(expr->getLocStart(), 1319 diag::err_designator_for_scalar_init) 1320 << DeclType << expr->getSourceRange(); 1321 hadError = true; 1322 ++Index; 1323 ++StructuredIndex; 1324 return; 1325 } 1326 1327 if (VerifyOnly) { 1328 if (!SemaRef.CanPerformCopyInitialization(Entity,expr)) 1329 hadError = true; 1330 ++Index; 1331 return; 1332 } 1333 1334 ExprResult Result = 1335 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), expr, 1336 /*TopLevelOfInitList=*/true); 1337 1338 Expr *ResultExpr = nullptr; 1339 1340 if (Result.isInvalid()) 1341 hadError = true; // types weren't compatible. 1342 else { 1343 ResultExpr = Result.getAs<Expr>(); 1344 1345 if (ResultExpr != expr) { 1346 // The type was promoted, update initializer list. 1347 IList->setInit(Index, ResultExpr); 1348 } 1349 } 1350 if (hadError) 1351 ++StructuredIndex; 1352 else 1353 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr); 1354 ++Index; 1355 } 1356 1357 void InitListChecker::CheckReferenceType(const InitializedEntity &Entity, 1358 InitListExpr *IList, QualType DeclType, 1359 unsigned &Index, 1360 InitListExpr *StructuredList, 1361 unsigned &StructuredIndex) { 1362 if (Index >= IList->getNumInits()) { 1363 // FIXME: It would be wonderful if we could point at the actual member. In 1364 // general, it would be useful to pass location information down the stack, 1365 // so that we know the location (or decl) of the "current object" being 1366 // initialized. 1367 if (!VerifyOnly) 1368 SemaRef.Diag(IList->getLocStart(), 1369 diag::err_init_reference_member_uninitialized) 1370 << DeclType 1371 << IList->getSourceRange(); 1372 hadError = true; 1373 ++Index; 1374 ++StructuredIndex; 1375 return; 1376 } 1377 1378 Expr *expr = IList->getInit(Index); 1379 if (isa<InitListExpr>(expr) && !SemaRef.getLangOpts().CPlusPlus11) { 1380 if (!VerifyOnly) 1381 SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list) 1382 << DeclType << IList->getSourceRange(); 1383 hadError = true; 1384 ++Index; 1385 ++StructuredIndex; 1386 return; 1387 } 1388 1389 if (VerifyOnly) { 1390 if (!SemaRef.CanPerformCopyInitialization(Entity,expr)) 1391 hadError = true; 1392 ++Index; 1393 return; 1394 } 1395 1396 ExprResult Result = 1397 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), expr, 1398 /*TopLevelOfInitList=*/true); 1399 1400 if (Result.isInvalid()) 1401 hadError = true; 1402 1403 expr = Result.getAs<Expr>(); 1404 IList->setInit(Index, expr); 1405 1406 if (hadError) 1407 ++StructuredIndex; 1408 else 1409 UpdateStructuredListElement(StructuredList, StructuredIndex, expr); 1410 ++Index; 1411 } 1412 1413 void InitListChecker::CheckVectorType(const InitializedEntity &Entity, 1414 InitListExpr *IList, QualType DeclType, 1415 unsigned &Index, 1416 InitListExpr *StructuredList, 1417 unsigned &StructuredIndex) { 1418 const VectorType *VT = DeclType->getAs<VectorType>(); 1419 unsigned maxElements = VT->getNumElements(); 1420 unsigned numEltsInit = 0; 1421 QualType elementType = VT->getElementType(); 1422 1423 if (Index >= IList->getNumInits()) { 1424 // Make sure the element type can be value-initialized. 1425 if (VerifyOnly) 1426 CheckEmptyInitializable( 1427 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity), 1428 IList->getLocEnd()); 1429 return; 1430 } 1431 1432 if (!SemaRef.getLangOpts().OpenCL) { 1433 // If the initializing element is a vector, try to copy-initialize 1434 // instead of breaking it apart (which is doomed to failure anyway). 1435 Expr *Init = IList->getInit(Index); 1436 if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) { 1437 if (VerifyOnly) { 1438 if (!SemaRef.CanPerformCopyInitialization(Entity, Init)) 1439 hadError = true; 1440 ++Index; 1441 return; 1442 } 1443 1444 ExprResult Result = 1445 SemaRef.PerformCopyInitialization(Entity, Init->getLocStart(), Init, 1446 /*TopLevelOfInitList=*/true); 1447 1448 Expr *ResultExpr = nullptr; 1449 if (Result.isInvalid()) 1450 hadError = true; // types weren't compatible. 1451 else { 1452 ResultExpr = Result.getAs<Expr>(); 1453 1454 if (ResultExpr != Init) { 1455 // The type was promoted, update initializer list. 1456 IList->setInit(Index, ResultExpr); 1457 } 1458 } 1459 if (hadError) 1460 ++StructuredIndex; 1461 else 1462 UpdateStructuredListElement(StructuredList, StructuredIndex, 1463 ResultExpr); 1464 ++Index; 1465 return; 1466 } 1467 1468 InitializedEntity ElementEntity = 1469 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity); 1470 1471 for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) { 1472 // Don't attempt to go past the end of the init list 1473 if (Index >= IList->getNumInits()) { 1474 if (VerifyOnly) 1475 CheckEmptyInitializable(ElementEntity, IList->getLocEnd()); 1476 break; 1477 } 1478 1479 ElementEntity.setElementIndex(Index); 1480 CheckSubElementType(ElementEntity, IList, elementType, Index, 1481 StructuredList, StructuredIndex); 1482 } 1483 1484 if (VerifyOnly) 1485 return; 1486 1487 bool isBigEndian = SemaRef.Context.getTargetInfo().isBigEndian(); 1488 const VectorType *T = Entity.getType()->getAs<VectorType>(); 1489 if (isBigEndian && (T->getVectorKind() == VectorType::NeonVector || 1490 T->getVectorKind() == VectorType::NeonPolyVector)) { 1491 // The ability to use vector initializer lists is a GNU vector extension 1492 // and is unrelated to the NEON intrinsics in arm_neon.h. On little 1493 // endian machines it works fine, however on big endian machines it 1494 // exhibits surprising behaviour: 1495 // 1496 // uint32x2_t x = {42, 64}; 1497 // return vget_lane_u32(x, 0); // Will return 64. 1498 // 1499 // Because of this, explicitly call out that it is non-portable. 1500 // 1501 SemaRef.Diag(IList->getLocStart(), 1502 diag::warn_neon_vector_initializer_non_portable); 1503 1504 const char *typeCode; 1505 unsigned typeSize = SemaRef.Context.getTypeSize(elementType); 1506 1507 if (elementType->isFloatingType()) 1508 typeCode = "f"; 1509 else if (elementType->isSignedIntegerType()) 1510 typeCode = "s"; 1511 else if (elementType->isUnsignedIntegerType()) 1512 typeCode = "u"; 1513 else 1514 llvm_unreachable("Invalid element type!"); 1515 1516 SemaRef.Diag(IList->getLocStart(), 1517 SemaRef.Context.getTypeSize(VT) > 64 ? 1518 diag::note_neon_vector_initializer_non_portable_q : 1519 diag::note_neon_vector_initializer_non_portable) 1520 << typeCode << typeSize; 1521 } 1522 1523 return; 1524 } 1525 1526 InitializedEntity ElementEntity = 1527 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity); 1528 1529 // OpenCL initializers allows vectors to be constructed from vectors. 1530 for (unsigned i = 0; i < maxElements; ++i) { 1531 // Don't attempt to go past the end of the init list 1532 if (Index >= IList->getNumInits()) 1533 break; 1534 1535 ElementEntity.setElementIndex(Index); 1536 1537 QualType IType = IList->getInit(Index)->getType(); 1538 if (!IType->isVectorType()) { 1539 CheckSubElementType(ElementEntity, IList, elementType, Index, 1540 StructuredList, StructuredIndex); 1541 ++numEltsInit; 1542 } else { 1543 QualType VecType; 1544 const VectorType *IVT = IType->getAs<VectorType>(); 1545 unsigned numIElts = IVT->getNumElements(); 1546 1547 if (IType->isExtVectorType()) 1548 VecType = SemaRef.Context.getExtVectorType(elementType, numIElts); 1549 else 1550 VecType = SemaRef.Context.getVectorType(elementType, numIElts, 1551 IVT->getVectorKind()); 1552 CheckSubElementType(ElementEntity, IList, VecType, Index, 1553 StructuredList, StructuredIndex); 1554 numEltsInit += numIElts; 1555 } 1556 } 1557 1558 // OpenCL requires all elements to be initialized. 1559 if (numEltsInit != maxElements) { 1560 if (!VerifyOnly) 1561 SemaRef.Diag(IList->getLocStart(), 1562 diag::err_vector_incorrect_num_initializers) 1563 << (numEltsInit < maxElements) << maxElements << numEltsInit; 1564 hadError = true; 1565 } 1566 } 1567 1568 void InitListChecker::CheckArrayType(const InitializedEntity &Entity, 1569 InitListExpr *IList, QualType &DeclType, 1570 llvm::APSInt elementIndex, 1571 bool SubobjectIsDesignatorContext, 1572 unsigned &Index, 1573 InitListExpr *StructuredList, 1574 unsigned &StructuredIndex) { 1575 const ArrayType *arrayType = SemaRef.Context.getAsArrayType(DeclType); 1576 1577 // Check for the special-case of initializing an array with a string. 1578 if (Index < IList->getNumInits()) { 1579 if (IsStringInit(IList->getInit(Index), arrayType, SemaRef.Context) == 1580 SIF_None) { 1581 // We place the string literal directly into the resulting 1582 // initializer list. This is the only place where the structure 1583 // of the structured initializer list doesn't match exactly, 1584 // because doing so would involve allocating one character 1585 // constant for each string. 1586 if (!VerifyOnly) { 1587 CheckStringInit(IList->getInit(Index), DeclType, arrayType, SemaRef); 1588 UpdateStructuredListElement(StructuredList, StructuredIndex, 1589 IList->getInit(Index)); 1590 StructuredList->resizeInits(SemaRef.Context, StructuredIndex); 1591 } 1592 ++Index; 1593 return; 1594 } 1595 } 1596 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(arrayType)) { 1597 // Check for VLAs; in standard C it would be possible to check this 1598 // earlier, but I don't know where clang accepts VLAs (gcc accepts 1599 // them in all sorts of strange places). 1600 if (!VerifyOnly) 1601 SemaRef.Diag(VAT->getSizeExpr()->getLocStart(), 1602 diag::err_variable_object_no_init) 1603 << VAT->getSizeExpr()->getSourceRange(); 1604 hadError = true; 1605 ++Index; 1606 ++StructuredIndex; 1607 return; 1608 } 1609 1610 // We might know the maximum number of elements in advance. 1611 llvm::APSInt maxElements(elementIndex.getBitWidth(), 1612 elementIndex.isUnsigned()); 1613 bool maxElementsKnown = false; 1614 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(arrayType)) { 1615 maxElements = CAT->getSize(); 1616 elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth()); 1617 elementIndex.setIsUnsigned(maxElements.isUnsigned()); 1618 maxElementsKnown = true; 1619 } 1620 1621 QualType elementType = arrayType->getElementType(); 1622 while (Index < IList->getNumInits()) { 1623 Expr *Init = IList->getInit(Index); 1624 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) { 1625 // If we're not the subobject that matches up with the '{' for 1626 // the designator, we shouldn't be handling the 1627 // designator. Return immediately. 1628 if (!SubobjectIsDesignatorContext) 1629 return; 1630 1631 // Handle this designated initializer. elementIndex will be 1632 // updated to be the next array element we'll initialize. 1633 if (CheckDesignatedInitializer(Entity, IList, DIE, 0, 1634 DeclType, nullptr, &elementIndex, Index, 1635 StructuredList, StructuredIndex, true, 1636 false)) { 1637 hadError = true; 1638 continue; 1639 } 1640 1641 if (elementIndex.getBitWidth() > maxElements.getBitWidth()) 1642 maxElements = maxElements.extend(elementIndex.getBitWidth()); 1643 else if (elementIndex.getBitWidth() < maxElements.getBitWidth()) 1644 elementIndex = elementIndex.extend(maxElements.getBitWidth()); 1645 elementIndex.setIsUnsigned(maxElements.isUnsigned()); 1646 1647 // If the array is of incomplete type, keep track of the number of 1648 // elements in the initializer. 1649 if (!maxElementsKnown && elementIndex > maxElements) 1650 maxElements = elementIndex; 1651 1652 continue; 1653 } 1654 1655 // If we know the maximum number of elements, and we've already 1656 // hit it, stop consuming elements in the initializer list. 1657 if (maxElementsKnown && elementIndex == maxElements) 1658 break; 1659 1660 InitializedEntity ElementEntity = 1661 InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex, 1662 Entity); 1663 // Check this element. 1664 CheckSubElementType(ElementEntity, IList, elementType, Index, 1665 StructuredList, StructuredIndex); 1666 ++elementIndex; 1667 1668 // If the array is of incomplete type, keep track of the number of 1669 // elements in the initializer. 1670 if (!maxElementsKnown && elementIndex > maxElements) 1671 maxElements = elementIndex; 1672 } 1673 if (!hadError && DeclType->isIncompleteArrayType() && !VerifyOnly) { 1674 // If this is an incomplete array type, the actual type needs to 1675 // be calculated here. 1676 llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned()); 1677 if (maxElements == Zero) { 1678 // Sizing an array implicitly to zero is not allowed by ISO C, 1679 // but is supported by GNU. 1680 SemaRef.Diag(IList->getLocStart(), 1681 diag::ext_typecheck_zero_array_size); 1682 } 1683 1684 DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements, 1685 ArrayType::Normal, 0); 1686 } 1687 if (!hadError && VerifyOnly) { 1688 // Check if there are any members of the array that get value-initialized. 1689 // If so, check if doing that is possible. 1690 // FIXME: This needs to detect holes left by designated initializers too. 1691 if (maxElementsKnown && elementIndex < maxElements) 1692 CheckEmptyInitializable(InitializedEntity::InitializeElement( 1693 SemaRef.Context, 0, Entity), 1694 IList->getLocEnd()); 1695 } 1696 } 1697 1698 bool InitListChecker::CheckFlexibleArrayInit(const InitializedEntity &Entity, 1699 Expr *InitExpr, 1700 FieldDecl *Field, 1701 bool TopLevelObject) { 1702 // Handle GNU flexible array initializers. 1703 unsigned FlexArrayDiag; 1704 if (isa<InitListExpr>(InitExpr) && 1705 cast<InitListExpr>(InitExpr)->getNumInits() == 0) { 1706 // Empty flexible array init always allowed as an extension 1707 FlexArrayDiag = diag::ext_flexible_array_init; 1708 } else if (SemaRef.getLangOpts().CPlusPlus) { 1709 // Disallow flexible array init in C++; it is not required for gcc 1710 // compatibility, and it needs work to IRGen correctly in general. 1711 FlexArrayDiag = diag::err_flexible_array_init; 1712 } else if (!TopLevelObject) { 1713 // Disallow flexible array init on non-top-level object 1714 FlexArrayDiag = diag::err_flexible_array_init; 1715 } else if (Entity.getKind() != InitializedEntity::EK_Variable) { 1716 // Disallow flexible array init on anything which is not a variable. 1717 FlexArrayDiag = diag::err_flexible_array_init; 1718 } else if (cast<VarDecl>(Entity.getDecl())->hasLocalStorage()) { 1719 // Disallow flexible array init on local variables. 1720 FlexArrayDiag = diag::err_flexible_array_init; 1721 } else { 1722 // Allow other cases. 1723 FlexArrayDiag = diag::ext_flexible_array_init; 1724 } 1725 1726 if (!VerifyOnly) { 1727 SemaRef.Diag(InitExpr->getLocStart(), 1728 FlexArrayDiag) 1729 << InitExpr->getLocStart(); 1730 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1731 << Field; 1732 } 1733 1734 return FlexArrayDiag != diag::ext_flexible_array_init; 1735 } 1736 1737 void InitListChecker::CheckStructUnionTypes( 1738 const InitializedEntity &Entity, InitListExpr *IList, QualType DeclType, 1739 CXXRecordDecl::base_class_range Bases, RecordDecl::field_iterator Field, 1740 bool SubobjectIsDesignatorContext, unsigned &Index, 1741 InitListExpr *StructuredList, unsigned &StructuredIndex, 1742 bool TopLevelObject) { 1743 RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl(); 1744 1745 // If the record is invalid, some of it's members are invalid. To avoid 1746 // confusion, we forgo checking the intializer for the entire record. 1747 if (structDecl->isInvalidDecl()) { 1748 // Assume it was supposed to consume a single initializer. 1749 ++Index; 1750 hadError = true; 1751 return; 1752 } 1753 1754 if (DeclType->isUnionType() && IList->getNumInits() == 0) { 1755 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl(); 1756 1757 // If there's a default initializer, use it. 1758 if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->hasInClassInitializer()) { 1759 if (VerifyOnly) 1760 return; 1761 for (RecordDecl::field_iterator FieldEnd = RD->field_end(); 1762 Field != FieldEnd; ++Field) { 1763 if (Field->hasInClassInitializer()) { 1764 StructuredList->setInitializedFieldInUnion(*Field); 1765 // FIXME: Actually build a CXXDefaultInitExpr? 1766 return; 1767 } 1768 } 1769 } 1770 1771 // Value-initialize the first member of the union that isn't an unnamed 1772 // bitfield. 1773 for (RecordDecl::field_iterator FieldEnd = RD->field_end(); 1774 Field != FieldEnd; ++Field) { 1775 if (!Field->isUnnamedBitfield()) { 1776 if (VerifyOnly) 1777 CheckEmptyInitializable( 1778 InitializedEntity::InitializeMember(*Field, &Entity), 1779 IList->getLocEnd()); 1780 else 1781 StructuredList->setInitializedFieldInUnion(*Field); 1782 break; 1783 } 1784 } 1785 return; 1786 } 1787 1788 bool InitializedSomething = false; 1789 1790 // If we have any base classes, they are initialized prior to the fields. 1791 for (auto &Base : Bases) { 1792 Expr *Init = Index < IList->getNumInits() ? IList->getInit(Index) : nullptr; 1793 SourceLocation InitLoc = Init ? Init->getLocStart() : IList->getLocEnd(); 1794 1795 // Designated inits always initialize fields, so if we see one, all 1796 // remaining base classes have no explicit initializer. 1797 if (Init && isa<DesignatedInitExpr>(Init)) 1798 Init = nullptr; 1799 1800 InitializedEntity BaseEntity = InitializedEntity::InitializeBase( 1801 SemaRef.Context, &Base, false, &Entity); 1802 if (Init) { 1803 CheckSubElementType(BaseEntity, IList, Base.getType(), Index, 1804 StructuredList, StructuredIndex); 1805 InitializedSomething = true; 1806 } else if (VerifyOnly) { 1807 CheckEmptyInitializable(BaseEntity, InitLoc); 1808 } 1809 } 1810 1811 // If structDecl is a forward declaration, this loop won't do 1812 // anything except look at designated initializers; That's okay, 1813 // because an error should get printed out elsewhere. It might be 1814 // worthwhile to skip over the rest of the initializer, though. 1815 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl(); 1816 RecordDecl::field_iterator FieldEnd = RD->field_end(); 1817 bool CheckForMissingFields = true; 1818 while (Index < IList->getNumInits()) { 1819 Expr *Init = IList->getInit(Index); 1820 1821 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) { 1822 // If we're not the subobject that matches up with the '{' for 1823 // the designator, we shouldn't be handling the 1824 // designator. Return immediately. 1825 if (!SubobjectIsDesignatorContext) 1826 return; 1827 1828 // Handle this designated initializer. Field will be updated to 1829 // the next field that we'll be initializing. 1830 if (CheckDesignatedInitializer(Entity, IList, DIE, 0, 1831 DeclType, &Field, nullptr, Index, 1832 StructuredList, StructuredIndex, 1833 true, TopLevelObject)) 1834 hadError = true; 1835 1836 InitializedSomething = true; 1837 1838 // Disable check for missing fields when designators are used. 1839 // This matches gcc behaviour. 1840 CheckForMissingFields = false; 1841 continue; 1842 } 1843 1844 if (Field == FieldEnd) { 1845 // We've run out of fields. We're done. 1846 break; 1847 } 1848 1849 // We've already initialized a member of a union. We're done. 1850 if (InitializedSomething && DeclType->isUnionType()) 1851 break; 1852 1853 // If we've hit the flexible array member at the end, we're done. 1854 if (Field->getType()->isIncompleteArrayType()) 1855 break; 1856 1857 if (Field->isUnnamedBitfield()) { 1858 // Don't initialize unnamed bitfields, e.g. "int : 20;" 1859 ++Field; 1860 continue; 1861 } 1862 1863 // Make sure we can use this declaration. 1864 bool InvalidUse; 1865 if (VerifyOnly) 1866 InvalidUse = !SemaRef.CanUseDecl(*Field, TreatUnavailableAsInvalid); 1867 else 1868 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, 1869 IList->getInit(Index)->getLocStart()); 1870 if (InvalidUse) { 1871 ++Index; 1872 ++Field; 1873 hadError = true; 1874 continue; 1875 } 1876 1877 InitializedEntity MemberEntity = 1878 InitializedEntity::InitializeMember(*Field, &Entity); 1879 CheckSubElementType(MemberEntity, IList, Field->getType(), Index, 1880 StructuredList, StructuredIndex); 1881 InitializedSomething = true; 1882 1883 if (DeclType->isUnionType() && !VerifyOnly) { 1884 // Initialize the first field within the union. 1885 StructuredList->setInitializedFieldInUnion(*Field); 1886 } 1887 1888 ++Field; 1889 } 1890 1891 // Emit warnings for missing struct field initializers. 1892 if (!VerifyOnly && InitializedSomething && CheckForMissingFields && 1893 Field != FieldEnd && !Field->getType()->isIncompleteArrayType() && 1894 !DeclType->isUnionType()) { 1895 // It is possible we have one or more unnamed bitfields remaining. 1896 // Find first (if any) named field and emit warning. 1897 for (RecordDecl::field_iterator it = Field, end = RD->field_end(); 1898 it != end; ++it) { 1899 if (!it->isUnnamedBitfield() && !it->hasInClassInitializer()) { 1900 SemaRef.Diag(IList->getSourceRange().getEnd(), 1901 diag::warn_missing_field_initializers) << *it; 1902 break; 1903 } 1904 } 1905 } 1906 1907 // Check that any remaining fields can be value-initialized. 1908 if (VerifyOnly && Field != FieldEnd && !DeclType->isUnionType() && 1909 !Field->getType()->isIncompleteArrayType()) { 1910 // FIXME: Should check for holes left by designated initializers too. 1911 for (; Field != FieldEnd && !hadError; ++Field) { 1912 if (!Field->isUnnamedBitfield() && !Field->hasInClassInitializer()) 1913 CheckEmptyInitializable( 1914 InitializedEntity::InitializeMember(*Field, &Entity), 1915 IList->getLocEnd()); 1916 } 1917 } 1918 1919 if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() || 1920 Index >= IList->getNumInits()) 1921 return; 1922 1923 if (CheckFlexibleArrayInit(Entity, IList->getInit(Index), *Field, 1924 TopLevelObject)) { 1925 hadError = true; 1926 ++Index; 1927 return; 1928 } 1929 1930 InitializedEntity MemberEntity = 1931 InitializedEntity::InitializeMember(*Field, &Entity); 1932 1933 if (isa<InitListExpr>(IList->getInit(Index))) 1934 CheckSubElementType(MemberEntity, IList, Field->getType(), Index, 1935 StructuredList, StructuredIndex); 1936 else 1937 CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index, 1938 StructuredList, StructuredIndex); 1939 } 1940 1941 /// \brief Expand a field designator that refers to a member of an 1942 /// anonymous struct or union into a series of field designators that 1943 /// refers to the field within the appropriate subobject. 1944 /// 1945 static void ExpandAnonymousFieldDesignator(Sema &SemaRef, 1946 DesignatedInitExpr *DIE, 1947 unsigned DesigIdx, 1948 IndirectFieldDecl *IndirectField) { 1949 typedef DesignatedInitExpr::Designator Designator; 1950 1951 // Build the replacement designators. 1952 SmallVector<Designator, 4> Replacements; 1953 for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(), 1954 PE = IndirectField->chain_end(); PI != PE; ++PI) { 1955 if (PI + 1 == PE) 1956 Replacements.push_back(Designator((IdentifierInfo *)nullptr, 1957 DIE->getDesignator(DesigIdx)->getDotLoc(), 1958 DIE->getDesignator(DesigIdx)->getFieldLoc())); 1959 else 1960 Replacements.push_back(Designator((IdentifierInfo *)nullptr, 1961 SourceLocation(), SourceLocation())); 1962 assert(isa<FieldDecl>(*PI)); 1963 Replacements.back().setField(cast<FieldDecl>(*PI)); 1964 } 1965 1966 // Expand the current designator into the set of replacement 1967 // designators, so we have a full subobject path down to where the 1968 // member of the anonymous struct/union is actually stored. 1969 DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0], 1970 &Replacements[0] + Replacements.size()); 1971 } 1972 1973 static DesignatedInitExpr *CloneDesignatedInitExpr(Sema &SemaRef, 1974 DesignatedInitExpr *DIE) { 1975 unsigned NumIndexExprs = DIE->getNumSubExprs() - 1; 1976 SmallVector<Expr*, 4> IndexExprs(NumIndexExprs); 1977 for (unsigned I = 0; I < NumIndexExprs; ++I) 1978 IndexExprs[I] = DIE->getSubExpr(I + 1); 1979 return DesignatedInitExpr::Create(SemaRef.Context, DIE->designators(), 1980 IndexExprs, 1981 DIE->getEqualOrColonLoc(), 1982 DIE->usesGNUSyntax(), DIE->getInit()); 1983 } 1984 1985 namespace { 1986 1987 // Callback to only accept typo corrections that are for field members of 1988 // the given struct or union. 1989 class FieldInitializerValidatorCCC : public CorrectionCandidateCallback { 1990 public: 1991 explicit FieldInitializerValidatorCCC(RecordDecl *RD) 1992 : Record(RD) {} 1993 1994 bool ValidateCandidate(const TypoCorrection &candidate) override { 1995 FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>(); 1996 return FD && FD->getDeclContext()->getRedeclContext()->Equals(Record); 1997 } 1998 1999 private: 2000 RecordDecl *Record; 2001 }; 2002 2003 } // end anonymous namespace 2004 2005 /// @brief Check the well-formedness of a C99 designated initializer. 2006 /// 2007 /// Determines whether the designated initializer @p DIE, which 2008 /// resides at the given @p Index within the initializer list @p 2009 /// IList, is well-formed for a current object of type @p DeclType 2010 /// (C99 6.7.8). The actual subobject that this designator refers to 2011 /// within the current subobject is returned in either 2012 /// @p NextField or @p NextElementIndex (whichever is appropriate). 2013 /// 2014 /// @param IList The initializer list in which this designated 2015 /// initializer occurs. 2016 /// 2017 /// @param DIE The designated initializer expression. 2018 /// 2019 /// @param DesigIdx The index of the current designator. 2020 /// 2021 /// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17), 2022 /// into which the designation in @p DIE should refer. 2023 /// 2024 /// @param NextField If non-NULL and the first designator in @p DIE is 2025 /// a field, this will be set to the field declaration corresponding 2026 /// to the field named by the designator. 2027 /// 2028 /// @param NextElementIndex If non-NULL and the first designator in @p 2029 /// DIE is an array designator or GNU array-range designator, this 2030 /// will be set to the last index initialized by this designator. 2031 /// 2032 /// @param Index Index into @p IList where the designated initializer 2033 /// @p DIE occurs. 2034 /// 2035 /// @param StructuredList The initializer list expression that 2036 /// describes all of the subobject initializers in the order they'll 2037 /// actually be initialized. 2038 /// 2039 /// @returns true if there was an error, false otherwise. 2040 bool 2041 InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity, 2042 InitListExpr *IList, 2043 DesignatedInitExpr *DIE, 2044 unsigned DesigIdx, 2045 QualType &CurrentObjectType, 2046 RecordDecl::field_iterator *NextField, 2047 llvm::APSInt *NextElementIndex, 2048 unsigned &Index, 2049 InitListExpr *StructuredList, 2050 unsigned &StructuredIndex, 2051 bool FinishSubobjectInit, 2052 bool TopLevelObject) { 2053 if (DesigIdx == DIE->size()) { 2054 // Check the actual initialization for the designated object type. 2055 bool prevHadError = hadError; 2056 2057 // Temporarily remove the designator expression from the 2058 // initializer list that the child calls see, so that we don't try 2059 // to re-process the designator. 2060 unsigned OldIndex = Index; 2061 IList->setInit(OldIndex, DIE->getInit()); 2062 2063 CheckSubElementType(Entity, IList, CurrentObjectType, Index, 2064 StructuredList, StructuredIndex); 2065 2066 // Restore the designated initializer expression in the syntactic 2067 // form of the initializer list. 2068 if (IList->getInit(OldIndex) != DIE->getInit()) 2069 DIE->setInit(IList->getInit(OldIndex)); 2070 IList->setInit(OldIndex, DIE); 2071 2072 return hadError && !prevHadError; 2073 } 2074 2075 DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx); 2076 bool IsFirstDesignator = (DesigIdx == 0); 2077 if (!VerifyOnly) { 2078 assert((IsFirstDesignator || StructuredList) && 2079 "Need a non-designated initializer list to start from"); 2080 2081 // Determine the structural initializer list that corresponds to the 2082 // current subobject. 2083 if (IsFirstDesignator) 2084 StructuredList = SyntacticToSemantic.lookup(IList); 2085 else { 2086 Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ? 2087 StructuredList->getInit(StructuredIndex) : nullptr; 2088 if (!ExistingInit && StructuredList->hasArrayFiller()) 2089 ExistingInit = StructuredList->getArrayFiller(); 2090 2091 if (!ExistingInit) 2092 StructuredList = 2093 getStructuredSubobjectInit(IList, Index, CurrentObjectType, 2094 StructuredList, StructuredIndex, 2095 SourceRange(D->getLocStart(), 2096 DIE->getLocEnd())); 2097 else if (InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit)) 2098 StructuredList = Result; 2099 else { 2100 if (DesignatedInitUpdateExpr *E = 2101 dyn_cast<DesignatedInitUpdateExpr>(ExistingInit)) 2102 StructuredList = E->getUpdater(); 2103 else { 2104 DesignatedInitUpdateExpr *DIUE = 2105 new (SemaRef.Context) DesignatedInitUpdateExpr(SemaRef.Context, 2106 D->getLocStart(), ExistingInit, 2107 DIE->getLocEnd()); 2108 StructuredList->updateInit(SemaRef.Context, StructuredIndex, DIUE); 2109 StructuredList = DIUE->getUpdater(); 2110 } 2111 2112 // We need to check on source range validity because the previous 2113 // initializer does not have to be an explicit initializer. e.g., 2114 // 2115 // struct P { int a, b; }; 2116 // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 }; 2117 // 2118 // There is an overwrite taking place because the first braced initializer 2119 // list "{ .a = 2 }" already provides value for .p.b (which is zero). 2120 if (ExistingInit->getSourceRange().isValid()) { 2121 // We are creating an initializer list that initializes the 2122 // subobjects of the current object, but there was already an 2123 // initialization that completely initialized the current 2124 // subobject, e.g., by a compound literal: 2125 // 2126 // struct X { int a, b; }; 2127 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 }; 2128 // 2129 // Here, xs[0].a == 0 and xs[0].b == 3, since the second, 2130 // designated initializer re-initializes the whole 2131 // subobject [0], overwriting previous initializers. 2132 SemaRef.Diag(D->getLocStart(), 2133 diag::warn_subobject_initializer_overrides) 2134 << SourceRange(D->getLocStart(), DIE->getLocEnd()); 2135 2136 SemaRef.Diag(ExistingInit->getLocStart(), 2137 diag::note_previous_initializer) 2138 << /*FIXME:has side effects=*/0 2139 << ExistingInit->getSourceRange(); 2140 } 2141 } 2142 } 2143 assert(StructuredList && "Expected a structured initializer list"); 2144 } 2145 2146 if (D->isFieldDesignator()) { 2147 // C99 6.7.8p7: 2148 // 2149 // If a designator has the form 2150 // 2151 // . identifier 2152 // 2153 // then the current object (defined below) shall have 2154 // structure or union type and the identifier shall be the 2155 // name of a member of that type. 2156 const RecordType *RT = CurrentObjectType->getAs<RecordType>(); 2157 if (!RT) { 2158 SourceLocation Loc = D->getDotLoc(); 2159 if (Loc.isInvalid()) 2160 Loc = D->getFieldLoc(); 2161 if (!VerifyOnly) 2162 SemaRef.Diag(Loc, diag::err_field_designator_non_aggr) 2163 << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType; 2164 ++Index; 2165 return true; 2166 } 2167 2168 FieldDecl *KnownField = D->getField(); 2169 if (!KnownField) { 2170 IdentifierInfo *FieldName = D->getFieldName(); 2171 DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName); 2172 for (NamedDecl *ND : Lookup) { 2173 if (auto *FD = dyn_cast<FieldDecl>(ND)) { 2174 KnownField = FD; 2175 break; 2176 } 2177 if (auto *IFD = dyn_cast<IndirectFieldDecl>(ND)) { 2178 // In verify mode, don't modify the original. 2179 if (VerifyOnly) 2180 DIE = CloneDesignatedInitExpr(SemaRef, DIE); 2181 ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IFD); 2182 D = DIE->getDesignator(DesigIdx); 2183 KnownField = cast<FieldDecl>(*IFD->chain_begin()); 2184 break; 2185 } 2186 } 2187 if (!KnownField) { 2188 if (VerifyOnly) { 2189 ++Index; 2190 return true; // No typo correction when just trying this out. 2191 } 2192 2193 // Name lookup found something, but it wasn't a field. 2194 if (!Lookup.empty()) { 2195 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield) 2196 << FieldName; 2197 SemaRef.Diag(Lookup.front()->getLocation(), 2198 diag::note_field_designator_found); 2199 ++Index; 2200 return true; 2201 } 2202 2203 // Name lookup didn't find anything. 2204 // Determine whether this was a typo for another field name. 2205 if (TypoCorrection Corrected = SemaRef.CorrectTypo( 2206 DeclarationNameInfo(FieldName, D->getFieldLoc()), 2207 Sema::LookupMemberName, /*Scope=*/nullptr, /*SS=*/nullptr, 2208 llvm::make_unique<FieldInitializerValidatorCCC>(RT->getDecl()), 2209 Sema::CTK_ErrorRecovery, RT->getDecl())) { 2210 SemaRef.diagnoseTypo( 2211 Corrected, 2212 SemaRef.PDiag(diag::err_field_designator_unknown_suggest) 2213 << FieldName << CurrentObjectType); 2214 KnownField = Corrected.getCorrectionDeclAs<FieldDecl>(); 2215 hadError = true; 2216 } else { 2217 // Typo correction didn't find anything. 2218 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown) 2219 << FieldName << CurrentObjectType; 2220 ++Index; 2221 return true; 2222 } 2223 } 2224 } 2225 2226 unsigned FieldIndex = 0; 2227 for (auto *FI : RT->getDecl()->fields()) { 2228 if (FI->isUnnamedBitfield()) 2229 continue; 2230 if (declaresSameEntity(KnownField, FI)) { 2231 KnownField = FI; 2232 break; 2233 } 2234 ++FieldIndex; 2235 } 2236 2237 RecordDecl::field_iterator Field = 2238 RecordDecl::field_iterator(DeclContext::decl_iterator(KnownField)); 2239 2240 // All of the fields of a union are located at the same place in 2241 // the initializer list. 2242 if (RT->getDecl()->isUnion()) { 2243 FieldIndex = 0; 2244 if (!VerifyOnly) { 2245 FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion(); 2246 if (CurrentField && !declaresSameEntity(CurrentField, *Field)) { 2247 assert(StructuredList->getNumInits() == 1 2248 && "A union should never have more than one initializer!"); 2249 2250 // We're about to throw away an initializer, emit warning. 2251 SemaRef.Diag(D->getFieldLoc(), 2252 diag::warn_initializer_overrides) 2253 << D->getSourceRange(); 2254 Expr *ExistingInit = StructuredList->getInit(0); 2255 SemaRef.Diag(ExistingInit->getLocStart(), 2256 diag::note_previous_initializer) 2257 << /*FIXME:has side effects=*/0 2258 << ExistingInit->getSourceRange(); 2259 2260 // remove existing initializer 2261 StructuredList->resizeInits(SemaRef.Context, 0); 2262 StructuredList->setInitializedFieldInUnion(nullptr); 2263 } 2264 2265 StructuredList->setInitializedFieldInUnion(*Field); 2266 } 2267 } 2268 2269 // Make sure we can use this declaration. 2270 bool InvalidUse; 2271 if (VerifyOnly) 2272 InvalidUse = !SemaRef.CanUseDecl(*Field, TreatUnavailableAsInvalid); 2273 else 2274 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc()); 2275 if (InvalidUse) { 2276 ++Index; 2277 return true; 2278 } 2279 2280 if (!VerifyOnly) { 2281 // Update the designator with the field declaration. 2282 D->setField(*Field); 2283 2284 // Make sure that our non-designated initializer list has space 2285 // for a subobject corresponding to this field. 2286 if (FieldIndex >= StructuredList->getNumInits()) 2287 StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1); 2288 } 2289 2290 // This designator names a flexible array member. 2291 if (Field->getType()->isIncompleteArrayType()) { 2292 bool Invalid = false; 2293 if ((DesigIdx + 1) != DIE->size()) { 2294 // We can't designate an object within the flexible array 2295 // member (because GCC doesn't allow it). 2296 if (!VerifyOnly) { 2297 DesignatedInitExpr::Designator *NextD 2298 = DIE->getDesignator(DesigIdx + 1); 2299 SemaRef.Diag(NextD->getLocStart(), 2300 diag::err_designator_into_flexible_array_member) 2301 << SourceRange(NextD->getLocStart(), 2302 DIE->getLocEnd()); 2303 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 2304 << *Field; 2305 } 2306 Invalid = true; 2307 } 2308 2309 if (!hadError && !isa<InitListExpr>(DIE->getInit()) && 2310 !isa<StringLiteral>(DIE->getInit())) { 2311 // The initializer is not an initializer list. 2312 if (!VerifyOnly) { 2313 SemaRef.Diag(DIE->getInit()->getLocStart(), 2314 diag::err_flexible_array_init_needs_braces) 2315 << DIE->getInit()->getSourceRange(); 2316 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 2317 << *Field; 2318 } 2319 Invalid = true; 2320 } 2321 2322 // Check GNU flexible array initializer. 2323 if (!Invalid && CheckFlexibleArrayInit(Entity, DIE->getInit(), *Field, 2324 TopLevelObject)) 2325 Invalid = true; 2326 2327 if (Invalid) { 2328 ++Index; 2329 return true; 2330 } 2331 2332 // Initialize the array. 2333 bool prevHadError = hadError; 2334 unsigned newStructuredIndex = FieldIndex; 2335 unsigned OldIndex = Index; 2336 IList->setInit(Index, DIE->getInit()); 2337 2338 InitializedEntity MemberEntity = 2339 InitializedEntity::InitializeMember(*Field, &Entity); 2340 CheckSubElementType(MemberEntity, IList, Field->getType(), Index, 2341 StructuredList, newStructuredIndex); 2342 2343 IList->setInit(OldIndex, DIE); 2344 if (hadError && !prevHadError) { 2345 ++Field; 2346 ++FieldIndex; 2347 if (NextField) 2348 *NextField = Field; 2349 StructuredIndex = FieldIndex; 2350 return true; 2351 } 2352 } else { 2353 // Recurse to check later designated subobjects. 2354 QualType FieldType = Field->getType(); 2355 unsigned newStructuredIndex = FieldIndex; 2356 2357 InitializedEntity MemberEntity = 2358 InitializedEntity::InitializeMember(*Field, &Entity); 2359 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1, 2360 FieldType, nullptr, nullptr, Index, 2361 StructuredList, newStructuredIndex, 2362 FinishSubobjectInit, false)) 2363 return true; 2364 } 2365 2366 // Find the position of the next field to be initialized in this 2367 // subobject. 2368 ++Field; 2369 ++FieldIndex; 2370 2371 // If this the first designator, our caller will continue checking 2372 // the rest of this struct/class/union subobject. 2373 if (IsFirstDesignator) { 2374 if (NextField) 2375 *NextField = Field; 2376 StructuredIndex = FieldIndex; 2377 return false; 2378 } 2379 2380 if (!FinishSubobjectInit) 2381 return false; 2382 2383 // We've already initialized something in the union; we're done. 2384 if (RT->getDecl()->isUnion()) 2385 return hadError; 2386 2387 // Check the remaining fields within this class/struct/union subobject. 2388 bool prevHadError = hadError; 2389 2390 auto NoBases = 2391 CXXRecordDecl::base_class_range(CXXRecordDecl::base_class_iterator(), 2392 CXXRecordDecl::base_class_iterator()); 2393 CheckStructUnionTypes(Entity, IList, CurrentObjectType, NoBases, Field, 2394 false, Index, StructuredList, FieldIndex); 2395 return hadError && !prevHadError; 2396 } 2397 2398 // C99 6.7.8p6: 2399 // 2400 // If a designator has the form 2401 // 2402 // [ constant-expression ] 2403 // 2404 // then the current object (defined below) shall have array 2405 // type and the expression shall be an integer constant 2406 // expression. If the array is of unknown size, any 2407 // nonnegative value is valid. 2408 // 2409 // Additionally, cope with the GNU extension that permits 2410 // designators of the form 2411 // 2412 // [ constant-expression ... constant-expression ] 2413 const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType); 2414 if (!AT) { 2415 if (!VerifyOnly) 2416 SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array) 2417 << CurrentObjectType; 2418 ++Index; 2419 return true; 2420 } 2421 2422 Expr *IndexExpr = nullptr; 2423 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex; 2424 if (D->isArrayDesignator()) { 2425 IndexExpr = DIE->getArrayIndex(*D); 2426 DesignatedStartIndex = IndexExpr->EvaluateKnownConstInt(SemaRef.Context); 2427 DesignatedEndIndex = DesignatedStartIndex; 2428 } else { 2429 assert(D->isArrayRangeDesignator() && "Need array-range designator"); 2430 2431 DesignatedStartIndex = 2432 DIE->getArrayRangeStart(*D)->EvaluateKnownConstInt(SemaRef.Context); 2433 DesignatedEndIndex = 2434 DIE->getArrayRangeEnd(*D)->EvaluateKnownConstInt(SemaRef.Context); 2435 IndexExpr = DIE->getArrayRangeEnd(*D); 2436 2437 // Codegen can't handle evaluating array range designators that have side 2438 // effects, because we replicate the AST value for each initialized element. 2439 // As such, set the sawArrayRangeDesignator() bit if we initialize multiple 2440 // elements with something that has a side effect, so codegen can emit an 2441 // "error unsupported" error instead of miscompiling the app. 2442 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&& 2443 DIE->getInit()->HasSideEffects(SemaRef.Context) && !VerifyOnly) 2444 FullyStructuredList->sawArrayRangeDesignator(); 2445 } 2446 2447 if (isa<ConstantArrayType>(AT)) { 2448 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false); 2449 DesignatedStartIndex 2450 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth()); 2451 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned()); 2452 DesignatedEndIndex 2453 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth()); 2454 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned()); 2455 if (DesignatedEndIndex >= MaxElements) { 2456 if (!VerifyOnly) 2457 SemaRef.Diag(IndexExpr->getLocStart(), 2458 diag::err_array_designator_too_large) 2459 << DesignatedEndIndex.toString(10) << MaxElements.toString(10) 2460 << IndexExpr->getSourceRange(); 2461 ++Index; 2462 return true; 2463 } 2464 } else { 2465 unsigned DesignatedIndexBitWidth = 2466 ConstantArrayType::getMaxSizeBits(SemaRef.Context); 2467 DesignatedStartIndex = 2468 DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth); 2469 DesignatedEndIndex = 2470 DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth); 2471 DesignatedStartIndex.setIsUnsigned(true); 2472 DesignatedEndIndex.setIsUnsigned(true); 2473 } 2474 2475 if (!VerifyOnly && StructuredList->isStringLiteralInit()) { 2476 // We're modifying a string literal init; we have to decompose the string 2477 // so we can modify the individual characters. 2478 ASTContext &Context = SemaRef.Context; 2479 Expr *SubExpr = StructuredList->getInit(0)->IgnoreParens(); 2480 2481 // Compute the character type 2482 QualType CharTy = AT->getElementType(); 2483 2484 // Compute the type of the integer literals. 2485 QualType PromotedCharTy = CharTy; 2486 if (CharTy->isPromotableIntegerType()) 2487 PromotedCharTy = Context.getPromotedIntegerType(CharTy); 2488 unsigned PromotedCharTyWidth = Context.getTypeSize(PromotedCharTy); 2489 2490 if (StringLiteral *SL = dyn_cast<StringLiteral>(SubExpr)) { 2491 // Get the length of the string. 2492 uint64_t StrLen = SL->getLength(); 2493 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen)) 2494 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue(); 2495 StructuredList->resizeInits(Context, StrLen); 2496 2497 // Build a literal for each character in the string, and put them into 2498 // the init list. 2499 for (unsigned i = 0, e = StrLen; i != e; ++i) { 2500 llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i)); 2501 Expr *Init = new (Context) IntegerLiteral( 2502 Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc()); 2503 if (CharTy != PromotedCharTy) 2504 Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast, 2505 Init, nullptr, VK_RValue); 2506 StructuredList->updateInit(Context, i, Init); 2507 } 2508 } else { 2509 ObjCEncodeExpr *E = cast<ObjCEncodeExpr>(SubExpr); 2510 std::string Str; 2511 Context.getObjCEncodingForType(E->getEncodedType(), Str); 2512 2513 // Get the length of the string. 2514 uint64_t StrLen = Str.size(); 2515 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen)) 2516 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue(); 2517 StructuredList->resizeInits(Context, StrLen); 2518 2519 // Build a literal for each character in the string, and put them into 2520 // the init list. 2521 for (unsigned i = 0, e = StrLen; i != e; ++i) { 2522 llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]); 2523 Expr *Init = new (Context) IntegerLiteral( 2524 Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc()); 2525 if (CharTy != PromotedCharTy) 2526 Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast, 2527 Init, nullptr, VK_RValue); 2528 StructuredList->updateInit(Context, i, Init); 2529 } 2530 } 2531 } 2532 2533 // Make sure that our non-designated initializer list has space 2534 // for a subobject corresponding to this array element. 2535 if (!VerifyOnly && 2536 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits()) 2537 StructuredList->resizeInits(SemaRef.Context, 2538 DesignatedEndIndex.getZExtValue() + 1); 2539 2540 // Repeatedly perform subobject initializations in the range 2541 // [DesignatedStartIndex, DesignatedEndIndex]. 2542 2543 // Move to the next designator 2544 unsigned ElementIndex = DesignatedStartIndex.getZExtValue(); 2545 unsigned OldIndex = Index; 2546 2547 InitializedEntity ElementEntity = 2548 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity); 2549 2550 while (DesignatedStartIndex <= DesignatedEndIndex) { 2551 // Recurse to check later designated subobjects. 2552 QualType ElementType = AT->getElementType(); 2553 Index = OldIndex; 2554 2555 ElementEntity.setElementIndex(ElementIndex); 2556 if (CheckDesignatedInitializer( 2557 ElementEntity, IList, DIE, DesigIdx + 1, ElementType, nullptr, 2558 nullptr, Index, StructuredList, ElementIndex, 2559 FinishSubobjectInit && (DesignatedStartIndex == DesignatedEndIndex), 2560 false)) 2561 return true; 2562 2563 // Move to the next index in the array that we'll be initializing. 2564 ++DesignatedStartIndex; 2565 ElementIndex = DesignatedStartIndex.getZExtValue(); 2566 } 2567 2568 // If this the first designator, our caller will continue checking 2569 // the rest of this array subobject. 2570 if (IsFirstDesignator) { 2571 if (NextElementIndex) 2572 *NextElementIndex = DesignatedStartIndex; 2573 StructuredIndex = ElementIndex; 2574 return false; 2575 } 2576 2577 if (!FinishSubobjectInit) 2578 return false; 2579 2580 // Check the remaining elements within this array subobject. 2581 bool prevHadError = hadError; 2582 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex, 2583 /*SubobjectIsDesignatorContext=*/false, Index, 2584 StructuredList, ElementIndex); 2585 return hadError && !prevHadError; 2586 } 2587 2588 // Get the structured initializer list for a subobject of type 2589 // @p CurrentObjectType. 2590 InitListExpr * 2591 InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index, 2592 QualType CurrentObjectType, 2593 InitListExpr *StructuredList, 2594 unsigned StructuredIndex, 2595 SourceRange InitRange, 2596 bool IsFullyOverwritten) { 2597 if (VerifyOnly) 2598 return nullptr; // No structured list in verification-only mode. 2599 Expr *ExistingInit = nullptr; 2600 if (!StructuredList) 2601 ExistingInit = SyntacticToSemantic.lookup(IList); 2602 else if (StructuredIndex < StructuredList->getNumInits()) 2603 ExistingInit = StructuredList->getInit(StructuredIndex); 2604 2605 if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit)) 2606 // There might have already been initializers for subobjects of the current 2607 // object, but a subsequent initializer list will overwrite the entirety 2608 // of the current object. (See DR 253 and C99 6.7.8p21). e.g., 2609 // 2610 // struct P { char x[6]; }; 2611 // struct P l = { .x[2] = 'x', .x = { [0] = 'f' } }; 2612 // 2613 // The first designated initializer is ignored, and l.x is just "f". 2614 if (!IsFullyOverwritten) 2615 return Result; 2616 2617 if (ExistingInit) { 2618 // We are creating an initializer list that initializes the 2619 // subobjects of the current object, but there was already an 2620 // initialization that completely initialized the current 2621 // subobject, e.g., by a compound literal: 2622 // 2623 // struct X { int a, b; }; 2624 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 }; 2625 // 2626 // Here, xs[0].a == 0 and xs[0].b == 3, since the second, 2627 // designated initializer re-initializes the whole 2628 // subobject [0], overwriting previous initializers. 2629 SemaRef.Diag(InitRange.getBegin(), 2630 diag::warn_subobject_initializer_overrides) 2631 << InitRange; 2632 SemaRef.Diag(ExistingInit->getLocStart(), 2633 diag::note_previous_initializer) 2634 << /*FIXME:has side effects=*/0 2635 << ExistingInit->getSourceRange(); 2636 } 2637 2638 InitListExpr *Result 2639 = new (SemaRef.Context) InitListExpr(SemaRef.Context, 2640 InitRange.getBegin(), None, 2641 InitRange.getEnd()); 2642 2643 QualType ResultType = CurrentObjectType; 2644 if (!ResultType->isArrayType()) 2645 ResultType = ResultType.getNonLValueExprType(SemaRef.Context); 2646 Result->setType(ResultType); 2647 2648 // Pre-allocate storage for the structured initializer list. 2649 unsigned NumElements = 0; 2650 unsigned NumInits = 0; 2651 bool GotNumInits = false; 2652 if (!StructuredList) { 2653 NumInits = IList->getNumInits(); 2654 GotNumInits = true; 2655 } else if (Index < IList->getNumInits()) { 2656 if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) { 2657 NumInits = SubList->getNumInits(); 2658 GotNumInits = true; 2659 } 2660 } 2661 2662 if (const ArrayType *AType 2663 = SemaRef.Context.getAsArrayType(CurrentObjectType)) { 2664 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) { 2665 NumElements = CAType->getSize().getZExtValue(); 2666 // Simple heuristic so that we don't allocate a very large 2667 // initializer with many empty entries at the end. 2668 if (GotNumInits && NumElements > NumInits) 2669 NumElements = 0; 2670 } 2671 } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>()) 2672 NumElements = VType->getNumElements(); 2673 else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) { 2674 RecordDecl *RDecl = RType->getDecl(); 2675 if (RDecl->isUnion()) 2676 NumElements = 1; 2677 else 2678 NumElements = std::distance(RDecl->field_begin(), RDecl->field_end()); 2679 } 2680 2681 Result->reserveInits(SemaRef.Context, NumElements); 2682 2683 // Link this new initializer list into the structured initializer 2684 // lists. 2685 if (StructuredList) 2686 StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result); 2687 else { 2688 Result->setSyntacticForm(IList); 2689 SyntacticToSemantic[IList] = Result; 2690 } 2691 2692 return Result; 2693 } 2694 2695 /// Update the initializer at index @p StructuredIndex within the 2696 /// structured initializer list to the value @p expr. 2697 void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList, 2698 unsigned &StructuredIndex, 2699 Expr *expr) { 2700 // No structured initializer list to update 2701 if (!StructuredList) 2702 return; 2703 2704 if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context, 2705 StructuredIndex, expr)) { 2706 // This initializer overwrites a previous initializer. Warn. 2707 // We need to check on source range validity because the previous 2708 // initializer does not have to be an explicit initializer. 2709 // struct P { int a, b; }; 2710 // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 }; 2711 // There is an overwrite taking place because the first braced initializer 2712 // list "{ .a = 2 }' already provides value for .p.b (which is zero). 2713 if (PrevInit->getSourceRange().isValid()) { 2714 SemaRef.Diag(expr->getLocStart(), 2715 diag::warn_initializer_overrides) 2716 << expr->getSourceRange(); 2717 2718 SemaRef.Diag(PrevInit->getLocStart(), 2719 diag::note_previous_initializer) 2720 << /*FIXME:has side effects=*/0 2721 << PrevInit->getSourceRange(); 2722 } 2723 } 2724 2725 ++StructuredIndex; 2726 } 2727 2728 /// Check that the given Index expression is a valid array designator 2729 /// value. This is essentially just a wrapper around 2730 /// VerifyIntegerConstantExpression that also checks for negative values 2731 /// and produces a reasonable diagnostic if there is a 2732 /// failure. Returns the index expression, possibly with an implicit cast 2733 /// added, on success. If everything went okay, Value will receive the 2734 /// value of the constant expression. 2735 static ExprResult 2736 CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) { 2737 SourceLocation Loc = Index->getLocStart(); 2738 2739 // Make sure this is an integer constant expression. 2740 ExprResult Result = S.VerifyIntegerConstantExpression(Index, &Value); 2741 if (Result.isInvalid()) 2742 return Result; 2743 2744 if (Value.isSigned() && Value.isNegative()) 2745 return S.Diag(Loc, diag::err_array_designator_negative) 2746 << Value.toString(10) << Index->getSourceRange(); 2747 2748 Value.setIsUnsigned(true); 2749 return Result; 2750 } 2751 2752 ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig, 2753 SourceLocation Loc, 2754 bool GNUSyntax, 2755 ExprResult Init) { 2756 typedef DesignatedInitExpr::Designator ASTDesignator; 2757 2758 bool Invalid = false; 2759 SmallVector<ASTDesignator, 32> Designators; 2760 SmallVector<Expr *, 32> InitExpressions; 2761 2762 // Build designators and check array designator expressions. 2763 for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) { 2764 const Designator &D = Desig.getDesignator(Idx); 2765 switch (D.getKind()) { 2766 case Designator::FieldDesignator: 2767 Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(), 2768 D.getFieldLoc())); 2769 break; 2770 2771 case Designator::ArrayDesignator: { 2772 Expr *Index = static_cast<Expr *>(D.getArrayIndex()); 2773 llvm::APSInt IndexValue; 2774 if (!Index->isTypeDependent() && !Index->isValueDependent()) 2775 Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).get(); 2776 if (!Index) 2777 Invalid = true; 2778 else { 2779 Designators.push_back(ASTDesignator(InitExpressions.size(), 2780 D.getLBracketLoc(), 2781 D.getRBracketLoc())); 2782 InitExpressions.push_back(Index); 2783 } 2784 break; 2785 } 2786 2787 case Designator::ArrayRangeDesignator: { 2788 Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart()); 2789 Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd()); 2790 llvm::APSInt StartValue; 2791 llvm::APSInt EndValue; 2792 bool StartDependent = StartIndex->isTypeDependent() || 2793 StartIndex->isValueDependent(); 2794 bool EndDependent = EndIndex->isTypeDependent() || 2795 EndIndex->isValueDependent(); 2796 if (!StartDependent) 2797 StartIndex = 2798 CheckArrayDesignatorExpr(*this, StartIndex, StartValue).get(); 2799 if (!EndDependent) 2800 EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).get(); 2801 2802 if (!StartIndex || !EndIndex) 2803 Invalid = true; 2804 else { 2805 // Make sure we're comparing values with the same bit width. 2806 if (StartDependent || EndDependent) { 2807 // Nothing to compute. 2808 } else if (StartValue.getBitWidth() > EndValue.getBitWidth()) 2809 EndValue = EndValue.extend(StartValue.getBitWidth()); 2810 else if (StartValue.getBitWidth() < EndValue.getBitWidth()) 2811 StartValue = StartValue.extend(EndValue.getBitWidth()); 2812 2813 if (!StartDependent && !EndDependent && EndValue < StartValue) { 2814 Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range) 2815 << StartValue.toString(10) << EndValue.toString(10) 2816 << StartIndex->getSourceRange() << EndIndex->getSourceRange(); 2817 Invalid = true; 2818 } else { 2819 Designators.push_back(ASTDesignator(InitExpressions.size(), 2820 D.getLBracketLoc(), 2821 D.getEllipsisLoc(), 2822 D.getRBracketLoc())); 2823 InitExpressions.push_back(StartIndex); 2824 InitExpressions.push_back(EndIndex); 2825 } 2826 } 2827 break; 2828 } 2829 } 2830 } 2831 2832 if (Invalid || Init.isInvalid()) 2833 return ExprError(); 2834 2835 // Clear out the expressions within the designation. 2836 Desig.ClearExprs(*this); 2837 2838 DesignatedInitExpr *DIE 2839 = DesignatedInitExpr::Create(Context, 2840 Designators, 2841 InitExpressions, Loc, GNUSyntax, 2842 Init.getAs<Expr>()); 2843 2844 if (!getLangOpts().C99) 2845 Diag(DIE->getLocStart(), diag::ext_designated_init) 2846 << DIE->getSourceRange(); 2847 2848 return DIE; 2849 } 2850 2851 //===----------------------------------------------------------------------===// 2852 // Initialization entity 2853 //===----------------------------------------------------------------------===// 2854 2855 InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index, 2856 const InitializedEntity &Parent) 2857 : Parent(&Parent), Index(Index) 2858 { 2859 if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) { 2860 Kind = EK_ArrayElement; 2861 Type = AT->getElementType(); 2862 } else if (const VectorType *VT = Parent.getType()->getAs<VectorType>()) { 2863 Kind = EK_VectorElement; 2864 Type = VT->getElementType(); 2865 } else { 2866 const ComplexType *CT = Parent.getType()->getAs<ComplexType>(); 2867 assert(CT && "Unexpected type"); 2868 Kind = EK_ComplexElement; 2869 Type = CT->getElementType(); 2870 } 2871 } 2872 2873 InitializedEntity 2874 InitializedEntity::InitializeBase(ASTContext &Context, 2875 const CXXBaseSpecifier *Base, 2876 bool IsInheritedVirtualBase, 2877 const InitializedEntity *Parent) { 2878 InitializedEntity Result; 2879 Result.Kind = EK_Base; 2880 Result.Parent = Parent; 2881 Result.Base = reinterpret_cast<uintptr_t>(Base); 2882 if (IsInheritedVirtualBase) 2883 Result.Base |= 0x01; 2884 2885 Result.Type = Base->getType(); 2886 return Result; 2887 } 2888 2889 DeclarationName InitializedEntity::getName() const { 2890 switch (getKind()) { 2891 case EK_Parameter: 2892 case EK_Parameter_CF_Audited: { 2893 ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1); 2894 return (D ? D->getDeclName() : DeclarationName()); 2895 } 2896 2897 case EK_Variable: 2898 case EK_Member: 2899 return VariableOrMember->getDeclName(); 2900 2901 case EK_LambdaCapture: 2902 return DeclarationName(Capture.VarID); 2903 2904 case EK_Result: 2905 case EK_Exception: 2906 case EK_New: 2907 case EK_Temporary: 2908 case EK_Base: 2909 case EK_Delegating: 2910 case EK_ArrayElement: 2911 case EK_VectorElement: 2912 case EK_ComplexElement: 2913 case EK_BlockElement: 2914 case EK_CompoundLiteralInit: 2915 case EK_RelatedResult: 2916 return DeclarationName(); 2917 } 2918 2919 llvm_unreachable("Invalid EntityKind!"); 2920 } 2921 2922 DeclaratorDecl *InitializedEntity::getDecl() const { 2923 switch (getKind()) { 2924 case EK_Variable: 2925 case EK_Member: 2926 return VariableOrMember; 2927 2928 case EK_Parameter: 2929 case EK_Parameter_CF_Audited: 2930 return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1); 2931 2932 case EK_Result: 2933 case EK_Exception: 2934 case EK_New: 2935 case EK_Temporary: 2936 case EK_Base: 2937 case EK_Delegating: 2938 case EK_ArrayElement: 2939 case EK_VectorElement: 2940 case EK_ComplexElement: 2941 case EK_BlockElement: 2942 case EK_LambdaCapture: 2943 case EK_CompoundLiteralInit: 2944 case EK_RelatedResult: 2945 return nullptr; 2946 } 2947 2948 llvm_unreachable("Invalid EntityKind!"); 2949 } 2950 2951 bool InitializedEntity::allowsNRVO() const { 2952 switch (getKind()) { 2953 case EK_Result: 2954 case EK_Exception: 2955 return LocAndNRVO.NRVO; 2956 2957 case EK_Variable: 2958 case EK_Parameter: 2959 case EK_Parameter_CF_Audited: 2960 case EK_Member: 2961 case EK_New: 2962 case EK_Temporary: 2963 case EK_CompoundLiteralInit: 2964 case EK_Base: 2965 case EK_Delegating: 2966 case EK_ArrayElement: 2967 case EK_VectorElement: 2968 case EK_ComplexElement: 2969 case EK_BlockElement: 2970 case EK_LambdaCapture: 2971 case EK_RelatedResult: 2972 break; 2973 } 2974 2975 return false; 2976 } 2977 2978 unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const { 2979 assert(getParent() != this); 2980 unsigned Depth = getParent() ? getParent()->dumpImpl(OS) : 0; 2981 for (unsigned I = 0; I != Depth; ++I) 2982 OS << "`-"; 2983 2984 switch (getKind()) { 2985 case EK_Variable: OS << "Variable"; break; 2986 case EK_Parameter: OS << "Parameter"; break; 2987 case EK_Parameter_CF_Audited: OS << "CF audited function Parameter"; 2988 break; 2989 case EK_Result: OS << "Result"; break; 2990 case EK_Exception: OS << "Exception"; break; 2991 case EK_Member: OS << "Member"; break; 2992 case EK_New: OS << "New"; break; 2993 case EK_Temporary: OS << "Temporary"; break; 2994 case EK_CompoundLiteralInit: OS << "CompoundLiteral";break; 2995 case EK_RelatedResult: OS << "RelatedResult"; break; 2996 case EK_Base: OS << "Base"; break; 2997 case EK_Delegating: OS << "Delegating"; break; 2998 case EK_ArrayElement: OS << "ArrayElement " << Index; break; 2999 case EK_VectorElement: OS << "VectorElement " << Index; break; 3000 case EK_ComplexElement: OS << "ComplexElement " << Index; break; 3001 case EK_BlockElement: OS << "Block"; break; 3002 case EK_LambdaCapture: 3003 OS << "LambdaCapture "; 3004 OS << DeclarationName(Capture.VarID); 3005 break; 3006 } 3007 3008 if (Decl *D = getDecl()) { 3009 OS << " "; 3010 cast<NamedDecl>(D)->printQualifiedName(OS); 3011 } 3012 3013 OS << " '" << getType().getAsString() << "'\n"; 3014 3015 return Depth + 1; 3016 } 3017 3018 LLVM_DUMP_METHOD void InitializedEntity::dump() const { 3019 dumpImpl(llvm::errs()); 3020 } 3021 3022 //===----------------------------------------------------------------------===// 3023 // Initialization sequence 3024 //===----------------------------------------------------------------------===// 3025 3026 void InitializationSequence::Step::Destroy() { 3027 switch (Kind) { 3028 case SK_ResolveAddressOfOverloadedFunction: 3029 case SK_CastDerivedToBaseRValue: 3030 case SK_CastDerivedToBaseXValue: 3031 case SK_CastDerivedToBaseLValue: 3032 case SK_BindReference: 3033 case SK_BindReferenceToTemporary: 3034 case SK_ExtraneousCopyToTemporary: 3035 case SK_UserConversion: 3036 case SK_QualificationConversionRValue: 3037 case SK_QualificationConversionXValue: 3038 case SK_QualificationConversionLValue: 3039 case SK_AtomicConversion: 3040 case SK_LValueToRValue: 3041 case SK_ListInitialization: 3042 case SK_UnwrapInitList: 3043 case SK_RewrapInitList: 3044 case SK_ConstructorInitialization: 3045 case SK_ConstructorInitializationFromList: 3046 case SK_ZeroInitialization: 3047 case SK_CAssignment: 3048 case SK_StringInit: 3049 case SK_ObjCObjectConversion: 3050 case SK_ArrayInit: 3051 case SK_ParenthesizedArrayInit: 3052 case SK_PassByIndirectCopyRestore: 3053 case SK_PassByIndirectRestore: 3054 case SK_ProduceObjCObject: 3055 case SK_StdInitializerList: 3056 case SK_StdInitializerListConstructorCall: 3057 case SK_OCLSamplerInit: 3058 case SK_OCLZeroEvent: 3059 break; 3060 3061 case SK_ConversionSequence: 3062 case SK_ConversionSequenceNoNarrowing: 3063 delete ICS; 3064 } 3065 } 3066 3067 bool InitializationSequence::isDirectReferenceBinding() const { 3068 return !Steps.empty() && Steps.back().Kind == SK_BindReference; 3069 } 3070 3071 bool InitializationSequence::isAmbiguous() const { 3072 if (!Failed()) 3073 return false; 3074 3075 switch (getFailureKind()) { 3076 case FK_TooManyInitsForReference: 3077 case FK_ArrayNeedsInitList: 3078 case FK_ArrayNeedsInitListOrStringLiteral: 3079 case FK_ArrayNeedsInitListOrWideStringLiteral: 3080 case FK_NarrowStringIntoWideCharArray: 3081 case FK_WideStringIntoCharArray: 3082 case FK_IncompatWideStringIntoWideChar: 3083 case FK_AddressOfOverloadFailed: // FIXME: Could do better 3084 case FK_NonConstLValueReferenceBindingToTemporary: 3085 case FK_NonConstLValueReferenceBindingToUnrelated: 3086 case FK_RValueReferenceBindingToLValue: 3087 case FK_ReferenceInitDropsQualifiers: 3088 case FK_ReferenceInitFailed: 3089 case FK_ConversionFailed: 3090 case FK_ConversionFromPropertyFailed: 3091 case FK_TooManyInitsForScalar: 3092 case FK_ReferenceBindingToInitList: 3093 case FK_InitListBadDestinationType: 3094 case FK_DefaultInitOfConst: 3095 case FK_Incomplete: 3096 case FK_ArrayTypeMismatch: 3097 case FK_NonConstantArrayInit: 3098 case FK_ListInitializationFailed: 3099 case FK_VariableLengthArrayHasInitializer: 3100 case FK_PlaceholderType: 3101 case FK_ExplicitConstructor: 3102 case FK_AddressOfUnaddressableFunction: 3103 return false; 3104 3105 case FK_ReferenceInitOverloadFailed: 3106 case FK_UserConversionOverloadFailed: 3107 case FK_ConstructorOverloadFailed: 3108 case FK_ListConstructorOverloadFailed: 3109 return FailedOverloadResult == OR_Ambiguous; 3110 } 3111 3112 llvm_unreachable("Invalid EntityKind!"); 3113 } 3114 3115 bool InitializationSequence::isConstructorInitialization() const { 3116 return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization; 3117 } 3118 3119 void 3120 InitializationSequence 3121 ::AddAddressOverloadResolutionStep(FunctionDecl *Function, 3122 DeclAccessPair Found, 3123 bool HadMultipleCandidates) { 3124 Step S; 3125 S.Kind = SK_ResolveAddressOfOverloadedFunction; 3126 S.Type = Function->getType(); 3127 S.Function.HadMultipleCandidates = HadMultipleCandidates; 3128 S.Function.Function = Function; 3129 S.Function.FoundDecl = Found; 3130 Steps.push_back(S); 3131 } 3132 3133 void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType, 3134 ExprValueKind VK) { 3135 Step S; 3136 switch (VK) { 3137 case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break; 3138 case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break; 3139 case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break; 3140 } 3141 S.Type = BaseType; 3142 Steps.push_back(S); 3143 } 3144 3145 void InitializationSequence::AddReferenceBindingStep(QualType T, 3146 bool BindingTemporary) { 3147 Step S; 3148 S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference; 3149 S.Type = T; 3150 Steps.push_back(S); 3151 } 3152 3153 void InitializationSequence::AddExtraneousCopyToTemporary(QualType T) { 3154 Step S; 3155 S.Kind = SK_ExtraneousCopyToTemporary; 3156 S.Type = T; 3157 Steps.push_back(S); 3158 } 3159 3160 void 3161 InitializationSequence::AddUserConversionStep(FunctionDecl *Function, 3162 DeclAccessPair FoundDecl, 3163 QualType T, 3164 bool HadMultipleCandidates) { 3165 Step S; 3166 S.Kind = SK_UserConversion; 3167 S.Type = T; 3168 S.Function.HadMultipleCandidates = HadMultipleCandidates; 3169 S.Function.Function = Function; 3170 S.Function.FoundDecl = FoundDecl; 3171 Steps.push_back(S); 3172 } 3173 3174 void InitializationSequence::AddQualificationConversionStep(QualType Ty, 3175 ExprValueKind VK) { 3176 Step S; 3177 S.Kind = SK_QualificationConversionRValue; // work around a gcc warning 3178 switch (VK) { 3179 case VK_RValue: 3180 S.Kind = SK_QualificationConversionRValue; 3181 break; 3182 case VK_XValue: 3183 S.Kind = SK_QualificationConversionXValue; 3184 break; 3185 case VK_LValue: 3186 S.Kind = SK_QualificationConversionLValue; 3187 break; 3188 } 3189 S.Type = Ty; 3190 Steps.push_back(S); 3191 } 3192 3193 void InitializationSequence::AddAtomicConversionStep(QualType Ty) { 3194 Step S; 3195 S.Kind = SK_AtomicConversion; 3196 S.Type = Ty; 3197 Steps.push_back(S); 3198 } 3199 3200 void InitializationSequence::AddLValueToRValueStep(QualType Ty) { 3201 assert(!Ty.hasQualifiers() && "rvalues may not have qualifiers"); 3202 3203 Step S; 3204 S.Kind = SK_LValueToRValue; 3205 S.Type = Ty; 3206 Steps.push_back(S); 3207 } 3208 3209 void InitializationSequence::AddConversionSequenceStep( 3210 const ImplicitConversionSequence &ICS, QualType T, 3211 bool TopLevelOfInitList) { 3212 Step S; 3213 S.Kind = TopLevelOfInitList ? SK_ConversionSequenceNoNarrowing 3214 : SK_ConversionSequence; 3215 S.Type = T; 3216 S.ICS = new ImplicitConversionSequence(ICS); 3217 Steps.push_back(S); 3218 } 3219 3220 void InitializationSequence::AddListInitializationStep(QualType T) { 3221 Step S; 3222 S.Kind = SK_ListInitialization; 3223 S.Type = T; 3224 Steps.push_back(S); 3225 } 3226 3227 void InitializationSequence::AddConstructorInitializationStep( 3228 DeclAccessPair FoundDecl, CXXConstructorDecl *Constructor, QualType T, 3229 bool HadMultipleCandidates, bool FromInitList, bool AsInitList) { 3230 Step S; 3231 S.Kind = FromInitList ? AsInitList ? SK_StdInitializerListConstructorCall 3232 : SK_ConstructorInitializationFromList 3233 : SK_ConstructorInitialization; 3234 S.Type = T; 3235 S.Function.HadMultipleCandidates = HadMultipleCandidates; 3236 S.Function.Function = Constructor; 3237 S.Function.FoundDecl = FoundDecl; 3238 Steps.push_back(S); 3239 } 3240 3241 void InitializationSequence::AddZeroInitializationStep(QualType T) { 3242 Step S; 3243 S.Kind = SK_ZeroInitialization; 3244 S.Type = T; 3245 Steps.push_back(S); 3246 } 3247 3248 void InitializationSequence::AddCAssignmentStep(QualType T) { 3249 Step S; 3250 S.Kind = SK_CAssignment; 3251 S.Type = T; 3252 Steps.push_back(S); 3253 } 3254 3255 void InitializationSequence::AddStringInitStep(QualType T) { 3256 Step S; 3257 S.Kind = SK_StringInit; 3258 S.Type = T; 3259 Steps.push_back(S); 3260 } 3261 3262 void InitializationSequence::AddObjCObjectConversionStep(QualType T) { 3263 Step S; 3264 S.Kind = SK_ObjCObjectConversion; 3265 S.Type = T; 3266 Steps.push_back(S); 3267 } 3268 3269 void InitializationSequence::AddArrayInitStep(QualType T) { 3270 Step S; 3271 S.Kind = SK_ArrayInit; 3272 S.Type = T; 3273 Steps.push_back(S); 3274 } 3275 3276 void InitializationSequence::AddParenthesizedArrayInitStep(QualType T) { 3277 Step S; 3278 S.Kind = SK_ParenthesizedArrayInit; 3279 S.Type = T; 3280 Steps.push_back(S); 3281 } 3282 3283 void InitializationSequence::AddPassByIndirectCopyRestoreStep(QualType type, 3284 bool shouldCopy) { 3285 Step s; 3286 s.Kind = (shouldCopy ? SK_PassByIndirectCopyRestore 3287 : SK_PassByIndirectRestore); 3288 s.Type = type; 3289 Steps.push_back(s); 3290 } 3291 3292 void InitializationSequence::AddProduceObjCObjectStep(QualType T) { 3293 Step S; 3294 S.Kind = SK_ProduceObjCObject; 3295 S.Type = T; 3296 Steps.push_back(S); 3297 } 3298 3299 void InitializationSequence::AddStdInitializerListConstructionStep(QualType T) { 3300 Step S; 3301 S.Kind = SK_StdInitializerList; 3302 S.Type = T; 3303 Steps.push_back(S); 3304 } 3305 3306 void InitializationSequence::AddOCLSamplerInitStep(QualType T) { 3307 Step S; 3308 S.Kind = SK_OCLSamplerInit; 3309 S.Type = T; 3310 Steps.push_back(S); 3311 } 3312 3313 void InitializationSequence::AddOCLZeroEventStep(QualType T) { 3314 Step S; 3315 S.Kind = SK_OCLZeroEvent; 3316 S.Type = T; 3317 Steps.push_back(S); 3318 } 3319 3320 void InitializationSequence::RewrapReferenceInitList(QualType T, 3321 InitListExpr *Syntactic) { 3322 assert(Syntactic->getNumInits() == 1 && 3323 "Can only rewrap trivial init lists."); 3324 Step S; 3325 S.Kind = SK_UnwrapInitList; 3326 S.Type = Syntactic->getInit(0)->getType(); 3327 Steps.insert(Steps.begin(), S); 3328 3329 S.Kind = SK_RewrapInitList; 3330 S.Type = T; 3331 S.WrappingSyntacticList = Syntactic; 3332 Steps.push_back(S); 3333 } 3334 3335 void InitializationSequence::SetOverloadFailure(FailureKind Failure, 3336 OverloadingResult Result) { 3337 setSequenceKind(FailedSequence); 3338 this->Failure = Failure; 3339 this->FailedOverloadResult = Result; 3340 } 3341 3342 //===----------------------------------------------------------------------===// 3343 // Attempt initialization 3344 //===----------------------------------------------------------------------===// 3345 3346 /// Tries to add a zero initializer. Returns true if that worked. 3347 static bool 3348 maybeRecoverWithZeroInitialization(Sema &S, InitializationSequence &Sequence, 3349 const InitializedEntity &Entity) { 3350 if (Entity.getKind() != InitializedEntity::EK_Variable) 3351 return false; 3352 3353 VarDecl *VD = cast<VarDecl>(Entity.getDecl()); 3354 if (VD->getInit() || VD->getLocEnd().isMacroID()) 3355 return false; 3356 3357 QualType VariableTy = VD->getType().getCanonicalType(); 3358 SourceLocation Loc = S.getLocForEndOfToken(VD->getLocEnd()); 3359 std::string Init = S.getFixItZeroInitializerForType(VariableTy, Loc); 3360 if (!Init.empty()) { 3361 Sequence.AddZeroInitializationStep(Entity.getType()); 3362 Sequence.SetZeroInitializationFixit(Init, Loc); 3363 return true; 3364 } 3365 return false; 3366 } 3367 3368 static void MaybeProduceObjCObject(Sema &S, 3369 InitializationSequence &Sequence, 3370 const InitializedEntity &Entity) { 3371 if (!S.getLangOpts().ObjCAutoRefCount) return; 3372 3373 /// When initializing a parameter, produce the value if it's marked 3374 /// __attribute__((ns_consumed)). 3375 if (Entity.isParameterKind()) { 3376 if (!Entity.isParameterConsumed()) 3377 return; 3378 3379 assert(Entity.getType()->isObjCRetainableType() && 3380 "consuming an object of unretainable type?"); 3381 Sequence.AddProduceObjCObjectStep(Entity.getType()); 3382 3383 /// When initializing a return value, if the return type is a 3384 /// retainable type, then returns need to immediately retain the 3385 /// object. If an autorelease is required, it will be done at the 3386 /// last instant. 3387 } else if (Entity.getKind() == InitializedEntity::EK_Result) { 3388 if (!Entity.getType()->isObjCRetainableType()) 3389 return; 3390 3391 Sequence.AddProduceObjCObjectStep(Entity.getType()); 3392 } 3393 } 3394 3395 static void TryListInitialization(Sema &S, 3396 const InitializedEntity &Entity, 3397 const InitializationKind &Kind, 3398 InitListExpr *InitList, 3399 InitializationSequence &Sequence, 3400 bool TreatUnavailableAsInvalid); 3401 3402 /// \brief When initializing from init list via constructor, handle 3403 /// initialization of an object of type std::initializer_list<T>. 3404 /// 3405 /// \return true if we have handled initialization of an object of type 3406 /// std::initializer_list<T>, false otherwise. 3407 static bool TryInitializerListConstruction(Sema &S, 3408 InitListExpr *List, 3409 QualType DestType, 3410 InitializationSequence &Sequence, 3411 bool TreatUnavailableAsInvalid) { 3412 QualType E; 3413 if (!S.isStdInitializerList(DestType, &E)) 3414 return false; 3415 3416 if (!S.isCompleteType(List->getExprLoc(), E)) { 3417 Sequence.setIncompleteTypeFailure(E); 3418 return true; 3419 } 3420 3421 // Try initializing a temporary array from the init list. 3422 QualType ArrayType = S.Context.getConstantArrayType( 3423 E.withConst(), llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()), 3424 List->getNumInits()), 3425 clang::ArrayType::Normal, 0); 3426 InitializedEntity HiddenArray = 3427 InitializedEntity::InitializeTemporary(ArrayType); 3428 InitializationKind Kind = 3429 InitializationKind::CreateDirectList(List->getExprLoc()); 3430 TryListInitialization(S, HiddenArray, Kind, List, Sequence, 3431 TreatUnavailableAsInvalid); 3432 if (Sequence) 3433 Sequence.AddStdInitializerListConstructionStep(DestType); 3434 return true; 3435 } 3436 3437 static OverloadingResult 3438 ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc, 3439 MultiExprArg Args, 3440 OverloadCandidateSet &CandidateSet, 3441 DeclContext::lookup_result Ctors, 3442 OverloadCandidateSet::iterator &Best, 3443 bool CopyInitializing, bool AllowExplicit, 3444 bool OnlyListConstructors, bool IsListInit) { 3445 CandidateSet.clear(); 3446 3447 for (NamedDecl *D : Ctors) { 3448 auto Info = getConstructorInfo(D); 3449 if (!Info.Constructor) 3450 continue; 3451 3452 bool SuppressUserConversions = false; 3453 3454 if (!Info.ConstructorTmpl) { 3455 // C++11 [over.best.ics]p4: 3456 // ... and the constructor or user-defined conversion function is a 3457 // candidate by 3458 // - 13.3.1.3, when the argument is the temporary in the second step 3459 // of a class copy-initialization, or 3460 // - 13.3.1.4, 13.3.1.5, or 13.3.1.6 (in all cases), 3461 // user-defined conversion sequences are not considered. 3462 // FIXME: This breaks backward compatibility, e.g. PR12117. As a 3463 // temporary fix, let's re-instate the third bullet above until 3464 // there is a resolution in the standard, i.e., 3465 // - 13.3.1.7 when the initializer list has exactly one element that is 3466 // itself an initializer list and a conversion to some class X or 3467 // reference to (possibly cv-qualified) X is considered for the first 3468 // parameter of a constructor of X. 3469 if ((CopyInitializing || 3470 (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]))) && 3471 Info.Constructor->isCopyOrMoveConstructor()) 3472 SuppressUserConversions = true; 3473 } 3474 3475 if (!Info.Constructor->isInvalidDecl() && 3476 (AllowExplicit || !Info.Constructor->isExplicit()) && 3477 (!OnlyListConstructors || S.isInitListConstructor(Info.Constructor))) { 3478 if (Info.ConstructorTmpl) 3479 S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl, 3480 /*ExplicitArgs*/ nullptr, Args, 3481 CandidateSet, SuppressUserConversions); 3482 else { 3483 // C++ [over.match.copy]p1: 3484 // - When initializing a temporary to be bound to the first parameter 3485 // of a constructor that takes a reference to possibly cv-qualified 3486 // T as its first argument, called with a single argument in the 3487 // context of direct-initialization, explicit conversion functions 3488 // are also considered. 3489 bool AllowExplicitConv = AllowExplicit && !CopyInitializing && 3490 Args.size() == 1 && 3491 Info.Constructor->isCopyOrMoveConstructor(); 3492 S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, Args, 3493 CandidateSet, SuppressUserConversions, 3494 /*PartialOverloading=*/false, 3495 /*AllowExplicit=*/AllowExplicitConv); 3496 } 3497 } 3498 } 3499 3500 // Perform overload resolution and return the result. 3501 return CandidateSet.BestViableFunction(S, DeclLoc, Best); 3502 } 3503 3504 /// \brief Attempt initialization by constructor (C++ [dcl.init]), which 3505 /// enumerates the constructors of the initialized entity and performs overload 3506 /// resolution to select the best. 3507 /// \param IsListInit Is this list-initialization? 3508 /// \param IsInitListCopy Is this non-list-initialization resulting from a 3509 /// list-initialization from {x} where x is the same 3510 /// type as the entity? 3511 static void TryConstructorInitialization(Sema &S, 3512 const InitializedEntity &Entity, 3513 const InitializationKind &Kind, 3514 MultiExprArg Args, QualType DestType, 3515 InitializationSequence &Sequence, 3516 bool IsListInit = false, 3517 bool IsInitListCopy = false) { 3518 assert((!IsListInit || (Args.size() == 1 && isa<InitListExpr>(Args[0]))) && 3519 "IsListInit must come with a single initializer list argument."); 3520 3521 // The type we're constructing needs to be complete. 3522 if (!S.isCompleteType(Kind.getLocation(), DestType)) { 3523 Sequence.setIncompleteTypeFailure(DestType); 3524 return; 3525 } 3526 3527 const RecordType *DestRecordType = DestType->getAs<RecordType>(); 3528 assert(DestRecordType && "Constructor initialization requires record type"); 3529 CXXRecordDecl *DestRecordDecl 3530 = cast<CXXRecordDecl>(DestRecordType->getDecl()); 3531 3532 // Build the candidate set directly in the initialization sequence 3533 // structure, so that it will persist if we fail. 3534 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet(); 3535 3536 // Determine whether we are allowed to call explicit constructors or 3537 // explicit conversion operators. 3538 bool AllowExplicit = Kind.AllowExplicit() || IsListInit; 3539 bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy; 3540 3541 // - Otherwise, if T is a class type, constructors are considered. The 3542 // applicable constructors are enumerated, and the best one is chosen 3543 // through overload resolution. 3544 DeclContext::lookup_result Ctors = S.LookupConstructors(DestRecordDecl); 3545 3546 OverloadingResult Result = OR_No_Viable_Function; 3547 OverloadCandidateSet::iterator Best; 3548 bool AsInitializerList = false; 3549 3550 // C++11 [over.match.list]p1, per DR1467: 3551 // When objects of non-aggregate type T are list-initialized, such that 3552 // 8.5.4 [dcl.init.list] specifies that overload resolution is performed 3553 // according to the rules in this section, overload resolution selects 3554 // the constructor in two phases: 3555 // 3556 // - Initially, the candidate functions are the initializer-list 3557 // constructors of the class T and the argument list consists of the 3558 // initializer list as a single argument. 3559 if (IsListInit) { 3560 InitListExpr *ILE = cast<InitListExpr>(Args[0]); 3561 AsInitializerList = true; 3562 3563 // If the initializer list has no elements and T has a default constructor, 3564 // the first phase is omitted. 3565 if (ILE->getNumInits() != 0 || !DestRecordDecl->hasDefaultConstructor()) 3566 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args, 3567 CandidateSet, Ctors, Best, 3568 CopyInitialization, AllowExplicit, 3569 /*OnlyListConstructor=*/true, 3570 IsListInit); 3571 3572 // Time to unwrap the init list. 3573 Args = MultiExprArg(ILE->getInits(), ILE->getNumInits()); 3574 } 3575 3576 // C++11 [over.match.list]p1: 3577 // - If no viable initializer-list constructor is found, overload resolution 3578 // is performed again, where the candidate functions are all the 3579 // constructors of the class T and the argument list consists of the 3580 // elements of the initializer list. 3581 if (Result == OR_No_Viable_Function) { 3582 AsInitializerList = false; 3583 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args, 3584 CandidateSet, Ctors, Best, 3585 CopyInitialization, AllowExplicit, 3586 /*OnlyListConstructors=*/false, 3587 IsListInit); 3588 } 3589 if (Result) { 3590 Sequence.SetOverloadFailure(IsListInit ? 3591 InitializationSequence::FK_ListConstructorOverloadFailed : 3592 InitializationSequence::FK_ConstructorOverloadFailed, 3593 Result); 3594 return; 3595 } 3596 3597 // C++11 [dcl.init]p6: 3598 // If a program calls for the default initialization of an object 3599 // of a const-qualified type T, T shall be a class type with a 3600 // user-provided default constructor. 3601 // C++ core issue 253 proposal: 3602 // If the implicit default constructor initializes all subobjects, no 3603 // initializer should be required. 3604 // The 253 proposal is for example needed to process libstdc++ headers in 5.x. 3605 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function); 3606 if (Kind.getKind() == InitializationKind::IK_Default && 3607 Entity.getType().isConstQualified()) { 3608 if (!CtorDecl->getParent()->allowConstDefaultInit()) { 3609 if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity)) 3610 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst); 3611 return; 3612 } 3613 } 3614 3615 // C++11 [over.match.list]p1: 3616 // In copy-list-initialization, if an explicit constructor is chosen, the 3617 // initializer is ill-formed. 3618 if (IsListInit && !Kind.AllowExplicit() && CtorDecl->isExplicit()) { 3619 Sequence.SetFailed(InitializationSequence::FK_ExplicitConstructor); 3620 return; 3621 } 3622 3623 // Add the constructor initialization step. Any cv-qualification conversion is 3624 // subsumed by the initialization. 3625 bool HadMultipleCandidates = (CandidateSet.size() > 1); 3626 Sequence.AddConstructorInitializationStep( 3627 Best->FoundDecl, CtorDecl, DestType, HadMultipleCandidates, 3628 IsListInit | IsInitListCopy, AsInitializerList); 3629 } 3630 3631 static bool 3632 ResolveOverloadedFunctionForReferenceBinding(Sema &S, 3633 Expr *Initializer, 3634 QualType &SourceType, 3635 QualType &UnqualifiedSourceType, 3636 QualType UnqualifiedTargetType, 3637 InitializationSequence &Sequence) { 3638 if (S.Context.getCanonicalType(UnqualifiedSourceType) == 3639 S.Context.OverloadTy) { 3640 DeclAccessPair Found; 3641 bool HadMultipleCandidates = false; 3642 if (FunctionDecl *Fn 3643 = S.ResolveAddressOfOverloadedFunction(Initializer, 3644 UnqualifiedTargetType, 3645 false, Found, 3646 &HadMultipleCandidates)) { 3647 Sequence.AddAddressOverloadResolutionStep(Fn, Found, 3648 HadMultipleCandidates); 3649 SourceType = Fn->getType(); 3650 UnqualifiedSourceType = SourceType.getUnqualifiedType(); 3651 } else if (!UnqualifiedTargetType->isRecordType()) { 3652 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed); 3653 return true; 3654 } 3655 } 3656 return false; 3657 } 3658 3659 static void TryReferenceInitializationCore(Sema &S, 3660 const InitializedEntity &Entity, 3661 const InitializationKind &Kind, 3662 Expr *Initializer, 3663 QualType cv1T1, QualType T1, 3664 Qualifiers T1Quals, 3665 QualType cv2T2, QualType T2, 3666 Qualifiers T2Quals, 3667 InitializationSequence &Sequence); 3668 3669 static void TryValueInitialization(Sema &S, 3670 const InitializedEntity &Entity, 3671 const InitializationKind &Kind, 3672 InitializationSequence &Sequence, 3673 InitListExpr *InitList = nullptr); 3674 3675 /// \brief Attempt list initialization of a reference. 3676 static void TryReferenceListInitialization(Sema &S, 3677 const InitializedEntity &Entity, 3678 const InitializationKind &Kind, 3679 InitListExpr *InitList, 3680 InitializationSequence &Sequence, 3681 bool TreatUnavailableAsInvalid) { 3682 // First, catch C++03 where this isn't possible. 3683 if (!S.getLangOpts().CPlusPlus11) { 3684 Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList); 3685 return; 3686 } 3687 // Can't reference initialize a compound literal. 3688 if (Entity.getKind() == InitializedEntity::EK_CompoundLiteralInit) { 3689 Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList); 3690 return; 3691 } 3692 3693 QualType DestType = Entity.getType(); 3694 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType(); 3695 Qualifiers T1Quals; 3696 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals); 3697 3698 // Reference initialization via an initializer list works thus: 3699 // If the initializer list consists of a single element that is 3700 // reference-related to the referenced type, bind directly to that element 3701 // (possibly creating temporaries). 3702 // Otherwise, initialize a temporary with the initializer list and 3703 // bind to that. 3704 if (InitList->getNumInits() == 1) { 3705 Expr *Initializer = InitList->getInit(0); 3706 QualType cv2T2 = Initializer->getType(); 3707 Qualifiers T2Quals; 3708 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals); 3709 3710 // If this fails, creating a temporary wouldn't work either. 3711 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2, 3712 T1, Sequence)) 3713 return; 3714 3715 SourceLocation DeclLoc = Initializer->getLocStart(); 3716 bool dummy1, dummy2, dummy3; 3717 Sema::ReferenceCompareResult RefRelationship 3718 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1, 3719 dummy2, dummy3); 3720 if (RefRelationship >= Sema::Ref_Related) { 3721 // Try to bind the reference here. 3722 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1, 3723 T1Quals, cv2T2, T2, T2Quals, Sequence); 3724 if (Sequence) 3725 Sequence.RewrapReferenceInitList(cv1T1, InitList); 3726 return; 3727 } 3728 3729 // Update the initializer if we've resolved an overloaded function. 3730 if (Sequence.step_begin() != Sequence.step_end()) 3731 Sequence.RewrapReferenceInitList(cv1T1, InitList); 3732 } 3733 3734 // Not reference-related. Create a temporary and bind to that. 3735 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1); 3736 3737 TryListInitialization(S, TempEntity, Kind, InitList, Sequence, 3738 TreatUnavailableAsInvalid); 3739 if (Sequence) { 3740 if (DestType->isRValueReferenceType() || 3741 (T1Quals.hasConst() && !T1Quals.hasVolatile())) 3742 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true); 3743 else 3744 Sequence.SetFailed( 3745 InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary); 3746 } 3747 } 3748 3749 /// \brief Attempt list initialization (C++0x [dcl.init.list]) 3750 static void TryListInitialization(Sema &S, 3751 const InitializedEntity &Entity, 3752 const InitializationKind &Kind, 3753 InitListExpr *InitList, 3754 InitializationSequence &Sequence, 3755 bool TreatUnavailableAsInvalid) { 3756 QualType DestType = Entity.getType(); 3757 3758 // C++ doesn't allow scalar initialization with more than one argument. 3759 // But C99 complex numbers are scalars and it makes sense there. 3760 if (S.getLangOpts().CPlusPlus && DestType->isScalarType() && 3761 !DestType->isAnyComplexType() && InitList->getNumInits() > 1) { 3762 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForScalar); 3763 return; 3764 } 3765 if (DestType->isReferenceType()) { 3766 TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence, 3767 TreatUnavailableAsInvalid); 3768 return; 3769 } 3770 3771 if (DestType->isRecordType() && 3772 !S.isCompleteType(InitList->getLocStart(), DestType)) { 3773 Sequence.setIncompleteTypeFailure(DestType); 3774 return; 3775 } 3776 3777 // C++11 [dcl.init.list]p3, per DR1467: 3778 // - If T is a class type and the initializer list has a single element of 3779 // type cv U, where U is T or a class derived from T, the object is 3780 // initialized from that element (by copy-initialization for 3781 // copy-list-initialization, or by direct-initialization for 3782 // direct-list-initialization). 3783 // - Otherwise, if T is a character array and the initializer list has a 3784 // single element that is an appropriately-typed string literal 3785 // (8.5.2 [dcl.init.string]), initialization is performed as described 3786 // in that section. 3787 // - Otherwise, if T is an aggregate, [...] (continue below). 3788 if (S.getLangOpts().CPlusPlus11 && InitList->getNumInits() == 1) { 3789 if (DestType->isRecordType()) { 3790 QualType InitType = InitList->getInit(0)->getType(); 3791 if (S.Context.hasSameUnqualifiedType(InitType, DestType) || 3792 S.IsDerivedFrom(InitList->getLocStart(), InitType, DestType)) { 3793 Expr *InitAsExpr = InitList->getInit(0); 3794 TryConstructorInitialization(S, Entity, Kind, InitAsExpr, DestType, 3795 Sequence, /*InitListSyntax*/ false, 3796 /*IsInitListCopy*/ true); 3797 return; 3798 } 3799 } 3800 if (const ArrayType *DestAT = S.Context.getAsArrayType(DestType)) { 3801 Expr *SubInit[1] = {InitList->getInit(0)}; 3802 if (!isa<VariableArrayType>(DestAT) && 3803 IsStringInit(SubInit[0], DestAT, S.Context) == SIF_None) { 3804 InitializationKind SubKind = 3805 Kind.getKind() == InitializationKind::IK_DirectList 3806 ? InitializationKind::CreateDirect(Kind.getLocation(), 3807 InitList->getLBraceLoc(), 3808 InitList->getRBraceLoc()) 3809 : Kind; 3810 Sequence.InitializeFrom(S, Entity, SubKind, SubInit, 3811 /*TopLevelOfInitList*/ true, 3812 TreatUnavailableAsInvalid); 3813 3814 // TryStringLiteralInitialization() (in InitializeFrom()) will fail if 3815 // the element is not an appropriately-typed string literal, in which 3816 // case we should proceed as in C++11 (below). 3817 if (Sequence) { 3818 Sequence.RewrapReferenceInitList(Entity.getType(), InitList); 3819 return; 3820 } 3821 } 3822 } 3823 } 3824 3825 // C++11 [dcl.init.list]p3: 3826 // - If T is an aggregate, aggregate initialization is performed. 3827 if ((DestType->isRecordType() && !DestType->isAggregateType()) || 3828 (S.getLangOpts().CPlusPlus11 && 3829 S.isStdInitializerList(DestType, nullptr))) { 3830 if (S.getLangOpts().CPlusPlus11) { 3831 // - Otherwise, if the initializer list has no elements and T is a 3832 // class type with a default constructor, the object is 3833 // value-initialized. 3834 if (InitList->getNumInits() == 0) { 3835 CXXRecordDecl *RD = DestType->getAsCXXRecordDecl(); 3836 if (RD->hasDefaultConstructor()) { 3837 TryValueInitialization(S, Entity, Kind, Sequence, InitList); 3838 return; 3839 } 3840 } 3841 3842 // - Otherwise, if T is a specialization of std::initializer_list<E>, 3843 // an initializer_list object constructed [...] 3844 if (TryInitializerListConstruction(S, InitList, DestType, Sequence, 3845 TreatUnavailableAsInvalid)) 3846 return; 3847 3848 // - Otherwise, if T is a class type, constructors are considered. 3849 Expr *InitListAsExpr = InitList; 3850 TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType, 3851 Sequence, /*InitListSyntax*/ true); 3852 } else 3853 Sequence.SetFailed(InitializationSequence::FK_InitListBadDestinationType); 3854 return; 3855 } 3856 3857 if (S.getLangOpts().CPlusPlus && !DestType->isAggregateType() && 3858 InitList->getNumInits() == 1) { 3859 Expr *E = InitList->getInit(0); 3860 3861 // - Otherwise, if T is an enumeration with a fixed underlying type, 3862 // the initializer-list has a single element v, and the initialization 3863 // is direct-list-initialization, the object is initialized with the 3864 // value T(v); if a narrowing conversion is required to convert v to 3865 // the underlying type of T, the program is ill-formed. 3866 auto *ET = DestType->getAs<EnumType>(); 3867 if (S.getLangOpts().CPlusPlus1z && 3868 Kind.getKind() == InitializationKind::IK_DirectList && 3869 ET && ET->getDecl()->isFixed() && 3870 !S.Context.hasSameUnqualifiedType(E->getType(), DestType) && 3871 (E->getType()->isIntegralOrEnumerationType() || 3872 E->getType()->isFloatingType())) { 3873 // There are two ways that T(v) can work when T is an enumeration type. 3874 // If there is either an implicit conversion sequence from v to T or 3875 // a conversion function that can convert from v to T, then we use that. 3876 // Otherwise, if v is of integral, enumeration, or floating-point type, 3877 // it is converted to the enumeration type via its underlying type. 3878 // There is no overlap possible between these two cases (except when the 3879 // source value is already of the destination type), and the first 3880 // case is handled by the general case for single-element lists below. 3881 ImplicitConversionSequence ICS; 3882 ICS.setStandard(); 3883 ICS.Standard.setAsIdentityConversion(); 3884 // If E is of a floating-point type, then the conversion is ill-formed 3885 // due to narrowing, but go through the motions in order to produce the 3886 // right diagnostic. 3887 ICS.Standard.Second = E->getType()->isFloatingType() 3888 ? ICK_Floating_Integral 3889 : ICK_Integral_Conversion; 3890 ICS.Standard.setFromType(E->getType()); 3891 ICS.Standard.setToType(0, E->getType()); 3892 ICS.Standard.setToType(1, DestType); 3893 ICS.Standard.setToType(2, DestType); 3894 Sequence.AddConversionSequenceStep(ICS, ICS.Standard.getToType(2), 3895 /*TopLevelOfInitList*/true); 3896 Sequence.RewrapReferenceInitList(Entity.getType(), InitList); 3897 return; 3898 } 3899 3900 // - Otherwise, if the initializer list has a single element of type E 3901 // [...references are handled above...], the object or reference is 3902 // initialized from that element (by copy-initialization for 3903 // copy-list-initialization, or by direct-initialization for 3904 // direct-list-initialization); if a narrowing conversion is required 3905 // to convert the element to T, the program is ill-formed. 3906 // 3907 // Per core-24034, this is direct-initialization if we were performing 3908 // direct-list-initialization and copy-initialization otherwise. 3909 // We can't use InitListChecker for this, because it always performs 3910 // copy-initialization. This only matters if we might use an 'explicit' 3911 // conversion operator, so we only need to handle the cases where the source 3912 // is of record type. 3913 if (InitList->getInit(0)->getType()->isRecordType()) { 3914 InitializationKind SubKind = 3915 Kind.getKind() == InitializationKind::IK_DirectList 3916 ? InitializationKind::CreateDirect(Kind.getLocation(), 3917 InitList->getLBraceLoc(), 3918 InitList->getRBraceLoc()) 3919 : Kind; 3920 Expr *SubInit[1] = { InitList->getInit(0) }; 3921 Sequence.InitializeFrom(S, Entity, SubKind, SubInit, 3922 /*TopLevelOfInitList*/true, 3923 TreatUnavailableAsInvalid); 3924 if (Sequence) 3925 Sequence.RewrapReferenceInitList(Entity.getType(), InitList); 3926 return; 3927 } 3928 } 3929 3930 InitListChecker CheckInitList(S, Entity, InitList, 3931 DestType, /*VerifyOnly=*/true, TreatUnavailableAsInvalid); 3932 if (CheckInitList.HadError()) { 3933 Sequence.SetFailed(InitializationSequence::FK_ListInitializationFailed); 3934 return; 3935 } 3936 3937 // Add the list initialization step with the built init list. 3938 Sequence.AddListInitializationStep(DestType); 3939 } 3940 3941 /// \brief Try a reference initialization that involves calling a conversion 3942 /// function. 3943 static OverloadingResult TryRefInitWithConversionFunction(Sema &S, 3944 const InitializedEntity &Entity, 3945 const InitializationKind &Kind, 3946 Expr *Initializer, 3947 bool AllowRValues, 3948 InitializationSequence &Sequence) { 3949 QualType DestType = Entity.getType(); 3950 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType(); 3951 QualType T1 = cv1T1.getUnqualifiedType(); 3952 QualType cv2T2 = Initializer->getType(); 3953 QualType T2 = cv2T2.getUnqualifiedType(); 3954 3955 bool DerivedToBase; 3956 bool ObjCConversion; 3957 bool ObjCLifetimeConversion; 3958 assert(!S.CompareReferenceRelationship(Initializer->getLocStart(), 3959 T1, T2, DerivedToBase, 3960 ObjCConversion, 3961 ObjCLifetimeConversion) && 3962 "Must have incompatible references when binding via conversion"); 3963 (void)DerivedToBase; 3964 (void)ObjCConversion; 3965 (void)ObjCLifetimeConversion; 3966 3967 // Build the candidate set directly in the initialization sequence 3968 // structure, so that it will persist if we fail. 3969 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet(); 3970 CandidateSet.clear(); 3971 3972 // Determine whether we are allowed to call explicit constructors or 3973 // explicit conversion operators. 3974 bool AllowExplicit = Kind.AllowExplicit(); 3975 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding(); 3976 3977 const RecordType *T1RecordType = nullptr; 3978 if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) && 3979 S.isCompleteType(Kind.getLocation(), T1)) { 3980 // The type we're converting to is a class type. Enumerate its constructors 3981 // to see if there is a suitable conversion. 3982 CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl()); 3983 3984 for (NamedDecl *D : S.LookupConstructors(T1RecordDecl)) { 3985 auto Info = getConstructorInfo(D); 3986 if (!Info.Constructor) 3987 continue; 3988 3989 if (!Info.Constructor->isInvalidDecl() && 3990 Info.Constructor->isConvertingConstructor(AllowExplicit)) { 3991 if (Info.ConstructorTmpl) 3992 S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl, 3993 /*ExplicitArgs*/ nullptr, 3994 Initializer, CandidateSet, 3995 /*SuppressUserConversions=*/true); 3996 else 3997 S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, 3998 Initializer, CandidateSet, 3999 /*SuppressUserConversions=*/true); 4000 } 4001 } 4002 } 4003 if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl()) 4004 return OR_No_Viable_Function; 4005 4006 const RecordType *T2RecordType = nullptr; 4007 if ((T2RecordType = T2->getAs<RecordType>()) && 4008 S.isCompleteType(Kind.getLocation(), T2)) { 4009 // The type we're converting from is a class type, enumerate its conversion 4010 // functions. 4011 CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl()); 4012 4013 const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions(); 4014 for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) { 4015 NamedDecl *D = *I; 4016 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext()); 4017 if (isa<UsingShadowDecl>(D)) 4018 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 4019 4020 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D); 4021 CXXConversionDecl *Conv; 4022 if (ConvTemplate) 4023 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 4024 else 4025 Conv = cast<CXXConversionDecl>(D); 4026 4027 // If the conversion function doesn't return a reference type, 4028 // it can't be considered for this conversion unless we're allowed to 4029 // consider rvalues. 4030 // FIXME: Do we need to make sure that we only consider conversion 4031 // candidates with reference-compatible results? That might be needed to 4032 // break recursion. 4033 if ((AllowExplicitConvs || !Conv->isExplicit()) && 4034 (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){ 4035 if (ConvTemplate) 4036 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(), 4037 ActingDC, Initializer, 4038 DestType, CandidateSet, 4039 /*AllowObjCConversionOnExplicit=*/ 4040 false); 4041 else 4042 S.AddConversionCandidate(Conv, I.getPair(), ActingDC, 4043 Initializer, DestType, CandidateSet, 4044 /*AllowObjCConversionOnExplicit=*/false); 4045 } 4046 } 4047 } 4048 if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl()) 4049 return OR_No_Viable_Function; 4050 4051 SourceLocation DeclLoc = Initializer->getLocStart(); 4052 4053 // Perform overload resolution. If it fails, return the failed result. 4054 OverloadCandidateSet::iterator Best; 4055 if (OverloadingResult Result 4056 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) 4057 return Result; 4058 4059 FunctionDecl *Function = Best->Function; 4060 // This is the overload that will be used for this initialization step if we 4061 // use this initialization. Mark it as referenced. 4062 Function->setReferenced(); 4063 4064 // Compute the returned type of the conversion. 4065 if (isa<CXXConversionDecl>(Function)) 4066 T2 = Function->getReturnType(); 4067 else 4068 T2 = cv1T1; 4069 4070 // Add the user-defined conversion step. 4071 bool HadMultipleCandidates = (CandidateSet.size() > 1); 4072 Sequence.AddUserConversionStep(Function, Best->FoundDecl, 4073 T2.getNonLValueExprType(S.Context), 4074 HadMultipleCandidates); 4075 4076 // Determine whether we need to perform derived-to-base or 4077 // cv-qualification adjustments. 4078 ExprValueKind VK = VK_RValue; 4079 if (T2->isLValueReferenceType()) 4080 VK = VK_LValue; 4081 else if (const RValueReferenceType *RRef = T2->getAs<RValueReferenceType>()) 4082 VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue; 4083 4084 bool NewDerivedToBase = false; 4085 bool NewObjCConversion = false; 4086 bool NewObjCLifetimeConversion = false; 4087 Sema::ReferenceCompareResult NewRefRelationship 4088 = S.CompareReferenceRelationship(DeclLoc, T1, 4089 T2.getNonLValueExprType(S.Context), 4090 NewDerivedToBase, NewObjCConversion, 4091 NewObjCLifetimeConversion); 4092 if (NewRefRelationship == Sema::Ref_Incompatible) { 4093 // If the type we've converted to is not reference-related to the 4094 // type we're looking for, then there is another conversion step 4095 // we need to perform to produce a temporary of the right type 4096 // that we'll be binding to. 4097 ImplicitConversionSequence ICS; 4098 ICS.setStandard(); 4099 ICS.Standard = Best->FinalConversion; 4100 T2 = ICS.Standard.getToType(2); 4101 Sequence.AddConversionSequenceStep(ICS, T2); 4102 } else if (NewDerivedToBase) 4103 Sequence.AddDerivedToBaseCastStep( 4104 S.Context.getQualifiedType(T1, 4105 T2.getNonReferenceType().getQualifiers()), 4106 VK); 4107 else if (NewObjCConversion) 4108 Sequence.AddObjCObjectConversionStep( 4109 S.Context.getQualifiedType(T1, 4110 T2.getNonReferenceType().getQualifiers())); 4111 4112 if (cv1T1.getQualifiers() != T2.getNonReferenceType().getQualifiers()) 4113 Sequence.AddQualificationConversionStep(cv1T1, VK); 4114 4115 Sequence.AddReferenceBindingStep(cv1T1, !T2->isReferenceType()); 4116 return OR_Success; 4117 } 4118 4119 static void CheckCXX98CompatAccessibleCopy(Sema &S, 4120 const InitializedEntity &Entity, 4121 Expr *CurInitExpr); 4122 4123 /// \brief Attempt reference initialization (C++0x [dcl.init.ref]) 4124 static void TryReferenceInitialization(Sema &S, 4125 const InitializedEntity &Entity, 4126 const InitializationKind &Kind, 4127 Expr *Initializer, 4128 InitializationSequence &Sequence) { 4129 QualType DestType = Entity.getType(); 4130 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType(); 4131 Qualifiers T1Quals; 4132 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals); 4133 QualType cv2T2 = Initializer->getType(); 4134 Qualifiers T2Quals; 4135 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals); 4136 4137 // If the initializer is the address of an overloaded function, try 4138 // to resolve the overloaded function. If all goes well, T2 is the 4139 // type of the resulting function. 4140 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2, 4141 T1, Sequence)) 4142 return; 4143 4144 // Delegate everything else to a subfunction. 4145 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1, 4146 T1Quals, cv2T2, T2, T2Quals, Sequence); 4147 } 4148 4149 /// Converts the target of reference initialization so that it has the 4150 /// appropriate qualifiers and value kind. 4151 /// 4152 /// In this case, 'x' is an 'int' lvalue, but it needs to be 'const int'. 4153 /// \code 4154 /// int x; 4155 /// const int &r = x; 4156 /// \endcode 4157 /// 4158 /// In this case the reference is binding to a bitfield lvalue, which isn't 4159 /// valid. Perform a load to create a lifetime-extended temporary instead. 4160 /// \code 4161 /// const int &r = someStruct.bitfield; 4162 /// \endcode 4163 static ExprValueKind 4164 convertQualifiersAndValueKindIfNecessary(Sema &S, 4165 InitializationSequence &Sequence, 4166 Expr *Initializer, 4167 QualType cv1T1, 4168 Qualifiers T1Quals, 4169 Qualifiers T2Quals, 4170 bool IsLValueRef) { 4171 bool IsNonAddressableType = Initializer->refersToBitField() || 4172 Initializer->refersToVectorElement(); 4173 4174 if (IsNonAddressableType) { 4175 // C++11 [dcl.init.ref]p5: [...] Otherwise, the reference shall be an 4176 // lvalue reference to a non-volatile const type, or the reference shall be 4177 // an rvalue reference. 4178 // 4179 // If not, we can't make a temporary and bind to that. Give up and allow the 4180 // error to be diagnosed later. 4181 if (IsLValueRef && (!T1Quals.hasConst() || T1Quals.hasVolatile())) { 4182 assert(Initializer->isGLValue()); 4183 return Initializer->getValueKind(); 4184 } 4185 4186 // Force a load so we can materialize a temporary. 4187 Sequence.AddLValueToRValueStep(cv1T1.getUnqualifiedType()); 4188 return VK_RValue; 4189 } 4190 4191 if (T1Quals != T2Quals) { 4192 Sequence.AddQualificationConversionStep(cv1T1, 4193 Initializer->getValueKind()); 4194 } 4195 4196 return Initializer->getValueKind(); 4197 } 4198 4199 /// \brief Reference initialization without resolving overloaded functions. 4200 static void TryReferenceInitializationCore(Sema &S, 4201 const InitializedEntity &Entity, 4202 const InitializationKind &Kind, 4203 Expr *Initializer, 4204 QualType cv1T1, QualType T1, 4205 Qualifiers T1Quals, 4206 QualType cv2T2, QualType T2, 4207 Qualifiers T2Quals, 4208 InitializationSequence &Sequence) { 4209 QualType DestType = Entity.getType(); 4210 SourceLocation DeclLoc = Initializer->getLocStart(); 4211 // Compute some basic properties of the types and the initializer. 4212 bool isLValueRef = DestType->isLValueReferenceType(); 4213 bool isRValueRef = !isLValueRef; 4214 bool DerivedToBase = false; 4215 bool ObjCConversion = false; 4216 bool ObjCLifetimeConversion = false; 4217 Expr::Classification InitCategory = Initializer->Classify(S.Context); 4218 Sema::ReferenceCompareResult RefRelationship 4219 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase, 4220 ObjCConversion, ObjCLifetimeConversion); 4221 4222 // C++0x [dcl.init.ref]p5: 4223 // A reference to type "cv1 T1" is initialized by an expression of type 4224 // "cv2 T2" as follows: 4225 // 4226 // - If the reference is an lvalue reference and the initializer 4227 // expression 4228 // Note the analogous bullet points for rvalue refs to functions. Because 4229 // there are no function rvalues in C++, rvalue refs to functions are treated 4230 // like lvalue refs. 4231 OverloadingResult ConvOvlResult = OR_Success; 4232 bool T1Function = T1->isFunctionType(); 4233 if (isLValueRef || T1Function) { 4234 if (InitCategory.isLValue() && 4235 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification || 4236 (Kind.isCStyleOrFunctionalCast() && 4237 RefRelationship == Sema::Ref_Related))) { 4238 // - is an lvalue (but is not a bit-field), and "cv1 T1" is 4239 // reference-compatible with "cv2 T2," or 4240 // 4241 // Per C++ [over.best.ics]p2, we don't diagnose whether the lvalue is a 4242 // bit-field when we're determining whether the reference initialization 4243 // can occur. However, we do pay attention to whether it is a bit-field 4244 // to decide whether we're actually binding to a temporary created from 4245 // the bit-field. 4246 if (DerivedToBase) 4247 Sequence.AddDerivedToBaseCastStep( 4248 S.Context.getQualifiedType(T1, T2Quals), 4249 VK_LValue); 4250 else if (ObjCConversion) 4251 Sequence.AddObjCObjectConversionStep( 4252 S.Context.getQualifiedType(T1, T2Quals)); 4253 4254 ExprValueKind ValueKind = 4255 convertQualifiersAndValueKindIfNecessary(S, Sequence, Initializer, 4256 cv1T1, T1Quals, T2Quals, 4257 isLValueRef); 4258 Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue); 4259 return; 4260 } 4261 4262 // - has a class type (i.e., T2 is a class type), where T1 is not 4263 // reference-related to T2, and can be implicitly converted to an 4264 // lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible 4265 // with "cv3 T3" (this conversion is selected by enumerating the 4266 // applicable conversion functions (13.3.1.6) and choosing the best 4267 // one through overload resolution (13.3)), 4268 // If we have an rvalue ref to function type here, the rhs must be 4269 // an rvalue. DR1287 removed the "implicitly" here. 4270 if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() && 4271 (isLValueRef || InitCategory.isRValue())) { 4272 ConvOvlResult = TryRefInitWithConversionFunction( 4273 S, Entity, Kind, Initializer, /*AllowRValues*/isRValueRef, Sequence); 4274 if (ConvOvlResult == OR_Success) 4275 return; 4276 if (ConvOvlResult != OR_No_Viable_Function) 4277 Sequence.SetOverloadFailure( 4278 InitializationSequence::FK_ReferenceInitOverloadFailed, 4279 ConvOvlResult); 4280 } 4281 } 4282 4283 // - Otherwise, the reference shall be an lvalue reference to a 4284 // non-volatile const type (i.e., cv1 shall be const), or the reference 4285 // shall be an rvalue reference. 4286 if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) { 4287 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) 4288 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed); 4289 else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty()) 4290 Sequence.SetOverloadFailure( 4291 InitializationSequence::FK_ReferenceInitOverloadFailed, 4292 ConvOvlResult); 4293 else 4294 Sequence.SetFailed(InitCategory.isLValue() 4295 ? (RefRelationship == Sema::Ref_Related 4296 ? InitializationSequence::FK_ReferenceInitDropsQualifiers 4297 : InitializationSequence::FK_NonConstLValueReferenceBindingToUnrelated) 4298 : InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary); 4299 4300 return; 4301 } 4302 4303 // - If the initializer expression 4304 // - is an xvalue, class prvalue, array prvalue, or function lvalue and 4305 // "cv1 T1" is reference-compatible with "cv2 T2" 4306 // Note: functions are handled below. 4307 if (!T1Function && 4308 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification || 4309 (Kind.isCStyleOrFunctionalCast() && 4310 RefRelationship == Sema::Ref_Related)) && 4311 (InitCategory.isXValue() || 4312 (InitCategory.isPRValue() && T2->isRecordType()) || 4313 (InitCategory.isPRValue() && T2->isArrayType()))) { 4314 ExprValueKind ValueKind = InitCategory.isXValue()? VK_XValue : VK_RValue; 4315 if (InitCategory.isPRValue() && T2->isRecordType()) { 4316 // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the 4317 // compiler the freedom to perform a copy here or bind to the 4318 // object, while C++0x requires that we bind directly to the 4319 // object. Hence, we always bind to the object without making an 4320 // extra copy. However, in C++03 requires that we check for the 4321 // presence of a suitable copy constructor: 4322 // 4323 // The constructor that would be used to make the copy shall 4324 // be callable whether or not the copy is actually done. 4325 if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt) 4326 Sequence.AddExtraneousCopyToTemporary(cv2T2); 4327 else if (S.getLangOpts().CPlusPlus11) 4328 CheckCXX98CompatAccessibleCopy(S, Entity, Initializer); 4329 } 4330 4331 if (DerivedToBase) 4332 Sequence.AddDerivedToBaseCastStep(S.Context.getQualifiedType(T1, T2Quals), 4333 ValueKind); 4334 else if (ObjCConversion) 4335 Sequence.AddObjCObjectConversionStep( 4336 S.Context.getQualifiedType(T1, T2Quals)); 4337 4338 ValueKind = convertQualifiersAndValueKindIfNecessary(S, Sequence, 4339 Initializer, cv1T1, 4340 T1Quals, T2Quals, 4341 isLValueRef); 4342 4343 Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue); 4344 return; 4345 } 4346 4347 // - has a class type (i.e., T2 is a class type), where T1 is not 4348 // reference-related to T2, and can be implicitly converted to an 4349 // xvalue, class prvalue, or function lvalue of type "cv3 T3", 4350 // where "cv1 T1" is reference-compatible with "cv3 T3", 4351 // 4352 // DR1287 removes the "implicitly" here. 4353 if (T2->isRecordType()) { 4354 if (RefRelationship == Sema::Ref_Incompatible) { 4355 ConvOvlResult = TryRefInitWithConversionFunction( 4356 S, Entity, Kind, Initializer, /*AllowRValues*/true, Sequence); 4357 if (ConvOvlResult) 4358 Sequence.SetOverloadFailure( 4359 InitializationSequence::FK_ReferenceInitOverloadFailed, 4360 ConvOvlResult); 4361 4362 return; 4363 } 4364 4365 if ((RefRelationship == Sema::Ref_Compatible || 4366 RefRelationship == Sema::Ref_Compatible_With_Added_Qualification) && 4367 isRValueRef && InitCategory.isLValue()) { 4368 Sequence.SetFailed( 4369 InitializationSequence::FK_RValueReferenceBindingToLValue); 4370 return; 4371 } 4372 4373 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers); 4374 return; 4375 } 4376 4377 // - Otherwise, a temporary of type "cv1 T1" is created and initialized 4378 // from the initializer expression using the rules for a non-reference 4379 // copy-initialization (8.5). The reference is then bound to the 4380 // temporary. [...] 4381 4382 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1); 4383 4384 // FIXME: Why do we use an implicit conversion here rather than trying 4385 // copy-initialization? 4386 ImplicitConversionSequence ICS 4387 = S.TryImplicitConversion(Initializer, TempEntity.getType(), 4388 /*SuppressUserConversions=*/false, 4389 /*AllowExplicit=*/false, 4390 /*FIXME:InOverloadResolution=*/false, 4391 /*CStyle=*/Kind.isCStyleOrFunctionalCast(), 4392 /*AllowObjCWritebackConversion=*/false); 4393 4394 if (ICS.isBad()) { 4395 // FIXME: Use the conversion function set stored in ICS to turn 4396 // this into an overloading ambiguity diagnostic. However, we need 4397 // to keep that set as an OverloadCandidateSet rather than as some 4398 // other kind of set. 4399 if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty()) 4400 Sequence.SetOverloadFailure( 4401 InitializationSequence::FK_ReferenceInitOverloadFailed, 4402 ConvOvlResult); 4403 else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) 4404 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed); 4405 else 4406 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitFailed); 4407 return; 4408 } else { 4409 Sequence.AddConversionSequenceStep(ICS, TempEntity.getType()); 4410 } 4411 4412 // [...] If T1 is reference-related to T2, cv1 must be the 4413 // same cv-qualification as, or greater cv-qualification 4414 // than, cv2; otherwise, the program is ill-formed. 4415 unsigned T1CVRQuals = T1Quals.getCVRQualifiers(); 4416 unsigned T2CVRQuals = T2Quals.getCVRQualifiers(); 4417 if (RefRelationship == Sema::Ref_Related && 4418 (T1CVRQuals | T2CVRQuals) != T1CVRQuals) { 4419 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers); 4420 return; 4421 } 4422 4423 // [...] If T1 is reference-related to T2 and the reference is an rvalue 4424 // reference, the initializer expression shall not be an lvalue. 4425 if (RefRelationship >= Sema::Ref_Related && !isLValueRef && 4426 InitCategory.isLValue()) { 4427 Sequence.SetFailed( 4428 InitializationSequence::FK_RValueReferenceBindingToLValue); 4429 return; 4430 } 4431 4432 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true); 4433 } 4434 4435 /// \brief Attempt character array initialization from a string literal 4436 /// (C++ [dcl.init.string], C99 6.7.8). 4437 static void TryStringLiteralInitialization(Sema &S, 4438 const InitializedEntity &Entity, 4439 const InitializationKind &Kind, 4440 Expr *Initializer, 4441 InitializationSequence &Sequence) { 4442 Sequence.AddStringInitStep(Entity.getType()); 4443 } 4444 4445 /// \brief Attempt value initialization (C++ [dcl.init]p7). 4446 static void TryValueInitialization(Sema &S, 4447 const InitializedEntity &Entity, 4448 const InitializationKind &Kind, 4449 InitializationSequence &Sequence, 4450 InitListExpr *InitList) { 4451 assert((!InitList || InitList->getNumInits() == 0) && 4452 "Shouldn't use value-init for non-empty init lists"); 4453 4454 // C++98 [dcl.init]p5, C++11 [dcl.init]p7: 4455 // 4456 // To value-initialize an object of type T means: 4457 QualType T = Entity.getType(); 4458 4459