[Debugify] Make the debugify aware of the original (-g) Debug Info

[djtodoro]

Summary

As discussed on the RFC [0], I am sharing the set of patches that enables checking of original Debug Info metadata preservation in optimizations. The proof-of-concept/proposal can be found at [1].

The implementation from the [1] was full of duplicated code, so this set of patches tries to merge this approach into the existing debugify utility.

For example, the utility pass in the original-debuginfo-check mode could be invoked as follows:

$ opt -verify-debuginfo-preserve -pass-to-test sample.ll

Since this is very initial stage of the implementation, there is a space for improvements such as:

• Add support for the new pass manager
• Add support for metadata other than DILocations and DISubprograms

[0] https://groups.google.com/forum/#!msg/llvm-dev/QOyF-38YPlE/G213uiuwCAAJ
[1] https://github.com/djolertrk/llvm-di-checker

[djtodoro]

• Fix an assertion
• Define the debugify DEBUG_TYPE macro

[djtodoro]

• Rebase on top of D83391

[djtodoro]

• Rebase
• TODO: Consider another name for mode. 'original' might be too sharp.

[djtodoro]

Hi @vsk, is this in better shape now? :)

[djtodoro]

Ping :)

[dblaikie]

Perhaps worth pinging @dsanders or anyone else who wrote bits of the original debugify support? I don't have any real context for it, so am not the best reviewer here.

[djtodoro]

@dblaikie Thanks for your comment!

[aprantl]

llvm/docs/HowToUpdateDebugInfo.rst

231–232

Can we call this

The ``debugify`` utility pass

?

I kind of expect a utility to be a standalone executable.

241

I think that this is a useful feature, but from the user's perspective the naming is confusing.

The name debugify implies that that the tool is taking input and then adds something debug-related to it. That clashes with preserving original information.

My suggestion is to either rename debugify to something more generic that encompasses both use-cases, or to share the implementation in one class, but give it two separate user-facing names. Maybe separating out the debugify action from the check action would also work (--enable-debugify --enable-debuginfo-(preservation-)verification).

llvm/include/llvm/Transforms/Utils/Debugify.h

48

Why is this a std::map and not a DenseMap? Do we need the map's sorted-ness?

[vsk]

@djtodoro sorry for the delay here. This looks much nicer now.

llvm/docs/HowToUpdateDebugInfo.rst

316

If 'synthetic/original' is not literally a string that can be passed to the -enable-debugify cl::opt, I think this example will be misleading. Perhaps we can sidestep the issue by picking a default behavior for -enable-debugify?

llvm/include/llvm/Transforms/Utils/Debugify.h

52

s/and its/to its associated/?

54

nit: 'about whether'?

168

This can be simplified by just storing a single DebugifyMode enum.

208

We shouldn't need two sets of super::add calls here. We should simply pass in the DebugifyMode enum, as well as the rest of the optional arguments that might be needed in original mode.

213

Ditto, I don't think we need two sets of super::add calls here either.

llvm/lib/Transforms/Utils/Debugify.cpp

338

Does this need to be const DebugFnMap &?

344

Early continue?

350

No need to check if (Preserved) before assigning it -- we can leave that sort of optimization to the compiler.

351

Early continue here as well?

359

Ditto.

377

Early continue?

383

Is Instr an llvm::Instruction *? I wonder whether it is sound to assume that pointer equality for llvm::Instruction implies actual equality, if we're comparing pointers before/after a pass runs. It's possible for a pass to delete and then create instructions: that could result in pointer reuse/recycling.

385

This might need to be relaxed to a warning, since we do specifically recommend that pass authors drop debug locations in certain transformations.

439

There can be a single map insertion call here, the branch is only needed to pretty-print SP when it's non-null.

[djtodoro]

@aprantl @vsk Thanks a lot for the reviews!

llvm/docs/HowToUpdateDebugInfo.rst

231–232

I agree with that.

241

Sure, I'll try to find a name for the pass(es) that will cover both use-cases. Thanks!

316

I'll try to make some changes to avoid ambiguity here.

llvm/include/llvm/Transforms/Utils/Debugify.h

48

Oh, I've forgotten why I have (initially) used the std::map here, but yes, we don't need the balanced data structure for this, indeed. Thanks!

52

I agree, thanks.

54

I agree, thanks.

168

Sure.

208

Good point. I was planning to do the final refactoring, but I haven't had time for that, thanks for catching this!

llvm/lib/Transforms/Utils/Debugify.cpp

338

Yes, I'll add it to some other spots as well.

344

Sure, thanks.

350

I agree, thanks.

383

It is an llvm::Instruction *. I see... any idea how to address that?
(I was trying to avoid having to make a temp object of the instr...)

385

Agree.. We can extend this (one day) to catch the cases where we actually allow dropping of the di locations, but until then, it is ok to be a warning.

[djtodoro]

• Addressing comments
• Refactoring
• Rename debugify passes into more general name (in order to support original debug info check) - VerifyDIPreserve
• Rename the options
• Fix the test cases
• Update the docs
• Rebasing

[vsk]

llvm/lib/Transforms/Utils/Debugify.cpp

383

I dug into this a bit and unfortunately it looks like a thorny issue. It looks like Instructions are (de)allocated via User::operator new and User::operator delete, and these essentially call into the system allocator. Relying on pointer equality to identify a unique instruction before/after a pass modifies the IR might necessitate e.g. changing the delete implementation to never free memory. That might not be practical -- it's certainly a big hammer.

It's possible that there's some alternative approach, but I'm not sure whether they'd be effective. One idea might be to use metadata to uniquely identify instructions (not !dbg metadata, of course :), and to teach the dropUnknownNonDebugMetadata utility to preserve that "inst ID" metadata. (I'd be curious to get some other opinions on whether that's workable.)

[djtodoro]

llvm/lib/Transforms/Utils/Debugify.cpp

383

Thanks! I have also taken a look, and I agree that the gymnastic with the new/delete operators won't be practical choice.

Using some special kind of metadata can help us for this purpose. The "inst ID" metadata sounds good to me, since we are going to use it for this purpose only. We can call it !debug-instr-number, similar to the LiveDebugValues/InstrRef (D85741) work.

Let me try to implement a prototype for it, so we can see what are the pros && cons.

[StephenTozer]

llvm/include/llvm/Transforms/Utils/VerifyDIPreserve.h

165 ↗

