[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

221

Can we call this

The ``debugify`` utility pass

?

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

230

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

24

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

329

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

28

s/and its/to its associated/?

30

nit: 'about whether'?

148

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

157

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

158

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.

llvm/lib/Transforms/Utils/Debugify.cpp

310

Does this need to be const DebugFnMap &?

316

Early continue?

322

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

323

Early continue here as well?

331

Ditto.

349

Early continue?

355

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.

357

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

411

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

221

I agree with that.

230

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

329

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

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

24

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!

28

I agree, thanks.

30

I agree, thanks.

148

Sure.

158

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

310

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

316

Sure, thanks.

322

I agree, thanks.

355

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...)

357

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

355

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

355

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

325

Minor, attacched -> attached.

355

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.

359

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

362

As above, attacched -> attached.

[djtodoro]

llvm/lib/Transforms/Utils/Debugify.cpp

355

@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

355

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

355

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

230

@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

230

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

4

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

4

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

[djtodoro]

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

4

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

369

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

6

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

369

Looks good to me. :)

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

6

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

6

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

6

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

 
 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`` testing utility is just a pair of passes: ``debugify`` and
-``check-debugify``.
+``check-debugify``. It works in two modes:
+
+* `synthetic` - attaches synthetic debug info to everything and tests its
+  preservation
+
+* `original` - collects and checks the preservation of real debug info
+  metadata
+
+The ``debugify`` in ``synthetic`` mode
+**************************************
 
 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.
 
.. code-block:: llvm
    !10 = !DIBasicType(name: "ty64", size: 64, encoding: DW_ATE_unsigned)
    !11 = !DILocalVariable(name: "2", scope: !6, file: !1, line: 3, type: !10)
    !12 = !DILocation(line: 1, column: 1, scope: !6)
    !13 = !DILocation(line: 2, column: 1, scope: !6)
    !14 = !DILocation(line: 3, column: 1, scope: !6)
    !15 = !DILocation(line: 4, column: 1, scope: !6)
    !16 = !DILocation(line: 5, column: 1, scope: !6)
 
+The ``debugify`` in ``original`` mode
+*************************************
+
+The debugify utility can operate in the `original` mode when it checks
+the preservation of the original/real Debug Info metadata in optimizations.
+Before a pass it collects the metadata, and after the pass it checks if it
+preserved the Debug Info metadata. It could be run as follows:
+
+.. code-block:: bash
+
+  $ opt -enable-debugify=original -pass-to-test sample.ll
+
 Using ``debugify``
 ^^^^^^^^^^^^^^^^^^
 
 A simple way to use ``debugify`` is as follows:
 
 .. code-block:: bash
 
   $ opt -debugify -pass-to-test -check-debugify sample.ll
 
 This will inject synthetic DI to ``sample.ll`` run the ``pass-to-test`` and
 then check for missing DI. The ``-check-debugify`` step can of course be
 omitted in favor of more customizable FileCheck directives.
 
 Some other ways to run debugify are available:
 
 .. code-block:: bash
 
    # Same as the above example.
-   $ opt -enable-debugify -pass-to-test sample.ll
+   $ opt -enable-debugify=synthetic -pass-to-test sample.ll
+
+   # Run the debugify in original mode.
+   $ opt -enable-debugify=original -pass-to-test sample.ll
 
    # Suppresses verbose debugify output.
-   $ opt -enable-debugify -debugify-quiet -pass-to-test sample.ll
+   $ opt -enable-debugify=synthetic/original -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
+   $ opt -debugify-each=synthetic -O2 sample.ll
+
+   # Check the preservation of original Debug Info after each pass.
+   $ opt -debugify-each=original -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.
+In order for ``check-debugify`` in `synthetic` mode to work, the DI must be
+coming from ``debugify`` (from the same mode). Thus, modules with existing
+DI will be skipped.
 
 ``debugify`` can be used to test a backend, e.g:
 
 .. code-block:: bash
 
    $ opt -debugify < sample.ll | llc -o -
 
 There is also a MIR-level debugify pass that can be run before each backend
.. note::
    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:
 
 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`` (although there is no equivalent MIR-level
 ``check-debugify`` pass).
 
 For example, here is a snippet before:
 

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_TRANSFORM_UTILS_DEBUGIFY_H
 #define LLVM_TRANSFORM_UTILS_DEBUGIFY_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/IR/PassManager.h"
 
+#include <map>
+
+using DebugFnMap = std::map<llvm::StringRef, const llvm::DISubprogram *>;
+using DebugInstMap = std::map<const llvm::Instruction*, bool>;
+
+/// Used to track the Debug Info Metadata information.
+struct DebugInfoPerPass {
+  // This maps a function name and its DISubprogram.
+  DebugFnMap DIFunctions;
+  // This maps an instruction and the info whether it has !dbg attached.
+  DebugInstMap DILocations;
+};
+
+/// 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);
 
+/// 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
 
-llvm::ModulePass *createDebugifyModulePass();
-llvm::FunctionPass *createDebugifyFunctionPass();
+/// 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>;
 
-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);
 };
 
 #endif // LLVM_TRANSFORM_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.
 ///
 //===----------------------------------------------------------------------===//
 
 #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/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::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.
