expose debugify as an LLVM option in clang

[tyb0807]

Summary

Hello,

As discussed in https://bugs.llvm.org/show_bug.cgi?id=37792.

Thanks for your review

[gbedwell]

Thanks for working on this! I've not reviewed the code, but I did try applying the patch and making use of it, and it seems to work perfectly so far for my use-case of being able to automatically enable automatic debugify checking over large codebases in build systems that I don't necessarily have control of :)

I built a medium sized PS4 codebase with "clang -O3 -mllvm -debugify-each" and piped stderr into a file, where I was able to generate the following stats. Obviously there will be some level of duplication due to linkonce functions, but looking through the data, it seems that the vast majority of error lines are unique so I don't think that's a big factor skewing the results.

$ cat err2.txt | grep FAIL | sort | uniq -c | sort
      2 CheckFunctionDebugify [MemCpy Optimization]: FAIL
      8 CheckFunctionDebugify [Tail Call Elimination]: FAIL
     17 CheckFunctionDebugify [Value Propagation]: FAIL
     23 CheckModuleDebugify [Global Variable Optimizer]: FAIL
     53 CheckFunctionDebugify [Dead Store Elimination]: FAIL
     76 CheckFunctionDebugify [Call-site splitting]: FAIL
    100 CheckFunctionDebugify [MergedLoadStoreMotion]: FAIL
    126 CheckFunctionDebugify [Constant Hoisting]: FAIL
    130 CheckFunctionDebugify [Loop Vectorization]: FAIL
    142 CheckFunctionDebugify [Reassociate expressions]: FAIL
    185 CheckModuleDebugify [Dead Argument Elimination]: FAIL
    385 CheckFunctionDebugify [SROA]: FAIL
    445 CheckFunctionDebugify [Merge disjoint stack slots]: FAIL
    555 CheckFunctionDebugify [Simplify the CFG]: FAIL
    584 CheckFunctionDebugify [Global Value Numbering]: FAIL
    727 CheckFunctionDebugify [CodeGen Prepare]: FAIL
    845 CheckFunctionDebugify [Jump Threading]: FAIL
   1761 CheckFunctionDebugify [Canonicalize natural loops]: FAIL
   2429 CheckFunctionDebugify [Combine redundant instructions]: FAIL
   8042 CheckFunctionDebugify [Loop-Closed SSA Form Pass]: FAIL

Based on this data, I'll attempt to produce a small test-case that demonstrates an LCSSA failure and raise a bug report.

[tyb0807]

Thanks for your comment Greg. Please feel free to tell me if you need anything else I'll try to update the patch.

[probinson]

I will try to look at this tomorrow if @vsk doesn't. Passes are not really my thing but as it's based on the existing opt code it should not be too hard to review.

[vsk]

First off, @tyb0807, I really appreciate the work you've been doing on LLVM.

With that said, I think this is trying to solve the wrong problem, and I don't think it makes sense to proceed.

There's already a way to find targeted test cases for debug info bugs with opt (see https://gramanas.github.io/posts/finding-debuginfo-loss/). I don't think it makes sense to land a change this invasive to make that process marginally easier. Especially not when there's a more general way to collect IR from a build system using a simple wrapper (see e.g https://github.com/vedantk/scripts/blob/master/generate-ir-cc).

We're bottlenecked by our ability to *fix* -- not simply to find -- these bugs.

[gbedwell]

In D49297#1165863, @vsk wrote:

First off, @tyb0807, I really appreciate the work you've been doing on LLVM.

With that said, I think this is trying to solve the wrong problem, and I don't think it makes sense to proceed.

That's fair, although I somewhat disagree and I'll say that for our workflow it's a bit more than marginal in terms of how much easier it is, but one thing I'd really like to get to the bottom of before rejecting this approach entirely are the following failures above:

445 CheckFunctionDebugify [Merge disjoint stack slots]: FAIL
727 CheckFunctionDebugify [CodeGen Prepare]: FAIL

I've had a background process running on my PC hitting some preprocessed game code files pretty hard for a couple of weeks now. It's produced small bug reports for a number of passes, but the above failures don't get spotted with the clang piped into opt approach. I've unfortunately been temporarily waylaid by another project for the last couple of months or so (otherwise I'd already be contributing fixes for the bugs I've raised) so I've not had a chance to investigate whether these are genuine failures or false positives. The big question for me, is does this increase the potential coverage?

[vsk]

In D49297#1165866, @gbedwell wrote:

445 CheckFunctionDebugify [Merge disjoint stack slots]: FAIL
727 CheckFunctionDebugify [CodeGen Prepare]: FAIL

I've had a background process running on my PC hitting some preprocessed game code files pretty hard for a couple of weeks now. It's produced small bug reports for a number of passes, but the above failures don't get spotted with the clang piped into opt approach. [...] The big question for me, is does this increase the potential coverage?

By default opt doesn't run -codegenprepare in its -OX pipelines, but it does supporting testing it. See e.g D47282.

The -stack-coloring pass lives in a weird space: it's a machine function pass which runs after isel, but it modifies IR. I don't think debugify operates on a very useful level at this point.

[tyb0807]

Hi @vsk,

Thank you for your comment. I agree with what you say, however, I think you may understand that we should have had this discussion before this patch in https://bugs.llvm.org/show_bug.cgi?id=37792 😭

Anyway, I think we can still reuse part of the logic of this patch to extend the -verify-each mode, so that it also is enabled after each module/function pass? What do you think? Do you still need this feature of -verify-each?

[vsk]

In D49297#1166117, @tyb0807 wrote:

Hi @vsk,

Thank you for your comment. I agree with what you say, however, I think you may understand that we should have had this discussion before this patch in https://bugs.llvm.org/show_bug.cgi?id=37792 😭

Keep in mind that folks can't respond to everything they're CC'd on. 'Would-be-nice' feature requests like this one necessarily receive less attention. To save time in the future, let people know what you're working on. Assigning a bugzilla PR to yourself, sending out a RFC or an implementation plan on llvm-dev, or even pinging people on IRC are all good ways to do that.

Anyway, I think we can still reuse part of the logic of this patch to extend the -verify-each mode, so that it also is enabled after each module/function pass? What do you think? Do you still need this feature of -verify-each?

If you're interested in adding/changing a -verify-each mode in clang/opt, I suggest sending out a RFC. That allows more people to participate in the discussion.

include/llvm/IR/Debugify.h

+//===- Debugify.h - Passes to attach synthetic debug info to IR constructs ===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines passes to attach synthetic debug info to the IR in
+/// various granularities. It can be used to create targeted tests for debug
+/// info preservation.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_DEBUGIFY_H
+#define LLVM_IR_DEBUGIFY_H
+
+#include "llvm/ADT/StringRef.h"
+
+namespace llvm {
+class Function;
+class FunctionPass;
+class Module;
+class ModulePass;
+class PreservedAnalyses;
+template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager;
+
+/// Create and return a pass that attaches synthetic debug info to the module.
+ModulePass *createDebugifyModulePass();
+
+/// Create and return a pass that attaches synthetic debug info to the function.
+FunctionPass *createDebugifyFunctionPass();
+
+/// Create and return a pass that verifies the debug info inserted by the above
+/// DebugifyModulePass.
+ModulePass *createCheckDebugifyModulePass(bool Strip = false,
+                                          StringRef NameOfWrappedPass = "");
+
+/// Create and return a pass that verifies the debug info inserted by the above
+/// DebugifyFunctionPass.
+FunctionPass *createCheckDebugifyFunctionPass(bool Strip = false,
+                                              StringRef NameOfWrappedPass = "");
+
+/// Pass for attaching synthetic debug info to the module.
+///
+/// Note: This pass is for use with the new pass manager. Use the create...Pass
+/// functions above to create passes for use with the legacy pass manager.
+class DebugifyModulePass {
+  bool Result = false;
+
+public:
+  PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM);
+
+  static StringRef name() { return "Debugify Module IR"; }
+
+  bool getResult() const { return Result; }
+};
+
+/// Pass for attaching synthetic debug info to instructions within a single
+/// function.
+///
+/// Note: This pass is for use with the new pass manager. Use the create...Pass
+/// functions above to create passes for use with the legacy pass manager.
+class DebugifyFunctionPass {
+  bool Result = false;
+
+public:
+  PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
+
+  static StringRef name() { return "Debugify Function IR"; }
+
+  bool getResult() const { return Result; }
+};
+
+/// Pass for checking debug info inserted by DebugifyModulePass.
+///
+/// Note: This pass is for use with the new pass manager. Use the create...Pass
+/// functions above to create passes for use with the legacy pass manager.
+class CheckDebugifyModulePass {
+  bool Result = false;
+  bool Strip;
+  StringRef NameOfWrappedPass;
+
+public:
+  CheckDebugifyModulePass(bool Strip = false,
+                          StringRef NamedOfWrappedPass = "");
+
+  PreservedAnalyses run(Module &F, AnalysisManager<Module> &AM);
+
+  static StringRef name() { return "Check Debugify Module IR"; }
+
+  bool getResult() const { return Result; }
+};
+
+/// Pass for checking debug info inserted by DebugifyFunctionPass.
+///
+/// Note: This pass is for use with the new pass manager. Use the create...Pass
+/// functions above to create passes for use with the legacy pass manager.
+class CheckDebugifyFunctionPass {
+  bool Result = false;
+  bool Strip;
+  StringRef NameOfWrappedPass;
+
+public:
+  CheckDebugifyFunctionPass(bool Strip = false,
+                            StringRef NamedOfWrappedPass = "");
+
+  PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
+
+  static StringRef name() { return "Check Debugify Function IR"; }
+
+  bool getResult() const { return Result; }
+};
+
+} // End llvm namespace
+
+#endif

