[Debugify] Add a pass to test debug info preservation

[vsk]

Summary

The Debugify pass synthesizes debug info for IR. It's paired with a
CheckDebugify pass which determines how much of the original debug info
is preserved. These passes make it easier to create targeted tests for
debug info preservation.

Here is the Debugify algorithm:

NextLine = 1
for (Instruction &I : M)
  attach DebugLoc(NextLine++) to I

NextVar = 1
for (Instruction &I : M)
  if (canAttachDebugValue(I))
    attach dbg.value(NextVar++) to I

The CheckDebugify pass expects contiguous ranges of DILocations and
DILocalVariables. If it fails to find all of the expected debug info, it
prints a specific error to stderr which can be FileChecked.

Example usage:

opt -debugify -mem2reg -check-debugify | grep "CheckDebugify: PASS"

opt -debugify -loop-reduce -check-debugify | grep "CheckDebugify: FAIL"

[davide]

Thank you Vedant, some comments inline.

lib/Transforms/Utils/Debugify.cpp

60–62 ↗

(On Diff #124435)

ehm, are you sure this is right?
This will break for code emitted by another frontend.

77–81 ↗

(On Diff #124435)

is there a way to avoid two scans of the whole module?

148 ↗

(On Diff #124435)

Why a bitvector?

149–151 ↗

(On Diff #124435)

You can probably use
F.instructions() here.

173–175 ↗

(On Diff #124435)

I think you can simplify this writing

for (Instruction &I: F.instructions())

or something [check include/llvm/IR/]

181–183 ↗

(On Diff #124435)

Can you fold valid inside the assertion and avoid the
(void)Valid hack?

212 ↗

(On Diff #124435)

I think the 3rd or 4th parameter should be true?
If this preserves everything, also preserves the CFG?

Also, isn't something that preserves everything (i.e. doesn't mutate the IR) technically an analysis?

212–215 ↗

(On Diff #124435)

INITIALIZE_PASS will suffice.

[vsk]

Thanks for your comments Davide!

lib/Transforms/Utils/Debugify.cpp

60–62 ↗

(On Diff #124435)

I really want to say "pick any language" here. This pass ignores IR which already has debug info, so I'm not sure what breaks -- could you clarify?

77–81 ↗

(On Diff #124435)

These loops could be combined. IMO it's just slightly neater to write the early break in the second loop if it's a separate loop.

148 ↗

(On Diff #124435)

It seems like a cheap way to track whether or not we've seen each line. I originally wanted to use an IntervalMap, but it has no mechanism to remove a mapping, or to iterate over holes in the mapping.

149–151 ↗

(On Diff #124435)

Thanks! Will fix.

173–175 ↗

(On Diff #124435)

Will fix.

181–183 ↗

(On Diff #124435)

AFAIK we need the hack to avoid -Wunused in non-asserts builds.

212 ↗

(On Diff #124435)

Thanks for the catch! Do you think this belongs in lib/Analysis?

212–215 ↗

(On Diff #124435)

Will fix.

[davide]

lib/Transforms/Utils/Debugify.cpp

60–62 ↗

(On Diff #124435)

The scenario I have in mind is the one where you have rust emitting an IR module without debug info and then running this pass on it (where you get a C++11 compile unit).
I guess there's no real to understand which frontend is emitting the IR unless the frontend emits enough metadata for the mid-level optimizer to find out which language is this IR derived from.

Another example is, what if you have code compiled with -std=c++98/-std=c++03, without debuginfo on which you call this pass?
I think in that case is setting C_plus_plus_11 always correct? I'm not sure myself, so please correct me if I'm wrong.

77–81 ↗

(On Diff #124435)

Fair enough. I'm just slightly worried about LTO as scanning the whole module can become really expensive. I guess we'll measure and see :)

148 ↗

(On Diff #124435)

Sounds reasonable. I thought you benchmarked vs DenseMap and found it a big win.
FWIW, if you have lots of setrange operations, it definitely is, in fact some algorithms use it as a cheap worklist (e.g. NewGVN).

181–183 ↗

(On Diff #124435)

even if you write
assert(to_integer() && "patatino") ?

212 ↗

(On Diff #124435)

Could be (at least in my opinion). I'm not sure whether metadata added are considered something IR transformations, as passes can just ignore them willy-nilly.
I think Chandler is the best person to comment on this one after years on the pass manager design. Ideally, you might also bring this up on llvm-dev.

[vsk]

• Hook into the new pass manager.
• Address review feedback from Davide, except for the bit about moving to lib/Analysis/, which I'll discuss in an inline comment.

lib/Transforms/Utils/Debugify.cpp

60–62 ↗

(On Diff #124435)

I don't think there's any correct language value we could use here due to the issue you point out. In practice, it shouldn't matter unless you actually try to load a debugified module in a debugger, which is a non-goal. I can keep things simple here by just using DW_LANG_C.

148 ↗

(On Diff #124435)

Gotcha. I didn't benchmark against DenseMap -- I just visualized 'MissingLines' as a bitmap and went down that route.

181–183 ↗

(On Diff #124435)

Then we'd need to call to_integer() twice (for the non-asserts and asserts paths), which doesn't seem better.

212 ↗

(On Diff #124435)

Based on docs/Passes, I think CheckDebugify best fits under the category of Utility passes. It doesn't provide information for other passes and it doesn't transform the IR.

The Debugify pass does technically provide information for another pass, but IMO it doesn't make sense to try to preserve/cache/invalidate its results, so it doesn't quite seem like an analysis either.

[probinson]

lib/Transforms/Utils/Debugify.cpp

60–62 ↗

(On Diff #124435)

The pass is not adding true source information, e.g. types, so the language is irrelevant. The goal is to see whether info attached to the IR is preserved, not to emit anything useful. No debugger will ever see this output, and probably not even llvm-dwarfdump.
You could do something more obviously bogus, like DW_LANG_Ada83. We don't have a language code for IR.

test/Transforms/LoopStrengthReduce/debug-info.ll

1 ↗

(On Diff #124488)

This doesn't seem very useful.

[mgrang]

lib/Transforms/Utils/Debugify.cpp

162 ↗

(On Diff #124488)

How about you wrap the "bool Valid" definition and the assert inside #ifndef NDEBUG ? You can then get rid of the (void) Valid.

[vsk]

• Remove an unnecessary test case pointed out by Paul Robinson.

lib/Transforms/Utils/Debugify.cpp

162 ↗

(On Diff #124488)

I'm not sure how Valid would be set in the asserts-enabled case, then.

test/Transforms/LoopStrengthReduce/debug-info.ll

1 ↗

(On Diff #124488)

Fair point. There's an easier way to add a negative test -- just run '-debugify -strip-debug -check-debugify' and check that it fails.

[MatzeB]

Thanks this is a great idea!

I assume this will only ever be used via opt, so you could move the pass to llvm/tools/opt to keep the size of the llvm libraries smaller.

[probinson]

In D40512#944484, @MatzeB wrote:

Thanks this is a great idea!

I assume this will only ever be used via opt, so you could move the pass to llvm/tools/opt to keep the size of the llvm libraries smaller.

Oh nice! It was making me uncomfortable to have a debugging-only pass that would be just taking up space in a production compiler, but I didn't know opt had (effectively) private passes.

[vsk]

• Move Debugify* to tools/opt, which simplifies the patch and avoids bloating llvm. Thanks @MatzeB for the suggestion!

[davide]

This looks good to me modulo minor, happy to see this in if Matthias/Adrian are happy with it.

tools/opt/Debugify.cpp

54 ↗

(On Diff #125595)

should this be return true?

143–144 ↗

(On Diff #125595)

I wonder whether this should be under DEBUG(), so that we don't clutter the release builds?

[vsk]

• Make the return type in a lambda explicit, & a minor tweak to an assert.

tools/opt/Debugify.cpp

54 ↗

(On Diff #125595)

This needs to return a DIType, but that could be made clearer. I'll make the return type explicit.

143–144 ↗

(On Diff #125595)

I'd rather not do that, since -check-debugify should indicate that the author is interested in messages related to debug info.

[aprantl]

tools/opt/Debugify.cpp

79 ↗

(On Diff #125595)

Sorry for having this idea so late, but: Would it make sense to combine this with the DebugIR pass, so, instead of assigning arbitrary artificial DILocations, the DILocations actually point back to the original instructions in the IR and are perhaps more useful when debugging a pass?

174 ↗

(On Diff #125595)

Doxygen comment explaining the purpose of the pass?

186 ↗

(On Diff #125595)

comment?

[MatzeB]

LGTM to go in tree. Comments/nitpicks below.

tools/opt/Debugify.cpp

10–11 ↗

(On Diff #125595)

Could use /// \file This pass ... so doxygen picks it up.

38–40 ↗

(On Diff #125595)

Maybe write a warning to the user to avoid surprises?

43 ↗

(On Diff #125595)

I'm personally no fan of auto if you cannot deduce the type immediately. It's not a deal breaker but I consider it friendlier to readers if types are spelled out as much as possible. With the only exception being auto X = dyn_cast<xxx>() as the xxx type can be seen in the same line or lambdas where the type is also obvious from the RHS of the assignment.

51–52 ↗

(On Diff #125595)

I don't know the DIB API, but seeing that createBasicType takes a StringRef makes me wonder if it actually takes the string and copies it or whether we will end up with a reference to a temporary std::string here?

143–146 ↗

(On Diff #125595)

I think simply printing is fine for a pass like this. I would probably print to stdout as this feels more like the "normal" output of this pass rather than an error condition (from the perspective of this pass).

If you wanted to you could also take a look at this Pass::print() thing we have as sort of an official interface to have a pass print information as part of opt. Though I don't know for sure whether it would work as intended here (and I would expect it to be little better than directly printing as is done here).

[vsk]

• Address comments by Adrian and Matthias.

tools/opt/Debugify.cpp

10–11 ↗

(On Diff #125595)

Will fix.

38–40 ↗

(On Diff #125595)

Will fix.

43 ↗

(On Diff #125595)

Will fix.

51–52 ↗

(On Diff #125595)

The stringref is internalized by MDString::get, and some canonical string is pulled out (possibly after a copy).

79 ↗

(On Diff #125595)

I don't think there's a way to unify the two tools in a way that's simpler than keeping them separate. We need separate code paths to mark-up *.ll files on disk vs. in-memory Modules. Secondly, to implement -check-debugify on DebugIR output, we'd need to do do extra work to store a list of all DILocations in a separate piece of metadata. IMO having a separate code path for DebugIR would be neater and less complicated.

143–146 ↗

(On Diff #125595)

Printing to stdout sgtm, but the Pass::print() mechanism seems a bit heavyweight given how this is structured.

174 ↗

(On Diff #125595)

Will fix.

186 ↗

(On Diff #125595)

Will fix.

[MatzeB]

tools/opt/Debugify.cpp

10–11 ↗

(On Diff #125595)

Needs three slashes for doxygen :)

[vsk]

Thanks everybody for your feedback. I think I've addressed all of it now. I'll commit this tomorrow barring any further comments.

tools/opt/Debugify.cpp

10–11 ↗

(On Diff #125595)

Will fix.

79 ↗

(On Diff #125595)

Adrian and I had an off-line conversation about this, in which we reached the conclusion that it would be neater to keep the DebugIR code path separate from this pass.

llvm/trunk/docs/ReleaseNotes.rst

* The ``Redirects`` argument of ``llvm::sys::ExecuteAndWait`` and
   ``llvm::sys::ExecuteNoWait`` was changed to an ``ArrayRef`` of optional
   ``StringRef``'s to make it safer and more convenient to use.
 
 * The backend name was added to the Target Registry to allow run-time
   information to be fed back into TableGen. Out-of-tree targets will need to add
   the name used in the `def X : Target` definition to the call to
   `RegisterTarget`.
 
+* The ``Debugify`` pass was added to ``opt`` to facilitate testing of debug
+  info preservation. This pass attaches synthetic ``DILocations`` and
+  ``DIVariables`` to the instructions in a ``Module``. The ``CheckDebugify``
+  pass determines how much of the metadata is lost.
+
 * Note..
 
 .. NOTE
    If you would like to document a larger change, then you can add a
    subsection about it right here. You can copy the following boilerplate
    and un-indent it (the indentation causes it to be inside this comment).
 
    Special New Feature

llvm/trunk/test/DebugInfo/debugify.ll

+; RUN: opt -debugify -S -o - < %s | FileCheck %s
+
+; RUN: opt -debugify -debugify -S -o - < %s 2>&1 | \
+; RUN:   FileCheck %s -check-prefix=CHECK-REPEAT
+
+; RUN: opt -debugify -check-debugify -S -o - < %s | \
+; RUN:   FileCheck %s -implicit-check-not="CheckDebugify: FAIL"
+
+; RUN: opt -debugify -strip -check-debugify -S -o - < %s | \
+; RUN:   FileCheck %s -check-prefix=CHECK-FAIL
+
+; CHECK-LABEL: define void @foo
+define void @foo() {
+; CHECK: ret void, !dbg ![[RET1:.*]]
+  ret void
+}
+
+; CHECK-LABEL: define i32 @bar
+define i32 @bar() {
+; CHECK: call void @foo(), !dbg ![[CALL1:.*]]
+  call void @foo()
+
+; CHECK: add i32 0, 1, !dbg ![[ADD1:.*]]
+  %sum = add i32 0, 1
+
+; CHECK: ret i32 0, !dbg ![[RET2:.*]]
+  ret i32 0
+}
+
+; CHECK-DAG: !llvm.dbg.cu = !{![[CU:.*]]}
+; CHECK-DAG: !llvm.debugify = !{![[NUM_INSTS:.*]], ![[NUM_VARS:.*]]}
+
+; CHECK-DAG: ![[CU]] = distinct !DICompileUnit(language: DW_LANG_C, file: {{.*}}, producer: "debugify", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: {{.*}})
+; CHECK-DAG: !DIFile(filename: "<stdin>", directory: "/")
+; CHECK-DAG: distinct !DISubprogram(name: "foo", linkageName: "foo", scope: null, file: {{.*}}, line: 1, type: {{.*}}, isLocal: false, isDefinition: true, scopeLine: 1, isOptimized: true, unit: {{.*}}, variables: {{.*}})
+; CHECK-DAG: distinct !DISubprogram(name: "bar", linkageName: "bar", scope: null, file: {{.*}}, line: 2, type: {{.*}}, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: {{.*}}, variables: {{.*}})
+
+; --- DILocations
+; CHECK-DAG: ![[RET1]] = !DILocation(line: 1, column: 1
+; CHECK-DAG: ![[CALL1]] = !DILocation(line: 2, column: 1
+; CHECK-DAG: ![[ADD1]] = !DILocation(line: 3, column: 1
+; CHECK-DAG: ![[RET2]] = !DILocation(line: 4, column: 1
+
+; --- DILocalVariables
+; CHECK-DAG: ![[TY32:.*]] = !DIBasicType(name: "ty32", size: 32, encoding: DW_ATE_unsigned)
+; CHECK-DAG: !DILocalVariable(name: "1", scope: {{.*}}, file: {{.*}}, line: 3, type: ![[TY32]])
+
+; --- Metadata counts
+; CHECK-DAG: ![[NUM_INSTS]] = !{i32 4}
+; CHECK-DAG: ![[NUM_VARS]] = !{i32 1}
+
+; --- Repeat case
+; CHECK-REPEAT: Debugify: Skipping module with debug info
+
+; --- Failure case
+; CHECK-FAIL: ERROR: Instruction with empty DebugLoc --   ret void
+; CHECK-FAIL: ERROR: Instruction with empty DebugLoc --   call void @foo()
+; CHECK-FAIL: ERROR: Instruction with empty DebugLoc --   {{.*}} add i32 0, 1
+; CHECK-FAIL: ERROR: Instruction with empty DebugLoc --   ret i32 0
+; CHECK-FAIL: WARNING: Missing line 1
+; CHECK-FAIL: WARNING: Missing line 2
+; CHECK-FAIL: WARNING: Missing line 3
+; CHECK-FAIL: WARNING: Missing line 4
+; CHECK-FAIL: ERROR: Missing variable 1
+; CHECK-FAIL: CheckDebugify: FAIL

llvm/trunk/test/Transforms/Mem2Reg/PromoteMemToRegister.ll

 ; Simple sanity check testcase.  Both alloca's should be eliminated.
-; RUN: opt < %s -mem2reg -S | not grep alloca
+; RUN: opt < %s -debugify -mem2reg -check-debugify -S | FileCheck %s
+
+; CHECK-NOT: alloca
+; CHECK: CheckDebugify: PASS
 
 define double @testfunc(i32 %i, double %j) {
   %I = alloca i32   ; <i32*> [#uses=4]
   %J = alloca double    ; <double*> [#uses=2]
   store i32 %i, i32* %I
   store double %j, double* %J
   %t1 = load i32, i32* %I    ; <i32> [#uses=1]
   %t2 = add i32 %t1, 1    ; <i32> [#uses=1]
   store i32 %t2, i32* %I
   %t3 = load i32, i32* %I    ; <i32> [#uses=1]
   %t4 = sitofp i32 %t3 to double    ; <double> [#uses=1]
   %t5 = load double, double* %J    ; <double> [#uses=1]
   %t6 = fmul double %t4, %t5    ; <double> [#uses=1]
   ret double %t6
 }
 

llvm/trunk/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)

llvm/trunk/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 "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 {
+
+bool applyDebugifyMetadata(Module &M) {
+  // Skip modules with debug info.
+  if (M.getNamedMetadata("llvm.dbg.cu")) {
+    errs() << "Debugify: 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 = M.getDataLayout().getTypeAllocSizeInBits(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, DIB.createFile(M.getName(), "/"),
+                            "debugify", /*isOptimized=*/true, "", 0);
+
+  // Visit each instruction.
+  for (Function &F : M) {
+    if (F.isDeclaration())
+      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, F.hasExactDefinition(), 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));
+
+      // Attach debug values.
+      for (Instruction &I : BB) {
+        // Skip void-valued instructions.
+        if (I.getType()->isVoidTy())
+          continue;
+
+        // Skip the terminator instruction and any just-inserted intrinsics.
+        if (isa<TerminatorInst>(&I) || isa<DbgValueInst>(&I))
+          break;
+
+        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,
+                                    BB.getTerminator());
+      }
+    }
+    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.
+  return true;
+}
+
+void checkDebugifyMetadata(Module &M) {
+  // Skip modules without debugify metadata.
+  NamedMDNode *NMD = M.getNamedMetadata("llvm.debugify");
+  if (!NMD)
+    return;
+
+  auto getDebugifyOperand = [&](unsigned Idx) -> unsigned {
+    return mdconst::extract<ConstantInt>(NMD->getOperand(Idx)->getOperand(0))
+        ->getZExtValue();
+  };
+  unsigned OriginalNumLines = getDebugifyOperand(0);
+  unsigned OriginalNumVars = getDebugifyOperand(1);
+  bool HasErrors = false;
+
+  // Find missing lines.
+  BitVector MissingLines{OriginalNumLines, true};
+  for (Function &F : M) {
+    for (Instruction &I : instructions(F)) {
+      if (isa<DbgValueInst>(&I))
+        continue;
+
+      auto DL = I.getDebugLoc();
+      if (DL) {
+        MissingLines.reset(DL.getLine() - 1);
+        continue;
+      }
+
+      outs() << "ERROR: Instruction with empty DebugLoc -- ";
+      I.print(outs());
+      outs() << "\n";
+      HasErrors = true;
+    }
+  }
+  for (unsigned Idx : MissingLines.set_bits())
+    outs() << "WARNING: Missing line " << Idx + 1 << "\n";
+
+  // Find missing variables.
+  BitVector MissingVars{OriginalNumVars, true};
+  for (Function &F : M) {
+    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");
+      MissingVars.reset(Var - 1);
+    }
+  }
+  for (unsigned Idx : MissingVars.set_bits())
+    outs() << "ERROR: Missing variable " << Idx + 1 << "\n";
+  HasErrors |= MissingVars.count() > 0;
+
+  outs() << "CheckDebugify: " << (HasErrors ? "FAIL" : "PASS") << "\n";
+}
+
+/// Attach synthetic debug info to everything.
+struct DebugifyPass : public ModulePass {
+  bool runOnModule(Module &M) override { return applyDebugifyMetadata(M); }
+
+  DebugifyPass() : ModulePass(ID) {}
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+  }
+
+  static char ID; // Pass identification.
+};
+
+/// Check debug info inserted by -debugify for completeness.
+struct CheckDebugifyPass : public ModulePass {
+  bool runOnModule(Module &M) override {
+    checkDebugifyMetadata(M);
+    return false;
+  }
+
+  CheckDebugifyPass() : ModulePass(ID) {}
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+  }
+
+  static char ID; // Pass identification.
+};
+
+} // end anonymous namespace
+
+char DebugifyPass::ID = 0;
+static RegisterPass<DebugifyPass> X("debugify",
+                                    "Attach debug info to everything");
+
+char CheckDebugifyPass::ID = 0;
+static RegisterPass<CheckDebugifyPass> Y("check-debugify",
+                                         "Check debug info from -debugify");