[Debugify] Skip debugifying on special/immutable passes

[aeubanks]

Summary

With a function pass manager, it would insert debuginfo metadata before
getting to function passes while processing the pass manager, causing
debugify to skip while running the function passes.

Skip special passes + verifier + printing passes. Compared to the legacy
implementation of -debugify-each, this additionally skips verifier
passes. Probably no need to update the legacy version since it will be
obsolete soon.

This fixes 2 instcombine tests using -debugify-each under NPM.

[MaskRay]

LGTM.

llvm/lib/Transforms/Utils/Debugify.cpp

67

https://llvm.org/docs/CodingStandards.html#anonymous-namespaces has rules about anonymous namespaces. Note that the existing usage does not stick with the rule.

[aeubanks]

make function static instead of in anon namespace

llvm/lib/IR/PassInstrumentation.cpp

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 AnalysisKey PassInstrumentationAnalysis::Key;
 
 bool isSpecialPass(StringRef PassID, const std::vector<StringRef> &Specials) {
   size_t Pos = PassID.find('<');
-  if (Pos == StringRef::npos)
-    return false;
-  StringRef Prefix = PassID.substr(0, Pos);
+  StringRef Prefix = PassID;
+  if (Pos != StringRef::npos)
+    Prefix = PassID.substr(0, Pos);
   return any_of(Specials, [Prefix](StringRef S) { return Prefix.endswith(S); });
 }
 
 } // namespace llvm

