LCOV - code coverage report
Current view: top level - lib/Target/AMDGPU - AMDGPULowerIntrinsics.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 60 64 93.8 %
Date: 2017-09-14 15:23:50 Functions: 8 10 80.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- AMDGPULowerIntrinsics.cpp -----------------------------------------===//
       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             : 
      10             : #include "AMDGPU.h"
      11             : #include "AMDGPUSubtarget.h"
      12             : #include "llvm/CodeGen/TargetPassConfig.h"
      13             : #include "llvm/Analysis/TargetTransformInfo.h"
      14             : #include "llvm/IR/Constants.h"
      15             : #include "llvm/IR/Instructions.h"
      16             : #include "llvm/IR/IntrinsicInst.h"
      17             : #include "llvm/IR/Module.h"
      18             : #include "llvm/Transforms/Utils/LowerMemIntrinsics.h"
      19             : 
      20             : #define DEBUG_TYPE "amdgpu-lower-intrinsics"
      21             : 
      22             : using namespace llvm;
      23             : 
      24             : namespace {
      25             : 
      26             : const unsigned MaxStaticSize = 1024;
      27             : 
      28        1706 : class AMDGPULowerIntrinsics : public ModulePass {
      29             : private:
      30             :   bool makeLIDRangeMetadata(Function &F) const;
      31             : 
      32             : public:
      33             :   static char ID;
      34             : 
      35        3430 :   AMDGPULowerIntrinsics() : ModulePass(ID) {}
      36             : 
      37             :   bool runOnModule(Module &M) override;
      38             :   bool expandMemIntrinsicUses(Function &F);
      39           0 :   StringRef getPassName() const override {
      40           0 :     return "AMDGPU Lower Intrinsics";
      41             :   }
      42             : 
      43        1706 :   void getAnalysisUsage(AnalysisUsage &AU) const override {
      44        1706 :     AU.addRequired<TargetTransformInfoWrapperPass>();
      45        1706 :   }
      46             : };
      47             : 
      48             : }
      49             : 
      50             : char AMDGPULowerIntrinsics::ID = 0;
      51             : 
      52             : char &llvm::AMDGPULowerIntrinsicsID = AMDGPULowerIntrinsics::ID;
      53             : 
      54      312538 : INITIALIZE_PASS(AMDGPULowerIntrinsics, DEBUG_TYPE, "Lower intrinsics", false,
      55             :                 false)
      56             : 
      57             : // TODO: Should refine based on estimated number of accesses (e.g. does it
      58             : // require splitting based on alignment)
      59             : static bool shouldExpandOperationWithSize(Value *Size) {
      60          98 :   ConstantInt *CI = dyn_cast<ConstantInt>(Size);
      61          98 :   return !CI || (CI->getZExtValue() > MaxStaticSize);
      62             : }
      63             : 
      64          16 : bool AMDGPULowerIntrinsics::expandMemIntrinsicUses(Function &F) {
      65          16 :   Intrinsic::ID ID = F.getIntrinsicID();
      66          16 :   bool Changed = false;
      67             : 
      68         174 :   for (auto I = F.user_begin(), E = F.user_end(); I != E;) {
      69         220 :     Instruction *Inst = cast<Instruction>(*I);
      70         110 :     ++I;
      71             : 
      72         110 :     switch (ID) {
      73         102 :     case Intrinsic::memcpy: {
      74         102 :       auto *Memcpy = cast<MemCpyInst>(Inst);
      75         204 :       if (shouldExpandOperationWithSize(Memcpy->getLength())) {
      76          14 :         Function *ParentFunc = Memcpy->getParent()->getParent();
      77             :         const TargetTransformInfo &TTI =
      78          14 :             getAnalysis<TargetTransformInfoWrapperPass>().getTTI(*ParentFunc);
      79          14 :         expandMemCpyAsLoop(Memcpy, TTI);
      80          14 :         Changed = true;
      81          14 :         Memcpy->eraseFromParent();
      82             :       }
      83             : 
      84             :       break;
      85             :     }
      86           4 :     case Intrinsic::memmove: {
      87           4 :       auto *Memmove = cast<MemMoveInst>(Inst);
      88           8 :       if (shouldExpandOperationWithSize(Memmove->getLength())) {
      89           2 :         expandMemMoveAsLoop(Memmove);
      90           2 :         Changed = true;
      91           2 :         Memmove->eraseFromParent();
      92             :       }
      93             : 
      94             :       break;
      95             :     }
      96           4 :     case Intrinsic::memset: {
      97           4 :       auto *Memset = cast<MemSetInst>(Inst);
      98           8 :       if (shouldExpandOperationWithSize(Memset->getLength())) {
      99           2 :         expandMemSetAsLoop(Memset);
     100           2 :         Changed = true;
     101           2 :         Memset->eraseFromParent();
     102             :       }
     103             : 
     104             :       break;
     105             :     }
     106             :     default:
     107             :       break;
     108             :     }
     109             :   }
     110             : 
     111          16 :   return Changed;
     112             : }
     113             : 
     114         472 : bool AMDGPULowerIntrinsics::makeLIDRangeMetadata(Function &F) const {
     115         472 :   auto *TPC = getAnalysisIfAvailable<TargetPassConfig>();
     116         472 :   if (!TPC)
     117             :     return false;
     118             : 
     119         472 :   const TargetMachine &TM = TPC->getTM<TargetMachine>();
     120         472 :   const AMDGPUSubtarget &ST = TM.getSubtarget<AMDGPUSubtarget>(F);
     121         472 :   bool Changed = false;
     122             : 
     123        6938 :   for (auto *U : F.users()) {
     124        2761 :     auto *CI = dyn_cast<CallInst>(U);
     125           0 :     if (!CI)
     126           0 :       continue;
     127             : 
     128        2761 :     Changed |= ST.makeLIDRangeMetadata(CI);
     129             :   }
     130             :   return Changed;
     131             : }
     132             : 
     133        1706 : bool AMDGPULowerIntrinsics::runOnModule(Module &M) {
     134        1706 :   bool Changed = false;
     135             : 
     136       24908 :   for (Function &F : M) {
     137       19790 :     if (!F.isDeclaration())
     138       16780 :       continue;
     139             : 
     140        3010 :     switch (F.getIntrinsicID()) {
     141          16 :     case Intrinsic::memcpy:
     142             :     case Intrinsic::memmove:
     143             :     case Intrinsic::memset:
     144          16 :       if (expandMemIntrinsicUses(F))
     145           8 :         Changed = true;
     146             :       break;
     147             : 
     148         472 :     case Intrinsic::amdgcn_workitem_id_x:
     149             :     case Intrinsic::r600_read_tidig_x:
     150             :     case Intrinsic::amdgcn_workitem_id_y:
     151             :     case Intrinsic::r600_read_tidig_y:
     152             :     case Intrinsic::amdgcn_workitem_id_z:
     153             :     case Intrinsic::r600_read_tidig_z:
     154             :     case Intrinsic::r600_read_local_size_x:
     155             :     case Intrinsic::r600_read_local_size_y:
     156             :     case Intrinsic::r600_read_local_size_z:
     157         472 :       Changed |= makeLIDRangeMetadata(F);
     158         472 :       break;
     159             : 
     160             :     default:
     161             :       break;
     162             :     }
     163             :   }
     164             : 
     165        1706 :   return Changed;
     166             : }
     167             : 
     168        1712 : ModulePass *llvm::createAMDGPULowerIntrinsicsPass() {
     169        3424 :   return new AMDGPULowerIntrinsics();
     170             : }

Generated by: LCOV version 1.13