blob: fc0d5cc6fbfa859e91d73ec6c84d88ba30b73054 [file] [log] [blame]
//===-- NVPTXImageOptimizer.cpp - Image optimization pass -----------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This pass implements IR-level optimizations of image access code,
// including:
//
// 1. Eliminate istypep intrinsics when image access qualifier is known
//
//===----------------------------------------------------------------------===//
#include "NVPTX.h"
#include "NVPTXUtilities.h"
#include "llvm/Analysis/ConstantFolding.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/IntrinsicsNVPTX.h"
#include "llvm/IR/Module.h"
#include "llvm/Pass.h"
using namespace llvm;
namespace {
class NVPTXImageOptimizer : public FunctionPass {
private:
static char ID;
SmallVector<Instruction*, 4> InstrToDelete;
public:
NVPTXImageOptimizer();
bool runOnFunction(Function &F) override;
private:
bool replaceIsTypePSampler(Instruction &I);
bool replaceIsTypePSurface(Instruction &I);
bool replaceIsTypePTexture(Instruction &I);
Value *cleanupValue(Value *V);
void replaceWith(Instruction *From, ConstantInt *To);
};
}
char NVPTXImageOptimizer::ID = 0;
NVPTXImageOptimizer::NVPTXImageOptimizer()
: FunctionPass(ID) {}
bool NVPTXImageOptimizer::runOnFunction(Function &F) {
if (skipFunction(F))
return false;
bool Changed = false;
InstrToDelete.clear();
// Look for call instructions in the function
for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE;
++BI) {
for (BasicBlock::iterator I = (*BI).begin(), E = (*BI).end();
I != E; ++I) {
Instruction &Instr = *I;
if (CallInst *CI = dyn_cast<CallInst>(I)) {
Function *CalledF = CI->getCalledFunction();
if (CalledF && CalledF->isIntrinsic()) {
// This is an intrinsic function call, check if its an istypep
switch (CalledF->getIntrinsicID()) {
default: break;
case Intrinsic::nvvm_istypep_sampler:
Changed |= replaceIsTypePSampler(Instr);
break;
case Intrinsic::nvvm_istypep_surface:
Changed |= replaceIsTypePSurface(Instr);
break;
case Intrinsic::nvvm_istypep_texture:
Changed |= replaceIsTypePTexture(Instr);
break;
}
}
}
}
}
// Delete any istypep instances we replaced in the IR
for (unsigned i = 0, e = InstrToDelete.size(); i != e; ++i)
InstrToDelete[i]->eraseFromParent();
return Changed;
}
bool NVPTXImageOptimizer::replaceIsTypePSampler(Instruction &I) {
Value *TexHandle = cleanupValue(I.getOperand(0));
if (isSampler(*TexHandle)) {
// This is an OpenCL sampler, so it must be a samplerref
replaceWith(&I, ConstantInt::getTrue(I.getContext()));
return true;
} else if (isImage(*TexHandle)) {
// This is an OpenCL image, so it cannot be a samplerref
replaceWith(&I, ConstantInt::getFalse(I.getContext()));
return true;
} else {
// The image type is unknown, so we cannot eliminate the intrinsic
return false;
}
}
bool NVPTXImageOptimizer::replaceIsTypePSurface(Instruction &I) {
Value *TexHandle = cleanupValue(I.getOperand(0));
if (isImageReadWrite(*TexHandle) ||
isImageWriteOnly(*TexHandle)) {
// This is an OpenCL read-only/read-write image, so it must be a surfref
replaceWith(&I, ConstantInt::getTrue(I.getContext()));
return true;
} else if (isImageReadOnly(*TexHandle) ||
isSampler(*TexHandle)) {
// This is an OpenCL read-only/ imageor sampler, so it cannot be
// a surfref
replaceWith(&I, ConstantInt::getFalse(I.getContext()));
return true;
} else {
// The image type is unknown, so we cannot eliminate the intrinsic
return false;
}
}
bool NVPTXImageOptimizer::replaceIsTypePTexture(Instruction &I) {
Value *TexHandle = cleanupValue(I.getOperand(0));
if (isImageReadOnly(*TexHandle)) {
// This is an OpenCL read-only image, so it must be a texref
replaceWith(&I, ConstantInt::getTrue(I.getContext()));
return true;
} else if (isImageWriteOnly(*TexHandle) ||
isImageReadWrite(*TexHandle) ||
isSampler(*TexHandle)) {
// This is an OpenCL read-write/write-only image or a sampler, so it
// cannot be a texref
replaceWith(&I, ConstantInt::getFalse(I.getContext()));
return true;
} else {
// The image type is unknown, so we cannot eliminate the intrinsic
return false;
}
}
void NVPTXImageOptimizer::replaceWith(Instruction *From, ConstantInt *To) {
// We implement "poor man's DCE" here to make sure any code that is no longer
// live is actually unreachable and can be trivially eliminated by the
// unreachable block elimination pass.
for (Use &U : From->uses()) {
if (BranchInst *BI = dyn_cast<BranchInst>(U)) {
if (BI->isUnconditional()) continue;
BasicBlock *Dest;
if (To->isZero())
// Get false block
Dest = BI->getSuccessor(1);
else
// Get true block
Dest = BI->getSuccessor(0);
BranchInst::Create(Dest, BI);
InstrToDelete.push_back(BI);
}
}
From->replaceAllUsesWith(To);
InstrToDelete.push_back(From);
}
Value *NVPTXImageOptimizer::cleanupValue(Value *V) {
if (ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(V)) {
return cleanupValue(EVI->getAggregateOperand());
}
return V;
}
FunctionPass *llvm::createNVPTXImageOptimizerPass() {
return new NVPTXImageOptimizer();
}