NVPTXGenericToNVVM.cpp [plain text]
#include "NVPTX.h"
#include "MCTargetDesc/NVPTXBaseInfo.h"
#include "NVPTXUtilities.h"
#include "llvm/CodeGen/MachineFunctionAnalysis.h"
#include "llvm/CodeGen/ValueTypes.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Operator.h"
#include "llvm/IR/ValueMap.h"
#include "llvm/PassManager.h"
#include "llvm/Transforms/Utils/ValueMapper.h"
using namespace llvm;
namespace llvm {
void initializeGenericToNVVMPass(PassRegistry &);
}
namespace {
class GenericToNVVM : public ModulePass {
public:
static char ID;
GenericToNVVM() : ModulePass(ID) {}
bool runOnModule(Module &M) override;
void getAnalysisUsage(AnalysisUsage &AU) const override {}
private:
Value *getOrInsertCVTA(Module *M, Function *F, GlobalVariable *GV,
IRBuilder<> &Builder);
Value *remapConstant(Module *M, Function *F, Constant *C,
IRBuilder<> &Builder);
Value *remapConstantVectorOrConstantAggregate(Module *M, Function *F,
Constant *C,
IRBuilder<> &Builder);
Value *remapConstantExpr(Module *M, Function *F, ConstantExpr *C,
IRBuilder<> &Builder);
void remapNamedMDNode(ValueToValueMapTy &VM, NamedMDNode *N);
typedef ValueMap<GlobalVariable *, GlobalVariable *> GVMapTy;
typedef ValueMap<Constant *, Value *> ConstantToValueMapTy;
GVMapTy GVMap;
ConstantToValueMapTy ConstantToValueMap;
};
}
char GenericToNVVM::ID = 0;
ModulePass *llvm::createGenericToNVVMPass() { return new GenericToNVVM(); }
INITIALIZE_PASS(
GenericToNVVM, "generic-to-nvvm",
"Ensure that the global variables are in the global address space", false,
false)
bool GenericToNVVM::runOnModule(Module &M) {
for (Module::global_iterator I = M.global_begin(), E = M.global_end();
I != E;) {
GlobalVariable *GV = I++;
if (GV->getType()->getAddressSpace() == llvm::ADDRESS_SPACE_GENERIC &&
!llvm::isTexture(*GV) && !llvm::isSurface(*GV) &&
!llvm::isSampler(*GV) && !GV->getName().startswith("llvm.")) {
GlobalVariable *NewGV = new GlobalVariable(
M, GV->getType()->getElementType(), GV->isConstant(),
GV->getLinkage(),
GV->hasInitializer() ? GV->getInitializer() : nullptr,
"", GV, GV->getThreadLocalMode(), llvm::ADDRESS_SPACE_GLOBAL);
NewGV->copyAttributesFrom(GV);
GVMap[GV] = NewGV;
}
}
if (GVMap.empty()) {
return false;
}
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
if (I->isDeclaration()) {
continue;
}
IRBuilder<> Builder(I->getEntryBlock().getFirstNonPHIOrDbg());
for (Function::iterator BBI = I->begin(), BBE = I->end(); BBI != BBE;
++BBI) {
for (BasicBlock::iterator II = BBI->begin(), IE = BBI->end(); II != IE;
++II) {
for (unsigned i = 0, e = II->getNumOperands(); i < e; ++i) {
Value *Operand = II->getOperand(i);
if (isa<Constant>(Operand)) {
II->setOperand(
i, remapConstant(&M, I, cast<Constant>(Operand), Builder));
}
}
}
}
ConstantToValueMap.clear();
}
ValueToValueMapTy VM;
for (auto I = GVMap.begin(), E = GVMap.end(); I != E; ++I)
VM[I->first] = I->second;
for (Module::named_metadata_iterator I = M.named_metadata_begin(),
E = M.named_metadata_end();
I != E; I++) {
remapNamedMDNode(VM, I);
}
for (GVMapTy::iterator I = GVMap.begin(), E = GVMap.end(); I != E;) {
GlobalVariable *GV = I->first;
GlobalVariable *NewGV = I->second;
auto Next = std::next(I);
GVMap.erase(I);
I = Next;
Constant *BitCastNewGV = ConstantExpr::getPointerCast(NewGV, GV->getType());
GV->replaceAllUsesWith(BitCastNewGV);
std::string Name = GV->getName();
GV->eraseFromParent();
NewGV->setName(Name);
}
assert(GVMap.empty() && "Expected it to be empty by now");
return true;
}
Value *GenericToNVVM::getOrInsertCVTA(Module *M, Function *F,
GlobalVariable *GV,
IRBuilder<> &Builder) {
PointerType *GVType = GV->getType();
Value *CVTA = nullptr;
EVT ExtendedGVType = EVT::getEVT(GVType->getElementType(), true);
if (!ExtendedGVType.isInteger() && !ExtendedGVType.isFloatingPoint()) {
LLVMContext &Context = M->getContext();
unsigned int AddrSpace = GVType->getAddressSpace();
Type *DestTy = PointerType::get(Type::getInt8Ty(Context), AddrSpace);
CVTA = Builder.CreateBitCast(GV, DestTy, "cvta");
Type *ResultType =
PointerType::get(Type::getInt8Ty(Context), llvm::ADDRESS_SPACE_GENERIC);
SmallVector<Type *, 2> ParamTypes;
ParamTypes.push_back(ResultType);
ParamTypes.push_back(DestTy);
Function *CVTAFunction = Intrinsic::getDeclaration(
M, Intrinsic::nvvm_ptr_global_to_gen, ParamTypes);
CVTA = Builder.CreateCall(CVTAFunction, CVTA, "cvta");
DestTy =
PointerType::get(GVType->getElementType(), llvm::ADDRESS_SPACE_GENERIC);
CVTA = Builder.CreateBitCast(CVTA, DestTy, "cvta");
} else {
SmallVector<Type *, 2> ParamTypes;
ParamTypes.push_back(PointerType::get(GVType->getElementType(),
llvm::ADDRESS_SPACE_GENERIC));
ParamTypes.push_back(GVType);
Function *CVTAFunction = Intrinsic::getDeclaration(
M, Intrinsic::nvvm_ptr_global_to_gen, ParamTypes);
CVTA = Builder.CreateCall(CVTAFunction, GV, "cvta");
}
return CVTA;
}
Value *GenericToNVVM::remapConstant(Module *M, Function *F, Constant *C,
IRBuilder<> &Builder) {
ConstantToValueMapTy::iterator CTII = ConstantToValueMap.find(C);
if (CTII != ConstantToValueMap.end()) {
return CTII->second;
}
Value *NewValue = C;
if (isa<GlobalVariable>(C)) {
GVMapTy::iterator I = GVMap.find(cast<GlobalVariable>(C));
if (I != GVMap.end()) {
NewValue = getOrInsertCVTA(M, F, I->second, Builder);
}
} else if (isa<ConstantVector>(C) || isa<ConstantArray>(C) ||
isa<ConstantStruct>(C)) {
NewValue = remapConstantVectorOrConstantAggregate(M, F, C, Builder);
} else if (isa<ConstantExpr>(C)) {
NewValue = remapConstantExpr(M, F, cast<ConstantExpr>(C), Builder);
}
ConstantToValueMap[C] = NewValue;
return NewValue;
}
Value *GenericToNVVM::remapConstantVectorOrConstantAggregate(
Module *M, Function *F, Constant *C, IRBuilder<> &Builder) {
bool OperandChanged = false;
SmallVector<Value *, 4> NewOperands;
unsigned NumOperands = C->getNumOperands();
for (unsigned i = 0; i < NumOperands; ++i) {
Value *Operand = C->getOperand(i);
Value *NewOperand = remapConstant(M, F, cast<Constant>(Operand), Builder);
OperandChanged |= Operand != NewOperand;
NewOperands.push_back(NewOperand);
}
if (!OperandChanged) {
return C;
}
Value *NewValue = UndefValue::get(C->getType());
if (isa<ConstantVector>(C)) {
for (unsigned i = 0; i < NumOperands; ++i) {
Value *Idx = ConstantInt::get(Type::getInt32Ty(M->getContext()), i);
NewValue = Builder.CreateInsertElement(NewValue, NewOperands[i], Idx);
}
} else {
for (unsigned i = 0; i < NumOperands; ++i) {
NewValue =
Builder.CreateInsertValue(NewValue, NewOperands[i], makeArrayRef(i));
}
}
return NewValue;
}
Value *GenericToNVVM::remapConstantExpr(Module *M, Function *F, ConstantExpr *C,
IRBuilder<> &Builder) {
bool OperandChanged = false;
SmallVector<Value *, 4> NewOperands;
unsigned NumOperands = C->getNumOperands();
for (unsigned i = 0; i < NumOperands; ++i) {
Value *Operand = C->getOperand(i);
Value *NewOperand = remapConstant(M, F, cast<Constant>(Operand), Builder);
OperandChanged |= Operand != NewOperand;
NewOperands.push_back(NewOperand);
}
if (!OperandChanged) {
return C;
}
unsigned Opcode = C->getOpcode();
switch (Opcode) {
case Instruction::ICmp:
return Builder.CreateICmp(CmpInst::Predicate(C->getPredicate()),
NewOperands[0], NewOperands[1]);
case Instruction::FCmp:
assert(false && "Address space conversion should have no effect "
"on float point CompareConstantExpr (fcmp)!");
return C;
case Instruction::ExtractElement:
return Builder.CreateExtractElement(NewOperands[0], NewOperands[1]);
case Instruction::InsertElement:
return Builder.CreateInsertElement(NewOperands[0], NewOperands[1],
NewOperands[2]);
case Instruction::ShuffleVector:
return Builder.CreateShuffleVector(NewOperands[0], NewOperands[1],
NewOperands[2]);
case Instruction::ExtractValue:
return Builder.CreateExtractValue(NewOperands[0], C->getIndices());
case Instruction::InsertValue:
return Builder.CreateInsertValue(NewOperands[0], NewOperands[1],
C->getIndices());
case Instruction::GetElementPtr:
return cast<GEPOperator>(C)->isInBounds()
? Builder.CreateGEP(
NewOperands[0],
makeArrayRef(&NewOperands[1], NumOperands - 1))
: Builder.CreateInBoundsGEP(
NewOperands[0],
makeArrayRef(&NewOperands[1], NumOperands - 1));
case Instruction::Select:
return Builder.CreateSelect(NewOperands[0], NewOperands[1], NewOperands[2]);
default:
if (Instruction::isBinaryOp(Opcode)) {
return Builder.CreateBinOp(Instruction::BinaryOps(C->getOpcode()),
NewOperands[0], NewOperands[1]);
}
if (Instruction::isCast(Opcode)) {
return Builder.CreateCast(Instruction::CastOps(C->getOpcode()),
NewOperands[0], C->getType());
}
assert(false && "GenericToNVVM encountered an unsupported ConstantExpr");
return C;
}
}
void GenericToNVVM::remapNamedMDNode(ValueToValueMapTy &VM, NamedMDNode *N) {
bool OperandChanged = false;
SmallVector<MDNode *, 16> NewOperands;
unsigned NumOperands = N->getNumOperands();
for (unsigned i = 0; i < NumOperands; ++i) {
MDNode *Operand = N->getOperand(i);
MDNode *NewOperand = MapMetadata(Operand, VM);
OperandChanged |= Operand != NewOperand;
NewOperands.push_back(NewOperand);
}
if (!OperandChanged) {
return;
}
N->dropAllReferences();
for (SmallVectorImpl<MDNode *>::iterator I = NewOperands.begin(),
E = NewOperands.end();
I != E; ++I) {
N->addOperand(*I);
}
}