Home | History | Annotate | Download | only in NVPTX 
      1 //===- NVPTXLowerAggrCopies.cpp - ------------------------------*- C++ -*--===//
      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 // Lower aggregate copies, memset, memcpy, memmov intrinsics into loops when
     10 // the size is large or is not a compile-time constant.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "NVPTXLowerAggrCopies.h"
     15 #include "llvm/IR/Constants.h"
     16 #include "llvm/IR/DataLayout.h"
     17 #include "llvm/IR/Function.h"
     18 #include "llvm/IR/IRBuilder.h"
     19 #include "llvm/IR/Instructions.h"
     20 #include "llvm/IR/IntrinsicInst.h"
     21 #include "llvm/IR/Intrinsics.h"
     22 #include "llvm/IR/LLVMContext.h"
     23 #include "llvm/IR/Module.h"
     24 #include "llvm/Support/InstIterator.h"
     25 
     26 using namespace llvm;
     27 
     28 namespace llvm {
     29 FunctionPass *createLowerAggrCopies();
     30 }
     31 
     32 char NVPTXLowerAggrCopies::ID = 0;
     33 
     34 // Lower MemTransferInst or load-store pair to loop
     35 static void convertTransferToLoop(Instruction *splitAt, Value *srcAddr,
     36                                   Value *dstAddr, Value *len,
     37                                   //unsigned numLoads,
     38                                   bool srcVolatile, bool dstVolatile,
     39                                   LLVMContext &Context, Function &F) {
     40   Type *indType = len->getType();
     41 
     42   BasicBlock *origBB = splitAt->getParent();
     43   BasicBlock *newBB = splitAt->getParent()->splitBasicBlock(splitAt, "split");
     44   BasicBlock *loopBB = BasicBlock::Create(Context, "loadstoreloop", &F, newBB);
     45 
     46   origBB->getTerminator()->setSuccessor(0, loopBB);
     47   IRBuilder<> builder(origBB, origBB->getTerminator());
     48 
     49   // srcAddr and dstAddr are expected to be pointer types,
     50   // so no check is made here.
     51   unsigned srcAS =
     52       dyn_cast<PointerType>(srcAddr->getType())->getAddressSpace();
     53   unsigned dstAS =
     54       dyn_cast<PointerType>(dstAddr->getType())->getAddressSpace();
     55 
     56   // Cast pointers to (char *)
     57   srcAddr = builder.CreateBitCast(srcAddr, Type::getInt8PtrTy(Context, srcAS));
     58   dstAddr = builder.CreateBitCast(dstAddr, Type::getInt8PtrTy(Context, dstAS));
     59 
     60   IRBuilder<> loop(loopBB);
     61   // The loop index (ind) is a phi node.
     62   PHINode *ind = loop.CreatePHI(indType, 0);
     63   // Incoming value for ind is 0
     64   ind->addIncoming(ConstantInt::get(indType, 0), origBB);
     65 
     66   // load from srcAddr+ind
     67   Value *val = loop.CreateLoad(loop.CreateGEP(srcAddr, ind), srcVolatile);
     68   // store at dstAddr+ind
     69   loop.CreateStore(val, loop.CreateGEP(dstAddr, ind), dstVolatile);
     70 
     71   // The value for ind coming from backedge is (ind + 1)
     72   Value *newind = loop.CreateAdd(ind, ConstantInt::get(indType, 1));
     73   ind->addIncoming(newind, loopBB);
     74 
     75   loop.CreateCondBr(loop.CreateICmpULT(newind, len), loopBB, newBB);
     76 }
     77 
     78 // Lower MemSetInst to loop
     79 static void convertMemSetToLoop(Instruction *splitAt, Value *dstAddr,
     80                                 Value *len, Value *val, LLVMContext &Context,
     81                                 Function &F) {
     82   BasicBlock *origBB = splitAt->getParent();
     83   BasicBlock *newBB = splitAt->getParent()->splitBasicBlock(splitAt, "split");
     84   BasicBlock *loopBB = BasicBlock::Create(Context, "loadstoreloop", &F, newBB);
     85 
     86   origBB->getTerminator()->setSuccessor(0, loopBB);
     87   IRBuilder<> builder(origBB, origBB->getTerminator());
     88 
     89   unsigned dstAS =
     90       dyn_cast<PointerType>(dstAddr->getType())->getAddressSpace();
     91 
     92   // Cast pointer to the type of value getting stored
     93   dstAddr = builder.CreateBitCast(dstAddr,
     94                                   PointerType::get(val->getType(), dstAS));
     95 
     96   IRBuilder<> loop(loopBB);
     97   PHINode *ind = loop.CreatePHI(len->getType(), 0);
     98   ind->addIncoming(ConstantInt::get(len->getType(), 0), origBB);
     99 
    100   loop.CreateStore(val, loop.CreateGEP(dstAddr, ind), false);
    101 
    102   Value *newind = loop.CreateAdd(ind, ConstantInt::get(len->getType(), 1));
    103   ind->addIncoming(newind, loopBB);
    104 
    105   loop.CreateCondBr(loop.CreateICmpULT(newind, len), loopBB, newBB);
    106 }
    107 
    108 bool NVPTXLowerAggrCopies::runOnFunction(Function &F) {
    109   SmallVector<LoadInst *, 4> aggrLoads;
    110   SmallVector<MemTransferInst *, 4> aggrMemcpys;
    111   SmallVector<MemSetInst *, 4> aggrMemsets;
    112 
    113   DataLayout *TD = &getAnalysis<DataLayout>();
    114   LLVMContext &Context = F.getParent()->getContext();
    115 
    116   //
    117   // Collect all the aggrLoads, aggrMemcpys and addrMemsets.
    118   //
    119   //const BasicBlock *firstBB = &F.front();  // first BB in F
    120   for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) {
    121     //BasicBlock *bb = BI;
    122     for (BasicBlock::iterator II = BI->begin(), IE = BI->end(); II != IE;
    123         ++II) {
    124       if (LoadInst * load = dyn_cast<LoadInst>(II)) {
    125 
    126         if (load->hasOneUse() == false) continue;
    127 
    128         if (TD->getTypeStoreSize(load->getType()) < MaxAggrCopySize) continue;
    129 
    130         User *use = *(load->use_begin());
    131         if (StoreInst * store = dyn_cast<StoreInst>(use)) {
    132           if (store->getOperand(0) != load) //getValueOperand
    133           continue;
    134           aggrLoads.push_back(load);
    135         }
    136       } else if (MemTransferInst * intr = dyn_cast<MemTransferInst>(II)) {
    137         Value *len = intr->getLength();
    138         // If the number of elements being copied is greater
    139         // than MaxAggrCopySize, lower it to a loop
    140         if (ConstantInt * len_int = dyn_cast < ConstantInt > (len)) {
    141           if (len_int->getZExtValue() >= MaxAggrCopySize) {
    142             aggrMemcpys.push_back(intr);
    143           }
    144         } else {
    145           // turn variable length memcpy/memmov into loop
    146           aggrMemcpys.push_back(intr);
    147         }
    148       } else if (MemSetInst * memsetintr = dyn_cast<MemSetInst>(II)) {
    149         Value *len = memsetintr->getLength();
    150         if (ConstantInt * len_int = dyn_cast<ConstantInt>(len)) {
    151           if (len_int->getZExtValue() >= MaxAggrCopySize) {
    152             aggrMemsets.push_back(memsetintr);
    153           }
    154         } else {
    155           // turn variable length memset into loop
    156           aggrMemsets.push_back(memsetintr);
    157         }
    158       }
    159     }
    160   }
    161   if ((aggrLoads.size() == 0) && (aggrMemcpys.size() == 0)
    162       && (aggrMemsets.size() == 0)) return false;
    163 
    164   //
    165   // Do the transformation of an aggr load/copy/set to a loop
    166   //
    167   for (unsigned i = 0, e = aggrLoads.size(); i != e; ++i) {
    168     LoadInst *load = aggrLoads[i];
    169     StoreInst *store = dyn_cast<StoreInst>(*load->use_begin());
    170     Value *srcAddr = load->getOperand(0);
    171     Value *dstAddr = store->getOperand(1);
    172     unsigned numLoads = TD->getTypeStoreSize(load->getType());
    173     Value *len = ConstantInt::get(Type::getInt32Ty(Context), numLoads);
    174 
    175     convertTransferToLoop(store, srcAddr, dstAddr, len, load->isVolatile(),
    176                           store->isVolatile(), Context, F);
    177 
    178     store->eraseFromParent();
    179     load->eraseFromParent();
    180   }
    181 
    182   for (unsigned i = 0, e = aggrMemcpys.size(); i != e; ++i) {
    183     MemTransferInst *cpy = aggrMemcpys[i];
    184     Value *len = cpy->getLength();
    185     // llvm 2.7 version of memcpy does not have volatile
    186     // operand yet. So always making it non-volatile
    187     // optimistically, so that we don't see unnecessary
    188     // st.volatile in ptx
    189     convertTransferToLoop(cpy, cpy->getSource(), cpy->getDest(), len, false,
    190                           false, Context, F);
    191     cpy->eraseFromParent();
    192   }
    193 
    194   for (unsigned i = 0, e = aggrMemsets.size(); i != e; ++i) {
    195     MemSetInst *memsetinst = aggrMemsets[i];
    196     Value *len = memsetinst->getLength();
    197     Value *val = memsetinst->getValue();
    198     convertMemSetToLoop(memsetinst, memsetinst->getDest(), len, val, Context,
    199                         F);
    200     memsetinst->eraseFromParent();
    201   }
    202 
    203   return true;
    204 }
    205 
    206 FunctionPass *llvm::createLowerAggrCopies() {
    207   return new NVPTXLowerAggrCopies();
    208 }
    209