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

   1 //===-- BuiltinTypeNodes.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(OCLImage3d, OCLImage3dTy)
 164
 165 // OpenCL sampler_t.
 166 BUILTIN_TYPE(OCLSampler, OCLSamplerTy)
 167
 168 // OpenCL event_t.
 169 BUILTIN_TYPE(OCLEvent, OCLEventTy)
 170
 171 // This represents the type of an expression whose type is
 172 // totally unknown, e.g. 'T::foo'.  It is permitted for this to
 173 // appear in situations where the structure of the type is
 174 // theoretically deducible.
 175 BUILTIN_TYPE(Dependent, DependentTy)
 176
 177 // The type of an unresolved overload set.  A placeholder type.
 178 // Expressions with this type have one of the following basic
 179 // forms, with parentheses generally permitted:
 180 //   foo          # possibly qualified, not if an implicit access
 181 //   foo          # possibly qualified, not if an implicit access
 182 //   &foo         # possibly qualified, not if an implicit access
 183 //   x->foo       # only if might be a static member function
 184 //   &x->foo      # only if might be a static member function
 185 //   &Class::foo  # when a pointer-to-member; sub-expr also has this type
 186 // OverloadExpr::find can be used to analyze the expression.
 187 //
 188 // Overload should be the first placeholder type, or else change
 189 // BuiltinType::isNonOverloadPlaceholderType()
 190 PLACEHOLDER_TYPE(Overload, OverloadTy)
 191
 192 // The type of a bound C++ non-static member function.
 193 // A placeholder type.  Expressions with this type have one of the
 194 // following basic forms:
 195 //   foo          # if an implicit access
 196 //   x->foo       # if only contains non-static members
 197 PLACEHOLDER_TYPE(BoundMember, BoundMemberTy)
 198
 199 // The type of an expression which refers to a pseudo-object,
 200 // such as those introduced by Objective C's @property or
 201 // VS.NET's __property declarations.  A placeholder type.  The
 202 // pseudo-object is actually accessed by emitting a call to
 203 // some sort of function or method;  typically there is a pair
 204 // of a setter and a getter, with the setter used if the
 205 // pseudo-object reference is used syntactically as the
 206 // left-hand-side of an assignment operator.
 207 //
 208 // A pseudo-object reference naming an Objective-C @property is
 209 // always a dot access with a base of object-pointer type,
 210 // e.g. 'x.foo'.
 211 //
 212 // In VS.NET, a __property declaration creates an implicit
 213 // member with an associated name, which can then be named
 214 // in any of the normal ways an ordinary member could be.
 215 PLACEHOLDER_TYPE(PseudoObject, PseudoObjectTy)
 216
 217 // __builtin_any_type.  A placeholder type.  Useful for clients
 218 // like debuggers that don't know what type to give something.
 219 // Only a small number of operations are valid on expressions of
 220 // unknown type, most notably explicit casts.
 221 PLACEHOLDER_TYPE(UnknownAny, UnknownAnyTy)
 222
 223 PLACEHOLDER_TYPE(BuiltinFn, BuiltinFnTy)
 224
 225 // The type of a cast which, in ARC, would normally require a
 226 // __bridge, but which might be okay depending on the immediate
 227 // context.
 228 PLACEHOLDER_TYPE(ARCUnbridgedCast, ARCUnbridgedCastTy)
 229
 230 #ifdef LAST_BUILTIN_TYPE
 231 LAST_BUILTIN_TYPE(ARCUnbridgedCast)
 232 #undef LAST_BUILTIN_TYPE
 233 #endif
 234
 235 #undef SHARED_SINGLETON_TYPE
 236 #undef PLACEHOLDER_TYPE
 237 #undef FLOATING_TYPE
 238 #undef SIGNED_TYPE
 239 #undef UNSIGNED_TYPE
 240 #undef BUILTIN_TYPE