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