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