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