[NFC][LICM] Minor improvements to debug output

[xiaoqing_wu]

Summary

Added a utility function in Value class to print block name and use block labels for unnamed blocks.
Changed LICM to call this function in its debug output.

[xiaoqing_wu]

Remve "\ No newline at end of file" at the end of the file.

[xiaoqing_wu]

Remove trailing space

[asbirlea]

This seems like a useful utility to add to BasicBlock itself if it doesn't exit? (e.g. getNonEmptyName or getNameOrAsOperand).

[xiaoqing_wu]

Created a utility function in Value class to print block name and use block labels for unnamed blocks. Thanks Alina for the suggestion.

[asbirlea]

Thanks!

llvm/lib/Transforms/Scalar/LICM.cpp

static Instruction *cloneInstructionInExitBlock(
     const LoopSafetyInfo *SafetyInfo, MemorySSAUpdater *MSSAU);
 
 static void eraseInstruction(Instruction &I, ICFLoopSafetyInfo &SafetyInfo,
                              AliasSetTracker *AST, MemorySSAUpdater *MSSAU);
 
 static void moveInstructionBefore(Instruction &I, Instruction &Dest,
                                   ICFLoopSafetyInfo &SafetyInfo,
                                   MemorySSAUpdater *MSSAU, ScalarEvolution *SE);
+#ifndef NDEBUG                                  
+static std::string getBlockName(const BasicBlock *BB);
+#endif
 
 namespace {
 struct LoopInvariantCodeMotion {
   bool runOnLoop(Loop *L, AAResults *AA, LoopInfo *LI, DominatorTree *DT,
                  BlockFrequencyInfo *BFI, TargetLibraryInfo *TLI,
                  TargetTransformInfo *TTI, ScalarEvolution *SE, MemorySSA *MSSA,
                  OptimizationRemarkEmitter *ORE);
 
LegacyLICMPass(
       : LoopPass(ID), LICM(LicmMssaOptCap, LicmMssaNoAccForPromotionCap) {
     initializeLegacyLICMPassPass(*PassRegistry::getPassRegistry());
   }
 
   bool runOnLoop(Loop *L, LPPassManager &LPM) override {
     if (skipLoop(L))
       return false;
 
+    LLVM_DEBUG(dbgs() << "Perform LICM on Loop with header at block "
+                      << getBlockName(L->getHeader()) << "\n");
+
     auto *SE = getAnalysisIfAvailable<ScalarEvolutionWrapperPass>();
     MemorySSA *MSSA = EnableMSSALoopDependency
                           ? (&getAnalysis<MemorySSAWrapperPass>().getMSSA())
                           : nullptr;
     bool hasProfileData = L->getHeader()->getParent()->hasProfileData();
     BlockFrequencyInfo *BFI =
         hasProfileData ? &getAnalysis<LazyBlockFrequencyInfoPass>().getBFI()
                        : nullptr;
auto HasBBAsSuccessor =
                                        Pair.first->getSuccessor(1) == BB);
         };
     auto It = std::find_if(HoistableBranches.begin(), HoistableBranches.end(),
                            HasBBAsSuccessor);
 
     // If not involved in a pending branch, hoist to preheader
     BasicBlock *InitialPreheader = CurLoop->getLoopPreheader();
     if (It == HoistableBranches.end()) {
-      LLVM_DEBUG(dbgs() << "LICM using " << InitialPreheader->getName()
-                        << " as hoist destination for " << BB->getName()
+      LLVM_DEBUG(dbgs() << "LICM using " << getBlockName(InitialPreheader)
+                        << " as hoist destination for " << getBlockName(BB)
                         << "\n");
       HoistDestinationMap[BB] = InitialPreheader;
       return InitialPreheader;
     }
     BranchInst *BI = It->first;
     assert(std::find_if(++It, HoistableBranches.end(), HasBBAsSuccessor) ==
                HoistableBranches.end() &&
            "BB is expected to be the target of at most one branch");
for (Instruction *I : reverse(HoistedInstructions)) {
             DT->getNode(I->getParent())->getIDom()->getBlock();
         if (!HoistPoint || !DT->dominates(HoistPoint->getParent(), Dominator)) {
           if (HoistPoint)
             assert(DT->dominates(Dominator, HoistPoint->getParent()) &&
                    "New hoist point expected to dominate old hoist point");
           HoistPoint = Dominator->getTerminator();
         }
         LLVM_DEBUG(dbgs() << "LICM rehoisting to "
-                          << HoistPoint->getParent()->getName()
-                          << ": " << *I << "\n");
+                          << getBlockName(HoistPoint->getParent()) << ": " << *I
+                          << "\n");
         moveInstructionBefore(*I, *HoistPoint, *SafetyInfo, MSSAU, SE);
         HoistPoint = I;
         Changed = true;
       }
     }
   }
   if (MSSAU && VerifyMemorySSA)
     MSSAU->getMemorySSA()->verifyMemorySSA();

 
 /// When an instruction is found to only use loop invariant operands that
 /// is safe to hoist, this instruction is called to do the dirty work.
 ///
 static void hoist(Instruction &I, const DominatorTree *DT, const Loop *CurLoop,
                   BasicBlock *Dest, ICFLoopSafetyInfo *SafetyInfo,
                   MemorySSAUpdater *MSSAU, ScalarEvolution *SE,
                   OptimizationRemarkEmitter *ORE) {
-  LLVM_DEBUG(dbgs() << "LICM hoisting to " << Dest->getName() << ": " << I
+  LLVM_DEBUG(dbgs() << "LICM hoisting to " << getBlockName(Dest) << ": " << I
                     << "\n");
   ORE->emit([&]() {
     return OptimizationRemark(DEBUG_TYPE, "Hoisted", &I) << "hoisting "
                                                          << ore::NV("Inst", &I);
   });
 
   // Metadata can be dependent on conditions we are hoisting above.
   // Conservatively strip all metadata on the instruction unless we were

 
 /// Little predicate that returns true if the specified basic block is in
 /// a subloop of the current one, not the current one itself.
 ///
 static bool inSubLoop(BasicBlock *BB, Loop *CurLoop, LoopInfo *LI) {
   assert(CurLoop->contains(BB) && "Only valid if BB is IN the loop");
   return LI->getLoopFor(BB) != CurLoop;
 }
+
+#ifndef NDEBUG
+/// Return block name, for unnamed block, return its label.
+static std::string getBlockName(const BasicBlock *BB) {
+  if (!BB->getName().empty())
+    return std::string(BB->getName());
+
+  std::string BBName;
+  raw_string_ostream OS(BBName);
+  BB->printAsOperand(OS, false);
+  return OS.str();
+}
+#endif
 No newline at end of file