contrib/llvm/lib/Target/NVPTX/NVPTXImageOptimizer.cpp

   1 //===-- NVPTXImageOptimizer.cpp - Image optimization pass -----------------===//
   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 // This pass implements IR-level optimizations of image access code,
  11 // including:
  12 //
  13 // 1. Eliminate istypep intrinsics when image access qualifier is known
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #include "NVPTX.h"
  18 #include "NVPTXUtilities.h"
  19 #include "llvm/Analysis/ConstantFolding.h"
  20 #include "llvm/IR/Instructions.h"
  21 #include "llvm/IR/Intrinsics.h"
  22 #include "llvm/IR/Module.h"
  23 #include "llvm/Pass.h"
  24
  25 using namespace llvm;
  26
  27 namespace {
  28 class NVPTXImageOptimizer : public FunctionPass {
  29 private:
  30   static char ID;
  31   SmallVector<Instruction*, 4> InstrToDelete;
  32
  33 public:
  34   NVPTXImageOptimizer();
  35
  36   bool runOnFunction(Function &F) override;
  37
  38 private:
  39   bool replaceIsTypePSampler(Instruction &I);
  40   bool replaceIsTypePSurface(Instruction &I);
  41   bool replaceIsTypePTexture(Instruction &I);
  42   Value *cleanupValue(Value *V);
  43   void replaceWith(Instruction *From, ConstantInt *To);
  44 };
  45 }
  46
  47 char NVPTXImageOptimizer::ID = 0;
  48
  49 NVPTXImageOptimizer::NVPTXImageOptimizer()
  50   : FunctionPass(ID) {}
  51
  52 bool NVPTXImageOptimizer::runOnFunction(Function &F) {
  53   if (skipFunction(F))
  54     return false;
  55
  56   bool Changed = false;
  57   InstrToDelete.clear();
  58
  59   // Look for call instructions in the function
  60   for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE;
  61        ++BI) {
  62     for (BasicBlock::iterator I = (*BI).begin(), E = (*BI).end();
  63          I != E; ++I) {
  64       Instruction &Instr = *I;
  65       if (CallInst *CI = dyn_cast<CallInst>(I)) {
  66         Function *CalledF = CI->getCalledFunction();
  67         if (CalledF && CalledF->isIntrinsic()) {
  68           // This is an intrinsic function call, check if its an istypep
  69           switch (CalledF->getIntrinsicID()) {
  70           default: break;
  71           case Intrinsic::nvvm_istypep_sampler:
  72             Changed |= replaceIsTypePSampler(Instr);
  73             break;
  74           case Intrinsic::nvvm_istypep_surface:
  75             Changed |= replaceIsTypePSurface(Instr);
  76             break;
  77           case Intrinsic::nvvm_istypep_texture:
  78             Changed |= replaceIsTypePTexture(Instr);
  79             break;
  80           }
  81         }
  82       }
  83     }
  84   }
  85
  86   // Delete any istypep instances we replaced in the IR
  87   for (unsigned i = 0, e = InstrToDelete.size(); i != e; ++i)
  88     InstrToDelete[i]->eraseFromParent();
  89
  90   return Changed;
  91 }
  92
  93 bool NVPTXImageOptimizer::replaceIsTypePSampler(Instruction &I) {
  94   Value *TexHandle = cleanupValue(I.getOperand(0));
  95   if (isSampler(*TexHandle)) {
  96     // This is an OpenCL sampler, so it must be a samplerref
  97     replaceWith(&I, ConstantInt::getTrue(I.getContext()));
  98     return true;
  99   } else if (isImageWriteOnly(*TexHandle) ||
 100              isImageReadWrite(*TexHandle) ||
 101              isImageReadOnly(*TexHandle)) {
 102     // This is an OpenCL image, so it cannot be a samplerref
 103     replaceWith(&I, ConstantInt::getFalse(I.getContext()));
 104     return true;
 105   } else {
 106     // The image type is unknown, so we cannot eliminate the intrinsic
 107     return false;
 108   }
 109 }
 110
 111 bool NVPTXImageOptimizer::replaceIsTypePSurface(Instruction &I) {
 112   Value *TexHandle = cleanupValue(I.getOperand(0));
 113   if (isImageReadWrite(*TexHandle) ||
 114       isImageWriteOnly(*TexHandle)) {
 115     // This is an OpenCL read-only/read-write image, so it must be a surfref
 116     replaceWith(&I, ConstantInt::getTrue(I.getContext()));
 117     return true;
 118   } else if (isImageReadOnly(*TexHandle) ||
 119              isSampler(*TexHandle)) {
 120     // This is an OpenCL read-only/ imageor sampler, so it cannot be
 121     // a surfref
 122     replaceWith(&I, ConstantInt::getFalse(I.getContext()));
 123     return true;
 124   } else {
 125     // The image type is unknown, so we cannot eliminate the intrinsic
 126     return false;
 127   }
 128 }
 129
 130 bool NVPTXImageOptimizer::replaceIsTypePTexture(Instruction &I) {
 131   Value *TexHandle = cleanupValue(I.getOperand(0));
 132   if (isImageReadOnly(*TexHandle)) {
 133     // This is an OpenCL read-only image, so it must be a texref
 134     replaceWith(&I, ConstantInt::getTrue(I.getContext()));
 135     return true;
 136   } else if (isImageWriteOnly(*TexHandle) ||
 137              isImageReadWrite(*TexHandle) ||
 138              isSampler(*TexHandle)) {
 139     // This is an OpenCL read-write/write-only image or a sampler, so it
 140     // cannot be a texref
 141     replaceWith(&I, ConstantInt::getFalse(I.getContext()));
 142     return true;
 143   } else {
 144     // The image type is unknown, so we cannot eliminate the intrinsic
 145     return false;
 146   }
 147 }
 148
 149 void NVPTXImageOptimizer::replaceWith(Instruction *From, ConstantInt *To) {
 150   // We implement "poor man's DCE" here to make sure any code that is no longer
 151   // live is actually unreachable and can be trivially eliminated by the
 152   // unreachable block elimination pass.
 153   for (CallInst::use_iterator UI = From->use_begin(), UE = From->use_end();
 154        UI != UE; ++UI) {
 155     if (BranchInst *BI = dyn_cast<BranchInst>(*UI)) {
 156       if (BI->isUnconditional()) continue;
 157       BasicBlock *Dest;
 158       if (To->isZero())
 159         // Get false block
 160         Dest = BI->getSuccessor(1);
 161       else
 162         // Get true block
 163         Dest = BI->getSuccessor(0);
 164       BranchInst::Create(Dest, BI);
 165       InstrToDelete.push_back(BI);
 166     }
 167   }
 168   From->replaceAllUsesWith(To);
 169   InstrToDelete.push_back(From);
 170 }
 171
 172 Value *NVPTXImageOptimizer::cleanupValue(Value *V) {
 173   if (ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(V)) {
 174     return cleanupValue(EVI->getAggregateOperand());
 175   }
 176   return V;
 177 }
 178
 179 FunctionPass *llvm::createNVPTXImageOptimizerPass() {
 180   return new NVPTXImageOptimizer();
 181 }