1 //===--- SemaDeclSpec.cpp - Declaration Specifier Semantic Analysis -------===// 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 declaration specifiers. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Sema/DeclSpec.h" 15 #include "clang/AST/ASTContext.h" 16 #include "clang/AST/Expr.h" 17 #include "clang/AST/NestedNameSpecifier.h" 18 #include "clang/AST/TypeLoc.h" 19 #include "clang/Basic/LangOptions.h" 20 #include "clang/Lex/Preprocessor.h" 21 #include "clang/Parse/ParseDiagnostic.h" // FIXME: remove this back-dependency! 22 #include "clang/Sema/LocInfoType.h" 23 #include "clang/Sema/ParsedTemplate.h" 24 #include "clang/Sema/Sema.h" 25 #include "clang/Sema/SemaDiagnostic.h" 26 #include "llvm/ADT/STLExtras.h" 27 #include "llvm/Support/ErrorHandling.h" 28 #include <cstring> 29 using namespace clang; 30 31 32 static DiagnosticBuilder Diag(DiagnosticsEngine &D, SourceLocation Loc, 33 unsigned DiagID) { 34 return D.Report(Loc, DiagID); 35 } 36 37 38 void UnqualifiedId::setTemplateId(TemplateIdAnnotation *TemplateId) { 39 assert(TemplateId && "NULL template-id annotation?"); 40 Kind = IK_TemplateId; 41 this->TemplateId = TemplateId; 42 StartLocation = TemplateId->TemplateNameLoc; 43 EndLocation = TemplateId->RAngleLoc; 44 } 45 46 void UnqualifiedId::setConstructorTemplateId(TemplateIdAnnotation *TemplateId) { 47 assert(TemplateId && "NULL template-id annotation?"); 48 Kind = IK_ConstructorTemplateId; 49 this->TemplateId = TemplateId; 50 StartLocation = TemplateId->TemplateNameLoc; 51 EndLocation = TemplateId->RAngleLoc; 52 } 53 54 void CXXScopeSpec::Extend(ASTContext &Context, SourceLocation TemplateKWLoc, 55 TypeLoc TL, SourceLocation ColonColonLoc) { 56 Builder.Extend(Context, TemplateKWLoc, TL, ColonColonLoc); 57 if (Range.getBegin().isInvalid()) 58 Range.setBegin(TL.getBeginLoc()); 59 Range.setEnd(ColonColonLoc); 60 61 assert(Range == Builder.getSourceRange() && 62 "NestedNameSpecifierLoc range computation incorrect"); 63 } 64 65 void CXXScopeSpec::Extend(ASTContext &Context, IdentifierInfo *Identifier, 66 SourceLocation IdentifierLoc, 67 SourceLocation ColonColonLoc) { 68 Builder.Extend(Context, Identifier, IdentifierLoc, ColonColonLoc); 69 70 if (Range.getBegin().isInvalid()) 71 Range.setBegin(IdentifierLoc); 72 Range.setEnd(ColonColonLoc); 73 74 assert(Range == Builder.getSourceRange() && 75 "NestedNameSpecifierLoc range computation incorrect"); 76 } 77 78 void CXXScopeSpec::Extend(ASTContext &Context, NamespaceDecl *Namespace, 79 SourceLocation NamespaceLoc, 80 SourceLocation ColonColonLoc) { 81 Builder.Extend(Context, Namespace, NamespaceLoc, ColonColonLoc); 82 83 if (Range.getBegin().isInvalid()) 84 Range.setBegin(NamespaceLoc); 85 Range.setEnd(ColonColonLoc); 86 87 assert(Range == Builder.getSourceRange() && 88 "NestedNameSpecifierLoc range computation incorrect"); 89 } 90 91 void CXXScopeSpec::Extend(ASTContext &Context, NamespaceAliasDecl *Alias, 92 SourceLocation AliasLoc, 93 SourceLocation ColonColonLoc) { 94 Builder.Extend(Context, Alias, AliasLoc, ColonColonLoc); 95 96 if (Range.getBegin().isInvalid()) 97 Range.setBegin(AliasLoc); 98 Range.setEnd(ColonColonLoc); 99 100 assert(Range == Builder.getSourceRange() && 101 "NestedNameSpecifierLoc range computation incorrect"); 102 } 103 104 void CXXScopeSpec::MakeGlobal(ASTContext &Context, 105 SourceLocation ColonColonLoc) { 106 Builder.MakeGlobal(Context, ColonColonLoc); 107 108 Range = SourceRange(ColonColonLoc); 109 110 assert(Range == Builder.getSourceRange() && 111 "NestedNameSpecifierLoc range computation incorrect"); 112 } 113 114 void CXXScopeSpec::MakeTrivial(ASTContext &Context, 115 NestedNameSpecifier *Qualifier, SourceRange R) { 116 Builder.MakeTrivial(Context, Qualifier, R); 117 Range = R; 118 } 119 120 void CXXScopeSpec::Adopt(NestedNameSpecifierLoc Other) { 121 if (!Other) { 122 Range = SourceRange(); 123 Builder.Clear(); 124 return; 125 } 126 127 Range = Other.getSourceRange(); 128 Builder.Adopt(Other); 129 } 130 131 SourceLocation CXXScopeSpec::getLastQualifierNameLoc() const { 132 if (!Builder.getRepresentation()) 133 return SourceLocation(); 134 return Builder.getTemporary().getLocalBeginLoc(); 135 } 136 137 NestedNameSpecifierLoc 138 CXXScopeSpec::getWithLocInContext(ASTContext &Context) const { 139 if (!Builder.getRepresentation()) 140 return NestedNameSpecifierLoc(); 141 142 return Builder.getWithLocInContext(Context); 143 } 144 145 /// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function. 146 /// "TheDeclarator" is the declarator that this will be added to. 147 DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto, 148 bool isAmbiguous, 149 SourceLocation LParenLoc, 150 ParamInfo *ArgInfo, 151 unsigned NumArgs, 152 SourceLocation EllipsisLoc, 153 SourceLocation RParenLoc, 154 unsigned TypeQuals, 155 bool RefQualifierIsLvalueRef, 156 SourceLocation RefQualifierLoc, 157 SourceLocation ConstQualifierLoc, 158 SourceLocation 159 VolatileQualifierLoc, 160 SourceLocation MutableLoc, 161 ExceptionSpecificationType 162 ESpecType, 163 SourceLocation ESpecLoc, 164 ParsedType *Exceptions, 165 SourceRange *ExceptionRanges, 166 unsigned NumExceptions, 167 Expr *NoexceptExpr, 168 SourceLocation LocalRangeBegin, 169 SourceLocation LocalRangeEnd, 170 Declarator &TheDeclarator, 171 TypeResult TrailingReturnType) { 172 DeclaratorChunk I; 173 I.Kind = Function; 174 I.Loc = LocalRangeBegin; 175 I.EndLoc = LocalRangeEnd; 176 I.Fun.AttrList = 0; 177 I.Fun.hasPrototype = hasProto; 178 I.Fun.isVariadic = EllipsisLoc.isValid(); 179 I.Fun.isAmbiguous = isAmbiguous; 180 I.Fun.LParenLoc = LParenLoc.getRawEncoding(); 181 I.Fun.EllipsisLoc = EllipsisLoc.getRawEncoding(); 182 I.Fun.RParenLoc = RParenLoc.getRawEncoding(); 183 I.Fun.DeleteArgInfo = false; 184 I.Fun.TypeQuals = TypeQuals; 185 I.Fun.NumArgs = NumArgs; 186 I.Fun.ArgInfo = 0; 187 I.Fun.RefQualifierIsLValueRef = RefQualifierIsLvalueRef; 188 I.Fun.RefQualifierLoc = RefQualifierLoc.getRawEncoding(); 189 I.Fun.ConstQualifierLoc = ConstQualifierLoc.getRawEncoding(); 190 I.Fun.VolatileQualifierLoc = VolatileQualifierLoc.getRawEncoding(); 191 I.Fun.MutableLoc = MutableLoc.getRawEncoding(); 192 I.Fun.ExceptionSpecType = ESpecType; 193 I.Fun.ExceptionSpecLoc = ESpecLoc.getRawEncoding(); 194 I.Fun.NumExceptions = 0; 195 I.Fun.Exceptions = 0; 196 I.Fun.NoexceptExpr = 0; 197 I.Fun.HasTrailingReturnType = TrailingReturnType.isUsable() || 198 TrailingReturnType.isInvalid(); 199 I.Fun.TrailingReturnType = TrailingReturnType.get(); 200 201 // new[] an argument array if needed. 202 if (NumArgs) { 203 // If the 'InlineParams' in Declarator is unused and big enough, put our 204 // parameter list there (in an effort to avoid new/delete traffic). If it 205 // is already used (consider a function returning a function pointer) or too 206 // small (function taking too many arguments), go to the heap. 207 if (!TheDeclarator.InlineParamsUsed && 208 NumArgs <= llvm::array_lengthof(TheDeclarator.InlineParams)) { 209 I.Fun.ArgInfo = TheDeclarator.InlineParams; 210 I.Fun.DeleteArgInfo = false; 211 TheDeclarator.InlineParamsUsed = true; 212 } else { 213 I.Fun.ArgInfo = new DeclaratorChunk::ParamInfo[NumArgs]; 214 I.Fun.DeleteArgInfo = true; 215 } 216 memcpy(I.Fun.ArgInfo, ArgInfo, sizeof(ArgInfo[0])*NumArgs); 217 } 218 219 // Check what exception specification information we should actually store. 220 switch (ESpecType) { 221 default: break; // By default, save nothing. 222 case EST_Dynamic: 223 // new[] an exception array if needed 224 if (NumExceptions) { 225 I.Fun.NumExceptions = NumExceptions; 226 I.Fun.Exceptions = new DeclaratorChunk::TypeAndRange[NumExceptions]; 227 for (unsigned i = 0; i != NumExceptions; ++i) { 228 I.Fun.Exceptions[i].Ty = Exceptions[i]; 229 I.Fun.Exceptions[i].Range = ExceptionRanges[i]; 230 } 231 } 232 break; 233 234 case EST_ComputedNoexcept: 235 I.Fun.NoexceptExpr = NoexceptExpr; 236 break; 237 } 238 return I; 239 } 240 241 bool Declarator::isDeclarationOfFunction() const { 242 for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) { 243 switch (DeclTypeInfo[i].Kind) { 244 case DeclaratorChunk::Function: 245 return true; 246 case DeclaratorChunk::Paren: 247 continue; 248 case DeclaratorChunk::Pointer: 249 case DeclaratorChunk::Reference: 250 case DeclaratorChunk::Array: 251 case DeclaratorChunk::BlockPointer: 252 case DeclaratorChunk::MemberPointer: 253 return false; 254 } 255 llvm_unreachable("Invalid type chunk"); 256 } 257 258 switch (DS.getTypeSpecType()) { 259 case TST_atomic: 260 case TST_auto: 261 case TST_bool: 262 case TST_char: 263 case TST_char16: 264 case TST_char32: 265 case TST_class: 266 case TST_decimal128: 267 case TST_decimal32: 268 case TST_decimal64: 269 case TST_double: 270 case TST_enum: 271 case TST_error: 272 case TST_float: 273 case TST_half: 274 case TST_int: 275 case TST_int128: 276 case TST_struct: 277 case TST_interface: 278 case TST_union: 279 case TST_unknown_anytype: 280 case TST_unspecified: 281 case TST_void: 282 case TST_wchar: 283 case TST_image1d_t: 284 case TST_image1d_array_t: 285 case TST_image1d_buffer_t: 286 case TST_image2d_t: 287 case TST_image2d_array_t: 288 case TST_image3d_t: 289 case TST_sampler_t: 290 case TST_event_t: 291 return false; 292 293 case TST_decltype: 294 case TST_typeofExpr: 295 if (Expr *E = DS.getRepAsExpr()) 296 return E->getType()->isFunctionType(); 297 return false; 298 299 case TST_underlyingType: 300 case TST_typename: 301 case TST_typeofType: { 302 QualType QT = DS.getRepAsType().get(); 303 if (QT.isNull()) 304 return false; 305 306 if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) 307 QT = LIT->getType(); 308 309 if (QT.isNull()) 310 return false; 311 312 return QT->isFunctionType(); 313 } 314 } 315 316 llvm_unreachable("Invalid TypeSpecType!"); 317 } 318 319 /// getParsedSpecifiers - Return a bitmask of which flavors of specifiers this 320 /// declaration specifier includes. 321 /// 322 unsigned DeclSpec::getParsedSpecifiers() const { 323 unsigned Res = 0; 324 if (StorageClassSpec != SCS_unspecified || 325 SCS_thread_specified) 326 Res |= PQ_StorageClassSpecifier; 327 328 if (TypeQualifiers != TQ_unspecified) 329 Res |= PQ_TypeQualifier; 330 331 if (hasTypeSpecifier()) 332 Res |= PQ_TypeSpecifier; 333 334 if (FS_inline_specified || FS_virtual_specified || FS_explicit_specified || 335 FS_noreturn_specified) 336 Res |= PQ_FunctionSpecifier; 337 return Res; 338 } 339 340 template <class T> static bool BadSpecifier(T TNew, T TPrev, 341 const char *&PrevSpec, 342 unsigned &DiagID, 343 bool IsExtension = true) { 344 PrevSpec = DeclSpec::getSpecifierName(TPrev); 345 if (TNew != TPrev) 346 DiagID = diag::err_invalid_decl_spec_combination; 347 else 348 DiagID = IsExtension ? diag::ext_duplicate_declspec : 349 diag::warn_duplicate_declspec; 350 return true; 351 } 352 353 const char *DeclSpec::getSpecifierName(DeclSpec::SCS S) { 354 switch (S) { 355 case DeclSpec::SCS_unspecified: return "unspecified"; 356 case DeclSpec::SCS_typedef: return "typedef"; 357 case DeclSpec::SCS_extern: return "extern"; 358 case DeclSpec::SCS_static: return "static"; 359 case DeclSpec::SCS_auto: return "auto"; 360 case DeclSpec::SCS_register: return "register"; 361 case DeclSpec::SCS_private_extern: return "__private_extern__"; 362 case DeclSpec::SCS_mutable: return "mutable"; 363 } 364 llvm_unreachable("Unknown typespec!"); 365 } 366 367 const char *DeclSpec::getSpecifierName(TSW W) { 368 switch (W) { 369 case TSW_unspecified: return "unspecified"; 370 case TSW_short: return "short"; 371 case TSW_long: return "long"; 372 case TSW_longlong: return "long long"; 373 } 374 llvm_unreachable("Unknown typespec!"); 375 } 376 377 const char *DeclSpec::getSpecifierName(TSC C) { 378 switch (C) { 379 case TSC_unspecified: return "unspecified"; 380 case TSC_imaginary: return "imaginary"; 381 case TSC_complex: return "complex"; 382 } 383 llvm_unreachable("Unknown typespec!"); 384 } 385 386 387 const char *DeclSpec::getSpecifierName(TSS S) { 388 switch (S) { 389 case TSS_unspecified: return "unspecified"; 390 case TSS_signed: return "signed"; 391 case TSS_unsigned: return "unsigned"; 392 } 393 llvm_unreachable("Unknown typespec!"); 394 } 395 396 const char *DeclSpec::getSpecifierName(DeclSpec::TST T) { 397 switch (T) { 398 case DeclSpec::TST_unspecified: return "unspecified"; 399 case DeclSpec::TST_void: return "void"; 400 case DeclSpec::TST_char: return "char"; 401 case DeclSpec::TST_wchar: return "wchar_t"; 402 case DeclSpec::TST_char16: return "char16_t"; 403 case DeclSpec::TST_char32: return "char32_t"; 404 case DeclSpec::TST_int: return "int"; 405 case DeclSpec::TST_int128: return "__int128"; 406 case DeclSpec::TST_half: return "half"; 407 case DeclSpec::TST_float: return "float"; 408 case DeclSpec::TST_double: return "double"; 409 case DeclSpec::TST_bool: return "_Bool"; 410 case DeclSpec::TST_decimal32: return "_Decimal32"; 411 case DeclSpec::TST_decimal64: return "_Decimal64"; 412 case DeclSpec::TST_decimal128: return "_Decimal128"; 413 case DeclSpec::TST_enum: return "enum"; 414 case DeclSpec::TST_class: return "class"; 415 case DeclSpec::TST_union: return "union"; 416 case DeclSpec::TST_struct: return "struct"; 417 case DeclSpec::TST_interface: return "__interface"; 418 case DeclSpec::TST_typename: return "type-name"; 419 case DeclSpec::TST_typeofType: 420 case DeclSpec::TST_typeofExpr: return "typeof"; 421 case DeclSpec::TST_auto: return "auto"; 422 case DeclSpec::TST_decltype: return "(decltype)"; 423 case DeclSpec::TST_underlyingType: return "__underlying_type"; 424 case DeclSpec::TST_unknown_anytype: return "__unknown_anytype"; 425 case DeclSpec::TST_atomic: return "_Atomic"; 426 case DeclSpec::TST_image1d_t: return "image1d_t"; 427 case DeclSpec::TST_image1d_array_t: return "image1d_array_t"; 428 case DeclSpec::TST_image1d_buffer_t: return "image1d_buffer_t"; 429 case DeclSpec::TST_image2d_t: return "image2d_t"; 430 case DeclSpec::TST_image2d_array_t: return "image2d_array_t"; 431 case DeclSpec::TST_image3d_t: return "image3d_t"; 432 case DeclSpec::TST_sampler_t: return "sampler_t"; 433 case DeclSpec::TST_event_t: return "event_t"; 434 case DeclSpec::TST_error: return "(error)"; 435 } 436 llvm_unreachable("Unknown typespec!"); 437 } 438 439 const char *DeclSpec::getSpecifierName(TQ T) { 440 switch (T) { 441 case DeclSpec::TQ_unspecified: return "unspecified"; 442 case DeclSpec::TQ_const: return "const"; 443 case DeclSpec::TQ_restrict: return "restrict"; 444 case DeclSpec::TQ_volatile: return "volatile"; 445 } 446 llvm_unreachable("Unknown typespec!"); 447 } 448 449 bool DeclSpec::SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, 450 const char *&PrevSpec, 451 unsigned &DiagID) { 452 // OpenCL v1.1 s6.8g: "The extern, static, auto and register storage-class 453 // specifiers are not supported. 454 // It seems sensible to prohibit private_extern too 455 // The cl_clang_storage_class_specifiers extension enables support for 456 // these storage-class specifiers. 457 // OpenCL v1.2 s6.8 changes this to "The auto and register storage-class 458 // specifiers are not supported." 459 if (S.getLangOpts().OpenCL && 460 !S.getOpenCLOptions().cl_clang_storage_class_specifiers) { 461 switch (SC) { 462 case SCS_extern: 463 case SCS_private_extern: 464 case SCS_static: 465 if (S.getLangOpts().OpenCLVersion < 120) { 466 DiagID = diag::err_not_opencl_storage_class_specifier; 467 PrevSpec = getSpecifierName(SC); 468 return true; 469 } 470 break; 471 case SCS_auto: 472 case SCS_register: 473 DiagID = diag::err_not_opencl_storage_class_specifier; 474 PrevSpec = getSpecifierName(SC); 475 return true; 476 default: 477 break; 478 } 479 } 480 481 if (StorageClassSpec != SCS_unspecified) { 482 // Maybe this is an attempt to use C++0x 'auto' outside of C++0x mode. 483 bool isInvalid = true; 484 if (TypeSpecType == TST_unspecified && S.getLangOpts().CPlusPlus) { 485 if (SC == SCS_auto) 486 return SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID); 487 if (StorageClassSpec == SCS_auto) { 488 isInvalid = SetTypeSpecType(TST_auto, StorageClassSpecLoc, 489 PrevSpec, DiagID); 490 assert(!isInvalid && "auto SCS -> TST recovery failed"); 491 } 492 } 493 494 // Changing storage class is allowed only if the previous one 495 // was the 'extern' that is part of a linkage specification and 496 // the new storage class is 'typedef'. 497 if (isInvalid && 498 !(SCS_extern_in_linkage_spec && 499 StorageClassSpec == SCS_extern && 500 SC == SCS_typedef)) 501 return BadSpecifier(SC, (SCS)StorageClassSpec, PrevSpec, DiagID); 502 } 503 StorageClassSpec = SC; 504 StorageClassSpecLoc = Loc; 505 assert((unsigned)SC == StorageClassSpec && "SCS constants overflow bitfield"); 506 return false; 507 } 508 509 bool DeclSpec::SetStorageClassSpecThread(SourceLocation Loc, 510 const char *&PrevSpec, 511 unsigned &DiagID) { 512 if (SCS_thread_specified) { 513 PrevSpec = "__thread"; 514 DiagID = diag::ext_duplicate_declspec; 515 return true; 516 } 517 SCS_thread_specified = true; 518 SCS_threadLoc = Loc; 519 return false; 520 } 521 522 /// These methods set the specified attribute of the DeclSpec, but return true 523 /// and ignore the request if invalid (e.g. "extern" then "auto" is 524 /// specified). 525 bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc, 526 const char *&PrevSpec, 527 unsigned &DiagID) { 528 // Overwrite TSWLoc only if TypeSpecWidth was unspecified, so that 529 // for 'long long' we will keep the source location of the first 'long'. 530 if (TypeSpecWidth == TSW_unspecified) 531 TSWLoc = Loc; 532 // Allow turning long -> long long. 533 else if (W != TSW_longlong || TypeSpecWidth != TSW_long) 534 return BadSpecifier(W, (TSW)TypeSpecWidth, PrevSpec, DiagID); 535 TypeSpecWidth = W; 536 if (TypeAltiVecVector && !TypeAltiVecBool && 537 ((TypeSpecWidth == TSW_long) || (TypeSpecWidth == TSW_longlong))) { 538 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); 539 DiagID = diag::warn_vector_long_decl_spec_combination; 540 return true; 541 } 542 return false; 543 } 544 545 bool DeclSpec::SetTypeSpecComplex(TSC C, SourceLocation Loc, 546 const char *&PrevSpec, 547 unsigned &DiagID) { 548 if (TypeSpecComplex != TSC_unspecified) 549 return BadSpecifier(C, (TSC)TypeSpecComplex, PrevSpec, DiagID); 550 TypeSpecComplex = C; 551 TSCLoc = Loc; 552 return false; 553 } 554 555 bool DeclSpec::SetTypeSpecSign(TSS S, SourceLocation Loc, 556 const char *&PrevSpec, 557 unsigned &DiagID) { 558 if (TypeSpecSign != TSS_unspecified) 559 return BadSpecifier(S, (TSS)TypeSpecSign, PrevSpec, DiagID); 560 TypeSpecSign = S; 561 TSSLoc = Loc; 562 return false; 563 } 564 565 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, 566 const char *&PrevSpec, 567 unsigned &DiagID, 568 ParsedType Rep) { 569 return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep); 570 } 571 572 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc, 573 SourceLocation TagNameLoc, 574 const char *&PrevSpec, 575 unsigned &DiagID, 576 ParsedType Rep) { 577 assert(isTypeRep(T) && "T does not store a type"); 578 assert(Rep && "no type provided!"); 579 if (TypeSpecType != TST_unspecified) { 580 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); 581 DiagID = diag::err_invalid_decl_spec_combination; 582 return true; 583 } 584 TypeSpecType = T; 585 TypeRep = Rep; 586 TSTLoc = TagKwLoc; 587 TSTNameLoc = TagNameLoc; 588 TypeSpecOwned = false; 589 return false; 590 } 591 592 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, 593 const char *&PrevSpec, 594 unsigned &DiagID, 595 Expr *Rep) { 596 assert(isExprRep(T) && "T does not store an expr"); 597 assert(Rep && "no expression provided!"); 598 if (TypeSpecType != TST_unspecified) { 599 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); 600 DiagID = diag::err_invalid_decl_spec_combination; 601 return true; 602 } 603 TypeSpecType = T; 604 ExprRep = Rep; 605 TSTLoc = Loc; 606 TSTNameLoc = Loc; 607 TypeSpecOwned = false; 608 return false; 609 } 610 611 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, 612 const char *&PrevSpec, 613 unsigned &DiagID, 614 Decl *Rep, bool Owned) { 615 return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned); 616 } 617 618 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc, 619 SourceLocation TagNameLoc, 620 const char *&PrevSpec, 621 unsigned &DiagID, 622 Decl *Rep, bool Owned) { 623 assert(isDeclRep(T) && "T does not store a decl"); 624 // Unlike the other cases, we don't assert that we actually get a decl. 625 626 if (TypeSpecType != TST_unspecified) { 627 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); 628 DiagID = diag::err_invalid_decl_spec_combination; 629 return true; 630 } 631 TypeSpecType = T; 632 DeclRep = Rep; 633 TSTLoc = TagKwLoc; 634 TSTNameLoc = TagNameLoc; 635 TypeSpecOwned = Owned; 636 return false; 637 } 638 639 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, 640 const char *&PrevSpec, 641 unsigned &DiagID) { 642 assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) && 643 "rep required for these type-spec kinds!"); 644 if (TypeSpecType != TST_unspecified) { 645 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); 646 DiagID = diag::err_invalid_decl_spec_combination; 647 return true; 648 } 649 TSTLoc = Loc; 650 TSTNameLoc = Loc; 651 if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) { 652 TypeAltiVecBool = true; 653 return false; 654 } 655 TypeSpecType = T; 656 TypeSpecOwned = false; 657 if (TypeAltiVecVector && !TypeAltiVecBool && (TypeSpecType == TST_double)) { 658 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); 659 DiagID = diag::err_invalid_vector_decl_spec; 660 return true; 661 } 662 return false; 663 } 664 665 bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc, 666 const char *&PrevSpec, unsigned &DiagID) { 667 if (TypeSpecType != TST_unspecified) { 668 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); 669 DiagID = diag::err_invalid_vector_decl_spec_combination; 670 return true; 671 } 672 TypeAltiVecVector = isAltiVecVector; 673 AltiVecLoc = Loc; 674 return false; 675 } 676 677 bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc, 678 const char *&PrevSpec, unsigned &DiagID) { 679 if (!TypeAltiVecVector || TypeAltiVecPixel || 680 (TypeSpecType != TST_unspecified)) { 681 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); 682 DiagID = diag::err_invalid_pixel_decl_spec_combination; 683 return true; 684 } 685 TypeAltiVecPixel = isAltiVecPixel; 686 TSTLoc = Loc; 687 TSTNameLoc = Loc; 688 return false; 689 } 690 691 bool DeclSpec::SetTypeSpecError() { 692 TypeSpecType = TST_error; 693 TypeSpecOwned = false; 694 TSTLoc = SourceLocation(); 695 TSTNameLoc = SourceLocation(); 696 return false; 697 } 698 699 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec, 700 unsigned &DiagID, const LangOptions &Lang) { 701 // Duplicates are permitted in C99, but are not permitted in C++. However, 702 // since this is likely not what the user intended, we will always warn. We 703 // do not need to set the qualifier's location since we already have it. 704 if (TypeQualifiers & T) { 705 bool IsExtension = true; 706 if (Lang.C99) 707 IsExtension = false; 708 return BadSpecifier(T, T, PrevSpec, DiagID, IsExtension); 709 } 710 TypeQualifiers |= T; 711 712 switch (T) { 713 default: llvm_unreachable("Unknown type qualifier!"); 714 case TQ_const: TQ_constLoc = Loc; break; 715 case TQ_restrict: TQ_restrictLoc = Loc; break; 716 case TQ_volatile: TQ_volatileLoc = Loc; break; 717 } 718 return false; 719 } 720 721 bool DeclSpec::setFunctionSpecInline(SourceLocation Loc) { 722 // 'inline inline' is ok. 723 FS_inline_specified = true; 724 FS_inlineLoc = Loc; 725 return false; 726 } 727 728 bool DeclSpec::setFunctionSpecVirtual(SourceLocation Loc) { 729 // 'virtual virtual' is ok. 730 FS_virtual_specified = true; 731 FS_virtualLoc = Loc; 732 return false; 733 } 734 735 bool DeclSpec::setFunctionSpecExplicit(SourceLocation Loc) { 736 // 'explicit explicit' is ok. 737 FS_explicit_specified = true; 738 FS_explicitLoc = Loc; 739 return false; 740 } 741 742 bool DeclSpec::setFunctionSpecNoreturn(SourceLocation Loc) { 743 // '_Noreturn _Noreturn' is ok. 744 FS_noreturn_specified = true; 745 FS_noreturnLoc = Loc; 746 return false; 747 } 748 749 bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec, 750 unsigned &DiagID) { 751 if (Friend_specified) { 752 PrevSpec = "friend"; 753 DiagID = diag::ext_duplicate_declspec; 754 return true; 755 } 756 757 Friend_specified = true; 758 FriendLoc = Loc; 759 return false; 760 } 761 762 bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec, 763 unsigned &DiagID) { 764 if (isModulePrivateSpecified()) { 765 PrevSpec = "__module_private__"; 766 DiagID = diag::ext_duplicate_declspec; 767 return true; 768 } 769 770 ModulePrivateLoc = Loc; 771 return false; 772 } 773 774 bool DeclSpec::SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec, 775 unsigned &DiagID) { 776 // 'constexpr constexpr' is ok. 777 Constexpr_specified = true; 778 ConstexprLoc = Loc; 779 return false; 780 } 781 782 void DeclSpec::setProtocolQualifiers(Decl * const *Protos, 783 unsigned NP, 784 SourceLocation *ProtoLocs, 785 SourceLocation LAngleLoc) { 786 if (NP == 0) return; 787 Decl **ProtoQuals = new Decl*[NP]; 788 memcpy(ProtoQuals, Protos, sizeof(Decl*)*NP); 789 ProtocolQualifiers = ProtoQuals; 790 ProtocolLocs = new SourceLocation[NP]; 791 memcpy(ProtocolLocs, ProtoLocs, sizeof(SourceLocation)*NP); 792 NumProtocolQualifiers = NP; 793 ProtocolLAngleLoc = LAngleLoc; 794 } 795 796 void DeclSpec::SaveWrittenBuiltinSpecs() { 797 writtenBS.Sign = getTypeSpecSign(); 798 writtenBS.Width = getTypeSpecWidth(); 799 writtenBS.Type = getTypeSpecType(); 800 // Search the list of attributes for the presence of a mode attribute. 801 writtenBS.ModeAttr = false; 802 AttributeList* attrs = getAttributes().getList(); 803 while (attrs) { 804 if (attrs->getKind() == AttributeList::AT_Mode) { 805 writtenBS.ModeAttr = true; 806 break; 807 } 808 attrs = attrs->getNext(); 809 } 810 } 811 812 void DeclSpec::SaveStorageSpecifierAsWritten() { 813 if (SCS_extern_in_linkage_spec && StorageClassSpec == SCS_extern) 814 // If 'extern' is part of a linkage specification, 815 // then it is not a storage class "as written". 816 StorageClassSpecAsWritten = SCS_unspecified; 817 else 818 StorageClassSpecAsWritten = StorageClassSpec; 819 } 820 821 /// Finish - This does final analysis of the declspec, rejecting things like 822 /// "_Imaginary" (lacking an FP type). This returns a diagnostic to issue or 823 /// diag::NUM_DIAGNOSTICS if there is no error. After calling this method, 824 /// DeclSpec is guaranteed self-consistent, even if an error occurred. 825 void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP) { 826 // Before possibly changing their values, save specs as written. 827 SaveWrittenBuiltinSpecs(); 828 SaveStorageSpecifierAsWritten(); 829 830 // Check the type specifier components first. 831 832 // Validate and finalize AltiVec vector declspec. 833 if (TypeAltiVecVector) { 834 if (TypeAltiVecBool) { 835 // Sign specifiers are not allowed with vector bool. (PIM 2.1) 836 if (TypeSpecSign != TSS_unspecified) { 837 Diag(D, TSSLoc, diag::err_invalid_vector_bool_decl_spec) 838 << getSpecifierName((TSS)TypeSpecSign); 839 } 840 841 // Only char/int are valid with vector bool. (PIM 2.1) 842 if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) && 843 (TypeSpecType != TST_int)) || TypeAltiVecPixel) { 844 Diag(D, TSTLoc, diag::err_invalid_vector_bool_decl_spec) 845 << (TypeAltiVecPixel ? "__pixel" : 846 getSpecifierName((TST)TypeSpecType)); 847 } 848 849 // Only 'short' is valid with vector bool. (PIM 2.1) 850 if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short)) 851 Diag(D, TSWLoc, diag::err_invalid_vector_bool_decl_spec) 852 << getSpecifierName((TSW)TypeSpecWidth); 853 854 // Elements of vector bool are interpreted as unsigned. (PIM 2.1) 855 if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) || 856 (TypeSpecWidth != TSW_unspecified)) 857 TypeSpecSign = TSS_unsigned; 858 } 859 860 if (TypeAltiVecPixel) { 861 //TODO: perform validation 862 TypeSpecType = TST_int; 863 TypeSpecSign = TSS_unsigned; 864 TypeSpecWidth = TSW_short; 865 TypeSpecOwned = false; 866 } 867 } 868 869 // signed/unsigned are only valid with int/char/wchar_t. 870 if (TypeSpecSign != TSS_unspecified) { 871 if (TypeSpecType == TST_unspecified) 872 TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int. 873 else if (TypeSpecType != TST_int && TypeSpecType != TST_int128 && 874 TypeSpecType != TST_char && TypeSpecType != TST_wchar) { 875 Diag(D, TSSLoc, diag::err_invalid_sign_spec) 876 << getSpecifierName((TST)TypeSpecType); 877 // signed double -> double. 878 TypeSpecSign = TSS_unspecified; 879 } 880 } 881 882 // Validate the width of the type. 883 switch (TypeSpecWidth) { 884 case TSW_unspecified: break; 885 case TSW_short: // short int 886 case TSW_longlong: // long long int 887 if (TypeSpecType == TST_unspecified) 888 TypeSpecType = TST_int; // short -> short int, long long -> long long int. 889 else if (TypeSpecType != TST_int) { 890 Diag(D, TSWLoc, 891 TypeSpecWidth == TSW_short ? diag::err_invalid_short_spec 892 : diag::err_invalid_longlong_spec) 893 << getSpecifierName((TST)TypeSpecType); 894 TypeSpecType = TST_int; 895 TypeSpecOwned = false; 896 } 897 break; 898 case TSW_long: // long double, long int 899 if (TypeSpecType == TST_unspecified) 900 TypeSpecType = TST_int; // long -> long int. 901 else if (TypeSpecType != TST_int && TypeSpecType != TST_double) { 902 Diag(D, TSWLoc, diag::err_invalid_long_spec) 903 << getSpecifierName((TST)TypeSpecType); 904 TypeSpecType = TST_int; 905 TypeSpecOwned = false; 906 } 907 break; 908 } 909 910 // TODO: if the implementation does not implement _Complex or _Imaginary, 911 // disallow their use. Need information about the backend. 912 if (TypeSpecComplex != TSC_unspecified) { 913 if (TypeSpecType == TST_unspecified) { 914 Diag(D, TSCLoc, diag::ext_plain_complex) 915 << FixItHint::CreateInsertion( 916 PP.getLocForEndOfToken(getTypeSpecComplexLoc()), 917 " double"); 918 TypeSpecType = TST_double; // _Complex -> _Complex double. 919 } else if (TypeSpecType == TST_int || TypeSpecType == TST_char) { 920 // Note that this intentionally doesn't include _Complex _Bool. 921 if (!PP.getLangOpts().CPlusPlus) 922 Diag(D, TSTLoc, diag::ext_integer_complex); 923 } else if (TypeSpecType != TST_float && TypeSpecType != TST_double) { 924 Diag(D, TSCLoc, diag::err_invalid_complex_spec) 925 << getSpecifierName((TST)TypeSpecType); 926 TypeSpecComplex = TSC_unspecified; 927 } 928 } 929 930 // If no type specifier was provided and we're parsing a language where 931 // the type specifier is not optional, but we got 'auto' as a storage 932 // class specifier, then assume this is an attempt to use C++0x's 'auto' 933 // type specifier. 934 // FIXME: Does Microsoft really support implicit int in C++? 935 if (PP.getLangOpts().CPlusPlus && !PP.getLangOpts().MicrosoftExt && 936 TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) { 937 TypeSpecType = TST_auto; 938 StorageClassSpec = StorageClassSpecAsWritten = SCS_unspecified; 939 TSTLoc = TSTNameLoc = StorageClassSpecLoc; 940 StorageClassSpecLoc = SourceLocation(); 941 } 942 // Diagnose if we've recovered from an ill-formed 'auto' storage class 943 // specifier in a pre-C++0x dialect of C++. 944 if (!PP.getLangOpts().CPlusPlus11 && TypeSpecType == TST_auto) 945 Diag(D, TSTLoc, diag::ext_auto_type_specifier); 946 if (PP.getLangOpts().CPlusPlus && !PP.getLangOpts().CPlusPlus11 && 947 StorageClassSpec == SCS_auto) 948 Diag(D, StorageClassSpecLoc, diag::warn_auto_storage_class) 949 << FixItHint::CreateRemoval(StorageClassSpecLoc); 950 if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32) 951 Diag(D, TSTLoc, diag::warn_cxx98_compat_unicode_type) 952 << (TypeSpecType == TST_char16 ? "char16_t" : "char32_t"); 953 if (Constexpr_specified) 954 Diag(D, ConstexprLoc, diag::warn_cxx98_compat_constexpr); 955 956 // C++ [class.friend]p6: 957 // No storage-class-specifier shall appear in the decl-specifier-seq 958 // of a friend declaration. 959 if (isFriendSpecified() && getStorageClassSpec()) { 960 DeclSpec::SCS SC = getStorageClassSpec(); 961 const char *SpecName = getSpecifierName(SC); 962 963 SourceLocation SCLoc = getStorageClassSpecLoc(); 964 SourceLocation SCEndLoc = SCLoc.getLocWithOffset(strlen(SpecName)); 965 966 Diag(D, SCLoc, diag::err_friend_storage_spec) 967 << SpecName 968 << FixItHint::CreateRemoval(SourceRange(SCLoc, SCEndLoc)); 969 970 ClearStorageClassSpecs(); 971 } 972 973 assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType)); 974 975 // Okay, now we can infer the real type. 976 977 // TODO: return "auto function" and other bad things based on the real type. 978 979 // 'data definition has no type or storage class'? 980 } 981 982 bool DeclSpec::isMissingDeclaratorOk() { 983 TST tst = getTypeSpecType(); 984 return isDeclRep(tst) && getRepAsDecl() != 0 && 985 StorageClassSpec != DeclSpec::SCS_typedef; 986 } 987 988 void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc, 989 OverloadedOperatorKind Op, 990 SourceLocation SymbolLocations[3]) { 991 Kind = IK_OperatorFunctionId; 992 StartLocation = OperatorLoc; 993 EndLocation = OperatorLoc; 994 OperatorFunctionId.Operator = Op; 995 for (unsigned I = 0; I != 3; ++I) { 996 OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding(); 997 998 if (SymbolLocations[I].isValid()) 999 EndLocation = SymbolLocations[I]; 1000 } 1001 } 1002 1003 bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc, 1004 const char *&PrevSpec) { 1005 LastLocation = Loc; 1006 1007 if (Specifiers & VS) { 1008 PrevSpec = getSpecifierName(VS); 1009 return true; 1010 } 1011 1012 Specifiers |= VS; 1013 1014 switch (VS) { 1015 default: llvm_unreachable("Unknown specifier!"); 1016 case VS_Override: VS_overrideLoc = Loc; break; 1017 case VS_Final: VS_finalLoc = Loc; break; 1018 } 1019 1020 return false; 1021 } 1022 1023 const char *VirtSpecifiers::getSpecifierName(Specifier VS) { 1024 switch (VS) { 1025 default: llvm_unreachable("Unknown specifier"); 1026 case VS_Override: return "override"; 1027 case VS_Final: return "final"; 1028 } 1029 } 1030