[wip/help] Access TargetMachine without crashing

[JonChesterfield]

Summary

Trying to access the TargetMachine from a module pass.

I think I've rediscovered https://llvm.org/docs/NewPassManager.html#status-of-the-new-and-legacy-pass-managers.

This is a module pass run from the backend. It looks like I have to choose between access to TargetPassConfig and allowing the new pass manager.

That is, the pass can be run using the new pass manager as that was encouraged during review, but it looks like I'll have to delete that if I want target information.

Cargo culting is not working. What other state do I need to set?
Tagging various people. I miss the mailing list. Discord won't let me in.

So far I've worked out that the pass constructor can't call getAnalysis, and doInitialization can, but doInitialization is only called by one of the pass managers.

[JonChesterfield]

• comment

[JonChesterfield]

• doInitialization works for one pass manager and not the other

[JonChesterfield]

llvm/lib/Target/AMDGPU/AMDGPULowerModuleLDSPass.cpp

1318

This is not running on the crashing invocation

[JonChesterfield]

• more confusion

[JonChesterfield]

Pretty sure this is a known limitation of the new pass manager.

[arsenm]

What were you trying to use the target machine for here?

[JonChesterfield]

In D155375#4508222, @arsenm wrote:

What were you trying to use the target machine for here?

I wanted to query the amount of LDS available for the architecture with the plan of setting [min max] frame dimensions on allocations. Working around by leaving max unspecified when unknown, where it is unknown because I couldn't make this ^ patch work. I think it would be possible to only use target machine from the old pass manager but that's a mess. Very tempting to delete the new pass manager code and go down that path, but probably better not to,

[arsenm]

In D155375#4522229, @JonChesterfield wrote:

In D155375#4508222, @arsenm wrote:

What were you trying to use the target machine for here?

I wanted to query the amount of LDS available for the architecture with the plan of setting [min max] frame dimensions on allocations. Working around by leaving max unspecified when unknown, where it is unknown because I couldn't make this ^ patch work. I think it would be possible to only use target machine from the old pass manager but that's a mess. Very tempting to delete the new pass manager code and go down that path, but probably better not to,

You should be able to have the TargetMachine as a member of the pass struct, passed in to the pass constructor in the passbuilder callback

llvm/lib/Target/AMDGPU/AMDGPULowerModuleLDSPass.cpp

 #include "Utils/AMDGPUMemoryUtils.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetOperations.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Analysis/CallGraph.h"
+#include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicsAMDGPU.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/ReplaceConstant.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/OptimizedStructLayout.h"
+#include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 
 #include <tuple>
 #include <vector>
 
 #include <cstdio>
 
static bool eliminateConstantExprUsesOfLDSFromAllInstructions(Module &M) {
     for (auto &GV : M.globals())
       if (AMDGPU::isLDSVariableToLower(GV))
         LDSGlobals.push_back(&GV);
 
     return convertUsersOfConstantsToInstructions(LDSGlobals);
   }
 
 public:
+  TargetMachine *TM = nullptr;
   static char ID;
 
-  AMDGPULowerModuleLDS() : ModulePass(ID) {
+  AMDGPULowerModuleLDS()
+      : ModulePass(ID)
+
+  {
+    fprintf(stderr, "Called LowerModuleLDS constructor\n");
     initializeAMDGPULowerModuleLDSPass(*PassRegistry::getPassRegistry());
+
+    // Asserts
+    // assert(PI && "getAnalysis for unregistered pass!");
+    // Can change to getAnalysisIfAvailable, which asserts
+    // assert(Resolver && "Pass not resident in a PassManager object!");
+    // Thus... how do I get at the TargetMachine from a ModulePass?
+
+#if 0
+    fprintf(stderr, "Constructor\n");
+    // This crashes in old and new pass manager at present
+    auto *TPC = getAnalysisIfAvailable<TargetPassConfig>();
+    fprintf(stderr, "Constructor done\n");
+#endif
   }
 
   using FunctionVariableMap = DenseMap<Function *, DenseSet<GlobalVariable *>>;
 
   using VariableFunctionMap = DenseMap<GlobalVariable *, DenseSet<Function *>>;
 
   static void getUsesOfLDSByFunction(CallGraph const &CG, Module &M,
                                      FunctionVariableMap &kernels,
if (!KernelsThatIndirectlyAllocateDynamicLDS.empty()) {
 
           replaceUseWithTableLookup(M, Builder, table, GV, U, nullptr);
         }
       }
     }
     return KernelToCreatedDynamicLDS;
   }
 
