lib/Target/R600/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   AttributeSet Set = F.getAttributes();
  65   Attribute A = Set.getAttribute(AttributeSet::FunctionIndex, "ShaderType");
  66
  67   unsigned ShaderType = ShaderType::COMPUTE;
  68   if (A.isStringAttribute()) {
  69     StringRef Str = A.getValueAsString();
  70     Str.getAsInteger(0, ShaderType);
  71   }
  72   if (ShaderType == ShaderType::COMPUTE)
  73     return false;
  74
  75   visit(F);
  76   visit(F);
  77
  78   return false;
  79 }
  80
  81 void SITypeRewriter::visitLoadInst(LoadInst &I) {
  82   Value *Ptr = I.getPointerOperand();
  83   Type *PtrTy = Ptr->getType();
  84   Type *ElemTy = PtrTy->getPointerElementType();
  85   IRBuilder<> Builder(&I);
  86   if (ElemTy == v16i8)  {
  87     Value *BitCast = Builder.CreateBitCast(Ptr,
  88         PointerType::get(v4i32,PtrTy->getPointerAddressSpace()));
  89     LoadInst *Load = Builder.CreateLoad(BitCast);
  90     SmallVector<std::pair<unsigned, MDNode *>, 8> MD;
  91     I.getAllMetadataOtherThanDebugLoc(MD);
  92     for (unsigned i = 0, e = MD.size(); i != e; ++i) {
  93       Load->setMetadata(MD[i].first, MD[i].second);
  94     }
  95     Value *BitCastLoad = Builder.CreateBitCast(Load, I.getType());
  96     I.replaceAllUsesWith(BitCastLoad);
  97     I.eraseFromParent();
  98   }
  99 }
 100
 101 void SITypeRewriter::visitCallInst(CallInst &I) {
 102   IRBuilder<> Builder(&I);
 103
 104   SmallVector <Value*, 8> Args;
 105   SmallVector <Type*, 8> Types;
 106   bool NeedToReplace = false;
 107   Function *F = I.getCalledFunction();
 108   std::string Name = F->getName().str();
 109   for (unsigned i = 0, e = I.getNumArgOperands(); i != e; ++i) {
 110     Value *Arg = I.getArgOperand(i);
 111     if (Arg->getType() == v16i8) {
 112       Args.push_back(Builder.CreateBitCast(Arg, v4i32));
 113       Types.push_back(v4i32);
 114       NeedToReplace = true;
 115       Name = Name + ".v4i32";
 116     } else if (Arg->getType()->isVectorTy() &&
 117                Arg->getType()->getVectorNumElements() == 1 &&
 118                Arg->getType()->getVectorElementType() ==
 119                                               Type::getInt32Ty(I.getContext())){
 120       Type *ElementTy = Arg->getType()->getVectorElementType();
 121       std::string TypeName = "i32";
 122       InsertElementInst *Def = cast<InsertElementInst>(Arg);
 123       Args.push_back(Def->getOperand(1));
 124       Types.push_back(ElementTy);
 125       std::string VecTypeName = "v1" + TypeName;
 126       Name = Name.replace(Name.find(VecTypeName), VecTypeName.length(), TypeName);
 127       NeedToReplace = true;
 128     } else {
 129       Args.push_back(Arg);
 130       Types.push_back(Arg->getType());
 131     }
 132   }
 133
 134   if (!NeedToReplace) {
 135     return;
 136   }
 137   Function *NewF = Mod->getFunction(Name);
 138   if (!NewF) {
 139     NewF = Function::Create(FunctionType::get(F->getReturnType(), Types, false), GlobalValue::ExternalLinkage, Name, Mod);
 140     NewF->setAttributes(F->getAttributes());
 141   }
 142   I.replaceAllUsesWith(Builder.CreateCall(NewF, Args));
 143   I.eraseFromParent();
 144 }
 145
 146 void SITypeRewriter::visitBitCast(BitCastInst &I) {
 147   IRBuilder<> Builder(&I);
 148   if (I.getDestTy() != v4i32) {
 149     return;
 150   }
 151
 152   if (BitCastInst *Op = dyn_cast<BitCastInst>(I.getOperand(0))) {
 153     if (Op->getSrcTy() == v4i32) {
 154       I.replaceAllUsesWith(Op->getOperand(0));
 155       I.eraseFromParent();
 156     }
 157   }
 158 }
 159
 160 FunctionPass *llvm::createSITypeRewriter() {
 161   return new SITypeRewriter();
 162 }