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