llvm/lib/SandboxIR/Type.cpp

   1 //===- Type.cpp - Sandbox IR Type -----------------------------------------===//
   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 #include "llvm/SandboxIR/Type.h"
  10 #include "llvm/SandboxIR/Context.h"
  11
  12 using namespace llvm::sandboxir;
  13
  14 Type *Type::getScalarType() const {
  15   return Ctx.getType(LLVMTy->getScalarType());
  16 }
  17
  18 Type *Type::getInt64Ty(Context &Ctx) {
  19   return Ctx.getType(llvm::Type::getInt64Ty(Ctx.LLVMCtx));
  20 }
  21 Type *Type::getInt32Ty(Context &Ctx) {
  22   return Ctx.getType(llvm::Type::getInt32Ty(Ctx.LLVMCtx));
  23 }
  24 Type *Type::getInt16Ty(Context &Ctx) {
  25   return Ctx.getType(llvm::Type::getInt16Ty(Ctx.LLVMCtx));
  26 }
  27 Type *Type::getInt8Ty(Context &Ctx) {
  28   return Ctx.getType(llvm::Type::getInt8Ty(Ctx.LLVMCtx));
  29 }
  30 Type *Type::getInt1Ty(Context &Ctx) {
  31   return Ctx.getType(llvm::Type::getInt1Ty(Ctx.LLVMCtx));
  32 }
  33 Type *Type::getDoubleTy(Context &Ctx) {
  34   return Ctx.getType(llvm::Type::getDoubleTy(Ctx.LLVMCtx));
  35 }
  36 Type *Type::getFloatTy(Context &Ctx) {
  37   return Ctx.getType(llvm::Type::getFloatTy(Ctx.LLVMCtx));
  38 }
  39
  40 #ifndef NDEBUG
  41 void Type::dumpOS(raw_ostream &OS) { LLVMTy->print(OS); }
  42 void Type::dump() {
  43   dumpOS(dbgs());
  44   dbgs() << "\n";
  45 }
  46 #endif
  47
  48 PointerType *PointerType::get(Type *ElementType, unsigned AddressSpace) {
  49   return cast<PointerType>(ElementType->getContext().getType(
  50       llvm::PointerType::get(ElementType->LLVMTy, AddressSpace)));
  51 }
  52
  53 PointerType *PointerType::get(Context &Ctx, unsigned AddressSpace) {
  54   return cast<PointerType>(
  55       Ctx.getType(llvm::PointerType::get(Ctx.LLVMCtx, AddressSpace)));
  56 }
  57
  58 ArrayType *ArrayType::get(Type *ElementType, uint64_t NumElements) {
  59   return cast<ArrayType>(ElementType->getContext().getType(
  60       llvm::ArrayType::get(ElementType->LLVMTy, NumElements)));
  61 }
  62
  63 StructType *StructType::get(Context &Ctx, ArrayRef<Type *> Elements,
  64                             bool IsPacked) {
  65   SmallVector<llvm::Type *> LLVMElements;
  66   LLVMElements.reserve(Elements.size());
  67   for (Type *Elm : Elements)
  68     LLVMElements.push_back(Elm->LLVMTy);
  69   return cast<StructType>(
  70       Ctx.getType(llvm::StructType::get(Ctx.LLVMCtx, LLVMElements, IsPacked)));
  71 }
  72
  73 VectorType *VectorType::get(Type *ElementType, ElementCount EC) {
  74   return cast<VectorType>(ElementType->getContext().getType(
  75       llvm::VectorType::get(ElementType->LLVMTy, EC)));
  76 }
  77
  78 Type *VectorType::getElementType() const {
  79   return Ctx.getType(cast<llvm::VectorType>(LLVMTy)->getElementType());
  80 }
  81 VectorType *VectorType::getInteger(VectorType *VTy) {
  82   return cast<VectorType>(VTy->getContext().getType(
  83       llvm::VectorType::getInteger(cast<llvm::VectorType>(VTy->LLVMTy))));
  84 }
  85 VectorType *VectorType::getExtendedElementVectorType(VectorType *VTy) {
  86   return cast<VectorType>(
  87       VTy->getContext().getType(llvm::VectorType::getExtendedElementVectorType(
  88           cast<llvm::VectorType>(VTy->LLVMTy))));
  89 }
  90 VectorType *VectorType::getTruncatedElementVectorType(VectorType *VTy) {
  91   return cast<VectorType>(
  92       VTy->getContext().getType(llvm::VectorType::getTruncatedElementVectorType(
  93           cast<llvm::VectorType>(VTy->LLVMTy))));
  94 }
  95 VectorType *VectorType::getSubdividedVectorType(VectorType *VTy,
  96                                                 int NumSubdivs) {
  97   return cast<VectorType>(
  98       VTy->getContext().getType(llvm::VectorType::getSubdividedVectorType(
  99           cast<llvm::VectorType>(VTy->LLVMTy), NumSubdivs)));
 100 }
 101 VectorType *VectorType::getHalfElementsVectorType(VectorType *VTy) {
 102   return cast<VectorType>(
 103       VTy->getContext().getType(llvm::VectorType::getHalfElementsVectorType(
 104           cast<llvm::VectorType>(VTy->LLVMTy))));
 105 }
 106 VectorType *VectorType::getDoubleElementsVectorType(VectorType *VTy) {
 107   return cast<VectorType>(
 108       VTy->getContext().getType(llvm::VectorType::getDoubleElementsVectorType(
 109           cast<llvm::VectorType>(VTy->LLVMTy))));
 110 }
 111 bool VectorType::isValidElementType(Type *ElemTy) {
 112   return llvm::VectorType::isValidElementType(ElemTy->LLVMTy);
 113 }
 114
 115 FixedVectorType *FixedVectorType::get(Type *ElementType, unsigned NumElts) {
 116   return cast<FixedVectorType>(ElementType->getContext().getType(
 117       llvm::FixedVectorType::get(ElementType->LLVMTy, NumElts)));
 118 }
 119
 120 ScalableVectorType *ScalableVectorType::get(Type *ElementType,
 121                                             unsigned NumElts) {
 122   return cast<ScalableVectorType>(ElementType->getContext().getType(
 123       llvm::ScalableVectorType::get(ElementType->LLVMTy, NumElts)));
 124 }
 125
 126 IntegerType *IntegerType::get(Context &Ctx, unsigned NumBits) {
 127   return cast<IntegerType>(
 128       Ctx.getType(llvm::IntegerType::get(Ctx.LLVMCtx, NumBits)));
 129 }