LLVM  3.7.0
NVPTXImageOptimizer.cpp
Go to the documentation of this file.
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"
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 
48 
49 NVPTXImageOptimizer::NVPTXImageOptimizer()
50  : FunctionPass(ID) {}
51 
52 bool NVPTXImageOptimizer::runOnFunction(Function &F) {
53  bool Changed = false;
54  InstrToDelete.clear();
55 
56  // Look for call instructions in the function
57  for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE;
58  ++BI) {
59  for (BasicBlock::iterator I = (*BI).begin(), E = (*BI).end();
60  I != E; ++I) {
61  Instruction &Instr = *I;
62  if (CallInst *CI = dyn_cast<CallInst>(I)) {
63  Function *CalledF = CI->getCalledFunction();
64  if (CalledF && CalledF->isIntrinsic()) {
65  // This is an intrinsic function call, check if its an istypep
66  switch (CalledF->getIntrinsicID()) {
67  default: break;
68  case Intrinsic::nvvm_istypep_sampler:
69  Changed |= replaceIsTypePSampler(Instr);
70  break;
71  case Intrinsic::nvvm_istypep_surface:
72  Changed |= replaceIsTypePSurface(Instr);
73  break;
74  case Intrinsic::nvvm_istypep_texture:
75  Changed |= replaceIsTypePTexture(Instr);
76  break;
77  }
78  }
79  }
80  }
81  }
82 
83  // Delete any istypep instances we replaced in the IR
84  for (unsigned i = 0, e = InstrToDelete.size(); i != e; ++i)
85  InstrToDelete[i]->eraseFromParent();
86 
87  return Changed;
88 }
89 
90 bool NVPTXImageOptimizer::replaceIsTypePSampler(Instruction &I) {
91  Value *TexHandle = cleanupValue(I.getOperand(0));
92  if (isSampler(*TexHandle)) {
93  // This is an OpenCL sampler, so it must be a samplerref
94  replaceWith(&I, ConstantInt::getTrue(I.getContext()));
95  return true;
96  } else if (isImageWriteOnly(*TexHandle) ||
97  isImageReadWrite(*TexHandle) ||
98  isImageReadOnly(*TexHandle)) {
99  // This is an OpenCL image, so it cannot be a samplerref
100  replaceWith(&I, ConstantInt::getFalse(I.getContext()));
101  return true;
102  } else {
103  // The image type is unknown, so we cannot eliminate the intrinsic
104  return false;
105  }
106 }
107 
108 bool NVPTXImageOptimizer::replaceIsTypePSurface(Instruction &I) {
109  Value *TexHandle = cleanupValue(I.getOperand(0));
110  if (isImageReadWrite(*TexHandle) ||
111  isImageWriteOnly(*TexHandle)) {
112  // This is an OpenCL read-only/read-write image, so it must be a surfref
113  replaceWith(&I, ConstantInt::getTrue(I.getContext()));
114  return true;
115  } else if (isImageReadOnly(*TexHandle) ||
116  isSampler(*TexHandle)) {
117  // This is an OpenCL read-only/ imageor sampler, so it cannot be
118  // a surfref
119  replaceWith(&I, ConstantInt::getFalse(I.getContext()));
120  return true;
121  } else {
122  // The image type is unknown, so we cannot eliminate the intrinsic
123  return false;
124  }
125 }
126 
127 bool NVPTXImageOptimizer::replaceIsTypePTexture(Instruction &I) {
128  Value *TexHandle = cleanupValue(I.getOperand(0));
129  if (isImageReadOnly(*TexHandle)) {
130  // This is an OpenCL read-only image, so it must be a texref
131  replaceWith(&I, ConstantInt::getTrue(I.getContext()));
132  return true;
133  } else if (isImageWriteOnly(*TexHandle) ||
134  isImageReadWrite(*TexHandle) ||
135  isSampler(*TexHandle)) {
136  // This is an OpenCL read-write/write-only image or a sampler, so it
137  // cannot be a texref
138  replaceWith(&I, ConstantInt::getFalse(I.getContext()));
139  return true;
140  } else {
141  // The image type is unknown, so we cannot eliminate the intrinsic
142  return false;
143  }
144 }
145 
146 void NVPTXImageOptimizer::replaceWith(Instruction *From, ConstantInt *To) {
147  // We implement "poor man's DCE" here to make sure any code that is no longer
148  // live is actually unreachable and can be trivially eliminated by the
149  // unreachable block elimination pass.
150  for (CallInst::use_iterator UI = From->use_begin(), UE = From->use_end();
151  UI != UE; ++UI) {
152  if (BranchInst *BI = dyn_cast<BranchInst>(*UI)) {
153  if (BI->isUnconditional()) continue;
154  BasicBlock *Dest;
155  if (To->isZero())
156  // Get false block
157  Dest = BI->getSuccessor(1);
158  else
159  // Get true block
160  Dest = BI->getSuccessor(0);
161  BranchInst::Create(Dest, BI);
162  InstrToDelete.push_back(BI);
163  }
164  }
165  From->replaceAllUsesWith(To);
166  InstrToDelete.push_back(From);
167 }
168 
169 Value *NVPTXImageOptimizer::cleanupValue(Value *V) {
170  if (ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(V)) {
171  return cleanupValue(EVI->getAggregateOperand());
172  }
173  return V;
174 }
175 
177  return new NVPTXImageOptimizer();
178 }
use_iterator use_end()
Definition: Value.h:281
ExtractValueInst - This instruction extracts a struct member or array element value from an aggregate...
iterator end()
Definition: Function.h:459
CallInst - This class represents a function call, abstracting a target machine's calling convention...
bool isIntrinsic() const
Definition: Function.h:160
F(f)
static Constant * getTrue(Type *Ty)
getTrue - For a boolean type, or a vector of boolean type, return true, or a vector with every elemen...
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:351
bool isImageReadWrite(const llvm::Value &)
FunctionPass * createNVPTXImageOptimizerPass()
iterator begin()
Definition: Function.h:457
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
BranchInst - Conditional or Unconditional Branch instruction.
bool isImageWriteOnly(const llvm::Value &)
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:294
Value * getOperand(unsigned i) const
Definition: User.h:118
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:519
bool isImageReadOnly(const llvm::Value &)
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Module.h This file contains the declarations for the Module class.
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
Definition: Constants.h:161
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:159
static Constant * getFalse(Type *Ty)
getFalse - For a boolean type, or a vector of boolean type, return false, or a vector with every elem...
bool isSampler(const llvm::Value &)
use_iterator use_begin()
Definition: Value.h:279
#define I(x, y, z)
Definition: MD5.cpp:54
LLVM Value Representation.
Definition: Value.h:69