include/llvm/InitializePasses.h

 void initializePostRAHazardRecognizerPass(PassRegistry&);
 void initializePostRAMachineSinkingPass(PassRegistry&);
 void initializePostRASchedulerPass(PassRegistry&);
 void initializePreISelIntrinsicLoweringLegacyPassPass(PassRegistry&);
 void initializePredicateInfoPrinterLegacyPassPass(PassRegistry&);
 void initializePrintBasicBlockPassPass(PassRegistry&);
 void initializePrintFunctionPassWrapperPass(PassRegistry&);
 void initializePrintModulePassWrapperPass(PassRegistry&);
+void initializeDebugifyModulePassWrapperPass(PassRegistry&);
+void initializeCheckDebugifyModulePassWrapperPass(PassRegistry&);
+void initializeDebugifyFunctionPassWrapperPass(PassRegistry&);
+void initializeCheckDebugifyFunctionPassWrapperPass(PassRegistry&);
 void initializeProcessImplicitDefsPass(PassRegistry&);
 void initializeProfileSummaryInfoWrapperPassPass(PassRegistry&);
 void initializePromoteLegacyPassPass(PassRegistry&);
 void initializePruneEHPass(PassRegistry&);
 void initializeRABasicPass(PassRegistry&);
 void initializeRegAllocFastPass(PassRegistry&);
 void initializeRAGreedyPass(PassRegistry&);
 void initializeReassociateLegacyPassPass(PassRegistry&);

include/llvm/LinkAllPasses.h

 #include "llvm/Analysis/RegionPass.h"
 #include "llvm/Analysis/RegionPrinter.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
 #include "llvm/Analysis/ScopedNoAliasAA.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TypeBasedAliasAnalysis.h"
 #include "llvm/CodeGen/Passes.h"
+#include "llvm/IR/Debugify.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/Support/Valgrind.h"
 #include "llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/AlwaysInliner.h"
 #include "llvm/Transforms/IPO/FunctionAttrs.h"
 #include "llvm/Transforms/InstCombine/InstCombine.h"
