EIC code displayed by LXR master/​include/​clang/​AST/​BuiltinTypes.def	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

Warning, /include/clang/AST/BuiltinTypes.def is written in an unsupported language. File is not indexed.

 //===-- BuiltinTypes.def - Metadata about BuiltinTypes ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the database about various builtin singleton types.
 //
 //  BuiltinType::Id is the enumerator defining the type.
 //
 //  Context.SingletonId is the global singleton of this type.  Some global
 //  singletons are shared by multiple types.
 //
 //    BUILTIN_TYPE(Id, SingletonId) - A builtin type that has not been
 //    covered by any other #define.  Defining this macro covers all
 //    the builtins.
 //
 //    SIGNED_TYPE(Id, SingletonId) - A signed integral type.
 //
 //    UNSIGNED_TYPE(Id, SingletonId) - An unsigned integral type.
 //
 //    FLOATING_TYPE(Id, SingletonId) - A floating-point type.
 //
 //    PLACEHOLDER_TYPE(Id, SingletonId) - A placeholder type.  Placeholder
 //    types are used to perform context-sensitive checking of specific
 //    forms of expression.
 //
 //    SHARED_SINGLETON_TYPE(Expansion) - The given expansion corresponds
 //    to a builtin which uses a shared singleton type.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SIGNED_TYPE
 #define SIGNED_TYPE(Id, SingletonId) BUILTIN_TYPE(Id, SingletonId)
 #endif
 
 #ifndef UNSIGNED_TYPE
 #define UNSIGNED_TYPE(Id, SingletonId) BUILTIN_TYPE(Id, SingletonId)
 #endif
 
 #ifndef FLOATING_TYPE
 #define FLOATING_TYPE(Id, SingletonId) BUILTIN_TYPE(Id, SingletonId)
 #endif
 
 #ifndef PLACEHOLDER_TYPE
 #define PLACEHOLDER_TYPE(Id, SingletonId) BUILTIN_TYPE(Id, SingletonId)
 #endif
 
 #ifndef SHARED_SINGLETON_TYPE
 #define SHARED_SINGLETON_TYPE(Expansion) Expansion
 #endif
 
 //===- Builtin Types ------------------------------------------------------===//
 
 // void
 BUILTIN_TYPE(Void, VoidTy)
 
 //===- Unsigned Types -----------------------------------------------------===//
 
 // 'bool' in C++, '_Bool' in C99
 UNSIGNED_TYPE(Bool, BoolTy)
 
 // 'char' for targets where it's unsigned
 SHARED_SINGLETON_TYPE(UNSIGNED_TYPE(Char_U, CharTy))
 
 // 'unsigned char', explicitly qualified
 UNSIGNED_TYPE(UChar, UnsignedCharTy)
 
 // 'wchar_t' for targets where it's unsigned
 SHARED_SINGLETON_TYPE(UNSIGNED_TYPE(WChar_U, WCharTy))
 
 // 'char8_t' in C++20 (proposed)
 UNSIGNED_TYPE(Char8, Char8Ty)
 
 // 'char16_t' in C++
 UNSIGNED_TYPE(Char16, Char16Ty)
 
 // 'char32_t' in C++
 UNSIGNED_TYPE(Char32, Char32Ty)
 
 // 'unsigned short'
 UNSIGNED_TYPE(UShort, UnsignedShortTy)
 
 // 'unsigned int'
 UNSIGNED_TYPE(UInt, UnsignedIntTy)
 
 // 'unsigned long'
 UNSIGNED_TYPE(ULong, UnsignedLongTy)
 
 // 'unsigned long long'
 UNSIGNED_TYPE(ULongLong, UnsignedLongLongTy)
 
 // '__uint128_t'
 UNSIGNED_TYPE(UInt128, UnsignedInt128Ty)
 
 //===- Signed Types -------------------------------------------------------===//
 
 // 'char' for targets where it's signed
 SHARED_SINGLETON_TYPE(SIGNED_TYPE(Char_S, CharTy))
 
 // 'signed char', explicitly qualified
 SIGNED_TYPE(SChar, SignedCharTy)
 
 // 'wchar_t' for targets where it's signed
 SHARED_SINGLETON_TYPE(SIGNED_TYPE(WChar_S, WCharTy))
 
 // 'short' or 'signed short'
 SIGNED_TYPE(Short, ShortTy)
 
 // 'int' or 'signed int'
 SIGNED_TYPE(Int, IntTy)
 
 // 'long' or 'signed long'
 SIGNED_TYPE(Long, LongTy)
 
 // 'long long' or 'signed long long'
 SIGNED_TYPE(LongLong, LongLongTy)
 
 // '__int128_t'
 SIGNED_TYPE(Int128, Int128Ty)
 
 //===- Fixed point types --------------------------------------------------===//
 
 // 'short _Accum'
 SIGNED_TYPE(ShortAccum, ShortAccumTy)
 
 // '_Accum'
 SIGNED_TYPE(Accum, AccumTy)
 
 // 'long _Accum'
 SIGNED_TYPE(LongAccum, LongAccumTy)
 
 // 'unsigned short _Accum'
 UNSIGNED_TYPE(UShortAccum, UnsignedShortAccumTy)
 
 // 'unsigned _Accum'
 UNSIGNED_TYPE(UAccum, UnsignedAccumTy)
 
 // 'unsigned long _Accum'
 UNSIGNED_TYPE(ULongAccum, UnsignedLongAccumTy)
 
 // 'short _Fract'
 SIGNED_TYPE(ShortFract, ShortFractTy)
 
 // '_Fract'
 SIGNED_TYPE(Fract, FractTy)
 
 // 'long _Fract'
 SIGNED_TYPE(LongFract, LongFractTy)
 
 // 'unsigned short _Fract'
 UNSIGNED_TYPE(UShortFract, UnsignedShortFractTy)
 
 // 'unsigned _Fract'
 UNSIGNED_TYPE(UFract, UnsignedFractTy)
 
 // 'unsigned long _Fract'
 UNSIGNED_TYPE(ULongFract, UnsignedLongFractTy)
 
 // '_Sat short _Accum'
 SIGNED_TYPE(SatShortAccum, SatShortAccumTy)
 
 // '_Sat _Accum'
 SIGNED_TYPE(SatAccum, SatAccumTy)
 
 // '_Sat long _Accum'
 SIGNED_TYPE(SatLongAccum, SatLongAccumTy)
 
 // '_Sat unsigned short _Accum'
 UNSIGNED_TYPE(SatUShortAccum, SatUnsignedShortAccumTy)
 
 // '_Sat unsigned _Accum'
 UNSIGNED_TYPE(SatUAccum, SatUnsignedAccumTy)
 
 // '_Sat unsigned long _Accum'
 UNSIGNED_TYPE(SatULongAccum, SatUnsignedLongAccumTy)
 
 // '_Sat short _Fract'
 SIGNED_TYPE(SatShortFract, SatShortFractTy)
 
 // '_Sat _Fract'
 SIGNED_TYPE(SatFract, SatFractTy)
 
 // '_Sat long _Fract'
 SIGNED_TYPE(SatLongFract, SatLongFractTy)
 
 // '_Sat unsigned short _Fract'
 UNSIGNED_TYPE(SatUShortFract, SatUnsignedShortFractTy)
 
 // '_Sat unsigned _Fract'
 UNSIGNED_TYPE(SatUFract, SatUnsignedFractTy)
 
 // '_Sat unsigned long _Fract'
 UNSIGNED_TYPE(SatULongFract, SatUnsignedLongFractTy)
 
 //===- Floating point types -----------------------------------------------===//
 
 // 'half' in OpenCL, '__fp16' in ARM NEON.
 FLOATING_TYPE(Half, HalfTy)
 
 // 'float'
 FLOATING_TYPE(Float, FloatTy)
 
 // 'double'
 FLOATING_TYPE(Double, DoubleTy)
 
 // 'long double'
 FLOATING_TYPE(LongDouble, LongDoubleTy)
 
 // '_Float16'
 FLOATING_TYPE(Float16, HalfTy)
 
 // '__bf16'
 FLOATING_TYPE(BFloat16, BFloat16Ty)
 
 // '__float128'
 FLOATING_TYPE(Float128, Float128Ty)
 
 // '__ibm128'
 FLOATING_TYPE(Ibm128, Ibm128Ty)
 
 //===- Language-specific types --------------------------------------------===//
 
 // This is the type of C++0x 'nullptr'.
 BUILTIN_TYPE(NullPtr, NullPtrTy)
 
 // The primitive Objective C 'id' type.  The user-visible 'id'
 // type is a typedef of an ObjCObjectPointerType to an
 // ObjCObjectType with this as its base.  In fact, this only ever
 // shows up in an AST as the base type of an ObjCObjectType.
 BUILTIN_TYPE(ObjCId, ObjCBuiltinIdTy)
 
 // The primitive Objective C 'Class' type.  The user-visible
 // 'Class' type is a typedef of an ObjCObjectPointerType to an
 // ObjCObjectType with this as its base.  In fact, this only ever
 // shows up in an AST as the base type of an ObjCObjectType.
 BUILTIN_TYPE(ObjCClass, ObjCBuiltinClassTy)
 
 // The primitive Objective C 'SEL' type.  The user-visible 'SEL'
 // type is a typedef of a PointerType to this.
 BUILTIN_TYPE(ObjCSel, ObjCBuiltinSelTy)
 
 // OpenCL sampler_t.
 BUILTIN_TYPE(OCLSampler, OCLSamplerTy)
 
 // OpenCL event_t.
 BUILTIN_TYPE(OCLEvent, OCLEventTy)
 
 // OpenCL clk_event_t.
 BUILTIN_TYPE(OCLClkEvent, OCLClkEventTy)
 
 // OpenCL queue_t.
 BUILTIN_TYPE(OCLQueue, OCLQueueTy)
 
 // OpenCL reserve_id_t.
 BUILTIN_TYPE(OCLReserveID, OCLReserveIDTy)
 
 // This represents the type of an expression whose type is
 // totally unknown, e.g. 'T::foo'.  It is permitted for this to
 // appear in situations where the structure of the type is
 // theoretically deducible.
 BUILTIN_TYPE(Dependent, DependentTy)
 
 // The type of an unresolved overload set.  A placeholder type.
 // Expressions with this type have one of the following basic
 // forms, with parentheses generally permitted:
 //   foo          # possibly qualified, not if an implicit access
 //   foo          # possibly qualified, not if an implicit access
 //   &foo         # possibly qualified, not if an implicit access
 //   x->foo       # only if might be a static member function
 //   &x->foo      # only if might be a static member function
 //   &Class::foo  # when a pointer-to-member; sub-expr also has this type
 // OverloadExpr::find can be used to analyze the expression.
 //
 // Overload should be the first placeholder type, or else change
 // BuiltinType::isNonOverloadPlaceholderType()
 PLACEHOLDER_TYPE(Overload, OverloadTy)
 
 // The type of a bound C++ non-static member function.
 // A placeholder type.  Expressions with this type have one of the
 // following basic forms:
 //   foo          # if an implicit access
 //   x->foo       # if only contains non-static members
 PLACEHOLDER_TYPE(BoundMember, BoundMemberTy)
 
 // The type of an unresolved template. Used in UnresolvedLookupExpr.
 PLACEHOLDER_TYPE(UnresolvedTemplate, UnresolvedTemplateTy)
 
 // The type of an expression which refers to a pseudo-object,
 // such as those introduced by Objective C's @property or
 // VS.NET's __property declarations.  A placeholder type.  The
 // pseudo-object is actually accessed by emitting a call to
 // some sort of function or method;  typically there is a pair
 // of a setter and a getter, with the setter used if the
 // pseudo-object reference is used syntactically as the
 // left-hand-side of an assignment operator.
 //
 // A pseudo-object reference naming an Objective-C @property is
 // always a dot access with a base of object-pointer type,
 // e.g. 'x.foo'.
 //
 // In VS.NET, a __property declaration creates an implicit
 // member with an associated name, which can then be named
 // in any of the normal ways an ordinary member could be.
 PLACEHOLDER_TYPE(PseudoObject, PseudoObjectTy)
 
 // __builtin_any_type.  A placeholder type.  Useful for clients
 // like debuggers that don't know what type to give something.
 // Only a small number of operations are valid on expressions of
 // unknown type, most notably explicit casts.
 PLACEHOLDER_TYPE(UnknownAny, UnknownAnyTy)
 
 PLACEHOLDER_TYPE(BuiltinFn, BuiltinFnTy)
 
 // The type of a cast which, in ARC, would normally require a
 // __bridge, but which might be okay depending on the immediate
 // context.
 PLACEHOLDER_TYPE(ARCUnbridgedCast, ARCUnbridgedCastTy)
 
 // A placeholder type for incomplete matrix index expressions.
 PLACEHOLDER_TYPE(IncompleteMatrixIdx, IncompleteMatrixIdxTy)
 
 // A placeholder type for OpenMP array sections.
 PLACEHOLDER_TYPE(ArraySection, ArraySectionTy)
 
 // A placeholder type for OpenMP array shaping operation.
 PLACEHOLDER_TYPE(OMPArrayShaping, OMPArrayShapingTy)
 
 // A placeholder type for OpenMP iterators.
 PLACEHOLDER_TYPE(OMPIterator, OMPIteratorTy)
 
 #ifdef LAST_BUILTIN_TYPE
 LAST_BUILTIN_TYPE(OMPIterator)
 #undef LAST_BUILTIN_TYPE
 #endif
 
 #undef SHARED_SINGLETON_TYPE
 #undef PLACEHOLDER_TYPE
 #undef FLOATING_TYPE
 #undef SIGNED_TYPE
 #undef UNSIGNED_TYPE
 #undef BUILTIN_TYPE

This page was automatically generated by the 2.3.7 LXR engine. The LXR team