[NFC][AMDGPULowerModuleLDSPass] Use shorter APIs in markUsedByKernel

[jmmartinez]

Summary

• Use shorter versions of the LLVM API

[JonChesterfield]

Nice!

[foad]

llvm/lib/Target/AMDGPU/AMDGPULowerModuleLDSPass.cpp

303

Don't need , ""

[JonChesterfield]

These use annotations are a property of how PromoteAlloca is currently implemented, not essential to the lowering process. I'm hoping to get rid of them at some point in the future. Cleaner implementation until then is good.

[jmmartinez]

• Remove "" from CreateCall

llvm/lib/Target/AMDGPU/AMDGPULowerModuleLDSPass.cpp

removeLocalVarsFromUsedLists(Module &M,
 
     removeFromUsedLists(
         M, [&LocalVarsSet](Constant *C) { return LocalVarsSet.count(C); });
 
     for (GlobalVariable *LocalVar : LocalVars)
       LocalVar->removeDeadConstantUsers();
   }
 
-  static void markUsedByKernel(IRBuilder<> &Builder, Function *Func,
-                               GlobalVariable *SGV) {
+  static void markUsedByKernel(Function *Func, GlobalVariable *SGV) {
     // The llvm.amdgcn.module.lds instance is implicitly used by all kernels
     // that might call a function which accesses a field within it. This is
     // presently approximated to 'all kernels' if there are any such functions
     // in the module. This implicit use is redefined as an explicit use here so
     // that later passes, specifically PromoteAlloca, account for the required
     // memory without any knowledge of this transform.
 
     // An operand bundle on llvm.donothing works because the call instruction
     // survives until after the last pass that needs to account for LDS. It is
     // better than inline asm as the latter survives until the end of codegen. A
     // totally robust solution would be a function with the same semantics as
     // llvm.donothing that takes a pointer to the instance and is lowered to a
     // no-op after LDS is allocated, but that is not presently necessary.
 
     // This intrinsic is eliminated shortly before instruction selection. It
     // does not suffice to indicate to ISel that a given global which is not
     // immediately used by the kernel must still be allocated by it. An
     // equivalent target specific intrinsic which lasts until immediately after
     // codegen would suffice for that, but one would still need to ensure that
     // the variables are allocated in the anticpated order.
-
-    LLVMContext &Ctx = Func->getContext();
-
-    Builder.SetInsertPoint(Func->getEntryBlock().getFirstNonPHI());
-
-    FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx), {});
+    IRBuilder<> Builder(Func->getEntryBlock().getFirstNonPHI());
 
     Function *Decl =
         Intrinsic::getDeclaration(Func->getParent(), Intrinsic::donothing, {});
 
-    Value *UseInstance[1] = {Builder.CreateInBoundsGEP(
-        SGV->getValueType(), SGV, ConstantInt::get(Type::getInt32Ty(Ctx), 0))};
+    Value *UseInstance[1] = {
+        Builder.CreateConstInBoundsGEP1_32(SGV->getValueType(), SGV, 0)};
 
-    Builder.CreateCall(FTy, Decl, {},
-                       {OperandBundleDefT<Value *>("ExplicitUse", UseInstance)},
-                       "");
+    Builder.CreateCall(
+        Decl, {}, {OperandBundleDefT<Value *>("ExplicitUse", UseInstance)});
   }
 
   static bool eliminateConstantExprUsesOfLDSFromAllInstructions(Module &M) {
     // Constants are uniqued within LLVM. A ConstantExpr referring to a LDS
     // global may have uses from multiple different functions as a result.
     // This pass specialises LDS variables with respect to the kernel that
     // allocates them.
 
replaceLDSVariablesWithStruct(
           Function *F = I->getFunction();
           return !isKernelLDS(F);
         });
 
     // Replace uses of module scope variable from kernel functions that
     // allocate the module scope variable, otherwise leave them unchanged
     // Record on each kernel whether the module scope global is used by it
 
-    IRBuilder<> Builder(Ctx);
-
     for (Function &Func : M.functions()) {
       if (Func.isDeclaration() || !isKernelLDS(&Func))
         continue;
 
       if (KernelsThatAllocateModuleLDS.contains(&Func)) {
         replaceLDSVariablesWithStruct(
             M, ModuleScopeVariables, ModuleScopeReplacement, [&](Use &U) {
               Instruction *I = dyn_cast<Instruction>(U.getUser());
               if (!I) {
                 return false;
               }
               Function *F = I->getFunction();
               return F == &Func;
             });
 
-        markUsedByKernel(Builder, &Func, ModuleScopeReplacement.SGV);
+        markUsedByKernel(&Func, ModuleScopeReplacement.SGV);
       }
     }
 
     return ModuleScopeReplacement.SGV;
   }
 
   static DenseMap<Function *, LDSVariableReplacement>
   lowerKernelScopeStructVariables(
       Module &M, LDSUsesInfoTy &LDSUsesInfo,
       DenseSet<GlobalVariable *> const &ModuleScopeVariables,
       DenseSet<Function *> const &KernelsThatAllocateModuleLDS,
       GlobalVariable *MaybeModuleScopeStruct) {
 
     // Create a struct for each kernel for the non-module-scope variables.
 
-    IRBuilder<> Builder(M.getContext());
     DenseMap<Function *, LDSVariableReplacement> KernelToReplacement;
     for (Function &Func : M.functions()) {
       if (Func.isDeclaration() || !isKernelLDS(&Func))
         continue;
 
       DenseSet<GlobalVariable *> KernelUsedVariables;
       // Allocating variables that are used directly in this struct to get
       // alignment aware allocation and predictable frame size.
for (Function &Func : M.functions()) {
           createLDSVariableReplacement(M, VarName, KernelUsedVariables);
 
       // If any indirect uses, create a direct use to ensure allocation
       // TODO: Simpler to unconditionally mark used but that regresses
       // codegen in test/CodeGen/AMDGPU/noclobber-barrier.ll
       auto Accesses = LDSUsesInfo.indirect_access.find(&Func);
       if ((Accesses != LDSUsesInfo.indirect_access.end()) &&
           !Accesses->second.empty())
-        markUsedByKernel(Builder, &Func, Replacement.SGV);
+        markUsedByKernel(&Func, Replacement.SGV);
 
       // remove preserves existing codegen
       removeLocalVarsFromUsedLists(M, KernelUsedVariables);
       KernelToReplacement[&Func] = Replacement;
 
       // Rewrite uses within kernel to the new struct
       replaceLDSVariablesWithStruct(
           M, KernelUsedVariables, Replacement, [&Func](Use &U) {
if (!KernelsThatIndirectlyAllocateDynamicLDS.empty()) {
             report_fatal_error("Anonymous kernels cannot use LDS variables");
           }
 
           GlobalVariable *N =
               buildRepresentativeDynamicLDSInstance(M, LDSUsesInfo, func);
 
           KernelToCreatedDynamicLDS[func] = N;
 
-          markUsedByKernel(Builder, func, N);
+          markUsedByKernel(func, N);
 
           auto emptyCharArray = ArrayType::get(Type::getInt8Ty(Ctx), 0);
           auto GEP = ConstantExpr::getGetElementPtr(
               emptyCharArray, N, ConstantInt::get(I32, 0), true);
           newDynamicLDS.push_back(ConstantExpr::getPtrToInt(GEP, I32));
         } else {
           newDynamicLDS.push_back(PoisonValue::get(I32));
         }