ForcePassLinking() {
       (void) llvm::createMergeFunctionsPass();
       (void) llvm::createMergeICmpsPass();
       (void) llvm::createExpandMemCmpPass();
       std::string buf;
       llvm::raw_string_ostream os(buf);
       (void) llvm::createPrintModulePass(os);
       (void) llvm::createPrintFunctionPass(os);
       (void) llvm::createPrintBasicBlockPass(os);
+      (void) llvm::createDebugifyModulePass();
+      (void) llvm::createDebugifyFunctionPass();
+      (void) llvm::createCheckDebugifyModulePass();
+      (void) llvm::createCheckDebugifyFunctionPass();
       (void) llvm::createModuleDebugInfoPrinterPass();
       (void) llvm::createPartialInliningPass();
       (void) llvm::createLintPass();
       (void) llvm::createSinkingPass();
       (void) llvm::createLowerAtomicPass();
       (void) llvm::createCorrelatedValuePropagationPass();
       (void) llvm::createMemDepPrinter();
       (void) llvm::createLoopVectorizePass();

include/llvm/Pass.h

public:
   /// necessary to implement this method.  Beware that the module pointer MAY be
   /// null.  This automatically forwards to a virtual function that does not
   /// provide the Module* in case the analysis doesn't need it it can just be
   /// ignored.
   virtual void print(raw_ostream &OS, const Module *M) const;
 
   void dump() const; // dump - Print to stderr.
 
+  /// createDebugifyPass - Create a Pass appropriate to attach the synthetic
+  /// debug information to the IR that this pass operates on (Module or
+  /// Function).
+  Pass *createDebugifyPass();
+
+  /// createCheckDebugifyPass - Create a Pass appropriate to verify the debug
+  /// info inserted by one of the above Debugify passes.
+  Pass *createCheckDebugifyPass(bool Strip, StringRef NameOfWrappedPass);
+
   /// createPrinterPass - Get a Pass appropriate to print the IR this
   /// pass operates on (Module, Function or MachineFunction).
   virtual Pass *createPrinterPass(raw_ostream &OS,
                                   const std::string &Banner) const = 0;
 
   /// Each pass is responsible for assigning a pass manager to itself.
   /// PMS is the stack of available pass manager.
   virtual void assignPassManager(PMStack &,

lib/IR/CMakeLists.txt

add_llvm_library(LLVMCore
   ConstantRange.cpp
   Constants.cpp
   Core.cpp
   DIBuilder.cpp
   DataLayout.cpp
   DebugInfo.cpp
   DebugInfoMetadata.cpp
   DebugLoc.cpp
+  Debugify.cpp
   DiagnosticHandler.cpp
   DiagnosticInfo.cpp
   DiagnosticPrinter.cpp
   Dominators.cpp
   DomTreeUpdater.cpp
   Function.cpp
   GVMaterializer.cpp
   Globals.cpp

lib/IR/Core.cpp

 
 #define DEBUG_TYPE "ir"
 
 void llvm::initializeCore(PassRegistry &Registry) {
   initializeDominatorTreeWrapperPassPass(Registry);
   initializePrintModulePassWrapperPass(Registry);
   initializePrintFunctionPassWrapperPass(Registry);
   initializePrintBasicBlockPassPass(Registry);
+  initializeDebugifyModulePassWrapperPass(Registry);
+  initializeCheckDebugifyModulePassWrapperPass(Registry);
+  initializeDebugifyFunctionPassWrapperPass(Registry);
+  initializeCheckDebugifyFunctionPassWrapperPass(Registry);
   initializeSafepointIRVerifierPass(Registry);
   initializeVerifierLegacyPassPass(Registry);
 }
 
 void LLVMInitializeCore(LLVMPassRegistryRef R) {
   initializeCore(*unwrap(R));
 }
 

lib/IR/Debugify.cpp

+//===- Debugify.cpp - Attach synthetic debug info to everything -----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// (Check)DebugifyModulePass and (Check)DebugifyFunctionPass implementations.
+///
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DIBuilder.h"
+#include "llvm/IR/DebugInfo.h"
+#include "llvm/IR/Debugify.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/InstIterator.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/IR/Type.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Transforms/IPO.h"
+
+using namespace llvm;
+
+namespace {
+
+cl::opt<bool> Quiet("debugify-quiet",
+                    cl::desc("Suppress verbose debugify output"));
+
+raw_ostream &dbg() { return Quiet ? nulls() : errs(); }
+
+uint64_t getAllocSizeInBits(Module &M, Type *Ty) {
+  return Ty->isSized() ? M.getDataLayout().getTypeAllocSizeInBits(Ty) : 0;
+}
+
+bool isFunctionSkipped(Function &F) {
+  return F.isDeclaration() || !F.hasExactDefinition();
+}
+
+/// Find the basic block's terminating instruction.
+///
+/// Special care is needed to handle musttail and deopt calls, as these behave
+/// like (but are in fact not) terminators.
+Instruction *findTerminatingInstruction(BasicBlock &BB) {
+  if (auto *I = BB.getTerminatingMustTailCall())
+    return I;
+  if (auto *I = BB.getTerminatingDeoptimizeCall())
+    return I;
+  return BB.getTerminator();
+}
+
+bool applyDebugifyMetadata(Module &M,
+                           iterator_range<Module::iterator> Functions,
+                           StringRef Banner) {
+  // Skip modules with debug info.
+  if (M.getNamedMetadata("llvm.dbg.cu")) {
+    dbg() << Banner << "Skipping module with debug info\n";
+    return false;
+  }
+
+  DIBuilder DIB(M);
+  LLVMContext &Ctx = M.getContext();
+
+  // Get a DIType which corresponds to Ty.
+  DenseMap<uint64_t, DIType *> TypeCache;
+  auto getCachedDIType = [&](Type *Ty) -> DIType * {
+    uint64_t Size = getAllocSizeInBits(M, Ty);
+    DIType *&DTy = TypeCache[Size];
+    if (!DTy) {
+      std::string Name = "ty" + utostr(Size);
+      DTy = DIB.createBasicType(Name, Size, dwarf::DW_ATE_unsigned);
+    }
+    return DTy;
+  };
+
+  unsigned NextLine = 1;
+  unsigned NextVar = 1;
+  auto File = DIB.createFile(M.getName(), "/");
+  auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C, File, "debugify",
+                                  /*isOptimized=*/true, "", 0);
+
+  // Visit each instruction.
+  for (Function &F : Functions) {
+    if (isFunctionSkipped(F))
+      continue;
+
+    auto SPType = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
+    bool IsLocalToUnit = F.hasPrivateLinkage() || F.hasInternalLinkage();
+    auto SP =
+        DIB.createFunction(CU, F.getName(), F.getName(), File, NextLine, SPType,
+                           IsLocalToUnit, /*isDefinition=*/true, NextLine,
+                           DINode::FlagZero, /*isOptimized=*/true);
+    F.setSubprogram(SP);
+    for (BasicBlock &BB : F) {
+      // Attach debug locations.
+      for (Instruction &I : BB)
+        I.setDebugLoc(DILocation::get(Ctx, NextLine++, 1, SP));
+
+      // Inserting debug values into EH pads can break IR invariants.
+      if (BB.isEHPad())
+        continue;
+
+      // Find the terminating instruction, after which no debug values are
+      // attached.
+      Instruction *LastInst = findTerminatingInstruction(BB);
+      assert(LastInst && "Expected basic block with a terminator");
+
+      // Maintain an insertion point which can't be invalidated when updates
+      // are made.
+      BasicBlock::iterator InsertPt = BB.getFirstInsertionPt();
+      assert(InsertPt != BB.end() && "Expected to find an insertion point");
+      Instruction *InsertBefore = &*InsertPt;
+
+      // Attach debug values.
+      for (Instruction *I = &*BB.begin(); I != LastInst; I = I->getNextNode()) {
+        // Skip void-valued instructions.
+        if (I->getType()->isVoidTy())
+          continue;
+
+        // Phis and EH pads must be grouped at the beginning of the block.
+        // Only advance the insertion point when we finish visiting these.
+        if (!isa<PHINode>(I) && !I->isEHPad())
+          InsertBefore = I->getNextNode();
+
+        std::string Name = utostr(NextVar++);
+        const DILocation *Loc = I->getDebugLoc().get();
+        auto LocalVar = DIB.createAutoVariable(SP, Name, File, Loc->getLine(),
+                                               getCachedDIType(I->getType()),
+                                               /*AlwaysPreserve=*/true);
+        DIB.insertDbgValueIntrinsic(I, LocalVar, DIB.createExpression(), Loc,
+                                    InsertBefore);
+      }
+    }
+    DIB.finalizeSubprogram(SP);
+  }
+  DIB.finalize();
+
+  // Track the number of distinct lines and variables.
+  NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.debugify");
+  auto *IntTy = Type::getInt32Ty(Ctx);
+  auto addDebugifyOperand = [&](unsigned N) {
+    NMD->addOperand(MDNode::get(
+        Ctx, ValueAsMetadata::getConstant(ConstantInt::get(IntTy, N))));
+  };
+  addDebugifyOperand(NextLine - 1); // Original number of lines.
+  addDebugifyOperand(NextVar - 1);  // Original number of variables.
+  assert(NMD->getNumOperands() == 2 &&
+         "llvm.debugify should have exactly 2 operands!");
+
+  // Claim that this synthetic debug info is valid.
+  StringRef DIVersionKey = "Debug Info Version";
+  if (!M.getModuleFlag(DIVersionKey))
+    M.addModuleFlag(Module::Warning, DIVersionKey, DEBUG_METADATA_VERSION);
+
+  return true;
+}
+
+/// Return true if a mis-sized diagnostic is issued for \p DVI.
+bool diagnoseMisSizedDbgValue(Module &M, DbgValueInst *DVI) {
+  // The size of a dbg.value's value operand should match the size of the
+  // variable it corresponds to.
+  //
+  // TODO: This, along with a check for non-null value operands, should be
+  // promoted to verifier failures.
+  Value *V = DVI->getValue();
+  if (!V)
+    return false;
+
+  // For now, don't try to interpret anything more complicated than an empty
+  // DIExpression. Eventually we should try to handle OP_deref and fragments.
+  if (DVI->getExpression()->getNumElements())
+    return false;
+
+  Type *Ty = V->getType();
+  uint64_t ValueOperandSize = getAllocSizeInBits(M, Ty);
+  Optional<uint64_t> DbgVarSize = DVI->getFragmentSizeInBits();
+  if (!ValueOperandSize || !DbgVarSize)
+    return false;
+
+  bool HasBadSize = Ty->isIntegerTy() ? (ValueOperandSize < *DbgVarSize)
+                                      : (ValueOperandSize != *DbgVarSize);
+  if (HasBadSize) {
+    dbg() << "ERROR: dbg.value operand has size " << ValueOperandSize
+          << ", but its variable has size " << *DbgVarSize << ": ";
+    DVI->print(dbg());
+    dbg() << "\n";
+  }
+  return HasBadSize;
+}
+
+bool checkDebugifyMetadata(Module &M,
+                           iterator_range<Module::iterator> Functions,
+                           StringRef NameOfWrappedPass, StringRef Banner,
+                           bool Strip) {
+  // Skip modules without debugify metadata.
+  NamedMDNode *NMD = M.getNamedMetadata("llvm.debugify");
+  if (!NMD) {
+    dbg() << Banner << "Skipping module without debugify metadata\n";
+    return false;
+  }
+
+  auto getDebugifyOperand = [&](unsigned Idx) -> unsigned {
+    return mdconst::extract<ConstantInt>(NMD->getOperand(Idx)->getOperand(0))
+        ->getZExtValue();
+  };
+  assert(NMD->getNumOperands() == 2 &&
+         "llvm.debugify should have exactly 2 operands!");
+  unsigned OriginalNumLines = getDebugifyOperand(0);
+  unsigned OriginalNumVars = getDebugifyOperand(1);
+  bool HasErrors = false;
+
+  BitVector MissingLines{OriginalNumLines, true};
+  BitVector MissingVars{OriginalNumVars, true};
+  for (Function &F : Functions) {
+    if (isFunctionSkipped(F))
+      continue;
+
+    // Find missing lines.
+    for (Instruction &I : instructions(F)) {
+      if (isa<DbgValueInst>(&I))
+        continue;
+
+      auto DL = I.getDebugLoc();
+      if (DL && DL.getLine() != 0) {
+        MissingLines.reset(DL.getLine() - 1);
+        continue;
+      }
+
+      if (!DL) {
+        dbg() << "ERROR: Instruction with empty DebugLoc in function ";
+        dbg() << F.getName() << " --";
+        I.print(dbg());
+        dbg() << "\n";
+        HasErrors = true;
+      }
+    }
+
+    // Find missing variables and mis-sized debug values.
+    for (Instruction &I : instructions(F)) {
+      auto *DVI = dyn_cast<DbgValueInst>(&I);
+      if (!DVI)
+        continue;
+
+      unsigned Var = ~0U;
+      (void)to_integer(DVI->getVariable()->getName(), Var, 10);
+      assert(Var <= OriginalNumVars && "Unexpected name for DILocalVariable");
+      bool HasBadSize = diagnoseMisSizedDbgValue(M, DVI);
+      if (!HasBadSize)
+        MissingVars.reset(Var - 1);
+      HasErrors |= HasBadSize;
+    }
+  }
+
+  // Print the results.
+  for (unsigned Idx : MissingLines.set_bits())
+    dbg() << "WARNING: Missing line " << Idx + 1 << "\n";
+
+  for (unsigned Idx : MissingVars.set_bits())
+    dbg() << "WARNING: Missing variable " << Idx + 1 << "\n";
+
+  dbg() << Banner;
+  if (!NameOfWrappedPass.empty())
+    dbg() << " [" << NameOfWrappedPass << "]";
+  dbg() << ": " << (HasErrors ? "FAIL" : "PASS") << '\n';
+
+  // Strip the Debugify Metadata if required.
+  if (Strip) {
+    StripDebugInfo(M);
+    M.eraseNamedMetadata(NMD);
+    return true;
+  }
+
+  return false;
+}
+
+/// Wrapper pass for attaching synthetic debug info to the module, to be used
+/// with the legacy module pass manager.
+class DebugifyModulePassWrapper : public ModulePass {
+  DebugifyModulePass P;
+
+public:
+  static char ID;
+
+  DebugifyModulePassWrapper() : ModulePass(ID) {
+    initializeDebugifyModulePassWrapperPass(*PassRegistry::getPassRegistry());
+  }
+  
+  bool runOnModule(Module &M) override {
+    ModuleAnalysisManager DummyMAM;
+    P.run(M, DummyMAM);
+    return P.getResult();
+  }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+  }
+
+  StringRef getPassName() const override { return P.name(); }
+};
+
+/// Wrapper pass for attaching synthetic debug info to a function, to be used
+/// with the legacy function pass manager.
+class DebugifyFunctionPassWrapper : public FunctionPass {
+  DebugifyFunctionPass P;
+
+public:
+  static char ID;
+
+  DebugifyFunctionPassWrapper() : FunctionPass(ID) {
+    initializeDebugifyFunctionPassWrapperPass(*PassRegistry::getPassRegistry());
+  }
+  
+  bool runOnFunction(Function &F) override {
+    FunctionAnalysisManager DummyFAM;
+    P.run(F, DummyFAM);
+    return P.getResult();
+  }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+  }
+
+  StringRef getPassName() const override { return P.name(); }
+};
+
+/// Pass for checking debug info inserted by DebugifyModulePass, to be used
+/// with the legacy module pass manager.
+class CheckDebugifyModulePassWrapper : public ModulePass {
+  CheckDebugifyModulePass P;
+
+public:
+  static char ID;
+
+  CheckDebugifyModulePassWrapper() : ModulePass(ID) {
+    initializeCheckDebugifyModulePassWrapperPass(
+        *PassRegistry::getPassRegistry());
+  }
+  CheckDebugifyModulePassWrapper(bool Strip, StringRef NameOfWrappedPass)
+      : ModulePass(ID), P(Strip, NameOfWrappedPass) {
+    initializeCheckDebugifyModulePassWrapperPass(
+        *PassRegistry::getPassRegistry());
+  }
+
+  bool runOnModule(Module &M) override {
+    ModuleAnalysisManager DummyMAM;
+    P.run(M, DummyMAM);
+    return P.getResult();
+  }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+  }
+
+  StringRef getPassName() const override { return P.name(); }
+};
+
+/// Pass for checking debug info inserted by DebugifyFunctionPass, to be used
+/// with the legacy function pass manager.
+struct CheckDebugifyFunctionPassWrapper : public FunctionPass {
+  CheckDebugifyFunctionPass P;
+
+public:
+  static char ID;
+
+  CheckDebugifyFunctionPassWrapper() : FunctionPass(ID) {
+    initializeCheckDebugifyFunctionPassWrapperPass(
+        *PassRegistry::getPassRegistry());
+  }
+  CheckDebugifyFunctionPassWrapper(bool Strip, StringRef NameOfWrappedPass)
+      : FunctionPass(ID), P(Strip, NameOfWrappedPass) {
+    initializeCheckDebugifyFunctionPassWrapperPass(
+        *PassRegistry::getPassRegistry());
+  }
+
+  bool runOnFunction(Function &F) override {
+    FunctionAnalysisManager DummyFAM;
+    P.run(F, DummyFAM);
+    return P.getResult();
+  }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+  }
+
+  StringRef getPassName() const override { return P.name(); }
+};
+
+} // end anonymous namespace
+
+// Debugify passes for new pass manager.
+PreservedAnalyses DebugifyModulePass::run(Module &M, ModuleAnalysisManager &) {
+  Result = applyDebugifyMetadata(M, M.functions(), "ModuleDebugify: ");
+  return PreservedAnalyses::all();
+}
+
+PreservedAnalyses DebugifyFunctionPass::run(Function &F,
+                                            FunctionAnalysisManager &) {
+  Module &M = *F.getParent();
+  auto FuncIt = F.getIterator();
+  Result = applyDebugifyMetadata(M, make_range(FuncIt, std::next(FuncIt)),
+                                 "FunctionDebugify: ");
+  return PreservedAnalyses::all();
+}
+
+CheckDebugifyModulePass::CheckDebugifyModulePass(bool Strip,
+                                                 StringRef NameOfWrappedPass)
+    : Strip(Strip), NameOfWrappedPass(NameOfWrappedPass) {}
+
+PreservedAnalyses CheckDebugifyModulePass::run(Module &M,
+                                               ModuleAnalysisManager &) {
+  Result = checkDebugifyMetadata(M, M.functions(), NameOfWrappedPass,
+                                 "CheckModuleDebugify", Strip);
+  return PreservedAnalyses::all();
+}
+
+CheckDebugifyFunctionPass::CheckDebugifyFunctionPass(bool Strip,
+                                                   StringRef NameOfWrappedPass)
+    : Strip(Strip), NameOfWrappedPass(NameOfWrappedPass) {}
+
+PreservedAnalyses CheckDebugifyFunctionPass::run(Function &F,
+                                                 FunctionAnalysisManager &) {
+  Module &M = *F.getParent();
+  auto FuncIt = F.getIterator();
+  Result = checkDebugifyMetadata(M, make_range(FuncIt, std::next(FuncIt)),
+                                 NameOfWrappedPass, "CheckFunctionDebugify",
+                                 Strip);
+  return PreservedAnalyses::all();
+}
+
+// Register the pass wrappers to the legacy pass manager.
+char DebugifyModulePassWrapper::ID = 0;
+INITIALIZE_PASS(DebugifyModulePassWrapper, "debugify",
+                "Attach debug info to the module", false, false)
+
+char CheckDebugifyModulePassWrapper::ID = 0;
+INITIALIZE_PASS(CheckDebugifyModulePassWrapper, "check-debugify",
+                "Check debug info inserted by DebugifyModulePass", false,
+                false)
+
+char DebugifyFunctionPassWrapper::ID = 0;
+INITIALIZE_PASS(DebugifyFunctionPassWrapper, "debugify-function",
+                "Attach debug info to a function", false, false)
+
+char CheckDebugifyFunctionPassWrapper::ID = 0;
+INITIALIZE_PASS(CheckDebugifyFunctionPassWrapper, "check-debugify-function",
+                "Check debug info inserted by DebugifyFunctionPass", false,
+                false)
+
+// API for use with the legacy pass manager.
+ModulePass *llvm::createDebugifyModulePass() {
+  return new DebugifyModulePassWrapper();
+}
+
+FunctionPass *llvm::createDebugifyFunctionPass() {
+  return new DebugifyFunctionPassWrapper();
+}
+
+ModulePass *llvm::createCheckDebugifyModulePass(bool Strip,
+                                          StringRef NameOfWrappedPass) {
+  return new CheckDebugifyModulePassWrapper(Strip, NameOfWrappedPass);
+}
+
+FunctionPass *llvm::createCheckDebugifyFunctionPass(bool Strip,
+                                              StringRef NameOfWrappedPass) {
+  return new CheckDebugifyFunctionPassWrapper(Strip, NameOfWrappedPass);
+}
+