(On Diff #292465)

Minor, this first condition would look better as Mode != VerifyDIPreserveMode::NoVerify in my opinion.

llvm/lib/Transforms/Utils/Debugify.cpp

353

Minor, attacched -> attached.

383

The metadata approach should work, although as discussed it may require changes to dropUnknownNonDebugMetadata. It might be a little messy though; I think it would also be viable to take the following approach: In the "before" step, populate a map of Instruction* Instr -> WeakVH(Instr). With this map, you can check Map[Instr] != nullptr to determine whether Instr was deleted at any point in the pass; if it wasn't deleted, then you can simply use raw pointer comparison. This avoids the need to fiddle with the internals of Instruction that could potentially affect performance or the behaviour of other code.

I think it worth adding that there will be some noise with this approach; the DebugLoc metadata for any new generated instructions will be dependent on the DebugLoc metadata for the instruction they're based on. For example, cloning an instruction , replacing a conditional branch with an unconditional one, reassociating arithmetic, etc. In each of these cases, we will get a warning from the preservation pass that a new instruction did not receive a DILocation, even though the pass that generated it had no responsibility for it. It's technically correct, but it may result in a continuously increasing amount of noise from pass-to-pass, with the worst case being that there are no DebugLocs left at the start of a pass so that we get an error for every instruction created even if the pass itself is handling DebugLocs correctly.

Unfortunately I don't think there's a way around this issue; if we had a way of programmatically determining which Instruction(s) that a new instruction should derive its DebugLoc from, then we wouldn't have as much need for debugify to begin with.

387

Minor, hadLoc -> HadLoc, although I think this could also just be inlined into the if condition.

390

As above, attacched -> attached.

[djtodoro]

llvm/lib/Transforms/Utils/Debugify.cpp

383

@StephenTozer thanks for the comment.

The metadata approach should work, although as discussed it may require changes to dropUnknownNonDebugMetadata. It might be a little messy though; I think it would also be viable to take the following approach: In the "before" step, populate a map of Instruction* Instr -> WeakVH(Instr). With this map, you can check Map[Instr] != nullptr to determine whether Instr was deleted at any point in the pass; if it wasn't deleted, then you can simply use raw pointer comparison. This avoids the need to fiddle with the internals of Instruction that could potentially affect performance or the behaviour of other code.

Interesting, but I think we'd still have the problem with the pointer reusing?

I still believe that we can use the approach from D85741, by using just simple unsigned IDs (I am making a prototype patch for it).

I think it worth adding that there will be some noise with this approach; the DebugLoc metadata for any new generated instructions will be dependent on the DebugLoc metadata for the instruction they're based on. For example, cloning an instruction , replacing a conditional branch with an unconditional one, reassociating arithmetic, etc. In each of these cases, we will get a warning from the preservation pass that a new instruction did not receive a DILocation, even though the pass that generated it had no responsibility for it. It's technically correct, but it may result in a continuously increasing amount of noise from pass-to-pass, with the worst case being that there are no DebugLocs left at the start of a pass so that we get an error for every instruction created even if the pass itself is handling DebugLocs correctly.

Actually, in the verify-each-pass-mode, it will point to the first pass that "caused" the issue with the instruction.

[StephenTozer]

llvm/lib/Transforms/Utils/Debugify.cpp

383

Interesting, but I think we'd still have the problem with the pointer reusing?

WeakVH will be nulled if the value it references is deleted; even if a new instruction is created that uses the same memory, the WeahVH object will still be equal to a nullptr.

Actually, in the verify-each-pass-mode, it will point to the first pass that "caused" the issue with the instruction.

I'm still reading the patch, so I can't be certain that I understand everything yet, but I don't think what you're describing is possible. I do understand that if we drop the DebugLoc for an instruction, then we will get an error in the pass that dropped that DebugLoc, but any subsequent passes will not show an error for that instruction because it had no DebugLoc to lose.

What I'm referring to is when we create a new instruction that should derive its DebugLoc from one or more existing instructions, but those instructions have none. For example:

We have a basic block with a conditional branch instruction with a debug location attached:

while.body:                                       ; preds = %while.body, %while.body.lr.ph
    br i1 %tobool, label %while.cond.while.cond1.preheader_crit_edge, label %while.body, !dbg !57

Some broken pass causes the debug location to be dropped; this is an error, and the DIVerifier reports it:

while.body:                                       ; preds = %while.body, %while.body.lr.ph
    br i1 %tobool, label %while.cond.while.cond1.preheader_crit_edge, label %while.body

The Jump Threading pass then determines that %tobool will always be false, and replaces the conditional branch with an unconditional branch that uses the cond branch's DebugLoc:

while.body:                                       ; preds = %while.body, %while.body.lr.ph
    br label %while.body

What should happen here? The jump threading pass has generated a new instruction with no DebugLoc attached, so DIVerifier will report it as an error. However, there is no error in the Jump Threading pass, it just has no DebugLoc to assign to the new instruction (assigning a Line 0 in this case would also be incorrect).

The more DebugLocs we lose, the more often these false errors will appear as every similar generated instruction has no way to generate a DebugLoc. I also believe there is no general method for recognizing the difference between "this new instruction has no DebugLoc because we have no way to generate one", versus "this new instruction has no DebugLoc because we didn't copy/calculate it correctly (i.e. a bug)".

[djtodoro]

llvm/lib/Transforms/Utils/Debugify.cpp

383

WeakVH will be nulled if the value it references is deleted; even if a new instruction is created that uses the same memory, the WeahVH object will still be equal to a nullptr.

Cool, I'll try it then. Thanks.

I'm still reading the patch, so I can't be certain that I understand everything yet, but I don't think what you're describing is possible. I do understand that if we drop the DebugLoc for an instruction, then we will get an error in the pass that dropped that DebugLoc, but any subsequent passes will not show an error for that instruction because it had no DebugLoc to lose.

What I'm referring to is when we create a new instruction that should derive its DebugLoc from one or more existing instructions, but those instructions have none. For example:

We have a basic block with a conditional branch instruction with a debug location attached:

while.body: ; preds = %while.body, %while.body.lr.ph

br i1 %tobool, label %while.cond.while.cond1.preheader_crit_edge, label %while.body, !dbg !57

Some broken pass causes the debug location to be dropped; this is an error, and the DIVerifier reports it:

while.body: ; preds = %while.body, %while.body.lr.ph

br i1 %tobool, label %while.cond.while.cond1.preheader_crit_edge, label %while.body

The Jump Threading pass then determines that %tobool will always be false, and replaces the conditional branch with an unconditional branch that uses the cond branch's DebugLoc:

while.body: ; preds = %while.body, %while.body.lr.ph

br label %while.body

What should happen here? The jump threading pass has generated a new instruction with no DebugLoc attached, so DIVerifier will report it as an error. However, there is no error in the Jump Threading pass, it just has no DebugLoc to assign to the new instruction (assigning a Line 0 in this case would also be incorrect).

The more DebugLocs we lose, the more often these false errors will appear as every similar generated instruction has no way to generate a DebugLoc. I also believe there is no general method for recognizing the difference between "this new instruction has no DebugLoc because we have no way to generate one", versus "this new instruction has no DebugLoc because we didn't copy/calculate it correctly (i.e. a bug)".

Oh, sorry, I haven't understood at first... Yes, but as you have said, it is not possible to catch with the utility pass like this.

[StephenTozer]

I think wait for someone with more experience in this area to give approval, but aside from the outstanding comments, LGTM.

[djtodoro]

-Addressing the latest comments
-Rebasing

[StephenTozer]

LGTM, though recommend waiting for a more experienced reviewer to give approval.

[vsk]

llvm/docs/HowToUpdateDebugInfo.rst

241

@aprantl @djtodoro -- let's not change any names in this patch, please.

The 'opt -debugify' name has been referenced in written communication since 2017 (D40512). Changing it would be disruptive (e.g., we've already recorded a talk that references this name extensively).

If you strongly feel that the old name should be changed, it should at least happen in a separate patch. This patch is already large, and it's difficult to determine what needs review. The name change exacerbates this issue.

[vsk]

I'd like to give this another pass, but the name change has made the patch too large. More inline --

[djtodoro]

llvm/docs/HowToUpdateDebugInfo.rst

241

OK, I'll return back the name, and we can defer the discussion about the name changing for later. That will make the review process easier.

[djtodoro]

• Return the names

(TODO: rebase the rest of the patches from the stack once this is finished)

[djtodoro]

Ping. :)

[aprantl]

llvm/test/DebugInfo/debugify-each-original-dbginfo.ll

3 ↗

(On Diff #295518)

This test looks like it could be very costly to maintain. If I understand correctly, it is depending on a bug in InstCombine that isn't further specified, but it's running opt with the full -O2 pipeline on all targets. What guarantees that the bug is actually triggered? Will it trigger on, e.g., an AArch64 host *and* on an x86_64 host? What if someone fixes the bug, or worse, if the pipeline changes, such that the bug isn't triggered any more — how should they update this testcase?
It would be better do do something very targeted. For example we could implement (in a unit test) a extremely simple pass that just deletes debug info intrinsics and run the check on that. This way we we will get a deterministic behavior on all targets and future compiler versions.

[dblaikie]

llvm/test/DebugInfo/debugify-each-original-dbginfo.ll

3 ↗

(On Diff #295518)

Strong +1 here. Thanks for pointing this out, @aprantl.

[djtodoro]

llvm/test/DebugInfo/debugify-each-original-dbginfo.ll

3 ↗

(On Diff #295518)

Thanks! Nice! I totally agree!
I'll make a unit test with the pass.

[djtodoro]

• Rebasing on top of trunk
• Adding a unit test with a pass that deletes debug info metadata

[aprantl]

llvm/docs/HowToUpdateDebugInfo.rst

352

How about: In addition to automatically generating debug info, the checks provided by the debugify utility pass can also be used to test the preservation of pre-existing debug info metadata.

llvm/test/DebugInfo/debugify-original-dbginfo.ll

5 ↗

(On Diff #320417)

This test has the same fundamental problem: It may fail on a different target, when instcombine is updated, ...
Can you do the same unittest trick here? (perhaps with an idempotent transformation?)

[djtodoro]

llvm/docs/HowToUpdateDebugInfo.rst

352

Looks good to me. :)

llvm/test/DebugInfo/debugify-original-dbginfo.ll

5 ↗

(On Diff #320417)

Sure.

This test has the same fundamental problem: It may fail on a different target, when instcombine is updated, ...

just curious -- I thought that all targets should handle Debug Info on the IR level the same way, but obviously that is not true?

[djtodoro]

• Improving the unit test with positive result of debugify

[aprantl]

llvm/test/DebugInfo/debugify-original-dbginfo.ll

5 ↗

(On Diff #320417)

just curious -- I thought that all targets should handle Debug Info on the IR level the same way, but obviously that is not true?

My understanding is that InstCombine has hooks for targets to apply target-specific combines that are profitable only on that architecture, but I'm far from an expert here :-)

The main problem is that this RUN line basically asserts that "instcombine behaves correctly in terms of debug info". While this may be true at the moment, at some point in the future someone will make an unrelated change to the IR, or to instcombine, or add a new target that will cause this test to break, but there is no indication in this test for how to fix it.
I think this test as it is might be okay inside the InstCombine subdirectory, to cement the fact that whatever InstCombine rules apply here behave correctly, but it's not so good as a test for the debugify pass, because it depends on the whole complex InstCombine machinery to behave in a specific way.

[djtodoro]

llvm/test/DebugInfo/debugify-original-dbginfo.ll

5 ↗

(On Diff #320417)

got it, thanks for the explanation -- I've learned something new! :)

[djtodoro]

Is this ok now?

[djtodoro]

ping :)

[aprantl]

I think you've addressed all feedback. Thanks for you patience!

llvm/docs/HowToUpdateDebugInfo.rst

 .. _IRDebugify:
 
 Mutation testing for IR-level transformations
 ---------------------------------------------
 
 An IR test case for a transformation can, in many cases, be automatically
 mutated to test debug info handling within that transformation. This is a
 simple way to test for proper debug info handling.
 
-The ``debugify`` utility
-^^^^^^^^^^^^^^^^^^^^^^^^
+The ``debugify`` utility pass
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 The ``debugify`` testing utility is just a pair of passes: ``debugify`` and
 ``check-debugify``.
 
 The first applies synthetic debug information to every instruction of the
 module, and the second checks that this DI is still available after an
 optimization has occurred, reporting any errors/warnings while doing so.
 
 The instructions are assigned sequentially increasing line locations, and are
 immediately used by debug value intrinsics everywhere possible.
 
 For example, here is a module before:
 
 .. code-block:: llvm
 
    define void @f(i32* %x) {

 Some other ways to run debugify are available:
 
 .. code-block:: bash
 
    # Same as the above example.
    $ opt -enable-debugify -pass-to-test sample.ll
 
    # Suppresses verbose debugify output.
    $ opt -enable-debugify -debugify-quiet -pass-to-test sample.ll
 
    # Prepend -debugify before and append -check-debugify -strip after
    # each pass on the pipeline (similar to -verify-each).
    $ opt -debugify-each -O2 sample.ll
 
 In order for ``check-debugify`` to work, the DI must be coming from
 ``debugify``. Thus, modules with existing DI will be skipped.
 

 .. note::
 
    Regression tests must be robust. Avoid hardcoding line/variable numbers in
    check lines. In cases where this can't be avoided (say, if a test wouldn't
    be precise enough), moving the test to its own file is preferred.
 
 .. _MIRDebugify:
 
+Test original debug info preservation in optimizations
+------------------------------------------------------
+
+In addition to automatically generating debug info, the checks provided by
+the ``debugify`` utility pass can also be used to test the preservation of
+pre-existing debug info metadata. It could be run as follows:
+
+.. code-block:: bash
+
+  # Run the pass by checking original Debug Info preservation.
+  $ opt -verify-debuginfo-preserve -pass-to-test sample.ll
+
+  # Check the preservation of original Debug Info after each pass.
+  $ opt -verify-each-debuginfo-preserve -O2 sample.ll
+
 Mutation testing for MIR-level transformations
 ----------------------------------------------
 
 A variant of the ``debugify`` utility described in
 :ref:`Mutation testing for IR-level transformations<IRDebugify>` can be used
 for MIR-level transformations as well: much like the IR-level pass,
 ``mir-debugify`` inserts sequentially increasing line locations to each
 ``MachineInstr`` in a ``Module``. And the MIR-level ``mir-check-debugify`` is

llvm/include/llvm/Transforms/Utils/Debugify.h

-//===- Debugify.h - Attach synthetic debug info to everything -------------===//
+//===- Debugify.h - Check debug info preservation in optimizations --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
-/// \file Interface to the `debugify` synthetic debug info testing utility.
+/// \file Interface to the `debugify` synthetic/original debug info testing
+/// utility.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_DEBUGIFY_H
 #define LLVM_TRANSFORMS_UTILS_DEBUGIFY_H
 
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/IR/ValueHandle.h"
+
+using DebugFnMap = llvm::DenseMap<llvm::StringRef, const llvm::DISubprogram *>;
+using DebugInstMap = llvm::DenseMap<const llvm::Instruction *, bool>;
+using WeakInstValueMap =
+    llvm::DenseMap<const llvm::Instruction *, llvm::WeakVH>;
+
+/// Used to track the Debug Info Metadata information.
+struct DebugInfoPerPass {
+  // This maps a function name to its associated DISubprogram.
+  DebugFnMap DIFunctions;
+  // This maps an instruction and the info about whether it has !dbg attached.
+  DebugInstMap DILocations;
+  // This tracks value (instruction) deletion. If an instruction gets deleted,
+  // WeakVH nulls itself.
+  WeakInstValueMap InstToDelete;
+};
+
+/// Map pass names to a per-pass DebugInfoPerPass instance.
+using DebugInfoPerPassMap = llvm::MapVector<llvm::StringRef, DebugInfoPerPass>;
 
 namespace llvm {
 class DIBuilder;
 
 /// Add synthesized debug information to a module.
 ///
 /// \param M The module to add debug information to.
 /// \param Functions A range of functions to add debug information to.
 /// \param Banner A prefix string to add to debug/error messages.
 /// \param ApplyToMF A call back that will add debug information to the
 ///                  MachineFunction for a Function. If nullptr, then the
 ///                  MachineFunction (if any) will not be modified.
 bool applyDebugifyMetadata(
     Module &M, iterator_range<Module::iterator> Functions, StringRef Banner,
     std::function<bool(DIBuilder &, Function &)> ApplyToMF);
 
 /// Strip out all of the metadata and debug info inserted by debugify. If no
 /// llvm.debugify module-level named metadata is present, this is a no-op.
 /// Returns true if any change was made.
 bool stripDebugifyMetadata(Module &M);
 
-llvm::ModulePass *createDebugifyModulePass();
-llvm::FunctionPass *createDebugifyFunctionPass();
+/// Collect original debug information before a pass.
+///
+/// \param M The module to collect debug information from.
+/// \param Functions A range of functions to collect debug information from.
+/// \param DIPreservationMap A map to collect the DI metadata.
+/// \param Banner A prefix string to add to debug/error messages.
+/// \param NameOfWrappedPass A name of a pass to add to debug/error messages.
+bool collectDebugInfoMetadata(Module &M,
+                              iterator_range<Module::iterator> Functions,
+                              DebugInfoPerPassMap &DIPreservationMap,
+                              StringRef Banner, StringRef NameOfWrappedPass);
+
+/// Check original debug information after a pass.
+///
+/// \param M The module to collect debug information from.
+/// \param Functions A range of functions to collect debug information from.
+/// \param DIPreservationMap A map used to check collected the DI metadata.
+/// \param Banner A prefix string to add to debug/error messages.
+/// \param NameOfWrappedPass A name of a pass to add to debug/error messages.
+bool checkDebugInfoMetadata(Module &M,
+                            iterator_range<Module::iterator> Functions,
+                            DebugInfoPerPassMap &DIPreservationMap,
+                            StringRef Banner, StringRef NameOfWrappedPass);
+} // namespace llvm
+
+/// Used to check whether we track synthetic or original debug info.
+enum class DebugifyMode { NoDebugify, SyntheticDebugInfo, OriginalDebugInfo };
+
+llvm::ModulePass *createDebugifyModulePass(
+    enum DebugifyMode Mode = DebugifyMode::SyntheticDebugInfo,
+    llvm::StringRef NameOfWrappedPass = "",
+    DebugInfoPerPassMap *DIPreservationMap = nullptr);
+llvm::FunctionPass *createDebugifyFunctionPass(
+    enum DebugifyMode Mode = DebugifyMode::SyntheticDebugInfo,
+    llvm::StringRef NameOfWrappedPass = "",
+    DebugInfoPerPassMap *DIPreservationMap = nullptr);
 
 struct NewPMDebugifyPass : public llvm::PassInfoMixin<NewPMDebugifyPass> {
   llvm::PreservedAnalyses run(llvm::Module &M, llvm::ModuleAnalysisManager &AM);
 };
 
-/// Track how much `debugify` information has been lost.
+/// Track how much `debugify` information (in the `synthetic` mode only)
+/// has been lost.
 struct DebugifyStatistics {
   /// Number of missing dbg.values.
   unsigned NumDbgValuesMissing = 0;
 
   /// Number of dbg.values expected.
   unsigned NumDbgValuesExpected = 0;
 
   /// Number of instructions with empty debug locations.
struct DebugifyStatistics {
   float getEmptyLocationRatio() const {
     return float(NumDbgLocsMissing) / float(NumDbgLocsExpected);
   }
 };
 
 /// Map pass names to a per-pass DebugifyStatistics instance.
 using DebugifyStatsMap = llvm::MapVector<llvm::StringRef, DebugifyStatistics>;
 
-void exportDebugifyStats(StringRef Path, const DebugifyStatsMap &Map);
-
-llvm::ModulePass *
-createCheckDebugifyModulePass(bool Strip = false,
-                              llvm::StringRef NameOfWrappedPass = "",
-                              DebugifyStatsMap *StatsMap = nullptr);
-
-llvm::FunctionPass *
-createCheckDebugifyFunctionPass(bool Strip = false,
-                                llvm::StringRef NameOfWrappedPass = "",
-                                DebugifyStatsMap *StatsMap = nullptr);
+llvm::ModulePass *createCheckDebugifyModulePass(
+    bool Strip = false, llvm::StringRef NameOfWrappedPass = "",
+    DebugifyStatsMap *StatsMap = nullptr,
+    enum DebugifyMode Mode = DebugifyMode::SyntheticDebugInfo,
+    DebugInfoPerPassMap *DIPreservationMap = nullptr);
+
+llvm::FunctionPass *createCheckDebugifyFunctionPass(
+    bool Strip = false, llvm::StringRef NameOfWrappedPass = "",
+    DebugifyStatsMap *StatsMap = nullptr,
+    enum DebugifyMode Mode = DebugifyMode::SyntheticDebugInfo,
+    DebugInfoPerPassMap *DIPreservationMap = nullptr);
 
 struct NewPMCheckDebugifyPass
     : public llvm::PassInfoMixin<NewPMCheckDebugifyPass> {
   llvm::PreservedAnalyses run(llvm::Module &M, llvm::ModuleAnalysisManager &AM);
 };
 
+namespace llvm {
+void exportDebugifyStats(StringRef Path, const DebugifyStatsMap &Map);
+
 struct DebugifyEachInstrumentation {
   DebugifyStatsMap StatsMap;
 
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 };
 
 /// DebugifyCustomPassManager wraps each pass with the debugify passes if
 /// needed.
 /// NOTE: We support legacy custom pass manager only.
 /// TODO: Add New PM support for custom pass manager.
 class DebugifyCustomPassManager : public legacy::PassManager {
-  DebugifyStatsMap DIStatsMap;
-  bool EnableDebugifyEach = false;
+  DebugifyStatsMap *DIStatsMap = nullptr;
+  DebugInfoPerPassMap *DIPreservationMap = nullptr;
+  enum DebugifyMode Mode = DebugifyMode::NoDebugify;
 
 public:
   using super = legacy::PassManager;
 
   void add(Pass *P) override {
     // Wrap each pass with (-check)-debugify passes if requested, making
     // exceptions for passes which shouldn't see -debugify instrumentation.
-    bool WrapWithDebugify = EnableDebugifyEach && !P->getAsImmutablePass() &&
-                            !isIRPrintingPass(P) && !isBitcodeWriterPass(P);
+    bool WrapWithDebugify =
+        Mode != DebugifyMode::NoDebugify &&
+        !P->getAsImmutablePass() && !isIRPrintingPass(P) &&
+        !isBitcodeWriterPass(P);
     if (!WrapWithDebugify) {
       super::add(P);
       return;
     }
 
-    // Apply -debugify/-check-debugify before/after each pass and collect
-    // debug info loss statistics.
+    // Either apply -debugify/-check-debugify before/after each pass and collect
+    // debug info loss statistics, or collect and check original debug info in
+    // the optimizations.
     PassKind Kind = P->getPassKind();
     StringRef Name = P->getPassName();
 
     // TODO: Implement Debugify for LoopPass.
     switch (Kind) {
     case PT_Function:
-      super::add(createDebugifyFunctionPass());
+      super::add(createDebugifyFunctionPass(Mode, Name, DIPreservationMap));
       super::add(P);
-      super::add(createCheckDebugifyFunctionPass(true, Name, &DIStatsMap));
+      super::add(createCheckDebugifyFunctionPass(
+          isSyntheticDebugInfo(), Name, DIStatsMap, Mode, DIPreservationMap));
       break;
     case PT_Module:
-      super::add(createDebugifyModulePass());
+      super::add(createDebugifyModulePass(Mode, Name, DIPreservationMap));
       super::add(P);
-      super::add(createCheckDebugifyModulePass(true, Name, &DIStatsMap));
+      super::add(createCheckDebugifyModulePass(
+          isSyntheticDebugInfo(), Name, DIStatsMap, Mode, DIPreservationMap));
       break;
     default:
       super::add(P);
       break;
     }
   }
 
-  void enableDebugifyEach() { EnableDebugifyEach = true; }
+  // Used within DebugifyMode::SyntheticDebugInfo mode.
+  void setDIStatsMap(DebugifyStatsMap &StatMap) { DIStatsMap = &StatMap; }
+  // Used within DebugifyMode::OriginalDebugInfo mode.
+  void setDIPreservationMap(DebugInfoPerPassMap &PerPassMap) {
+    DIPreservationMap = &PerPassMap;
+  }
+  void setDebugifyMode(enum DebugifyMode M) { Mode = M; }
+
+  bool isSyntheticDebugInfo() const {
+    return Mode == DebugifyMode::SyntheticDebugInfo;
+  }
+  bool isOriginalDebugInfoMode() const {
+    return Mode == DebugifyMode::OriginalDebugInfo;
+  }
 
-  const DebugifyStatsMap &getDebugifyStatsMap() const { return DIStatsMap; }
+  const DebugifyStatsMap &getDebugifyStatsMap() const { return *DIStatsMap; }
+  DebugInfoPerPassMap &getDebugInfoPerPassMap() { return *DIPreservationMap; }
 };
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_DEBUGIFY_H

llvm/lib/Transforms/Utils/Debugify.cpp

-//===- Debugify.cpp - Attach synthetic debug info to everything -----------===//
+//===- Debugify.cpp - Check debug info preservation in optimizations ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
-/// \file This pass attaches synthetic debug info to everything. It can be used
-/// to create targeted tests for debug info preservation.
+/// \file In the `synthetic` mode, the `-debugify` attaches synthetic debug info
+/// to everything. It can be used to create targeted tests for debug info
+/// preservation. In addition, when using the `original` mode, it can check
+/// original debug info preservation. The `synthetic` mode is default one.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Utils/Debugify.h"
 #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"
 
+#define DEBUG_TYPE "debugify"
+
 using namespace llvm;
 
 namespace {
 
 cl::opt<bool> Quiet("debugify-quiet",
                     cl::desc("Suppress verbose debugify output"));
 
 enum class Level {
   Locations,
   LocationsAndVariables
 };
+
+// Used for the synthetic mode only.
 cl::opt<Level> DebugifyLevel(
     "debugify-level", cl::desc("Kind of debug info to add"),
     cl::values(clEnumValN(Level::Locations, "locations", "Locations only"),
                clEnumValN(Level::LocationsAndVariables, "location+variables",
                           "Locations and Variables")),
     cl::init(Level::LocationsAndVariables));
 
 raw_ostream &dbg() { return Quiet ? nulls() : errs(); }
bool llvm::applyDebugifyMetadata(
   // 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;
 }
 
-static bool applyDebugify(Function &F) {
+static bool
+applyDebugify(Function &F,
+              enum DebugifyMode Mode = DebugifyMode::SyntheticDebugInfo,
+              DebugInfoPerPassMap *DIPreservationMap = nullptr,
+              StringRef NameOfWrappedPass = "") {
   Module &M = *F.getParent();
   auto FuncIt = F.getIterator();
+  if (Mode == DebugifyMode::SyntheticDebugInfo)
     return applyDebugifyMetadata(M, make_range(FuncIt, std::next(FuncIt)),
-                               "FunctionDebugify: ", /*ApplyToMF=*/nullptr);
+                                 "FunctionDebugify: ", /*ApplyToMF*/ nullptr);
+  assert(DIPreservationMap);
+  return collectDebugInfoMetadata(M, M.functions(), *DIPreservationMap,
+                                  "FunctionDebugify (original debuginfo)",
+                                  NameOfWrappedPass);
 }
 
-static bool applyDebugify(Module &M) {
+static bool
+applyDebugify(Module &M,
+              enum DebugifyMode Mode = DebugifyMode::SyntheticDebugInfo,
+              DebugInfoPerPassMap *DIPreservationMap = nullptr,
+              StringRef NameOfWrappedPass = "") {
+  if (Mode == DebugifyMode::SyntheticDebugInfo)
     return applyDebugifyMetadata(M, M.functions(),
-                               "ModuleDebugify: ", /*ApplyToMF=*/nullptr);
+                                 "ModuleDebugify: ", /*ApplyToMF*/ nullptr);
+  return collectDebugInfoMetadata(M, M.functions(), *DIPreservationMap,
+                                  "ModuleDebugify (original debuginfo)",
+                                  NameOfWrappedPass);
 }
 
 bool llvm::stripDebugifyMetadata(Module &M) {
   bool Changed = false;
 
   // Remove the llvm.debugify module-level named metadata.
   NamedMDNode *DebugifyMD = M.getNamedMetadata("llvm.debugify");
   if (DebugifyMD) {
bool llvm::stripDebugifyMetadata(Module &M) {
   }
   // If we left it empty we might as well remove it.
   if (NMD->getNumOperands() == 0)
     NMD->eraseFromParent();
 
   return Changed;
 }
 
+bool llvm::collectDebugInfoMetadata(Module &M,
+                                    iterator_range<Module::iterator> Functions,
+                                    DebugInfoPerPassMap &DIPreservationMap,
+                                    StringRef Banner,
+                                    StringRef NameOfWrappedPass) {
+  LLVM_DEBUG(dbgs() << Banner << ": (before) " << NameOfWrappedPass << '\n');
+
+  // Clear the map with the debug info before every single pass.
+  DIPreservationMap.clear();
+
+  if (!M.getNamedMetadata("llvm.dbg.cu")) {
+    dbg() << Banner << ": Skipping module without debug info\n";
+    return false;
+  }
+
+  // Visit each instruction.
+  for (Function &F : Functions) {
+    if (isFunctionSkipped(F))
+      continue;
+
+    // Collect the DISubprogram.
+    auto *SP = F.getSubprogram();
+    DIPreservationMap[NameOfWrappedPass].DIFunctions.insert({F.getName(), SP});
+    if (SP)
+      LLVM_DEBUG(dbgs() << "  Collecting subprogram: " << *SP << '\n');
+
+    for (BasicBlock &BB : F) {
+      // Collect debug locations (!dbg).
+      // TODO: Collect dbg.values.
+      for (Instruction &I : BB) {
+        // Skip PHIs.
+        if (isa<PHINode>(I))
+          continue;
+
+        // Skip debug instructions.
+        if (isa<DbgInfoIntrinsic>(&I))
+          continue;
+
+        LLVM_DEBUG(dbgs() << "  Collecting info for inst: " << I << '\n');
+        DIPreservationMap[NameOfWrappedPass].InstToDelete.insert({&I, &I});
+
+        const DILocation *Loc = I.getDebugLoc().get();
+        bool HasLoc = Loc != nullptr;
+        DIPreservationMap[NameOfWrappedPass].DILocations.insert({&I, HasLoc});
+      }
+    }
+  }
+
+  return true;
+}
+
+// This checks the preservation of original debug info attached to functions.
+static bool checkFunctions(const DebugFnMap &DIFunctionsBefore,
+                           const DebugFnMap &DIFunctionsAfter,
+                           StringRef NameOfWrappedPass,
+                           StringRef FileNameFromCU) {
+  bool Preserved = true;
+  for (const auto &F : DIFunctionsAfter) {
+    if (F.second)
+      continue;
+    auto SPIt = DIFunctionsBefore.find(F.first);
+    if (SPIt == DIFunctionsBefore.end()) {
+      dbg() << "ERROR: " << NameOfWrappedPass
+            << " did not generate DISubprogram for " << F.first << " from "
+            << FileNameFromCU << '\n';
+      Preserved = false;
+    } else {
+      auto SP = SPIt->second;
+      if (!SP)
+        continue;
+      // If the function had the SP attached before the pass, consider it as
+      // a debug info bug.
+      dbg() << "ERROR: " << NameOfWrappedPass << " dropped DISubprogram of "
+            << F.first << " from " << FileNameFromCU << '\n';
+      Preserved = false;
+    }
+  }
+
+  return Preserved;
+}
+
+// This checks the preservation of the original debug info attached to
+// instructions.
+static bool checkInstructions(const DebugInstMap &DILocsBefore,
+                              const DebugInstMap &DILocsAfter,
+                              const WeakInstValueMap &InstToDelete,
+                              StringRef NameOfWrappedPass,
+                              StringRef FileNameFromCU) {
+  bool Preserved = true;
+  for (const auto &L : DILocsAfter) {
+    if (L.second)
+      continue;
+    auto Instr = L.first;
+
+    // In order to avoid pointer reuse/recycling, skip the values that might
+    // have been deleted during a pass.
+    auto WeakInstrPtr = InstToDelete.find(Instr);
+    if (WeakInstrPtr != InstToDelete.end() && !WeakInstrPtr->second)
+      continue;
+
+    auto FnName = Instr->getFunction()->getName();
+    auto BB = Instr->getParent();
+    auto BBName = BB->hasName() ? BB->getName() : "no-name";
+
+    auto InstrIt = DILocsBefore.find(Instr);
+    if (InstrIt == DILocsBefore.end()) {
+      dbg() << "WARNING: " << NameOfWrappedPass
+            << " did not generate DILocation for " << *Instr
+            << " (BB: " << BBName << ", Fn: " << FnName
+            << ", File: " << FileNameFromCU << ")\n";
+      Preserved = false;
+    } else {
+      if (!InstrIt->second)
+        continue;
+      // If the instr had the !dbg attached before the pass, consider it as
+      // a debug info issue.
+      dbg() << "WARNING: " << NameOfWrappedPass << " dropped DILocation of "
+            << *Instr << " (BB: " << BBName << ", Fn: " << FnName
+            << ", File: " << FileNameFromCU << ")\n";
+      Preserved = false;
+    }
+  }
+
+  return Preserved;
+}
+
+bool llvm::checkDebugInfoMetadata(Module &M,
+                                  iterator_range<Module::iterator> Functions,
+                                  DebugInfoPerPassMap &DIPreservationMap,
+                                  StringRef Banner,
+                                  StringRef NameOfWrappedPass) {
+  LLVM_DEBUG(dbgs() << Banner << ": (after) " << NameOfWrappedPass << '\n');
+
+  if (!M.getNamedMetadata("llvm.dbg.cu")) {
+    dbg() << Banner << ": Skipping module without debug info\n";
+    return false;
+  }
+
+  // Map the debug info holding DIs after a pass.
+  DebugInfoPerPassMap DIPreservationAfter;
+
+  // Visit each instruction.
+  for (Function &F : Functions) {
+    if (isFunctionSkipped(F))
+      continue;
+
+    // TODO: Collect metadata other than DISubprograms.
+    // Collect the DISubprogram.
+    auto *SP = F.getSubprogram();
+    DIPreservationAfter[NameOfWrappedPass].DIFunctions.insert({F.getName(), SP});
+    if (SP)
+      LLVM_DEBUG(dbgs() << "  Collecting subprogram: " << *SP << '\n');
+
+    for (BasicBlock &BB : F) {
+      // Collect debug locations (!dbg attachments).
+      // TODO: Collect dbg.values.
+      for (Instruction &I : BB) {
+        // Skip PHIs.
+        if (isa<PHINode>(I))
+          continue;
+
+        // Skip debug instructions.
+        if (isa<DbgInfoIntrinsic>(&I))
+          continue;
+
+        LLVM_DEBUG(dbgs() << "  Collecting info for inst: " << I << '\n');
+
+        const DILocation *Loc = I.getDebugLoc().get();
+        bool HasLoc = Loc != nullptr;
+
+        DIPreservationAfter[NameOfWrappedPass].DILocations.insert({&I, HasLoc});
+      }
+    }
+  }
+
+  // TODO: The name of the module could be read better?
+  StringRef FileNameFromCU =
+      (cast<DICompileUnit>(M.getNamedMetadata("llvm.dbg.cu")->getOperand(0)))
+          ->getFilename();
+
+  auto DIFunctionsBefore = DIPreservationMap[NameOfWrappedPass].DIFunctions;
+  auto DIFunctionsAfter = DIPreservationAfter[NameOfWrappedPass].DIFunctions;
+
+  auto DILocsBefore = DIPreservationMap[NameOfWrappedPass].DILocations;
+  auto DILocsAfter = DIPreservationAfter[NameOfWrappedPass].DILocations;
+
+  auto InstToDelete = DIPreservationAfter[NameOfWrappedPass].InstToDelete;
+
+  bool ResultForFunc = checkFunctions(DIFunctionsBefore, DIFunctionsAfter,
+                                      NameOfWrappedPass, FileNameFromCU);
+  bool ResultForInsts =
+      checkInstructions(DILocsBefore, DILocsAfter, InstToDelete,
+                        NameOfWrappedPass, FileNameFromCU);
+  bool Result = ResultForFunc && ResultForInsts;
+
+  StringRef ResultBanner = NameOfWrappedPass != "" ? NameOfWrappedPass : Banner;
+  if (Result)
+    dbg() << ResultBanner << ": PASS\n";
+  else
+    dbg() << ResultBanner << ": FAIL\n";
+
+  LLVM_DEBUG(dbgs() << "\n\n");
+  return Result;
+}
+
 namespace {
 /// 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.
if (Strip)
     return stripDebugifyMetadata(M);
 
   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 applyDebugify(M); }
+  bool runOnModule(Module &M) override {
+    return applyDebugify(M, Mode, DIPreservationMap, NameOfWrappedPass);
+  }
 
-  DebugifyModulePass() : ModulePass(ID) {}
+  DebugifyModulePass(enum DebugifyMode Mode = DebugifyMode::SyntheticDebugInfo,
+                     StringRef NameOfWrappedPass = "",
+                     DebugInfoPerPassMap *DIPreservationMap = nullptr)
+      : ModulePass(ID), NameOfWrappedPass(NameOfWrappedPass),
+        DIPreservationMap(DIPreservationMap), Mode(Mode) {}
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 
   static char ID; // Pass identification.
+
+private:
+  StringRef NameOfWrappedPass;
+  DebugInfoPerPassMap *DIPreservationMap;
+  enum DebugifyMode Mode;
 };
 
 /// 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 { return applyDebugify(F); }
+  bool runOnFunction(Function &F) override {
+    return applyDebugify(F, Mode, DIPreservationMap, NameOfWrappedPass);
+  }
 
-  DebugifyFunctionPass() : FunctionPass(ID) {}
+  DebugifyFunctionPass(
+      enum DebugifyMode Mode = DebugifyMode::SyntheticDebugInfo,
+      StringRef NameOfWrappedPass = "",
+      DebugInfoPerPassMap *DIPreservationMap = nullptr)
+      : FunctionPass(ID), NameOfWrappedPass(NameOfWrappedPass),
+        DIPreservationMap(DIPreservationMap), Mode(Mode) {}
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 
   static char ID; // Pass identification.
+
+private:
+  StringRef NameOfWrappedPass;
+  DebugInfoPerPassMap *DIPreservationMap;
+  enum DebugifyMode Mode;
 };
 
 /// ModulePass for checking debug info inserted by -debugify, used with the
 /// legacy module pass manager.
 struct CheckDebugifyModulePass : public ModulePass {
   bool runOnModule(Module &M) override {
+    if (Mode == DebugifyMode::SyntheticDebugInfo)
       return checkDebugifyMetadata(M, M.functions(), NameOfWrappedPass,
                                    "CheckModuleDebugify", Strip, StatsMap);
+    return checkDebugInfoMetadata(
+        M, M.functions(), *DIPreservationMap,
+        "CheckModuleDebugify (original debuginfo)", NameOfWrappedPass);
   }
 
-  CheckDebugifyModulePass(bool Strip = false, StringRef NameOfWrappedPass = "",
-                          DebugifyStatsMap *StatsMap = nullptr)
-      : ModulePass(ID), Strip(Strip), NameOfWrappedPass(NameOfWrappedPass),
-        StatsMap(StatsMap) {}
+  CheckDebugifyModulePass(
+      bool Strip = false, StringRef NameOfWrappedPass = "",
+      DebugifyStatsMap *StatsMap = nullptr,
+      enum DebugifyMode Mode = DebugifyMode::SyntheticDebugInfo,
+      DebugInfoPerPassMap *DIPreservationMap = nullptr)
+      : ModulePass(ID), NameOfWrappedPass(NameOfWrappedPass),
+        StatsMap(StatsMap), DIPreservationMap(DIPreservationMap), Mode(Mode),
+        Strip(Strip) {}
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 
   static char ID; // Pass identification.
 
 private:
-  bool Strip;
   StringRef NameOfWrappedPass;
   DebugifyStatsMap *StatsMap;
+  DebugInfoPerPassMap *DIPreservationMap;
+  enum DebugifyMode Mode;
+  bool Strip;
 };
 
 /// 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();
+    if (Mode == DebugifyMode::SyntheticDebugInfo)
       return checkDebugifyMetadata(M, make_range(FuncIt, std::next(FuncIt)),
                                    NameOfWrappedPass, "CheckFunctionDebugify",
                                    Strip, StatsMap);
+    return checkDebugInfoMetadata(
+        M, make_range(FuncIt, std::next(FuncIt)), *DIPreservationMap,
+        "CheckFunctionDebugify (original debuginfo)", NameOfWrappedPass);
   }
 
-  CheckDebugifyFunctionPass(bool Strip = false,
-                            StringRef NameOfWrappedPass = "",
-                            DebugifyStatsMap *StatsMap = nullptr)
-      : FunctionPass(ID), Strip(Strip), NameOfWrappedPass(NameOfWrappedPass),
-        StatsMap(StatsMap) {}
+  CheckDebugifyFunctionPass(
+      bool Strip = false, StringRef NameOfWrappedPass = "",
+      DebugifyStatsMap *StatsMap = nullptr,
+      enum DebugifyMode Mode = DebugifyMode::SyntheticDebugInfo,
+      DebugInfoPerPassMap *DIPreservationMap = nullptr)
+      : FunctionPass(ID), NameOfWrappedPass(NameOfWrappedPass),
+        StatsMap(StatsMap), DIPreservationMap(DIPreservationMap), Mode(Mode),
+        Strip(Strip) {}
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 
   static char ID; // Pass identification.
 
 private:
-  bool Strip;
   StringRef NameOfWrappedPass;
   DebugifyStatsMap *StatsMap;
+  DebugInfoPerPassMap *DIPreservationMap;
+  enum DebugifyMode Mode;
+  bool Strip;
 };
 
 } // end anonymous namespace
 
 void llvm::exportDebugifyStats(StringRef Path, const DebugifyStatsMap &Map) {
   std::error_code EC;
   raw_fd_ostream OS{Path, EC};
   if (EC) {
for (const auto &Entry : Map) {
     DebugifyStatistics Stats = Entry.second;
 
     OS << Pass << ',' << Stats.NumDbgValuesMissing << ','
        << Stats.NumDbgLocsMissing << ',' << Stats.getMissingValueRatio() << ','
        << Stats.getEmptyLocationRatio() << '\n';
   }
 }
 
-ModulePass *llvm::createDebugifyModulePass() {
+ModulePass *createDebugifyModulePass(enum DebugifyMode Mode,
+                                     llvm::StringRef NameOfWrappedPass,
+                                     DebugInfoPerPassMap *DIPreservationMap) {
+  if (Mode == DebugifyMode::SyntheticDebugInfo)
     return new DebugifyModulePass();
+  assert(Mode == DebugifyMode::OriginalDebugInfo && "Must be original mode");
+  return new DebugifyModulePass(Mode, NameOfWrappedPass, DIPreservationMap);
 }
 
-FunctionPass *llvm::createDebugifyFunctionPass() {
+FunctionPass *
+createDebugifyFunctionPass(enum DebugifyMode Mode,
+                           llvm::StringRef NameOfWrappedPass,
+                           DebugInfoPerPassMap *DIPreservationMap) {
+  if (Mode == DebugifyMode::SyntheticDebugInfo)
     return new DebugifyFunctionPass();
+  assert(Mode == DebugifyMode::OriginalDebugInfo && "Must be original mode");
+  return new DebugifyFunctionPass(Mode, NameOfWrappedPass, DIPreservationMap);
 }
 
 PreservedAnalyses NewPMDebugifyPass::run(Module &M, ModuleAnalysisManager &) {
   applyDebugifyMetadata(M, M.functions(),
                         "ModuleDebugify: ", /*ApplyToMF*/ nullptr);
   return PreservedAnalyses::all();
 }
 
-ModulePass *llvm::createCheckDebugifyModulePass(bool Strip,
-                                                StringRef NameOfWrappedPass,
-                                                DebugifyStatsMap *StatsMap) {
+ModulePass *createCheckDebugifyModulePass(
+    bool Strip, StringRef NameOfWrappedPass, DebugifyStatsMap *StatsMap,
+    enum DebugifyMode Mode, DebugInfoPerPassMap *DIPreservationMap) {
+  if (Mode == DebugifyMode::SyntheticDebugInfo)
     return new CheckDebugifyModulePass(Strip, NameOfWrappedPass, StatsMap);
+  assert(Mode == DebugifyMode::OriginalDebugInfo && "Must be original mode");
+  return new CheckDebugifyModulePass(false, NameOfWrappedPass, nullptr, Mode,
+                                     DIPreservationMap);
 }
 
-FunctionPass *
-llvm::createCheckDebugifyFunctionPass(bool Strip, StringRef NameOfWrappedPass,
-                                      DebugifyStatsMap *StatsMap) {
+FunctionPass *createCheckDebugifyFunctionPass(
+    bool Strip, StringRef NameOfWrappedPass, DebugifyStatsMap *StatsMap,
+    enum DebugifyMode Mode, DebugInfoPerPassMap *DIPreservationMap) {
+  if (Mode == DebugifyMode::SyntheticDebugInfo)
     return new CheckDebugifyFunctionPass(Strip, NameOfWrappedPass, StatsMap);
+  assert(Mode == DebugifyMode::OriginalDebugInfo && "Must be original mode");
+  return new CheckDebugifyFunctionPass(false, NameOfWrappedPass, nullptr, Mode,
+                                       DIPreservationMap);
 }
 
 PreservedAnalyses NewPMCheckDebugifyPass::run(Module &M,
                                               ModuleAnalysisManager &) {
   checkDebugifyMetadata(M, M.functions(), "", "CheckModuleDebugify", false,
                         nullptr);
   return PreservedAnalyses::all();
 }

llvm/test/DebugInfo/debugify-original-no-dbg-info.ll

+; RUN: opt -verify-debuginfo-preserve -instcombine -S -o - < %s 2>&1 | FileCheck %s
+
+; CHECK: ModuleDebugify (original debuginfo): Skipping module without debug info
+; CHECK-NEXT: CheckModuleDebugify (original debuginfo): Skipping module without debug info
+
+; ModuleID = 'no-dbg-info.c'
+source_filename = "no-dbg-info.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: nounwind uwtable
+define dso_local i32 @fn() {
+  %1 = call i32 (...) @fn2()
+  ret i32 %1
+}
+
+declare dso_local i32 @fn2(...)
+
+!llvm.module.flags = !{!0}
+!llvm.ident = !{!1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{!"clang version 11.0.0"}

llvm/tools/opt/opt.cpp

static cl::opt<bool>
     AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization. "
                                     "Legacy pass manager only."));
 
 static cl::opt<bool> EnableDebugify(
     "enable-debugify",
     cl::desc(
         "Start the pipeline with debugify and end it with check-debugify"));
 
+static cl::opt<bool> VerifyDebugInfoPreserve(
+    "verify-debuginfo-preserve",
+    cl::desc("Start the pipeline with collecting and end it with checking of "
+             "debug info preservation."));
+
+static cl::opt<bool> VerifyEachDebugInfoPreserve(
+    "verify-each-debuginfo-preserve",
+    cl::desc("Start each pass with collecting and end it with checking of "
+             "debug info preservation."));
+
 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(""));
return runPassPipeline(argv[0], *M, TM.get(), &TLII, Out.get(),
                ? 0
                : 1;
   }
 
   // Create a PassManager to hold and optimize the collection of passes we are
   // about to build. If the -debugify-each option is set, wrap each pass with
   // the (-check)-debugify passes.
   DebugifyCustomPassManager Passes;
-  if (DebugifyEach)
-    Passes.enableDebugifyEach();
+  DebugifyStatsMap DIStatsMap;
+  DebugInfoPerPassMap DIPreservationMap;
+  if (DebugifyEach) {
+    Passes.setDebugifyMode(DebugifyMode::SyntheticDebugInfo);
+    Passes.setDIStatsMap(DIStatsMap);
+  } else if (VerifyEachDebugInfoPreserve) {
+    Passes.setDebugifyMode(DebugifyMode::OriginalDebugInfo);
+    Passes.setDIPreservationMap(DIPreservationMap);
+  }
 
-  bool AddOneTimeDebugifyPasses = EnableDebugify && !DebugifyEach;
+  bool AddOneTimeDebugifyPasses =
+      (EnableDebugify && !DebugifyEach) ||
+      (VerifyDebugInfoPreserve && !VerifyEachDebugInfoPreserve);
 
   Passes.add(new TargetLibraryInfoWrapperPass(TLII));
 
   // Add internal analysis passes from the target machine.
   Passes.add(createTargetTransformInfoWrapperPass(TM ? TM->getTargetIRAnalysis()
                                                      : TargetIRAnalysis()));
 
-  if (AddOneTimeDebugifyPasses)
+  if (AddOneTimeDebugifyPasses) {
+    if (EnableDebugify) {
+      Passes.setDIStatsMap(DIStatsMap);
       Passes.add(createDebugifyModulePass());
+    } else if (VerifyDebugInfoPreserve) {
+      Passes.setDIPreservationMap(DIPreservationMap);
+      Passes.add(createDebugifyModulePass(
+          DebugifyMode::OriginalDebugInfo, "",
+          &(Passes.getDebugInfoPerPassMap())));
+    }
+  }
 
   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 (AddOneTimeDebugifyPasses) {
+    if (EnableDebugify)
       Passes.add(createCheckDebugifyModulePass(false));
+    else if (VerifyDebugInfoPreserve)
+      Passes.add(createCheckDebugifyModulePass(
+          false, "", nullptr, DebugifyMode::OriginalDebugInfo,
+          &(Passes.getDebugInfoPerPassMap())));
+  }
 
   // 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;
   std::unique_ptr<raw_svector_ostream> BOS;

llvm/unittests/Transforms/Utils/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Analysis
   AsmParser
+  BitWriter
   Core
   Support
   TransformUtils
   )
 
 add_llvm_unittest(UtilsTests
   ASanStackFrameLayoutTest.cpp
   BasicBlockUtilsTest.cpp
   CallPromotionUtilsTest.cpp
   CloningTest.cpp
   CodeExtractorTest.cpp
   CodeMoverUtilsTest.cpp
+  DebugifyTest.cpp
   FunctionComparatorTest.cpp
   IntegerDivisionTest.cpp
   LocalTest.cpp
   LoopRotationUtilsTest.cpp
   LoopUtilsTest.cpp
   ScalarEvolutionExpanderTest.cpp
   SizeOptsTest.cpp
   SSAUpdaterBulkTest.cpp
   UnrollLoopTest.cpp
   ValueMapperTest.cpp
   VFABIUtils.cpp
   )

llvm/unittests/Transforms/Utils/DebugifyTest.cpp

+//===- DebugifyTest.cpp - Debugify unit tests -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/AsmParser/Parser.h"
+#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Transforms/Utils/Debugify.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
+  SMDiagnostic Err;
+  std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
+  if (!Mod)
+    Err.print("DebugifyTest", errs());
+  return Mod;
+}
+
+namespace llvm {
+void initializeDebugInfoDropPass(PassRegistry &);
+void initializeDebugInfoDummyAnalysisPass(PassRegistry &);
+
+namespace {
+struct DebugInfoDrop : public FunctionPass {
+  static char ID;
+  bool runOnFunction(Function &F) override {
+    // Drop DISubprogram.
+    F.setSubprogram(nullptr);
+    for (BasicBlock &BB : F) {
+      // Remove debug locations.
+      for (Instruction &I : BB)
+        I.setDebugLoc(DebugLoc());
+    }
+
+    return false;
+  }
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesCFG();
+  }
+
+  DebugInfoDrop() : FunctionPass(ID) {}
+};
+
+struct DebugInfoDummyAnalysis : public FunctionPass {
+  static char ID;
+  bool runOnFunction(Function &F) override {
+    // Do nothing, so debug info stays untouched.
+    return false;
+  }
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+  }
+
+  DebugInfoDummyAnalysis() : FunctionPass(ID) {}
+};
+}
+
+char DebugInfoDrop::ID = 0;
+char DebugInfoDummyAnalysis::ID = 0;
+
+TEST(DebugInfoDrop, DropOriginalDebugInfo) {
+  LLVMContext C;
+  std::unique_ptr<Module> M = parseIR(C, R"(
+    define i16 @f(i16 %a) !dbg !6 {
+      %b = add i16 %a, 1, !dbg !11
+      call void @llvm.dbg.value(metadata i16 %b, metadata !9, metadata !DIExpression()), !dbg !11
+      ret i16 0, !dbg !11
+    }
+    declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+    !llvm.dbg.cu = !{!0}
+    !llvm.module.flags = !{!5}
+
+    !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "debugify", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+    !1 = !DIFile(filename: "t.ll", directory: "/")
+    !2 = !{}
+    !5 = !{i32 2, !"Debug Info Version", i32 3}
+    !6 = distinct !DISubprogram(name: "f", linkageName: "f", scope: null, file: !1, line: 1, type: !7, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !8)
+    !7 = !DISubroutineType(types: !2)
+    !8 = !{!9}
+    !9 = !DILocalVariable(name: "b", scope: !6, file: !1, line: 1, type: !10)
+    !10 = !DIBasicType(name: "ty16", size: 16, encoding: DW_ATE_unsigned)
+    !11 = !DILocation(line: 1, column: 1, scope: !6)
+  )");
+
+  DebugInfoDrop *P = new DebugInfoDrop();
+
+  DebugInfoPerPassMap DIPreservationMap;
+  DebugifyCustomPassManager Passes;
+  Passes.setDIPreservationMap(DIPreservationMap);
+  Passes.add(createDebugifyModulePass(DebugifyMode::OriginalDebugInfo, "",
+                                      &(Passes.getDebugInfoPerPassMap())));
+  Passes.add(P);
+  Passes.add(createCheckDebugifyModulePass(false, "", nullptr,
+                                           DebugifyMode::OriginalDebugInfo,
+                                           &(Passes.getDebugInfoPerPassMap())));
+
+  testing::internal::CaptureStderr();
+  Passes.run(*M);
+
+  std::string StdOut = testing::internal::GetCapturedStderr();
+
+  std::string ErrorForSP = "ERROR:  dropped DISubprogram of";
+  std::string WarningForLoc = "WARNING:  dropped DILocation of";
+  std::string FinalResult = "CheckModuleDebugify (original debuginfo): FAIL";
+
+  EXPECT_TRUE(StdOut.find(ErrorForSP) != std::string::npos);
+  EXPECT_TRUE(StdOut.find(WarningForLoc) != std::string::npos);
+  EXPECT_TRUE(StdOut.find(FinalResult) != std::string::npos);
+}
+
+TEST(DebugInfoDummyAnalysis, PreserveOriginalDebugInfo) {
+  LLVMContext C;
+  std::unique_ptr<Module> M = parseIR(C, R"(
+    define i32 @g(i32 %b) !dbg !6 {
+      %c = add i32 %b, 1, !dbg !11
+      call void @llvm.dbg.value(metadata i32 %c, metadata !9, metadata !DIExpression()), !dbg !11
+      ret i32 1, !dbg !11
+    }
+    declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+    !llvm.dbg.cu = !{!0}
+    !llvm.module.flags = !{!5}
+
+    !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "debugify", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+    !1 = !DIFile(filename: "test.ll", directory: "/")
+    !2 = !{}
+    !5 = !{i32 2, !"Debug Info Version", i32 3}
+    !6 = distinct !DISubprogram(name: "f", linkageName: "f", scope: null, file: !1, line: 1, type: !7, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !8)
+    !7 = !DISubroutineType(types: !2)
+    !8 = !{!9}
+    !9 = !DILocalVariable(name: "c", scope: !6, file: !1, line: 1, type: !10)
+    !10 = !DIBasicType(name: "ty32", size: 32, encoding: DW_ATE_unsigned)
+    !11 = !DILocation(line: 1, column: 1, scope: !6)
+  )");
+
+  DebugInfoDummyAnalysis *P = new DebugInfoDummyAnalysis();
+
+  DebugInfoPerPassMap DIPreservationMap;
+  DebugifyCustomPassManager Passes;
+  Passes.setDIPreservationMap(DIPreservationMap);
+  Passes.add(createDebugifyModulePass(DebugifyMode::OriginalDebugInfo, "",
+                                      &(Passes.getDebugInfoPerPassMap())));
+  Passes.add(P);
+  Passes.add(createCheckDebugifyModulePass(false, "", nullptr,
+                                           DebugifyMode::OriginalDebugInfo,
+                                           &(Passes.getDebugInfoPerPassMap())));
+
+  testing::internal::CaptureStderr();
+  Passes.run(*M);
+
+  std::string StdOut = testing::internal::GetCapturedStderr();
+
+  std::string ErrorForSP = "ERROR:  dropped DISubprogram of";
+  std::string WarningForLoc = "WARNING:  dropped DILocation of";
+  std::string FinalResult = "CheckModuleDebugify (original debuginfo): PASS";
+
+  EXPECT_TRUE(StdOut.find(ErrorForSP) == std::string::npos);
+  EXPECT_TRUE(StdOut.find(WarningForLoc) == std::string::npos);
+  EXPECT_TRUE(StdOut.find(FinalResult) != std::string::npos);
+}
+
+} // end namespace llvm
+
+INITIALIZE_PASS_BEGIN(DebugInfoDrop, "debuginfodroppass", "debuginfodroppass",
+                      false, false)
+INITIALIZE_PASS_END(DebugInfoDrop, "debuginfodroppass", "debuginfodroppass", false,
+                    false)
+
+INITIALIZE_PASS_BEGIN(DebugInfoDummyAnalysis, "debuginfodummyanalysispass",
+                      "debuginfodummyanalysispass", false, false)
+INITIALIZE_PASS_END(DebugInfoDummyAnalysis, "debuginfodummyanalysispass",
+                    "debuginfodummyanalysispass", false, false)