[WebAssembly] Print a debug message at the start of each pass

[aheejin]

Summary

Looks like many passes print its pass description as a debug message at
the start of each pass, so added that to (mostly newly added) other
passes as well.

lib/Target/WebAssembly/WebAssemblyAddMissingPrototypes.cpp

 INITIALIZE_PASS(WebAssemblyAddMissingPrototypes, DEBUG_TYPE,
                 "Add prototypes to prototypes-less functions", false, false)
 
 ModulePass *llvm::createWebAssemblyAddMissingPrototypes() {
   return new WebAssemblyAddMissingPrototypes();
 }
 
 bool WebAssemblyAddMissingPrototypes::runOnModule(Module &M) {
-  LLVM_DEBUG(dbgs() << "runnning AddMissingPrototypes\n");
+  LLVM_DEBUG(dbgs() << "********** Add Missing Prototypes **********\n");
 
   std::vector<std::pair<Function *, Function *>> Replacements;
 
   // Find all the prototype-less function declarations
   for (Function &F : M) {
     if (!F.isDeclaration() || !F.hasFnAttribute("no-prototype"))
       continue;
 

lib/Target/WebAssembly/WebAssemblyCallIndirectFixup.cpp

 
 static bool IsPseudoCallIndirect(const MachineInstr &MI) {
   return GetNonPseudoCallIndirectOpcode(MI) !=
          WebAssembly::INSTRUCTION_LIST_END;
 }
 
 bool WebAssemblyCallIndirectFixup::runOnMachineFunction(MachineFunction &MF) {
   LLVM_DEBUG(dbgs() << "********** Fixing up CALL_INDIRECTs **********\n"
-                    << MF.getName() << '\n');
+                    << "********** Function: " << MF.getName() << '\n');
 
   bool Changed = false;
   const WebAssemblyInstrInfo *TII =
       MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
 
   for (MachineBasicBlock &MBB : MF) {
     for (MachineInstr &MI : MBB) {
       if (IsPseudoCallIndirect(MI)) {

lib/Target/WebAssembly/WebAssemblyEHRestoreStackPointer.cpp

INITIALIZE_PASS(WebAssemblyEHRestoreStackPointer, DEBUG_TYPE,
                 "Restore Stack Pointer for Exception Handling", true, false)
 
 FunctionPass *llvm::createWebAssemblyEHRestoreStackPointer() {
   return new WebAssemblyEHRestoreStackPointer();
 }
 
 bool WebAssemblyEHRestoreStackPointer::runOnMachineFunction(
     MachineFunction &MF) {
+  LLVM_DEBUG(dbgs() << "********** EH Restore Stack Pointer **********\n"
+                       "********** Function: "
+                    << MF.getName() << '\n');
+
   const auto *FrameLowering = static_cast<const WebAssemblyFrameLowering *>(
       MF.getSubtarget().getFrameLowering());
   if (!FrameLowering->needsPrologForEH(MF))
     return false;
   bool Changed = false;
 
   for (auto &MBB : MF) {
     if (!MBB.isEHPad())

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

 
 INITIALIZE_PASS_BEGIN(WebAssemblyExceptionInfo, DEBUG_TYPE,
                       "WebAssembly Exception Information", true, true)
 INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
 INITIALIZE_PASS_DEPENDENCY(MachineDominanceFrontier)
 INITIALIZE_PASS_END(WebAssemblyExceptionInfo, DEBUG_TYPE,
                     "WebAssembly Exception Information", true, true)
 
-bool WebAssemblyExceptionInfo::runOnMachineFunction(MachineFunction &F) {
+bool WebAssemblyExceptionInfo::runOnMachineFunction(MachineFunction &MF) {
+  LLVM_DEBUG(dbgs() << "********** Exception Info Calculation **********\n"
+                       "********** Function: "
+                    << MF.getName() << '\n');
   releaseMemory();
   auto &MDT = getAnalysis<MachineDominatorTree>();
   auto &MDF = getAnalysis<MachineDominanceFrontier>();
   recalculate(MDT, MDF);
   return false;
 }
 
 void WebAssemblyExceptionInfo::recalculate(

lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp

if (TypeMismatch) {
     Wrapper->eraseFromParent();
     return nullptr;
   }
   LLVM_DEBUG(dbgs() << "CreateWrapper: " << F->getName() << "\n");
   return Wrapper;
 }
 
 bool FixFunctionBitcasts::runOnModule(Module &M) {
+  LLVM_DEBUG(dbgs() << "********** Fix Function Bitcasts **********\n");
+
   Function *Main = nullptr;
   CallInst *CallMain = nullptr;
   SmallVector<std::pair<Use *, Function *>, 0> Uses;
   SmallPtrSet<Constant *, 2> ConstantBCs;
 
   // Collect all the places that need wrappers.
   for (Function &F : M) {
     FindUses(&F, F, Uses, ConstantBCs);

lib/Target/WebAssembly/WebAssemblyISelDAGToDAG.cpp

WebAssemblyDAGToDAGISel(WebAssemblyTargetMachine &tm,
       : SelectionDAGISel(tm, OptLevel), Subtarget(nullptr), ForCodeSize(false) {
   }
 
   StringRef getPassName() const override {
     return "WebAssembly Instruction Selection";
   }
 
   bool runOnMachineFunction(MachineFunction &MF) override {
+    LLVM_DEBUG(dbgs() << "********** ISelDAGToDAG **********\n"
+                         "********** Function: "
+                      << MF.getName() << '\n');
+
     ForCodeSize = MF.getFunction().hasFnAttribute(Attribute::OptimizeForSize) ||
                   MF.getFunction().hasFnAttribute(Attribute::MinSize);
     Subtarget = &MF.getSubtarget<WebAssemblySubtarget>();
     return SelectionDAGISel::runOnMachineFunction(MF);
   }
 
   void Select(SDNode *Node) override;
 

lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp

while (!WL.empty()) {
     WL.append(MBB->succ_begin(), MBB->succ_end());
     for (auto *Succ : Succs)
       MBB->removeSuccessor(Succ);
     MBB->eraseFromParent();
   }
 }
 
 bool WebAssemblyLateEHPrepare::runOnMachineFunction(MachineFunction &MF) {
+  LLVM_DEBUG(dbgs() << "********** Late EH Prepare **********\n"
+                       "********** Function: "
+                    << MF.getName() << '\n');
+
   if (MF.getTarget().getMCAsmInfo()->getExceptionHandlingType() !=
       ExceptionHandling::Wasm)
     return false;
 
   bool Changed = false;
   Changed |= removeUnnecessaryUnreachables(MF);
   Changed |= addRethrows(MF);
   if (!MF.getFunction().hasPersonalityFn())

lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

for (Instruction &I : BB) {
           continue;
         SSA.RewriteUseAfterInsertions(U);
       }
     }
   }
 }
 
 bool WebAssemblyLowerEmscriptenEHSjLj::runOnModule(Module &M) {
+  LLVM_DEBUG(dbgs() << "********** Lower Emscripten EH & SjLj **********\n");
+
   LLVMContext &C = M.getContext();
   IRBuilder<> IRB(C);
 
   Function *SetjmpF = M.getFunction("setjmp");
   Function *LongjmpF = M.getFunction("longjmp");
   bool SetjmpUsed = SetjmpF && !SetjmpF->use_empty();
   bool LongjmpUsed = LongjmpF && !LongjmpF->use_empty();
   bool DoSjLj = EnableSjLj && (SetjmpUsed || LongjmpUsed);

lib/Target/WebAssembly/WebAssemblyLowerGlobalDtors.cpp

 INITIALIZE_PASS(LowerGlobalDtors, DEBUG_TYPE,
                 "Lower @llvm.global_dtors for WebAssembly", false, false)
 
 ModulePass *llvm::createWebAssemblyLowerGlobalDtors() {
   return new LowerGlobalDtors();
 }
 
 bool LowerGlobalDtors::runOnModule(Module &M) {
+  LLVM_DEBUG(dbgs() << "********** Lower Global Destructors **********\n");
+
   GlobalVariable *GV = M.getGlobalVariable("llvm.global_dtors");
   if (!GV)
     return false;
 
   const ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
   if (!InitList)
     return false;
 

lib/Target/WebAssembly/WebAssemblyOptimizeReturned.cpp

if (CS.paramHasAttr(i, Attribute::Returned)) {
         Use &U = *UI++;
         if (DT->dominates(Inst, U))
           U.set(Inst);
       }
     }
 }
 
 bool OptimizeReturned::runOnFunction(Function &F) {
+  LLVM_DEBUG(dbgs() << "********** Optimize returned Attributes **********\n"
+                       "********** Function: "
+                    << F.getName() << '\n');
+
   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   visit(F);
   return true;
 }