llvm/lib/Transforms/Utils/Debugify.cpp

 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/PassInstrumentation.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 
 namespace {
 
 cl::opt<bool> Quiet("debugify-quiet",

 Instruction *findTerminatingInstruction(BasicBlock &BB) {
   if (auto *I = BB.getTerminatingMustTailCall())
     return I;
   if (auto *I = BB.getTerminatingDeoptimizeCall())
     return I;
   return BB.getTerminator();
 }
 } // end anonymous namespace
 
 bool llvm::applyDebugifyMetadata(
     Module &M, iterator_range<Module::iterator> Functions, StringRef Banner,
     std::function<bool(DIBuilder &DIB, Function &F)> ApplyToMF) {
   // Skip modules with debug info.
   if (M.getNamedMetadata("llvm.dbg.cu")) {
     dbg() << Banner << "Skipping module with debug info\n";
     return false;
   }

 
 PreservedAnalyses NewPMCheckDebugifyPass::run(Module &M,
                                               ModuleAnalysisManager &) {
   checkDebugifyMetadata(M, M.functions(), "", "CheckModuleDebugify", false,
                         nullptr);
   return PreservedAnalyses::all();
 }
 
+static bool isIgnoredPass(StringRef PassID) {
+  return isSpecialPass(PassID, {"PassManager", "PassAdaptor",
+                                "AnalysisManagerProxy", "PrintFunctionPass",
+                                "PrintModulePass", "BitcodeWriterPass",
+                                "ThinLTOBitcodeWriterPass", "VerifierPass"});
+}
+
 void DebugifyEachInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   PIC.registerBeforeNonSkippedPassCallback([](StringRef P, Any IR) {
+    if (isIgnoredPass(P))
+      return;
     if (any_isa<const Function *>(IR))
       applyDebugify(*const_cast<Function *>(any_cast<const Function *>(IR)));
     else if (any_isa<const Module *>(IR))
       applyDebugify(*const_cast<Module *>(any_cast<const Module *>(IR)));
   });
   PIC.registerAfterPassCallback([this](StringRef P, Any IR,
                                        const PreservedAnalyses &PassPA) {
+    if (isIgnoredPass(P))
+      return;
     if (any_isa<const Function *>(IR)) {
       auto &F = *const_cast<Function *>(any_cast<const Function *>(IR));
       Module &M = *F.getParent();
       auto It = F.getIterator();
       checkDebugifyMetadata(M, make_range(It, std::next(It)), P,
                             "CheckFunctionDebugify", /*Strip=*/true, &StatsMap);
     } else if (any_isa<const Module *>(IR)) {
       auto &M = *const_cast<Module *>(any_cast<const Module *>(IR));

llvm/test/DebugInfo/debugify-each.ll

 ; RUN: opt -O1 -debugify-each < %s -S -o %t.after
 ; RUN: diff %t.before %t.after
 
 ; Check that stripped IR compares equal before and after applying debugify.
 ; RUN: opt -O1 < %s | llvm-dis -o %t.before
 ; RUN: opt -O1 -debugify-each < %s | llvm-dis -o %t.after
 ; RUN: diff %t.before %t.after
 
+; Check that we only run debugify once per function per function pass.
+; This ensures that we don't run it for pass managers/verifiers/printers.
+; RUN: opt -debugify-each -passes=instsimplify -S -o /dev/null < %s 2> %t
+; RUN: FileCheck %s -input-file=%t -check-prefix=FUNCTION-PASS-ONE
+
+; Check that we only run debugify once per module pass
+; (plus the implicitly added begin/end verifier passes).
+; RUN: opt -debugify-each -passes=globalopt -S -o /dev/null < %s 2> %t
+; RUN: FileCheck %s -input-file=%t -check-prefix=MODULE-PASS-ONE
+
 define void @foo(i32 %arg) {
   call i32 asm "bswap $0", "=r,r"(i32 %arg)
   ret void
 }
 
 define void @bar() {
   ret void
 }
 
 ; Verify that the module & function (check-)debugify passes run at least twice.
 
 ; MODULE-PASS: CheckModuleDebugify [{{.*}}]
 ; MODULE-PASS: CheckModuleDebugify [{{.*}}]
 
 ; FUNCTION-PASS: CheckFunctionDebugify [{{.*}}]
 ; FUNCTION-PASS: CheckFunctionDebugify [{{.*}}]
 ; FUNCTION-PASS: CheckFunctionDebugify [{{.*}}]
 ; FUNCTION-PASS: CheckFunctionDebugify [{{.*}}]
+
+; MODULE-PASS-ONE: CheckModuleDebugify [{{.*}}]
+; MODULE-PASS-ONE-NOT: CheckModuleDebugify [{{.*}}]
+
+; FUNCTION-PASS-ONE: CheckFunctionDebugify [{{.*}}]
+; FUNCTION-PASS-ONE: CheckFunctionDebugify [{{.*}}]
+; FUNCTION-PASS-ONE-NOT: CheckFunctionDebugify [{{.*}}]

llvm/test/DebugInfo/debugify-export.ll

-; RUN: opt %s -disable-output -debugify-each -debugify-quiet -debugify-export - -enable-new-pm=0 | FileCheck %s
-; RUN: opt %s -disable-output -debugify-each -debugify-quiet -debugify-export - -enable-new-pm=1 | FileCheck %s
+; RUN: opt %s -disable-output -debugify-each -debugify-quiet -debugify-export - -globalopt | FileCheck %s
+; RUN: opt %s -disable-output -debugify-each -debugify-quiet -debugify-export - -passes=globalopt | FileCheck %s
 
 ; CHECK: Pass Name
 ; CHECK-SAME: # of missing debug values
 ; CHECK-SAME: # of missing locations
 ; CHECK-SAME: Missing/Expected value ratio
 ; CHECK-SAME: Missing/Expected location ratio
 
-; CHECK:      {{Module Verifier|VerifierPass}}
+; CHECK:      {{Module Verifier|GlobalOptPass}}
 ; CHECK-SAME: 0,0,0.000000e+00,0.000000e+00
 
 define void @foo() {
   ret void
 }

llvm/test/Transforms/InstCombine/call-guard.ll

 ; RUN: opt < %s -instcombine -instcombine-infinite-loop-threshold=2 -S | FileCheck %s
 ; RUN: opt < %s -instcombine -S -debugify-each | FileCheck %s
+; RUN: opt < %s -passes=instcombine -S -debugify-each | FileCheck %s
 
 declare void @llvm.experimental.guard(i1, ...)
 
 define void @test_guard_adjacent_same_cond(i1 %A) {
 ; CHECK-LABEL: @test_guard_adjacent_same_cond(
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 %A) [ "deopt"() ]
 ; CHECK-NEXT:    ret void
   call void(i1, ...) @llvm.experimental.guard( i1 %A )[ "deopt"() ]