[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

1287

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>
 
for (auto &GV : M.globals())
         LDSGlobals.push_back(&GV);
 
     return convertUsersOfConstantsToInstructions(LDSGlobals);
   }
 
 public:
   static char ID;
 
-  AMDGPULowerModuleLDS() : ModulePass(ID) {
+  AMDGPULowerModuleLDS()
+      : ModulePass(ID)
+
+  {
+    // 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?
+
+    TargetPassConfig &TPC = getAnalysis<TargetPassConfig>();
+    const TargetMachine &TM = TPC.getTM<TargetMachine>();
+    (void)TM;
+
     initializeAMDGPULowerModuleLDSPass(*PassRegistry::getPassRegistry());
   }
 
   using FunctionVariableMap = DenseMap<Function *, DenseSet<GlobalVariable *>>;
 
   using VariableFunctionMap = DenseMap<GlobalVariable *, DenseSet<Function *>>;
 
   static void getUsesOfLDSByFunction(CallGraph const &CG, Module &M,
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 {
+    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 &) {
   return AMDGPULowerModuleLDS().runOnModule(M) ? PreservedAnalyses::none()
                                                : PreservedAnalyses::all();
 }