blob: de013afa14d1b68ff75bbc6da5fef0e1dbc17a9e [file] [log] [blame]
Craig Topper56e51be2015-11-15 17:27:55 +00001//===--- DeclSpec.cpp - Declaration Specifier Semantic Analysis -----------===//
Chris Lattnerb9093cd2006-08-04 04:39:53 +00002//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnerb9093cd2006-08-04 04:39:53 +00007//
8//===----------------------------------------------------------------------===//
9//
Chris Lattner289ab7b2006-11-08 06:54:53 +000010// This file implements semantic analysis for declaration specifiers.
Chris Lattnerb9093cd2006-08-04 04:39:53 +000011//
12//===----------------------------------------------------------------------===//
13
John McCall8b0666c2010-08-20 18:27:03 +000014#include "clang/Sema/DeclSpec.h"
Douglas Gregor869ad452011-02-24 17:54:50 +000015#include "clang/AST/ASTContext.h"
Reid Kleckner9a7f3e62013-10-08 00:58:57 +000016#include "clang/AST/DeclCXX.h"
Douglas Gregorc15b0cf2011-06-25 00:56:27 +000017#include "clang/AST/Expr.h"
Benjamin Kramer31b382e2016-02-01 17:42:01 +000018#include "clang/AST/LocInfoType.h"
Douglas Gregor90c99722011-02-24 00:17:56 +000019#include "clang/AST/TypeLoc.h"
Chris Lattnerda48a8e2006-08-04 05:25:55 +000020#include "clang/Basic/LangOptions.h"
Bill Schmidt691e01d2014-10-31 19:19:24 +000021#include "clang/Basic/TargetInfo.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000022#include "clang/Sema/ParsedTemplate.h"
23#include "clang/Sema/Sema.h"
24#include "clang/Sema/SemaDiagnostic.h"
Chris Lattner1ce41ed2009-01-20 19:11:22 +000025#include "llvm/ADT/STLExtras.h"
Richard Smithb4a9e862013-04-12 22:46:28 +000026#include "llvm/ADT/SmallString.h"
Douglas Gregor52537682009-03-19 00:18:19 +000027#include <cstring>
Chris Lattnerb9093cd2006-08-04 04:39:53 +000028using namespace clang;
29
Chris Lattner3b0f3ef2008-11-22 08:32:36 +000030
Douglas Gregorb53edfb2009-11-10 19:49:08 +000031void UnqualifiedId::setTemplateId(TemplateIdAnnotation *TemplateId) {
32 assert(TemplateId && "NULL template-id annotation?");
33 Kind = IK_TemplateId;
34 this->TemplateId = TemplateId;
35 StartLocation = TemplateId->TemplateNameLoc;
36 EndLocation = TemplateId->RAngleLoc;
37}
38
Douglas Gregor9de54ea2010-01-13 17:31:36 +000039void UnqualifiedId::setConstructorTemplateId(TemplateIdAnnotation *TemplateId) {
40 assert(TemplateId && "NULL template-id annotation?");
41 Kind = IK_ConstructorTemplateId;
42 this->TemplateId = TemplateId;
43 StartLocation = TemplateId->TemplateNameLoc;
44 EndLocation = TemplateId->RAngleLoc;
45}
46
Douglas Gregor90c99722011-02-24 00:17:56 +000047void CXXScopeSpec::Extend(ASTContext &Context, SourceLocation TemplateKWLoc,
48 TypeLoc TL, SourceLocation ColonColonLoc) {
Douglas Gregor9b272512011-02-28 23:58:31 +000049 Builder.Extend(Context, TemplateKWLoc, TL, ColonColonLoc);
Douglas Gregor90c99722011-02-24 00:17:56 +000050 if (Range.getBegin().isInvalid())
51 Range.setBegin(TL.getBeginLoc());
52 Range.setEnd(ColonColonLoc);
Douglas Gregor869ad452011-02-24 17:54:50 +000053
Douglas Gregor9b272512011-02-28 23:58:31 +000054 assert(Range == Builder.getSourceRange() &&
Douglas Gregor869ad452011-02-24 17:54:50 +000055 "NestedNameSpecifierLoc range computation incorrect");
Douglas Gregor90c99722011-02-24 00:17:56 +000056}
57
58void CXXScopeSpec::Extend(ASTContext &Context, IdentifierInfo *Identifier,
59 SourceLocation IdentifierLoc,
60 SourceLocation ColonColonLoc) {
Douglas Gregor9b272512011-02-28 23:58:31 +000061 Builder.Extend(Context, Identifier, IdentifierLoc, ColonColonLoc);
62
Douglas Gregor90c99722011-02-24 00:17:56 +000063 if (Range.getBegin().isInvalid())
64 Range.setBegin(IdentifierLoc);
65 Range.setEnd(ColonColonLoc);
Douglas Gregor869ad452011-02-24 17:54:50 +000066
Douglas Gregor9b272512011-02-28 23:58:31 +000067 assert(Range == Builder.getSourceRange() &&
Douglas Gregor869ad452011-02-24 17:54:50 +000068 "NestedNameSpecifierLoc range computation incorrect");
Douglas Gregor90c99722011-02-24 00:17:56 +000069}
70
71void CXXScopeSpec::Extend(ASTContext &Context, NamespaceDecl *Namespace,
72 SourceLocation NamespaceLoc,
73 SourceLocation ColonColonLoc) {
Douglas Gregor9b272512011-02-28 23:58:31 +000074 Builder.Extend(Context, Namespace, NamespaceLoc, ColonColonLoc);
75
Douglas Gregor90c99722011-02-24 00:17:56 +000076 if (Range.getBegin().isInvalid())
77 Range.setBegin(NamespaceLoc);
78 Range.setEnd(ColonColonLoc);
Douglas Gregor869ad452011-02-24 17:54:50 +000079
Douglas Gregor9b272512011-02-28 23:58:31 +000080 assert(Range == Builder.getSourceRange() &&
Douglas Gregor869ad452011-02-24 17:54:50 +000081 "NestedNameSpecifierLoc range computation incorrect");
Douglas Gregor90c99722011-02-24 00:17:56 +000082}
83
Douglas Gregor7b26ff92011-02-24 02:36:08 +000084void CXXScopeSpec::Extend(ASTContext &Context, NamespaceAliasDecl *Alias,
85 SourceLocation AliasLoc,
86 SourceLocation ColonColonLoc) {
Douglas Gregor9b272512011-02-28 23:58:31 +000087 Builder.Extend(Context, Alias, AliasLoc, ColonColonLoc);
88
Douglas Gregor7b26ff92011-02-24 02:36:08 +000089 if (Range.getBegin().isInvalid())
90 Range.setBegin(AliasLoc);
91 Range.setEnd(ColonColonLoc);
Douglas Gregor869ad452011-02-24 17:54:50 +000092
Douglas Gregor9b272512011-02-28 23:58:31 +000093 assert(Range == Builder.getSourceRange() &&
Douglas Gregor869ad452011-02-24 17:54:50 +000094 "NestedNameSpecifierLoc range computation incorrect");
Douglas Gregor7b26ff92011-02-24 02:36:08 +000095}
96
Douglas Gregor90c99722011-02-24 00:17:56 +000097void CXXScopeSpec::MakeGlobal(ASTContext &Context,
98 SourceLocation ColonColonLoc) {
Douglas Gregor9b272512011-02-28 23:58:31 +000099 Builder.MakeGlobal(Context, ColonColonLoc);
100
Douglas Gregor90c99722011-02-24 00:17:56 +0000101 Range = SourceRange(ColonColonLoc);
Douglas Gregor869ad452011-02-24 17:54:50 +0000102
Douglas Gregor9b272512011-02-28 23:58:31 +0000103 assert(Range == Builder.getSourceRange() &&
Douglas Gregor869ad452011-02-24 17:54:50 +0000104 "NestedNameSpecifierLoc range computation incorrect");
105}
106
Nikola Smiljanic67860242014-09-26 00:28:20 +0000107void CXXScopeSpec::MakeSuper(ASTContext &Context, CXXRecordDecl *RD,
108 SourceLocation SuperLoc,
109 SourceLocation ColonColonLoc) {
110 Builder.MakeSuper(Context, RD, SuperLoc, ColonColonLoc);
111
112 Range.setBegin(SuperLoc);
113 Range.setEnd(ColonColonLoc);
114
115 assert(Range == Builder.getSourceRange() &&
116 "NestedNameSpecifierLoc range computation incorrect");
117}
118
Douglas Gregor869ad452011-02-24 17:54:50 +0000119void CXXScopeSpec::MakeTrivial(ASTContext &Context,
120 NestedNameSpecifier *Qualifier, SourceRange R) {
Douglas Gregor9b272512011-02-28 23:58:31 +0000121 Builder.MakeTrivial(Context, Qualifier, R);
Douglas Gregor869ad452011-02-24 17:54:50 +0000122 Range = R;
Douglas Gregor869ad452011-02-24 17:54:50 +0000123}
124
125void CXXScopeSpec::Adopt(NestedNameSpecifierLoc Other) {
126 if (!Other) {
127 Range = SourceRange();
Douglas Gregor9b272512011-02-28 23:58:31 +0000128 Builder.Clear();
Douglas Gregor869ad452011-02-24 17:54:50 +0000129 return;
130 }
Douglas Gregor9b272512011-02-28 23:58:31 +0000131
Douglas Gregor869ad452011-02-24 17:54:50 +0000132 Range = Other.getSourceRange();
Douglas Gregor9b272512011-02-28 23:58:31 +0000133 Builder.Adopt(Other);
Douglas Gregor869ad452011-02-24 17:54:50 +0000134}
135
John McCall21878762011-07-06 06:57:57 +0000136SourceLocation CXXScopeSpec::getLastQualifierNameLoc() const {
137 if (!Builder.getRepresentation())
138 return SourceLocation();
139 return Builder.getTemporary().getLocalBeginLoc();
140}
141
Douglas Gregor14454802011-02-25 02:25:35 +0000142NestedNameSpecifierLoc
143CXXScopeSpec::getWithLocInContext(ASTContext &Context) const {
Douglas Gregor2b1ca9e2011-03-03 21:48:55 +0000144 if (!Builder.getRepresentation())
Douglas Gregor869ad452011-02-24 17:54:50 +0000145 return NestedNameSpecifierLoc();
146
Douglas Gregor9b272512011-02-28 23:58:31 +0000147 return Builder.getWithLocInContext(Context);
Douglas Gregor90c99722011-02-24 00:17:56 +0000148}
149
Chris Lattner1ce41ed2009-01-20 19:11:22 +0000150/// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
151/// "TheDeclarator" is the declarator that this will be added to.
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +0000152DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto,
Richard Smith943c4402012-07-30 21:30:52 +0000153 bool isAmbiguous,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +0000154 SourceLocation LParenLoc,
Alp Tokerc5350722014-02-26 22:27:52 +0000155 ParamInfo *Params,
156 unsigned NumParams,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +0000157 SourceLocation EllipsisLoc,
158 SourceLocation RParenLoc,
Chris Lattner1ce41ed2009-01-20 19:11:22 +0000159 unsigned TypeQuals,
Douglas Gregor54992352011-01-26 03:43:54 +0000160 bool RefQualifierIsLvalueRef,
161 SourceLocation RefQualifierLoc,
Douglas Gregore248eea2011-10-19 06:04:55 +0000162 SourceLocation ConstQualifierLoc,
163 SourceLocation
164 VolatileQualifierLoc,
Hal Finkel23a07392014-10-20 17:32:04 +0000165 SourceLocation
166 RestrictQualifierLoc,
Douglas Gregorad69e652011-07-13 21:47:47 +0000167 SourceLocation MutableLoc,
Sebastian Redl802a4532011-03-05 22:42:13 +0000168 ExceptionSpecificationType
169 ESpecType,
Nathan Wilsone23a9a42015-08-26 04:19:36 +0000170 SourceRange ESpecRange,
John McCallba7bf592010-08-24 05:47:05 +0000171 ParsedType *Exceptions,
Sebastian Redld6434562009-05-29 18:02:33 +0000172 SourceRange *ExceptionRanges,
Sebastian Redl2b9cacb2009-04-29 17:30:04 +0000173 unsigned NumExceptions,
Sebastian Redl802a4532011-03-05 22:42:13 +0000174 Expr *NoexceptExpr,
Richard Smith0b3a4622014-11-13 20:01:57 +0000175 CachedTokens *ExceptionSpecTokens,
Abramo Bagnaraf2a79d92011-03-12 11:17:06 +0000176 SourceLocation LocalRangeBegin,
177 SourceLocation LocalRangeEnd,
Douglas Gregor7fb25412010-10-01 18:44:50 +0000178 Declarator &TheDeclarator,
Richard Smith700537c2012-06-12 01:51:59 +0000179 TypeResult TrailingReturnType) {
Richard Smith8e1ac332013-03-28 01:55:44 +0000180 assert(!(TypeQuals & DeclSpec::TQ_atomic) &&
181 "function cannot have _Atomic qualifier");
182
Chris Lattner1ce41ed2009-01-20 19:11:22 +0000183 DeclaratorChunk I;
Sebastian Redl802a4532011-03-05 22:42:13 +0000184 I.Kind = Function;
Abramo Bagnaraf2a79d92011-03-12 11:17:06 +0000185 I.Loc = LocalRangeBegin;
186 I.EndLoc = LocalRangeEnd;
Craig Topper4b566922014-06-09 02:04:02 +0000187 I.Fun.AttrList = nullptr;
Sebastian Redl802a4532011-03-05 22:42:13 +0000188 I.Fun.hasPrototype = hasProto;
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +0000189 I.Fun.isVariadic = EllipsisLoc.isValid();
Richard Smith943c4402012-07-30 21:30:52 +0000190 I.Fun.isAmbiguous = isAmbiguous;
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +0000191 I.Fun.LParenLoc = LParenLoc.getRawEncoding();
Sebastian Redl802a4532011-03-05 22:42:13 +0000192 I.Fun.EllipsisLoc = EllipsisLoc.getRawEncoding();
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +0000193 I.Fun.RParenLoc = RParenLoc.getRawEncoding();
Alp Tokerc5350722014-02-26 22:27:52 +0000194 I.Fun.DeleteParams = false;
Sebastian Redl802a4532011-03-05 22:42:13 +0000195 I.Fun.TypeQuals = TypeQuals;
Alp Tokerc5350722014-02-26 22:27:52 +0000196 I.Fun.NumParams = NumParams;
Craig Topper4b566922014-06-09 02:04:02 +0000197 I.Fun.Params = nullptr;
Douglas Gregor54992352011-01-26 03:43:54 +0000198 I.Fun.RefQualifierIsLValueRef = RefQualifierIsLvalueRef;
Sebastian Redl802a4532011-03-05 22:42:13 +0000199 I.Fun.RefQualifierLoc = RefQualifierLoc.getRawEncoding();
Douglas Gregore248eea2011-10-19 06:04:55 +0000200 I.Fun.ConstQualifierLoc = ConstQualifierLoc.getRawEncoding();
201 I.Fun.VolatileQualifierLoc = VolatileQualifierLoc.getRawEncoding();
Hal Finkel23a07392014-10-20 17:32:04 +0000202 I.Fun.RestrictQualifierLoc = RestrictQualifierLoc.getRawEncoding();
Douglas Gregorad69e652011-07-13 21:47:47 +0000203 I.Fun.MutableLoc = MutableLoc.getRawEncoding();
Sebastian Redl802a4532011-03-05 22:42:13 +0000204 I.Fun.ExceptionSpecType = ESpecType;
Nathan Wilsone23a9a42015-08-26 04:19:36 +0000205 I.Fun.ExceptionSpecLocBeg = ESpecRange.getBegin().getRawEncoding();
206 I.Fun.ExceptionSpecLocEnd = ESpecRange.getEnd().getRawEncoding();
Sebastian Redl802a4532011-03-05 22:42:13 +0000207 I.Fun.NumExceptions = 0;
Craig Topper4b566922014-06-09 02:04:02 +0000208 I.Fun.Exceptions = nullptr;
209 I.Fun.NoexceptExpr = nullptr;
Richard Smith700537c2012-06-12 01:51:59 +0000210 I.Fun.HasTrailingReturnType = TrailingReturnType.isUsable() ||
211 TrailingReturnType.isInvalid();
212 I.Fun.TrailingReturnType = TrailingReturnType.get();
Sebastian Redl2b9cacb2009-04-29 17:30:04 +0000213
Richard Smith0b3a4622014-11-13 20:01:57 +0000214 assert(I.Fun.TypeQuals == TypeQuals && "bitfield overflow");
215 assert(I.Fun.ExceptionSpecType == ESpecType && "bitfield overflow");
216
Alp Tokerc5350722014-02-26 22:27:52 +0000217 // new[] a parameter array if needed.
218 if (NumParams) {
Chris Lattner1ce41ed2009-01-20 19:11:22 +0000219 // If the 'InlineParams' in Declarator is unused and big enough, put our
220 // parameter list there (in an effort to avoid new/delete traffic). If it
221 // is already used (consider a function returning a function pointer) or too
Alp Tokerc5350722014-02-26 22:27:52 +0000222 // small (function with too many parameters), go to the heap.
Mike Stump11289f42009-09-09 15:08:12 +0000223 if (!TheDeclarator.InlineParamsUsed &&
Alp Tokerc5350722014-02-26 22:27:52 +0000224 NumParams <= llvm::array_lengthof(TheDeclarator.InlineParams)) {
225 I.Fun.Params = TheDeclarator.InlineParams;
226 I.Fun.DeleteParams = false;
Chris Lattner1ce41ed2009-01-20 19:11:22 +0000227 TheDeclarator.InlineParamsUsed = true;
228 } else {
Alp Tokerc5350722014-02-26 22:27:52 +0000229 I.Fun.Params = new DeclaratorChunk::ParamInfo[NumParams];
230 I.Fun.DeleteParams = true;
Chris Lattner1ce41ed2009-01-20 19:11:22 +0000231 }
Alp Tokerc5350722014-02-26 22:27:52 +0000232 memcpy(I.Fun.Params, Params, sizeof(Params[0]) * NumParams);
Chris Lattner1ce41ed2009-01-20 19:11:22 +0000233 }
Sebastian Redl802a4532011-03-05 22:42:13 +0000234
235 // Check what exception specification information we should actually store.
236 switch (ESpecType) {
237 default: break; // By default, save nothing.
238 case EST_Dynamic:
239 // new[] an exception array if needed
240 if (NumExceptions) {
241 I.Fun.NumExceptions = NumExceptions;
242 I.Fun.Exceptions = new DeclaratorChunk::TypeAndRange[NumExceptions];
243 for (unsigned i = 0; i != NumExceptions; ++i) {
244 I.Fun.Exceptions[i].Ty = Exceptions[i];
245 I.Fun.Exceptions[i].Range = ExceptionRanges[i];
246 }
Sebastian Redld6434562009-05-29 18:02:33 +0000247 }
Sebastian Redl802a4532011-03-05 22:42:13 +0000248 break;
249
250 case EST_ComputedNoexcept:
251 I.Fun.NoexceptExpr = NoexceptExpr;
252 break;
Richard Smith0b3a4622014-11-13 20:01:57 +0000253
254 case EST_Unparsed:
255 I.Fun.ExceptionSpecTokens = ExceptionSpecTokens;
256 break;
Sebastian Redl2b9cacb2009-04-29 17:30:04 +0000257 }
Chris Lattner1ce41ed2009-01-20 19:11:22 +0000258 return I;
259}
Chris Lattner3b0f3ef2008-11-22 08:32:36 +0000260
Douglas Gregorc15b0cf2011-06-25 00:56:27 +0000261bool Declarator::isDeclarationOfFunction() const {
Richard Smithcfcdf3a2011-06-25 02:28:38 +0000262 for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
263 switch (DeclTypeInfo[i].Kind) {
264 case DeclaratorChunk::Function:
265 return true;
266 case DeclaratorChunk::Paren:
267 continue;
268 case DeclaratorChunk::Pointer:
269 case DeclaratorChunk::Reference:
270 case DeclaratorChunk::Array:
271 case DeclaratorChunk::BlockPointer:
272 case DeclaratorChunk::MemberPointer:
Xiuli Pan9c14e282016-01-09 12:53:17 +0000273 case DeclaratorChunk::Pipe:
Richard Smithcfcdf3a2011-06-25 02:28:38 +0000274 return false;
275 }
276 llvm_unreachable("Invalid type chunk");
Richard Smithcfcdf3a2011-06-25 02:28:38 +0000277 }
Douglas Gregorc15b0cf2011-06-25 00:56:27 +0000278
279 switch (DS.getTypeSpecType()) {
Eli Friedman0dfb8892011-10-06 23:00:33 +0000280 case TST_atomic:
Douglas Gregorc15b0cf2011-06-25 00:56:27 +0000281 case TST_auto:
Richard Smithe301ba22015-11-11 02:02:15 +0000282 case TST_auto_type:
Douglas Gregorc15b0cf2011-06-25 00:56:27 +0000283 case TST_bool:
284 case TST_char:
285 case TST_char16:
286 case TST_char32:
287 case TST_class:
288 case TST_decimal128:
289 case TST_decimal32:
290 case TST_decimal64:
291 case TST_double:
Nemanja Ivanovicbb1ea2d2016-05-09 08:52:33 +0000292 case TST_float128:
Douglas Gregorc15b0cf2011-06-25 00:56:27 +0000293 case TST_enum:
294 case TST_error:
295 case TST_float:
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +0000296 case TST_half:
Douglas Gregorc15b0cf2011-06-25 00:56:27 +0000297 case TST_int:
Richard Smithf016bbc2012-04-04 06:24:32 +0000298 case TST_int128:
Douglas Gregorc15b0cf2011-06-25 00:56:27 +0000299 case TST_struct:
Joao Matosdc86f942012-08-31 18:45:21 +0000300 case TST_interface:
Douglas Gregorc15b0cf2011-06-25 00:56:27 +0000301 case TST_union:
302 case TST_unknown_anytype:
303 case TST_unspecified:
304 case TST_void:
305 case TST_wchar:
Alexey Bader954ba212016-04-08 13:40:33 +0000306#define GENERIC_IMAGE_TYPE(ImgType, Id) case TST_##ImgType##_t:
Alexey Baderb62f1442016-04-13 08:33:41 +0000307#include "clang/Basic/OpenCLImageTypes.def"
Douglas Gregorc15b0cf2011-06-25 00:56:27 +0000308 return false;
309
Richard Smith74aeef52013-04-26 16:15:35 +0000310 case TST_decltype_auto:
311 // This must have an initializer, so can't be a function declaration,
312 // even if the initializer has function type.
313 return false;
314
Douglas Gregorc15b0cf2011-06-25 00:56:27 +0000315 case TST_decltype:
316 case TST_typeofExpr:
317 if (Expr *E = DS.getRepAsExpr())
318 return E->getType()->isFunctionType();
319 return false;
320
321 case TST_underlyingType:
322 case TST_typename:
323 case TST_typeofType: {
324 QualType QT = DS.getRepAsType().get();
325 if (QT.isNull())
326 return false;
327
328 if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT))
329 QT = LIT->getType();
330
331 if (QT.isNull())
332 return false;
333
334 return QT->isFunctionType();
335 }
336 }
David Blaikie8a40f702012-01-17 06:56:22 +0000337
338 llvm_unreachable("Invalid TypeSpecType!");
Douglas Gregorc15b0cf2011-06-25 00:56:27 +0000339}
340
Reid Kleckner9a7f3e62013-10-08 00:58:57 +0000341bool Declarator::isStaticMember() {
342 assert(getContext() == MemberContext);
343 return getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static ||
Petar Jovanovice886cfb2015-03-30 00:43:56 +0000344 (getName().Kind == UnqualifiedId::IK_OperatorFunctionId &&
345 CXXMethodDecl::isStaticOverloadedOperator(
346 getName().OperatorFunctionId.Operator));
Reid Kleckner9a7f3e62013-10-08 00:58:57 +0000347}
348
Andrey Bokhankoddc04ef2015-09-14 21:29:57 +0000349bool Declarator::isCtorOrDtor() {
350 return (getName().getKind() == UnqualifiedId::IK_ConstructorName) ||
351 (getName().getKind() == UnqualifiedId::IK_DestructorName);
352}
353
Richard Smith404dfb42013-11-19 22:47:36 +0000354bool DeclSpec::hasTagDefinition() const {
355 if (!TypeSpecOwned)
356 return false;
357 return cast<TagDecl>(getRepAsDecl())->isCompleteDefinition();
358}
359
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000360/// getParsedSpecifiers - Return a bitmask of which flavors of specifiers this
Chris Lattnere0c51162009-02-27 18:35:46 +0000361/// declaration specifier includes.
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000362///
363unsigned DeclSpec::getParsedSpecifiers() const {
364 unsigned Res = 0;
Chris Lattnerf63f89a2006-08-05 03:28:50 +0000365 if (StorageClassSpec != SCS_unspecified ||
Richard Smithb4a9e862013-04-12 22:46:28 +0000366 ThreadStorageClassSpec != TSCS_unspecified)
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000367 Res |= PQ_StorageClassSpecifier;
Mike Stump65643c62008-06-19 19:52:46 +0000368
Chris Lattner4d8f8732006-11-28 05:05:08 +0000369 if (TypeQualifiers != TQ_unspecified)
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000370 Res |= PQ_TypeQualifier;
Mike Stump11289f42009-09-09 15:08:12 +0000371
Chris Lattnerf055d432006-11-28 04:28:12 +0000372 if (hasTypeSpecifier())
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000373 Res |= PQ_TypeSpecifier;
Mike Stump11289f42009-09-09 15:08:12 +0000374
Richard Smith0015f092013-01-17 22:16:11 +0000375 if (FS_inline_specified || FS_virtual_specified || FS_explicit_specified ||
Serge Pavlov750db652013-11-13 06:57:53 +0000376 FS_noreturn_specified || FS_forceinline_specified)
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000377 Res |= PQ_FunctionSpecifier;
378 return Res;
379}
380
John McCall49bfce42009-08-03 20:12:06 +0000381template <class T> static bool BadSpecifier(T TNew, T TPrev,
382 const char *&PrevSpec,
Aaron Ballman3731b332012-08-28 20:55:40 +0000383 unsigned &DiagID,
384 bool IsExtension = true) {
John McCall898cd0f2009-08-03 18:47:27 +0000385 PrevSpec = DeclSpec::getSpecifierName(TPrev);
Aaron Ballman3731b332012-08-28 20:55:40 +0000386 if (TNew != TPrev)
387 DiagID = diag::err_invalid_decl_spec_combination;
388 else
389 DiagID = IsExtension ? diag::ext_duplicate_declspec :
390 diag::warn_duplicate_declspec;
John McCall898cd0f2009-08-03 18:47:27 +0000391 return true;
Mike Stump11289f42009-09-09 15:08:12 +0000392}
John McCall898cd0f2009-08-03 18:47:27 +0000393
Chris Lattner7bd11fe2007-01-23 04:35:33 +0000394const char *DeclSpec::getSpecifierName(DeclSpec::SCS S) {
Chris Lattnerf63f89a2006-08-05 03:28:50 +0000395 switch (S) {
Chris Lattnerf63f89a2006-08-05 03:28:50 +0000396 case DeclSpec::SCS_unspecified: return "unspecified";
397 case DeclSpec::SCS_typedef: return "typedef";
398 case DeclSpec::SCS_extern: return "extern";
399 case DeclSpec::SCS_static: return "static";
400 case DeclSpec::SCS_auto: return "auto";
401 case DeclSpec::SCS_register: return "register";
Eli Friedmand5c0eed2009-04-19 20:27:55 +0000402 case DeclSpec::SCS_private_extern: return "__private_extern__";
Sebastian Redlccdfaba2008-11-14 23:42:31 +0000403 case DeclSpec::SCS_mutable: return "mutable";
Chris Lattnerf63f89a2006-08-05 03:28:50 +0000404 }
Jeffrey Yasskin1615d452009-12-12 05:05:38 +0000405 llvm_unreachable("Unknown typespec!");
Chris Lattnerf63f89a2006-08-05 03:28:50 +0000406}
407
Richard Smithb4a9e862013-04-12 22:46:28 +0000408const char *DeclSpec::getSpecifierName(DeclSpec::TSCS S) {
409 switch (S) {
410 case DeclSpec::TSCS_unspecified: return "unspecified";
411 case DeclSpec::TSCS___thread: return "__thread";
412 case DeclSpec::TSCS_thread_local: return "thread_local";
413 case DeclSpec::TSCS__Thread_local: return "_Thread_local";
414 }
415 llvm_unreachable("Unknown typespec!");
416}
417
John McCall898cd0f2009-08-03 18:47:27 +0000418const char *DeclSpec::getSpecifierName(TSW W) {
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000419 switch (W) {
John McCall898cd0f2009-08-03 18:47:27 +0000420 case TSW_unspecified: return "unspecified";
421 case TSW_short: return "short";
422 case TSW_long: return "long";
423 case TSW_longlong: return "long long";
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000424 }
Jeffrey Yasskin1615d452009-12-12 05:05:38 +0000425 llvm_unreachable("Unknown typespec!");
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000426}
427
John McCall898cd0f2009-08-03 18:47:27 +0000428const char *DeclSpec::getSpecifierName(TSC C) {
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000429 switch (C) {
John McCall898cd0f2009-08-03 18:47:27 +0000430 case TSC_unspecified: return "unspecified";
431 case TSC_imaginary: return "imaginary";
432 case TSC_complex: return "complex";
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000433 }
Jeffrey Yasskin1615d452009-12-12 05:05:38 +0000434 llvm_unreachable("Unknown typespec!");
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000435}
436
437
John McCall898cd0f2009-08-03 18:47:27 +0000438const char *DeclSpec::getSpecifierName(TSS S) {
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000439 switch (S) {
John McCall898cd0f2009-08-03 18:47:27 +0000440 case TSS_unspecified: return "unspecified";
441 case TSS_signed: return "signed";
442 case TSS_unsigned: return "unsigned";
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000443 }
Jeffrey Yasskin1615d452009-12-12 05:05:38 +0000444 llvm_unreachable("Unknown typespec!");
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000445}
446
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000447const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
448 const PrintingPolicy &Policy) {
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000449 switch (T) {
Chris Lattner839713c2006-08-04 06:15:52 +0000450 case DeclSpec::TST_unspecified: return "unspecified";
451 case DeclSpec::TST_void: return "void";
452 case DeclSpec::TST_char: return "char";
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000453 case DeclSpec::TST_wchar: return Policy.MSWChar ? "__wchar_t" : "wchar_t";
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +0000454 case DeclSpec::TST_char16: return "char16_t";
455 case DeclSpec::TST_char32: return "char32_t";
Chris Lattner839713c2006-08-04 06:15:52 +0000456 case DeclSpec::TST_int: return "int";
Richard Smithf016bbc2012-04-04 06:24:32 +0000457 case DeclSpec::TST_int128: return "__int128";
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +0000458 case DeclSpec::TST_half: return "half";
Chris Lattner839713c2006-08-04 06:15:52 +0000459 case DeclSpec::TST_float: return "float";
460 case DeclSpec::TST_double: return "double";
Nemanja Ivanovicbb1ea2d2016-05-09 08:52:33 +0000461 case DeclSpec::TST_float128: return "__float128";
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000462 case DeclSpec::TST_bool: return Policy.Bool ? "bool" : "_Bool";
Chris Lattner839713c2006-08-04 06:15:52 +0000463 case DeclSpec::TST_decimal32: return "_Decimal32";
464 case DeclSpec::TST_decimal64: return "_Decimal64";
465 case DeclSpec::TST_decimal128: return "_Decimal128";
Chris Lattnerda72c822006-08-13 22:16:42 +0000466 case DeclSpec::TST_enum: return "enum";
Chris Lattner861a2262008-04-13 18:59:07 +0000467 case DeclSpec::TST_class: return "class";
Chris Lattnerda72c822006-08-13 22:16:42 +0000468 case DeclSpec::TST_union: return "union";
469 case DeclSpec::TST_struct: return "struct";
Joao Matosdc86f942012-08-31 18:45:21 +0000470 case DeclSpec::TST_interface: return "__interface";
Douglas Gregor9817f4a2009-02-09 15:09:02 +0000471 case DeclSpec::TST_typename: return "type-name";
Steve Naroffad373bd2007-07-31 12:34:36 +0000472 case DeclSpec::TST_typeofType:
473 case DeclSpec::TST_typeofExpr: return "typeof";
John McCall898cd0f2009-08-03 18:47:27 +0000474 case DeclSpec::TST_auto: return "auto";
Richard Smithe301ba22015-11-11 02:02:15 +0000475 case DeclSpec::TST_auto_type: return "__auto_type";
John McCall898cd0f2009-08-03 18:47:27 +0000476 case DeclSpec::TST_decltype: return "(decltype)";
Richard Smith74aeef52013-04-26 16:15:35 +0000477 case DeclSpec::TST_decltype_auto: return "decltype(auto)";
Alexis Hunte852b102011-05-24 22:41:36 +0000478 case DeclSpec::TST_underlyingType: return "__underlying_type";
John McCall39439732011-04-09 22:50:59 +0000479 case DeclSpec::TST_unknown_anytype: return "__unknown_anytype";
Eli Friedman0dfb8892011-10-06 23:00:33 +0000480 case DeclSpec::TST_atomic: return "_Atomic";
Alexey Bader954ba212016-04-08 13:40:33 +0000481#define GENERIC_IMAGE_TYPE(ImgType, Id) \
482 case DeclSpec::TST_##ImgType##_t: \
483 return #ImgType "_t";
Alexey Baderb62f1442016-04-13 08:33:41 +0000484#include "clang/Basic/OpenCLImageTypes.def"
John McCall898cd0f2009-08-03 18:47:27 +0000485 case DeclSpec::TST_error: return "(error)";
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000486 }
Jeffrey Yasskin1615d452009-12-12 05:05:38 +0000487 llvm_unreachable("Unknown typespec!");
Chris Lattner839713c2006-08-04 06:15:52 +0000488}
489
John McCall898cd0f2009-08-03 18:47:27 +0000490const char *DeclSpec::getSpecifierName(TQ T) {
Chris Lattnerda48a8e2006-08-04 05:25:55 +0000491 switch (T) {
John McCall898cd0f2009-08-03 18:47:27 +0000492 case DeclSpec::TQ_unspecified: return "unspecified";
493 case DeclSpec::TQ_const: return "const";
494 case DeclSpec::TQ_restrict: return "restrict";
495 case DeclSpec::TQ_volatile: return "volatile";
Richard Smith8e1ac332013-03-28 01:55:44 +0000496 case DeclSpec::TQ_atomic: return "_Atomic";
Andrey Bokhanko45d41322016-05-11 18:38:21 +0000497 case DeclSpec::TQ_unaligned: return "__unaligned";
Chris Lattnerda48a8e2006-08-04 05:25:55 +0000498 }
Jeffrey Yasskin1615d452009-12-12 05:05:38 +0000499 llvm_unreachable("Unknown typespec!");
Chris Lattnerda48a8e2006-08-04 05:25:55 +0000500}
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000501
Peter Collingbourne485b80f2011-10-06 03:01:00 +0000502bool DeclSpec::SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
John McCall49bfce42009-08-03 20:12:06 +0000503 const char *&PrevSpec,
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000504 unsigned &DiagID,
505 const PrintingPolicy &Policy) {
Tanya Lattner4fdce3f2012-06-19 23:09:52 +0000506 // OpenCL v1.1 s6.8g: "The extern, static, auto and register storage-class
507 // specifiers are not supported.
Peter Collingbournede32b202011-02-11 19:59:54 +0000508 // It seems sensible to prohibit private_extern too
Peter Collingbourne485b80f2011-10-06 03:01:00 +0000509 // The cl_clang_storage_class_specifiers extension enables support for
510 // these storage-class specifiers.
Tanya Lattner4fdce3f2012-06-19 23:09:52 +0000511 // OpenCL v1.2 s6.8 changes this to "The auto and register storage-class
512 // specifiers are not supported."
David Blaikiebbafb8a2012-03-11 07:00:24 +0000513 if (S.getLangOpts().OpenCL &&
Peter Collingbourne485b80f2011-10-06 03:01:00 +0000514 !S.getOpenCLOptions().cl_clang_storage_class_specifiers) {
515 switch (SC) {
Peter Collingbournede32b202011-02-11 19:59:54 +0000516 case SCS_extern:
517 case SCS_private_extern:
Tanya Lattner4fdce3f2012-06-19 23:09:52 +0000518 case SCS_static:
Craig Topper7d2f9432015-11-14 19:31:52 +0000519 if (S.getLangOpts().OpenCLVersion < 120) {
520 DiagID = diag::err_opencl_unknown_type_specifier;
521 PrevSpec = getSpecifierName(SC);
522 return true;
523 }
524 break;
Peter Collingbournede32b202011-02-11 19:59:54 +0000525 case SCS_auto:
526 case SCS_register:
Anastasia Stulova2c8dcfb2014-11-26 14:10:06 +0000527 DiagID = diag::err_opencl_unknown_type_specifier;
Peter Collingbourne485b80f2011-10-06 03:01:00 +0000528 PrevSpec = getSpecifierName(SC);
Peter Collingbournede32b202011-02-11 19:59:54 +0000529 return true;
530 default:
531 break;
532 }
533 }
534
Abramo Bagnaraed5b6892010-07-30 16:47:02 +0000535 if (StorageClassSpec != SCS_unspecified) {
Richard Smith74aeef52013-04-26 16:15:35 +0000536 // Maybe this is an attempt to use C++11 'auto' outside of C++11 mode.
Richard Smith58c74332011-09-04 19:54:14 +0000537 bool isInvalid = true;
David Blaikiebbafb8a2012-03-11 07:00:24 +0000538 if (TypeSpecType == TST_unspecified && S.getLangOpts().CPlusPlus) {
Peter Collingbourne485b80f2011-10-06 03:01:00 +0000539 if (SC == SCS_auto)
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000540 return SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID, Policy);
Richard Smith58c74332011-09-04 19:54:14 +0000541 if (StorageClassSpec == SCS_auto) {
542 isInvalid = SetTypeSpecType(TST_auto, StorageClassSpecLoc,
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000543 PrevSpec, DiagID, Policy);
Richard Smith58c74332011-09-04 19:54:14 +0000544 assert(!isInvalid && "auto SCS -> TST recovery failed");
545 }
546 }
547
Abramo Bagnaraed5b6892010-07-30 16:47:02 +0000548 // Changing storage class is allowed only if the previous one
549 // was the 'extern' that is part of a linkage specification and
550 // the new storage class is 'typedef'.
Richard Smith58c74332011-09-04 19:54:14 +0000551 if (isInvalid &&
552 !(SCS_extern_in_linkage_spec &&
Abramo Bagnaraed5b6892010-07-30 16:47:02 +0000553 StorageClassSpec == SCS_extern &&
Peter Collingbourne485b80f2011-10-06 03:01:00 +0000554 SC == SCS_typedef))
555 return BadSpecifier(SC, (SCS)StorageClassSpec, PrevSpec, DiagID);
Abramo Bagnaraed5b6892010-07-30 16:47:02 +0000556 }
Peter Collingbourne485b80f2011-10-06 03:01:00 +0000557 StorageClassSpec = SC;
Chris Lattner4d8f8732006-11-28 05:05:08 +0000558 StorageClassSpecLoc = Loc;
Peter Collingbourne485b80f2011-10-06 03:01:00 +0000559 assert((unsigned)SC == StorageClassSpec && "SCS constants overflow bitfield");
Chris Lattnerf63f89a2006-08-05 03:28:50 +0000560 return false;
561}
562
Richard Smithb4a9e862013-04-12 22:46:28 +0000563bool DeclSpec::SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,
John McCall49bfce42009-08-03 20:12:06 +0000564 const char *&PrevSpec,
565 unsigned &DiagID) {
Richard Smithb4a9e862013-04-12 22:46:28 +0000566 if (ThreadStorageClassSpec != TSCS_unspecified)
567 return BadSpecifier(TSC, (TSCS)ThreadStorageClassSpec, PrevSpec, DiagID);
568
569 ThreadStorageClassSpec = TSC;
570 ThreadStorageClassSpecLoc = Loc;
Chris Lattner353f5742006-11-28 04:50:12 +0000571 return false;
572}
573
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000574/// These methods set the specified attribute of the DeclSpec, but return true
575/// and ignore the request if invalid (e.g. "extern" then "auto" is
576/// specified).
Chris Lattnerb20e8942006-11-28 05:30:29 +0000577bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc,
John McCall49bfce42009-08-03 20:12:06 +0000578 const char *&PrevSpec,
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000579 unsigned &DiagID,
580 const PrintingPolicy &Policy) {
Abramo Bagnaraead67d92011-03-06 22:21:56 +0000581 // Overwrite TSWLoc only if TypeSpecWidth was unspecified, so that
582 // for 'long long' we will keep the source location of the first 'long'.
583 if (TypeSpecWidth == TSW_unspecified)
584 TSWLoc = Loc;
585 // Allow turning long -> long long.
586 else if (W != TSW_longlong || TypeSpecWidth != TSW_long)
John McCall49bfce42009-08-03 20:12:06 +0000587 return BadSpecifier(W, (TSW)TypeSpecWidth, PrevSpec, DiagID);
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000588 TypeSpecWidth = W;
589 return false;
590}
591
Mike Stump11289f42009-09-09 15:08:12 +0000592bool DeclSpec::SetTypeSpecComplex(TSC C, SourceLocation Loc,
John McCall49bfce42009-08-03 20:12:06 +0000593 const char *&PrevSpec,
594 unsigned &DiagID) {
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000595 if (TypeSpecComplex != TSC_unspecified)
John McCall49bfce42009-08-03 20:12:06 +0000596 return BadSpecifier(C, (TSC)TypeSpecComplex, PrevSpec, DiagID);
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000597 TypeSpecComplex = C;
Chris Lattnerb20e8942006-11-28 05:30:29 +0000598 TSCLoc = Loc;
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000599 return false;
600}
601
Mike Stump11289f42009-09-09 15:08:12 +0000602bool DeclSpec::SetTypeSpecSign(TSS S, SourceLocation Loc,
John McCall49bfce42009-08-03 20:12:06 +0000603 const char *&PrevSpec,
604 unsigned &DiagID) {
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000605 if (TypeSpecSign != TSS_unspecified)
John McCall49bfce42009-08-03 20:12:06 +0000606 return BadSpecifier(S, (TSS)TypeSpecSign, PrevSpec, DiagID);
Chris Lattnerdeb42f52006-08-04 05:26:52 +0000607 TypeSpecSign = S;
Chris Lattnerb20e8942006-11-28 05:30:29 +0000608 TSSLoc = Loc;
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000609 return false;
610}
611
Chris Lattnerb20e8942006-11-28 05:30:29 +0000612bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
John McCall49bfce42009-08-03 20:12:06 +0000613 const char *&PrevSpec,
614 unsigned &DiagID,
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000615 ParsedType Rep,
616 const PrintingPolicy &Policy) {
617 return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Policy);
Abramo Bagnara9875a3c2011-03-16 20:16:18 +0000618}
619
620bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
621 SourceLocation TagNameLoc,
622 const char *&PrevSpec,
623 unsigned &DiagID,
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000624 ParsedType Rep,
625 const PrintingPolicy &Policy) {
John McCallba7bf592010-08-24 05:47:05 +0000626 assert(isTypeRep(T) && "T does not store a type");
627 assert(Rep && "no type provided!");
628 if (TypeSpecType != TST_unspecified) {
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000629 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
John McCallba7bf592010-08-24 05:47:05 +0000630 DiagID = diag::err_invalid_decl_spec_combination;
631 return true;
632 }
633 TypeSpecType = T;
634 TypeRep = Rep;
Abramo Bagnara9875a3c2011-03-16 20:16:18 +0000635 TSTLoc = TagKwLoc;
636 TSTNameLoc = TagNameLoc;
John McCallba7bf592010-08-24 05:47:05 +0000637 TypeSpecOwned = false;
638 return false;
639}
640
641bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
642 const char *&PrevSpec,
643 unsigned &DiagID,
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000644 Expr *Rep,
645 const PrintingPolicy &Policy) {
John McCallba7bf592010-08-24 05:47:05 +0000646 assert(isExprRep(T) && "T does not store an expr");
647 assert(Rep && "no expression provided!");
648 if (TypeSpecType != TST_unspecified) {
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000649 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
John McCallba7bf592010-08-24 05:47:05 +0000650 DiagID = diag::err_invalid_decl_spec_combination;
651 return true;
652 }
653 TypeSpecType = T;
654 ExprRep = Rep;
655 TSTLoc = Loc;
Abramo Bagnara9875a3c2011-03-16 20:16:18 +0000656 TSTNameLoc = Loc;
John McCallba7bf592010-08-24 05:47:05 +0000657 TypeSpecOwned = false;
658 return false;
659}
660
661bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
662 const char *&PrevSpec,
663 unsigned &DiagID,
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000664 Decl *Rep, bool Owned,
665 const PrintingPolicy &Policy) {
666 return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned, Policy);
Abramo Bagnara9875a3c2011-03-16 20:16:18 +0000667}
668
669bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
670 SourceLocation TagNameLoc,
671 const char *&PrevSpec,
672 unsigned &DiagID,
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000673 Decl *Rep, bool Owned,
674 const PrintingPolicy &Policy) {
John McCallba7bf592010-08-24 05:47:05 +0000675 assert(isDeclRep(T) && "T does not store a decl");
676 // Unlike the other cases, we don't assert that we actually get a decl.
677
678 if (TypeSpecType != TST_unspecified) {
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000679 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
John McCallba7bf592010-08-24 05:47:05 +0000680 DiagID = diag::err_invalid_decl_spec_combination;
681 return true;
682 }
683 TypeSpecType = T;
684 DeclRep = Rep;
Abramo Bagnara9875a3c2011-03-16 20:16:18 +0000685 TSTLoc = TagKwLoc;
686 TSTNameLoc = TagNameLoc;
Craig Topper4b566922014-06-09 02:04:02 +0000687 TypeSpecOwned = Owned && Rep != nullptr;
John McCallba7bf592010-08-24 05:47:05 +0000688 return false;
689}
690
691bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
692 const char *&PrevSpec,
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000693 unsigned &DiagID,
694 const PrintingPolicy &Policy) {
John McCallba7bf592010-08-24 05:47:05 +0000695 assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) &&
696 "rep required for these type-spec kinds!");
John McCall49bfce42009-08-03 20:12:06 +0000697 if (TypeSpecType != TST_unspecified) {
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000698 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
John McCall49bfce42009-08-03 20:12:06 +0000699 DiagID = diag::err_invalid_decl_spec_combination;
700 return true;
701 }
Abramo Bagnara9875a3c2011-03-16 20:16:18 +0000702 TSTLoc = Loc;
703 TSTNameLoc = Loc;
Chris Lattner37141f42010-06-23 06:00:24 +0000704 if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) {
705 TypeAltiVecBool = true;
Chris Lattner37141f42010-06-23 06:00:24 +0000706 return false;
707 }
Chris Lattnerdeb42f52006-08-04 05:26:52 +0000708 TypeSpecType = T;
John McCallba7bf592010-08-24 05:47:05 +0000709 TypeSpecOwned = false;
John Thompson22334602010-02-05 00:12:22 +0000710 return false;
711}
712
713bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000714 const char *&PrevSpec, unsigned &DiagID,
715 const PrintingPolicy &Policy) {
John Thompson22334602010-02-05 00:12:22 +0000716 if (TypeSpecType != TST_unspecified) {
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000717 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
John Thompson22334602010-02-05 00:12:22 +0000718 DiagID = diag::err_invalid_vector_decl_spec_combination;
719 return true;
720 }
721 TypeAltiVecVector = isAltiVecVector;
722 AltiVecLoc = Loc;
723 return false;
724}
725
Xiuli Pan9c14e282016-01-09 12:53:17 +0000726bool DeclSpec::SetTypePipe(bool isPipe, SourceLocation Loc,
727 const char *&PrevSpec, unsigned &DiagID,
728 const PrintingPolicy &Policy) {
729
730 if (TypeSpecType != TST_unspecified) {
731 PrevSpec = DeclSpec::getSpecifierName((TST)TypeSpecType, Policy);
732 DiagID = diag::err_invalid_decl_spec_combination;
733 return true;
734 }
735
736 if (isPipe) {
737 TypeSpecPipe = TSP_pipe;
738 }
739 return false;
740}
741
John Thompson22334602010-02-05 00:12:22 +0000742bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000743 const char *&PrevSpec, unsigned &DiagID,
744 const PrintingPolicy &Policy) {
Chris Lattner37141f42010-06-23 06:00:24 +0000745 if (!TypeAltiVecVector || TypeAltiVecPixel ||
746 (TypeSpecType != TST_unspecified)) {
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000747 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
John Thompson22334602010-02-05 00:12:22 +0000748 DiagID = diag::err_invalid_pixel_decl_spec_combination;
749 return true;
750 }
John Thompson22334602010-02-05 00:12:22 +0000751 TypeAltiVecPixel = isAltiVecPixel;
752 TSTLoc = Loc;
Abramo Bagnara9875a3c2011-03-16 20:16:18 +0000753 TSTNameLoc = Loc;
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000754 return false;
755}
756
Bill Schmidt99a084b2013-07-03 20:54:09 +0000757bool DeclSpec::SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000758 const char *&PrevSpec, unsigned &DiagID,
759 const PrintingPolicy &Policy) {
Bill Schmidt99a084b2013-07-03 20:54:09 +0000760 if (!TypeAltiVecVector || TypeAltiVecBool ||
761 (TypeSpecType != TST_unspecified)) {
Erik Verbruggen888d52a2014-01-15 09:15:43 +0000762 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
Bill Schmidt99a084b2013-07-03 20:54:09 +0000763 DiagID = diag::err_invalid_vector_bool_decl_spec;
764 return true;
765 }
766 TypeAltiVecBool = isAltiVecBool;
767 TSTLoc = Loc;
768 TSTNameLoc = Loc;
769 return false;
770}
771
Douglas Gregorcd72ba92009-02-06 22:42:48 +0000772bool DeclSpec::SetTypeSpecError() {
773 TypeSpecType = TST_error;
John McCalla3707cc2010-08-26 17:22:34 +0000774 TypeSpecOwned = false;
Douglas Gregorcd72ba92009-02-06 22:42:48 +0000775 TSTLoc = SourceLocation();
Abramo Bagnara9875a3c2011-03-16 20:16:18 +0000776 TSTNameLoc = SourceLocation();
Douglas Gregorcd72ba92009-02-06 22:42:48 +0000777 return false;
778}
779
Chris Lattner60809f52006-11-28 05:18:46 +0000780bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
Richard Smith87e79512012-10-17 23:31:46 +0000781 unsigned &DiagID, const LangOptions &Lang) {
Serge Pavlov750db652013-11-13 06:57:53 +0000782 // Duplicates are permitted in C99 onwards, but are not permitted in C89 or
783 // C++. However, since this is likely not what the user intended, we will
784 // always warn. We do not need to set the qualifier's location since we
785 // already have it.
Aaron Ballman3731b332012-08-28 20:55:40 +0000786 if (TypeQualifiers & T) {
Aaron Ballmand5a176d2012-08-29 12:35:14 +0000787 bool IsExtension = true;
Richard Smith87e79512012-10-17 23:31:46 +0000788 if (Lang.C99)
Aaron Ballmand5a176d2012-08-29 12:35:14 +0000789 IsExtension = false;
Aaron Ballman3731b332012-08-28 20:55:40 +0000790 return BadSpecifier(T, T, PrevSpec, DiagID, IsExtension);
791 }
Chris Lattnerda48a8e2006-08-04 05:25:55 +0000792 TypeQualifiers |= T;
Mike Stump11289f42009-09-09 15:08:12 +0000793
Chris Lattner60809f52006-11-28 05:18:46 +0000794 switch (T) {
Richard Smith8e1ac332013-03-28 01:55:44 +0000795 case TQ_unspecified: break;
796 case TQ_const: TQ_constLoc = Loc; return false;
797 case TQ_restrict: TQ_restrictLoc = Loc; return false;
798 case TQ_volatile: TQ_volatileLoc = Loc; return false;
799 case TQ_atomic: TQ_atomicLoc = Loc; return false;
Andrey Bokhanko45d41322016-05-11 18:38:21 +0000800 case TQ_unaligned: TQ_unalignedLoc = Loc; return false;
Chris Lattner60809f52006-11-28 05:18:46 +0000801 }
Richard Smith8e1ac332013-03-28 01:55:44 +0000802
803 llvm_unreachable("Unknown type qualifier!");
Chris Lattnerda48a8e2006-08-04 05:25:55 +0000804}
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000805
Serge Pavlov750db652013-11-13 06:57:53 +0000806bool DeclSpec::setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
807 unsigned &DiagID) {
808 // 'inline inline' is ok. However, since this is likely not what the user
809 // intended, we will always warn, similar to duplicates of type qualifiers.
810 if (FS_inline_specified) {
811 DiagID = diag::warn_duplicate_declspec;
812 PrevSpec = "inline";
813 return true;
814 }
Chris Lattnera925dc62006-11-28 04:33:46 +0000815 FS_inline_specified = true;
Chris Lattner1b22eed2006-11-28 05:12:07 +0000816 FS_inlineLoc = Loc;
Chris Lattnera925dc62006-11-28 04:33:46 +0000817 return false;
818}
819
Serge Pavlov750db652013-11-13 06:57:53 +0000820bool DeclSpec::setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
821 unsigned &DiagID) {
822 if (FS_forceinline_specified) {
823 DiagID = diag::warn_duplicate_declspec;
824 PrevSpec = "__forceinline";
825 return true;
826 }
827 FS_forceinline_specified = true;
828 FS_forceinlineLoc = Loc;
829 return false;
830}
831
832bool DeclSpec::setFunctionSpecVirtual(SourceLocation Loc,
833 const char *&PrevSpec,
834 unsigned &DiagID) {
835 // 'virtual virtual' is ok, but warn as this is likely not what the user
836 // intended.
837 if (FS_virtual_specified) {
838 DiagID = diag::warn_duplicate_declspec;
839 PrevSpec = "virtual";
840 return true;
841 }
Douglas Gregor61956c42008-10-31 09:07:45 +0000842 FS_virtual_specified = true;
843 FS_virtualLoc = Loc;
844 return false;
845}
846
Serge Pavlov750db652013-11-13 06:57:53 +0000847bool DeclSpec::setFunctionSpecExplicit(SourceLocation Loc,
848 const char *&PrevSpec,
849 unsigned &DiagID) {
850 // 'explicit explicit' is ok, but warn as this is likely not what the user
851 // intended.
852 if (FS_explicit_specified) {
853 DiagID = diag::warn_duplicate_declspec;
854 PrevSpec = "explicit";
855 return true;
856 }
Douglas Gregor61956c42008-10-31 09:07:45 +0000857 FS_explicit_specified = true;
858 FS_explicitLoc = Loc;
859 return false;
860}
861
Serge Pavlov750db652013-11-13 06:57:53 +0000862bool DeclSpec::setFunctionSpecNoreturn(SourceLocation Loc,
863 const char *&PrevSpec,
864 unsigned &DiagID) {
865 // '_Noreturn _Noreturn' is ok, but warn as this is likely not what the user
866 // intended.
867 if (FS_noreturn_specified) {
868 DiagID = diag::warn_duplicate_declspec;
869 PrevSpec = "_Noreturn";
870 return true;
871 }
Richard Smith0015f092013-01-17 22:16:11 +0000872 FS_noreturn_specified = true;
873 FS_noreturnLoc = Loc;
874 return false;
875}
876
John McCall49bfce42009-08-03 20:12:06 +0000877bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
878 unsigned &DiagID) {
Anders Carlssoncd8db412009-05-06 04:46:28 +0000879 if (Friend_specified) {
880 PrevSpec = "friend";
Richard Smithc0a5d5b2014-01-10 21:27:55 +0000881 // Keep the later location, so that we can later diagnose ill-formed
882 // declarations like 'friend class X friend;'. Per [class.friend]p3,
883 // 'friend' must be the first token in a friend declaration that is
884 // not a function declaration.
885 FriendLoc = Loc;
886 DiagID = diag::warn_duplicate_declspec;
Anders Carlssoncd8db412009-05-06 04:46:28 +0000887 return true;
888 }
John McCall49bfce42009-08-03 20:12:06 +0000889
Anders Carlssoncd8db412009-05-06 04:46:28 +0000890 Friend_specified = true;
891 FriendLoc = Loc;
892 return false;
893}
Chris Lattnera925dc62006-11-28 04:33:46 +0000894
Douglas Gregor26701a42011-09-09 02:06:17 +0000895bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
896 unsigned &DiagID) {
897 if (isModulePrivateSpecified()) {
898 PrevSpec = "__module_private__";
899 DiagID = diag::ext_duplicate_declspec;
900 return true;
901 }
902
903 ModulePrivateLoc = Loc;
904 return false;
905}
906
Sebastian Redl39c2a8b2009-11-05 15:47:02 +0000907bool DeclSpec::SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
908 unsigned &DiagID) {
Richard Smithc0a5d5b2014-01-10 21:27:55 +0000909 // 'constexpr constexpr' is ok, but warn as this is likely not what the user
910 // intended.
911 if (Constexpr_specified) {
912 DiagID = diag::warn_duplicate_declspec;
913 PrevSpec = "constexpr";
914 return true;
915 }
Sebastian Redl39c2a8b2009-11-05 15:47:02 +0000916 Constexpr_specified = true;
917 ConstexprLoc = Loc;
918 return false;
919}
920
Hubert Tong375f00a2015-06-30 12:14:52 +0000921bool DeclSpec::SetConceptSpec(SourceLocation Loc, const char *&PrevSpec,
922 unsigned &DiagID) {
923 if (Concept_specified) {
924 DiagID = diag::ext_duplicate_declspec;
925 PrevSpec = "concept";
926 return true;
927 }
928 Concept_specified = true;
929 ConceptLoc = Loc;
930 return false;
931}
932
Douglas Gregorc9b7a592010-01-18 18:04:31 +0000933void DeclSpec::SaveWrittenBuiltinSpecs() {
934 writtenBS.Sign = getTypeSpecSign();
935 writtenBS.Width = getTypeSpecWidth();
936 writtenBS.Type = getTypeSpecType();
937 // Search the list of attributes for the presence of a mode attribute.
938 writtenBS.ModeAttr = false;
John McCall53fa7142010-12-24 02:08:15 +0000939 AttributeList* attrs = getAttributes().getList();
Douglas Gregorc9b7a592010-01-18 18:04:31 +0000940 while (attrs) {
Alexis Hunt3bc72c12012-06-19 23:57:03 +0000941 if (attrs->getKind() == AttributeList::AT_Mode) {
Douglas Gregorc9b7a592010-01-18 18:04:31 +0000942 writtenBS.ModeAttr = true;
943 break;
944 }
945 attrs = attrs->getNext();
946 }
947}
948
Chris Lattnerb9093cd2006-08-04 04:39:53 +0000949/// Finish - This does final analysis of the declspec, rejecting things like
950/// "_Imaginary" (lacking an FP type). This returns a diagnostic to issue or
951/// diag::NUM_DIAGNOSTICS if there is no error. After calling this method,
952/// DeclSpec is guaranteed self-consistent, even if an error occurred.
Craig Topper25122412015-11-15 03:32:11 +0000953void DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {
Douglas Gregorc9b7a592010-01-18 18:04:31 +0000954 // Before possibly changing their values, save specs as written.
955 SaveWrittenBuiltinSpecs();
956
Chris Lattnerfef9d2b2006-08-04 06:36:52 +0000957 // Check the type specifier components first.
958
Richard Smith74aeef52013-04-26 16:15:35 +0000959 // If decltype(auto) is used, no other type specifiers are permitted.
960 if (TypeSpecType == TST_decltype_auto &&
961 (TypeSpecWidth != TSW_unspecified ||
962 TypeSpecComplex != TSC_unspecified ||
963 TypeSpecSign != TSS_unspecified ||
964 TypeAltiVecVector || TypeAltiVecPixel || TypeAltiVecBool ||
965 TypeQualifiers)) {
Andrey Bokhanko45d41322016-05-11 18:38:21 +0000966 const unsigned NumLocs = 9;
Richard Smith74aeef52013-04-26 16:15:35 +0000967 SourceLocation ExtraLocs[NumLocs] = {
968 TSWLoc, TSCLoc, TSSLoc, AltiVecLoc,
Andrey Bokhanko45d41322016-05-11 18:38:21 +0000969 TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc, TQ_unalignedLoc
Richard Smith74aeef52013-04-26 16:15:35 +0000970 };
971 FixItHint Hints[NumLocs];
972 SourceLocation FirstLoc;
973 for (unsigned I = 0; I != NumLocs; ++I) {
Yaron Kerened1fe5d2015-10-03 05:15:57 +0000974 if (ExtraLocs[I].isValid()) {
Richard Smith74aeef52013-04-26 16:15:35 +0000975 if (FirstLoc.isInvalid() ||
Craig Topper25122412015-11-15 03:32:11 +0000976 S.getSourceManager().isBeforeInTranslationUnit(ExtraLocs[I],
977 FirstLoc))
Richard Smith74aeef52013-04-26 16:15:35 +0000978 FirstLoc = ExtraLocs[I];
979 Hints[I] = FixItHint::CreateRemoval(ExtraLocs[I]);
980 }
981 }
982 TypeSpecWidth = TSW_unspecified;
983 TypeSpecComplex = TSC_unspecified;
984 TypeSpecSign = TSS_unspecified;
985 TypeAltiVecVector = TypeAltiVecPixel = TypeAltiVecBool = false;
986 TypeQualifiers = 0;
Craig Topper25122412015-11-15 03:32:11 +0000987 S.Diag(TSTLoc, diag::err_decltype_auto_cannot_be_combined)
Richard Smith74aeef52013-04-26 16:15:35 +0000988 << Hints[0] << Hints[1] << Hints[2] << Hints[3]
989 << Hints[4] << Hints[5] << Hints[6] << Hints[7];
990 }
991
Chris Lattner37141f42010-06-23 06:00:24 +0000992 // Validate and finalize AltiVec vector declspec.
993 if (TypeAltiVecVector) {
994 if (TypeAltiVecBool) {
995 // Sign specifiers are not allowed with vector bool. (PIM 2.1)
996 if (TypeSpecSign != TSS_unspecified) {
Craig Topper25122412015-11-15 03:32:11 +0000997 S.Diag(TSSLoc, diag::err_invalid_vector_bool_decl_spec)
Chris Lattner37141f42010-06-23 06:00:24 +0000998 << getSpecifierName((TSS)TypeSpecSign);
999 }
1000
1001 // Only char/int are valid with vector bool. (PIM 2.1)
Duncan Sandsd3e231e2010-06-23 19:34:52 +00001002 if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) &&
1003 (TypeSpecType != TST_int)) || TypeAltiVecPixel) {
Craig Topper25122412015-11-15 03:32:11 +00001004 S.Diag(TSTLoc, diag::err_invalid_vector_bool_decl_spec)
Chris Lattner37141f42010-06-23 06:00:24 +00001005 << (TypeAltiVecPixel ? "__pixel" :
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001006 getSpecifierName((TST)TypeSpecType, Policy));
Chris Lattner37141f42010-06-23 06:00:24 +00001007 }
1008
Bill Seurer2351bec2015-03-03 20:08:43 +00001009 // Only 'short' and 'long long' are valid with vector bool. (PIM 2.1)
1010 if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short) &&
1011 (TypeSpecWidth != TSW_longlong))
Craig Topper25122412015-11-15 03:32:11 +00001012 S.Diag(TSWLoc, diag::err_invalid_vector_bool_decl_spec)
Chris Lattner37141f42010-06-23 06:00:24 +00001013 << getSpecifierName((TSW)TypeSpecWidth);
1014
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00001015 // vector bool long long requires VSX support or ZVector.
Kit Barton8553bec2015-03-11 15:57:19 +00001016 if ((TypeSpecWidth == TSW_longlong) &&
Craig Topper25122412015-11-15 03:32:11 +00001017 (!S.Context.getTargetInfo().hasFeature("vsx")) &&
1018 (!S.Context.getTargetInfo().hasFeature("power8-vector")) &&
1019 !S.getLangOpts().ZVector)
1020 S.Diag(TSTLoc, diag::err_invalid_vector_long_long_decl_spec);
Bill Seurer2351bec2015-03-03 20:08:43 +00001021
Chris Lattner37141f42010-06-23 06:00:24 +00001022 // Elements of vector bool are interpreted as unsigned. (PIM 2.1)
1023 if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) ||
1024 (TypeSpecWidth != TSW_unspecified))
1025 TypeSpecSign = TSS_unsigned;
Bill Schmidt691e01d2014-10-31 19:19:24 +00001026 } else if (TypeSpecType == TST_double) {
1027 // vector long double and vector long long double are never allowed.
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00001028 // vector double is OK for Power7 and later, and ZVector.
Bill Schmidt691e01d2014-10-31 19:19:24 +00001029 if (TypeSpecWidth == TSW_long || TypeSpecWidth == TSW_longlong)
Craig Topper25122412015-11-15 03:32:11 +00001030 S.Diag(TSWLoc, diag::err_invalid_vector_long_double_decl_spec);
1031 else if (!S.Context.getTargetInfo().hasFeature("vsx") &&
1032 !S.getLangOpts().ZVector)
1033 S.Diag(TSTLoc, diag::err_invalid_vector_double_decl_spec);
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00001034 } else if (TypeSpecType == TST_float) {
1035 // vector float is unsupported for ZVector.
Craig Topper25122412015-11-15 03:32:11 +00001036 if (S.getLangOpts().ZVector)
1037 S.Diag(TSTLoc, diag::err_invalid_vector_float_decl_spec);
Hal Finkel3a1f4c72014-08-24 04:50:19 +00001038 } else if (TypeSpecWidth == TSW_long) {
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00001039 // vector long is unsupported for ZVector and deprecated for AltiVec.
Craig Topper25122412015-11-15 03:32:11 +00001040 if (S.getLangOpts().ZVector)
1041 S.Diag(TSWLoc, diag::err_invalid_vector_long_decl_spec);
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00001042 else
Craig Topper25122412015-11-15 03:32:11 +00001043 S.Diag(TSWLoc, diag::warn_vector_long_decl_spec_combination)
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00001044 << getSpecifierName((TST)TypeSpecType, Policy);
Chris Lattner37141f42010-06-23 06:00:24 +00001045 }
1046
1047 if (TypeAltiVecPixel) {
1048 //TODO: perform validation
1049 TypeSpecType = TST_int;
1050 TypeSpecSign = TSS_unsigned;
1051 TypeSpecWidth = TSW_short;
John McCalla3707cc2010-08-26 17:22:34 +00001052 TypeSpecOwned = false;
Chris Lattner37141f42010-06-23 06:00:24 +00001053 }
1054 }
1055
Argyrios Kyrtzidis40e9e482008-08-09 16:51:54 +00001056 // signed/unsigned are only valid with int/char/wchar_t.
Chris Lattner839713c2006-08-04 06:15:52 +00001057 if (TypeSpecSign != TSS_unspecified) {
Chris Lattnerfef9d2b2006-08-04 06:36:52 +00001058 if (TypeSpecType == TST_unspecified)
1059 TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int.
Richard Smithf016bbc2012-04-04 06:24:32 +00001060 else if (TypeSpecType != TST_int && TypeSpecType != TST_int128 &&
Argyrios Kyrtzidis40e9e482008-08-09 16:51:54 +00001061 TypeSpecType != TST_char && TypeSpecType != TST_wchar) {
Craig Topper25122412015-11-15 03:32:11 +00001062 S.Diag(TSSLoc, diag::err_invalid_sign_spec)
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001063 << getSpecifierName((TST)TypeSpecType, Policy);
Chris Lattnerfef9d2b2006-08-04 06:36:52 +00001064 // signed double -> double.
Chris Lattner839713c2006-08-04 06:15:52 +00001065 TypeSpecSign = TSS_unspecified;
1066 }
1067 }
Chris Lattnerfef9d2b2006-08-04 06:36:52 +00001068
Chris Lattner839713c2006-08-04 06:15:52 +00001069 // Validate the width of the type.
1070 switch (TypeSpecWidth) {
1071 case TSW_unspecified: break;
1072 case TSW_short: // short int
1073 case TSW_longlong: // long long int
Chris Lattnerfef9d2b2006-08-04 06:36:52 +00001074 if (TypeSpecType == TST_unspecified)
1075 TypeSpecType = TST_int; // short -> short int, long long -> long long int.
1076 else if (TypeSpecType != TST_int) {
Craig Topper25122412015-11-15 03:32:11 +00001077 S.Diag(TSWLoc, diag::err_invalid_width_spec) << (int)TypeSpecWidth
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001078 << getSpecifierName((TST)TypeSpecType, Policy);
Chris Lattner839713c2006-08-04 06:15:52 +00001079 TypeSpecType = TST_int;
John McCalla3707cc2010-08-26 17:22:34 +00001080 TypeSpecOwned = false;
Chris Lattner839713c2006-08-04 06:15:52 +00001081 }
1082 break;
1083 case TSW_long: // long double, long int
Chris Lattnerfef9d2b2006-08-04 06:36:52 +00001084 if (TypeSpecType == TST_unspecified)
1085 TypeSpecType = TST_int; // long -> long int.
1086 else if (TypeSpecType != TST_int && TypeSpecType != TST_double) {
Craig Topper25122412015-11-15 03:32:11 +00001087 S.Diag(TSWLoc, diag::err_invalid_width_spec) << (int)TypeSpecWidth
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001088 << getSpecifierName((TST)TypeSpecType, Policy);
Chris Lattner839713c2006-08-04 06:15:52 +00001089 TypeSpecType = TST_int;
John McCalla3707cc2010-08-26 17:22:34 +00001090 TypeSpecOwned = false;
Chris Lattner839713c2006-08-04 06:15:52 +00001091 }
Chris Lattnerfef9d2b2006-08-04 06:36:52 +00001092 break;
Chris Lattner839713c2006-08-04 06:15:52 +00001093 }
Mike Stump11289f42009-09-09 15:08:12 +00001094
Chris Lattner0e894622006-08-13 19:58:17 +00001095 // TODO: if the implementation does not implement _Complex or _Imaginary,
Chris Lattnerfef9d2b2006-08-04 06:36:52 +00001096 // disallow their use. Need information about the backend.
1097 if (TypeSpecComplex != TSC_unspecified) {
1098 if (TypeSpecType == TST_unspecified) {
Craig Topper25122412015-11-15 03:32:11 +00001099 S.Diag(TSCLoc, diag::ext_plain_complex)
Douglas Gregora771f462010-03-31 17:46:05 +00001100 << FixItHint::CreateInsertion(
Craig Topper25122412015-11-15 03:32:11 +00001101 S.getLocForEndOfToken(getTypeSpecComplexLoc()),
Douglas Gregore3e01a22009-04-01 22:41:11 +00001102 " double");
Chris Lattnerfef9d2b2006-08-04 06:36:52 +00001103 TypeSpecType = TST_double; // _Complex -> _Complex double.
1104 } else if (TypeSpecType == TST_int || TypeSpecType == TST_char) {
Chris Lattnerf63f89a2006-08-05 03:28:50 +00001105 // Note that this intentionally doesn't include _Complex _Bool.
Craig Topper25122412015-11-15 03:32:11 +00001106 if (!S.getLangOpts().CPlusPlus)
1107 S.Diag(TSTLoc, diag::ext_integer_complex);
Chris Lattnerfef9d2b2006-08-04 06:36:52 +00001108 } else if (TypeSpecType != TST_float && TypeSpecType != TST_double) {
Craig Topper25122412015-11-15 03:32:11 +00001109 S.Diag(TSCLoc, diag::err_invalid_complex_spec)
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001110 << getSpecifierName((TST)TypeSpecType, Policy);
Chris Lattnerfef9d2b2006-08-04 06:36:52 +00001111 TypeSpecComplex = TSC_unspecified;
1112 }
1113 }
Chris Lattner8e90ef62006-08-05 03:30:45 +00001114
Richard Smithb4a9e862013-04-12 22:46:28 +00001115 // C11 6.7.1/3, C++11 [dcl.stc]p1, GNU TLS: __thread, thread_local and
1116 // _Thread_local can only appear with the 'static' and 'extern' storage class
1117 // specifiers. We also allow __private_extern__ as an extension.
1118 if (ThreadStorageClassSpec != TSCS_unspecified) {
1119 switch (StorageClassSpec) {
1120 case SCS_unspecified:
1121 case SCS_extern:
1122 case SCS_private_extern:
1123 case SCS_static:
1124 break;
1125 default:
Craig Topper25122412015-11-15 03:32:11 +00001126 if (S.getSourceManager().isBeforeInTranslationUnit(
Richard Smithb4a9e862013-04-12 22:46:28 +00001127 getThreadStorageClassSpecLoc(), getStorageClassSpecLoc()))
Craig Topper25122412015-11-15 03:32:11 +00001128 S.Diag(getStorageClassSpecLoc(),
Richard Smithb4a9e862013-04-12 22:46:28 +00001129 diag::err_invalid_decl_spec_combination)
1130 << DeclSpec::getSpecifierName(getThreadStorageClassSpec())
1131 << SourceRange(getThreadStorageClassSpecLoc());
1132 else
Craig Topper25122412015-11-15 03:32:11 +00001133 S.Diag(getThreadStorageClassSpecLoc(),
Richard Smithb4a9e862013-04-12 22:46:28 +00001134 diag::err_invalid_decl_spec_combination)
1135 << DeclSpec::getSpecifierName(getStorageClassSpec())
1136 << SourceRange(getStorageClassSpecLoc());
1137 // Discard the thread storage class specifier to recover.
1138 ThreadStorageClassSpec = TSCS_unspecified;
1139 ThreadStorageClassSpecLoc = SourceLocation();
1140 }
1141 }
1142
Richard Smith58c74332011-09-04 19:54:14 +00001143 // If no type specifier was provided and we're parsing a language where
1144 // the type specifier is not optional, but we got 'auto' as a storage
1145 // class specifier, then assume this is an attempt to use C++0x's 'auto'
1146 // type specifier.
Craig Topper25122412015-11-15 03:32:11 +00001147 if (S.getLangOpts().CPlusPlus &&
Richard Smith58c74332011-09-04 19:54:14 +00001148 TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) {
1149 TypeSpecType = TST_auto;
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001150 StorageClassSpec = SCS_unspecified;
Richard Smith58c74332011-09-04 19:54:14 +00001151 TSTLoc = TSTNameLoc = StorageClassSpecLoc;
1152 StorageClassSpecLoc = SourceLocation();
1153 }
1154 // Diagnose if we've recovered from an ill-formed 'auto' storage class
Richard Smith74aeef52013-04-26 16:15:35 +00001155 // specifier in a pre-C++11 dialect of C++.
Craig Topper25122412015-11-15 03:32:11 +00001156 if (!S.getLangOpts().CPlusPlus11 && TypeSpecType == TST_auto)
1157 S.Diag(TSTLoc, diag::ext_auto_type_specifier);
1158 if (S.getLangOpts().CPlusPlus && !S.getLangOpts().CPlusPlus11 &&
Richard Smith58c74332011-09-04 19:54:14 +00001159 StorageClassSpec == SCS_auto)
Craig Topper25122412015-11-15 03:32:11 +00001160 S.Diag(StorageClassSpecLoc, diag::warn_auto_storage_class)
Richard Smith58c74332011-09-04 19:54:14 +00001161 << FixItHint::CreateRemoval(StorageClassSpecLoc);
Richard Smithb15c11c2011-10-17 23:06:20 +00001162 if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32)
Craig Topper25122412015-11-15 03:32:11 +00001163 S.Diag(TSTLoc, diag::warn_cxx98_compat_unicode_type)
Richard Smithb15c11c2011-10-17 23:06:20 +00001164 << (TypeSpecType == TST_char16 ? "char16_t" : "char32_t");
Richard Smithb15c11c2011-10-17 23:06:20 +00001165 if (Constexpr_specified)
Craig Topper25122412015-11-15 03:32:11 +00001166 S.Diag(ConstexprLoc, diag::warn_cxx98_compat_constexpr);
Richard Smith58c74332011-09-04 19:54:14 +00001167
John McCall07e91c02009-08-06 02:15:43 +00001168 // C++ [class.friend]p6:
1169 // No storage-class-specifier shall appear in the decl-specifier-seq
1170 // of a friend declaration.
Richard Smithb4a9e862013-04-12 22:46:28 +00001171 if (isFriendSpecified() &&
1172 (getStorageClassSpec() || getThreadStorageClassSpec())) {
1173 SmallString<32> SpecName;
1174 SourceLocation SCLoc;
1175 FixItHint StorageHint, ThreadHint;
John McCall07e91c02009-08-06 02:15:43 +00001176
Richard Smithb4a9e862013-04-12 22:46:28 +00001177 if (DeclSpec::SCS SC = getStorageClassSpec()) {
1178 SpecName = getSpecifierName(SC);
1179 SCLoc = getStorageClassSpecLoc();
1180 StorageHint = FixItHint::CreateRemoval(SCLoc);
1181 }
1182
1183 if (DeclSpec::TSCS TSC = getThreadStorageClassSpec()) {
1184 if (!SpecName.empty()) SpecName += " ";
1185 SpecName += getSpecifierName(TSC);
1186 SCLoc = getThreadStorageClassSpecLoc();
1187 ThreadHint = FixItHint::CreateRemoval(SCLoc);
1188 }
John McCall07e91c02009-08-06 02:15:43 +00001189
Craig Topper25122412015-11-15 03:32:11 +00001190 S.Diag(SCLoc, diag::err_friend_decl_spec)
Richard Smithb4a9e862013-04-12 22:46:28 +00001191 << SpecName << StorageHint << ThreadHint;
John McCall07e91c02009-08-06 02:15:43 +00001192
1193 ClearStorageClassSpecs();
1194 }
1195
David Majnemerdeca7052014-04-30 18:24:01 +00001196 // C++11 [dcl.fct.spec]p5:
1197 // The virtual specifier shall be used only in the initial
1198 // declaration of a non-static class member function;
1199 // C++11 [dcl.fct.spec]p6:
1200 // The explicit specifier shall be used only in the declaration of
1201 // a constructor or conversion function within its class
1202 // definition;
1203 if (isFriendSpecified() && (isVirtualSpecified() || isExplicitSpecified())) {
1204 StringRef Keyword;
1205 SourceLocation SCLoc;
1206
1207 if (isVirtualSpecified()) {
1208 Keyword = "virtual";
1209 SCLoc = getVirtualSpecLoc();
1210 } else {
1211 Keyword = "explicit";
1212 SCLoc = getExplicitSpecLoc();
1213 }
1214
1215 FixItHint Hint = FixItHint::CreateRemoval(SCLoc);
Craig Topper25122412015-11-15 03:32:11 +00001216 S.Diag(SCLoc, diag::err_friend_decl_spec)
David Majnemerdeca7052014-04-30 18:24:01 +00001217 << Keyword << Hint;
1218
1219 FS_virtual_specified = FS_explicit_specified = false;
1220 FS_virtualLoc = FS_explicitLoc = SourceLocation();
1221 }
1222
Douglas Gregor64226422011-09-09 21:14:29 +00001223 assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType));
David Majnemerdeca7052014-04-30 18:24:01 +00001224
Chris Lattner8e90ef62006-08-05 03:30:45 +00001225 // Okay, now we can infer the real type.
Mike Stump11289f42009-09-09 15:08:12 +00001226
Chris Lattner0e894622006-08-13 19:58:17 +00001227 // TODO: return "auto function" and other bad things based on the real type.
Mike Stump11289f42009-09-09 15:08:12 +00001228
Chris Lattner1ae23292006-08-04 06:42:31 +00001229 // 'data definition has no type or storage class'?
Chris Lattnerb9093cd2006-08-04 04:39:53 +00001230}
Daniel Dunbarc74b5cc2008-08-11 03:45:03 +00001231
Sebastian Redla2b5e312008-12-28 15:28:59 +00001232bool DeclSpec::isMissingDeclaratorOk() {
1233 TST tst = getTypeSpecType();
Craig Topper4b566922014-06-09 02:04:02 +00001234 return isDeclRep(tst) && getRepAsDecl() != nullptr &&
John McCallba7bf592010-08-24 05:47:05 +00001235 StorageClassSpec != DeclSpec::SCS_typedef;
Sebastian Redla2b5e312008-12-28 15:28:59 +00001236}
Douglas Gregor7861a802009-11-03 01:35:08 +00001237
Douglas Gregor7861a802009-11-03 01:35:08 +00001238void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc,
1239 OverloadedOperatorKind Op,
1240 SourceLocation SymbolLocations[3]) {
1241 Kind = IK_OperatorFunctionId;
1242 StartLocation = OperatorLoc;
1243 EndLocation = OperatorLoc;
1244 OperatorFunctionId.Operator = Op;
1245 for (unsigned I = 0; I != 3; ++I) {
1246 OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding();
1247
1248 if (SymbolLocations[I].isValid())
1249 EndLocation = SymbolLocations[I];
1250 }
1251}
Anders Carlsson56104902011-01-17 03:05:47 +00001252
Anders Carlsson4b63d0e2011-01-22 16:56:46 +00001253bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc,
Anders Carlssonf2ca3892011-01-22 15:58:16 +00001254 const char *&PrevSpec) {
Ehsan Akhgari93ed5cf2015-03-25 00:53:27 +00001255 if (!FirstLocation.isValid())
1256 FirstLocation = Loc;
Douglas Gregorf2f08062011-03-08 17:10:18 +00001257 LastLocation = Loc;
Ehsan Akhgari93ed5cf2015-03-25 00:53:27 +00001258 LastSpecifier = VS;
Douglas Gregorf2f08062011-03-08 17:10:18 +00001259
Anders Carlsson56104902011-01-17 03:05:47 +00001260 if (Specifiers & VS) {
1261 PrevSpec = getSpecifierName(VS);
1262 return true;
1263 }
1264
1265 Specifiers |= VS;
1266
1267 switch (VS) {
David Blaikie83d382b2011-09-23 05:06:16 +00001268 default: llvm_unreachable("Unknown specifier!");
Anders Carlsson56104902011-01-17 03:05:47 +00001269 case VS_Override: VS_overrideLoc = Loc; break;
David Majnemera5433082013-10-18 00:33:31 +00001270 case VS_Sealed:
Anders Carlsson56104902011-01-17 03:05:47 +00001271 case VS_Final: VS_finalLoc = Loc; break;
Anders Carlsson56104902011-01-17 03:05:47 +00001272 }
Anders Carlssonf2ca3892011-01-22 15:58:16 +00001273
Anders Carlsson56104902011-01-17 03:05:47 +00001274 return false;
1275}
1276
Anders Carlsson4b63d0e2011-01-22 16:56:46 +00001277const char *VirtSpecifiers::getSpecifierName(Specifier VS) {
Anders Carlssona6d35012011-01-22 15:11:37 +00001278 switch (VS) {
David Blaikie83d382b2011-09-23 05:06:16 +00001279 default: llvm_unreachable("Unknown specifier");
Anders Carlssona6d35012011-01-22 15:11:37 +00001280 case VS_Override: return "override";
1281 case VS_Final: return "final";
David Majnemera5433082013-10-18 00:33:31 +00001282 case VS_Sealed: return "sealed";
Anders Carlssona6d35012011-01-22 15:11:37 +00001283 }
1284}