+  bool doInitialization(Module &) override {
+    // When called as -amdgpu-lower-module-lds, this function runs and sets up
+    // TM When called as -passes=amdgpu-lower-module-lds, this function does not
+    // run
+    auto *TPC = getAnalysisIfAvailable<TargetPassConfig>();
+    if (!TPC)
+      report_fatal_error("TargetMachine is required");
+
+    TM = &TPC->getTM<TargetMachine>();
+
+    fprintf(stderr, "doInitialization ran\n");
+    return false;
+  }
+
   bool runOnModule(Module &M) override {
+
+    fprintf(stderr, "calling runOnModule\n");
+
+    auto *TPC = getAnalysisIfAvailable<TargetPassConfig>();
+    if (!TPC)
+      report_fatal_error(
+          "TargetMachine get if available failed in runonmodule");
+
+    if (!TM) {
+      report_fatal_error("TargetMachine is required by runOnModule");
+    }
+
     CallGraph CG = CallGraph(M);
     bool Changed = superAlignLDSGlobals(M);
 
     Changed |= eliminateConstantExprUsesOfLDSFromAllInstructions(M);
 
     Changed = true; // todo: narrow this down
 
     // For each kernel, what variables does it access directly or through
for (auto &GV : make_early_inc_range(M.globals()))
         GV.removeDeadConstantUsers();
         if (GV.use_empty())
           GV.eraseFromParent();
       }
 
     return Changed;
   }
 
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    fprintf(stderr, "Called getAnalysisUsage\n");
+    AU.addRequired<TargetPassConfig>();
+  }
+
 private:
   // Increase the alignment of LDS globals if necessary to maximise the chance
   // that we can use aligned LDS instructions to access them.
   static bool superAlignLDSGlobals(Module &M) {
     const DataLayout &DL = M.getDataLayout();
     bool Changed = false;
     if (!SuperAlignLDSGlobals) {
       return Changed;
private:
   }
 };
 
 } // namespace
 char AMDGPULowerModuleLDS::ID = 0;
 
 char &llvm::AMDGPULowerModuleLDSID = AMDGPULowerModuleLDS::ID;
 
-INITIALIZE_PASS(AMDGPULowerModuleLDS, DEBUG_TYPE,
-                "Lower uses of LDS variables from non-kernel functions", false,
-                false)
+INITIALIZE_PASS_BEGIN(AMDGPULowerModuleLDS, DEBUG_TYPE,
+                      "Lower uses of LDS variables from non-kernel functions",
+                      false, false)
+INITIALIZE_PASS_DEPENDENCY(TargetPassConfig)
+INITIALIZE_PASS_END(AMDGPULowerModuleLDS, DEBUG_TYPE,
+                    "Lower uses of LDS variables from non-kernel functions",
+                    false, false)
 
 ModulePass *llvm::createAMDGPULowerModuleLDSPass() {
   return new AMDGPULowerModuleLDS();
 }
 
 PreservedAnalyses AMDGPULowerModuleLDSPass::run(Module &M,
-                                                ModuleAnalysisManager &) {
+                                                ModuleAnalysisManager &AM) {
+  fprintf(stderr, "LDSPass::run\n");
+  // Docs suggest this, but it doesn't compile
+  // No type named result
+  auto wot = AM.getResult<TargetPassConfig>(M);
   return AMDGPULowerModuleLDS().runOnModule(M) ? PreservedAnalyses::none()
                                                : PreservedAnalyses::all();
 }