+    if (auto *SP = F.getSubprogram()) {
+      LLVM_DEBUG(dbgs() << "  Collecting subprogram: " << *SP << '\n');
+      DIPreservationMap[NameOfWrappedPass].DIFunctions.insert(
+          {F.getName(), SP});
+    } else {
+      LLVM_DEBUG(dbgs() << "  Collecting subprogram: nullptr\n");
+      DIPreservationMap[NameOfWrappedPass].DIFunctions.insert(
+          {F.getName(), nullptr});
+    }
+
+    for (BasicBlock &BB : F) {
+      // Collect debug locations (!dbg) and 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;
+
+        DIPreservationMap[NameOfWrappedPass].DILocations.insert({&I, HasLoc});
+      }
+    }
+  }
+
+  return true;
+}
+
+// This checks the preservation of original debug info attached to functions.
+static bool checkFunctions(DebugFnMap &DIFunctionsBefore,
+                           DebugFnMap &DIFunctionsAfter,
+                           StringRef NameOfWrappedPass,
+                           StringRef FileNameFromCU) {
+  bool Preserved = true;
+  for (const auto &F : DIFunctionsAfter) {
+    if (!F.second) {
+      auto SPIt = DIFunctionsBefore.find(F.first);
+      if (SPIt == DIFunctionsBefore.end()) {
+        dbg() << "ERROR: " << NameOfWrappedPass
+              << " did not generate DISubprogram for " << F.first << " from "
+              << FileNameFromCU << '\n';
+        if (Preserved)
+          Preserved = false;
+      } else {
+        auto SP = SPIt->second;
+        // If the function had the SP attacched before the pass, consider it as
+        // a debug info bug.
+        if (SP) {
+          dbg() << "ERROR: " << NameOfWrappedPass << " dropped DISubprogram of "
+                << F.first << " from " << FileNameFromCU << '\n';
+          if (Preserved)
+            Preserved = false;
+        }
+      }
+    }
+  }
+
+  return Preserved;
+}
+
+// This checks the preservation of the original debug info attached to
+// instructions.
+static bool checkInstructions(DebugInstMap &DILocsBefore,
+                              DebugInstMap &DILocsAfter,
+                              StringRef NameOfWrappedPass,
+                              StringRef FileNameFromCU) {
+  bool Preserved = true;
+  for (const auto &L : DILocsAfter) {
+    if (!L.second) {
+      auto Instr = L.first;
+      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() << "ERROR: " << NameOfWrappedPass
+              << " did not generate DILocation for " << *Instr
+              << " (BB: " << BBName << ", Fn: " << FnName
+              << ", File: " << FileNameFromCU << ")\n";
+        if (Preserved)
+          Preserved = false;
+      } else {
+        auto hadLoc = InstrIt->second;
+        // If the instr had the !dbg attacched before the pass, consider it as
+        // a debug info bug.
+        if (hadLoc) {
+          dbg() << "ERROR: " << NameOfWrappedPass << " dropped DILocation of "
+                << *Instr << " (BB: " << BBName << ", Fn: " << FnName
+                << ", File: " << FileNameFromCU << ")\n";
+          if (Preserved)
+            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.
+    if (auto *SP = F.getSubprogram()) {
+      LLVM_DEBUG(dbgs() << "  Collecting subprogram: " << *SP << '\n');
+      DIPreservationAfter[NameOfWrappedPass].DIFunctions.insert(
+          {F.getName(), SP});
+    } else {
+      LLVM_DEBUG(dbgs() << "  Collecting subprogram: nullptr\n");
+      DIPreservationAfter[NameOfWrappedPass].DIFunctions.insert(
+          {F.getName(), nullptr});
+    }
+
+    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;
+
+  bool Result = checkFunctions(DIFunctionsBefore, DIFunctionsAfter,
+                               NameOfWrappedPass, FileNameFromCU) &&
+                checkInstructions(DILocsBefore, DILocsAfter, NameOfWrappedPass,
+                                  FileNameFromCU);
+
+  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.
bool checkDebugifyMetadata(Module &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 {
+    if (Mode == DebugifyMode::SyntheticDebugInfo)
       return applyDebugifyMetadata(M, M.functions(),
                                    "ModuleDebugify: ", /*ApplyToMF*/ nullptr);
+    return collectDebugInfoMetadata(
+        M, M.functions(), *DIPreservationMap,
+        "ModuleDebugify (original): ", 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 {
     Module &M = *F.getParent();
     auto FuncIt = F.getIterator();
+    if (Mode == DebugifyMode::SyntheticDebugInfo)
       return applyDebugifyMetadata(M, make_range(FuncIt, std::next(FuncIt)),
                                    "FunctionDebugify: ", /*ApplyToMF*/ nullptr);
+    return collectDebugInfoMetadata(
+        M, M.functions(), *DIPreservationMap,
+        "FunctionDebugify (original): ", 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): ", 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): ", 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
 
-ModulePass *createDebugifyModulePass() { return new DebugifyModulePass(); }
+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 *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 *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 *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/check-debugify-preserves-analyses.ll

 ; RUN: opt < %s -globals-aa -functionattrs | \
 ; RUN:   opt -S -strip -strip-dead-prototypes -strip-named-metadata > %t.no_dbg
 
-; RUN: opt < %s -debugify-each -globals-aa -functionattrs | \
+; RUN: opt < %s -debugify-each=synthetic -globals-aa -functionattrs | \
 ; RUN:   opt -S -strip -strip-dead-prototypes -strip-named-metadata > %t.with_dbg
 
 ; RUN: diff %t.no_dbg %t.with_dbg
 
 define i32 @f_1(i32 %x) {
   %tmp = call i32 @f_1(i32 0) [ "deopt"() ]
   ret i32 0
 }

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

+; Check the preservation of original debug info.
+
+; RUN: opt -O2 -debugify-each=original -S -o - < %s 2>&1 | FileCheck %s
+
+; CHECK: ERROR: Combine redundant instructions {{.*}}
+; CHECK-NEXT: Combine redundant instructions: FAIL
+
+; ModuleID = 'simple.c'
+source_filename = "simple.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 @fn1(i32 %arg1) !dbg !12 {
+entry:
+  %retval = alloca i32, align 4
+  %arg1.addr = alloca i32, align 4
+  store i32 %arg1, i32* %arg1.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %arg1.addr, metadata !16, metadata !DIExpression()), !dbg !21
+  %0 = load i32, i32* %arg1.addr, align 4, !dbg !22
+  %rem = srem i32 %0, 2, !dbg !24
+  %tobool = icmp ne i32 %rem, 0, !dbg !24
+  br i1 %tobool, label %if.then, label %if.end, !dbg !25
+
+if.then:                                          ; preds = %entry
+  %1 = load i32, i32* %arg1.addr, align 4, !dbg !24
+  %inc = add nsw i32 %1, 1, !dbg !24
+  store i32 %inc, i32* %arg1.addr, align 4, !dbg !24
+  store i32 %inc, i32* %retval, align 4, !dbg !24
+  br label %return, !dbg !24
+
+if.end:                                           ; preds = %entry
+  %2 = load i32, i32* %arg1.addr, align 4, !dbg !25
+  store i32 %2, i32* %retval, align 4, !dbg !25
+  br label %return, !dbg !25
+
+return:                                           ; preds = %if.end, %if.then
+  %3 = load i32, i32* %retval, align 4, !dbg !25
+  ret i32 %3, !dbg !25
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+
+; Function Attrs: nounwind uwtable
+define dso_local i32 @fn2() !dbg !31 {
+entry:
+  %local1 = alloca i32, align 4
+  %0 = bitcast i32* %local1 to i8*, !dbg !36
+  call void @llvm.dbg.declare(metadata i32* %local1, metadata !35, metadata !DIExpression()), !dbg !36
+  %call = call i32 (...) @fn3(), !dbg !36
+  store i32 %call, i32* %local1, align 4, !dbg !36
+  %1 = load i32, i32* %local1, align 4, !dbg !36
+  %call1 = call i32 @fn1(i32 %1), !dbg !36
+  %2 = load i32, i32* %local1, align 4
+  %add = add nsw i32 %2, %call1
+  store i32 %add, i32* %local1, align 4
+  %3 = load i32, i32* %local1, align 4, !dbg !36
+  %4 = bitcast i32* %local1 to i8*, !dbg !36
+  ret i32 %3, !dbg !36
+}
+
+declare !dbg !4 dso_local i32 @fn3(...)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 11.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !3, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "simple.c", directory: "/dir")
+!2 = !{}
+!3 = !{!4}
+!4 = !DISubprogram(name: "fn3", scope: !1, file: !1, line: 1, type: !5, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!5 = !DISubroutineType(types: !6)
+!6 = !{!7, null}
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{i32 7, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"wchar_size", i32 4}
+!11 = !{!"clang version 11.0.0"}
+!12 = distinct !DISubprogram(name: "fn1", scope: !1, file: !1, line: 3, type: !13, scopeLine: 3, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!7, !7}
+!15 = !{!16}
+!16 = !DILocalVariable(name: "arg1", arg: 1, scope: !12, file: !1, line: 3, type: !7)
+!21 = !DILocation(line: 3, column: 13, scope: !12)
+!22 = !DILocation(line: 4, column: 7, scope: !23)
+!23 = distinct !DILexicalBlock(scope: !12, file: !1, line: 4, column: 7)
+!24 = !DILocation(line: 4, column: 12, scope: !23)
+!25 = !DILocation(line: 4, column: 7, scope: !12)
+!31 = distinct !DISubprogram(name: "fn2", scope: !1, file: !1, line: 10, type: !32, scopeLine: 10, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !34)
+!32 = !DISubroutineType(types: !33)
+!33 = !{!7}
+!34 = !{!35}
+!35 = !DILocalVariable(name: "local1", scope: !31, file: !1, line: 11, type: !7)
+!36 = !DILocation(line: 11, column: 3, scope: !31)

llvm/test/DebugInfo/debugify-each.ll

-; RUN: opt -debugify-each -O3 -S -o /dev/null < %s 2> %t
+; RUN: opt -debugify-each=synthetic -O3 -S -o /dev/null < %s 2> %t
 ; RUN: FileCheck %s -input-file=%t -check-prefix=MODULE-PASS
 ; RUN: FileCheck %s -input-file=%t -check-prefix=FUNCTION-PASS
 
-; RUN: opt -enable-debugify -debugify-each -O3 -S -o /dev/null < %s 2> %t
+; RUN: opt -enable-debugify=synthetic -debugify-each=synthetic -O3 -S -o /dev/null < %s 2> %t
 ; RUN: FileCheck %s -input-file=%t -check-prefix=MODULE-PASS
 ; RUN: FileCheck %s -input-file=%t -check-prefix=FUNCTION-PASS
 
-; RUN: opt -debugify-each -instrprof -instrprof -sroa -sccp -S -o /dev/null < %s 2> %t
+; RUN: opt -debugify-each=synthetic -instrprof -instrprof -sroa -sccp -S -o /dev/null < %s 2> %t
 ; RUN: FileCheck %s -input-file=%t -check-prefix=MODULE-PASS
 ; RUN: FileCheck %s -input-file=%t -check-prefix=FUNCTION-PASS
 
 ; Verify that debugify each can be safely used with piping
-; RUN: opt -debugify-each -O1 < %s | opt -O2 -o /dev/null
+; RUN: opt -debugify-each=synthetic -O1 < %s | opt -O2 -o /dev/null
 
 ; Check that the quiet mode emits no messages.
-; RUN: opt -disable-output -debugify-quiet -debugify-each -O1 < %s 2>&1 | count 0
+; RUN: opt -disable-output -debugify-quiet -debugify-each=synthetic -O1 < %s 2>&1 | count 0
 
 ; Check that stripped textual IR compares equal before and after applying
 ; debugify.
 ; RUN: opt -O1 < %s -S -o %t.before
-; RUN: opt -O1 -debugify-each < %s -S -o %t.after
+; RUN: opt -O1 -debugify-each=synthetic < %s -S -o %t.after
 ; RUN: diff %t.before %t.after
 
 ; Check that stripped IR compares equal before and after applying debugify.
 ; RUN: opt -O1 < %s | llvm-dis -o %t.before
-; RUN: opt -O1 -debugify-each < %s | llvm-dis -o %t.after
+; RUN: opt -O1 -debugify-each=synthetic < %s | llvm-dis -o %t.after
 ; RUN: diff %t.before %t.after
 
 define void @foo(i32 %arg) {
   call i32 asm "bswap $0", "=r,r"(i32 %arg)
   ret void
 }
 
 define void @bar() {

llvm/test/DebugInfo/debugify-export.ll

-; RUN: opt < %s -debugify-each -debugify-quiet -debugify-export - -o /dev/null | FileCheck %s
+; RUN: opt < %s -debugify-each=synthetic -debugify-quiet -debugify-export - -o /dev/null | FileCheck %s
 
 ; CHECK: Pass Name
 ; CHECK-SAME: # of missing debug values
 ; CHECK-SAME: # of missing locations
 ; CHECK-SAME: Missing/Expected value ratio
 ; CHECK-SAME: Missing/Expected location ratio
 
 ; CHECK: Module Verifier
 ; CHECK-SAME: 0,0,0.000000e+00,0.000000e+00
 
 define void @foo() {
   ret void
 }

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

+; Check the preservation of original debug info.
+
+; RUN: opt -enable-debugify=original -instcombine -S -o - < %s 2>&1 | FileCheck %s
+
+; CHECK: CheckModuleDebugify(original): : PASS
+
+; ModuleID = 'test'
+source_filename = "test.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: norecurse nounwind readnone uwtable
+define dso_local i32 @fn1(i32 %0) local_unnamed_addr !dbg !12 {
+  call void @llvm.dbg.value(metadata i32 %0, metadata !16, metadata !DIExpression()), !dbg !17
+  %2 = and i32 %0, 1, !dbg !18
+  %.0 = add nsw i32 %2, %0, !dbg !20
+  ret i32 %.0, !dbg !21
+}
+
+; Function Attrs: nounwind uwtable
+define dso_local i32 @fn2() local_unnamed_addr !dbg !22 {
+  %1 = tail call i32 (...) @fn3(), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %1, metadata !26, metadata !DIExpression()), !dbg !28
+  call void @llvm.dbg.value(metadata i32 %1, metadata !16, metadata !DIExpression()), !dbg !29
+  %2 = and i32 %1, 1, !dbg !31
+  %reass.add = shl i32 %1, 1
+  %3 = or i32 %2, %reass.add
+  call void @llvm.dbg.value(metadata i32 %3, metadata !26, metadata !DIExpression()), !dbg !28
+  ret i32 %3, !dbg !32
+}
+
+declare !dbg !4 dso_local i32 @fn3(...) local_unnamed_addr
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 11.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !3, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "/")
+!2 = !{}
+!3 = !{!4}
+!4 = !DISubprogram(name: "fn3", scope: !1, file: !1, line: 1, type: !5, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!5 = !DISubroutineType(types: !6)
+!6 = !{!7, null}
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{i32 7, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"wchar_size", i32 4}
+!11 = !{!"clang version 11.0.0"}
+!12 = distinct !DISubprogram(name: "fn1", scope: !1, file: !1, line: 2, type: !13, scopeLine: 2, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!7, !7}
+!15 = !{!16}
+!16 = !DILocalVariable(name: "arg1", arg: 1, scope: !12, file: !1, line: 2, type: !7)
+!17 = !DILocation(line: 0, scope: !12)
+!18 = !DILocation(line: 3, column: 12, scope: !19)
+!19 = distinct !DILexicalBlock(scope: !12, file: !1, line: 3, column: 7)
+!20 = !DILocation(line: 3, column: 7, scope: !12)
+!21 = !DILocation(line: 6, column: 1, scope: !12)
+!22 = distinct !DISubprogram(name: "fn2", scope: !1, file: !1, line: 7, type: !23, scopeLine: 7, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !25)
+!23 = !DISubroutineType(types: !24)
+!24 = !{!7}
+!25 = !{!26}
+!26 = !DILocalVariable(name: "local1", scope: !22, file: !1, line: 8, type: !7)
+!27 = !DILocation(line: 8, column: 16, scope: !22)
+!28 = !DILocation(line: 0, scope: !22)
+!29 = !DILocation(line: 0, scope: !12, inlinedAt: !30)
+!30 = distinct !DILocation(line: 9, column: 13, scope: !22)
+!31 = !DILocation(line: 3, column: 12, scope: !19, inlinedAt: !30)
+!32 = !DILocation(line: 10, column: 3, scope: !22)

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

+; RUN: opt -enable-debugify=original -instcombine -S -o - < %s 2>&1 | FileCheck %s
+
+; CHECK: ModuleDebugify (original): Skipping module without debug info
+; CHECK-NEXT: CheckModuleDebugify(original): 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/test/DebugInfo/debugify.ll

 ; RUN: opt -debugify -S -o - < %s | FileCheck %s
 ; RUN: opt -passes=debugify -S -o - < %s | FileCheck %s
 
 ; RUN: opt -debugify -debugify -S -o - < %s 2>&1 | \
 ; RUN:   FileCheck %s -check-prefix=CHECK-REPEAT
 ; RUN: opt -passes=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="CheckModuleDebugify: FAIL"
 ; RUN: opt -passes=debugify,check-debugify -S -o - < %s | \
 ; RUN:   FileCheck %s -implicit-check-not="CheckModuleDebugify: FAIL"
-; RUN: opt -enable-debugify -passes=verify -S -o - < %s | \
+; RUN: opt -enable-debugify=synthetic -passes=verify -S -o - < %s | \
 ; RUN:   FileCheck %s -implicit-check-not="CheckModuleDebugify: FAIL"
 
 ; RUN: opt -debugify -strip -check-debugify -S -o - < %s 2>&1 | \
 ; RUN:   FileCheck %s -check-prefix=CHECK-FAIL
 
-; RUN: opt -enable-debugify -strip -S -o - < %s 2>&1 | \
+; RUN: opt -enable-debugify=synthetic -strip -S -o - < %s 2>&1 | \
 ; RUN:   FileCheck %s -check-prefix=CHECK-FAIL
 
-; RUN: opt -enable-debugify -S -o - < %s 2>&1 | FileCheck %s -check-prefix=PASS
+; RUN: opt -enable-debugify=synthetic -S -o - < %s 2>&1 | FileCheck %s -check-prefix=PASS
 
 ; Verify that debugify can be safely used with piping
-; RUN: opt -enable-debugify -O1 < %s | opt -O2 -o /dev/null
+; RUN: opt -enable-debugify=synthetic -O1 < %s | opt -O2 -o /dev/null
 ; RUN: opt -debugify -mem2reg -check-debugify < %s | opt -O2 -o /dev/null
 
 ; CHECK-LABEL: define void @foo
 define void @foo() {
 ; CHECK: ret void, !dbg ![[RET1:.*]]
   ret void
 }
 

llvm/test/DebugInfo/pr37964.ll

-; RUN: opt -disable-output -debugify-each -gvn < %s 2>&1 | FileCheck %s
+; RUN: opt -disable-output -debugify-each=synthetic -gvn < %s 2>&1 | FileCheck %s
 
 ; CHECK-NOT: ERROR: Instruction with empty DebugLoc in function _Z3bazv --  {{%.*}} = phi
 ; CHECK: CheckFunctionDebugify [Global Value Numbering]: PASS
 
 @foo = dso_local local_unnamed_addr global i32 0, align 4
 @x = global i8 17
 
 define dso_local void @_Z3bazv() local_unnamed_addr #0 {

llvm/test/Transforms/CodeGenPrepare/AArch64/overflow-intrinsics.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -codegenprepare -S < %s | FileCheck %s
-; RUN: opt -enable-debugify -codegenprepare -S < %s 2>&1 | FileCheck %s -check-prefix=DEBUG
+; RUN: opt -enable-debugify=synthetic -codegenprepare -S < %s 2>&1 | FileCheck %s -check-prefix=DEBUG
 
 ; Subset of tests from llvm/tests/Transforms/CodeGenPrepare/X86/overflow-intrinsics.ll
 ; to test shouldFormOverflowOp on SPARC, where it is not profitable to create
 ; overflow intrinsics if the math part is not used.
 
 target triple = "arm64-apple-iphoneos"
 
 define i64 @uaddo1_overflow_used(i64 %a, i64 %b) nounwind ssp {

llvm/test/Transforms/CodeGenPrepare/SPARC/overflow-intrinsics.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -codegenprepare -S < %s | FileCheck %s
-; RUN: opt -enable-debugify -codegenprepare -S < %s 2>&1 | FileCheck %s -check-prefix=DEBUG
+; RUN: opt -enable-debugify=synthetic -codegenprepare -S < %s 2>&1 | FileCheck %s -check-prefix=DEBUG
 
 ; Subset of tests from llvm/tests/Transforms/CodeGenPrepare/X86/overflow-intrinsics.ll
 ; to test shouldFormOverflowOp on SPARC, where it is not profitable to create
 ; overflow intrinsics if the math part is not used.
 
 target triple = "sparc64-unknown-linux"
 
 define i64 @uaddo1_overflow_used(i64 %a, i64 %b) nounwind ssp {

llvm/test/Transforms/CodeGenPrepare/X86/overflow-intrinsics.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -codegenprepare -S < %s | FileCheck %s
-; RUN: opt -enable-debugify -codegenprepare -S < %s 2>&1 | FileCheck %s -check-prefix=DEBUG
+; RUN: opt -enable-debugify=synthetic -codegenprepare -S < %s 2>&1 | FileCheck %s -check-prefix=DEBUG
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-apple-darwin10.0.0"
 
 define i64 @uaddo1_overflow_used(i64 %a, i64 %b) nounwind ssp {
 ; CHECK-LABEL: @uaddo1_overflow_used(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 [[B:%.*]], i64 [[A:%.*]])
 ; CHECK-NEXT:    [[MATH:%.*]] = extractvalue { i64, i1 } [[TMP1]], 0

llvm/test/Transforms/CodeGenPrepare/X86/vec-shift.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -codegenprepare -mtriple=x86_64-- -mattr=+avx -S < %s | FileCheck %s --check-prefixes=ALL,AVX,AVX1
 ; RUN: opt -codegenprepare -mtriple=x86_64-- -mattr=+avx2 -S < %s | FileCheck %s --check-prefixes=ALL,AVX,AVX2
 ; RUN: opt -codegenprepare -mtriple=x86_64-- -mattr=+avx512bw -S < %s | FileCheck %s --check-prefixes=ALL,AVX,AVX512BW
 ; RUN: opt -codegenprepare -mtriple=x86_64-- -mattr=+avx,+xop -S < %s | FileCheck %s --check-prefixes=ALL,XOP,XOPAVX1
 ; RUN: opt -codegenprepare -mtriple=x86_64-- -mattr=+avx2,+xop -S < %s | FileCheck %s --check-prefixes=ALL,XOP,XOPAVX2
-; RUN: opt -codegenprepare -mtriple=x86_64-- -mattr=+avx -S -enable-debugify < %s 2>&1 | FileCheck %s -check-prefix=DEBUG
+; RUN: opt -codegenprepare -mtriple=x86_64-- -mattr=+avx -S -enable-debugify=synthetic < %s 2>&1 | FileCheck %s -check-prefix=DEBUG
 
 define <4 x i32> @vector_variable_shift_right_v4i32(<4 x i1> %cond, <4 x i32> %x, <4 x i32> %y, <4 x i32> %z) {
 ; AVX1-LABEL: @vector_variable_shift_right_v4i32(
 ; AVX1-NEXT:    [[SPLAT1:%.*]] = shufflevector <4 x i32> [[X:%.*]], <4 x i32> undef, <4 x i32> zeroinitializer
 ; AVX1-NEXT:    [[SPLAT2:%.*]] = shufflevector <4 x i32> [[Y:%.*]], <4 x i32> undef, <4 x i32> zeroinitializer
 ; AVX1-NEXT:    [[SEL:%.*]] = select <4 x i1> [[COND:%.*]], <4 x i32> [[SPLAT1]], <4 x i32> [[SPLAT2]]
 ; AVX1-NEXT:    [[TMP1:%.*]] = lshr <4 x i32> [[Z:%.*]], [[SPLAT1]]
 ; AVX1-NEXT:    [[TMP2:%.*]] = lshr <4 x i32> [[Z]], [[SPLAT2]]

llvm/test/Transforms/CorrelatedValuePropagation/ashr.ll

 ; RUN: opt < %s -correlated-propagation -S | FileCheck %s
 
 ; Check that debug locations are preserved. For more info see:
 ;   https://llvm.org/docs/SourceLevelDebugging.html#fixing-errors
-; RUN: opt < %s -enable-debugify -correlated-propagation -S 2>&1 | \
+; RUN: opt < %s -enable-debugify=synthetic -correlated-propagation -S 2>&1 | \
 ; RUN:   FileCheck %s -check-prefix=DEBUG
 ; DEBUG: CheckModuleDebugify: PASS
 
 ; CHECK-LABEL: @test1
 define void @test1(i32 %n) {
 entry:
   br label %for.cond
 

llvm/test/Transforms/CorrelatedValuePropagation/overflows.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -correlated-propagation < %s | FileCheck %s
 
 ; Check that debug locations are preserved. For more info see:
 ;   https://llvm.org/docs/SourceLevelDebugging.html#fixing-errors
-; RUN: opt < %s -enable-debugify -correlated-propagation -S 2>&1 | \
+; RUN: opt < %s -enable-debugify=synthetic -correlated-propagation -S 2>&1 | \
 ; RUN:   FileCheck %s -check-prefix=DEBUG
 ; DEBUG: CheckModuleDebugify: PASS
 
 declare { i32, i1 } @llvm.sadd.with.overflow.i32(i32, i32)
 
 declare { i32, i1 } @llvm.ssub.with.overflow.i32(i32, i32)
 
 declare { i32, i1 } @llvm.smul.with.overflow.i32(i32, i32)

llvm/test/Transforms/CorrelatedValuePropagation/sext.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -correlated-propagation -S | FileCheck %s
 
 ; Check that debug locations are preserved. For more info see:
 ;   https://llvm.org/docs/SourceLevelDebugging.html#fixing-errors
-; RUN: opt < %s -enable-debugify -correlated-propagation -S 2>&1 | \
+; RUN: opt < %s -enable-debugify=synthetic -correlated-propagation -S 2>&1 | \
 ; RUN:   FileCheck %s -check-prefix=DEBUG
 ; DEBUG: CheckModuleDebugify: PASS
 
 declare void @use64(i64)
 
 define void @test1(i32 %n) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:

llvm/test/Transforms/CorrelatedValuePropagation/udiv.ll

 ; RUN: opt < %s -correlated-propagation -S | FileCheck %s
 
 ; Check that debug locations are preserved. For more info see:
 ;   https://llvm.org/docs/SourceLevelDebugging.html#fixing-errors
-; RUN: opt < %s -enable-debugify -correlated-propagation -S 2>&1 | \
+; RUN: opt < %s -enable-debugify=synthetic -correlated-propagation -S 2>&1 | \
 ; RUN:   FileCheck %s -check-prefix=DEBUG
 ; DEBUG: CheckModuleDebugify: PASS
 
 ; CHECK-LABEL: @test_nop
 define void @test_nop(i32 %n) {
 ; CHECK: udiv i32 %n, 100
   %div = udiv i32 %n, 100
   ret void

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

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

llvm/test/Transforms/InstCombine/double-float-shrink-2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -S -mtriple "i386-pc-linux"     | FileCheck %s
 ; RUN: opt < %s -instcombine -S -mtriple "i386-pc-win32"     | FileCheck %s
 ; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-win32"   | FileCheck %s
 ; RUN: opt < %s -instcombine -S -mtriple "i386-pc-mingw32"   | FileCheck %s
 ; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-mingw32" | FileCheck %s
 ; RUN: opt < %s -instcombine -S -mtriple "sparc-sun-solaris" | FileCheck %s
-; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-win32" -enable-debugify 2>&1 | FileCheck --check-prefix=DBG-VALID %s
+; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-win32" -enable-debugify=synthetic 2>&1 | FileCheck --check-prefix=DBG-VALID %s
 
 declare double @floor(double)
 declare double @ceil(double)
 declare double @round(double)
 declare double @roundeven(double)
 declare double @nearbyint(double)
 declare double @trunc(double)
 declare double @fabs(double)

llvm/test/Transforms/InstCombine/malloc-free-delete-dbginvar.ll

 ; Check that the instcombine result is the same with/without debug info.
 ; This is a regression test for a function taken from malloc-free-delete.ll.
 
 ; RUN: opt < %s -instcombine -S > %t.no_dbg.ll
-; RUN: opt < %s -debugify-each -instcombine -S > %t.ll
+; RUN: opt < %s -debugify-each=synthetic -instcombine -S > %t.ll
 ; RUN: diff %t.no_dbg.ll %t.ll
 
 declare void @free(i8*)
 
 define void @test12(i32* %foo) minsize {
 entry:
   %tobool = icmp eq i32* %foo, null
   br i1 %tobool, label %if.end, label %if.then

llvm/test/Transforms/InstCombine/musttail-thunk.ll

 ; RUN: opt -instcombine -S < %s | FileCheck %s
-; RUN: opt -debugify-each -instcombine -S < %s | FileCheck %s
+; RUN: opt -debugify-each=synthetic -instcombine -S < %s | FileCheck %s
 
 ; These are both direct calls, but make sure instcombine leaves the casts
 ; alone.
 
 define i32 @call_thunk(i32 %x, i32 %y) {
   %r = call i32 bitcast (void (i32, ...)* @inc_first_arg_thunk to i32 (i32, i32)*)(i32 %x, i32 %y)
   ret i32 %r
 }

llvm/test/Transforms/SCCP/ipsccp-basic.ll

 ; RUN: opt < %s -ipsccp -S | FileCheck %s
-; RUN: opt < %s -enable-debugify -ipsccp -debugify-quiet -disable-output
+; RUN: opt < %s -enable-debugify=synthetic -ipsccp -debugify-quiet -disable-output
 
 ;;======================== test1
 
 define internal i32 @test1a(i32 %A) {
   %X = add i32 1, 2
   ret i32 %A
 }
 ; CHECK-LABEL: define internal i32 @test1a(

llvm/tools/opt/opt.cpp

 Quiet("q", cl::desc("Obsolete option"), cl::Hidden);
 
 static cl::alias
 QuietA("quiet", cl::desc("Alias for -q"), cl::aliasopt(Quiet));
 
 static cl::opt<bool>
 AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization"));
 
-static cl::opt<bool> EnableDebugify(
+static cl::opt<DebugifyMode> EnableDebugify(
     "enable-debugify",
-    cl::desc(
-        "Start the pipeline with debugify and end it with check-debugify"));
+    cl::desc("Start the pipeline with debugify and end it with check-debugify "
+             "by processing either synthetic or original debug info"),
+    cl::values(clEnumValN(DebugifyMode::NoDebugify, "no-debugify",
+                          "Do not use debugify"),
+               clEnumValN(DebugifyMode::SyntheticDebugInfo, "synthetic",
+                          "Synthetic Debug Info"),
+               clEnumValN(DebugifyMode::OriginalDebugInfo, "original",
+                          "Original Debug Info")),
+    cl::init(DebugifyMode::NoDebugify));
 
-static cl::opt<bool> DebugifyEach(
+static cl::opt<DebugifyMode> DebugifyEach(
     "debugify-each",
-    cl::desc(
-        "Start each pass with debugify and end it with check-debugify"));
+    cl::desc("Start each pass with debugify and end it with check-debugify by "
+             "processing either synthetic or original debug info."),
+    cl::values(clEnumValN(DebugifyMode::NoDebugify, "no-debugify",
+                          "Do not use debugify"),
+               clEnumValN(DebugifyMode::SyntheticDebugInfo, "synthetic",
+                          "Synthetic Debug Info"),
+               clEnumValN(DebugifyMode::OriginalDebugInfo, "original",
+                          "Original Debug Info")),
+    cl::init(DebugifyMode::NoDebugify));
 
 static cl::opt<std::string>
     DebugifyExport("debugify-export",
-                   cl::desc("Export per-pass debugify statistics to this file"),
+                   cl::desc("Export per-pass debugify (in synthetic mode) "
+                            "statistics to this file"),
                    cl::value_desc("filename"), cl::init(""));
 
 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::values(
             "Use instrumented (context sensitive) profile to guide PGO.")));
 cl::opt<std::string> CSProfileGenFile(
     "cs-profilegen-file",
     cl::desc("Path to the instrumented context sensitive profile."),
     cl::Hidden);
 
 class OptCustomPassManager : public legacy::PassManager {
   DebugifyStatsMap DIStatsMap;
+  DebugInfoPerPassMap DIPreservationMap;
 
 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 = DebugifyEach && !P->getAsImmutablePass() &&
+    bool WrapWithDebugify = DebugifyEach != 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:
+      if (DebugifyEach == DebugifyMode::SyntheticDebugInfo) {
         super::add(createDebugifyFunctionPass());
         super::add(P);
         super::add(createCheckDebugifyFunctionPass(true, Name, &DIStatsMap));
-        break;
-      case PT_Module:
+      } else {
+        assert(DebugifyEach == DebugifyMode::OriginalDebugInfo &&
+               "Must be original mode");
+        super::add(createDebugifyFunctionPass(DebugifyMode::OriginalDebugInfo,
+                                              Name, &DIPreservationMap));
+        super::add(P);
+        super::add(createCheckDebugifyFunctionPass(
+            false, Name, nullptr, DebugifyMode::OriginalDebugInfo,
+            &DIPreservationMap));
+      }
+      if (DebugifyEach == DebugifyMode::SyntheticDebugInfo) {
         super::add(createDebugifyModulePass());
         super::add(P);
         super::add(createCheckDebugifyModulePass(true, Name, &DIStatsMap));
-        break;
-      default:
-        super::add(P);
-        break;
+      } else {
+        assert(DebugifyEach == DebugifyMode::OriginalDebugInfo &&
+               "Must be original mode");
+        super::add(createDebugifyModulePass(DebugifyMode::OriginalDebugInfo,
+                                            Name, &DIPreservationMap));
+        super::add(P);
+        super::add(createCheckDebugifyModulePass(
+            false, Name, nullptr, DebugifyMode::OriginalDebugInfo,
+            &DIPreservationMap));
+      }
     }
   }
 
   const DebugifyStatsMap &getDebugifyStatsMap() const { return DIStatsMap; }
+  DebugInfoPerPassMap &getDebugInfoPerPassMap() {
+    return DIPreservationMap;
+  }
 };
 
 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)
if (PassPipeline.getNumOccurrences() > 0) {
 
     // The user has asked to use the new pass manager and provided a pipeline
     // string. Hand off the rest of the functionality to the new code for that
     // layer.
     return runPassPipeline(argv[0], *M, TM.get(), Out.get(), ThinLinkOut.get(),
                            RemarksFile.get(), PassPipeline, OK, VK,
                            PreserveAssemblyUseListOrder,
                            PreserveBitcodeUseListOrder, EmitSummaryIndex,
-                           EmitModuleHash, EnableDebugify, Coroutines)
+                           EmitModuleHash,
+                           EnableDebugify == DebugifyMode::SyntheticDebugInfo,
+                           Coroutines)
                ? 0
                : 1;
   }
 
   // Create a PassManager to hold and optimize the collection of passes we are
   // about to build.
   OptCustomPassManager Passes;
-  bool AddOneTimeDebugifyPasses = EnableDebugify && !DebugifyEach;
+  bool AddOneTimeDebugifyPasses = EnableDebugify != DebugifyMode::NoDebugify &&
+                                  DebugifyEach == DebugifyMode::NoDebugify;
 
   // 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();
   else {
#endif
   }
 
   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 == DebugifyMode::SyntheticDebugInfo)
       Passes.add(createDebugifyModulePass());
+    else
+      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 == DebugifyMode::SyntheticDebugInfo)
       Passes.add(createCheckDebugifyModulePass(false));
+    else
+      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;
if (Buffer.size() != FirstRunBuffer.size() ||
       if (RemarksFile)
         RemarksFile->keep();
       return 1;
     }
     if (ShouldEmitOutput)
       Out->os() << BOS->str();
   }
 
-  if (DebugifyEach && !DebugifyExport.empty())
+  if (DebugifyEach == DebugifyMode::SyntheticDebugInfo &&
+      !DebugifyExport.empty())
     exportDebugifyStats(DebugifyExport, Passes.getDebugifyStatsMap());
 
   // Declare success.
   if (!NoOutput || PrintBreakpoints)
     Out->keep();
 
   if (RemarksFile)
     RemarksFile->keep();
 
   if (ThinLinkOut)
     ThinLinkOut->keep();
 
   return 0;
 }