Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- llvm/Type.h - Classes for handling data types ------------*- 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. // This file contains the declaration of the Type class.  For more "Type"
  10. // stuff, look in DerivedTypes.h.
  11. //
  12. //===----------------------------------------------------------------------===//
  13.  
  14. #ifndef LLVM_IR_TYPE_H
  15. #define LLVM_IR_TYPE_H
  16.  
  17. #include "llvm/ADT/ArrayRef.h"
  18. #include "llvm/Support/CBindingWrapping.h"
  19. #include "llvm/Support/Casting.h"
  20. #include "llvm/Support/Compiler.h"
  21. #include "llvm/Support/ErrorHandling.h"
  22. #include "llvm/Support/TypeSize.h"
  23. #include <cassert>
  24. #include <cstdint>
  25. #include <iterator>
  26.  
  27. namespace llvm {
  28.  
  29. class IntegerType;
  30. struct fltSemantics;
  31. class LLVMContext;
  32. class PointerType;
  33. class raw_ostream;
  34. class StringRef;
  35. template <typename PtrType> class SmallPtrSetImpl;
  36.  
  37. /// The instances of the Type class are immutable: once they are created,
  38. /// they are never changed.  Also note that only one instance of a particular
  39. /// type is ever created.  Thus seeing if two types are equal is a matter of
  40. /// doing a trivial pointer comparison. To enforce that no two equal instances
  41. /// are created, Type instances can only be created via static factory methods
  42. /// in class Type and in derived classes.  Once allocated, Types are never
  43. /// free'd.
  44. ///
  45. class Type {
  46. public:
  47.   //===--------------------------------------------------------------------===//
  48.   /// Definitions of all of the base types for the Type system.  Based on this
  49.   /// value, you can cast to a class defined in DerivedTypes.h.
  50.   /// Note: If you add an element to this, you need to add an element to the
  51.   /// Type::getPrimitiveType function, or else things will break!
  52.   /// Also update LLVMTypeKind and LLVMGetTypeKind () in the C binding.
  53.   ///
  54.   enum TypeID {
  55.     // PrimitiveTypes
  56.     HalfTyID = 0,  ///< 16-bit floating point type
  57.     BFloatTyID,    ///< 16-bit floating point type (7-bit significand)
  58.     FloatTyID,     ///< 32-bit floating point type
  59.     DoubleTyID,    ///< 64-bit floating point type
  60.     X86_FP80TyID,  ///< 80-bit floating point type (X87)
  61.     FP128TyID,     ///< 128-bit floating point type (112-bit significand)
  62.     PPC_FP128TyID, ///< 128-bit floating point type (two 64-bits, PowerPC)
  63.     VoidTyID,      ///< type with no size
  64.     LabelTyID,     ///< Labels
  65.     MetadataTyID,  ///< Metadata
  66.     X86_MMXTyID,   ///< MMX vectors (64 bits, X86 specific)
  67.     X86_AMXTyID,   ///< AMX vectors (8192 bits, X86 specific)
  68.     TokenTyID,     ///< Tokens
  69.  
  70.     // Derived types... see DerivedTypes.h file.
  71.     IntegerTyID,        ///< Arbitrary bit width integers
  72.     FunctionTyID,       ///< Functions
  73.     PointerTyID,        ///< Pointers
  74.     StructTyID,         ///< Structures
  75.     ArrayTyID,          ///< Arrays
  76.     FixedVectorTyID,    ///< Fixed width SIMD vector type
  77.     ScalableVectorTyID, ///< Scalable SIMD vector type
  78.     TypedPointerTyID,   ///< Typed pointer used by some GPU targets
  79.     TargetExtTyID,      ///< Target extension type
  80.   };
  81.  
  82. private:
  83.   /// This refers to the LLVMContext in which this type was uniqued.
  84.   LLVMContext &Context;
  85.  
  86.   TypeID   ID : 8;            // The current base type of this type.
  87.   unsigned SubclassData : 24; // Space for subclasses to store data.
  88.                               // Note that this should be synchronized with
  89.                               // MAX_INT_BITS value in IntegerType class.
  90.  
  91. protected:
  92.   friend class LLVMContextImpl;
  93.  
  94.   explicit Type(LLVMContext &C, TypeID tid)
  95.     : Context(C), ID(tid), SubclassData(0) {}
  96.   ~Type() = default;
  97.  
  98.   unsigned getSubclassData() const { return SubclassData; }
  99.  
  100.   void setSubclassData(unsigned val) {
  101.     SubclassData = val;
  102.     // Ensure we don't have any accidental truncation.
  103.     assert(getSubclassData() == val && "Subclass data too large for field");
  104.   }
  105.  
  106.   /// Keeps track of how many Type*'s there are in the ContainedTys list.
  107.   unsigned NumContainedTys = 0;
  108.  
  109.   /// A pointer to the array of Types contained by this Type. For example, this
  110.   /// includes the arguments of a function type, the elements of a structure,
  111.   /// the pointee of a pointer, the element type of an array, etc. This pointer
  112.   /// may be 0 for types that don't contain other types (Integer, Double,
  113.   /// Float).
  114.   Type * const *ContainedTys = nullptr;
  115.  
  116. public:
  117.   /// Print the current type.
  118.   /// Omit the type details if \p NoDetails == true.
  119.   /// E.g., let %st = type { i32, i16 }
  120.   /// When \p NoDetails is true, we only print %st.
  121.   /// Put differently, \p NoDetails prints the type as if
  122.   /// inlined with the operands when printing an instruction.
  123.   void print(raw_ostream &O, bool IsForDebug = false,
  124.              bool NoDetails = false) const;
  125.  
  126.   void dump() const;
  127.  
  128.   /// Return the LLVMContext in which this type was uniqued.
  129.   LLVMContext &getContext() const { return Context; }
  130.  
  131.   //===--------------------------------------------------------------------===//
  132.   // Accessors for working with types.
  133.   //
  134.  
  135.   /// Return the type id for the type. This will return one of the TypeID enum
  136.   /// elements defined above.
  137.   TypeID getTypeID() const { return ID; }
  138.  
  139.   /// Return true if this is 'void'.
  140.   bool isVoidTy() const { return getTypeID() == VoidTyID; }
  141.  
  142.   /// Return true if this is 'half', a 16-bit IEEE fp type.
  143.   bool isHalfTy() const { return getTypeID() == HalfTyID; }
  144.  
  145.   /// Return true if this is 'bfloat', a 16-bit bfloat type.
  146.   bool isBFloatTy() const { return getTypeID() == BFloatTyID; }
  147.  
  148.   /// Return true if this is a 16-bit float type.
  149.   bool is16bitFPTy() const {
  150.     return getTypeID() == BFloatTyID || getTypeID() == HalfTyID;
  151.   }
  152.  
  153.   /// Return true if this is 'float', a 32-bit IEEE fp type.
  154.   bool isFloatTy() const { return getTypeID() == FloatTyID; }
  155.  
  156.   /// Return true if this is 'double', a 64-bit IEEE fp type.
  157.   bool isDoubleTy() const { return getTypeID() == DoubleTyID; }
  158.  
  159.   /// Return true if this is x86 long double.
  160.   bool isX86_FP80Ty() const { return getTypeID() == X86_FP80TyID; }
  161.  
  162.   /// Return true if this is 'fp128'.
  163.   bool isFP128Ty() const { return getTypeID() == FP128TyID; }
  164.  
  165.   /// Return true if this is powerpc long double.
  166.   bool isPPC_FP128Ty() const { return getTypeID() == PPC_FP128TyID; }
  167.  
  168.   /// Return true if this is a well-behaved IEEE-like type, which has a IEEE
  169.   /// compatible layout as defined by isIEEE(), and does not have unnormal
  170.   /// values
  171.   bool isIEEELikeFPTy() const {
  172.     switch (getTypeID()) {
  173.     case DoubleTyID:
  174.     case FloatTyID:
  175.     case HalfTyID:
  176.     case BFloatTyID:
  177.     case FP128TyID:
  178.       return true;
  179.     default:
  180.       return false;
  181.     }
  182.   }
  183.  
  184.   /// Return true if this is one of the floating-point types
  185.   bool isFloatingPointTy() const {
  186.     return isIEEELikeFPTy() || getTypeID() == X86_FP80TyID ||
  187.            getTypeID() == PPC_FP128TyID;
  188.   }
  189.  
  190.   /// Returns true if this is a floating-point type that is an unevaluated sum
  191.   /// of multiple floating-point units.
  192.   /// An example of such a type is ppc_fp128, also known as double-double, which
  193.   /// consists of two IEEE 754 doubles.
  194.   bool isMultiUnitFPType() const {
  195.     return getTypeID() == PPC_FP128TyID;
  196.   }
  197.  
  198.   const fltSemantics &getFltSemantics() const;
  199.  
  200.   /// Return true if this is X86 MMX.
  201.   bool isX86_MMXTy() const { return getTypeID() == X86_MMXTyID; }
  202.  
  203.   /// Return true if this is X86 AMX.
  204.   bool isX86_AMXTy() const { return getTypeID() == X86_AMXTyID; }
  205.  
  206.   /// Return true if this is a target extension type.
  207.   bool isTargetExtTy() const { return getTypeID() == TargetExtTyID; }
  208.  
  209.   /// Return true if this is a FP type or a vector of FP.
  210.   bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); }
  211.  
  212.   /// Return true if this is 'label'.
  213.   bool isLabelTy() const { return getTypeID() == LabelTyID; }
  214.  
  215.   /// Return true if this is 'metadata'.
  216.   bool isMetadataTy() const { return getTypeID() == MetadataTyID; }
  217.  
  218.   /// Return true if this is 'token'.
  219.   bool isTokenTy() const { return getTypeID() == TokenTyID; }
  220.  
  221.   /// True if this is an instance of IntegerType.
  222.   bool isIntegerTy() const { return getTypeID() == IntegerTyID; }
  223.  
  224.   /// Return true if this is an IntegerType of the given width.
  225.   bool isIntegerTy(unsigned Bitwidth) const;
  226.  
  227.   /// Return true if this is an integer type or a vector of integer types.
  228.   bool isIntOrIntVectorTy() const { return getScalarType()->isIntegerTy(); }
  229.  
  230.   /// Return true if this is an integer type or a vector of integer types of
  231.   /// the given width.
  232.   bool isIntOrIntVectorTy(unsigned BitWidth) const {
  233.     return getScalarType()->isIntegerTy(BitWidth);
  234.   }
  235.  
  236.   /// Return true if this is an integer type or a pointer type.
  237.   bool isIntOrPtrTy() const { return isIntegerTy() || isPointerTy(); }
  238.  
  239.   /// True if this is an instance of FunctionType.
  240.   bool isFunctionTy() const { return getTypeID() == FunctionTyID; }
  241.  
  242.   /// True if this is an instance of StructType.
  243.   bool isStructTy() const { return getTypeID() == StructTyID; }
  244.  
  245.   /// True if this is an instance of ArrayType.
  246.   bool isArrayTy() const { return getTypeID() == ArrayTyID; }
  247.  
  248.   /// True if this is an instance of PointerType.
  249.   bool isPointerTy() const { return getTypeID() == PointerTyID; }
  250.  
  251.   /// True if this is an instance of an opaque PointerType.
  252.   bool isOpaquePointerTy() const;
  253.  
  254.   /// Return true if this is a pointer type or a vector of pointer types.
  255.   bool isPtrOrPtrVectorTy() const { return getScalarType()->isPointerTy(); }
  256.  
  257.   /// True if this is an instance of VectorType.
  258.   inline bool isVectorTy() const {
  259.     return getTypeID() == ScalableVectorTyID || getTypeID() == FixedVectorTyID;
  260.   }
  261.  
  262.   /// Return true if this type could be converted with a lossless BitCast to
  263.   /// type 'Ty'. For example, i8* to i32*. BitCasts are valid for types of the
  264.   /// same size only where no re-interpretation of the bits is done.
  265.   /// Determine if this type could be losslessly bitcast to Ty
  266.   bool canLosslesslyBitCastTo(Type *Ty) const;
  267.  
  268.   /// Return true if this type is empty, that is, it has no elements or all of
  269.   /// its elements are empty.
  270.   bool isEmptyTy() const;
  271.  
  272.   /// Return true if the type is "first class", meaning it is a valid type for a
  273.   /// Value.
  274.   bool isFirstClassType() const {
  275.     return getTypeID() != FunctionTyID && getTypeID() != VoidTyID;
  276.   }
  277.  
  278.   /// Return true if the type is a valid type for a register in codegen. This
  279.   /// includes all first-class types except struct and array types.
  280.   bool isSingleValueType() const {
  281.     return isFloatingPointTy() || isX86_MMXTy() || isIntegerTy() ||
  282.            isPointerTy() || isVectorTy() || isX86_AMXTy() || isTargetExtTy();
  283.   }
  284.  
  285.   /// Return true if the type is an aggregate type. This means it is valid as
  286.   /// the first operand of an insertvalue or extractvalue instruction. This
  287.   /// includes struct and array types, but does not include vector types.
  288.   bool isAggregateType() const {
  289.     return getTypeID() == StructTyID || getTypeID() == ArrayTyID;
  290.   }
  291.  
  292.   /// Return true if it makes sense to take the size of this type. To get the
  293.   /// actual size for a particular target, it is reasonable to use the
  294.   /// DataLayout subsystem to do this.
  295.   bool isSized(SmallPtrSetImpl<Type*> *Visited = nullptr) const {
  296.     // If it's a primitive, it is always sized.
  297.     if (getTypeID() == IntegerTyID || isFloatingPointTy() ||
  298.         getTypeID() == PointerTyID || getTypeID() == X86_MMXTyID ||
  299.         getTypeID() == X86_AMXTyID)
  300.       return true;
  301.     // If it is not something that can have a size (e.g. a function or label),
  302.     // it doesn't have a size.
  303.     if (getTypeID() != StructTyID && getTypeID() != ArrayTyID &&
  304.         !isVectorTy() && getTypeID() != TargetExtTyID)
  305.       return false;
  306.     // Otherwise we have to try harder to decide.
  307.     return isSizedDerivedType(Visited);
  308.   }
  309.  
  310.   /// Return the basic size of this type if it is a primitive type. These are
  311.   /// fixed by LLVM and are not target-dependent.
  312.   /// This will return zero if the type does not have a size or is not a
  313.   /// primitive type.
  314.   ///
  315.   /// If this is a scalable vector type, the scalable property will be set and
  316.   /// the runtime size will be a positive integer multiple of the base size.
  317.   ///
  318.   /// Note that this may not reflect the size of memory allocated for an
  319.   /// instance of the type or the number of bytes that are written when an
  320.   /// instance of the type is stored to memory. The DataLayout class provides
  321.   /// additional query functions to provide this information.
  322.   ///
  323.   TypeSize getPrimitiveSizeInBits() const LLVM_READONLY;
  324.  
  325.   /// If this is a vector type, return the getPrimitiveSizeInBits value for the
  326.   /// element type. Otherwise return the getPrimitiveSizeInBits value for this
  327.   /// type.
  328.   unsigned getScalarSizeInBits() const LLVM_READONLY;
  329.  
  330.   /// Return the width of the mantissa of this type. This is only valid on
  331.   /// floating-point types. If the FP type does not have a stable mantissa (e.g.
  332.   /// ppc long double), this method returns -1.
  333.   int getFPMantissaWidth() const;
  334.  
  335.   /// Return whether the type is IEEE compatible, as defined by the eponymous
  336.   /// method in APFloat.
  337.   bool isIEEE() const;
  338.  
  339.   /// If this is a vector type, return the element type, otherwise return
  340.   /// 'this'.
  341.   inline Type *getScalarType() const {
  342.     if (isVectorTy())
  343.       return getContainedType(0);
  344.     return const_cast<Type *>(this);
  345.   }
  346.  
  347.   //===--------------------------------------------------------------------===//
  348.   // Type Iteration support.
  349.   //
  350.   using subtype_iterator = Type * const *;
  351.  
  352.   subtype_iterator subtype_begin() const { return ContainedTys; }
  353.   subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
  354.   ArrayRef<Type*> subtypes() const {
  355.     return ArrayRef(subtype_begin(), subtype_end());
  356.   }
  357.  
  358.   using subtype_reverse_iterator = std::reverse_iterator<subtype_iterator>;
  359.  
  360.   subtype_reverse_iterator subtype_rbegin() const {
  361.     return subtype_reverse_iterator(subtype_end());
  362.   }
  363.   subtype_reverse_iterator subtype_rend() const {
  364.     return subtype_reverse_iterator(subtype_begin());
  365.   }
  366.  
  367.   /// This method is used to implement the type iterator (defined at the end of
  368.   /// the file). For derived types, this returns the types 'contained' in the
  369.   /// derived type.
  370.   Type *getContainedType(unsigned i) const {
  371.     assert(i < NumContainedTys && "Index out of range!");
  372.     return ContainedTys[i];
  373.   }
  374.  
  375.   /// Return the number of types in the derived type.
  376.   unsigned getNumContainedTypes() const { return NumContainedTys; }
  377.  
  378.   //===--------------------------------------------------------------------===//
  379.   // Helper methods corresponding to subclass methods.  This forces a cast to
  380.   // the specified subclass and calls its accessor.  "getArrayNumElements" (for
  381.   // example) is shorthand for cast<ArrayType>(Ty)->getNumElements().  This is
  382.   // only intended to cover the core methods that are frequently used, helper
  383.   // methods should not be added here.
  384.  
  385.   inline unsigned getIntegerBitWidth() const;
  386.  
  387.   inline Type *getFunctionParamType(unsigned i) const;
  388.   inline unsigned getFunctionNumParams() const;
  389.   inline bool isFunctionVarArg() const;
  390.  
  391.   inline StringRef getStructName() const;
  392.   inline unsigned getStructNumElements() const;
  393.   inline Type *getStructElementType(unsigned N) const;
  394.  
  395.   inline uint64_t getArrayNumElements() const;
  396.  
  397.   Type *getArrayElementType() const {
  398.     assert(getTypeID() == ArrayTyID);
  399.     return ContainedTys[0];
  400.   }
  401.  
  402.   inline StringRef getTargetExtName() const;
  403.  
  404.   /// This method is deprecated without replacement. Pointer element types are
  405.   /// not available with opaque pointers.
  406.   [[deprecated("Deprecated without replacement, see "
  407.                "https://llvm.org/docs/OpaquePointers.html for context and "
  408.                "migration instructions")]]
  409.   Type *getPointerElementType() const {
  410.     return getNonOpaquePointerElementType();
  411.   }
  412.  
  413.   /// Only use this method in code that is not reachable with opaque pointers,
  414.   /// or part of deprecated methods that will be removed as part of the opaque
  415.   /// pointers transition.
  416.   Type *getNonOpaquePointerElementType() const {
  417.     assert(getTypeID() == PointerTyID);
  418.     assert(NumContainedTys &&
  419.            "Attempting to get element type of opaque pointer");
  420.     return ContainedTys[0];
  421.   }
  422.  
  423.   /// Given vector type, change the element type,
  424.   /// whilst keeping the old number of elements.
  425.   /// For non-vectors simply returns \p EltTy.
  426.   inline Type *getWithNewType(Type *EltTy) const;
  427.  
  428.   /// Given an integer or vector type, change the lane bitwidth to NewBitwidth,
  429.   /// whilst keeping the old number of lanes.
  430.   inline Type *getWithNewBitWidth(unsigned NewBitWidth) const;
  431.  
  432.   /// Given scalar/vector integer type, returns a type with elements twice as
  433.   /// wide as in the original type. For vectors, preserves element count.
  434.   inline Type *getExtendedType() const;
  435.  
  436.   /// Get the address space of this pointer or pointer vector type.
  437.   inline unsigned getPointerAddressSpace() const;
  438.  
  439.   //===--------------------------------------------------------------------===//
  440.   // Static members exported by the Type class itself.  Useful for getting
  441.   // instances of Type.
  442.   //
  443.  
  444.   /// Return a type based on an identifier.
  445.   static Type *getPrimitiveType(LLVMContext &C, TypeID IDNumber);
  446.  
  447.   //===--------------------------------------------------------------------===//
  448.   // These are the builtin types that are always available.
  449.   //
  450.   static Type *getVoidTy(LLVMContext &C);
  451.   static Type *getLabelTy(LLVMContext &C);
  452.   static Type *getHalfTy(LLVMContext &C);
  453.   static Type *getBFloatTy(LLVMContext &C);
  454.   static Type *getFloatTy(LLVMContext &C);
  455.   static Type *getDoubleTy(LLVMContext &C);
  456.   static Type *getMetadataTy(LLVMContext &C);
  457.   static Type *getX86_FP80Ty(LLVMContext &C);
  458.   static Type *getFP128Ty(LLVMContext &C);
  459.   static Type *getPPC_FP128Ty(LLVMContext &C);
  460.   static Type *getX86_MMXTy(LLVMContext &C);
  461.   static Type *getX86_AMXTy(LLVMContext &C);
  462.   static Type *getTokenTy(LLVMContext &C);
  463.   static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
  464.   static IntegerType *getInt1Ty(LLVMContext &C);
  465.   static IntegerType *getInt8Ty(LLVMContext &C);
  466.   static IntegerType *getInt16Ty(LLVMContext &C);
  467.   static IntegerType *getInt32Ty(LLVMContext &C);
  468.   static IntegerType *getInt64Ty(LLVMContext &C);
  469.   static IntegerType *getInt128Ty(LLVMContext &C);
  470.   template <typename ScalarTy> static Type *getScalarTy(LLVMContext &C) {
  471.     int noOfBits = sizeof(ScalarTy) * CHAR_BIT;
  472.     if (std::is_integral<ScalarTy>::value) {
  473.       return (Type*) Type::getIntNTy(C, noOfBits);
  474.     } else if (std::is_floating_point<ScalarTy>::value) {
  475.       switch (noOfBits) {
  476.       case 32:
  477.         return Type::getFloatTy(C);
  478.       case 64:
  479.         return Type::getDoubleTy(C);
  480.       }
  481.     }
  482.     llvm_unreachable("Unsupported type in Type::getScalarTy");
  483.   }
  484.   static Type *getFloatingPointTy(LLVMContext &C, const fltSemantics &S);
  485.  
  486.   //===--------------------------------------------------------------------===//
  487.   // Convenience methods for getting pointer types with one of the above builtin
  488.   // types as pointee.
  489.   //
  490.   static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0);
  491.   static PointerType *getBFloatPtrTy(LLVMContext &C, unsigned AS = 0);
  492.   static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0);
  493.   static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0);
  494.   static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0);
  495.   static PointerType *getFP128PtrTy(LLVMContext &C, unsigned AS = 0);
  496.   static PointerType *getPPC_FP128PtrTy(LLVMContext &C, unsigned AS = 0);
  497.   static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0);
  498.   static PointerType *getX86_AMXPtrTy(LLVMContext &C, unsigned AS = 0);
  499.   static PointerType *getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS = 0);
  500.   static PointerType *getInt1PtrTy(LLVMContext &C, unsigned AS = 0);
  501.   static PointerType *getInt8PtrTy(LLVMContext &C, unsigned AS = 0);
  502.   static PointerType *getInt16PtrTy(LLVMContext &C, unsigned AS = 0);
  503.   static PointerType *getInt32PtrTy(LLVMContext &C, unsigned AS = 0);
  504.   static PointerType *getInt64PtrTy(LLVMContext &C, unsigned AS = 0);
  505.  
  506.   /// Return a pointer to the current type. This is equivalent to
  507.   /// PointerType::get(Foo, AddrSpace).
  508.   /// TODO: Remove this after opaque pointer transition is complete.
  509.   PointerType *getPointerTo(unsigned AddrSpace = 0) const;
  510.  
  511. private:
  512.   /// Derived types like structures and arrays are sized iff all of the members
  513.   /// of the type are sized as well. Since asking for their size is relatively
  514.   /// uncommon, move this operation out-of-line.
  515.   bool isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited = nullptr) const;
  516. };
  517.  
  518. // Printing of types.
  519. inline raw_ostream &operator<<(raw_ostream &OS, const Type &T) {
  520.   T.print(OS);
  521.   return OS;
  522. }
  523.  
  524. // allow isa<PointerType>(x) to work without DerivedTypes.h included.
  525. template <> struct isa_impl<PointerType, Type> {
  526.   static inline bool doit(const Type &Ty) {
  527.     return Ty.getTypeID() == Type::PointerTyID;
  528.   }
  529. };
  530.  
  531. // Create wrappers for C Binding types (see CBindingWrapping.h).
  532. DEFINE_ISA_CONVERSION_FUNCTIONS(Type, LLVMTypeRef)
  533.  
  534. /* Specialized opaque type conversions.
  535.  */
  536. inline Type **unwrap(LLVMTypeRef* Tys) {
  537.   return reinterpret_cast<Type**>(Tys);
  538. }
  539.  
  540. inline LLVMTypeRef *wrap(Type **Tys) {
  541.   return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
  542. }
  543.  
  544. } // end namespace llvm
  545.  
  546. #endif // LLVM_IR_TYPE_H
  547.