contrib/llvm/tools/clang/include/clang/AST/BuiltinTypes.def

   1 //===-- BuiltinTypes.def - Metadata about BuiltinTypes ----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file defines the database about various builtin singleton types.
  11 //
  12 //  BuiltinType::Id is the enumerator defining the type.
  13 //
  14 //  Context.SingletonId is the global singleton of this type.  Some global
  15 //  singletons are shared by multiple types.
  16 //
  17 //    BUILTIN_TYPE(Id, SingletonId) - A builtin type that has not been
  18 //    covered by any other #define.  Defining this macro covers all
  19 //    the builtins.
  20 //
  21 //    SIGNED_TYPE(Id, SingletonId) - A signed integral type.
  22 //
  23 //    UNSIGNED_TYPE(Id, SingletonId) - An unsigned integral type.
  24 //
  25 //    FLOATING_TYPE(Id, SingletonId) - A floating-point type.
  26 //
  27 //    PLACEHOLDER_TYPE(Id, SingletonId) - A placeholder type.  Placeholder
  28 //    types are used to perform context-sensitive checking of specific
  29 //    forms of expression.
  30 //
  31 //    SHARED_SINGLETON_TYPE(Expansion) - The given expansion corresponds
  32 //    to a builtin which uses a shared singleton type.
  33 //
  34 //===----------------------------------------------------------------------===//
  35
  36 #ifndef SIGNED_TYPE
  37 #define SIGNED_TYPE(Id, SingletonId) BUILTIN_TYPE(Id, SingletonId)
  38 #endif
  39
  40 #ifndef UNSIGNED_TYPE
  41 #define UNSIGNED_TYPE(Id, SingletonId) BUILTIN_TYPE(Id, SingletonId)
  42 #endif
  43
  44 #ifndef FLOATING_TYPE
  45 #define FLOATING_TYPE(Id, SingletonId) BUILTIN_TYPE(Id, SingletonId)
  46 #endif
  47
  48 #ifndef PLACEHOLDER_TYPE
  49 #define PLACEHOLDER_TYPE(Id, SingletonId) BUILTIN_TYPE(Id, SingletonId)
  50 #endif
  51
  52 #ifndef SHARED_SINGLETON_TYPE
  53 #define SHARED_SINGLETON_TYPE(Expansion) Expansion
  54 #endif
  55
  56 //===- Builtin Types ------------------------------------------------------===//
  57
  58 // void
  59 BUILTIN_TYPE(Void, VoidTy)
  60
  61 //===- Unsigned Types -----------------------------------------------------===//
  62
  63 // 'bool' in C++, '_Bool' in C99
  64 UNSIGNED_TYPE(Bool, BoolTy)
  65
  66 // 'char' for targets where it's unsigned
  67 SHARED_SINGLETON_TYPE(UNSIGNED_TYPE(Char_U, CharTy))
  68
  69 // 'unsigned char', explicitly qualified
  70 UNSIGNED_TYPE(UChar, UnsignedCharTy)
  71
  72 // 'wchar_t' for targets where it's unsigned
  73 SHARED_SINGLETON_TYPE(UNSIGNED_TYPE(WChar_U, WCharTy))
  74
  75 // 'char16_t' in C++
  76 UNSIGNED_TYPE(Char16, Char16Ty)
  77
  78 // 'char32_t' in C++
  79 UNSIGNED_TYPE(Char32, Char32Ty)
  80
  81 // 'unsigned short'
  82 UNSIGNED_TYPE(UShort, UnsignedShortTy)
  83
  84 // 'unsigned int'
  85 UNSIGNED_TYPE(UInt, UnsignedIntTy)
  86
  87 // 'unsigned long'
  88 UNSIGNED_TYPE(ULong, UnsignedLongTy)
  89
  90 // 'unsigned long long'
  91 UNSIGNED_TYPE(ULongLong, UnsignedLongLongTy)
  92
  93 // '__uint128_t'
  94 UNSIGNED_TYPE(UInt128, UnsignedInt128Ty)
  95
  96 //===- Signed Types -------------------------------------------------------===//
  97
  98 // 'char' for targets where it's signed
  99 SHARED_SINGLETON_TYPE(SIGNED_TYPE(Char_S, CharTy))
 100
 101 // 'signed char', explicitly qualified
 102 SIGNED_TYPE(SChar, SignedCharTy)
 103
 104 // 'wchar_t' for targets where it's signed
 105 SHARED_SINGLETON_TYPE(SIGNED_TYPE(WChar_S, WCharTy))
 106
 107 // 'short' or 'signed short'
 108 SIGNED_TYPE(Short, ShortTy)
 109
 110 // 'int' or 'signed int'
 111 SIGNED_TYPE(Int, IntTy)
 112
 113 // 'long' or 'signed long'
 114 SIGNED_TYPE(Long, LongTy)
 115
 116 // 'long long' or 'signed long long'
 117 SIGNED_TYPE(LongLong, LongLongTy)
 118
 119 // '__int128_t'
 120 SIGNED_TYPE(Int128, Int128Ty)
 121
 122 //===- Floating point types -----------------------------------------------===//
 123
 124 // 'half' in OpenCL, '__fp16' in ARM NEON.
 125 FLOATING_TYPE(Half, HalfTy)
 126
 127 // 'float'
 128 FLOATING_TYPE(Float, FloatTy)
 129
 130 // 'double'
 131 FLOATING_TYPE(Double, DoubleTy)
 132
 133 // 'long double'
 134 FLOATING_TYPE(LongDouble, LongDoubleTy)
 135
 136 //===- Language-specific types --------------------------------------------===//
 137
 138 // This is the type of C++0x 'nullptr'.
 139 BUILTIN_TYPE(NullPtr, NullPtrTy)
 140
 141 // The primitive Objective C 'id' type.  The user-visible 'id'
 142 // type is a typedef of an ObjCObjectPointerType to an
 143 // ObjCObjectType with this as its base.  In fact, this only ever
 144 // shows up in an AST as the base type of an ObjCObjectType.
 145 BUILTIN_TYPE(ObjCId, ObjCBuiltinIdTy)
 146
 147 // The primitive Objective C 'Class' type.  The user-visible
 148 // 'Class' type is a typedef of an ObjCObjectPointerType to an
 149 // ObjCObjectType with this as its base.  In fact, this only ever
 150 // shows up in an AST as the base type of an ObjCObjectType.
 151 BUILTIN_TYPE(ObjCClass, ObjCBuiltinClassTy)
 152
 153 // The primitive Objective C 'SEL' type.  The user-visible 'SEL'
 154 // type is a typedef of a PointerType to this.
 155 BUILTIN_TYPE(ObjCSel, ObjCBuiltinSelTy)
 156
 157 // OpenCL image types.
 158 BUILTIN_TYPE(OCLImage1d, OCLImage1dTy)
 159 BUILTIN_TYPE(OCLImage1dArray, OCLImage1dArrayTy)
 160 BUILTIN_TYPE(OCLImage1dBuffer, OCLImage1dBufferTy)
 161 BUILTIN_TYPE(OCLImage2d, OCLImage2dTy)
 162 BUILTIN_TYPE(OCLImage2dArray, OCLImage2dArrayTy)
 163 BUILTIN_TYPE(OCLImage2dDepth, OCLImage2dDepthTy)
 164 BUILTIN_TYPE(OCLImage2dArrayDepth, OCLImage2dArrayDepthTy)
 165 BUILTIN_TYPE(OCLImage2dMSAA, OCLImage2dMSAATy)
 166 BUILTIN_TYPE(OCLImage2dArrayMSAA, OCLImage2dArrayMSAATy)
 167 BUILTIN_TYPE(OCLImage2dMSAADepth, OCLImage2dMSAADepthTy)
 168 BUILTIN_TYPE(OCLImage2dArrayMSAADepth, OCLImage2dArrayMSAADepthTy)
 169 BUILTIN_TYPE(OCLImage3d, OCLImage3dTy)
 170
 171 // OpenCL sampler_t.
 172 BUILTIN_TYPE(OCLSampler, OCLSamplerTy)
 173
 174 // OpenCL event_t.
 175 BUILTIN_TYPE(OCLEvent, OCLEventTy)
 176
 177 // OpenCL clk_event_t.
 178 BUILTIN_TYPE(OCLClkEvent, OCLClkEventTy)
 179
 180 // OpenCL queue_t.
 181 BUILTIN_TYPE(OCLQueue, OCLQueueTy)
 182
 183 // OpenCL ndrange_t.
 184 BUILTIN_TYPE(OCLNDRange, OCLNDRangeTy)
 185
 186 // OpenCL reserve_id_t.
 187 BUILTIN_TYPE(OCLReserveID, OCLReserveIDTy)
 188
 189 // This represents the type of an expression whose type is
 190 // totally unknown, e.g. 'T::foo'.  It is permitted for this to
 191 // appear in situations where the structure of the type is
 192 // theoretically deducible.
 193 BUILTIN_TYPE(Dependent, DependentTy)
 194
 195 // The type of an unresolved overload set.  A placeholder type.
 196 // Expressions with this type have one of the following basic
 197 // forms, with parentheses generally permitted:
 198 //   foo          # possibly qualified, not if an implicit access
 199 //   foo          # possibly qualified, not if an implicit access
 200 //   &foo         # possibly qualified, not if an implicit access
 201 //   x->foo       # only if might be a static member function
 202 //   &x->foo      # only if might be a static member function
 203 //   &Class::foo  # when a pointer-to-member; sub-expr also has this type
 204 // OverloadExpr::find can be used to analyze the expression.
 205 //
 206 // Overload should be the first placeholder type, or else change
 207 // BuiltinType::isNonOverloadPlaceholderType()
 208 PLACEHOLDER_TYPE(Overload, OverloadTy)
 209
 210 // The type of a bound C++ non-static member function.
 211 // A placeholder type.  Expressions with this type have one of the
 212 // following basic forms:
 213 //   foo          # if an implicit access
 214 //   x->foo       # if only contains non-static members
 215 PLACEHOLDER_TYPE(BoundMember, BoundMemberTy)
 216
 217 // The type of an expression which refers to a pseudo-object,
 218 // such as those introduced by Objective C's @property or
 219 // VS.NET's __property declarations.  A placeholder type.  The
 220 // pseudo-object is actually accessed by emitting a call to
 221 // some sort of function or method;  typically there is a pair
 222 // of a setter and a getter, with the setter used if the
 223 // pseudo-object reference is used syntactically as the
 224 // left-hand-side of an assignment operator.
 225 //
 226 // A pseudo-object reference naming an Objective-C @property is
 227 // always a dot access with a base of object-pointer type,
 228 // e.g. 'x.foo'.
 229 //
 230 // In VS.NET, a __property declaration creates an implicit
 231 // member with an associated name, which can then be named
 232 // in any of the normal ways an ordinary member could be.
 233 PLACEHOLDER_TYPE(PseudoObject, PseudoObjectTy)
 234
 235 // __builtin_any_type.  A placeholder type.  Useful for clients
 236 // like debuggers that don't know what type to give something.
 237 // Only a small number of operations are valid on expressions of
 238 // unknown type, most notably explicit casts.
 239 PLACEHOLDER_TYPE(UnknownAny, UnknownAnyTy)
 240
 241 PLACEHOLDER_TYPE(BuiltinFn, BuiltinFnTy)
 242
 243 // The type of a cast which, in ARC, would normally require a
 244 // __bridge, but which might be okay depending on the immediate
 245 // context.
 246 PLACEHOLDER_TYPE(ARCUnbridgedCast, ARCUnbridgedCastTy)
 247
 248 // A placeholder type for OpenMP array sections.
 249 PLACEHOLDER_TYPE(OMPArraySection, OMPArraySectionTy)
 250
 251 #ifdef LAST_BUILTIN_TYPE
 252 LAST_BUILTIN_TYPE(OMPArraySection)
 253 #undef LAST_BUILTIN_TYPE
 254 #endif
 255
 256 #undef SHARED_SINGLETON_TYPE
 257 #undef PLACEHOLDER_TYPE
 258 #undef FLOATING_TYPE
 259 #undef SIGNED_TYPE
 260 #undef UNSIGNED_TYPE
 261 #undef BUILTIN_TYPE