contrib/llvm-project/llvm/lib/Target/AMDGPU/AMDGPULowerIntrinsics.cpp

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