[llvm] r264919 - [NVPTX] Make NVVMReflect a function pass.
Justin Lebar via llvm-commits
llvm-commits at lists.llvm.org
Wed Mar 30 13:40:12 PDT 2016
Author: jlebar
Date: Wed Mar 30 15:40:11 2016
New Revision: 264919
URL: http://llvm.org/viewvc/llvm-project?rev=264919&view=rev
Log:
[NVPTX] Make NVVMReflect a function pass.
Summary:
Currently it's a module pass. Make it a function pass so that we can
move it to PassManagerBuilder's EP_EarlyAsPossible extension point,
which only accepts function passes.
Reviewers: rnk
Subscribers: tra, llvm-commits, jholewinski
Differential Revision: http://reviews.llvm.org/D18615
Modified:
llvm/trunk/docs/NVPTXUsage.rst
llvm/trunk/lib/Target/NVPTX/NVPTX.h
llvm/trunk/lib/Target/NVPTX/NVVMReflect.cpp
Modified: llvm/trunk/docs/NVPTXUsage.rst
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/NVPTXUsage.rst?rev=264919&r1=264918&r2=264919&view=diff
==============================================================================
--- llvm/trunk/docs/NVPTXUsage.rst (original)
+++ llvm/trunk/docs/NVPTXUsage.rst Wed Mar 30 15:40:11 2016
@@ -361,7 +361,7 @@ With programmatic pass pipeline:
.. code-block:: c++
- extern ModulePass *llvm::createNVVMReflectPass(const StringMap<int>& Mapping);
+ extern FunctionPass *llvm::createNVVMReflectPass(const StringMap<int>& Mapping);
StringMap<int> ReflectParams;
ReflectParams["__CUDA_FTZ"] = 1;
Modified: llvm/trunk/lib/Target/NVPTX/NVPTX.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/NVPTX/NVPTX.h?rev=264919&r1=264918&r2=264919&view=diff
==============================================================================
--- llvm/trunk/lib/Target/NVPTX/NVPTX.h (original)
+++ llvm/trunk/lib/Target/NVPTX/NVPTX.h Wed Mar 30 15:40:11 2016
@@ -47,8 +47,8 @@ ModulePass *createNVPTXAssignValidGlobal
ModulePass *createGenericToNVVMPass();
FunctionPass *createNVPTXFavorNonGenericAddrSpacesPass();
FunctionPass *createNVPTXInferAddressSpacesPass();
-ModulePass *createNVVMReflectPass();
-ModulePass *createNVVMReflectPass(const StringMap<int>& Mapping);
+FunctionPass *createNVVMReflectPass();
+FunctionPass *createNVVMReflectPass(const StringMap<int> &Mapping);
MachineFunctionPass *createNVPTXPrologEpilogPass();
MachineFunctionPass *createNVPTXReplaceImageHandlesPass();
FunctionPass *createNVPTXImageOptimizerPass();
Modified: llvm/trunk/lib/Target/NVPTX/NVVMReflect.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/NVPTX/NVVMReflect.cpp?rev=264919&r1=264918&r2=264919&view=diff
==============================================================================
--- llvm/trunk/lib/Target/NVPTX/NVVMReflect.cpp (original)
+++ llvm/trunk/lib/Target/NVPTX/NVVMReflect.cpp Wed Mar 30 15:40:11 2016
@@ -7,20 +7,23 @@
//
//===----------------------------------------------------------------------===//
//
-// This pass replaces occurrences of __nvvm_reflect("string") with an
-// integer based on -nvvm-reflect-list string=<int> option given to this pass.
-// If an undefined string value is seen in a call to __nvvm_reflect("string"),
-// a default value of 0 will be used.
+// This pass replaces occurrences of __nvvm_reflect("string") and
+// llvm.nvvm.reflect with an integer based on the value of -nvvm-reflect-list
+// string=<int>.
+//
+// If we see a string not specified in our flags, we replace that call with 0.
//
//===----------------------------------------------------------------------===//
#include "NVPTX.h"
#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"
+#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/Module.h"
@@ -35,7 +38,6 @@
#include <sstream>
#include <string>
#include <vector>
-
#define NVVM_REFLECT_FUNCTION "__nvvm_reflect"
using namespace llvm;
@@ -45,31 +47,25 @@ using namespace llvm;
namespace llvm { void initializeNVVMReflectPass(PassRegistry &); }
namespace {
-class NVVMReflect : public ModulePass {
+class NVVMReflect : public FunctionPass {
private:
StringMap<int> VarMap;
- typedef DenseMap<std::string, int>::iterator VarMapIter;
public:
static char ID;
- NVVMReflect() : ModulePass(ID) {
- initializeNVVMReflectPass(*PassRegistry::getPassRegistry());
- VarMap.clear();
- }
+ NVVMReflect() : NVVMReflect(StringMap<int>()) {}
- NVVMReflect(const StringMap<int> &Mapping)
- : ModulePass(ID) {
+ NVVMReflect(const StringMap<int> &Mapping) : FunctionPass(ID) {
initializeNVVMReflectPass(*PassRegistry::getPassRegistry());
- for (StringMap<int>::const_iterator I = Mapping.begin(), E = Mapping.end();
- I != E; ++I) {
- VarMap[(*I).getKey()] = (*I).getValue();
- }
+ for (const auto &KV : Mapping)
+ VarMap[KV.getKey()] = KV.getValue();
+ setVarMap();
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.setPreservesAll();
}
- bool runOnModule(Module &) override;
+ bool runOnFunction(Function &) override;
private:
bool handleFunction(Function *ReflectFunction);
@@ -77,11 +73,8 @@ private:
};
}
-ModulePass *llvm::createNVVMReflectPass() {
- return new NVVMReflect();
-}
-
-ModulePass *llvm::createNVVMReflectPass(const StringMap<int>& Mapping) {
+FunctionPass *llvm::createNVVMReflectPass() { return new NVVMReflect(); }
+FunctionPass *llvm::createNVVMReflectPass(const StringMap<int> &Mapping) {
return new NVVMReflect(Mapping);
}
@@ -123,30 +116,35 @@ void NVVMReflect::setVarMap() {
}
}
-bool NVVMReflect::handleFunction(Function *ReflectFunction) {
- // Validate _reflect function
- assert(ReflectFunction->isDeclaration() &&
- "_reflect function should not have a body");
- assert(ReflectFunction->getReturnType()->isIntegerTy() &&
- "_reflect's return type should be integer");
-
- std::vector<Instruction *> ToRemove;
-
- // Go through the uses of ReflectFunction in this Function.
- // Each of them should a CallInst with a ConstantArray argument.
- // First validate that. If the c-string corresponding to the
- // ConstantArray can be found successfully, see if it can be
- // found in VarMap. If so, replace the uses of CallInst with the
- // value found in VarMap. If not, replace the use with value 0.
+bool NVVMReflect::runOnFunction(Function &F) {
+ if (!NVVMReflectEnabled)
+ return false;
+
+ if (F.getName() == NVVM_REFLECT_FUNCTION) {
+ assert(F.isDeclaration() && "_reflect function should not have a body");
+ assert(F.getReturnType()->isIntegerTy() &&
+ "_reflect's return type should be integer");
+ return false;
+ }
- // IR for __nvvm_reflect calls differs between CUDA versions:
+ SmallVector<Instruction *, 4> ToRemove;
+
+ // Go through the calls in this function. Each call to __nvvm_reflect or
+ // llvm.nvvm.reflect should be a CallInst with a ConstantArray argument.
+ // First validate that. If the c-string corresponding to the ConstantArray can
+ // be found successfully, see if it can be found in VarMap. If so, replace the
+ // uses of CallInst with the value found in VarMap. If not, replace the use
+ // with value 0.
+
+ // The IR for __nvvm_reflect calls differs between CUDA versions.
+ //
// CUDA 6.5 and earlier uses this sequence:
// %ptr = tail call i8* @llvm.nvvm.ptr.constant.to.gen.p0i8.p4i8
// (i8 addrspace(4)* getelementptr inbounds
// ([8 x i8], [8 x i8] addrspace(4)* @str, i32 0, i32 0))
// %reflect = tail call i32 @__nvvm_reflect(i8* %ptr)
//
- // Value returned by Sym->getOperand(0) is a Constant with a
+ // The value returned by Sym->getOperand(0) is a Constant with a
// ConstantDataSequential operand which can be converted to string and used
// for lookup.
//
@@ -157,31 +155,37 @@ bool NVVMReflect::handleFunction(Functio
//
// In this case, we get a Constant with a GlobalVariable operand and we need
// to dig deeper to find its initializer with the string we'll use for lookup.
-
- for (User *U : ReflectFunction->users()) {
- assert(isa<CallInst>(U) && "Only a call instruction can use _reflect");
- CallInst *Reflect = cast<CallInst>(U);
-
- assert((Reflect->getNumOperands() == 2) &&
- "Only one operand expect for _reflect function");
- // In cuda, we will have an extra constant-to-generic conversion of
- // the string.
- const Value *Str = Reflect->getArgOperand(0);
- if (isa<CallInst>(Str)) {
- // CUDA path
- const CallInst *ConvCall = cast<CallInst>(Str);
+ for (Instruction &I : instructions(F)) {
+ CallInst *Call = dyn_cast<CallInst>(&I);
+ if (!Call)
+ continue;
+ Function *Callee = Call->getCalledFunction();
+ if (!Callee || (Callee->getName() != NVVM_REFLECT_FUNCTION &&
+ Callee->getIntrinsicID() != Intrinsic::nvvm_reflect))
+ continue;
+
+ // FIXME: Improve error handling here and elsewhere in this pass.
+ assert(Call->getNumOperands() == 2 &&
+ "Wrong number of operands to __nvvm_reflect function");
+
+ // In cuda 6.5 and earlier, we will have an extra constant-to-generic
+ // conversion of the string.
+ const Value *Str = Call->getArgOperand(0);
+ if (const CallInst *ConvCall = dyn_cast<CallInst>(Str)) {
+ // FIXME: Add assertions about ConvCall.
Str = ConvCall->getArgOperand(0);
}
assert(isa<ConstantExpr>(Str) &&
- "Format of _reflect function not recognized");
+ "Format of __nvvm__reflect function not recognized");
const ConstantExpr *GEP = cast<ConstantExpr>(Str);
const Value *Sym = GEP->getOperand(0);
- assert(isa<Constant>(Sym) && "Format of _reflect function not recognized");
+ assert(isa<Constant>(Sym) &&
+ "Format of __nvvm_reflect function not recognized");
const Value *Operand = cast<Constant>(Sym)->getOperand(0);
if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(Operand)) {
- // For CUDA-7.0 style __nvvm_reflect calls we need to find operand's
+ // For CUDA-7.0 style __nvvm_reflect calls, we need to find the operand's
// initializer.
assert(GV->hasInitializer() &&
"Format of _reflect function not recognized");
@@ -194,57 +198,20 @@ bool NVVMReflect::handleFunction(Functio
assert(cast<ConstantDataSequential>(Operand)->isCString() &&
"Format of _reflect function not recognized");
- std::string ReflectArg =
- cast<ConstantDataSequential>(Operand)->getAsString();
-
+ StringRef ReflectArg = cast<ConstantDataSequential>(Operand)->getAsString();
ReflectArg = ReflectArg.substr(0, ReflectArg.size() - 1);
DEBUG(dbgs() << "Arg of _reflect : " << ReflectArg << "\n");
int ReflectVal = 0; // The default value is 0
- if (VarMap.find(ReflectArg) != VarMap.end()) {
- ReflectVal = VarMap[ReflectArg];
- }
- Reflect->replaceAllUsesWith(
- ConstantInt::get(Reflect->getType(), ReflectVal));
- ToRemove.push_back(Reflect);
- }
- if (ToRemove.size() == 0)
- return false;
-
- for (unsigned i = 0, e = ToRemove.size(); i != e; ++i)
- ToRemove[i]->eraseFromParent();
- return true;
-}
-
-bool NVVMReflect::runOnModule(Module &M) {
- if (!NVVMReflectEnabled)
- return false;
-
- setVarMap();
-
-
- bool Res = false;
- std::string Name;
- Type *Tys[1];
- Type *I8Ty = Type::getInt8Ty(M.getContext());
- Function *ReflectFunction;
-
- // Check for standard overloaded versions of llvm.nvvm.reflect
-
- for (unsigned i = 0; i != 5; ++i) {
- Tys[0] = PointerType::get(I8Ty, i);
- Name = Intrinsic::getName(Intrinsic::nvvm_reflect, Tys);
- ReflectFunction = M.getFunction(Name);
- if(ReflectFunction != 0) {
- Res |= handleFunction(ReflectFunction);
- }
+ auto Iter = VarMap.find(ReflectArg);
+ if (Iter != VarMap.end())
+ ReflectVal = Iter->second;
+ Call->replaceAllUsesWith(ConstantInt::get(Call->getType(), ReflectVal));
+ ToRemove.push_back(Call);
}
- ReflectFunction = M.getFunction(NVVM_REFLECT_FUNCTION);
- // If reflect function is not used, then there will be
- // no entry in the module.
- if (ReflectFunction != 0)
- Res |= handleFunction(ReflectFunction);
+ for (Instruction *I : ToRemove)
+ I->eraseFromParent();
- return Res;
+ return ToRemove.size() > 0;
}
More information about the llvm-commits
mailing list