lib/IR/LegacyPassManager.cpp

 //===- LegacyPassManager.cpp - LLVM Pass Infrastructure Implementation ----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the legacy LLVM Pass Manager infrastructure.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/IR/Debugify.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManagers.h"
 #include "llvm/IR/LegacyPassNameParser.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/CommandLine.h"

 static cl::opt<bool> PrintBeforeAll("print-before-all",
                                     llvm::cl::desc("Print IR before each pass"),
                                     cl::init(false), cl::Hidden);
 static cl::opt<bool> PrintAfterAll("print-after-all",
                                    llvm::cl::desc("Print IR after each pass"),
                                    cl::init(false), cl::Hidden);
 
 static cl::opt<bool>
+    DebugifyEach("debugify-each",
+                 cl::desc("Start each pass with debugify and end it with check-debugify"),
+                 cl::init(false), cl::Hidden);
+
+static cl::opt<bool>
     PrintModuleScope("print-module-scope",
                      cl::desc("When printing IR for print-[before|after]{-all} "
                               "always print a module IR"),
                      cl::init(false), cl::Hidden);
 
 static cl::list<std::string>
     PrintFuncsList("filter-print-funcs", cl::value_desc("function names"),
                    cl::desc("Only print IR for functions whose name "
if (ImmutablePass *IP = P->getAsImmutablePass()) {
     AnalysisResolver *AR = new AnalysisResolver(*DM);
     P->setResolver(AR);
     DM->initializeAnalysisImpl(P);
     addImmutablePass(IP);
     DM->recordAvailableAnalysis(IP);
     return;
   }
 
+  // We do not want to debugify Verifier, since it verifies in doFinalization()
+  // if 
+  bool shouldInsertDebugifyPasses = DebugifyEach && PI && !PI->isAnalysis();
+
   if (PI && !PI->isAnalysis() && ShouldPrintBeforePass(PI)) {
     Pass *PP = P->createPrinterPass(
         dbgs(), ("*** IR Dump Before " + P->getPassName() + " ***").str());
     PP->assignPassManager(activeStack, getTopLevelPassManagerType());
   }
 
+  if (shouldInsertDebugifyPasses) {
+    if (Pass *DP = P->createDebugifyPass()) {
+      DP->assignPassManager(activeStack, getTopLevelPassManagerType());
+    }
+  }
+
   // Add the requested pass to the best available pass manager.
   P->assignPassManager(activeStack, getTopLevelPassManagerType());
 
   if (PI && !PI->isAnalysis() && ShouldPrintAfterPass(PI)) {
     Pass *PP = P->createPrinterPass(
         dbgs(), ("*** IR Dump After " + P->getPassName() + " ***").str());
     PP->assignPassManager(activeStack, getTopLevelPassManagerType());
   }
+  if (shouldInsertDebugifyPasses) {
+    if (Pass *DP = P->createCheckDebugifyPass(true, P->getPassName())) {
+      DP->assignPassManager(activeStack, getTopLevelPassManagerType());
+    }
+  }
+
 }
 
 /// Find the pass that implements Analysis AID. Search immutable
 /// passes and all pass managers. If desired pass is not found
 /// then return NULL.
 Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) {
   // For immutable passes we have a direct mapping from ID to pass, so check
   // that first.

lib/IR/Pass.cpp

 // optimally.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Pass.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Debugify.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassNameParser.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/OptBisect.h"
 #include "llvm/PassInfo.h"
 #include "llvm/PassRegistry.h"

 // Pass Implementation
 //
 
 // Force out-of-line virtual method.
 Pass::~Pass() {
   delete Resolver;
 }
 
-// Force out-of-line virtual method.
-ModulePass::~ModulePass() = default;
-
-Pass *ModulePass::createPrinterPass(raw_ostream &OS,
-                                    const std::string &Banner) const {
-  return createPrintModulePass(OS, Banner);
-}
-
-PassManagerType ModulePass::getPotentialPassManagerType() const {
-  return PMT_ModulePassManager;
-}
-
-bool ModulePass::skipModule(Module &M) const {
-  return !M.getContext().getOptPassGate().shouldRunPass(this, M);
-}
-
 bool Pass::mustPreserveAnalysisID(char &AID) const {
   return Resolver->getAnalysisIfAvailable(&AID, true) != nullptr;
 }
 
 // dumpPassStructure - Implement the -debug-pass=Structure option
 void Pass::dumpPassStructure(unsigned Offset) {
   dbgs().indent(Offset*2) << getPassName() << "\n";
 }

 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 // dump - call print(cerr);
 LLVM_DUMP_METHOD void Pass::dump() const {
   print(dbgs(), nullptr);
 }
 #endif
 
+Pass *Pass::createDebugifyPass() {
+  switch (Kind) {
+    case PT_Module:
+      return createDebugifyModulePass();
+    case PT_Function:
+      return createDebugifyFunctionPass();
+    default:
+      return nullptr;
+  }
+}
+
+Pass *Pass::createCheckDebugifyPass(bool Strip, StringRef NameOfWrappedPass) {
+  switch (Kind) {
+    case PT_Module:
+      return createCheckDebugifyModulePass(Strip, NameOfWrappedPass);
+    case PT_Function:
+      return createCheckDebugifyFunctionPass(Strip, NameOfWrappedPass);
+    default:
+      return nullptr;
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // ImmutablePass Implementation
 //
 // Force out-of-line virtual method.
 ImmutablePass::~ImmutablePass() = default;
 
 void ImmutablePass::initializePass() {
   // By default, don't do anything.
 }
 
 //===----------------------------------------------------------------------===//
+// ModulePass Implementation
+//
+// Force out-of-line virtual method.
+ModulePass::~ModulePass() = default;
+
+Pass *ModulePass::createPrinterPass(raw_ostream &OS,
+                                    const std::string &Banner) const {
+  return createPrintModulePass(OS, Banner);
+}
+
+PassManagerType ModulePass::getPotentialPassManagerType() const {
+  return PMT_ModulePassManager;
+}
+
+bool ModulePass::skipModule(Module &M) const {
+  return !M.getContext().getOptPassGate().shouldRunPass(this, M);
+}
+
+//===----------------------------------------------------------------------===//
 // FunctionPass Implementation
 //
 
 Pass *FunctionPass::createPrinterPass(raw_ostream &OS,
                                       const std::string &Banner) const {
   return createPrintFunctionPass(OS, Banner);
 }
 

lib/IR/Verifier.cpp

if (auto *Array = N.getRawImportedEntities()) {
     }
   }
   if (auto *Array = N.getRawMacros()) {
     AssertDI(isa<MDTuple>(Array), "invalid macro list", &N, Array);
     for (Metadata *Op : N.getMacros()->operands()) {
       AssertDI(Op && isa<DIMacroNode>(Op), "invalid macro ref", &N, Op);
     }
   }
+  // We only want to verify real debug information, not synthetic inserted by
+  // Debugify.
+  if (N.getProducer() != "debugify")
     CUVisited.insert(&N);
 }
 
 void Verifier::visitDISubprogram(const DISubprogram &N) {
   AssertDI(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N);
   AssertDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope());
   if (auto *F = N.getRawFile())
     AssertDI(isa<DIFile>(F), "invalid file", &N, F);
   else

test/DebugInfo/debugify-each.c

+// RUN: clang -mllvm -debugify-each -emit-llvm -S -O1 -o - %s 2>&1 | \
+// RUN:         FileCheck %s 
+
+int main()
+{
+        int a = 3;
+        int b = 4;
+        return a + b;
+}
+
+// CHECK: CheckModuleDebugify [{{.*}}]: PASS
+// CHECK: CheckModuleDebugify [{{.*}}]: PASS
+
+// CHECK: CheckFunctionDebugify [{{.*}}]: PASS
+// CHECK: CheckFunctionDebugify [{{.*}}]: PASS
+// CHECK: CheckFunctionDebugify [{{.*}}]: PASS
+// CHECK: CheckFunctionDebugify [{{.*}}]: PASS

tools/opt/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   )
 
 # Support plugins.
 set(LLVM_NO_DEAD_STRIP 1)
 
 add_llvm_tool(opt
   AnalysisWrappers.cpp
   BreakpointPrinter.cpp
-  Debugify.cpp
   GraphPrinters.cpp
   NewPMDriver.cpp
   PassPrinters.cpp
   PrintSCC.cpp
   opt.cpp
 
   DEPENDS
   intrinsics_gen
   )
 export_executable_symbols(opt)
 
 if(WITH_POLLY AND LINK_POLLY_INTO_TOOLS)
   target_link_libraries(opt PRIVATE Polly)
 endif(WITH_POLLY AND LINK_POLLY_INTO_TOOLS)

