[NFC][AMDGPULowerModuleLDSPass] Add const to some variables/parameters

[jmmartinez]

Summary

Moving out some changes not related to the bugfix in https://reviews.llvm.org/D154946

[JonChesterfield]

LG here too, thanks for factoring it out

llvm/lib/Target/AMDGPU/AMDGPULowerModuleLDSPass.cpp

for (Function &F : M.functions()) {
                               /* IgnoreArcAttachedCall */ false)) {
           set_union(VariablesReachableThroughFunctionPointer,
                     direct_map_function[&F]);
         }
     }
 
     auto functionMakesUnknownCall = [&](const Function *F) -> bool {
       assert(!F->isDeclaration());
-      for (CallGraphNode::CallRecord R : *CG[F]) {
+      for (const CallGraphNode::CallRecord &R : *CG[F]) {
         if (!R.second->getFunction()) {
           return true;
         }
       }
       return false;
     };
 
     // Work out which variables are reachable through function calls
for (Function &Func : M.functions()) {
 
       while (!wip.empty()) {
         Function *F = wip.pop_back_val();
 
         // Can accelerate this by referring to transitive map for functions that
         // have already been computed, with more care than this
         set_union(transitive_map_function[&Func], direct_map_function[F]);
 
-        for (CallGraphNode::CallRecord R : *CG[F]) {
+        for (const CallGraphNode::CallRecord &R : *CG[F]) {
           Function *ith = R.second->getFunction();
           if (ith) {
             if (!seen.contains(ith)) {
               seen.insert(ith);
               wip.push_back(ith);
             }
           }
         }
       }
     }
 
     // direct_map_kernel lists which variables are used by the kernel
     // find the variables which are used through a function call
     FunctionVariableMap indirect_map_kernel;
 
     for (Function &Func : M.functions()) {
       if (Func.isDeclaration() || !isKernelLDS(&Func))
         continue;
 
-      for (CallGraphNode::CallRecord R : *CG[&Func]) {
+      for (const CallGraphNode::CallRecord &R : *CG[&Func]) {
         Function *ith = R.second->getFunction();
         if (ith) {
           set_union(indirect_map_kernel[&Func], transitive_map_function[ith]);
         } else {
           set_union(indirect_map_kernel[&Func],
                     VariablesReachableThroughFunctionPointer);
         }
       }
public:
 
   // remap from lds global to a constantexpr gep to where it has been moved to
   // for each kernel
   // an array with an element for each kernel containing where the corresponding
   // variable was remapped to
 
   static Constant *getAddressesOfVariablesInKernel(
       LLVMContext &Ctx, ArrayRef<GlobalVariable *> Variables,
-      DenseMap<GlobalVariable *, Constant *> &LDSVarsToConstantGEP) {
+      const DenseMap<GlobalVariable *, Constant *> &LDSVarsToConstantGEP) {
     // Create a ConstantArray containing the address of each Variable within the
     // kernel corresponding to LDSVarsToConstantGEP, or poison if that kernel
     // does not allocate it
     // TODO: Drop the ptrtoint conversion
 
     Type *I32 = Type::getInt32Ty(Ctx);
 
     ArrayType *KernelOffsetsType = ArrayType::get(I32, Variables.size());
 
     SmallVector<Constant *> Elements;
     for (size_t i = 0; i < Variables.size(); i++) {
       GlobalVariable *GV = Variables[i];
-      if (LDSVarsToConstantGEP.count(GV) != 0) {
-        auto elt = ConstantExpr::getPtrToInt(LDSVarsToConstantGEP[GV], I32);
+      auto ConstantGepIt = LDSVarsToConstantGEP.find(GV);
+      if (ConstantGepIt != LDSVarsToConstantGEP.end()) {
+        auto elt = ConstantExpr::getPtrToInt(ConstantGepIt->second, I32);
         Elements.push_back(elt);
       } else {
         Elements.push_back(PoisonValue::get(I32));
       }
     }
     return ConstantArray::get(KernelOffsetsType, Elements);
   }
 
bool runOnModule(Module &M) override {
     partitionVariablesIntoIndirectStrategies(
         M, LDSUsesInfo, LDSToKernelsThatNeedToAccessItIndirectly,
         ModuleScopeVariables, TableLookupVariables, KernelAccessVariables,
         DynamicVariables);
 
     // If the kernel accesses a variable that is going to be stored in the
     // module instance through a call then that kernel needs to allocate the
     // module instance
-    DenseSet<Function *> KernelsThatAllocateModuleLDS =
+    const DenseSet<Function *> KernelsThatAllocateModuleLDS =
         kernelsThatIndirectlyAccessAnyOfPassedVariables(M, LDSUsesInfo,
                                                         ModuleScopeVariables);
-    DenseSet<Function *> KernelsThatAllocateTableLDS =
+    const DenseSet<Function *> KernelsThatAllocateTableLDS =
         kernelsThatIndirectlyAccessAnyOfPassedVariables(M, LDSUsesInfo,
                                                         TableLookupVariables);
 
-    DenseSet<Function *> KernelsThatIndirectlyAllocateDynamicLDS =
+    const DenseSet<Function *> KernelsThatIndirectlyAllocateDynamicLDS =
         kernelsThatIndirectlyAccessAnyOfPassedVariables(M, LDSUsesInfo,
                                                         DynamicVariables);
 
     GlobalVariable *MaybeModuleScopeStruct = lowerModuleScopeStructVariables(
         M, ModuleScopeVariables, KernelsThatAllocateModuleLDS);
 
     DenseMap<Function *, LDSVariableReplacement> KernelToReplacement =
         lowerKernelScopeStructVariables(M, LDSUsesInfo, ModuleScopeVariables,
// addresses.
         //  kernel instance
         //  alignment padding
         //  dynamic lds variables
         //}
 
         const bool AllocateModuleScopeStruct =
             MaybeModuleScopeStruct && !canElideModuleLDS(Func);
 
+        auto Replacement = KernelToReplacement.find(&Func);
         const bool AllocateKernelScopeStruct =
-            KernelToReplacement.contains(&Func);
+            Replacement != KernelToReplacement.end();
 
         const bool AllocateDynamicVariable =
             KernelToCreatedDynamicLDS.contains(&Func);
 
         uint32_t Offset = 0;
 
         if (AllocateModuleScopeStruct) {
           // Allocated at zero, recorded once on construction, not once per
           // kernel
           Offset += DL.getTypeAllocSize(MaybeModuleScopeStruct->getValueType());
         }
 
         if (AllocateKernelScopeStruct) {
-          GlobalVariable *KernelStruct = KernelToReplacement[&Func].SGV;
+          GlobalVariable *KernelStruct = Replacement->second.SGV;
 
           Offset = alignTo(Offset, AMDGPU::getAlign(DL, KernelStruct));
 
           recordLDSAbsoluteAddress(&M, KernelStruct, Offset);
 
           Offset += DL.getTypeAllocSize(KernelStruct->getValueType());
 
         }