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