SemaInit.cpp revision e85f43d31101a875a6621e43bde21dcc13d860ff
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. The main entry 11// point is Sema::CheckInitList(), but all of the work is performed 12// within the InitListChecker class. 13// 14// This file also implements Sema::CheckInitializerTypes. 15// 16//===----------------------------------------------------------------------===// 17 18#include "Sema.h" 19#include "clang/Parse/Designator.h" 20#include "clang/AST/ASTContext.h" 21#include "clang/AST/ExprCXX.h" 22#include "clang/AST/ExprObjC.h" 23#include <map> 24using namespace clang; 25 26//===----------------------------------------------------------------------===// 27// Sema Initialization Checking 28//===----------------------------------------------------------------------===// 29 30static Expr *IsStringInit(Expr *Init, QualType DeclType, ASTContext &Context) { 31 const ArrayType *AT = Context.getAsArrayType(DeclType); 32 if (!AT) return 0; 33 34 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT)) 35 return 0; 36 37 // See if this is a string literal or @encode. 38 Init = Init->IgnoreParens(); 39 40 // Handle @encode, which is a narrow string. 41 if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType()) 42 return Init; 43 44 // Otherwise we can only handle string literals. 45 StringLiteral *SL = dyn_cast<StringLiteral>(Init); 46 if (SL == 0) return 0; 47 48 QualType ElemTy = Context.getCanonicalType(AT->getElementType()); 49 // char array can be initialized with a narrow string. 50 // Only allow char x[] = "foo"; not char x[] = L"foo"; 51 if (!SL->isWide()) 52 return ElemTy->isCharType() ? Init : 0; 53 54 // wchar_t array can be initialized with a wide string: C99 6.7.8p15 (with 55 // correction from DR343): "An array with element type compatible with a 56 // qualified or unqualified version of wchar_t may be initialized by a wide 57 // string literal, optionally enclosed in braces." 58 if (Context.typesAreCompatible(Context.getWCharType(), 59 ElemTy.getUnqualifiedType())) 60 return Init; 61 62 return 0; 63} 64 65static bool CheckSingleInitializer(Expr *&Init, QualType DeclType, 66 bool DirectInit, Sema &S) { 67 // Get the type before calling CheckSingleAssignmentConstraints(), since 68 // it can promote the expression. 69 QualType InitType = Init->getType(); 70 71 if (S.getLangOptions().CPlusPlus) { 72 // FIXME: I dislike this error message. A lot. 73 if (S.PerformImplicitConversion(Init, DeclType, "initializing", DirectInit)) 74 return S.Diag(Init->getSourceRange().getBegin(), 75 diag::err_typecheck_convert_incompatible) 76 << DeclType << Init->getType() << "initializing" 77 << Init->getSourceRange(); 78 return false; 79 } 80 81 Sema::AssignConvertType ConvTy = 82 S.CheckSingleAssignmentConstraints(DeclType, Init); 83 return S.DiagnoseAssignmentResult(ConvTy, Init->getLocStart(), DeclType, 84 InitType, Init, "initializing"); 85} 86 87static void CheckStringInit(Expr *Str, QualType &DeclT, Sema &S) { 88 // Get the length of the string as parsed. 89 uint64_t StrLength = 90 cast<ConstantArrayType>(Str->getType())->getSize().getZExtValue(); 91 92 93 const ArrayType *AT = S.Context.getAsArrayType(DeclT); 94 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 95 // C99 6.7.8p14. We have an array of character type with unknown size 96 // being initialized to a string literal. 97 llvm::APSInt ConstVal(32); 98 ConstVal = StrLength; 99 // Return a new array type (C99 6.7.8p22). 100 DeclT = S.Context.getConstantArrayWithoutExprType(IAT->getElementType(), 101 ConstVal, 102 ArrayType::Normal, 0); 103 return; 104 } 105 106 const ConstantArrayType *CAT = cast<ConstantArrayType>(AT); 107 108 // C99 6.7.8p14. We have an array of character type with known size. However, 109 // the size may be smaller or larger than the string we are initializing. 110 // FIXME: Avoid truncation for 64-bit length strings. 111 if (StrLength-1 > CAT->getSize().getZExtValue()) 112 S.Diag(Str->getSourceRange().getBegin(), 113 diag::warn_initializer_string_for_char_array_too_long) 114 << Str->getSourceRange(); 115 116 // Set the type to the actual size that we are initializing. If we have 117 // something like: 118 // char x[1] = "foo"; 119 // then this will set the string literal's type to char[1]. 120 Str->setType(DeclT); 121} 122 123bool Sema::CheckInitializerTypes(Expr *&Init, QualType &DeclType, 124 SourceLocation InitLoc, 125 DeclarationName InitEntity, bool DirectInit) { 126 if (DeclType->isDependentType() || 127 Init->isTypeDependent() || Init->isValueDependent()) 128 return false; 129 130 // C++ [dcl.init.ref]p1: 131 // A variable declared to be a T& or T&&, that is "reference to type T" 132 // (8.3.2), shall be initialized by an object, or function, of 133 // type T or by an object that can be converted into a T. 134 if (DeclType->isReferenceType()) 135 return CheckReferenceInit(Init, DeclType, 0, false, DirectInit); 136 137 // C99 6.7.8p3: The type of the entity to be initialized shall be an array 138 // of unknown size ("[]") or an object type that is not a variable array type. 139 if (const VariableArrayType *VAT = Context.getAsVariableArrayType(DeclType)) 140 return Diag(InitLoc, diag::err_variable_object_no_init) 141 << VAT->getSizeExpr()->getSourceRange(); 142 143 InitListExpr *InitList = dyn_cast<InitListExpr>(Init); 144 if (!InitList) { 145 // FIXME: Handle wide strings 146 if (Expr *Str = IsStringInit(Init, DeclType, Context)) { 147 CheckStringInit(Str, DeclType, *this); 148 return false; 149 } 150 151 // C++ [dcl.init]p14: 152 // -- If the destination type is a (possibly cv-qualified) class 153 // type: 154 if (getLangOptions().CPlusPlus && DeclType->isRecordType()) { 155 QualType DeclTypeC = Context.getCanonicalType(DeclType); 156 QualType InitTypeC = Context.getCanonicalType(Init->getType()); 157 158 // -- If the initialization is direct-initialization, or if it is 159 // copy-initialization where the cv-unqualified version of the 160 // source type is the same class as, or a derived class of, the 161 // class of the destination, constructors are considered. 162 if ((DeclTypeC.getUnqualifiedType() == InitTypeC.getUnqualifiedType()) || 163 IsDerivedFrom(InitTypeC, DeclTypeC)) { 164 const CXXRecordDecl *RD = 165 cast<CXXRecordDecl>(DeclType->getAs<RecordType>()->getDecl()); 166 167 // No need to make a CXXConstructExpr if both the ctor and dtor are 168 // trivial. 169 if (RD->hasTrivialConstructor() && RD->hasTrivialDestructor()) 170 return false; 171 172 CXXConstructorDecl *Constructor 173 = PerformInitializationByConstructor(DeclType, &Init, 1, 174 InitLoc, Init->getSourceRange(), 175 InitEntity, 176 DirectInit? IK_Direct : IK_Copy); 177 if (!Constructor) 178 return true; 179 bool Elidable = (isa<CallExpr>(Init) || 180 isa<CXXTemporaryObjectExpr>(Init)); 181 Init = BuildCXXConstructExpr(Context, 182 DeclType, Constructor, Elidable, &Init, 1); 183 Init = MaybeCreateCXXExprWithTemporaries(Init, /*DestroyTemps=*/true); 184 return false; 185 } 186 187 // -- Otherwise (i.e., for the remaining copy-initialization 188 // cases), user-defined conversion sequences that can 189 // convert from the source type to the destination type or 190 // (when a conversion function is used) to a derived class 191 // thereof are enumerated as described in 13.3.1.4, and the 192 // best one is chosen through overload resolution 193 // (13.3). If the conversion cannot be done or is 194 // ambiguous, the initialization is ill-formed. The 195 // function selected is called with the initializer 196 // expression as its argument; if the function is a 197 // constructor, the call initializes a temporary of the 198 // destination type. 199 // FIXME: We're pretending to do copy elision here; return to this when we 200 // have ASTs for such things. 201 if (!PerformImplicitConversion(Init, DeclType, "initializing")) 202 return false; 203 204 if (InitEntity) 205 return Diag(InitLoc, diag::err_cannot_initialize_decl) 206 << InitEntity << (int)(Init->isLvalue(Context) == Expr::LV_Valid) 207 << Init->getType() << Init->getSourceRange(); 208 return Diag(InitLoc, diag::err_cannot_initialize_decl_noname) 209 << DeclType << (int)(Init->isLvalue(Context) == Expr::LV_Valid) 210 << Init->getType() << Init->getSourceRange(); 211 } 212 213 // C99 6.7.8p16. 214 if (DeclType->isArrayType()) 215 return Diag(Init->getLocStart(), diag::err_array_init_list_required) 216 << Init->getSourceRange(); 217 218 return CheckSingleInitializer(Init, DeclType, DirectInit, *this); 219 } 220 221 bool hadError = CheckInitList(InitList, DeclType); 222 Init = InitList; 223 return hadError; 224} 225 226//===----------------------------------------------------------------------===// 227// Semantic checking for initializer lists. 228//===----------------------------------------------------------------------===// 229 230/// @brief Semantic checking for initializer lists. 231/// 232/// The InitListChecker class contains a set of routines that each 233/// handle the initialization of a certain kind of entity, e.g., 234/// arrays, vectors, struct/union types, scalars, etc. The 235/// InitListChecker itself performs a recursive walk of the subobject 236/// structure of the type to be initialized, while stepping through 237/// the initializer list one element at a time. The IList and Index 238/// parameters to each of the Check* routines contain the active 239/// (syntactic) initializer list and the index into that initializer 240/// list that represents the current initializer. Each routine is 241/// responsible for moving that Index forward as it consumes elements. 242/// 243/// Each Check* routine also has a StructuredList/StructuredIndex 244/// arguments, which contains the current the "structured" (semantic) 245/// initializer list and the index into that initializer list where we 246/// are copying initializers as we map them over to the semantic 247/// list. Once we have completed our recursive walk of the subobject 248/// structure, we will have constructed a full semantic initializer 249/// list. 250/// 251/// C99 designators cause changes in the initializer list traversal, 252/// because they make the initialization "jump" into a specific 253/// subobject and then continue the initialization from that 254/// point. CheckDesignatedInitializer() recursively steps into the 255/// designated subobject and manages backing out the recursion to 256/// initialize the subobjects after the one designated. 257namespace { 258class InitListChecker { 259 Sema &SemaRef; 260 bool hadError; 261 std::map<InitListExpr *, InitListExpr *> SyntacticToSemantic; 262 InitListExpr *FullyStructuredList; 263 264 void CheckImplicitInitList(InitListExpr *ParentIList, QualType T, 265 unsigned &Index, InitListExpr *StructuredList, 266 unsigned &StructuredIndex, 267 bool TopLevelObject = false); 268 void CheckExplicitInitList(InitListExpr *IList, QualType &T, 269 unsigned &Index, InitListExpr *StructuredList, 270 unsigned &StructuredIndex, 271 bool TopLevelObject = false); 272 void CheckListElementTypes(InitListExpr *IList, QualType &DeclType, 273 bool SubobjectIsDesignatorContext, 274 unsigned &Index, 275 InitListExpr *StructuredList, 276 unsigned &StructuredIndex, 277 bool TopLevelObject = false); 278 void CheckSubElementType(InitListExpr *IList, QualType ElemType, 279 unsigned &Index, 280 InitListExpr *StructuredList, 281 unsigned &StructuredIndex); 282 void CheckScalarType(InitListExpr *IList, QualType DeclType, 283 unsigned &Index, 284 InitListExpr *StructuredList, 285 unsigned &StructuredIndex); 286 void CheckReferenceType(InitListExpr *IList, QualType DeclType, 287 unsigned &Index, 288 InitListExpr *StructuredList, 289 unsigned &StructuredIndex); 290 void CheckVectorType(InitListExpr *IList, QualType DeclType, unsigned &Index, 291 InitListExpr *StructuredList, 292 unsigned &StructuredIndex); 293 void CheckStructUnionTypes(InitListExpr *IList, QualType DeclType, 294 RecordDecl::field_iterator Field, 295 bool SubobjectIsDesignatorContext, unsigned &Index, 296 InitListExpr *StructuredList, 297 unsigned &StructuredIndex, 298 bool TopLevelObject = false); 299 void CheckArrayType(InitListExpr *IList, QualType &DeclType, 300 llvm::APSInt elementIndex, 301 bool SubobjectIsDesignatorContext, unsigned &Index, 302 InitListExpr *StructuredList, 303 unsigned &StructuredIndex); 304 bool CheckDesignatedInitializer(InitListExpr *IList, DesignatedInitExpr *DIE, 305 unsigned DesigIdx, 306 QualType &CurrentObjectType, 307 RecordDecl::field_iterator *NextField, 308 llvm::APSInt *NextElementIndex, 309 unsigned &Index, 310 InitListExpr *StructuredList, 311 unsigned &StructuredIndex, 312 bool FinishSubobjectInit, 313 bool TopLevelObject); 314 InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index, 315 QualType CurrentObjectType, 316 InitListExpr *StructuredList, 317 unsigned StructuredIndex, 318 SourceRange InitRange); 319 void UpdateStructuredListElement(InitListExpr *StructuredList, 320 unsigned &StructuredIndex, 321 Expr *expr); 322 int numArrayElements(QualType DeclType); 323 int numStructUnionElements(QualType DeclType); 324 325 void FillInValueInitializations(InitListExpr *ILE); 326public: 327 InitListChecker(Sema &S, InitListExpr *IL, QualType &T); 328 bool HadError() { return hadError; } 329 330 // @brief Retrieves the fully-structured initializer list used for 331 // semantic analysis and code generation. 332 InitListExpr *getFullyStructuredList() const { return FullyStructuredList; } 333}; 334} // end anonymous namespace 335 336/// Recursively replaces NULL values within the given initializer list 337/// with expressions that perform value-initialization of the 338/// appropriate type. 339void InitListChecker::FillInValueInitializations(InitListExpr *ILE) { 340 assert((ILE->getType() != SemaRef.Context.VoidTy) && 341 "Should not have void type"); 342 SourceLocation Loc = ILE->getSourceRange().getBegin(); 343 if (ILE->getSyntacticForm()) 344 Loc = ILE->getSyntacticForm()->getSourceRange().getBegin(); 345 346 if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) { 347 unsigned Init = 0, NumInits = ILE->getNumInits(); 348 for (RecordDecl::field_iterator 349 Field = RType->getDecl()->field_begin(), 350 FieldEnd = RType->getDecl()->field_end(); 351 Field != FieldEnd; ++Field) { 352 if (Field->isUnnamedBitfield()) 353 continue; 354 355 if (Init >= NumInits || !ILE->getInit(Init)) { 356 if (Field->getType()->isReferenceType()) { 357 // C++ [dcl.init.aggr]p9: 358 // If an incomplete or empty initializer-list leaves a 359 // member of reference type uninitialized, the program is 360 // ill-formed. 361 SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized) 362 << Field->getType() 363 << ILE->getSyntacticForm()->getSourceRange(); 364 SemaRef.Diag(Field->getLocation(), 365 diag::note_uninit_reference_member); 366 hadError = true; 367 return; 368 } else if (SemaRef.CheckValueInitialization(Field->getType(), Loc)) { 369 hadError = true; 370 return; 371 } 372 373 // FIXME: If value-initialization involves calling a constructor, should 374 // we make that call explicit in the representation (even when it means 375 // extending the initializer list)? 376 if (Init < NumInits && !hadError) 377 ILE->setInit(Init, 378 new (SemaRef.Context) ImplicitValueInitExpr(Field->getType())); 379 } else if (InitListExpr *InnerILE 380 = dyn_cast<InitListExpr>(ILE->getInit(Init))) 381 FillInValueInitializations(InnerILE); 382 ++Init; 383 384 // Only look at the first initialization of a union. 385 if (RType->getDecl()->isUnion()) 386 break; 387 } 388 389 return; 390 } 391 392 QualType ElementType; 393 394 unsigned NumInits = ILE->getNumInits(); 395 unsigned NumElements = NumInits; 396 if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) { 397 ElementType = AType->getElementType(); 398 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) 399 NumElements = CAType->getSize().getZExtValue(); 400 } else if (const VectorType *VType = ILE->getType()->getAsVectorType()) { 401 ElementType = VType->getElementType(); 402 NumElements = VType->getNumElements(); 403 } else 404 ElementType = ILE->getType(); 405 406 for (unsigned Init = 0; Init != NumElements; ++Init) { 407 if (Init >= NumInits || !ILE->getInit(Init)) { 408 if (SemaRef.CheckValueInitialization(ElementType, Loc)) { 409 hadError = true; 410 return; 411 } 412 413 // FIXME: If value-initialization involves calling a constructor, should 414 // we make that call explicit in the representation (even when it means 415 // extending the initializer list)? 416 if (Init < NumInits && !hadError) 417 ILE->setInit(Init, 418 new (SemaRef.Context) ImplicitValueInitExpr(ElementType)); 419 } else if (InitListExpr *InnerILE 420 = dyn_cast<InitListExpr>(ILE->getInit(Init))) 421 FillInValueInitializations(InnerILE); 422 } 423} 424 425 426InitListChecker::InitListChecker(Sema &S, InitListExpr *IL, QualType &T) 427 : SemaRef(S) { 428 hadError = false; 429 430 unsigned newIndex = 0; 431 unsigned newStructuredIndex = 0; 432 FullyStructuredList 433 = getStructuredSubobjectInit(IL, newIndex, T, 0, 0, IL->getSourceRange()); 434 CheckExplicitInitList(IL, T, newIndex, FullyStructuredList, newStructuredIndex, 435 /*TopLevelObject=*/true); 436 437 if (!hadError) 438 FillInValueInitializations(FullyStructuredList); 439} 440 441int InitListChecker::numArrayElements(QualType DeclType) { 442 // FIXME: use a proper constant 443 int maxElements = 0x7FFFFFFF; 444 if (const ConstantArrayType *CAT = 445 SemaRef.Context.getAsConstantArrayType(DeclType)) { 446 maxElements = static_cast<int>(CAT->getSize().getZExtValue()); 447 } 448 return maxElements; 449} 450 451int InitListChecker::numStructUnionElements(QualType DeclType) { 452 RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl(); 453 int InitializableMembers = 0; 454 for (RecordDecl::field_iterator 455 Field = structDecl->field_begin(), 456 FieldEnd = structDecl->field_end(); 457 Field != FieldEnd; ++Field) { 458 if ((*Field)->getIdentifier() || !(*Field)->isBitField()) 459 ++InitializableMembers; 460 } 461 if (structDecl->isUnion()) 462 return std::min(InitializableMembers, 1); 463 return InitializableMembers - structDecl->hasFlexibleArrayMember(); 464} 465 466void InitListChecker::CheckImplicitInitList(InitListExpr *ParentIList, 467 QualType T, unsigned &Index, 468 InitListExpr *StructuredList, 469 unsigned &StructuredIndex, 470 bool TopLevelObject) { 471 int maxElements = 0; 472 473 if (T->isArrayType()) 474 maxElements = numArrayElements(T); 475 else if (T->isStructureType() || T->isUnionType()) 476 maxElements = numStructUnionElements(T); 477 else if (T->isVectorType()) 478 maxElements = T->getAsVectorType()->getNumElements(); 479 else 480 assert(0 && "CheckImplicitInitList(): Illegal type"); 481 482 if (maxElements == 0) { 483 SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(), 484 diag::err_implicit_empty_initializer); 485 ++Index; 486 hadError = true; 487 return; 488 } 489 490 // Build a structured initializer list corresponding to this subobject. 491 InitListExpr *StructuredSubobjectInitList 492 = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList, 493 StructuredIndex, 494 SourceRange(ParentIList->getInit(Index)->getSourceRange().getBegin(), 495 ParentIList->getSourceRange().getEnd())); 496 unsigned StructuredSubobjectInitIndex = 0; 497 498 // Check the element types and build the structural subobject. 499 unsigned StartIndex = Index; 500 CheckListElementTypes(ParentIList, T, false, Index, 501 StructuredSubobjectInitList, 502 StructuredSubobjectInitIndex, 503 TopLevelObject); 504 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1); 505 StructuredSubobjectInitList->setType(T); 506 507 // Update the structured sub-object initializer so that it's ending 508 // range corresponds with the end of the last initializer it used. 509 if (EndIndex < ParentIList->getNumInits()) { 510 SourceLocation EndLoc 511 = ParentIList->getInit(EndIndex)->getSourceRange().getEnd(); 512 StructuredSubobjectInitList->setRBraceLoc(EndLoc); 513 } 514} 515 516void InitListChecker::CheckExplicitInitList(InitListExpr *IList, QualType &T, 517 unsigned &Index, 518 InitListExpr *StructuredList, 519 unsigned &StructuredIndex, 520 bool TopLevelObject) { 521 assert(IList->isExplicit() && "Illegal Implicit InitListExpr"); 522 SyntacticToSemantic[IList] = StructuredList; 523 StructuredList->setSyntacticForm(IList); 524 CheckListElementTypes(IList, T, true, Index, StructuredList, 525 StructuredIndex, TopLevelObject); 526 IList->setType(T); 527 StructuredList->setType(T); 528 if (hadError) 529 return; 530 531 if (Index < IList->getNumInits()) { 532 // We have leftover initializers 533 if (StructuredIndex == 1 && 534 IsStringInit(StructuredList->getInit(0), T, SemaRef.Context)) { 535 unsigned DK = diag::warn_excess_initializers_in_char_array_initializer; 536 if (SemaRef.getLangOptions().CPlusPlus) { 537 DK = diag::err_excess_initializers_in_char_array_initializer; 538 hadError = true; 539 } 540 // Special-case 541 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK) 542 << IList->getInit(Index)->getSourceRange(); 543 } else if (!T->isIncompleteType()) { 544 // Don't complain for incomplete types, since we'll get an error 545 // elsewhere 546 QualType CurrentObjectType = StructuredList->getType(); 547 int initKind = 548 CurrentObjectType->isArrayType()? 0 : 549 CurrentObjectType->isVectorType()? 1 : 550 CurrentObjectType->isScalarType()? 2 : 551 CurrentObjectType->isUnionType()? 3 : 552 4; 553 554 unsigned DK = diag::warn_excess_initializers; 555 if (SemaRef.getLangOptions().CPlusPlus) { 556 DK = diag::err_excess_initializers; 557 hadError = true; 558 } 559 if (SemaRef.getLangOptions().OpenCL && initKind == 1) { 560 DK = diag::err_excess_initializers; 561 hadError = true; 562 } 563 564 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK) 565 << initKind << IList->getInit(Index)->getSourceRange(); 566 } 567 } 568 569 if (T->isScalarType() && !TopLevelObject) 570 SemaRef.Diag(IList->getLocStart(), diag::warn_braces_around_scalar_init) 571 << IList->getSourceRange() 572 << CodeModificationHint::CreateRemoval(SourceRange(IList->getLocStart())) 573 << CodeModificationHint::CreateRemoval(SourceRange(IList->getLocEnd())); 574} 575 576void InitListChecker::CheckListElementTypes(InitListExpr *IList, 577 QualType &DeclType, 578 bool SubobjectIsDesignatorContext, 579 unsigned &Index, 580 InitListExpr *StructuredList, 581 unsigned &StructuredIndex, 582 bool TopLevelObject) { 583 if (DeclType->isScalarType()) { 584 CheckScalarType(IList, DeclType, Index, StructuredList, StructuredIndex); 585 } else if (DeclType->isVectorType()) { 586 CheckVectorType(IList, DeclType, Index, StructuredList, StructuredIndex); 587 } else if (DeclType->isAggregateType()) { 588 if (DeclType->isRecordType()) { 589 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl(); 590 CheckStructUnionTypes(IList, DeclType, RD->field_begin(), 591 SubobjectIsDesignatorContext, Index, 592 StructuredList, StructuredIndex, 593 TopLevelObject); 594 } else if (DeclType->isArrayType()) { 595 llvm::APSInt Zero( 596 SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()), 597 false); 598 CheckArrayType(IList, DeclType, Zero, SubobjectIsDesignatorContext, Index, 599 StructuredList, StructuredIndex); 600 } else 601 assert(0 && "Aggregate that isn't a structure or array?!"); 602 } else if (DeclType->isVoidType() || DeclType->isFunctionType()) { 603 // This type is invalid, issue a diagnostic. 604 ++Index; 605 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type) 606 << DeclType; 607 hadError = true; 608 } else if (DeclType->isRecordType()) { 609 // C++ [dcl.init]p14: 610 // [...] If the class is an aggregate (8.5.1), and the initializer 611 // is a brace-enclosed list, see 8.5.1. 612 // 613 // Note: 8.5.1 is handled below; here, we diagnose the case where 614 // we have an initializer list and a destination type that is not 615 // an aggregate. 616 // FIXME: In C++0x, this is yet another form of initialization. 617 SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list) 618 << DeclType << IList->getSourceRange(); 619 hadError = true; 620 } else if (DeclType->isReferenceType()) { 621 CheckReferenceType(IList, DeclType, Index, StructuredList, StructuredIndex); 622 } else { 623 // In C, all types are either scalars or aggregates, but 624 // additional handling is needed here for C++ (and possibly others?). 625 assert(0 && "Unsupported initializer type"); 626 } 627} 628 629void InitListChecker::CheckSubElementType(InitListExpr *IList, 630 QualType ElemType, 631 unsigned &Index, 632 InitListExpr *StructuredList, 633 unsigned &StructuredIndex) { 634 Expr *expr = IList->getInit(Index); 635 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) { 636 unsigned newIndex = 0; 637 unsigned newStructuredIndex = 0; 638 InitListExpr *newStructuredList 639 = getStructuredSubobjectInit(IList, Index, ElemType, 640 StructuredList, StructuredIndex, 641 SubInitList->getSourceRange()); 642 CheckExplicitInitList(SubInitList, ElemType, newIndex, 643 newStructuredList, newStructuredIndex); 644 ++StructuredIndex; 645 ++Index; 646 } else if (Expr *Str = IsStringInit(expr, ElemType, SemaRef.Context)) { 647 CheckStringInit(Str, ElemType, SemaRef); 648 UpdateStructuredListElement(StructuredList, StructuredIndex, Str); 649 ++Index; 650 } else if (ElemType->isScalarType()) { 651 CheckScalarType(IList, ElemType, Index, StructuredList, StructuredIndex); 652 } else if (ElemType->isReferenceType()) { 653 CheckReferenceType(IList, ElemType, Index, StructuredList, StructuredIndex); 654 } else { 655 if (SemaRef.getLangOptions().CPlusPlus) { 656 // C++ [dcl.init.aggr]p12: 657 // All implicit type conversions (clause 4) are considered when 658 // initializing the aggregate member with an ini- tializer from 659 // an initializer-list. If the initializer can initialize a 660 // member, the member is initialized. [...] 661 ImplicitConversionSequence ICS 662 = SemaRef.TryCopyInitialization(expr, ElemType); 663 if (ICS.ConversionKind != ImplicitConversionSequence::BadConversion) { 664 if (SemaRef.PerformImplicitConversion(expr, ElemType, ICS, 665 "initializing")) 666 hadError = true; 667 UpdateStructuredListElement(StructuredList, StructuredIndex, expr); 668 ++Index; 669 return; 670 } 671 672 // Fall through for subaggregate initialization 673 } else { 674 // C99 6.7.8p13: 675 // 676 // The initializer for a structure or union object that has 677 // automatic storage duration shall be either an initializer 678 // list as described below, or a single expression that has 679 // compatible structure or union type. In the latter case, the 680 // initial value of the object, including unnamed members, is 681 // that of the expression. 682 if ((ElemType->isRecordType() || ElemType->isVectorType()) && 683 SemaRef.Context.hasSameUnqualifiedType(expr->getType(), ElemType)) { 684 UpdateStructuredListElement(StructuredList, StructuredIndex, expr); 685 ++Index; 686 return; 687 } 688 689 // Fall through for subaggregate initialization 690 } 691 692 // C++ [dcl.init.aggr]p12: 693 // 694 // [...] Otherwise, if the member is itself a non-empty 695 // subaggregate, brace elision is assumed and the initializer is 696 // considered for the initialization of the first member of 697 // the subaggregate. 698 if (ElemType->isAggregateType() || ElemType->isVectorType()) { 699 CheckImplicitInitList(IList, ElemType, Index, StructuredList, 700 StructuredIndex); 701 ++StructuredIndex; 702 } else { 703 // We cannot initialize this element, so let 704 // PerformCopyInitialization produce the appropriate diagnostic. 705 SemaRef.PerformCopyInitialization(expr, ElemType, "initializing"); 706 hadError = true; 707 ++Index; 708 ++StructuredIndex; 709 } 710 } 711} 712 713void InitListChecker::CheckScalarType(InitListExpr *IList, QualType DeclType, 714 unsigned &Index, 715 InitListExpr *StructuredList, 716 unsigned &StructuredIndex) { 717 if (Index < IList->getNumInits()) { 718 Expr *expr = IList->getInit(Index); 719 if (isa<InitListExpr>(expr)) { 720 SemaRef.Diag(IList->getLocStart(), 721 diag::err_many_braces_around_scalar_init) 722 << IList->getSourceRange(); 723 hadError = true; 724 ++Index; 725 ++StructuredIndex; 726 return; 727 } else if (isa<DesignatedInitExpr>(expr)) { 728 SemaRef.Diag(expr->getSourceRange().getBegin(), 729 diag::err_designator_for_scalar_init) 730 << DeclType << expr->getSourceRange(); 731 hadError = true; 732 ++Index; 733 ++StructuredIndex; 734 return; 735 } 736 737 Expr *savExpr = expr; // Might be promoted by CheckSingleInitializer. 738 if (CheckSingleInitializer(expr, DeclType, false, SemaRef)) 739 hadError = true; // types weren't compatible. 740 else if (savExpr != expr) { 741 // The type was promoted, update initializer list. 742 IList->setInit(Index, expr); 743 } 744 if (hadError) 745 ++StructuredIndex; 746 else 747 UpdateStructuredListElement(StructuredList, StructuredIndex, expr); 748 ++Index; 749 } else { 750 SemaRef.Diag(IList->getLocStart(), diag::err_empty_scalar_initializer) 751 << IList->getSourceRange(); 752 hadError = true; 753 ++Index; 754 ++StructuredIndex; 755 return; 756 } 757} 758 759void InitListChecker::CheckReferenceType(InitListExpr *IList, QualType DeclType, 760 unsigned &Index, 761 InitListExpr *StructuredList, 762 unsigned &StructuredIndex) { 763 if (Index < IList->getNumInits()) { 764 Expr *expr = IList->getInit(Index); 765 if (isa<InitListExpr>(expr)) { 766 SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list) 767 << DeclType << IList->getSourceRange(); 768 hadError = true; 769 ++Index; 770 ++StructuredIndex; 771 return; 772 } 773 774 Expr *savExpr = expr; // Might be promoted by CheckSingleInitializer. 775 if (SemaRef.CheckReferenceInit(expr, DeclType)) 776 hadError = true; 777 else if (savExpr != expr) { 778 // The type was promoted, update initializer list. 779 IList->setInit(Index, expr); 780 } 781 if (hadError) 782 ++StructuredIndex; 783 else 784 UpdateStructuredListElement(StructuredList, StructuredIndex, expr); 785 ++Index; 786 } else { 787 // FIXME: It would be wonderful if we could point at the actual member. In 788 // general, it would be useful to pass location information down the stack, 789 // so that we know the location (or decl) of the "current object" being 790 // initialized. 791 SemaRef.Diag(IList->getLocStart(), 792 diag::err_init_reference_member_uninitialized) 793 << DeclType 794 << IList->getSourceRange(); 795 hadError = true; 796 ++Index; 797 ++StructuredIndex; 798 return; 799 } 800} 801 802void InitListChecker::CheckVectorType(InitListExpr *IList, QualType DeclType, 803 unsigned &Index, 804 InitListExpr *StructuredList, 805 unsigned &StructuredIndex) { 806 if (Index < IList->getNumInits()) { 807 const VectorType *VT = DeclType->getAsVectorType(); 808 unsigned maxElements = VT->getNumElements(); 809 unsigned numEltsInit = 0; 810 QualType elementType = VT->getElementType(); 811 812 if (!SemaRef.getLangOptions().OpenCL) { 813 for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) { 814 // Don't attempt to go past the end of the init list 815 if (Index >= IList->getNumInits()) 816 break; 817 CheckSubElementType(IList, elementType, Index, 818 StructuredList, StructuredIndex); 819 } 820 } else { 821 // OpenCL initializers allows vectors to be constructed from vectors. 822 for (unsigned i = 0; i < maxElements; ++i) { 823 // Don't attempt to go past the end of the init list 824 if (Index >= IList->getNumInits()) 825 break; 826 QualType IType = IList->getInit(Index)->getType(); 827 if (!IType->isVectorType()) { 828 CheckSubElementType(IList, elementType, Index, 829 StructuredList, StructuredIndex); 830 ++numEltsInit; 831 } else { 832 const VectorType *IVT = IType->getAsVectorType(); 833 unsigned numIElts = IVT->getNumElements(); 834 QualType VecType = SemaRef.Context.getExtVectorType(elementType, 835 numIElts); 836 CheckSubElementType(IList, VecType, Index, 837 StructuredList, StructuredIndex); 838 numEltsInit += numIElts; 839 } 840 } 841 } 842 843 // OpenCL & AltiVec require all elements to be initialized. 844 if (numEltsInit != maxElements) 845 if (SemaRef.getLangOptions().OpenCL || SemaRef.getLangOptions().AltiVec) 846 SemaRef.Diag(IList->getSourceRange().getBegin(), 847 diag::err_vector_incorrect_num_initializers) 848 << (numEltsInit < maxElements) << maxElements << numEltsInit; 849 } 850} 851 852void InitListChecker::CheckArrayType(InitListExpr *IList, QualType &DeclType, 853 llvm::APSInt elementIndex, 854 bool SubobjectIsDesignatorContext, 855 unsigned &Index, 856 InitListExpr *StructuredList, 857 unsigned &StructuredIndex) { 858 // Check for the special-case of initializing an array with a string. 859 if (Index < IList->getNumInits()) { 860 if (Expr *Str = IsStringInit(IList->getInit(Index), DeclType, 861 SemaRef.Context)) { 862 CheckStringInit(Str, DeclType, SemaRef); 863 // We place the string literal directly into the resulting 864 // initializer list. This is the only place where the structure 865 // of the structured initializer list doesn't match exactly, 866 // because doing so would involve allocating one character 867 // constant for each string. 868 UpdateStructuredListElement(StructuredList, StructuredIndex, Str); 869 StructuredList->resizeInits(SemaRef.Context, StructuredIndex); 870 ++Index; 871 return; 872 } 873 } 874 if (const VariableArrayType *VAT = 875 SemaRef.Context.getAsVariableArrayType(DeclType)) { 876 // Check for VLAs; in standard C it would be possible to check this 877 // earlier, but I don't know where clang accepts VLAs (gcc accepts 878 // them in all sorts of strange places). 879 SemaRef.Diag(VAT->getSizeExpr()->getLocStart(), 880 diag::err_variable_object_no_init) 881 << VAT->getSizeExpr()->getSourceRange(); 882 hadError = true; 883 ++Index; 884 ++StructuredIndex; 885 return; 886 } 887 888 // We might know the maximum number of elements in advance. 889 llvm::APSInt maxElements(elementIndex.getBitWidth(), 890 elementIndex.isUnsigned()); 891 bool maxElementsKnown = false; 892 if (const ConstantArrayType *CAT = 893 SemaRef.Context.getAsConstantArrayType(DeclType)) { 894 maxElements = CAT->getSize(); 895 elementIndex.extOrTrunc(maxElements.getBitWidth()); 896 elementIndex.setIsUnsigned(maxElements.isUnsigned()); 897 maxElementsKnown = true; 898 } 899 900 QualType elementType = SemaRef.Context.getAsArrayType(DeclType) 901 ->getElementType(); 902 while (Index < IList->getNumInits()) { 903 Expr *Init = IList->getInit(Index); 904 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) { 905 // If we're not the subobject that matches up with the '{' for 906 // the designator, we shouldn't be handling the 907 // designator. Return immediately. 908 if (!SubobjectIsDesignatorContext) 909 return; 910 911 // Handle this designated initializer. elementIndex will be 912 // updated to be the next array element we'll initialize. 913 if (CheckDesignatedInitializer(IList, DIE, 0, 914 DeclType, 0, &elementIndex, Index, 915 StructuredList, StructuredIndex, true, 916 false)) { 917 hadError = true; 918 continue; 919 } 920 921 if (elementIndex.getBitWidth() > maxElements.getBitWidth()) 922 maxElements.extend(elementIndex.getBitWidth()); 923 else if (elementIndex.getBitWidth() < maxElements.getBitWidth()) 924 elementIndex.extend(maxElements.getBitWidth()); 925 elementIndex.setIsUnsigned(maxElements.isUnsigned()); 926 927 // If the array is of incomplete type, keep track of the number of 928 // elements in the initializer. 929 if (!maxElementsKnown && elementIndex > maxElements) 930 maxElements = elementIndex; 931 932 continue; 933 } 934 935 // If we know the maximum number of elements, and we've already 936 // hit it, stop consuming elements in the initializer list. 937 if (maxElementsKnown && elementIndex == maxElements) 938 break; 939 940 // Check this element. 941 CheckSubElementType(IList, elementType, Index, 942 StructuredList, StructuredIndex); 943 ++elementIndex; 944 945 // If the array is of incomplete type, keep track of the number of 946 // elements in the initializer. 947 if (!maxElementsKnown && elementIndex > maxElements) 948 maxElements = elementIndex; 949 } 950 if (!hadError && DeclType->isIncompleteArrayType()) { 951 // If this is an incomplete array type, the actual type needs to 952 // be calculated here. 953 llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned()); 954 if (maxElements == Zero) { 955 // Sizing an array implicitly to zero is not allowed by ISO C, 956 // but is supported by GNU. 957 SemaRef.Diag(IList->getLocStart(), 958 diag::ext_typecheck_zero_array_size); 959 } 960 961 DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements, 962 ArrayType::Normal, 0); 963 } 964} 965 966void InitListChecker::CheckStructUnionTypes(InitListExpr *IList, 967 QualType DeclType, 968 RecordDecl::field_iterator Field, 969 bool SubobjectIsDesignatorContext, 970 unsigned &Index, 971 InitListExpr *StructuredList, 972 unsigned &StructuredIndex, 973 bool TopLevelObject) { 974 RecordDecl* structDecl = DeclType->getAs<RecordType>()->getDecl(); 975 976 // If the record is invalid, some of it's members are invalid. To avoid 977 // confusion, we forgo checking the intializer for the entire record. 978 if (structDecl->isInvalidDecl()) { 979 hadError = true; 980 return; 981 } 982 983 if (DeclType->isUnionType() && IList->getNumInits() == 0) { 984 // Value-initialize the first named member of the union. 985 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl(); 986 for (RecordDecl::field_iterator FieldEnd = RD->field_end(); 987 Field != FieldEnd; ++Field) { 988 if (Field->getDeclName()) { 989 StructuredList->setInitializedFieldInUnion(*Field); 990 break; 991 } 992 } 993 return; 994 } 995 996 // If structDecl is a forward declaration, this loop won't do 997 // anything except look at designated initializers; That's okay, 998 // because an error should get printed out elsewhere. It might be 999 // worthwhile to skip over the rest of the initializer, though. 1000 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl(); 1001 RecordDecl::field_iterator FieldEnd = RD->field_end(); 1002 bool InitializedSomething = false; 1003 while (Index < IList->getNumInits()) { 1004 Expr *Init = IList->getInit(Index); 1005 1006 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) { 1007 // If we're not the subobject that matches up with the '{' for 1008 // the designator, we shouldn't be handling the 1009 // designator. Return immediately. 1010 if (!SubobjectIsDesignatorContext) 1011 return; 1012 1013 // Handle this designated initializer. Field will be updated to 1014 // the next field that we'll be initializing. 1015 if (CheckDesignatedInitializer(IList, DIE, 0, 1016 DeclType, &Field, 0, Index, 1017 StructuredList, StructuredIndex, 1018 true, TopLevelObject)) 1019 hadError = true; 1020 1021 InitializedSomething = true; 1022 continue; 1023 } 1024 1025 if (Field == FieldEnd) { 1026 // We've run out of fields. We're done. 1027 break; 1028 } 1029 1030 // We've already initialized a member of a union. We're done. 1031 if (InitializedSomething && DeclType->isUnionType()) 1032 break; 1033 1034 // If we've hit the flexible array member at the end, we're done. 1035 if (Field->getType()->isIncompleteArrayType()) 1036 break; 1037 1038 if (Field->isUnnamedBitfield()) { 1039 // Don't initialize unnamed bitfields, e.g. "int : 20;" 1040 ++Field; 1041 continue; 1042 } 1043 1044 CheckSubElementType(IList, Field->getType(), Index, 1045 StructuredList, StructuredIndex); 1046 InitializedSomething = true; 1047 1048 if (DeclType->isUnionType()) { 1049 // Initialize the first field within the union. 1050 StructuredList->setInitializedFieldInUnion(*Field); 1051 } 1052 1053 ++Field; 1054 } 1055 1056 if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() || 1057 Index >= IList->getNumInits()) 1058 return; 1059 1060 // Handle GNU flexible array initializers. 1061 if (!TopLevelObject && 1062 (!isa<InitListExpr>(IList->getInit(Index)) || 1063 cast<InitListExpr>(IList->getInit(Index))->getNumInits() > 0)) { 1064 SemaRef.Diag(IList->getInit(Index)->getSourceRange().getBegin(), 1065 diag::err_flexible_array_init_nonempty) 1066 << IList->getInit(Index)->getSourceRange().getBegin(); 1067 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1068 << *Field; 1069 hadError = true; 1070 ++Index; 1071 return; 1072 } else { 1073 SemaRef.Diag(IList->getInit(Index)->getSourceRange().getBegin(), 1074 diag::ext_flexible_array_init) 1075 << IList->getInit(Index)->getSourceRange().getBegin(); 1076 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1077 << *Field; 1078 } 1079 1080 if (isa<InitListExpr>(IList->getInit(Index))) 1081 CheckSubElementType(IList, Field->getType(), Index, StructuredList, 1082 StructuredIndex); 1083 else 1084 CheckImplicitInitList(IList, Field->getType(), Index, StructuredList, 1085 StructuredIndex); 1086} 1087 1088/// \brief Expand a field designator that refers to a member of an 1089/// anonymous struct or union into a series of field designators that 1090/// refers to the field within the appropriate subobject. 1091/// 1092/// Field/FieldIndex will be updated to point to the (new) 1093/// currently-designated field. 1094static void ExpandAnonymousFieldDesignator(Sema &SemaRef, 1095 DesignatedInitExpr *DIE, 1096 unsigned DesigIdx, 1097 FieldDecl *Field, 1098 RecordDecl::field_iterator &FieldIter, 1099 unsigned &FieldIndex) { 1100 typedef DesignatedInitExpr::Designator Designator; 1101 1102 // Build the path from the current object to the member of the 1103 // anonymous struct/union (backwards). 1104 llvm::SmallVector<FieldDecl *, 4> Path; 1105 SemaRef.BuildAnonymousStructUnionMemberPath(Field, Path); 1106 1107 // Build the replacement designators. 1108 llvm::SmallVector<Designator, 4> Replacements; 1109 for (llvm::SmallVector<FieldDecl *, 4>::reverse_iterator 1110 FI = Path.rbegin(), FIEnd = Path.rend(); 1111 FI != FIEnd; ++FI) { 1112 if (FI + 1 == FIEnd) 1113 Replacements.push_back(Designator((IdentifierInfo *)0, 1114 DIE->getDesignator(DesigIdx)->getDotLoc(), 1115 DIE->getDesignator(DesigIdx)->getFieldLoc())); 1116 else 1117 Replacements.push_back(Designator((IdentifierInfo *)0, SourceLocation(), 1118 SourceLocation())); 1119 Replacements.back().setField(*FI); 1120 } 1121 1122 // Expand the current designator into the set of replacement 1123 // designators, so we have a full subobject path down to where the 1124 // member of the anonymous struct/union is actually stored. 1125 DIE->ExpandDesignator(DesigIdx, &Replacements[0], 1126 &Replacements[0] + Replacements.size()); 1127 1128 // Update FieldIter/FieldIndex; 1129 RecordDecl *Record = cast<RecordDecl>(Path.back()->getDeclContext()); 1130 FieldIter = Record->field_begin(); 1131 FieldIndex = 0; 1132 for (RecordDecl::field_iterator FEnd = Record->field_end(); 1133 FieldIter != FEnd; ++FieldIter) { 1134 if (FieldIter->isUnnamedBitfield()) 1135 continue; 1136 1137 if (*FieldIter == Path.back()) 1138 return; 1139 1140 ++FieldIndex; 1141 } 1142 1143 assert(false && "Unable to find anonymous struct/union field"); 1144} 1145 1146/// @brief Check the well-formedness of a C99 designated initializer. 1147/// 1148/// Determines whether the designated initializer @p DIE, which 1149/// resides at the given @p Index within the initializer list @p 1150/// IList, is well-formed for a current object of type @p DeclType 1151/// (C99 6.7.8). The actual subobject that this designator refers to 1152/// within the current subobject is returned in either 1153/// @p NextField or @p NextElementIndex (whichever is appropriate). 1154/// 1155/// @param IList The initializer list in which this designated 1156/// initializer occurs. 1157/// 1158/// @param DIE The designated initializer expression. 1159/// 1160/// @param DesigIdx The index of the current designator. 1161/// 1162/// @param DeclType The type of the "current object" (C99 6.7.8p17), 1163/// into which the designation in @p DIE should refer. 1164/// 1165/// @param NextField If non-NULL and the first designator in @p DIE is 1166/// a field, this will be set to the field declaration corresponding 1167/// to the field named by the designator. 1168/// 1169/// @param NextElementIndex If non-NULL and the first designator in @p 1170/// DIE is an array designator or GNU array-range designator, this 1171/// will be set to the last index initialized by this designator. 1172/// 1173/// @param Index Index into @p IList where the designated initializer 1174/// @p DIE occurs. 1175/// 1176/// @param StructuredList The initializer list expression that 1177/// describes all of the subobject initializers in the order they'll 1178/// actually be initialized. 1179/// 1180/// @returns true if there was an error, false otherwise. 1181bool 1182InitListChecker::CheckDesignatedInitializer(InitListExpr *IList, 1183 DesignatedInitExpr *DIE, 1184 unsigned DesigIdx, 1185 QualType &CurrentObjectType, 1186 RecordDecl::field_iterator *NextField, 1187 llvm::APSInt *NextElementIndex, 1188 unsigned &Index, 1189 InitListExpr *StructuredList, 1190 unsigned &StructuredIndex, 1191 bool FinishSubobjectInit, 1192 bool TopLevelObject) { 1193 if (DesigIdx == DIE->size()) { 1194 // Check the actual initialization for the designated object type. 1195 bool prevHadError = hadError; 1196 1197 // Temporarily remove the designator expression from the 1198 // initializer list that the child calls see, so that we don't try 1199 // to re-process the designator. 1200 unsigned OldIndex = Index; 1201 IList->setInit(OldIndex, DIE->getInit()); 1202 1203 CheckSubElementType(IList, CurrentObjectType, Index, 1204 StructuredList, StructuredIndex); 1205 1206 // Restore the designated initializer expression in the syntactic 1207 // form of the initializer list. 1208 if (IList->getInit(OldIndex) != DIE->getInit()) 1209 DIE->setInit(IList->getInit(OldIndex)); 1210 IList->setInit(OldIndex, DIE); 1211 1212 return hadError && !prevHadError; 1213 } 1214 1215 bool IsFirstDesignator = (DesigIdx == 0); 1216 assert((IsFirstDesignator || StructuredList) && 1217 "Need a non-designated initializer list to start from"); 1218 1219 DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx); 1220 // Determine the structural initializer list that corresponds to the 1221 // current subobject. 1222 StructuredList = IsFirstDesignator? SyntacticToSemantic[IList] 1223 : getStructuredSubobjectInit(IList, Index, CurrentObjectType, 1224 StructuredList, StructuredIndex, 1225 SourceRange(D->getStartLocation(), 1226 DIE->getSourceRange().getEnd())); 1227 assert(StructuredList && "Expected a structured initializer list"); 1228 1229 if (D->isFieldDesignator()) { 1230 // C99 6.7.8p7: 1231 // 1232 // If a designator has the form 1233 // 1234 // . identifier 1235 // 1236 // then the current object (defined below) shall have 1237 // structure or union type and the identifier shall be the 1238 // name of a member of that type. 1239 const RecordType *RT = CurrentObjectType->getAs<RecordType>(); 1240 if (!RT) { 1241 SourceLocation Loc = D->getDotLoc(); 1242 if (Loc.isInvalid()) 1243 Loc = D->getFieldLoc(); 1244 SemaRef.Diag(Loc, diag::err_field_designator_non_aggr) 1245 << SemaRef.getLangOptions().CPlusPlus << CurrentObjectType; 1246 ++Index; 1247 return true; 1248 } 1249 1250 // Note: we perform a linear search of the fields here, despite 1251 // the fact that we have a faster lookup method, because we always 1252 // need to compute the field's index. 1253 FieldDecl *KnownField = D->getField(); 1254 IdentifierInfo *FieldName = D->getFieldName(); 1255 unsigned FieldIndex = 0; 1256 RecordDecl::field_iterator 1257 Field = RT->getDecl()->field_begin(), 1258 FieldEnd = RT->getDecl()->field_end(); 1259 for (; Field != FieldEnd; ++Field) { 1260 if (Field->isUnnamedBitfield()) 1261 continue; 1262 1263 if (KnownField == *Field || Field->getIdentifier() == FieldName) 1264 break; 1265 1266 ++FieldIndex; 1267 } 1268 1269 if (Field == FieldEnd) { 1270 // There was no normal field in the struct with the designated 1271 // name. Perform another lookup for this name, which may find 1272 // something that we can't designate (e.g., a member function), 1273 // may find nothing, or may find a member of an anonymous 1274 // struct/union. 1275 DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName); 1276 if (Lookup.first == Lookup.second) { 1277 // Name lookup didn't find anything. 1278 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown) 1279 << FieldName << CurrentObjectType; 1280 ++Index; 1281 return true; 1282 } else if (!KnownField && isa<FieldDecl>(*Lookup.first) && 1283 cast<RecordDecl>((*Lookup.first)->getDeclContext()) 1284 ->isAnonymousStructOrUnion()) { 1285 // Handle an field designator that refers to a member of an 1286 // anonymous struct or union. 1287 ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, 1288 cast<FieldDecl>(*Lookup.first), 1289 Field, FieldIndex); 1290 D = DIE->getDesignator(DesigIdx); 1291 } else { 1292 // Name lookup found something, but it wasn't a field. 1293 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield) 1294 << FieldName; 1295 SemaRef.Diag((*Lookup.first)->getLocation(), 1296 diag::note_field_designator_found); 1297 ++Index; 1298 return true; 1299 } 1300 } else if (!KnownField && 1301 cast<RecordDecl>((*Field)->getDeclContext()) 1302 ->isAnonymousStructOrUnion()) { 1303 ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, *Field, 1304 Field, FieldIndex); 1305 D = DIE->getDesignator(DesigIdx); 1306 } 1307 1308 // All of the fields of a union are located at the same place in 1309 // the initializer list. 1310 if (RT->getDecl()->isUnion()) { 1311 FieldIndex = 0; 1312 StructuredList->setInitializedFieldInUnion(*Field); 1313 } 1314 1315 // Update the designator with the field declaration. 1316 D->setField(*Field); 1317 1318 // Make sure that our non-designated initializer list has space 1319 // for a subobject corresponding to this field. 1320 if (FieldIndex >= StructuredList->getNumInits()) 1321 StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1); 1322 1323 // This designator names a flexible array member. 1324 if (Field->getType()->isIncompleteArrayType()) { 1325 bool Invalid = false; 1326 if ((DesigIdx + 1) != DIE->size()) { 1327 // We can't designate an object within the flexible array 1328 // member (because GCC doesn't allow it). 1329 DesignatedInitExpr::Designator *NextD 1330 = DIE->getDesignator(DesigIdx + 1); 1331 SemaRef.Diag(NextD->getStartLocation(), 1332 diag::err_designator_into_flexible_array_member) 1333 << SourceRange(NextD->getStartLocation(), 1334 DIE->getSourceRange().getEnd()); 1335 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1336 << *Field; 1337 Invalid = true; 1338 } 1339 1340 if (!hadError && !isa<InitListExpr>(DIE->getInit())) { 1341 // The initializer is not an initializer list. 1342 SemaRef.Diag(DIE->getInit()->getSourceRange().getBegin(), 1343 diag::err_flexible_array_init_needs_braces) 1344 << DIE->getInit()->getSourceRange(); 1345 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1346 << *Field; 1347 Invalid = true; 1348 } 1349 1350 // Handle GNU flexible array initializers. 1351 if (!Invalid && !TopLevelObject && 1352 cast<InitListExpr>(DIE->getInit())->getNumInits() > 0) { 1353 SemaRef.Diag(DIE->getSourceRange().getBegin(), 1354 diag::err_flexible_array_init_nonempty) 1355 << DIE->getSourceRange().getBegin(); 1356 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1357 << *Field; 1358 Invalid = true; 1359 } 1360 1361 if (Invalid) { 1362 ++Index; 1363 return true; 1364 } 1365 1366 // Initialize the array. 1367 bool prevHadError = hadError; 1368 unsigned newStructuredIndex = FieldIndex; 1369 unsigned OldIndex = Index; 1370 IList->setInit(Index, DIE->getInit()); 1371 CheckSubElementType(IList, Field->getType(), Index, 1372 StructuredList, newStructuredIndex); 1373 IList->setInit(OldIndex, DIE); 1374 if (hadError && !prevHadError) { 1375 ++Field; 1376 ++FieldIndex; 1377 if (NextField) 1378 *NextField = Field; 1379 StructuredIndex = FieldIndex; 1380 return true; 1381 } 1382 } else { 1383 // Recurse to check later designated subobjects. 1384 QualType FieldType = (*Field)->getType(); 1385 unsigned newStructuredIndex = FieldIndex; 1386 if (CheckDesignatedInitializer(IList, DIE, DesigIdx + 1, FieldType, 0, 0, 1387 Index, StructuredList, newStructuredIndex, 1388 true, false)) 1389 return true; 1390 } 1391 1392 // Find the position of the next field to be initialized in this 1393 // subobject. 1394 ++Field; 1395 ++FieldIndex; 1396 1397 // If this the first designator, our caller will continue checking 1398 // the rest of this struct/class/union subobject. 1399 if (IsFirstDesignator) { 1400 if (NextField) 1401 *NextField = Field; 1402 StructuredIndex = FieldIndex; 1403 return false; 1404 } 1405 1406 if (!FinishSubobjectInit) 1407 return false; 1408 1409 // We've already initialized something in the union; we're done. 1410 if (RT->getDecl()->isUnion()) 1411 return hadError; 1412 1413 // Check the remaining fields within this class/struct/union subobject. 1414 bool prevHadError = hadError; 1415 CheckStructUnionTypes(IList, CurrentObjectType, Field, false, Index, 1416 StructuredList, FieldIndex); 1417 return hadError && !prevHadError; 1418 } 1419 1420 // C99 6.7.8p6: 1421 // 1422 // If a designator has the form 1423 // 1424 // [ constant-expression ] 1425 // 1426 // then the current object (defined below) shall have array 1427 // type and the expression shall be an integer constant 1428 // expression. If the array is of unknown size, any 1429 // nonnegative value is valid. 1430 // 1431 // Additionally, cope with the GNU extension that permits 1432 // designators of the form 1433 // 1434 // [ constant-expression ... constant-expression ] 1435 const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType); 1436 if (!AT) { 1437 SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array) 1438 << CurrentObjectType; 1439 ++Index; 1440 return true; 1441 } 1442 1443 Expr *IndexExpr = 0; 1444 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex; 1445 if (D->isArrayDesignator()) { 1446 IndexExpr = DIE->getArrayIndex(*D); 1447 DesignatedStartIndex = IndexExpr->EvaluateAsInt(SemaRef.Context); 1448 DesignatedEndIndex = DesignatedStartIndex; 1449 } else { 1450 assert(D->isArrayRangeDesignator() && "Need array-range designator"); 1451 1452 1453 DesignatedStartIndex = 1454 DIE->getArrayRangeStart(*D)->EvaluateAsInt(SemaRef.Context); 1455 DesignatedEndIndex = 1456 DIE->getArrayRangeEnd(*D)->EvaluateAsInt(SemaRef.Context); 1457 IndexExpr = DIE->getArrayRangeEnd(*D); 1458 1459 if (DesignatedStartIndex.getZExtValue() !=DesignatedEndIndex.getZExtValue()) 1460 FullyStructuredList->sawArrayRangeDesignator(); 1461 } 1462 1463 if (isa<ConstantArrayType>(AT)) { 1464 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false); 1465 DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth()); 1466 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned()); 1467 DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth()); 1468 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned()); 1469 if (DesignatedEndIndex >= MaxElements) { 1470 SemaRef.Diag(IndexExpr->getSourceRange().getBegin(), 1471 diag::err_array_designator_too_large) 1472 << DesignatedEndIndex.toString(10) << MaxElements.toString(10) 1473 << IndexExpr->getSourceRange(); 1474 ++Index; 1475 return true; 1476 } 1477 } else { 1478 // Make sure the bit-widths and signedness match. 1479 if (DesignatedStartIndex.getBitWidth() > DesignatedEndIndex.getBitWidth()) 1480 DesignatedEndIndex.extend(DesignatedStartIndex.getBitWidth()); 1481 else if (DesignatedStartIndex.getBitWidth() < 1482 DesignatedEndIndex.getBitWidth()) 1483 DesignatedStartIndex.extend(DesignatedEndIndex.getBitWidth()); 1484 DesignatedStartIndex.setIsUnsigned(true); 1485 DesignatedEndIndex.setIsUnsigned(true); 1486 } 1487 1488 // Make sure that our non-designated initializer list has space 1489 // for a subobject corresponding to this array element. 1490 if (DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits()) 1491 StructuredList->resizeInits(SemaRef.Context, 1492 DesignatedEndIndex.getZExtValue() + 1); 1493 1494 // Repeatedly perform subobject initializations in the range 1495 // [DesignatedStartIndex, DesignatedEndIndex]. 1496 1497 // Move to the next designator 1498 unsigned ElementIndex = DesignatedStartIndex.getZExtValue(); 1499 unsigned OldIndex = Index; 1500 while (DesignatedStartIndex <= DesignatedEndIndex) { 1501 // Recurse to check later designated subobjects. 1502 QualType ElementType = AT->getElementType(); 1503 Index = OldIndex; 1504 if (CheckDesignatedInitializer(IList, DIE, DesigIdx + 1, ElementType, 0, 0, 1505 Index, StructuredList, ElementIndex, 1506 (DesignatedStartIndex == DesignatedEndIndex), 1507 false)) 1508 return true; 1509 1510 // Move to the next index in the array that we'll be initializing. 1511 ++DesignatedStartIndex; 1512 ElementIndex = DesignatedStartIndex.getZExtValue(); 1513 } 1514 1515 // If this the first designator, our caller will continue checking 1516 // the rest of this array subobject. 1517 if (IsFirstDesignator) { 1518 if (NextElementIndex) 1519 *NextElementIndex = DesignatedStartIndex; 1520 StructuredIndex = ElementIndex; 1521 return false; 1522 } 1523 1524 if (!FinishSubobjectInit) 1525 return false; 1526 1527 // Check the remaining elements within this array subobject. 1528 bool prevHadError = hadError; 1529 CheckArrayType(IList, CurrentObjectType, DesignatedStartIndex, false, Index, 1530 StructuredList, ElementIndex); 1531 return hadError && !prevHadError; 1532} 1533 1534// Get the structured initializer list for a subobject of type 1535// @p CurrentObjectType. 1536InitListExpr * 1537InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index, 1538 QualType CurrentObjectType, 1539 InitListExpr *StructuredList, 1540 unsigned StructuredIndex, 1541 SourceRange InitRange) { 1542 Expr *ExistingInit = 0; 1543 if (!StructuredList) 1544 ExistingInit = SyntacticToSemantic[IList]; 1545 else if (StructuredIndex < StructuredList->getNumInits()) 1546 ExistingInit = StructuredList->getInit(StructuredIndex); 1547 1548 if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit)) 1549 return Result; 1550 1551 if (ExistingInit) { 1552 // We are creating an initializer list that initializes the 1553 // subobjects of the current object, but there was already an 1554 // initialization that completely initialized the current 1555 // subobject, e.g., by a compound literal: 1556 // 1557 // struct X { int a, b; }; 1558 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 }; 1559 // 1560 // Here, xs[0].a == 0 and xs[0].b == 3, since the second, 1561 // designated initializer re-initializes the whole 1562 // subobject [0], overwriting previous initializers. 1563 SemaRef.Diag(InitRange.getBegin(), 1564 diag::warn_subobject_initializer_overrides) 1565 << InitRange; 1566 SemaRef.Diag(ExistingInit->getSourceRange().getBegin(), 1567 diag::note_previous_initializer) 1568 << /*FIXME:has side effects=*/0 1569 << ExistingInit->getSourceRange(); 1570 } 1571 1572 InitListExpr *Result 1573 = new (SemaRef.Context) InitListExpr(InitRange.getBegin(), 0, 0, 1574 InitRange.getEnd()); 1575 1576 Result->setType(CurrentObjectType); 1577 1578 // Pre-allocate storage for the structured initializer list. 1579 unsigned NumElements = 0; 1580 unsigned NumInits = 0; 1581 if (!StructuredList) 1582 NumInits = IList->getNumInits(); 1583 else if (Index < IList->getNumInits()) { 1584 if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) 1585 NumInits = SubList->getNumInits(); 1586 } 1587 1588 if (const ArrayType *AType 1589 = SemaRef.Context.getAsArrayType(CurrentObjectType)) { 1590 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) { 1591 NumElements = CAType->getSize().getZExtValue(); 1592 // Simple heuristic so that we don't allocate a very large 1593 // initializer with many empty entries at the end. 1594 if (NumInits && NumElements > NumInits) 1595 NumElements = 0; 1596 } 1597 } else if (const VectorType *VType = CurrentObjectType->getAsVectorType()) 1598 NumElements = VType->getNumElements(); 1599 else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) { 1600 RecordDecl *RDecl = RType->getDecl(); 1601 if (RDecl->isUnion()) 1602 NumElements = 1; 1603 else 1604 NumElements = std::distance(RDecl->field_begin(), 1605 RDecl->field_end()); 1606 } 1607 1608 if (NumElements < NumInits) 1609 NumElements = IList->getNumInits(); 1610 1611 Result->reserveInits(NumElements); 1612 1613 // Link this new initializer list into the structured initializer 1614 // lists. 1615 if (StructuredList) 1616 StructuredList->updateInit(StructuredIndex, Result); 1617 else { 1618 Result->setSyntacticForm(IList); 1619 SyntacticToSemantic[IList] = Result; 1620 } 1621 1622 return Result; 1623} 1624 1625/// Update the initializer at index @p StructuredIndex within the 1626/// structured initializer list to the value @p expr. 1627void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList, 1628 unsigned &StructuredIndex, 1629 Expr *expr) { 1630 // No structured initializer list to update 1631 if (!StructuredList) 1632 return; 1633 1634 if (Expr *PrevInit = StructuredList->updateInit(StructuredIndex, expr)) { 1635 // This initializer overwrites a previous initializer. Warn. 1636 SemaRef.Diag(expr->getSourceRange().getBegin(), 1637 diag::warn_initializer_overrides) 1638 << expr->getSourceRange(); 1639 SemaRef.Diag(PrevInit->getSourceRange().getBegin(), 1640 diag::note_previous_initializer) 1641 << /*FIXME:has side effects=*/0 1642 << PrevInit->getSourceRange(); 1643 } 1644 1645 ++StructuredIndex; 1646} 1647 1648/// Check that the given Index expression is a valid array designator 1649/// value. This is essentailly just a wrapper around 1650/// VerifyIntegerConstantExpression that also checks for negative values 1651/// and produces a reasonable diagnostic if there is a 1652/// failure. Returns true if there was an error, false otherwise. If 1653/// everything went okay, Value will receive the value of the constant 1654/// expression. 1655static bool 1656CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) { 1657 SourceLocation Loc = Index->getSourceRange().getBegin(); 1658 1659 // Make sure this is an integer constant expression. 1660 if (S.VerifyIntegerConstantExpression(Index, &Value)) 1661 return true; 1662 1663 if (Value.isSigned() && Value.isNegative()) 1664 return S.Diag(Loc, diag::err_array_designator_negative) 1665 << Value.toString(10) << Index->getSourceRange(); 1666 1667 Value.setIsUnsigned(true); 1668 return false; 1669} 1670 1671Sema::OwningExprResult Sema::ActOnDesignatedInitializer(Designation &Desig, 1672 SourceLocation Loc, 1673 bool GNUSyntax, 1674 OwningExprResult Init) { 1675 typedef DesignatedInitExpr::Designator ASTDesignator; 1676 1677 bool Invalid = false; 1678 llvm::SmallVector<ASTDesignator, 32> Designators; 1679 llvm::SmallVector<Expr *, 32> InitExpressions; 1680 1681 // Build designators and check array designator expressions. 1682 for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) { 1683 const Designator &D = Desig.getDesignator(Idx); 1684 switch (D.getKind()) { 1685 case Designator::FieldDesignator: 1686 Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(), 1687 D.getFieldLoc())); 1688 break; 1689 1690 case Designator::ArrayDesignator: { 1691 Expr *Index = static_cast<Expr *>(D.getArrayIndex()); 1692 llvm::APSInt IndexValue; 1693 if (!Index->isTypeDependent() && 1694 !Index->isValueDependent() && 1695 CheckArrayDesignatorExpr(*this, Index, IndexValue)) 1696 Invalid = true; 1697 else { 1698 Designators.push_back(ASTDesignator(InitExpressions.size(), 1699 D.getLBracketLoc(), 1700 D.getRBracketLoc())); 1701 InitExpressions.push_back(Index); 1702 } 1703 break; 1704 } 1705 1706 case Designator::ArrayRangeDesignator: { 1707 Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart()); 1708 Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd()); 1709 llvm::APSInt StartValue; 1710 llvm::APSInt EndValue; 1711 bool StartDependent = StartIndex->isTypeDependent() || 1712 StartIndex->isValueDependent(); 1713 bool EndDependent = EndIndex->isTypeDependent() || 1714 EndIndex->isValueDependent(); 1715 if ((!StartDependent && 1716 CheckArrayDesignatorExpr(*this, StartIndex, StartValue)) || 1717 (!EndDependent && 1718 CheckArrayDesignatorExpr(*this, EndIndex, EndValue))) 1719 Invalid = true; 1720 else { 1721 // Make sure we're comparing values with the same bit width. 1722 if (StartDependent || EndDependent) { 1723 // Nothing to compute. 1724 } else if (StartValue.getBitWidth() > EndValue.getBitWidth()) 1725 EndValue.extend(StartValue.getBitWidth()); 1726 else if (StartValue.getBitWidth() < EndValue.getBitWidth()) 1727 StartValue.extend(EndValue.getBitWidth()); 1728 1729 if (!StartDependent && !EndDependent && EndValue < StartValue) { 1730 Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range) 1731 << StartValue.toString(10) << EndValue.toString(10) 1732 << StartIndex->getSourceRange() << EndIndex->getSourceRange(); 1733 Invalid = true; 1734 } else { 1735 Designators.push_back(ASTDesignator(InitExpressions.size(), 1736 D.getLBracketLoc(), 1737 D.getEllipsisLoc(), 1738 D.getRBracketLoc())); 1739 InitExpressions.push_back(StartIndex); 1740 InitExpressions.push_back(EndIndex); 1741 } 1742 } 1743 break; 1744 } 1745 } 1746 } 1747 1748 if (Invalid || Init.isInvalid()) 1749 return ExprError(); 1750 1751 // Clear out the expressions within the designation. 1752 Desig.ClearExprs(*this); 1753 1754 DesignatedInitExpr *DIE 1755 = DesignatedInitExpr::Create(Context, 1756 Designators.data(), Designators.size(), 1757 InitExpressions.data(), InitExpressions.size(), 1758 Loc, GNUSyntax, Init.takeAs<Expr>()); 1759 return Owned(DIE); 1760} 1761 1762bool Sema::CheckInitList(InitListExpr *&InitList, QualType &DeclType) { 1763 InitListChecker CheckInitList(*this, InitList, DeclType); 1764 if (!CheckInitList.HadError()) 1765 InitList = CheckInitList.getFullyStructuredList(); 1766 1767 return CheckInitList.HadError(); 1768} 1769 1770/// \brief Diagnose any semantic errors with value-initialization of 1771/// the given type. 1772/// 1773/// Value-initialization effectively zero-initializes any types 1774/// without user-declared constructors, and calls the default 1775/// constructor for a for any type that has a user-declared 1776/// constructor (C++ [dcl.init]p5). Value-initialization can fail when 1777/// a type with a user-declared constructor does not have an 1778/// accessible, non-deleted default constructor. In C, everything can 1779/// be value-initialized, which corresponds to C's notion of 1780/// initializing objects with static storage duration when no 1781/// initializer is provided for that object. 1782/// 1783/// \returns true if there was an error, false otherwise. 1784bool Sema::CheckValueInitialization(QualType Type, SourceLocation Loc) { 1785 // C++ [dcl.init]p5: 1786 // 1787 // To value-initialize an object of type T means: 1788 1789 // -- if T is an array type, then each element is value-initialized; 1790 if (const ArrayType *AT = Context.getAsArrayType(Type)) 1791 return CheckValueInitialization(AT->getElementType(), Loc); 1792 1793 if (const RecordType *RT = Type->getAs<RecordType>()) { 1794 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 1795 // -- if T is a class type (clause 9) with a user-declared 1796 // constructor (12.1), then the default constructor for T is 1797 // called (and the initialization is ill-formed if T has no 1798 // accessible default constructor); 1799 if (ClassDecl->hasUserDeclaredConstructor()) 1800 // FIXME: Eventually, we'll need to put the constructor decl into the 1801 // AST. 1802 return PerformInitializationByConstructor(Type, 0, 0, Loc, 1803 SourceRange(Loc), 1804 DeclarationName(), 1805 IK_Direct); 1806 } 1807 } 1808 1809 if (Type->isReferenceType()) { 1810 // C++ [dcl.init]p5: 1811 // [...] A program that calls for default-initialization or 1812 // value-initialization of an entity of reference type is 1813 // ill-formed. [...] 1814 // FIXME: Once we have code that goes through this path, add an actual 1815 // diagnostic :) 1816 } 1817 1818 return false; 1819} 1820