tools/opt/Debugify.cpp

-//===- Debugify.cpp - Attach synthetic debug info to everything -----------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file This pass attaches synthetic debug info to everything. It can be used
-/// to create targeted tests for debug info preservation.
-///
-//===----------------------------------------------------------------------===//
-
-#include "PassPrinters.h"
-#include "llvm/ADT/BitVector.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/Constants.h"
-#include "llvm/IR/DIBuilder.h"
-#include "llvm/IR/DebugInfo.h"
-#include "llvm/IR/Function.h"
-#include "llvm/IR/GlobalVariable.h"
-#include "llvm/IR/InstIterator.h"
-#include "llvm/IR/Instruction.h"
-#include "llvm/IR/Instructions.h"
-#include "llvm/IR/IntrinsicInst.h"
-#include "llvm/IR/Module.h"
-#include "llvm/IR/Type.h"
-#include "llvm/Pass.h"
-#include "llvm/Support/raw_ostream.h"
-#include "llvm/Transforms/IPO.h"
-
-using namespace llvm;
-
-namespace {
-
-cl::opt<bool> Quiet("debugify-quiet",
-                    cl::desc("Suppress verbose debugify output"));
-
-raw_ostream &dbg() { return Quiet ? nulls() : errs(); }
-
-uint64_t getAllocSizeInBits(Module &M, Type *Ty) {
-  return Ty->isSized() ? M.getDataLayout().getTypeAllocSizeInBits(Ty) : 0;
-}
-
-bool isFunctionSkipped(Function &F) {
-  return F.isDeclaration() || !F.hasExactDefinition();
-}
-
-/// Find the basic block's terminating instruction.
-///
-/// Special care is needed to handle musttail and deopt calls, as these behave
-/// like (but are in fact not) terminators.
-Instruction *findTerminatingInstruction(BasicBlock &BB) {
-  if (auto *I = BB.getTerminatingMustTailCall())
-    return I;
-  if (auto *I = BB.getTerminatingDeoptimizeCall())
-    return I;
-  return BB.getTerminator();
-}
-
-bool applyDebugifyMetadata(Module &M,
-                           iterator_range<Module::iterator> Functions,
-                           StringRef Banner) {
-  // Skip modules with debug info.
-  if (M.getNamedMetadata("llvm.dbg.cu")) {
-    dbg() << Banner << "Skipping module with debug info\n";
-    return false;
-  }
-
-  DIBuilder DIB(M);
-  LLVMContext &Ctx = M.getContext();
-
-  // Get a DIType which corresponds to Ty.
-  DenseMap<uint64_t, DIType *> TypeCache;
-  auto getCachedDIType = [&](Type *Ty) -> DIType * {
-    uint64_t Size = getAllocSizeInBits(M, Ty);
-    DIType *&DTy = TypeCache[Size];
-    if (!DTy) {
-      std::string Name = "ty" + utostr(Size);
-      DTy = DIB.createBasicType(Name, Size, dwarf::DW_ATE_unsigned);
-    }
-    return DTy;
-  };
-
-  unsigned NextLine = 1;
-  unsigned NextVar = 1;
-  auto File = DIB.createFile(M.getName(), "/");
-  auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C, File, "debugify",
-                                  /*isOptimized=*/true, "", 0);
-
-  // Visit each instruction.
-  for (Function &F : Functions) {
-    if (isFunctionSkipped(F))
-      continue;
-
-    auto SPType = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
-    bool IsLocalToUnit = F.hasPrivateLinkage() || F.hasInternalLinkage();
-    auto SP =
-        DIB.createFunction(CU, F.getName(), F.getName(), File, NextLine, SPType,
-                           IsLocalToUnit, /*isDefinition=*/true, NextLine,
-                           DINode::FlagZero, /*isOptimized=*/true);
-    F.setSubprogram(SP);
-    for (BasicBlock &BB : F) {
-      // Attach debug locations.
-      for (Instruction &I : BB)
-        I.setDebugLoc(DILocation::get(Ctx, NextLine++, 1, SP));
-
-      // Inserting debug values into EH pads can break IR invariants.
-      if (BB.isEHPad())
-        continue;
-
-      // Find the terminating instruction, after which no debug values are
-      // attached.
-      Instruction *LastInst = findTerminatingInstruction(BB);
-      assert(LastInst && "Expected basic block with a terminator");
-
-      // Maintain an insertion point which can't be invalidated when updates
-      // are made.
-      BasicBlock::iterator InsertPt = BB.getFirstInsertionPt();
-      assert(InsertPt != BB.end() && "Expected to find an insertion point");
-      Instruction *InsertBefore = &*InsertPt;
-
-      // Attach debug values.
-      for (Instruction *I = &*BB.begin(); I != LastInst; I = I->getNextNode()) {
-        // Skip void-valued instructions.
-        if (I->getType()->isVoidTy())
-          continue;
-
-        // Phis and EH pads must be grouped at the beginning of the block.
-        // Only advance the insertion point when we finish visiting these.
-        if (!isa<PHINode>(I) && !I->isEHPad())
-          InsertBefore = I->getNextNode();
-
-        std::string Name = utostr(NextVar++);
-        const DILocation *Loc = I->getDebugLoc().get();
-        auto LocalVar = DIB.createAutoVariable(SP, Name, File, Loc->getLine(),
-                                               getCachedDIType(I->getType()),
-                                               /*AlwaysPreserve=*/true);
-        DIB.insertDbgValueIntrinsic(I, LocalVar, DIB.createExpression(), Loc,
-                                    InsertBefore);
-      }
-    }
-    DIB.finalizeSubprogram(SP);
-  }
-  DIB.finalize();
-
-  // Track the number of distinct lines and variables.
-  NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.debugify");
-  auto *IntTy = Type::getInt32Ty(Ctx);
-  auto addDebugifyOperand = [&](unsigned N) {
-    NMD->addOperand(MDNode::get(
-        Ctx, ValueAsMetadata::getConstant(ConstantInt::get(IntTy, N))));
-  };
-  addDebugifyOperand(NextLine - 1); // Original number of lines.
-  addDebugifyOperand(NextVar - 1);  // Original number of variables.
-  assert(NMD->getNumOperands() == 2 &&
-         "llvm.debugify should have exactly 2 operands!");
-
-  // Claim that this synthetic debug info is valid.
-  StringRef DIVersionKey = "Debug Info Version";
-  if (!M.getModuleFlag(DIVersionKey))
-    M.addModuleFlag(Module::Warning, DIVersionKey, DEBUG_METADATA_VERSION);
-
-  return true;
-}
-
-/// Return true if a mis-sized diagnostic is issued for \p DVI.
-bool diagnoseMisSizedDbgValue(Module &M, DbgValueInst *DVI) {
-  // The size of a dbg.value's value operand should match the size of the
-  // variable it corresponds to.
-  //
-  // TODO: This, along with a check for non-null value operands, should be
-  // promoted to verifier failures.
-  Value *V = DVI->getValue();
-  if (!V)
-    return false;
-
-  // For now, don't try to interpret anything more complicated than an empty
-  // DIExpression. Eventually we should try to handle OP_deref and fragments.
-  if (DVI->getExpression()->getNumElements())
-    return false;
-
-  Type *Ty = V->getType();
-  uint64_t ValueOperandSize = getAllocSizeInBits(M, Ty);
-  Optional<uint64_t> DbgVarSize = DVI->getFragmentSizeInBits();
-  if (!ValueOperandSize || !DbgVarSize)
-    return false;
-
-  bool HasBadSize = false;
-  if (Ty->isIntegerTy()) {
-    auto Signedness = DVI->getVariable()->getSignedness();
-    if (Signedness && *Signedness == DIBasicType::Signedness::Signed)
-      HasBadSize = ValueOperandSize < *DbgVarSize;
-  } else {
-    HasBadSize = ValueOperandSize != *DbgVarSize;
-  }
-
-  if (HasBadSize) {
-    dbg() << "ERROR: dbg.value operand has size " << ValueOperandSize
-          << ", but its variable has size " << *DbgVarSize << ": ";
-    DVI->print(dbg());
-    dbg() << "\n";
-  }
-  return HasBadSize;
-}
-
-bool checkDebugifyMetadata(Module &M,
-                           iterator_range<Module::iterator> Functions,
-                           StringRef NameOfWrappedPass, StringRef Banner,
-                           bool Strip) {
-  // Skip modules without debugify metadata.
-  NamedMDNode *NMD = M.getNamedMetadata("llvm.debugify");
-  if (!NMD) {
-    dbg() << Banner << "Skipping module without debugify metadata\n";
-    return false;
-  }
-
-  auto getDebugifyOperand = [&](unsigned Idx) -> unsigned {
-    return mdconst::extract<ConstantInt>(NMD->getOperand(Idx)->getOperand(0))
-        ->getZExtValue();
-  };
-  assert(NMD->getNumOperands() == 2 &&
-         "llvm.debugify should have exactly 2 operands!");
-  unsigned OriginalNumLines = getDebugifyOperand(0);
-  unsigned OriginalNumVars = getDebugifyOperand(1);
-  bool HasErrors = false;
-
-  BitVector MissingLines{OriginalNumLines, true};
-  BitVector MissingVars{OriginalNumVars, true};
-  for (Function &F : Functions) {
-    if (isFunctionSkipped(F))
-      continue;
-
-    // Find missing lines.
-    for (Instruction &I : instructions(F)) {
-      if (isa<DbgValueInst>(&I))
-        continue;
-
-      auto DL = I.getDebugLoc();
-      if (DL && DL.getLine() != 0) {
-        MissingLines.reset(DL.getLine() - 1);
-        continue;
-      }
-
-      if (!DL) {
-        dbg() << "ERROR: Instruction with empty DebugLoc in function ";
-        dbg() << F.getName() << " --";
-        I.print(dbg());
-        dbg() << "\n";
-        HasErrors = true;
-      }
-    }
-
-    // Find missing variables and mis-sized debug values.
-    for (Instruction &I : instructions(F)) {
-      auto *DVI = dyn_cast<DbgValueInst>(&I);
-      if (!DVI)
-        continue;
-
-      unsigned Var = ~0U;
-      (void)to_integer(DVI->getVariable()->getName(), Var, 10);
-      assert(Var <= OriginalNumVars && "Unexpected name for DILocalVariable");
-      bool HasBadSize = diagnoseMisSizedDbgValue(M, DVI);
-      if (!HasBadSize)
-        MissingVars.reset(Var - 1);
-      HasErrors |= HasBadSize;
-    }
-  }
-
-  // Print the results.
-  for (unsigned Idx : MissingLines.set_bits())
-    dbg() << "WARNING: Missing line " << Idx + 1 << "\n";
-
-  for (unsigned Idx : MissingVars.set_bits())
-    dbg() << "WARNING: Missing variable " << Idx + 1 << "\n";
-
-  dbg() << Banner;
-  if (!NameOfWrappedPass.empty())
-    dbg() << " [" << NameOfWrappedPass << "]";
-  dbg() << ": " << (HasErrors ? "FAIL" : "PASS") << '\n';
-
-  // Strip the Debugify Metadata if required.
-  if (Strip) {
-    StripDebugInfo(M);
-    M.eraseNamedMetadata(NMD);
-    return true;
-  }
-
-  return false;
-}
-
-/// ModulePass for attaching synthetic debug info to everything, used with the
-/// legacy module pass manager.
-struct DebugifyModulePass : public ModulePass {
-  bool runOnModule(Module &M) override {
-    return applyDebugifyMetadata(M, M.functions(), "ModuleDebugify: ");
-  }
-
-  DebugifyModulePass() : ModulePass(ID) {}
-
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.setPreservesAll();
-  }
-
-  static char ID; // Pass identification.
-};
-
-/// FunctionPass for attaching synthetic debug info to instructions within a
-/// single function, used with the legacy module pass manager.
-struct DebugifyFunctionPass : public FunctionPass {
-  bool runOnFunction(Function &F) override {
-    Module &M = *F.getParent();
-    auto FuncIt = F.getIterator();
-    return applyDebugifyMetadata(M, make_range(FuncIt, std::next(FuncIt)),
-                                 "FunctionDebugify: ");
-  }
-
-  DebugifyFunctionPass() : FunctionPass(ID) {}
-
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.setPreservesAll();
-  }
-
-  static char ID; // Pass identification.
-};
-
-/// ModulePass for checking debug info inserted by -debugify, used with the
-/// legacy module pass manager.
-struct CheckDebugifyModulePass : public ModulePass {
-  bool runOnModule(Module &M) override {
-    return checkDebugifyMetadata(M, M.functions(), NameOfWrappedPass,
-                                 "CheckModuleDebugify", Strip);
-  }
-
-  CheckDebugifyModulePass(bool Strip = false, StringRef NameOfWrappedPass = "")
-      : ModulePass(ID), Strip(Strip), NameOfWrappedPass(NameOfWrappedPass) {}
-
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.setPreservesAll();
-  }
-
-  static char ID; // Pass identification.
-
-private:
-  bool Strip;
-  StringRef NameOfWrappedPass;
-};
-
-/// FunctionPass for checking debug info inserted by -debugify-function, used
-/// with the legacy module pass manager.
-struct CheckDebugifyFunctionPass : public FunctionPass {
-  bool runOnFunction(Function &F) override {
-    Module &M = *F.getParent();
-    auto FuncIt = F.getIterator();
-    return checkDebugifyMetadata(M, make_range(FuncIt, std::next(FuncIt)),
-                                 NameOfWrappedPass, "CheckFunctionDebugify",
-                                 Strip);
-  }
-
-  CheckDebugifyFunctionPass(bool Strip = false,
-                            StringRef NameOfWrappedPass = "")
-      : FunctionPass(ID), Strip(Strip), NameOfWrappedPass(NameOfWrappedPass) {}
-
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.setPreservesAll();
-  }
-
-  static char ID; // Pass identification.
-
-private:
-  bool Strip;
-  StringRef NameOfWrappedPass;
-};
-
-} // end anonymous namespace
-
-ModulePass *createDebugifyModulePass() { return new DebugifyModulePass(); }
-
-FunctionPass *createDebugifyFunctionPass() {
-  return new DebugifyFunctionPass();
-}
-
-PreservedAnalyses NewPMDebugifyPass::run(Module &M, ModuleAnalysisManager &) {
-  applyDebugifyMetadata(M, M.functions(), "ModuleDebugify: ");
-  return PreservedAnalyses::all();
-}
-
-ModulePass *createCheckDebugifyModulePass(bool Strip,
-                                          StringRef NameOfWrappedPass) {
-  return new CheckDebugifyModulePass(Strip, NameOfWrappedPass);
-}
-
-FunctionPass *createCheckDebugifyFunctionPass(bool Strip,
-                                              StringRef NameOfWrappedPass) {
-  return new CheckDebugifyFunctionPass(Strip, NameOfWrappedPass);
-}
-
-PreservedAnalyses NewPMCheckDebugifyPass::run(Module &M,
-                                              ModuleAnalysisManager &) {
-  checkDebugifyMetadata(M, M.functions(), "", "CheckModuleDebugify", false);
-  return PreservedAnalyses::all();
-}
-
-char DebugifyModulePass::ID = 0;
-static RegisterPass<DebugifyModulePass> DM("debugify",
-                                           "Attach debug info to everything");
-
-char CheckDebugifyModulePass::ID = 0;
-static RegisterPass<CheckDebugifyModulePass>
-    CDM("check-debugify", "Check debug info from -debugify");
-
-char DebugifyFunctionPass::ID = 0;
-static RegisterPass<DebugifyFunctionPass> DF("debugify-function",
-                                             "Attach debug info to a function");
-
-char CheckDebugifyFunctionPass::ID = 0;
-static RegisterPass<CheckDebugifyFunctionPass>
-    CDF("check-debugify-function", "Check debug info from -debugify-function");

