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