1//===-- NVPTXLowerAlloca.cpp - Make alloca to use local memory =====--===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// For all alloca instructions, and add a pair of cast to local address for 10// each of them. For example, 11// 12// %A = alloca i32 13// store i32 0, i32* %A ; emits st.u32 14// 15// will be transformed to 16// 17// %A = alloca i32 18// %Local = addrspacecast i32* %A to i32 addrspace(5)* 19// %Generic = addrspacecast i32 addrspace(5)* %A to i32* 20// store i32 0, i32 addrspace(5)* %Generic ; emits st.local.u32 21// 22// And we will rely on NVPTXInferAddressSpaces to combine the last two 23// instructions. 24// 25//===----------------------------------------------------------------------===// 26 27#include "NVPTX.h" 28#include "NVPTXUtilities.h" 29#include "MCTargetDesc/NVPTXBaseInfo.h" 30#include "llvm/IR/Function.h" 31#include "llvm/IR/Instructions.h" 32#include "llvm/IR/IntrinsicInst.h" 33#include "llvm/IR/Module.h" 34#include "llvm/IR/Type.h" 35#include "llvm/Pass.h" 36 37using namespace llvm; 38 39namespace llvm { 40void initializeNVPTXLowerAllocaPass(PassRegistry &); 41} 42 43namespace { 44class NVPTXLowerAlloca : public FunctionPass { 45 bool runOnFunction(Function &F) override; 46 47public: 48 static char ID; // Pass identification, replacement for typeid 49 NVPTXLowerAlloca() : FunctionPass(ID) {} 50 StringRef getPassName() const override { 51 return "convert address space of alloca'ed memory to local"; 52 } 53}; 54} // namespace 55 56char NVPTXLowerAlloca::ID = 1; 57 58INITIALIZE_PASS(NVPTXLowerAlloca, "nvptx-lower-alloca", 59 "Lower Alloca", false, false) 60 61// ============================================================================= 62// Main function for this pass. 63// ============================================================================= 64bool NVPTXLowerAlloca::runOnFunction(Function &F) { 65 if (skipFunction(F)) 66 return false; 67 68 bool Changed = false; 69 for (auto &BB : F) 70 for (auto &I : BB) { 71 if (auto allocaInst = dyn_cast<AllocaInst>(&I)) { 72 Changed = true; 73 auto ETy = allocaInst->getAllocatedType(); 74 auto LocalAddrTy = PointerType::get(ETy, ADDRESS_SPACE_LOCAL); 75 auto NewASCToLocal = new AddrSpaceCastInst(allocaInst, LocalAddrTy, ""); 76 auto GenericAddrTy = PointerType::get(ETy, ADDRESS_SPACE_GENERIC); 77 auto NewASCToGeneric = 78 new AddrSpaceCastInst(NewASCToLocal, GenericAddrTy, ""); 79 NewASCToLocal->insertAfter(allocaInst); 80 NewASCToGeneric->insertAfter(NewASCToLocal); 81 for (Use &AllocaUse : llvm::make_early_inc_range(allocaInst->uses())) { 82 // Check Load, Store, GEP, and BitCast Uses on alloca and make them 83 // use the converted generic address, in order to expose non-generic 84 // addrspacecast to NVPTXInferAddressSpaces. For other types 85 // of instructions this is unnecessary and may introduce redundant 86 // address cast. 87 auto LI = dyn_cast<LoadInst>(AllocaUse.getUser()); 88 if (LI && LI->getPointerOperand() == allocaInst && 89 !LI->isVolatile()) { 90 LI->setOperand(LI->getPointerOperandIndex(), NewASCToGeneric); 91 continue; 92 } 93 auto SI = dyn_cast<StoreInst>(AllocaUse.getUser()); 94 if (SI && SI->getPointerOperand() == allocaInst && 95 !SI->isVolatile()) { 96 SI->setOperand(SI->getPointerOperandIndex(), NewASCToGeneric); 97 continue; 98 } 99 auto GI = dyn_cast<GetElementPtrInst>(AllocaUse.getUser()); 100 if (GI && GI->getPointerOperand() == allocaInst) { 101 GI->setOperand(GI->getPointerOperandIndex(), NewASCToGeneric); 102 continue; 103 } 104 auto BI = dyn_cast<BitCastInst>(AllocaUse.getUser()); 105 if (BI && BI->getOperand(0) == allocaInst) { 106 BI->setOperand(0, NewASCToGeneric); 107 continue; 108 } 109 } 110 } 111 } 112 return Changed; 113} 114 115FunctionPass *llvm::createNVPTXLowerAllocaPass() { 116 return new NVPTXLowerAlloca(); 117} 118