tools/opt/NewPMDriver.cpp

 //===- NewPMDriver.cpp - Driver for opt with new PM -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file is just a split of the code that logically belongs in opt.cpp but
 /// that includes the new pass manager headers.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "NewPMDriver.h"
-#include "PassPrinters.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/Config/llvm-config.h"
+#include "llvm/IR/Debugify.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Passes/PassPlugin.h"
for (auto &PluginFN : PassPlugins) {
     PassPlugin->registerPassBuilderCallbacks(PB);
   }
 
   // Register a callback that creates the debugify passes as needed.
   PB.registerPipelineParsingCallback(
       [](StringRef Name, ModulePassManager &MPM,
          ArrayRef<PassBuilder::PipelineElement>) {
         if (Name == "debugify") {
-          MPM.addPass(NewPMDebugifyPass());
+          MPM.addPass(DebugifyModulePass());
           return true;
         } else if (Name == "check-debugify") {
-          MPM.addPass(NewPMCheckDebugifyPass());
+          MPM.addPass(CheckDebugifyModulePass());
           return true;
         }
         return false;
       });
 
 #ifdef LINK_POLLY_INTO_TOOLS
   polly::RegisterPollyPasses(PB);
 #endif
#endif
   PB.registerFunctionAnalyses(FAM);
   PB.registerLoopAnalyses(LAM);
   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
 
   ModulePassManager MPM(DebugPM);
   if (VK > VK_NoVerifier)
     MPM.addPass(VerifierPass());
   if (EnableDebugify)
