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