[AMDGPU] Disable garbage collection passes

[arsenm]

LGTM, not that it should do much since the passes just no-op anyway

llvm/test/CodeGen/AMDGPU/llc-pipeline.ll

692

Why did this move?

[rampitec]

llvm/test/CodeGen/AMDGPU/llc-pipeline.ll

692

This is analysys. The request order has changed.

llvm/include/llvm/CodeGen/Passes.h

namespace llvm {
   /// basic block placement using branch probabilities and block frequency
   /// information.
   extern char &MachineBlockPlacementStatsID;
 
   /// GCLowering Pass - Used by gc.root to perform its default lowering
   /// operations.
   FunctionPass *createGCLoweringPass();
 
+  /// GCLowering Pass - Used by gc.root to perform its default lowering
+  /// operations.
+  extern char &GCLoweringID;
+
   /// ShadowStackGCLowering - Implements the custom lowering mechanism
   /// used by the shadow stack GC.  Only runs on functions which opt in to
   /// the shadow stack collector.
   FunctionPass *createShadowStackGCLoweringPass();
 
+  /// ShadowStackGCLowering - Implements the custom lowering mechanism
+  /// used by the shadow stack GC.
+  extern char &ShadowStackGCLoweringID;
+
   /// GCMachineCodeAnalysis - Target-independent pass to mark safe points
   /// in machine code. Must be added very late during code generation, just
   /// prior to output, and importantly after all CFG transformations (such as
   /// branch folding).
   extern char &GCMachineCodeAnalysisID;
 
   /// Creates a pass to print GC metadata.
   ///

llvm/lib/CodeGen/CodeGen.cpp

void llvm::initializeCodeGen(PassRegistry &Registry) {
   initializeRABasicPass(Registry);
   initializeRAGreedyPass(Registry);
   initializeRegAllocFastPass(Registry);
   initializeRegUsageInfoCollectorPass(Registry);
   initializeRegUsageInfoPropagationPass(Registry);
   initializeRegisterCoalescerPass(Registry);
   initializeRenameIndependentSubregsPass(Registry);
   initializeSafeStackLegacyPassPass(Registry);
+  initializeShadowStackGCLoweringPass(Registry);
   initializeShrinkWrapPass(Registry);
   initializeSjLjEHPreparePass(Registry);
   initializeSlotIndexesPass(Registry);
   initializeStackColoringPass(Registry);
   initializeStackMapLivenessPass(Registry);
   initializeStackProtectorPass(Registry);
   initializeStackSlotColoringPass(Registry);
   initializeStripDebugMachineModulePass(Registry);

llvm/lib/CodeGen/GCRootLowering.cpp

 INITIALIZE_PASS_BEGIN(LowerIntrinsics, "gc-lowering", "GC Lowering", false,
                       false)
 INITIALIZE_PASS_DEPENDENCY(GCModuleInfo)
 INITIALIZE_PASS_END(LowerIntrinsics, "gc-lowering", "GC Lowering", false, false)
 
 FunctionPass *llvm::createGCLoweringPass() { return new LowerIntrinsics(); }
 
 char LowerIntrinsics::ID = 0;
+char &llvm::GCLoweringID = LowerIntrinsics::ID;
 
 LowerIntrinsics::LowerIntrinsics() : FunctionPass(ID) {
   initializeLowerIntrinsicsPass(*PassRegistry::getPassRegistry());
 }
 
 StringRef LowerIntrinsics::getPassName() const {
   return "Lower Garbage Collection Instructions";
 }

llvm/lib/CodeGen/ShadowStackGCLowering.cpp

private:
   static GetElementPtrInst *CreateGEP(LLVMContext &Context, IRBuilder<> &B,
                                       Type *Ty, Value *BasePtr, int Idx1, int Idx2,
                                       const char *Name);
 };
 
 } // end anonymous namespace
 
 char ShadowStackGCLowering::ID = 0;