-    MPM.addPass(NewPMDebugifyPass());
+    MPM.addPass(DebugifyModulePass());
 
   if (!PB.parsePassPipeline(MPM, PassPipeline, VerifyEachPass, DebugPM)) {
     errs() << Arg0 << ": unable to parse pass pipeline description.\n";
     return false;
   }
 
   if (VK > VK_NoVerifier)
     MPM.addPass(VerifierPass());
   if (EnableDebugify)
-    MPM.addPass(NewPMCheckDebugifyPass());
+    MPM.addPass(CheckDebugifyModulePass());
 
   // Add any relevant output pass at the end of the pipeline.
   switch (OK) {
   case OK_NoOutput:
     break; // No output pass needed.
   case OK_OutputAssembly:
     MPM.addPass(
         PrintModulePass(Out->os(), "", ShouldPreserveAssemblyUseListOrder));

tools/opt/PassPrinters.h

 RegionPass *createRegionPassPrinter(const PassInfo *PI, raw_ostream &out,
                                     bool Quiet);
 
 BasicBlockPass *createBasicBlockPassPrinter(const PassInfo *PI,
                                             raw_ostream &out, bool Quiet);
 
 } // end namespace llvm
 
-llvm::ModulePass *createDebugifyModulePass();
-llvm::FunctionPass *createDebugifyFunctionPass();
-
-struct NewPMDebugifyPass : public llvm::PassInfoMixin<NewPMDebugifyPass> {
-  llvm::PreservedAnalyses run(llvm::Module &M, llvm::ModuleAnalysisManager &AM);
-};
-
-llvm::ModulePass *
-createCheckDebugifyModulePass(bool Strip = false,
-                              llvm::StringRef NameOfWrappedPass = "");
-
-llvm::FunctionPass *
-createCheckDebugifyFunctionPass(bool Strip = false,
-                                llvm::StringRef NameOfWrappedPass = "");
-
-struct NewPMCheckDebugifyPass
-    : public llvm::PassInfoMixin<NewPMCheckDebugifyPass> {
-  llvm::PreservedAnalyses run(llvm::Module &M, llvm::ModuleAnalysisManager &AM);
-};
-
 #endif // LLVM_TOOLS_OPT_PASSPRINTERS_H

