contrib/llvm/lib/Target/AMDGPU/AMDGPUIntrinsicInfo.cpp

   1 //===- AMDGPUIntrinsicInfo.cpp - AMDGPU Intrinsic Information ---*- 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 /// \file
  11 /// \brief AMDGPU Implementation of the IntrinsicInfo class.
  12 //
  13 //===-----------------------------------------------------------------------===//
  14
  15 #include "AMDGPUIntrinsicInfo.h"
  16 #include "AMDGPUSubtarget.h"
  17 #include "llvm/IR/DerivedTypes.h"
  18 #include "llvm/IR/Intrinsics.h"
  19 #include "llvm/IR/Module.h"
  20
  21 using namespace llvm;
  22
  23 AMDGPUIntrinsicInfo::AMDGPUIntrinsicInfo()
  24     : TargetIntrinsicInfo() {}
  25
  26 static const char *const IntrinsicNameTable[] = {
  27 #define GET_INTRINSIC_NAME_TABLE
  28 #include "AMDGPUGenIntrinsics.inc"
  29 #undef GET_INTRINSIC_NAME_TABLE
  30 };
  31
  32 namespace {
  33 #define GET_INTRINSIC_ATTRIBUTES
  34 #include "AMDGPUGenIntrinsics.inc"
  35 #undef GET_INTRINSIC_ATTRIBUTES
  36 }
  37
  38 StringRef AMDGPUIntrinsicInfo::getName(unsigned IntrID,
  39                                        ArrayRef<Type *> Tys) const {
  40   if (IntrID < Intrinsic::num_intrinsics)
  41     return StringRef();
  42
  43   assert(IntrID < AMDGPUIntrinsic::num_AMDGPU_intrinsics &&
  44          "Invalid intrinsic ID");
  45
  46   return IntrinsicNameTable[IntrID - Intrinsic::num_intrinsics];
  47 }
  48
  49 std::string AMDGPUIntrinsicInfo::getName(unsigned IntrID, Type **Tys,
  50                                          unsigned NumTys) const {
  51   return getName(IntrID, makeArrayRef(Tys, NumTys)).str();
  52 }
  53
  54 FunctionType *AMDGPUIntrinsicInfo::getType(LLVMContext &Context, unsigned ID,
  55                                            ArrayRef<Type*> Tys) const {
  56   // FIXME: Re-use Intrinsic::getType machinery
  57   switch (ID) {
  58   case AMDGPUIntrinsic::amdgcn_fdiv_fast: {
  59     Type *F32Ty = Type::getFloatTy(Context);
  60     return FunctionType::get(F32Ty, { F32Ty, F32Ty }, false);
  61   }
  62   default:
  63     llvm_unreachable("unhandled intrinsic");
  64   }
  65 }
  66
  67 unsigned AMDGPUIntrinsicInfo::lookupName(const char *NameData,
  68                                          unsigned Len) const {
  69   StringRef Name(NameData, Len);
  70   if (!Name.startswith("llvm."))
  71     return 0; // All intrinsics start with 'llvm.'
  72
  73   // Look for a name match in our table.  If the intrinsic is not overloaded,
  74   // require an exact match. If it is overloaded, require a prefix match. The
  75   // AMDGPU enum enum starts at Intrinsic::num_intrinsics.
  76   int Idx = Intrinsic::lookupLLVMIntrinsicByName(IntrinsicNameTable, Name);
  77   if (Idx >= 0) {
  78     bool IsPrefixMatch = Name.size() > strlen(IntrinsicNameTable[Idx]);
  79     return IsPrefixMatch == isOverloaded(Idx + 1)
  80                ? Intrinsic::num_intrinsics + Idx
  81                : 0;
  82   }
  83
  84   return 0;
  85 }
  86
  87 bool AMDGPUIntrinsicInfo::isOverloaded(unsigned id) const {
  88 // Overload Table
  89 #define GET_INTRINSIC_OVERLOAD_TABLE
  90 #include "AMDGPUGenIntrinsics.inc"
  91 #undef GET_INTRINSIC_OVERLOAD_TABLE
  92 }
  93
  94 Function *AMDGPUIntrinsicInfo::getDeclaration(Module *M, unsigned IntrID,
  95                                               ArrayRef<Type *> Tys) const {
  96   FunctionType *FTy = getType(M->getContext(), IntrID, Tys);
  97   Function *F
  98     = cast<Function>(M->getOrInsertFunction(getName(IntrID, Tys), FTy));
  99
 100   AttributeSet AS = getAttributes(M->getContext(),
 101                                   static_cast<AMDGPUIntrinsic::ID>(IntrID));
 102   F->setAttributes(AS);
 103   return F;
 104 }
 105
 106 Function *AMDGPUIntrinsicInfo::getDeclaration(Module *M, unsigned IntrID,
 107                                               Type **Tys,
 108                                               unsigned NumTys) const {
 109   return getDeclaration(M, IntrID, makeArrayRef(Tys, NumTys));
 110 }