+char &llvm::ShadowStackGCLoweringID = ShadowStackGCLowering::ID;
 
 INITIALIZE_PASS_BEGIN(ShadowStackGCLowering, DEBUG_TYPE,
                       "Shadow Stack GC Lowering", false, false)
 INITIALIZE_PASS_DEPENDENCY(GCModuleInfo)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_END(ShadowStackGCLowering, DEBUG_TYPE,
                     "Shadow Stack GC Lowering", false, false)
 

llvm/lib/CodeGen/TargetPassConfig.cpp

if (getOptLevel() != CodeGenOpt::None) {
     // target lowering hook.
     if (!DisableMergeICmps)
       addPass(createMergeICmpsLegacyPass());
     addPass(createExpandMemCmpPass());
   }
 
   // Run GC lowering passes for builtin collectors
   // TODO: add a pass insertion point here
-  addPass(createGCLoweringPass());
-  addPass(createShadowStackGCLoweringPass());
+  addPass(&GCLoweringID);
+  addPass(&ShadowStackGCLoweringID);
   addPass(createLowerConstantIntrinsicsPass());
 
   // Make sure that no unreachable blocks are instruction selected.
   addPass(createUnreachableBlockEliminationPass());
 
   // Prepare expensive constants for SelectionDAG.
   if (getOptLevel() != CodeGenOpt::None && !DisableConstantHoisting)
     addPass(createConstantHoistingPass());

llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp

 class AMDGPUPassConfig : public TargetPassConfig {
 public:
   AMDGPUPassConfig(LLVMTargetMachine &TM, PassManagerBase &PM)
     : TargetPassConfig(TM, PM) {
     // Exceptions and StackMaps are not supported, so these passes will never do
     // anything.
     disablePass(&StackMapLivenessID);
     disablePass(&FuncletLayoutID);
+    // Garbage collection is not supported.
+    disablePass(&GCLoweringID);
+    disablePass(&ShadowStackGCLoweringID);
   }
 
   AMDGPUTargetMachine &getAMDGPUTargetMachine() const {
     return getTM<AMDGPUTargetMachine>();
   }
 
   ScheduleDAGInstrs *
   createMachineScheduler(MachineSchedContext *C) const override {

llvm/test/CodeGen/AMDGPU/llc-pipeline.ll

 ; REQUIRES: asserts
 
 ; GCN-O0: Target Library Information
 ; GCN-O0-NEXT: Target Pass Configuration
 ; GCN-O0-NEXT: Machine Module Information
 ; GCN-O0-NEXT: Target Transform Information
 ; GCN-O0-NEXT: Assumption Cache Tracker
 ; GCN-O0-NEXT: Profile summary info
-; GCN-O0-NEXT: Create Garbage Collector Module Metadata
 ; GCN-O0-NEXT: Argument Register Usage Information Storage
+; GCN-O0-NEXT: Create Garbage Collector Module Metadata
 ; GCN-O0-NEXT: Register Usage Information Storage
 ; GCN-O0-NEXT: Machine Branch Probability Analysis
 ; GCN-O0-NEXT:   ModulePass Manager
 ; GCN-O0-NEXT:     Pre-ISel Intrinsic Lowering
 ; GCN-O0-NEXT:     AMDGPU Printf lowering
 ; GCN-O0-NEXT:       FunctionPass Manager
 ; GCN-O0-NEXT:         Dominator Tree Construction
 ; GCN-O0-NEXT:     Fix function bitcasts for AMDGPU
 ; GCN-O0-NEXT:     FunctionPass Manager
 ; GCN-O0-NEXT:       Early propagate attributes from kernels to functions
 ; GCN-O0-NEXT:     AMDGPU Lower Intrinsics
 ; GCN-O0-NEXT:     AMDGPU Inline All Functions
 ; GCN-O0-NEXT:     CallGraph Construction
 ; GCN-O0-NEXT:     Call Graph SCC Pass Manager
 ; GCN-O0-NEXT:       Inliner for always_inline functions
 ; GCN-O0-NEXT:     A No-Op Barrier Pass
 ; GCN-O0-NEXT:     Lower OpenCL enqueued blocks
 ; GCN-O0-NEXT:     Lower uses of LDS variables from non-kernel functions
 ; GCN-O0-NEXT:     FunctionPass Manager
-; GCN-O0-NEXT:     Expand Atomic instructions
-; GCN-O0-NEXT:       Lower Garbage Collection Instructions
-; GCN-O0-NEXT:       Shadow Stack GC Lowering
+; GCN-O0-NEXT:       Expand Atomic instructions
 ; GCN-O0-NEXT:       Lower constant intrinsics
 ; GCN-O0-NEXT:       Remove unreachable blocks from the CFG
 ; GCN-O0-NEXT:       Expand vector predication intrinsics
 ; GCN-O0-NEXT:       Scalarize Masked Memory Intrinsics
 ; GCN-O0-NEXT:       Expand reduction intrinsics
 ; GCN-O0-NEXT:     CallGraph Construction
 ; GCN-O0-NEXT:     Call Graph SCC Pass Manager
 ; GCN-O0-NEXT:       AMDGPU Annotate Kernel Features

 ; GCN-O1-NEXT: Machine Module Information
 ; GCN-O1-NEXT: Target Transform Information
 ; GCN-O1-NEXT: Assumption Cache Tracker
 ; GCN-O1-NEXT: Profile summary info
 ; GCN-O1-NEXT: AMDGPU Address space based Alias Analysis
 ; GCN-O1-NEXT: External Alias Analysis
 ; GCN-O1-NEXT: Type-Based Alias Analysis
 ; GCN-O1-NEXT: Scoped NoAlias Alias Analysis
-; GCN-O1-NEXT: Create Garbage Collector Module Metadata
 ; GCN-O1-NEXT: Argument Register Usage Information Storage
+; GCN-O1-NEXT: Create Garbage Collector Module Metadata
 ; GCN-O1-NEXT: Machine Branch Probability Analysis
 ; GCN-O1-NEXT: Register Usage Information Storage
 ; GCN-O1-NEXT:   ModulePass Manager
 ; GCN-O1-NEXT:     Pre-ISel Intrinsic Lowering
 ; GCN-O1-NEXT:     AMDGPU Printf lowering
 ; GCN-O1-NEXT:       FunctionPass Manager
 ; GCN-O1-NEXT:         Dominator Tree Construction
 ; GCN-O1-NEXT:     Fix function bitcasts for AMDGPU

 ; GCN-O1-NEXT:         Loop Strength Reduction
 ; GCN-O1-NEXT:       Basic Alias Analysis (stateless AA impl)
 ; GCN-O1-NEXT:       Function Alias Analysis Results
 ; GCN-O1-NEXT:       Merge contiguous icmps into a memcmp
 ; GCN-O1-NEXT:       Natural Loop Information
 ; GCN-O1-NEXT:       Lazy Branch Probability Analysis
 ; GCN-O1-NEXT:       Lazy Block Frequency Analysis
 ; GCN-O1-NEXT:       Expand memcmp() to load/stores
-; GCN-O1-NEXT:       Lower Garbage Collection Instructions
-; GCN-O1-NEXT:       Shadow Stack GC Lowering
 ; GCN-O1-NEXT:       Lower constant intrinsics
 ; GCN-O1-NEXT:       Remove unreachable blocks from the CFG
 ; GCN-O1-NEXT:       Natural Loop Information
 ; GCN-O1-NEXT:       Post-Dominator Tree Construction
 ; GCN-O1-NEXT:       Branch Probability Analysis
 ; GCN-O1-NEXT:       Block Frequency Analysis
 ; GCN-O1-NEXT:       Constant Hoisting
 ; GCN-O1-NEXT:       Replace intrinsics with calls to vector library

 ; GCN-O1-OPTS-NEXT: Machine Module Information
 ; GCN-O1-OPTS-NEXT: Target Transform Information
 ; GCN-O1-OPTS-NEXT: Assumption Cache Tracker
 ; GCN-O1-OPTS-NEXT: Profile summary info
 ; GCN-O1-OPTS-NEXT: AMDGPU Address space based Alias Analysis
 ; GCN-O1-OPTS-NEXT: External Alias Analysis
 ; GCN-O1-OPTS-NEXT: Type-Based Alias Analysis
 ; GCN-O1-OPTS-NEXT: Scoped NoAlias Alias Analysis
-; GCN-O1-OPTS-NEXT: Create Garbage Collector Module Metadata
 ; GCN-O1-OPTS-NEXT: Argument Register Usage Information Storage
+; GCN-O1-OPTS-NEXT: Create Garbage Collector Module Metadata
 ; GCN-O1-OPTS-NEXT: Machine Branch Probability Analysis
 ; GCN-O1-OPTS-NEXT: Register Usage Information Storage
 ; GCN-O1-OPTS-NEXT:   ModulePass Manager
 ; GCN-O1-OPTS-NEXT:     Pre-ISel Intrinsic Lowering
 ; GCN-O1-OPTS-NEXT:     AMDGPU Printf lowering
 ; GCN-O1-OPTS-NEXT:       FunctionPass Manager
 ; GCN-O1-OPTS-NEXT:         Dominator Tree Construction
 ; GCN-O1-OPTS-NEXT:     Fix function bitcasts for AMDGPU

 ; GCN-O1-OPTS-NEXT:         Loop Strength Reduction
 ; GCN-O1-OPTS-NEXT:       Basic Alias Analysis (stateless AA impl)
 ; GCN-O1-OPTS-NEXT:       Function Alias Analysis Results
 ; GCN-O1-OPTS-NEXT:       Merge contiguous icmps into a memcmp
 ; GCN-O1-OPTS-NEXT:       Natural Loop Information
 ; GCN-O1-OPTS-NEXT:       Lazy Branch Probability Analysis
 ; GCN-O1-OPTS-NEXT:       Lazy Block Frequency Analysis
 ; GCN-O1-OPTS-NEXT:       Expand memcmp() to load/stores
-; GCN-O1-OPTS-NEXT:       Lower Garbage Collection Instructions
-; GCN-O1-OPTS-NEXT:       Shadow Stack GC Lowering
 ; GCN-O1-OPTS-NEXT:       Lower constant intrinsics
 ; GCN-O1-OPTS-NEXT:       Remove unreachable blocks from the CFG
 ; GCN-O1-OPTS-NEXT:       Natural Loop Information
 ; GCN-O1-OPTS-NEXT:       Post-Dominator Tree Construction
 ; GCN-O1-OPTS-NEXT:       Branch Probability Analysis
 ; GCN-O1-OPTS-NEXT:       Block Frequency Analysis
 ; GCN-O1-OPTS-NEXT:       Constant Hoisting
 ; GCN-O1-OPTS-NEXT:       Replace intrinsics with calls to vector library

 ; GCN-O2-NEXT: Machine Module Information
 ; GCN-O2-NEXT: Target Transform Information
 ; GCN-O2-NEXT: Assumption Cache Tracker
 ; GCN-O2-NEXT: Profile summary info
 ; GCN-O2-NEXT: AMDGPU Address space based Alias Analysis
 ; GCN-O2-NEXT: External Alias Analysis
 ; GCN-O2-NEXT: Type-Based Alias Analysis
 ; GCN-O2-NEXT: Scoped NoAlias Alias Analysis
-; GCN-O2-NEXT: Create Garbage Collector Module Metadata
 ; GCN-O2-NEXT: Argument Register Usage Information Storage
+; GCN-O2-NEXT: Create Garbage Collector Module Metadata
 ; GCN-O2-NEXT: Machine Branch Probability Analysis
 ; GCN-O2-NEXT: Register Usage Information Storage
 ; GCN-O2-NEXT:   ModulePass Manager
 ; GCN-O2-NEXT:     Pre-ISel Intrinsic Lowering
 ; GCN-O2-NEXT:     AMDGPU Printf lowering
 ; GCN-O2-NEXT:       FunctionPass Manager
 ; GCN-O2-NEXT:         Dominator Tree Construction
 ; GCN-O2-NEXT:     Fix function bitcasts for AMDGPU

 ; GCN-O2-NEXT:         Loop Strength Reduction
 ; GCN-O2-NEXT:       Basic Alias Analysis (stateless AA impl)
 ; GCN-O2-NEXT:       Function Alias Analysis Results
 ; GCN-O2-NEXT:       Merge contiguous icmps into a memcmp
 ; GCN-O2-NEXT:       Natural Loop Information
 ; GCN-O2-NEXT:       Lazy Branch Probability Analysis
 ; GCN-O2-NEXT:       Lazy Block Frequency Analysis
 ; GCN-O2-NEXT:       Expand memcmp() to load/stores
-; GCN-O2-NEXT:       Lower Garbage Collection Instructions
-; GCN-O2-NEXT:       Shadow Stack GC Lowering
 ; GCN-O2-NEXT:       Lower constant intrinsics
 ; GCN-O2-NEXT:       Remove unreachable blocks from the CFG
 ; GCN-O2-NEXT:       Natural Loop Information
 ; GCN-O2-NEXT:       Post-Dominator Tree Construction
 ; GCN-O2-NEXT:       Branch Probability Analysis
 ; GCN-O2-NEXT:       Block Frequency Analysis
 ; GCN-O2-NEXT:       Constant Hoisting
 ; GCN-O2-NEXT:       Replace intrinsics with calls to vector library

 ; GCN-O3-NEXT: Machine Module Information
 ; GCN-O3-NEXT: Target Transform Information
 ; GCN-O3-NEXT: Assumption Cache Tracker
 ; GCN-O3-NEXT: Profile summary info
 ; GCN-O3-NEXT: AMDGPU Address space based Alias Analysis
 ; GCN-O3-NEXT: External Alias Analysis
 ; GCN-O3-NEXT: Type-Based Alias Analysis
 ; GCN-O3-NEXT: Scoped NoAlias Alias Analysis
-; GCN-O3-NEXT: Create Garbage Collector Module Metadata
 ; GCN-O3-NEXT: Argument Register Usage Information Storage
+; GCN-O3-NEXT: Create Garbage Collector Module Metadata
 ; GCN-O3-NEXT: Machine Branch Probability Analysis
 ; GCN-O3-NEXT: Register Usage Information Storage
 ; GCN-O3-NEXT:   ModulePass Manager
 ; GCN-O3-NEXT:     Pre-ISel Intrinsic Lowering
 ; GCN-O3-NEXT:     AMDGPU Printf lowering
 ; GCN-O3-NEXT:       FunctionPass Manager
 ; GCN-O3-NEXT:         Dominator Tree Construction
 ; GCN-O3-NEXT:     Fix function bitcasts for AMDGPU

 ; GCN-O3-NEXT:         Loop Strength Reduction
 ; GCN-O3-NEXT:       Basic Alias Analysis (stateless AA impl)
 ; GCN-O3-NEXT:       Function Alias Analysis Results
 ; GCN-O3-NEXT:       Merge contiguous icmps into a memcmp
 ; GCN-O3-NEXT:       Natural Loop Information
 ; GCN-O3-NEXT:       Lazy Branch Probability Analysis
 ; GCN-O3-NEXT:       Lazy Block Frequency Analysis
 ; GCN-O3-NEXT:       Expand memcmp() to load/stores
-; GCN-O3-NEXT:       Lower Garbage Collection Instructions
-; GCN-O3-NEXT:       Shadow Stack GC Lowering
 ; GCN-O3-NEXT:       Lower constant intrinsics
 ; GCN-O3-NEXT:       Remove unreachable blocks from the CFG
 ; GCN-O3-NEXT:       Natural Loop Information
 ; GCN-O3-NEXT:       Post-Dominator Tree Construction
 ; GCN-O3-NEXT:       Branch Probability Analysis
 ; GCN-O3-NEXT:       Block Frequency Analysis
 ; GCN-O3-NEXT:       Constant Hoisting
 ; GCN-O3-NEXT:       Replace intrinsics with calls to vector library