Coverage Report

Created: 2020-02-15 09:57

/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 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
18.8M
  inline bool isTemplateInstantiation(TemplateSpecializationKind Kind) {
200
18.8M
    return Kind != TSK_Undeclared && 
Kind != TSK_ExplicitSpecialization4.80M
;
201
18.8M
  }
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
1.12M
      TemplateSpecializationKind Kind) {
208
1.12M
    switch (Kind) {
209
100k
    case TSK_ExplicitSpecialization:
210
100k
    case TSK_ExplicitInstantiationDeclaration:
211
100k
    case TSK_ExplicitInstantiationDefinition:
212
100k
      return true;
213
100k
214
1.02M
    case TSK_Undeclared:
215
1.02M
    case TSK_ImplicitInstantiation:
216
1.02M
      return false;
217
0
    }
218
0
    llvm_unreachable("bad template specialization kind");
219
0
  }
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
0
  inline bool isLegalForFunction(StorageClass SC) {
249
0
    return SC <= SC_PrivateExtern;
250
0
  }
251
252
  /// Checks whether the given storage class is legal for variables.
253
81
  inline bool isLegalForVariable(StorageClass SC) {
254
81
    return true;
255
81
  }
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
7.81k
  inline bool supportsVariadicCall(CallingConv CC) {
289
7.81k
    switch (CC) {
290
1.91k
    case CC_X86StdCall:
291
1.91k
    case CC_X86FastCall:
292
1.91k
    case CC_X86ThisCall:
293
1.91k
    case CC_X86RegCall:
294
1.91k
    case CC_X86Pascal:
295
1.91k
    case CC_X86VectorCall:
296
1.91k
    case CC_SpirFunction:
297
1.91k
    case CC_OpenCLKernel:
298
1.91k
    case CC_Swift:
299
1.91k
      return false;
300
5.90k
    default:
301
5.90k
      return true;
302
7.81k
    }
303
7.81k
  }
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
2
  inline bool hasWeakerNullability(NullabilityKind L, NullabilityKind R) {
330
2
    return uint8_t(L) > uint8_t(R);
331
2
  }
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