MachineRegionInfo: fix pass initialization

[thegameg]

Summary

• Adapt MachineBasicBlock::getName() to have the same behavior as the IR BasicBlock (Value::getName()).
• Add it to lib/CodeGen/CodeGen.cpp::initializeCodeGen so that it is linked in the CodeGen library.
• MachineRegionInfoPass's name conflicts with RegionInfoPass's name ("region").
• MachineRegionInfo should depend on MachineDominatorTree, MachinePostDominatorTree and MachineDominanceFrontier instead of their respective IR versions.
• Since there were no tests for this, add a X86 MIR test.

[arsenm]

LGTM with name fix

lib/CodeGen/MachineRegionInfo.cpp

7

machine-region-info to better match name

126–127

Use DEBUG_TYPE

131–132

Ditto

[MatzeB]

test/CodeGen/MIR/Generic/machine-region-info.ll

1–2 ↗

(On Diff #88965)

I'd try to write a .mir test directly, instead of only generating it as an intermediate step.

[thegameg]

• Update pass name.
• Directly add an X86 MIR test instead of generating it.

[thegameg]

• Simplify MIR test. Removing IR causes MachineBasicBlock::getName() to return "(null)".
• Return an empty string instead of "(null)" in MachineBasicBlock::getName() (same behavior as Value::getName()).

[MatzeB]

LGTM, I will commit on your behalf.

[MatzeB]

Committed in 295518

include/llvm/CodeGen/MachineBasicBlock.h

private:
   friend class MachineFunction;
 
 public:
   /// Return the LLVM basic block that this instance corresponded to originally.
   /// Note that this may be NULL if this instance does not correspond directly
   /// to an LLVM basic block.
   const BasicBlock *getBasicBlock() const { return BB; }
 
-  /// Return the name of the corresponding LLVM basic block, or "(null)".
+  /// Return the name of the corresponding LLVM basic block, or an empty string.
   StringRef getName() const;
 
   /// Return a formatted string to identify this block and its parent function.
   std::string getFullName() const;
 
   /// Test whether this block is potentially the target of an indirect branch.
   bool hasAddressTaken() const { return AddressTaken; }
 

lib/CodeGen/CodeGen.cpp

void llvm::initializeCodeGen(PassRegistry &Registry) {
   initializeMachineCopyPropagationPass(Registry);
   initializeMachineDominatorTreePass(Registry);
   initializeMachineFunctionPrinterPassPass(Registry);
   initializeMachineLICMPass(Registry);
   initializeMachineLoopInfoPass(Registry);
   initializeMachineModuleInfoPass(Registry);
   initializeMachinePipelinerPass(Registry);
   initializeMachinePostDominatorTreePass(Registry);
+  initializeMachineRegionInfoPassPass(Registry);
   initializeMachineSchedulerPass(Registry);
   initializeMachineSinkingPass(Registry);
   initializeMachineVerifierPassPass(Registry);
   initializeXRayInstrumentationPass(Registry);
   initializePatchableFunctionPass(Registry);
   initializeOptimizePHIsPass(Registry);
   initializePEIPass(Registry);
   initializePHIEliminationPass(Registry);

lib/CodeGen/MachineBasicBlock.cpp

LLVM_DUMP_METHOD void MachineBasicBlock::dump() const {
   print(dbgs());
 }
 #endif
 
 StringRef MachineBasicBlock::getName() const {
   if (const BasicBlock *LBB = getBasicBlock())
     return LBB->getName();
   else
-    return "(null)";
+    return StringRef("", 0);
 }
 
 /// Return a hopefully unique identifier for this block.
 std::string MachineBasicBlock::getFullName() const {
   std::string Name;
   if (getParent())
     Name = (getParent()->getName() + ":").str();
   if (getBasicBlock())

lib/CodeGen/MachineRegionInfo.cpp

 
 #include "llvm/CodeGen/MachineRegionInfo.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/RegionInfoImpl.h"
 #include "llvm/CodeGen/MachinePostDominators.h"
 
-#define DEBUG_TYPE "region"
+#define DEBUG_TYPE "machine-region-info"
 
 using namespace llvm;
 
 STATISTIC(numMachineRegions,       "The # of machine regions");
 STATISTIC(numMachineSimpleRegions, "The # of simple machine regions");
 
 namespace llvm {
 template class RegionBase<RegionTraits<MachineFunction>>;

 bool MachineRegionInfoPass::runOnMachineFunction(MachineFunction &F) {
   releaseMemory();
 
   auto DT = &getAnalysis<MachineDominatorTree>();
   auto PDT = &getAnalysis<MachinePostDominatorTree>();
   auto DF = &getAnalysis<MachineDominanceFrontier>();
 
   RI.recalculate(F, DT, PDT, DF);
+
+  DEBUG(RI.dump());
+
   return false;
 }
 
 void MachineRegionInfoPass::releaseMemory() {
   RI.releaseMemory();
 }
 
 void MachineRegionInfoPass::verifyAnalysis() const {
   // Only do verification when user wants to, otherwise this expensive check
   // will be invoked by PMDataManager::verifyPreservedAnalysis when
   // a regionpass (marked PreservedAll) finish.
   if (MachineRegionInfo::VerifyRegionInfo)
     RI.verifyAnalysis();
 }
 
 void MachineRegionInfoPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
-  AU.addRequiredTransitive<DominatorTreeWrapperPass>();
-  AU.addRequired<PostDominatorTreeWrapperPass>();
-  AU.addRequired<DominanceFrontierWrapperPass>();
+  AU.addRequired<MachineDominatorTree>();
+  AU.addRequired<MachinePostDominatorTree>();
+  AU.addRequired<MachineDominanceFrontier>();
+  MachineFunctionPass::getAnalysisUsage(AU);
 }
 
 void MachineRegionInfoPass::print(raw_ostream &OS, const Module *) const {
   RI.print(OS);
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void MachineRegionInfoPass::dump() const {
   RI.dump();
 }
 #endif
 
 char MachineRegionInfoPass::ID = 0;
 
-INITIALIZE_PASS_BEGIN(MachineRegionInfoPass, "regions",
+INITIALIZE_PASS_BEGIN(MachineRegionInfoPass, DEBUG_TYPE,
                       "Detect single entry single exit regions", true, true)
 INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
 INITIALIZE_PASS_DEPENDENCY(MachinePostDominatorTree)
 INITIALIZE_PASS_DEPENDENCY(MachineDominanceFrontier)
-INITIALIZE_PASS_END(MachineRegionInfoPass, "regions",
+INITIALIZE_PASS_END(MachineRegionInfoPass, DEBUG_TYPE,
                     "Detect single entry single exit regions", true, true)
 
 // Create methods available outside of this file, to use them
 // "include/llvm/LinkAllPasses.h". Otherwise the pass would be deleted by
 // the link time optimization.
 
 namespace llvm {
   FunctionPass *createMachineRegionInfoPass() {
     return new MachineRegionInfoPass();
   }
 }
 

test/CodeGen/MIR/X86/machine-region-info.mir

+# RUN: llc -run-pass=machine-region-info %s -debug-only=machine-region-info -o /dev/null 2>&1 | FileCheck %s
+
+--- |
+  define void @fun() { ret void }
+...
+---
+name:            fun
+body:             |
+  bb.0:
+    successors: %bb.1(0x40000000), %bb.7(0x40000000)
+
+    CMP32ri8 %edi, 40, implicit-def %eflags
+    JNE_1 %bb.7, implicit killed %eflags
+    JMP_1 %bb.1
+
+  bb.1:
+    successors: %bb.2(0x40000000), %bb.11(0x40000000)
+
+    CMP32ri8 %edi, 1, implicit-def %eflags
+    JNE_1 %bb.11, implicit killed %eflags
+    JMP_1 %bb.2
+
+  bb.2:
+    successors: %bb.3(0x40000000), %bb.5(0x40000000)
+
+    CMP32ri8 %edi, 2, implicit-def %eflags
+    JNE_1 %bb.5, implicit killed %eflags
+    JMP_1 %bb.3
+
+  bb.3:
+    successors: %bb.4(0x40000000), %bb.5(0x40000000)
+
+    CMP32ri8 %edi, 90, implicit-def %eflags
+    JNE_1 %bb.5, implicit killed %eflags
+    JMP_1 %bb.4
+
+  bb.4:
+    successors: %bb.5(0x80000000)
+
+  bb.5:
+    successors: %bb.6(0x40000000), %bb.11(0x40000000)
+
+    CMP32ri8 %edi, 4, implicit-def %eflags
+    JNE_1 %bb.11, implicit killed %eflags
+    JMP_1 %bb.6
+
+  bb.6:
+    successors: %bb.11(0x80000000)
+
+    JMP_1 %bb.11
+
+  bb.7:
+    successors: %bb.9(0x40000000), %bb.8(0x40000000)
+
+    CMP32ri8 %edi, 5, implicit-def %eflags
+    JE_1 %bb.9, implicit killed %eflags
+    JMP_1 %bb.8
+
+  bb.8:
+    successors: %bb.9(0x80000000)
+
+  bb.9:
+    successors: %bb.11(0x40000000), %bb.10(0x40000000)
+
+    CMP32ri8 %edi, 6, implicit-def %eflags
+    JE_1 %bb.11, implicit killed %eflags
+    JMP_1 %bb.10
+
+  bb.10:
+    successors: %bb.11(0x80000000)
+
+  bb.11:
+    RET 0
+
+...
+
+# CHECK: Region tree:
+# CHECK-NEXT: [0] BB#0 => <Function Return>
+# CHECK-NEXT:   [1] BB#0 => BB#11
+# CHECK-NEXT:     [2] BB#1 => BB#11
+# CHECK-NEXT:       [3] BB#2 => BB#5
+# CHECK-NEXT:         [4] BB#3 => BB#5
+# CHECK-NEXT:       [3] BB#5 => BB#11
+# CHECK-NEXT:     [2] BB#7 => BB#9
+# CHECK-NEXT:     [2] BB#9 => BB#11
+# CHECK-NEXT: End region tree