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