lib/Target/AMDGPU/SITypeRewriter.cpp

   1 //===-- SITypeRewriter.cpp - Remove unwanted types ------------------------===//
   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 /// This pass removes performs the following type substitution on all
  12 /// non-compute shaders:
  13 ///
  14 /// v16i8 => i128
  15 ///   - v16i8 is used for constant memory resource descriptors.  This type is
  16 ///      legal for some compute APIs, and we don't want to declare it as legal
  17 ///      in the backend, because we want the legalizer to expand all v16i8
  18 ///      operations.
  19 /// v1* => *
  20 ///   - Having v1* types complicates the legalizer and we can easily replace
  21 ///   - them with the element type.
  22 //===----------------------------------------------------------------------===//
  23
  24 #include "AMDGPU.h"
  25 #include "llvm/IR/IRBuilder.h"
  26 #include "llvm/IR/InstVisitor.h"
  27
  28 using namespace llvm;
  29
  30 namespace {
  31
  32 class SITypeRewriter : public FunctionPass,
  33                        public InstVisitor<SITypeRewriter> {
  34
  35   static char ID;
  36   Module *Mod;
  37   Type *v16i8;
  38   Type *v4i32;
  39
  40 public:
  41   SITypeRewriter() : FunctionPass(ID) { }
  42   bool doInitialization(Module &M) override;
  43   bool runOnFunction(Function &F) override;
  44   const char *getPassName() const override {
  45     return "SI Type Rewriter";
  46   }
  47   void visitLoadInst(LoadInst &I);
  48   void visitCallInst(CallInst &I);
  49   void visitBitCast(BitCastInst &I);
  50 };
  51
  52 } // End anonymous namespace
  53
  54 char SITypeRewriter::ID = 0;
  55
  56 bool SITypeRewriter::doInitialization(Module &M) {
  57   Mod = &M;
  58   v16i8 = VectorType::get(Type::getInt8Ty(M.getContext()), 16);
  59   v4i32 = VectorType::get(Type::getInt32Ty(M.getContext()), 4);
  60   return false;
  61 }
  62
  63 bool SITypeRewriter::runOnFunction(Function &F) {
  64   Attribute A = F.getFnAttribute("ShaderType");
  65
  66   unsigned ShaderType = ShaderType::COMPUTE;
  67   if (A.isStringAttribute()) {
  68     StringRef Str = A.getValueAsString();
  69     Str.getAsInteger(0, ShaderType);
  70   }
  71   if (ShaderType == ShaderType::COMPUTE)
  72     return false;
  73
  74   visit(F);
  75   visit(F);
  76
  77   return false;
  78 }
  79
  80 void SITypeRewriter::visitLoadInst(LoadInst &I) {
  81   Value *Ptr = I.getPointerOperand();
  82   Type *PtrTy = Ptr->getType();
  83   Type *ElemTy = PtrTy->getPointerElementType();
  84   IRBuilder<> Builder(&I);
  85   if (ElemTy == v16i8)  {
  86     Value *BitCast = Builder.CreateBitCast(Ptr,
  87         PointerType::get(v4i32,PtrTy->getPointerAddressSpace()));
  88     LoadInst *Load = Builder.CreateLoad(BitCast);
  89     SmallVector<std::pair<unsigned, MDNode *>, 8> MD;
  90     I.getAllMetadataOtherThanDebugLoc(MD);
  91     for (unsigned i = 0, e = MD.size(); i != e; ++i) {
  92       Load->setMetadata(MD[i].first, MD[i].second);
  93     }
  94     Value *BitCastLoad = Builder.CreateBitCast(Load, I.getType());
  95     I.replaceAllUsesWith(BitCastLoad);
  96     I.eraseFromParent();
  97   }
  98 }
  99
 100 void SITypeRewriter::visitCallInst(CallInst &I) {
 101   IRBuilder<> Builder(&I);
 102
 103   SmallVector <Value*, 8> Args;
 104   SmallVector <Type*, 8> Types;
 105   bool NeedToReplace = false;
 106   Function *F = I.getCalledFunction();
 107   std::string Name = F->getName();
 108   for (unsigned i = 0, e = I.getNumArgOperands(); i != e; ++i) {
 109     Value *Arg = I.getArgOperand(i);
 110     if (Arg->getType() == v16i8) {
 111       Args.push_back(Builder.CreateBitCast(Arg, v4i32));
 112       Types.push_back(v4i32);
 113       NeedToReplace = true;
 114       Name = Name + ".v4i32";
 115     } else if (Arg->getType()->isVectorTy() &&
 116                Arg->getType()->getVectorNumElements() == 1 &&
 117                Arg->getType()->getVectorElementType() ==
 118                                               Type::getInt32Ty(I.getContext())){
 119       Type *ElementTy = Arg->getType()->getVectorElementType();
 120       std::string TypeName = "i32";
 121       InsertElementInst *Def = cast<InsertElementInst>(Arg);
 122       Args.push_back(Def->getOperand(1));
 123       Types.push_back(ElementTy);
 124       std::string VecTypeName = "v1" + TypeName;
 125       Name = Name.replace(Name.find(VecTypeName), VecTypeName.length(), TypeName);
 126       NeedToReplace = true;
 127     } else {
 128       Args.push_back(Arg);
 129       Types.push_back(Arg->getType());
 130     }
 131   }
 132
 133   if (!NeedToReplace) {
 134     return;
 135   }
 136   Function *NewF = Mod->getFunction(Name);
 137   if (!NewF) {
 138     NewF = Function::Create(FunctionType::get(F->getReturnType(), Types, false), GlobalValue::ExternalLinkage, Name, Mod);
 139     NewF->setAttributes(F->getAttributes());
 140   }
 141   I.replaceAllUsesWith(Builder.CreateCall(NewF, Args));
 142   I.eraseFromParent();
 143 }
 144
 145 void SITypeRewriter::visitBitCast(BitCastInst &I) {
 146   IRBuilder<> Builder(&I);
 147   if (I.getDestTy() != v4i32) {
 148     return;
 149   }
 150
 151   if (BitCastInst *Op = dyn_cast<BitCastInst>(I.getOperand(0))) {
 152     if (Op->getSrcTy() == v4i32) {
 153       I.replaceAllUsesWith(Op->getOperand(0));
 154       I.eraseFromParent();
 155     }
 156   }
 157 }
 158
 159 FunctionPass *llvm::createSITypeRewriter() {
 160   return new SITypeRewriter();
 161 }