tools/opt/opt.cpp

 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/CodeGen/CommandFlags.inc"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfo.h"
+#include "llvm/IR/Debugify.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/LegacyPassNameParser.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/InitializePasses.h"

 static cl::opt<bool>
 AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization"));
 
 static cl::opt<bool> EnableDebugify(
     "enable-debugify",
     cl::desc(
         "Start the pipeline with debugify and end it with check-debugify"));
 
-static cl::opt<bool> DebugifyEach(
-    "debugify-each",
-    cl::desc(
-        "Start each pass with debugify and end it with check-debugify"));
-
 static cl::opt<bool>
 PrintBreakpoints("print-breakpoints-for-testing",
                  cl::desc("Print select breakpoints location for testing"));
 
 static cl::opt<std::string> ClDataLayout("data-layout",
                                          cl::desc("data layout string to use"),
                                          cl::value_desc("layout-string"),
                                          cl::init(""));
static cl::opt<unsigned> PassRemarksHotnessThreshold(
     cl::desc("Minimum profile count required for an optimization remark to be output"),
     cl::Hidden);
 
 static cl::opt<std::string>
     RemarksFilename("pass-remarks-output",
                     cl::desc("YAML output filename for pass remarks"),
                     cl::value_desc("filename"));
 
-class OptCustomPassManager : public legacy::PassManager {
-public:
-  using super = legacy::PassManager;
-
-  void add(Pass *P) override {
-    bool WrapWithDebugify = DebugifyEach && !P->getAsImmutablePass() &&
-                            !isIRPrintingPass(P) && !isBitcodeWriterPass(P);
-    if (!WrapWithDebugify) {
-      super::add(P);
-      return;
-    }
-    PassKind Kind = P->getPassKind();
-    // TODO: Implement Debugify for BasicBlockPass, LoopPass.
-    switch (Kind) {
-      case PT_Function:
-        super::add(createDebugifyFunctionPass());
-        super::add(P);
-        super::add(createCheckDebugifyFunctionPass(true, P->getPassName()));
-        break;
-      case PT_Module:
-        super::add(createDebugifyModulePass());
-        super::add(P);
-        super::add(createCheckDebugifyModulePass(true, P->getPassName()));
-        break;
-      default:
-        super::add(P);
-        break;
-    }
-  }
-};
-
 static inline void addPass(legacy::PassManagerBase &PM, Pass *P) {
   // Add the pass to the pass manager...
   PM.add(P);
 
   // If we are verifying all of the intermediate steps, add the verifier...
   if (VerifyEach)
     PM.add(createVerifierPass());
 }
return runPassPipeline(argv[0], *M, TM.get(), Out.get(), ThinLinkOut.get(),
                            PreserveBitcodeUseListOrder, EmitSummaryIndex,
                            EmitModuleHash, EnableDebugify)
                ? 0
                : 1;
   }
 
   // Create a PassManager to hold and optimize the collection of passes we are
   // about to build.
-  OptCustomPassManager Passes;
-  bool AddOneTimeDebugifyPasses = EnableDebugify && !DebugifyEach;
+  legacy::PassManager Passes;
 
   // Add an appropriate TargetLibraryInfo pass for the module's triple.
   TargetLibraryInfoImpl TLII(ModuleTriple);
 
   // The -disable-simplify-libcalls flag actually disables all builtin optzns.
   if (DisableSimplifyLibCalls)
     TLII.disableAllFunctions();
   Passes.add(new TargetLibraryInfoWrapperPass(TLII));
 
   // Add internal analysis passes from the target machine.
   Passes.add(createTargetTransformInfoWrapperPass(TM ? TM->getTargetIRAnalysis()
                                                      : TargetIRAnalysis()));
 
-  if (AddOneTimeDebugifyPasses)
+  if (EnableDebugify)
     Passes.add(createDebugifyModulePass());
 
   std::unique_ptr<legacy::FunctionPassManager> FPasses;
   if (OptLevelO0 || OptLevelO1 || OptLevelO2 || OptLevelOs || OptLevelOz ||
       OptLevelO3) {
     FPasses.reset(new legacy::FunctionPassManager(M.get()));
     FPasses->add(createTargetTransformInfoWrapperPass(
         TM ? TM->getTargetIRAnalysis() : TargetIRAnalysis()));
for (Function &F : *M)
       FPasses->run(F);
     FPasses->doFinalization();
   }
 
   // Check that the module is well formed on completion of optimization
   if (!NoVerify && !VerifyEach)
     Passes.add(createVerifierPass());
 
-  if (AddOneTimeDebugifyPasses)
+  if (EnableDebugify)
     Passes.add(createCheckDebugifyModulePass(false));
 
   // In run twice mode, we want to make sure the output is bit-by-bit
   // equivalent if we run the pass manager again, so setup two buffers and
   // a stream to write to them. Note that llc does something similar and it
   // may be worth to abstract this out in the future.
   SmallVector<char, 0> Buffer;
   SmallVector<char, 0> FirstRunBuffer;