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