1 | //===--- Specifiers.h - Declaration and Type Specifiers ---------*- C++ -*-===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | /// |
9 | /// \file |
10 | /// Defines various enumerations that describe declaration and |
11 | /// type specifiers. |
12 | /// |
13 | //===----------------------------------------------------------------------===// |
14 | |
15 | #ifndef LLVM_CLANG_BASIC_SPECIFIERS_H |
16 | #define LLVM_CLANG_BASIC_SPECIFIERS_H |
17 | |
18 | #include "llvm/ADT/StringRef.h" |
19 | #include "llvm/Support/DataTypes.h" |
20 | #include "llvm/Support/ErrorHandling.h" |
21 | |
22 | namespace llvm { |
23 | class raw_ostream; |
24 | } // namespace llvm |
25 | namespace clang { |
26 | |
27 | /// Define the meaning of possible values of the kind in ExplicitSpecifier. |
28 | enum class ExplicitSpecKind : unsigned { |
29 | ResolvedFalse, |
30 | ResolvedTrue, |
31 | Unresolved, |
32 | }; |
33 | |
34 | /// Define the kind of constexpr specifier. |
35 | enum class ConstexprSpecKind { Unspecified, Constexpr, Consteval, Constinit }; |
36 | |
37 | /// In an if statement, this denotes whether the statement is |
38 | /// a constexpr or consteval if statement. |
39 | enum class IfStatementKind : unsigned { |
40 | Ordinary, |
41 | Constexpr, |
42 | ConstevalNonNegated, |
43 | ConstevalNegated |
44 | }; |
45 | |
46 | /// Specifies the width of a type, e.g., short, long, or long long. |
47 | enum class TypeSpecifierWidth { Unspecified, Short, Long, LongLong }; |
48 | |
49 | /// Specifies the signedness of a type, e.g., signed or unsigned. |
50 | enum class TypeSpecifierSign { Unspecified, Signed, Unsigned }; |
51 | |
52 | enum class TypeSpecifiersPipe { Unspecified, Pipe }; |
53 | |
54 | /// Specifies the kind of type. |
55 | enum TypeSpecifierType { |
56 | TST_unspecified, |
57 | TST_void, |
58 | TST_char, |
59 | TST_wchar, // C++ wchar_t |
60 | TST_char8, // C++20 char8_t (proposed) |
61 | TST_char16, // C++11 char16_t |
62 | TST_char32, // C++11 char32_t |
63 | TST_int, |
64 | TST_int128, |
65 | TST_bitint, // Bit-precise integer types. |
66 | TST_half, // OpenCL half, ARM NEON __fp16 |
67 | TST_Float16, // C11 extension ISO/IEC TS 18661-3 |
68 | TST_Accum, // ISO/IEC JTC1 SC22 WG14 N1169 Extension |
69 | TST_Fract, |
70 | TST_BFloat16, |
71 | TST_float, |
72 | TST_double, |
73 | TST_float128, |
74 | TST_ibm128, |
75 | TST_bool, // _Bool |
76 | TST_decimal32, // _Decimal32 |
77 | TST_decimal64, // _Decimal64 |
78 | TST_decimal128, // _Decimal128 |
79 | TST_enum, |
80 | TST_union, |
81 | TST_struct, |
82 | TST_class, // C++ class type |
83 | TST_interface, // C++ (Microsoft-specific) __interface type |
84 | TST_typename, // Typedef, C++ class-name or enum name, etc. |
85 | TST_typeofType, // C23 (and GNU extension) typeof(type-name) |
86 | TST_typeofExpr, // C23 (and GNU extension) typeof(expression) |
87 | TST_typeof_unqualType, // C23 typeof_unqual(type-name) |
88 | TST_typeof_unqualExpr, // C23 typeof_unqual(expression) |
89 | TST_decltype, // C++11 decltype |
90 | #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) TST_##Trait, |
91 | #include "clang/Basic/TransformTypeTraits.def" |
92 | TST_auto, // C++11 auto |
93 | TST_decltype_auto, // C++1y decltype(auto) |
94 | TST_auto_type, // __auto_type extension |
95 | TST_unknown_anytype, // __unknown_anytype extension |
96 | TST_atomic, // C11 _Atomic |
97 | TST_typename_pack_indexing, |
98 | #define GENERIC_IMAGE_TYPE(ImgType, Id) \ |
99 | TST_##ImgType##_t, // OpenCL image types |
100 | #include "clang/Basic/OpenCLImageTypes.def" |
101 | TST_error // erroneous type |
102 | }; |
103 | |
104 | /// Structure that packs information about the type specifiers that |
105 | /// were written in a particular type specifier sequence. |
106 | struct WrittenBuiltinSpecs { |
107 | static_assert(TST_error < 1 << 7, "Type bitfield not wide enough for TST" ); |
108 | LLVM_PREFERRED_TYPE(TypeSpecifierType) |
109 | unsigned Type : 7; |
110 | LLVM_PREFERRED_TYPE(TypeSpecifierSign) |
111 | unsigned Sign : 2; |
112 | LLVM_PREFERRED_TYPE(TypeSpecifierWidth) |
113 | unsigned Width : 2; |
114 | LLVM_PREFERRED_TYPE(bool) |
115 | unsigned ModeAttr : 1; |
116 | }; |
117 | |
118 | /// A C++ access specifier (public, private, protected), plus the |
119 | /// special value "none" which means different things in different contexts. |
120 | enum AccessSpecifier { |
121 | AS_public, |
122 | AS_protected, |
123 | AS_private, |
124 | AS_none |
125 | }; |
126 | |
127 | /// The categorization of expression values, currently following the |
128 | /// C++11 scheme. |
129 | enum ExprValueKind { |
130 | /// A pr-value expression (in the C++11 taxonomy) |
131 | /// produces a temporary value. |
132 | VK_PRValue, |
133 | |
134 | /// An l-value expression is a reference to an object with |
135 | /// independent storage. |
136 | VK_LValue, |
137 | |
138 | /// An x-value expression is a reference to an object with |
139 | /// independent storage but which can be "moved", i.e. |
140 | /// efficiently cannibalized for its resources. |
141 | VK_XValue |
142 | }; |
143 | |
144 | /// A further classification of the kind of object referenced by an |
145 | /// l-value or x-value. |
146 | enum ExprObjectKind { |
147 | /// An ordinary object is located at an address in memory. |
148 | OK_Ordinary, |
149 | |
150 | /// A bitfield object is a bitfield on a C or C++ record. |
151 | OK_BitField, |
152 | |
153 | /// A vector component is an element or range of elements on a vector. |
154 | OK_VectorComponent, |
155 | |
156 | /// An Objective-C property is a logical field of an Objective-C |
157 | /// object which is read and written via Objective-C method calls. |
158 | OK_ObjCProperty, |
159 | |
160 | /// An Objective-C array/dictionary subscripting which reads an |
161 | /// object or writes at the subscripted array/dictionary element via |
162 | /// Objective-C method calls. |
163 | OK_ObjCSubscript, |
164 | |
165 | /// A matrix component is a single element of a matrix. |
166 | OK_MatrixComponent |
167 | }; |
168 | |
169 | /// The reason why a DeclRefExpr does not constitute an odr-use. |
170 | enum NonOdrUseReason { |
171 | /// This is an odr-use. |
172 | NOUR_None = 0, |
173 | /// This name appears in an unevaluated operand. |
174 | NOUR_Unevaluated, |
175 | /// This name appears as a potential result of an lvalue-to-rvalue |
176 | /// conversion that is a constant expression. |
177 | NOUR_Constant, |
178 | /// This name appears as a potential result of a discarded value |
179 | /// expression. |
180 | NOUR_Discarded, |
181 | }; |
182 | |
183 | /// Describes the kind of template specialization that a |
184 | /// particular template specialization declaration represents. |
185 | enum TemplateSpecializationKind { |
186 | /// This template specialization was formed from a template-id but |
187 | /// has not yet been declared, defined, or instantiated. |
188 | TSK_Undeclared = 0, |
189 | /// This template specialization was implicitly instantiated from a |
190 | /// template. (C++ [temp.inst]). |
191 | TSK_ImplicitInstantiation, |
192 | /// This template specialization was declared or defined by an |
193 | /// explicit specialization (C++ [temp.expl.spec]) or partial |
194 | /// specialization (C++ [temp.class.spec]). |
195 | TSK_ExplicitSpecialization, |
196 | /// This template specialization was instantiated from a template |
197 | /// due to an explicit instantiation declaration request |
198 | /// (C++11 [temp.explicit]). |
199 | TSK_ExplicitInstantiationDeclaration, |
200 | /// This template specialization was instantiated from a template |
201 | /// due to an explicit instantiation definition request |
202 | /// (C++ [temp.explicit]). |
203 | TSK_ExplicitInstantiationDefinition |
204 | }; |
205 | |
206 | /// Determine whether this template specialization kind refers |
207 | /// to an instantiation of an entity (as opposed to a non-template or |
208 | /// an explicit specialization). |
209 | inline bool isTemplateInstantiation(TemplateSpecializationKind Kind) { |
210 | return Kind != TSK_Undeclared && Kind != TSK_ExplicitSpecialization; |
211 | } |
212 | |
213 | /// True if this template specialization kind is an explicit |
214 | /// specialization, explicit instantiation declaration, or explicit |
215 | /// instantiation definition. |
216 | inline bool isTemplateExplicitInstantiationOrSpecialization( |
217 | TemplateSpecializationKind Kind) { |
218 | switch (Kind) { |
219 | case TSK_ExplicitSpecialization: |
220 | case TSK_ExplicitInstantiationDeclaration: |
221 | case TSK_ExplicitInstantiationDefinition: |
222 | return true; |
223 | |
224 | case TSK_Undeclared: |
225 | case TSK_ImplicitInstantiation: |
226 | return false; |
227 | } |
228 | llvm_unreachable("bad template specialization kind" ); |
229 | } |
230 | |
231 | /// Thread storage-class-specifier. |
232 | enum ThreadStorageClassSpecifier { |
233 | TSCS_unspecified, |
234 | /// GNU __thread. |
235 | TSCS___thread, |
236 | /// C++11 thread_local. Implies 'static' at block scope, but not at |
237 | /// class scope. |
238 | TSCS_thread_local, |
239 | /// C11 _Thread_local. Must be combined with either 'static' or 'extern' |
240 | /// if used at block scope. |
241 | TSCS__Thread_local |
242 | }; |
243 | |
244 | /// Storage classes. |
245 | enum StorageClass { |
246 | // These are legal on both functions and variables. |
247 | SC_None, |
248 | SC_Extern, |
249 | SC_Static, |
250 | SC_PrivateExtern, |
251 | |
252 | // These are only legal on variables. |
253 | SC_Auto, |
254 | SC_Register |
255 | }; |
256 | |
257 | /// Checks whether the given storage class is legal for functions. |
258 | inline bool isLegalForFunction(StorageClass SC) { |
259 | return SC <= SC_PrivateExtern; |
260 | } |
261 | |
262 | /// Checks whether the given storage class is legal for variables. |
263 | inline bool isLegalForVariable(StorageClass SC) { |
264 | return true; |
265 | } |
266 | |
267 | /// In-class initialization styles for non-static data members. |
268 | enum InClassInitStyle { |
269 | ICIS_NoInit, ///< No in-class initializer. |
270 | ICIS_CopyInit, ///< Copy initialization. |
271 | ICIS_ListInit ///< Direct list-initialization. |
272 | }; |
273 | |
274 | /// CallingConv - Specifies the calling convention that a function uses. |
275 | enum CallingConv { |
276 | CC_C, // __attribute__((cdecl)) |
277 | CC_X86StdCall, // __attribute__((stdcall)) |
278 | CC_X86FastCall, // __attribute__((fastcall)) |
279 | CC_X86ThisCall, // __attribute__((thiscall)) |
280 | CC_X86VectorCall, // __attribute__((vectorcall)) |
281 | CC_X86Pascal, // __attribute__((pascal)) |
282 | CC_Win64, // __attribute__((ms_abi)) |
283 | CC_X86_64SysV, // __attribute__((sysv_abi)) |
284 | CC_X86RegCall, // __attribute__((regcall)) |
285 | CC_AAPCS, // __attribute__((pcs("aapcs"))) |
286 | CC_AAPCS_VFP, // __attribute__((pcs("aapcs-vfp"))) |
287 | CC_IntelOclBicc, // __attribute__((intel_ocl_bicc)) |
288 | CC_SpirFunction, // default for OpenCL functions on SPIR target |
289 | CC_OpenCLKernel, // inferred for OpenCL kernels |
290 | CC_Swift, // __attribute__((swiftcall)) |
291 | CC_SwiftAsync, // __attribute__((swiftasynccall)) |
292 | CC_PreserveMost, // __attribute__((preserve_most)) |
293 | CC_PreserveAll, // __attribute__((preserve_all)) |
294 | CC_AArch64VectorCall, // __attribute__((aarch64_vector_pcs)) |
295 | CC_AArch64SVEPCS, // __attribute__((aarch64_sve_pcs)) |
296 | CC_AMDGPUKernelCall, // __attribute__((amdgpu_kernel)) |
297 | CC_M68kRTD, // __attribute__((m68k_rtd)) |
298 | CC_PreserveNone, // __attribute__((preserve_none)) |
299 | }; |
300 | |
301 | /// Checks whether the given calling convention supports variadic |
302 | /// calls. Unprototyped calls also use the variadic call rules. |
303 | inline bool supportsVariadicCall(CallingConv CC) { |
304 | switch (CC) { |
305 | case CC_X86StdCall: |
306 | case CC_X86FastCall: |
307 | case CC_X86ThisCall: |
308 | case CC_X86RegCall: |
309 | case CC_X86Pascal: |
310 | case CC_X86VectorCall: |
311 | case CC_SpirFunction: |
312 | case CC_OpenCLKernel: |
313 | case CC_Swift: |
314 | case CC_SwiftAsync: |
315 | case CC_M68kRTD: |
316 | return false; |
317 | default: |
318 | return true; |
319 | } |
320 | } |
321 | |
322 | /// The storage duration for an object (per C++ [basic.stc]). |
323 | enum StorageDuration { |
324 | SD_FullExpression, ///< Full-expression storage duration (for temporaries). |
325 | SD_Automatic, ///< Automatic storage duration (most local variables). |
326 | SD_Thread, ///< Thread storage duration. |
327 | SD_Static, ///< Static storage duration. |
328 | SD_Dynamic ///< Dynamic storage duration. |
329 | }; |
330 | |
331 | /// Describes the nullability of a particular type. |
332 | enum class NullabilityKind : uint8_t { |
333 | /// Values of this type can never be null. |
334 | NonNull = 0, |
335 | /// Values of this type can be null. |
336 | Nullable, |
337 | /// Whether values of this type can be null is (explicitly) |
338 | /// unspecified. This captures a (fairly rare) case where we |
339 | /// can't conclude anything about the nullability of the type even |
340 | /// though it has been considered. |
341 | Unspecified, |
342 | // Generally behaves like Nullable, except when used in a block parameter |
343 | // that was imported into a swift async method. There, swift will assume |
344 | // that the parameter can get null even if no error occurred. _Nullable |
345 | // parameters are assumed to only get null on error. |
346 | NullableResult, |
347 | }; |
348 | /// Prints human-readable debug representation. |
349 | llvm::raw_ostream &operator<<(llvm::raw_ostream&, NullabilityKind); |
350 | |
351 | /// Return true if \p L has a weaker nullability annotation than \p R. The |
352 | /// ordering is: Unspecified < Nullable < NonNull. |
353 | inline bool hasWeakerNullability(NullabilityKind L, NullabilityKind R) { |
354 | return uint8_t(L) > uint8_t(R); |
355 | } |
356 | |
357 | /// Retrieve the spelling of the given nullability kind. |
358 | llvm::StringRef getNullabilitySpelling(NullabilityKind kind, |
359 | bool isContextSensitive = false); |
360 | |
361 | /// Kinds of parameter ABI. |
362 | enum class ParameterABI { |
363 | /// This parameter uses ordinary ABI rules for its type. |
364 | Ordinary, |
365 | |
366 | /// This parameter (which must have pointer type) is a Swift |
367 | /// indirect result parameter. |
368 | SwiftIndirectResult, |
369 | |
370 | /// This parameter (which must have pointer-to-pointer type) uses |
371 | /// the special Swift error-result ABI treatment. There can be at |
372 | /// most one parameter on a given function that uses this treatment. |
373 | SwiftErrorResult, |
374 | |
375 | /// This parameter (which must have pointer type) uses the special |
376 | /// Swift context-pointer ABI treatment. There can be at |
377 | /// most one parameter on a given function that uses this treatment. |
378 | SwiftContext, |
379 | |
380 | /// This parameter (which must have pointer type) uses the special |
381 | /// Swift asynchronous context-pointer ABI treatment. There can be at |
382 | /// most one parameter on a given function that uses this treatment. |
383 | SwiftAsyncContext, |
384 | }; |
385 | |
386 | /// Assigned inheritance model for a class in the MS C++ ABI. Must match order |
387 | /// of spellings in MSInheritanceAttr. |
388 | enum class MSInheritanceModel { |
389 | Single = 0, |
390 | Multiple = 1, |
391 | Virtual = 2, |
392 | Unspecified = 3, |
393 | }; |
394 | |
395 | llvm::StringRef getParameterABISpelling(ParameterABI kind); |
396 | |
397 | inline llvm::StringRef getAccessSpelling(AccessSpecifier AS) { |
398 | switch (AS) { |
399 | case AccessSpecifier::AS_public: |
400 | return "public" ; |
401 | case AccessSpecifier::AS_protected: |
402 | return "protected" ; |
403 | case AccessSpecifier::AS_private: |
404 | return "private" ; |
405 | case AccessSpecifier::AS_none: |
406 | return {}; |
407 | } |
408 | llvm_unreachable("Unknown AccessSpecifier" ); |
409 | } |
410 | } // end namespace clang |
411 | |
412 | #endif // LLVM_CLANG_BASIC_SPECIFIERS_H |
413 | |