[POC][DebugInfo] Use entry values within IR

[djtodoro]

Summary

Using entry values on IR will give us better debugging user experience when debugging "optimized" code (swift uses llvm.dbg.values even in non-optimized code, so this refers to that code as well). This patch implements a utility (within Transforms/Utils/Local.cpp) that finds an entry Value for a given Variable.

Consider this (simple) test case:

void f1(int);
void f2(int i) {
  f1(1);
  i = i + 5;
  f1(3);
}

IR ($ clang -g -O2 -S) for the func looks:

define dso_local void @f2(i32 %i) local_unnamed_addr !dbg !7 {
entry:
  call void @llvm.dbg.value(metadata i32 %i, metadata !12, metadata !DIExpression()), !dbg !13
  tail call void @f1(i32 1), !dbg !14
  call void @llvm.dbg.value(metadata i32 %i, metadata !12, metadata !DIExpression(DW_OP_plus_uconst, 5, DW_OP_stack_value)), !dbg !13
  tail call void @f1(i32 3), !dbg !15
  ret void, !dbg !16
}

SelectionDAG for the second dbg.value generates:

DBG_VALUE $noreg, $noreg, !"i", !DIExpression(DW_OP_plus_uconst, 5, DW_OP_stack_value), debug-location !13; test.c:0 line no:2

After this set of patches, we will salvage the value by using the entry values, so the DBG_VALUE looks as following:

DBG_VALUE $edi, $noreg, !12, !DIExpression(DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 5, DW_OP_stack_value), debug-location !13

[djtodoro]

This is actually ISel phase, but we still consider SSA, so this should be the latest point we are able to use the findEntryValue() in the pipeline.

[djtodoro]

(test.c was listed within llvm/test/DebugInfo/X86/entry-values-for-isel-invalidated-nodes.ll)
Looks like LLDB has a problem with parsing "complex" expression with DW_OP_entry_value:

$ cat main.c
#include <stdio.h>

void f1(int x) {
  printf("%d\n", x);
}

int main()
{
  f2(4);
  return 0;
}

GCC generated debug_loc (gcc-test.o):

    00000000 0000000000000000 0000000000000009 (DW_OP_reg5 (rdi))
    00000013 0000000000000009 000000000000000e (DW_OP_GNU_entry_value: (DW_OP_reg5 (rdi)); DW_OP_stack_value)
    00000029 000000000000000e 000000000000001c (DW_OP_GNU_entry_value: (DW_OP_reg5 (rdi)); DW_OP_plus_uconst: 5; DW_OP_stack_value)
$ gcc --version
gcc (GCC) 4.8.5 20150623 (Red Hat 4.8.5-39)
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
$ gcc main.c gcc-test.o -o main-gcc
$ lldb ./main-gcc
(lldb) target create "./main-gcc"
Current executable set to 'main-gcc' (x86_64).
(lldb) b test.c:5
Breakpoint 1: where = main-gcc`f2 + 14 at test.c:5, address = 0x000000000040119e
(lldb) r
Process 16815 launched: 'main-gcc' (x86_64)
1
Process 16815 stopped
* thread #1, name = 'main-gcc', stop reason = breakpoint 1.1
    frame #0: 0x000000000040119e main-gcc`f2(i=5) at test.c:5
   2    void f2(int i) {
   3      f1(1);
   4      i = i + 5;
-> 5      f1(3);
   6    }
   7
(lldb) p i
(int) $0 = 5

The same situation is with the test case compiled with clang (patched by using this change).

[dstenb]

Interesting!

I will go through this more deeply, but just an initial comment is that I think it may be worth considering splitting it into two patches, in order to make it easier to review:

1. One which loosens the DIExpression limitations, and adds support to DwarfExpression. With test cases using handcrafted DIExpressions.
2. One which adds the SelectionDAG support.

[dstenb]

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

604–605 ↗

(On Diff #290277)

This means that the entry value will cover the whole expression, regardless of the number of operands that are specified in DW_OP_LLVM_entry_value? I think we want to do this conditionally in the ExprCursor loop?

Doing this after addStackValue() makes it so that the entry value contains an implicit location description, but as mentioned in DWARF5 2.5.1.7 the second operand in a DW_OP_entry_value is "a block containing a DWARF expression or a register location description", and as was discussed in D75270 and [0], location descriptions does not seem to be allowed to be used where "DWARF expressions" are specified.

[0] http://lists.dwarfstd.org/pipermail/dwarf-discuss-dwarfstd.org/2020-March/004610.html

[dstenb]

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

456–458 ↗

(On Diff #290277)

Is there test case where we land in this situation? As I understand it we still have the limitation inside DIExpression that it can only cover one operand (the register operand), and if I am not overlooking something we should have finalized the entry value on line 299:

if (isEntryValue())
  finalizeEntryValue();

[djtodoro]

@dstenb Thanks a lot for your comments! I will split this into two patches.

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

456–458 ↗

(On Diff #290277)

I should have removed this from the patch, since this is unused indeed (it was part of some testing during the development).

604–605 ↗

(On Diff #290277)

The same as above.

[djtodoro]

-Split into 2 parts
-Remove unused parts

[dstenb]

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

513 ↗

(On Diff #290680)

This might be outside of the scope of this patch, but I wonder if should change the location kind from Register to Unknown/Implicit after finalizing the entry value? The entry value operation's operand is a register location description, but the operation itself just pushes a value on the stack.

llvm/lib/IR/DebugInfoMetadata.cpp

1032

Ah, I it seems that we did not have a small Verifier case for the last condition. Perhaps we now should add a small permissive one. Something like this:

--- a/llvm/test/Verifier/diexpression-valid-entry-value.ll
+++ b/llvm/test/Verifier/diexpression-valid-entry-value.ll
@@ -1,5 +1,6 @@
 ; RUN: opt -S < %s 2>&1 | FileCheck %s
 
-!named = !{!0}
+!named = !{!0, !1}
 ; CHECK-NOT: invalid expression
 !0 = !DIExpression(DW_OP_LLVM_entry_value, 1)
+!1 = !DIExpression(DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 3, DW_OP_stack_value)

[djtodoro]

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

513 ↗

(On Diff #290680)

Hm... yes, I guess. It might be closer to Implicit location? I think that should be a separate change.

llvm/lib/IR/DebugInfoMetadata.cpp

1032

Yes, thanks!

[djtodoro]

• Test new expression

[djtodoro]

@dstenb Please let me know if this looks OK to you now.

Any other comments?

[Orlando]

llvm/lib/Transforms/Utils/Local.cpp

1606

Hi @djtodoro. IIUC this function assumes that the returned dbg.value - the first one we find - for parameter variable Var uses the corresponding argument value (as opposed to some other value that a mutable parameter could be assigned). If that is correct, why is that assumption safe?

[djtodoro]

llvm/lib/Transforms/Utils/Local.cpp

1606

(Hmm.... I've forgotten to take another look into this, in spite of the fact that I've had an item for it within my TODO list...)

Hi @Orlando.
I had a crazy premise in my mind, that every parameter should have a dbg_value on the beginning of the bb.entry. In some situations, the Value could be undef (due to some optimizations), but it will indicate just that the value has been optimized out (but it should be still there in the code). Is that correct? I've prepared this POC in rush, and have forgotten to check this once again. If the users() aren't sorted out, this should be reimplemented.

[Orlando]

llvm/lib/Transforms/Utils/Local.cpp

1606

Every parameter should have a dbg_value on the beginning of the bb.entry

My understanding is that there should be _at least_ one dbg.value for each param at the top of the function. E.g. in the following source, a parameter test has been split into two argument values and there's a fragment expression for each.

$ cat test.c
struct S {
  long long one;
  long long two;
};
void foo(struct S test) {}

$ clang -O2 -g -S -emit-llvm -o - test.c
...
define dso_local void @foo(i64 %test.coerce0, i64 %test.coerce1) local_unnamed_addr #0 !dbg !7 {
entry:
  call void @llvm.dbg.value(metadata i64 %test.coerce0, metadata !16, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64)), !dbg !17
  call void @llvm.dbg.value(metadata i64 %test.coerce1, metadata !16, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)), !dbg !17
  ret void, !dbg !18
}
...

If the users() aren't sorted out, this should be reimplemented

I am not sure if users() is sorted. I had a hunch that it isn't and I can't see any comments indicating that it is. @jmorse - or anyone else - do you know for sure?

Supposing that users() isn't sorted and we take the first assumption as truth (that every parameter should have a dbg.value at the top of the function, ignoring fragmented parameters), then I don't think it should be too hard to go forward from here. I think we could just order the dbg.values on Instruction::comesBefore(const Instruction *).

Additionally, shouldn't we be filtering out dbg.values from inlined uses of Var?

[dblaikie]

llvm/lib/Transforms/Utils/Local.cpp

1606

I am not sure if users() is sorted. I had a hunch that it isn't and I can't see any comments indicating that it is. @jmorse - or anyone else - do you know for sure?

I'm about 98% sure that use list order is not stable. (that's why there's this: https://llvm.org/doxygen/UseListOrder_8h_source.html )

[djtodoro]

llvm/lib/Transforms/Utils/Local.cpp

1606

Thanks!

We can simply iterate throughout the entry-bb and find the first dbg.value for a given parameter.

Additionally, shouldn't we be filtering out dbg.values from inlined uses of Var?

Yes. We should avoid fragmented variables as well, since we do not support such entry values at the moment.

[djtodoro]

• Update the algorithm for finding the entry values
• Improve the tests

[Orlando]

llvm/lib/Transforms/Utils/Local.cpp

1606

This function (and the unit test) LGTM now, thanks.

[dstenb]

Sorry for a piecemeal review from my part!

llvm/lib/Transforms/Utils/Local.cpp

1622

Perhaps this is too verbose?

1623

Maybe make this an early continue?

DbgValueInst *DVI = dyn_cast<DbgValueInst>(&I);
if (!DVI)
  continue;

1632–1633

I might be misunderstanding something here, but shouldn't we want to still search for the debug value even though we have encountered an inline variant of the same variable? I guess this is something that is not really common but still.

If so, this needs to be moved above the getNumElements() check.

[djtodoro]

In D87233#2288809, @dstenb wrote:

Sorry for a piecemeal review from my part!

No problem, the tempo works for me. :) Thanks!

llvm/lib/Transforms/Utils/Local.cpp

1622

No problem, I'll remove this.

1623

Sure.

1632–1633

Nice catch, thanks!

[djtodoro]

• addressing comments

[StephenTozer]

LGTM. I think the Implicit flag idea might be able to be folded into this patch without much issue, but it's not urgent and can definitely be shifted to another patch (or even just left as a TODO). Should probably be looked at by others with experience in the area, but I think most of the comments are probably going to be for the later patches in this stack.

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

303 ↗

(On Diff #293676)

With regards to the comment below about using an Implicit location, this would be a good place to do it I think. If you set LocationKind = isIndirect() ? Memory : Implicit, then DwarfExpression::addExpression will add the required stack value automatically at the end (in addition to removing the need to add || isEntryValue() to the clauses below).

[dstenb]

I'm equally fine with doing the Implicit flag change here, or for someone to do it in a separate patch.

[djtodoro]

@StephenTozer @dstenb Thanks for your comments! I'll try to change the approach (by putting some extra context), so we might end up changing this one (a bit).

I'll let you know once I am ready. :)

[djtodoro]

I am about to post new set of patches addressing this problem. We are back to the initial idea that refers to extending the llvm.dbg.value() to hold info about the entry Value. We need to do that, since the current approach (by relying on the method that uses the DILocalVariable*) couldn't detect variable modifications (in an efficient way). Another advantage we are getting with this new approach is that we can handle local variables as well, if it can be expressed in terms of an entry value such as:

void fn (int param) {
 ...
 int local = param + 2;
 ...

The idea is to extend the debug intrinsic with two extra operands:

1. 4th operand points to the Value * that holds the entry value the variable depends on
2. 5th the expression that applies to the entry Value * expressing a modification in terms of the entry value

In this initial stage, I am not handling the AutoUpgrade and bitcode backward compatibility. I will add that as well in following days, as well as some unit tests for the new functionality.

[djtodoro]

• Extend the llvm.dbg.value() with 2 operands by describing Entry Value

TODOs:

1. Handle auto-upgrade
2. Handle bitcode backward compatibility
3. Add tests (unit tests)
4. Add documentation

For now, the usage of this can be seen at: D87357

[djtodoro]

• Avoid null metadata within the new llvm.dbg.value()

[dstenb]

Some minor code style comments while I look into this.

llvm/lib/Transforms/Utils/Local.cpp

1605–1646

Perhaps make the return type Optional<EntryValue>?

1639–1643

I think this should be able to be simplified into:

return DIExpression::prepend(DIExpr, DIExpression::StackValue, Offset);

(And perhaps the lambda is not necessary then.)

[djtodoro]

llvm/lib/Transforms/Utils/Local.cpp

1605–1646

Makes sense, I'll refactor it :)

1639–1643

I've used "copy-paste" technique to make the tests working. This piece of code was copied from salvageDebugInfoImpl(), and I think this can be refactored into a static function or so.

[djtodoro]

• Use VMContext instead of InsertBB->getParent()->getContext()

• Additional TODOs:
• handle findDbgUsers() and dropDebugUsers()
• refactoring

[djtodoro]

TODO: Handle Function Inlining

[dstenb]

If I understand this correctly, the new {EntryValue, EntryExpr} operands do, if EntryExpr is not undef, specify a location that is identical to the dbg.value's current {Value, Expr} operands, but with DW_OP_LLVM_entry_value implicitly being applied to EntryValue before EntryExpr. Is that correct?

If so, just throwing out some questions (sorry in case I have overlooked the answers for this in the implementation):

• I assume that we are only interested in EntryValue operands that are Argument values? Should the verifier catch that? Or is there some case where it could anything else than an Argument?

• What should happen in cases where the dbg.values Value operand already is an Argument? Do we need to specify that value in the EntryValue operand also to ensure that entry values can be emitted?

llvm/lib/Transforms/Utils/Local.cpp

1625–1628

Nit: Can use BI here instead.

[djtodoro]

In D87233#2316204, @dstenb wrote:

If I understand this correctly, the new {EntryValue, EntryExpr} operands do, if EntryExpr is not undef, specify a location that is identical to the dbg.value's current {Value, Expr} operands, but with DW_OP_LLVM_entry_value implicitly being applied to EntryValue before EntryExpr. Is that correct?

Yes, that is correct.

If so, just throwing out some questions (sorry in case I have overlooked the answers for this in the implementation):

• I assume that we are only interested in EntryValue operands that are Argument values? Should the verifier catch that? Or is there some case where it could anything else than an Argument?

I think we should extend the Verifier with some kind of support for this. Not sure at the moment how we are going to handle this:

fn(%param) {
...
}

isa<Argument>(%param) ==>true
isa<Argument>(%param.something) ==> false (something could be `addr`)

Actually, I extended the Verifier locally, and I am catching some cases during the replaceAllUsesWith() where the entry value needs to be handled differently, e.g.:

llvm.dbg.value(%p1, !var_p1, !DIExpr(), %p1, !DIExpr()) becomes llvm.dbg.value(i32 0, !var_p1, !DIExpr(), i32 0, !DIExpr())

but we want the entry value to be an undef in this situation, so I am wondering whether we need a new representation of the entry-value, something like MetadataAsEntryValue, so we can invalidate such nodes in an efficent way.

• What should happen in cases where the dbg.values Value operand already is an Argument? Do we need to specify that value in the EntryValue operand also to ensure that entry values can be emitted?

We should, since the Argument (from some point) can start depending on different entry value, please consider this case:

void fn (int p1, int p2) {
   ...
   p1 = p2;
}

And the intrinsics would be:

llvm.dbg.value(%p1, !var_p1, !DIExpr(), %p1, !DIExpr())
llvm.dbg.value(%p2, !var_p1, !DIExpr(), %p2, !DIExpr())
....
llvm.dbg.value(%p1, !var_p1, !DIExpr(), %p2, !DIExpr()) <=== p1 is an argument, but it depends on different entry value

[djtodoro]

In D87233#2321073, @djtodoro wrote:

In D87233#2316204, @dstenb wrote:

If I understand this correctly, the new {EntryValue, EntryExpr} operands do, if EntryExpr is not undef, specify a location that is identical to the dbg.value's current {Value, Expr} operands, but with DW_OP_LLVM_entry_value implicitly being applied to EntryValue before EntryExpr. Is that correct?

Yes, that is correct.

If so, just throwing out some questions (sorry in case I have overlooked the answers for this in the implementation):

• I assume that we are only interested in EntryValue operands that are Argument values? Should the verifier catch that? Or is there some case where it could anything else than an Argument?

I think we should extend the Verifier with some kind of support for this. Not sure at the moment how we are going to handle this:

fn(%param) {
...
}

isa<Argument>(%param) ==>true
isa<Argument>(%param.something) ==> false (something could be `addr`)

Actually, I extended the Verifier locally, and I am catching some cases during the replaceAllUsesWith() where the entry value needs to be handled differently, e.g.:

llvm.dbg.value(%p1, !var_p1, !DIExpr(), %p1, !DIExpr()) becomes llvm.dbg.value(i32 0, !var_p1, !DIExpr(), i32 0, !DIExpr())

but we want the entry value to be an undef in this situation, so I am wondering whether we need a new representation of the entry-value, something like MetadataAsEntryValue, so we can invalidate such nodes in an efficent way.

• What should happen in cases where the dbg.values Value operand already is an Argument? Do we need to specify that value in the EntryValue operand also to ensure that entry values can be emitted?

We should, since the Argument (from some point) can start depending on different entry value, please consider this case:

void fn (int p1, int p2) {
   ...
   p1 = p2;
}

And the intrinsics would be:

llvm.dbg.value(%p1, !var_p1, !DIExpr(), %p1, !DIExpr())
llvm.dbg.value(%p2, !var_p1, !DIExpr(), %p2, !DIExpr())

!var_p2, sorry for my mistake

....
llvm.dbg.value(%p1, !var_p1, !DIExpr(), %p2, !DIExpr()) <=== p1 is an argument, but it depends on different entry value

[StephenTozer]

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

290–292 ↗

(On Diff #296453)

Should be fixed up before merging (relatively simple logic reassociation).

llvm/lib/Transforms/Utils/Local.cpp

1635

Nit: I believe you don't need to end the final statement in LLVM_DEBUG with a semicolon.

1637–1638

Would it not be possible to just use salvageDebugInfoImpl directly here? As far as I understand, there's no reason we shouldn't be able to support all of the salvage options for an entry value. Also, it should be possible to perform this salvage repeatedly; i.e. if we have:

void foo(int param) {
  int i = param + 3;
  int j = i + 6;
}

When creating an entry value for j, we could attempt to salvage it, find that the first operand %i is not an argument but can itself be salvaged, then attempt to salvage %i and find that its first operand is an argument, resulting in an entry value %param, DIExpression(DW_OP_plus_uconst, 3, DW_OP_plus_uconst, 6).

[djtodoro]

• Support old metadata
• Fix testcases

llvm/bindings/go/llvm/dibuilder.go

const (
   DIGlobalVariableMetadataKind             = C.LLVMDIGlobalVariableMetadataKind
   DILocalVariableMetadataKind              = C.LLVMDILocalVariableMetadataKind
   DILabelMetadataKind                      = C.LLVMDILabelMetadataKind
   DIObjCPropertyMetadataKind               = C.LLVMDIObjCPropertyMetadataKind
   DIImportedEntityMetadataKind             = C.LLVMDIImportedEntityMetadataKind
   DIMacroMetadataKind                      = C.LLVMDIMacroMetadataKind
   DIMacroFileMetadataKind                  = C.LLVMDIMacroFileMetadataKind
   DICommonBlockMetadataKind                = C.LLVMDICommonBlockMetadataKind
+  EntryValueAsMetadataMetadataKind         = C.LLVMEntryValueAsMetadataMetadataKind
 )
 
 // Kind returns the metadata kind.
 func (md Metadata) Kind() MetadataKind {
   return MetadataKind(C.LLVMGetMetadataKind(md.C))
 }
 
 // FileDirectory returns the directory of a DIFile metadata node.

llvm/include/llvm-c/DebugInfo.h

enum {
   LLVMDIGlobalVariableMetadataKind,
   LLVMDILocalVariableMetadataKind,
   LLVMDILabelMetadataKind,
   LLVMDIObjCPropertyMetadataKind,
   LLVMDIImportedEntityMetadataKind,
   LLVMDIMacroMetadataKind,
   LLVMDIMacroFileMetadataKind,
   LLVMDICommonBlockMetadataKind,
-  LLVMDIStringTypeMetadataKind
+  LLVMDIStringTypeMetadataKind,
+  LLVMEntryValueAsMetadataMetadataKind
 };
 typedef unsigned LLVMMetadataKind;
 
 /**
  * An LLVM DWARF type encoding.
  */
 typedef unsigned LLVMDWARFTypeEncoding;
 

llvm/include/llvm/IR/DIBuilder.h

class DIBuilder {
     /// Internal helper for insertLabel.
     Instruction *insertLabel(DILabel *LabelInfo, const DILocation *DL,
                              BasicBlock *InsertBB, Instruction *InsertBefore);
 
     /// Internal helper for insertDbgValueIntrinsic.
     Instruction *
     insertDbgValueIntrinsic(llvm::Value *Val, DILocalVariable *VarInfo,
                             DIExpression *Expr, const DILocation *DL,
-                            BasicBlock *InsertBB, Instruction *InsertBefore);
+                            BasicBlock *InsertBB, Instruction *InsertBefore,
+                            llvm::Value *EntryValue = nullptr,
+                            llvm::DIExpression *EntryDIExpr = nullptr);
 
   public:
     /// Construct a builder for a module.
     ///
     /// If \c AllowUnresolved, collect unresolved nodes attached to the module
     /// in order to resolve cycles during \a finalize().
     ///
     /// If \p CU is given a value other than nullptr, then set \p CUNode to CU.
Instruction *insertDbgValueIntrinsic(llvm::Value *Val,
                                          BasicBlock *InsertAtEnd);
 
     /// Insert a new llvm.dbg.value intrinsic call.
     /// \param Val          llvm::Value of the variable
     /// \param VarInfo      Variable's debug info descriptor.
     /// \param Expr         A complex location expression.
     /// \param DL           Debug info location.
     /// \param InsertBefore Location for the new intrinsic.
-    Instruction *insertDbgValueIntrinsic(llvm::Value *Val,
-                                         DILocalVariable *VarInfo,
-                                         DIExpression *Expr,
-                                         const DILocation *DL,
-                                         Instruction *InsertBefore);
+    /// \param EntryValue   An entry value.
+    /// \param EntryDIExpr  An entry value expression.
+    Instruction *
+    insertDbgValueIntrinsic(llvm::Value *Val, DILocalVariable *VarInfo,
+                            DIExpression *Expr, const DILocation *DL,
+                            Instruction *InsertBefore,
+                            llvm::Value *EntryValue = nullptr,
+                            llvm::DIExpression *EntryDIExpr = nullptr);
 
     /// Replace the vtable holder in the given type.
     ///
     /// If this creates a self reference, it may orphan some unresolved cycles
     /// in the operands of \c T, so \a DIBuilder needs to track that.
     void replaceVTableHolder(DICompositeType *&T,
                              DIType *VTableHolder);
 

llvm/include/llvm/IR/IntrinsicInst.h

 
 /// This represents the llvm.dbg.value instruction.
 class DbgValueInst : public DbgVariableIntrinsic {
 public:
   Value *getValue() const {
     return getVariableLocation(/* AllowNullOp = */ false);
   }
 
+  /// \return the entry value for the variable or nullptr.
+  Value *getVariableEntryValue() const;
+
+  /// \return an expression that applies on the entry value.
+  DIExpression *getEntryExpression() const;
+
+  /// Sets the entry value to undef.
+  void setEntryValueToUndef();
+
   /// \name Casting methods
   /// @{
   static bool classof(const IntrinsicInst *I) {
     return I->getIntrinsicID() == Intrinsic::dbg_value;
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }

llvm/include/llvm/IR/Intrinsics.td

 let IntrProperties = [IntrNoMem, IntrSpeculatable, IntrWillReturn] in {
   def int_dbg_declare      : Intrinsic<[],
                                        [llvm_metadata_ty,
                                         llvm_metadata_ty,
                                         llvm_metadata_ty]>;
   def int_dbg_value        : Intrinsic<[],
                                        [llvm_metadata_ty,
                                         llvm_metadata_ty,
+                                        llvm_metadata_ty,
+                                        llvm_metadata_ty,
                                         llvm_metadata_ty]>;
   def int_dbg_addr         : Intrinsic<[],
                                        [llvm_metadata_ty,
                                         llvm_metadata_ty,
                                         llvm_metadata_ty]>;
   def int_dbg_label        : Intrinsic<[],
                                        [llvm_metadata_ty]>;
 }

llvm/include/llvm/IR/Metadata.h

protected:
   ValueAsMetadata(unsigned ID, Value *V)
       : Metadata(ID, Uniqued), ReplaceableMetadataImpl(V->getContext()), V(V) {
     assert(V && "Expected valid value");
   }
 
   ~ValueAsMetadata() = default;
 
 public:
-  static ValueAsMetadata *get(Value *V);
+  static ValueAsMetadata *get(Value *V, bool IsEntryValue = false);
 
   static ConstantAsMetadata *getConstant(Value *C) {
     return cast<ConstantAsMetadata>(get(C));
   }
 
   static LocalAsMetadata *getLocal(Value *Local) {
     return cast<LocalAsMetadata>(get(Local));
   }
 
+  static EntryValueAsMetadata *getEntryValue(Value *V) {
+    return cast<EntryValueAsMetadata>(get(V));
+  }
+
   static ValueAsMetadata *getIfExists(Value *V);
 
   static ConstantAsMetadata *getConstantIfExists(Value *C) {
     return cast_or_null<ConstantAsMetadata>(getIfExists(C));
   }
 
   static LocalAsMetadata *getLocalIfExists(Value *Local) {
     return cast_or_null<LocalAsMetadata>(getIfExists(Local));
   }
 
+  static EntryValueAsMetadata *getEntryValueIfExists(Value *V) {
+    return cast_or_null<EntryValueAsMetadata>(getIfExists(V));
+  }
+
   Value *getValue() const { return V; }
   Type *getType() const { return V->getType(); }
   LLVMContext &getContext() const { return V->getContext(); }
 
   static void handleDeletion(Value *V);
   static void handleRAUW(Value *From, Value *To);
 
 protected:
   /// Handle collisions after \a Value::replaceAllUsesWith().
   ///
   /// RAUW isn't supported directly for \a ValueAsMetadata, but if the wrapped
   /// \a Value gets RAUW'ed and the target already exists, this is used to
   /// merge the two metadata nodes.
   void replaceAllUsesWith(Metadata *MD) {
     ReplaceableMetadataImpl::replaceAllUsesWith(MD);
   }
 
 public:
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == LocalAsMetadataKind ||
-           MD->getMetadataID() == ConstantAsMetadataKind;
+           MD->getMetadataID() == ConstantAsMetadataKind ||
+           MD->getMetadataID() == EntryValueAsMetadataKind;
+  }
+};
+
+class EntryValueAsMetadata : public ValueAsMetadata {
+  friend class ValueAsMetadata;
+
+  EntryValueAsMetadata(Value *V)
+      : ValueAsMetadata(EntryValueAsMetadataKind, V) {}
+
+public:
+  static EntryValueAsMetadata *get(Value *V) {
+    return ValueAsMetadata::getEntryValue(V);
+  }
+
+  static EntryValueAsMetadata *getIfExists(Value *V) {
+    return ValueAsMetadata::getEntryValueIfExists(V);
+  }
+
+  static bool classof(const Metadata *MD) {
+    return MD->getMetadataID() == EntryValueAsMetadataKind;
   }
 };
 
 class ConstantAsMetadata : public ValueAsMetadata {
   friend class ValueAsMetadata;
 
   ConstantAsMetadata(Constant *C)
       : ValueAsMetadata(ConstantAsMetadataKind, C) {}

llvm/include/llvm/IR/Metadata.def

 #ifndef HANDLE_SPECIALIZED_MDNODE_BRANCH
 #define HANDLE_SPECIALIZED_MDNODE_BRANCH(CLASS) HANDLE_MDNODE_BRANCH(CLASS)
 #endif
 
 HANDLE_METADATA_LEAF(MDString)
 HANDLE_METADATA_BRANCH(ValueAsMetadata)
 HANDLE_METADATA_LEAF(ConstantAsMetadata)
 HANDLE_METADATA_LEAF(LocalAsMetadata)
+HANDLE_METADATA_LEAF(EntryValueAsMetadata)
 HANDLE_METADATA_LEAF(DistinctMDOperandPlaceholder)
 HANDLE_MDNODE_BRANCH(MDNode)
 HANDLE_MDNODE_LEAF_UNIQUABLE(MDTuple)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILocation)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIExpression)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGlobalVariableExpression)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DINode)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(GenericDINode)

llvm/include/llvm/IR/Value.h

protected:
   /// any.
   ///
   /// This is stored here to save space in User on 64-bit hosts.  Since most
   /// instances of Value have operands, 32-bit hosts aren't significantly
   /// affected.
   ///
   /// Note, this should *NOT* be used directly by any class other than User.
   /// User uses this value to find the Use list.
-  enum : unsigned { NumUserOperandsBits = 28 };
+  enum : unsigned { NumUserOperandsBits = 27 };
   unsigned NumUserOperands : NumUserOperandsBits;
 
+  /// A value could be used by regular metadata and/or as an entry value.
+  enum : unsigned {
+    NotUsedByMD = 0,
+    UsedBySSA = 1,
+    UsedByEV = 2,
+    UsedByEVandSSA = 3
+  };
+  unsigned IsUsedByMD : 2;
+
   // Use the same type as the bitfield above so that MSVC will pack them.
-  unsigned IsUsedByMD : 1;
   unsigned HasName : 1;
   unsigned HasHungOffUses : 1;
   unsigned HasDescriptor : 1;
 
 private:
   template <typename UseT> // UseT == 'Use' or 'const Use'
   class use_iterator_impl
       : public std::iterator<std::forward_iterator_tag, UseT *> {
#include "llvm/IR/Value.def"
   bool hasSameSubclassOptionalData(const Value *V) const {
     return SubclassOptionalData == V->SubclassOptionalData;
   }
 
   /// Return true if there is a value handle associated with this value.
   bool hasValueHandle() const { return HasValueHandle; }
 
   /// Return true if there is metadata referencing this value.
-  bool isUsedByMetadata() const { return IsUsedByMD; }
+  bool isUsedByMetadata() const {
+    return IsUsedByMD != NotUsedByMD;
+  }
 
   /// Return true if this value is a swifterror value.
   ///
   /// swifterror values can be either a function argument or an alloca with a
   /// swifterror attribute.
   bool isSwiftError() const;
 
   /// Strip off pointer casts, all-zero GEPs and address space casts.

llvm/include/llvm/Transforms/Utils/Local.h

 /// 'V' points to. This may include a mix of dbg.declare and
 /// dbg.addr intrinsics.
 TinyPtrVector<DbgVariableIntrinsic *> FindDbgAddrUses(Value *V);
 
 /// Like \c FindDbgAddrUses, but only returns dbg.declare intrinsics, not
 /// dbg.addr.
 TinyPtrVector<DbgDeclareInst *> FindDbgDeclareUses(Value *V);
 
+/// Represents an entry value.
+struct EntryValue {
+  // Value that is entry one.
+  Value *V;
+  // Expression that applies onto V.
+  DIExpression *Expr;
+};
+
+/// Finds an entry value for a variable.
+Optional<EntryValue> findEntryValue(Value *V, Function &F);
+
 /// Finds the llvm.dbg.value intrinsics describing a value.
 void findDbgValues(SmallVectorImpl<DbgValueInst *> &DbgValues, Value *V);
 
 /// Finds the debug info intrinsics describing a value.
 void findDbgUsers(SmallVectorImpl<DbgVariableIntrinsic *> &DbgInsts, Value *V);
 
 /// Replaces llvm.dbg.declare instruction when the address it
 /// describes is replaced with a new value. If Deref is true, an

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
       // Add the constraint string.
       const std::string &ConstraintStr = IA->getConstraintString();
       Record.push_back(ConstraintStr.size());
       Record.append(ConstraintStr.begin(), ConstraintStr.end());
       Stream.EmitRecord(bitc::CST_CODE_INLINEASM, Record);
       Record.clear();
       continue;
     }
+
+    assert(isa<Constant>(V) && "Value expected to be a constant.");
     const Constant *C = cast<Constant>(V);
     unsigned Code = -1U;
     unsigned AbbrevToUse = 0;
     if (C->isNullValue()) {
       Code = bitc::CST_CODE_NULL;
     } else if (isa<UndefValue>(C)) {
       Code = bitc::CST_CODE_UNDEF;
     } else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) {

llvm/lib/Bitcode/Writer/ValueEnumerator.cpp

while (!Worklist.empty()) {
     }
   }
 }
 
 const MDNode *ValueEnumerator::enumerateMetadataImpl(unsigned F, const Metadata *MD) {
   if (!MD)
     return nullptr;
 
-  assert(
-      (isa<MDNode>(MD) || isa<MDString>(MD) || isa<ConstantAsMetadata>(MD)) &&
+  assert((isa<MDNode>(MD) || isa<MDString>(MD) || isa<ConstantAsMetadata>(MD) ||
+          isa<EntryValueAsMetadata>(MD)) &&
          "Invalid metadata kind");
 
   auto Insertion = MetadataMap.insert(std::make_pair(MD, MDIndex(F)));
   MDIndex &Entry = Insertion.first->second;
   if (!Insertion.second) {
     // Already mapped.  If F doesn't match the function tag, drop it.
     if (Entry.hasDifferentFunction(F))
       dropFunctionFromMetadata(*Insertion.first);
     return nullptr;
   }
 
   // Don't assign IDs to metadata nodes.
   if (auto *N = dyn_cast<MDNode>(MD))
     return N;
 
   // Save the metadata.
   MDs.push_back(MD);
   Entry.ID = MDs.size();
 
   // Enumerate the constant, if any.
   if (auto *C = dyn_cast<ConstantAsMetadata>(MD))
     EnumerateValue(C->getValue());
+  else if (auto *EV = dyn_cast<EntryValueAsMetadata>(MD)) {
+    if (isa<Constant>(EV->getValue())) {
+      assert(isa<UndefValue>(EV->getValue()) && "Must be undef as entry value");
+      EnumerateValue(EV->getValue());
+    }
+  }
 
   return nullptr;
 }
 
 /// EnumerateFunctionLocalMetadataa - Incorporate function-local metadata
 /// information reachable from the metadata.
 void ValueEnumerator::EnumerateFunctionLocalMetadata(
     unsigned F, const LocalAsMetadata *Local) {

llvm/lib/IR/AutoUpgrade.cpp

if (Name.startswith("cttz.") && F->arg_size() == 1) {
       rename(F);
       NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::cttz,
                                         F->arg_begin()->getType());
       return true;
     }
     break;
   }
   case 'd': {
-    if (Name == "dbg.value" && F->arg_size() == 4) {
+    if (Name == "dbg.value" && (F->arg_size() == 4 || F->arg_size() == 3)) {
       rename(F);
       NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::dbg_value);
       return true;
     }
     break;
   }
   case 'e': {
     SmallVector<StringRef, 2> Groups;

   case Intrinsic::ctpop:
     NewCall = Builder.CreateCall(NewFn, {CI->getArgOperand(0)});
     break;
 
   case Intrinsic::convert_from_fp16:
     NewCall = Builder.CreateCall(NewFn, {CI->getArgOperand(0)});
     break;
 
-  case Intrinsic::dbg_value:
+  case Intrinsic::dbg_value: {
     // Upgrade from the old version that had an extra offset argument.
-    assert(CI->getNumArgOperands() == 4);
+    assert(CI->getNumArgOperands() == 4 || CI->getNumArgOperands() == 3);
     // Drop nonzero offsets instead of attempting to upgrade them.
-    if (auto *Offset = dyn_cast_or_null<Constant>(CI->getArgOperand(1)))
+    if (CI->getNumArgOperands() == 4) {
+      if (auto *Offset = dyn_cast_or_null<Constant>(CI->getArgOperand(1))) {
         if (Offset->isZeroValue()) {
+          Type *EVType = nullptr;
+          if (isa<MetadataAsValue>(CI->getArgOperand(0))) {
+            auto MD =
+                cast<MetadataAsValue>(CI->getArgOperand(0))->getMetadata();
+            if (isa<ValueAsMetadata>(MD))
+              EVType = cast<ValueAsMetadata>(MD)->getType();
+          }
+
+          if (!EVType)
+            EVType = IntegerType::getInt64Ty(C);
+
           NewCall = Builder.CreateCall(
               NewFn,
-            {CI->getArgOperand(0), CI->getArgOperand(2), CI->getArgOperand(3)});
-        break;
-      }
+              {CI->getArgOperand(0), CI->getArgOperand(2), CI->getArgOperand(3),
+               MetadataAsValue::get(
+                   C, ValueAsMetadata::get(UndefValue::get(EVType),
+                                           /*IsEntryValue*/ true)),
+               MetadataAsValue::get(C, DIExpression::get(C, {}))});
+          break;
+        }
+      }
+    } else if (CI->getNumArgOperands() == 3) {
+      Type *EVType = nullptr;
+      if (isa<MetadataAsValue>(CI->getArgOperand(0))) {
+        auto MD = cast<MetadataAsValue>(CI->getArgOperand(0))->getMetadata();
+        if (isa<ValueAsMetadata>(MD))
+          EVType = cast<ValueAsMetadata>(MD)->getType();
+      }
+
+      if (!EVType)
+        EVType = IntegerType::getInt64Ty(C);
+
+      // This handles the old llvm.dbg.value:
+      //   @llvm.dbg.value.old(metadata %0, i64 %1, metadata %2)
+      if (!CI->getArgOperand(1)->getType()->isMetadataTy()) {
+        NewCall = Builder.CreateCall(
+            NewFn,
+            {CI->getArgOperand(0),
+             MetadataAsValue::get(
+                 C, ValueAsMetadata::get(CI->getArgOperand(1), false)),
+             CI->getArgOperand(2),
+             MetadataAsValue::get(C,
+                                  ValueAsMetadata::get(UndefValue::get(EVType),
+                                                       /*IsEntryValue*/ true)),
+             MetadataAsValue::get(C, DIExpression::get(C, {}))});
+        break;
+      }
+
+      assert(CI->getArgOperand(0)->getType()->isMetadataTy() &&
+             CI->getArgOperand(1)->getType()->isMetadataTy() &&
+             CI->getArgOperand(2)->getType()->isMetadataTy() &&
+             "All three dbg.value arguments should be metadata.");
+
+      NewCall = Builder.CreateCall(
+          NewFn,
+          {CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2),
+           MetadataAsValue::get(C, ValueAsMetadata::get(UndefValue::get(EVType),
+                                                        /*IsEntryValue*/ true)),
+           MetadataAsValue::get(C, DIExpression::get(C, {}))});
     CI->eraseFromParent();
     return;
-
+  }
   case Intrinsic::x86_xop_vfrcz_ss:
   case Intrinsic::x86_xop_vfrcz_sd:
     NewCall = Builder.CreateCall(NewFn, {CI->getArgOperand(1)});
     break;
 
   case Intrinsic::x86_xop_vpermil2pd:
   case Intrinsic::x86_xop_vpermil2ps:
   case Intrinsic::x86_xop_vpermil2pd_256:

llvm/lib/IR/Core.cpp

for (auto *OV : makeArrayRef(Vals, Count)) {
     if (!V)
       MD = nullptr;
     else if (auto *C = dyn_cast<Constant>(V))
       MD = ConstantAsMetadata::get(C);
     else if (auto *MDV = dyn_cast<MetadataAsValue>(V)) {
       MD = MDV->getMetadata();
       assert(!isa<LocalAsMetadata>(MD) && "Unexpected function-local metadata "
                                           "outside of direct argument to call");
+      if (isa<EntryValueAsMetadata>(MD))
+        return wrap(MetadataAsValue::get(Context, EntryValueAsMetadata::get(V)));
     } else {
       // This is function-local metadata.  Pretend to make an MDNode.
       assert(Count == 1 &&
              "Expected only one operand to function-local metadata");
       return wrap(MetadataAsValue::get(Context, LocalAsMetadata::get(V)));
     }
 
     MDs.push_back(MD);

llvm/lib/IR/DIBuilder.cpp

Instruction *DIBuilder::insertLabel(DILabel *LabelInfo, const DILocation *DL,
                                     BasicBlock *InsertAtEnd) {
   return insertLabel(LabelInfo, DL, InsertAtEnd, nullptr);
 }
 
 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V,
                                                 DILocalVariable *VarInfo,
                                                 DIExpression *Expr,
                                                 const DILocation *DL,
-                                                Instruction *InsertBefore) {
+                                                Instruction *InsertBefore,
+                                                Value *EntryValue,
+                                                DIExpression *EntryDIExpr) {
   return insertDbgValueIntrinsic(
       V, VarInfo, Expr, DL, InsertBefore ? InsertBefore->getParent() : nullptr,
-      InsertBefore);
+      InsertBefore, EntryValue, EntryDIExpr);
 }
 
 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V,
                                                 DILocalVariable *VarInfo,
                                                 DIExpression *Expr,
                                                 const DILocation *DL,
                                                 BasicBlock *InsertAtEnd) {
   return insertDbgValueIntrinsic(V, VarInfo, Expr, DL, InsertAtEnd, nullptr);
static void initIRBuilder(IRBuilder<> &Builder, const DILocation *DL,
   Builder.SetCurrentDebugLocation(DL);
 }
 
 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
   assert(V && "no value passed to dbg intrinsic");
   return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
 }
 
+static Value *getDbgIntrinsicEntryValueImpl(LLVMContext &VMContext, Value *V) {
+  assert(V && "no value passed to dbg intrinsic");
+  return MetadataAsValue::get(VMContext,
+                              ValueAsMetadata::get(V, /*IsEntryValue*/true));
+}
+
 static Function *getDeclareIntrin(Module &M) {
   return Intrinsic::getDeclaration(&M, UseDbgAddr ? Intrinsic::dbg_addr
                                                   : Intrinsic::dbg_declare);
 }
 
 Instruction *DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo,
                                       DIExpression *Expr, const DILocation *DL,
                                       BasicBlock *InsertBB, Instruction *InsertBefore) {
Instruction *DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo,
 
   IRBuilder<> B(DL->getContext());
   initIRBuilder(B, DL, InsertBB, InsertBefore);
   return B.CreateCall(DeclareFn, Args);
 }
 
 Instruction *DIBuilder::insertDbgValueIntrinsic(
     Value *V, DILocalVariable *VarInfo, DIExpression *Expr,
-    const DILocation *DL, BasicBlock *InsertBB, Instruction *InsertBefore) {
+    const DILocation *DL, BasicBlock *InsertBB, Instruction *InsertBefore,
+    Value *EntryValue, DIExpression *EntryDIExpr) {
   assert(V && "no value passed to dbg.value");
   assert(VarInfo && "empty or invalid DILocalVariable* passed to dbg.value");
   assert(DL && "Expected debug loc");
   assert(DL->getScope()->getSubprogram() ==
              VarInfo->getScope()->getSubprogram() &&
          "Expected matching subprograms");
   if (!ValueFn)
     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
 
   trackIfUnresolved(VarInfo);
   trackIfUnresolved(Expr);
+
+  if (!EntryValue || DL->getInlinedAt())
+    EntryValue = UndefValue::get(V->getType());
+  if (!EntryDIExpr || DL->getInlinedAt())
+    EntryDIExpr = DIExpression::get(VMContext, {});
+
   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
                    MetadataAsValue::get(VMContext, VarInfo),
-                   MetadataAsValue::get(VMContext, Expr)};
+                   MetadataAsValue::get(VMContext, Expr),
+                   getDbgIntrinsicEntryValueImpl(VMContext, EntryValue),
+                   MetadataAsValue::get(VMContext, EntryDIExpr)};
 
   IRBuilder<> B(DL->getContext());
   initIRBuilder(B, DL, InsertBB, InsertBefore);
   return B.CreateCall(ValueFn, Args);
 }
 
 Instruction *DIBuilder::insertLabel(
     DILabel *LabelInfo, const DILocation *DL,

llvm/lib/IR/DebugInfoMetadata.cpp

case dwarf::DW_OP_swap: {
       break;
     }
     case dwarf::DW_OP_LLVM_entry_value: {
       // An entry value operator must appear at the beginning and the number of
       // operations it cover can currently only be 1, because we support only
       // entry values of a simple register location. One reason for this is that
       // we currently can't calculate the size of the resulting DWARF block for
       // other expressions.
-      return I->get() == expr_op_begin()->get() && I->getArg(0) == 1 &&
-             getNumElements() == 2;
+      return I->get() == expr_op_begin()->get() && I->getArg(0) == 1;
     }
     case dwarf::DW_OP_LLVM_convert:
     case dwarf::DW_OP_LLVM_tag_offset:
     case dwarf::DW_OP_constu:
     case dwarf::DW_OP_plus_uconst:
     case dwarf::DW_OP_plus:
     case dwarf::DW_OP_minus:
     case dwarf::DW_OP_mul:
DIExpression *DIExpression::prependOpcodes(const DIExpression *Expr,
                                            SmallVectorImpl<uint64_t> &Ops,
                                            bool StackValue,
                                            bool EntryValue) {
   assert(Expr && "Can't prepend ops to this expression");
 
   if (EntryValue) {
     Ops.push_back(dwarf::DW_OP_LLVM_entry_value);
     // Add size info needed for entry value expression.
-    // Add plus one for target register operand.
-    Ops.push_back(Expr->getNumElements() + 1);
+    // It is always of size 1 at the moment, since we support
+    // simple register locations only.
+    Ops.push_back(1);
   }
 
   // If there are no ops to prepend, do not even add the DW_OP_stack_value.
   if (Ops.empty())
     StackValue = false;
   for (auto Op : Expr->expr_ops()) {
     // A DW_OP_stack_value comes at the end, but before a DW_OP_LLVM_fragment.
     if (StackValue) {

llvm/lib/IR/IntrinsicInst.cpp

 }
 
 Optional<uint64_t> DbgVariableIntrinsic::getFragmentSizeInBits() const {
   if (auto Fragment = getExpression()->getFragmentInfo())
     return Fragment->SizeInBits;
   return getVariable()->getSizeInBits();
 }
 
+Value *DbgValueInst::getVariableEntryValue() const {
+  Value *Op = getArgOperand(3);
+  if (!Op)
+    return nullptr;
+
+  auto *MD = cast<MetadataAsValue>(Op)->getMetadata();
+  if (auto *V = dyn_cast<ValueAsMetadata>(MD))
+    return V->getValue();
+
+  return nullptr;
+}
+
+DIExpression *DbgValueInst::getEntryExpression() const {
+  return cast<DIExpression>(
+    cast<MetadataAsValue>(getArgOperand(4))->getMetadata());
+}
+
+void DbgValueInst::setEntryValueToUndef() {
+  // FIXME: Do we need to use something like handleChangedMetadata()?
+  setOperand(3, MetadataAsValue::get(
+                    getModule()->getContext(),
+                    ValueAsMetadata::get(UndefValue::get(getValue()->getType()),
+                                         /*IsEntryValue*/ true)));
+}
+
 int llvm::Intrinsic::lookupLLVMIntrinsicByName(ArrayRef<const char *> NameTable,
                                                StringRef Name) {
   assert(Name.startswith("llvm."));
 
   // Do successive binary searches of the dotted name components. For
   // "llvm.gc.experimental.statepoint.p1i8.p1i32", we will find the range of
   // intrinsics starting with "llvm.gc", then "llvm.gc.experimental", then
   // "llvm.gc.experimental.statepoint", and then we will stop as the range is

llvm/lib/IR/LLVMContextImpl.h

public:
   FPMapTy FPConstants;
 
   FoldingSet<AttributeImpl> AttrsSet;
   FoldingSet<AttributeListImpl> AttrsLists;
   FoldingSet<AttributeSetNode> AttrsSetNodes;
 
   StringMap<MDString, BumpPtrAllocator> MDStringCache;
   DenseMap<Value *, ValueAsMetadata *> ValuesAsMetadata;
+  DenseMap<Value *, ValueAsMetadata *> EntryValuesAsMetadata;
   DenseMap<Metadata *, MetadataAsValue *> MetadataAsValues;
 
   DenseMap<const Value*, ValueName*> ValueNames;
 
 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
   DenseSet<CLASS *, CLASS##Info> CLASS##s;
 #include "llvm/IR/Metadata.def"
 

llvm/lib/IR/LLVMContextImpl.cpp

 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
   for (auto *I : CLASS##s)                                                     \
     I->dropAllReferences();
 #include "llvm/IR/Metadata.def"
 
   // Also drop references that come from the Value bridges.
   for (auto &Pair : ValuesAsMetadata)
     Pair.second->dropUsers();
+  for (auto &Pair : EntryValuesAsMetadata)
+    Pair.second->dropUsers();
   for (auto &Pair : MetadataAsValues)
     Pair.second->dropUse();
 
   // Destroy MDNodes.
   for (MDNode *I : DistinctMDNodes)
     I->deleteAsSubclass();
 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
   for (CLASS * I : CLASS##s)                                                   \
// Destroy MetadataAsValues.
     MetadataAsValues.clear();
     for (auto *V : MDVs)
       delete V;
   }
 
   // Destroy ValuesAsMetadata.
   for (auto &Pair : ValuesAsMetadata)
     delete Pair.second;
+  // Destroy EntryValuesAsMetadata.
+  for (auto &Pair : EntryValuesAsMetadata)
+    delete Pair.second;
 }
 
 void LLVMContextImpl::dropTriviallyDeadConstantArrays() {
   SmallSetVector<ConstantArray *, 4> WorkList;
 
   // When ArrayConstants are of substantial size and only a few in them are
   // dead, starting WorkList with all elements of ArrayConstants can be
   // wasteful. Instead, starting WorkList with only elements that have empty

llvm/lib/IR/Metadata.cpp

if (BasicBlock *BB = cast<Instruction>(V)->getParent()) {
     if (auto *Fn = BB->getParent())
       return Fn->getSubprogram();
     return nullptr;
   }
 
   return nullptr;
 }
 
-ValueAsMetadata *ValueAsMetadata::get(Value *V) {
+ValueAsMetadata *ValueAsMetadata::get(Value *V, bool IsEntryValue) {
   assert(V && "Unexpected null Value");
 
   auto &Context = V->getContext();
-  auto *&Entry = Context.pImpl->ValuesAsMetadata[V];
+  auto *&Entry = (IsEntryValue) ? Context.pImpl->EntryValuesAsMetadata[V]
+                                : Context.pImpl->ValuesAsMetadata[V];
   if (!Entry) {
     assert((isa<Constant>(V) || isa<Argument>(V) || isa<Instruction>(V)) &&
            "Expected constant or function-local value");
-    assert(!V->IsUsedByMD && "Expected this to be the only metadata use");
-    V->IsUsedByMD = true;
-    if (auto *C = dyn_cast<Constant>(V))
+
+    // Update Value's IsUsedByMD field.
+    if (IsEntryValue) {
+      assert((V->IsUsedByMD & Value::UsedByEV) == 0 &&
+             "Expected this to be a metadata use in Entry Value only");
+      V->IsUsedByMD |= Value::UsedByEV;
+    } else {
+      assert((V->IsUsedByMD & Value::UsedBySSA) == 0 &&
+             "Expected this to be a metadata use in SSA value only");
+      V->IsUsedByMD |= Value::UsedBySSA;
+    }
+
+    if (IsEntryValue)
+      Entry = new EntryValueAsMetadata(V);
+    else if (auto *C = dyn_cast<Constant>(V))
       Entry = new ConstantAsMetadata(C);
     else
       Entry = new LocalAsMetadata(V);
   }
 
   return Entry;
 }
 
 ValueAsMetadata *ValueAsMetadata::getIfExists(Value *V) {
   assert(V && "Unexpected null Value");
   return V->getContext().pImpl->ValuesAsMetadata.lookup(V);
 }
 
 void ValueAsMetadata::handleDeletion(Value *V) {
   assert(V && "Expected valid value");
 
+  auto &EntryValues = V->getType()->getContext().pImpl->EntryValuesAsMetadata;
+  auto EV = EntryValues.find(V);
+  if (EV != EntryValues.end()) {
+    // Remove old entry from the map.
+    ValueAsMetadata *MD = EV->second;
+    assert(MD && "Expected valid metadata");
+    assert(MD->getValue() == V && "Expected valid mapping");
+    EntryValues.erase(EV);
+
+    // Delete the metadata.
+    MD->replaceAllUsesWith(nullptr);
+    delete MD;
+  }
+
   auto &Store = V->getType()->getContext().pImpl->ValuesAsMetadata;
   auto I = Store.find(V);
   if (I == Store.end())
     return;
 
   // Remove old entry from the map.
   ValueAsMetadata *MD = I->second;
   assert(MD && "Expected valid metadata");
   assert(MD->getValue() == V && "Expected valid mapping");
   Store.erase(I);
 
   // Delete the metadata.
   MD->replaceAllUsesWith(nullptr);
   delete MD;
 }
 
 void ValueAsMetadata::handleRAUW(Value *From, Value *To) {
   assert(From && "Expected valid value");
   assert(To && "Expected valid value");
   assert(From != To && "Expected changed value");
   assert(From->getType() == To->getType() && "Unexpected type change");
 
+  // If there was an Entry Value represented by From, update the
+  // Entry Value to undef.
   LLVMContext &Context = From->getType()->getContext();
+  auto &EntryValues = Context.pImpl->EntryValuesAsMetadata;
+  auto EV = EntryValues.find(From);
+  bool IsEntryValue = (EV != EntryValues.end());
+  if (IsEntryValue) {
+    ValueAsMetadata *EntryValueMD = EV->second;
+    assert(EntryValueMD && "Expected valid metadata from EntryValue");
+    assert(EntryValueMD->getValue() == From &&
+           "Expected valid mapping from EntryValue");
+    assert(isa<EntryValueAsMetadata>(EntryValueMD) &&
+           "Expected EntryValueAsMetadata type from EntryValue");
+    EntryValues.erase(EV);
+
+    Value *Undef = UndefValue::get(To->getType());
+    auto *&UndefEntry = EntryValues[Undef];
+    if (!UndefEntry) {
+      EntryValues.insert(std::make_pair(
+          Undef, ValueAsMetadata::get(UndefValue::get(From->getType()),
+                                      /*IsEntryValue*/ true)));
+      UndefEntry = EntryValues[Undef];
+    }
+
+    // Update Value's IsUsedByMD field.
+    assert((From->IsUsedByMD & Value::UsedByEV) &&
+           "Expected this to be used by metadata in Entry Value");
+    From->IsUsedByMD &= ~Value::UsedByEV;
+
+    EntryValueMD->replaceAllUsesWith(UndefEntry);
+    delete EntryValueMD;
+  }
+
+  // Handle regular SSA Value as metadata.
   auto &Store = Context.pImpl->ValuesAsMetadata;
   auto I = Store.find(From);
+
   if (I == Store.end()) {
-    assert(!From->IsUsedByMD && "Expected From not to be used by metadata");
+    assert((From->IsUsedByMD & Value::UsedBySSA) == 0 &&
+           "Expected From not to be used by metadata in SSA value");
     return;
   }
 
-  // Remove old entry from the map.
-  assert(From->IsUsedByMD && "Expected From to be used by metadata");
-  From->IsUsedByMD = false;
+  // Update Value's IsUsedByMD field.
+  assert((From->IsUsedByMD & Value::UsedBySSA) &&
+         "Expected From to be used by metadata in SSA value");
+  From->IsUsedByMD &= ~Value::UsedBySSA;
+
   ValueAsMetadata *MD = I->second;
   assert(MD && "Expected valid metadata");
   assert(MD->getValue() == From && "Expected valid mapping");
   Store.erase(I);
 
   if (isa<LocalAsMetadata>(MD)) {
     if (auto *C = dyn_cast<Constant>(To)) {
       // Local became a constant.
void ValueAsMetadata::handleRAUW(Value *From, Value *To) {
   if (Entry) {
     // The target already exists.
     MD->replaceAllUsesWith(Entry);
     delete MD;
     return;
   }
 
   // Update MD in place (and update the map entry).
-  assert(!To->IsUsedByMD && "Expected this to be the only metadata use");
-  To->IsUsedByMD = true;
+  // Update Value's IsUsedByMD field.
+  assert((To->IsUsedByMD & Value::UsedBySSA) == 0 &&
+         "Expected this to be the only metadata use in SSA value");
+  To->IsUsedByMD |= Value::UsedBySSA;
   MD->V = To;
   Entry = MD;
 }
 
 //===----------------------------------------------------------------------===//
 // MDString implementation.
 //
 

llvm/lib/IR/Value.cpp

 static inline Type *checkType(Type *Ty) {
   assert(Ty && "Value defined with a null type: Error!");
   return Ty;
 }
 
 Value::Value(Type *ty, unsigned scid)
     : VTy(checkType(ty)), UseList(nullptr), SubclassID(scid),
       HasValueHandle(0), SubclassOptionalData(0), SubclassData(0),
-      NumUserOperands(0), IsUsedByMD(false), HasName(false) {
+      NumUserOperands(0), IsUsedByMD(NotUsedByMD), HasName(false) {
   static_assert(ConstantFirstVal == 0, "!(SubclassID < ConstantFirstVal)");
   // FIXME: Why isn't this in the subclass gunk??
   // Note, we cannot call isa<CallInst> before the CallInst has been
   // constructed.
   if (SubclassID == Instruction::Call || SubclassID == Instruction::Invoke ||
       SubclassID == Instruction::CallBr)
     assert((VTy->isFirstClassType() || VTy->isVoidTy() || VTy->isStructTy()) &&
            "invalid CallInst type!");

llvm/lib/IR/Verifier.cpp

void Verifier::verifyFnArgs(const DbgVariableIntrinsic &I) {
   // These will cause hard-to-debug assertions in the DWARF backend.
   if (DebugFnArgs.size() < ArgNo)
     DebugFnArgs.resize(ArgNo, nullptr);
 
   auto *Prev = DebugFnArgs[ArgNo - 1];
   DebugFnArgs[ArgNo - 1] = Var;
   AssertDI(!Prev || (Prev == Var), "conflicting debug info for argument", &I,
            Prev, Var);
+
+  if (!isa<DbgValueInst>(&I))
+    return;
+
+  // Validate the entry value argument.
+  const DbgValueInst &DVI = cast<DbgValueInst>(I);
+
+  Value* EntryValue = DVI.getVariableEntryValue();
+  AssertDI(EntryValue, "dbg_value with null entry-value (should be undef)");
+  AssertDI(isa<Argument>(EntryValue) || isa<UndefValue>(EntryValue),
+           "dbg_value with non-argument entry-value");
 }
 
 void Verifier::verifyNotEntryValue(const DbgVariableIntrinsic &I) {
   DIExpression *E = dyn_cast_or_null<DIExpression>(I.getRawExpression());
 
   // We don't know whether this intrinsic verified correctly.
   if (!E || !E->isValid())
     return;

llvm/lib/Transforms/Utils/InlineFunction.cpp

if (NoInlineLineTables) {
         }
         ++BI;
       }
     }
 
   }
 }
 
+/// We can't rely on the entry values for inlined functions, so we set it
+/// to undef.
+static void invalidateEntryValues(Function *Fn, Function::iterator FI,
+                                  Instruction *TheCall) {
+  for (; FI != Fn->end(); ++FI)
+    for (BasicBlock::iterator BI = FI->begin(), BE = FI->end();
+         BI != BE; ++BI) {
+      DbgValueInst *DVI = dyn_cast<DbgValueInst>(&(*BI));
+      if (!DVI)
+        continue;
+
+      auto UndefVal =
+        dyn_cast_or_null<UndefValue>(DVI->getVariableEntryValue());
+
+      if (UndefVal)
+        continue;
+
+      DVI->setEntryValueToUndef();
+    }
+}
+
 /// Update the block frequencies of the caller after a callee has been inlined.
 ///
 /// Each block cloned into the caller has its block frequency scaled by the
 /// ratio of CallSiteFreq/CalleeEntryFreq. This ensures that the cloned copy of
 /// callee's entry block gets the same frequency as the callsite block and the
 /// relative frequencies of all cloned blocks remain the same after cloning.
 static void updateCallerBFI(BasicBlock *CallSiteBlock,
                             const ValueToValueMapTy &VMap,
if (IFI.CG)
       UpdateCallGraphAfterInlining(CB, FirstNewBlock, VMap, IFI);
 
     // For 'nodebug' functions, the associated DISubprogram is always null.
     // Conservatively avoid propagating the callsite debug location to
     // instructions inlined from a function whose DISubprogram is not null.
     fixupLineNumbers(Caller, FirstNewBlock, &CB,
                      CalledFunc->getSubprogram() != nullptr);
 
+    if (CalledFunc->getSubprogram() != nullptr)
+      invalidateEntryValues(Caller, FirstNewBlock, &CB);
+
     // Clone existing noalias metadata if necessary.
     CloneAliasScopeMetadata(CB, VMap);
 
     // Add noalias metadata if necessary.
     AddAliasScopeMetadata(CB, VMap, DL, CalleeAAR);
 
     // Clone return attributes on the callsite into the calls within the inlined
     // function which feed into its return value.

llvm/lib/Transforms/Utils/Local.cpp

if (!valueCoversEntireFragment(DV->getType(), DII)) {
     // For now, when there is a store to parts of the variable (but we do not
     // know which part) we insert an dbg.value instrinsic to indicate that we
     // know nothing about the variable's content.
     DV = UndefValue::get(DV->getType());
     Builder.insertDbgValueIntrinsic(DV, DIVar, DIExpr, NewLoc, SI);
     return;
   }
 
-  Builder.insertDbgValueIntrinsic(DV, DIVar, DIExpr, NewLoc, SI);
+  // If this value can be expressed in terms of an entry value, remember it and
+  // keep using it as a backup value for the variable.
+  auto EntryValue = findEntryValue(DV, *(DII->getParent()->getParent()));
+  Value *EV = nullptr;
+  DIExpression *EVExpr = nullptr;
+  if (EntryValue) {
+    EV = EntryValue->V;
+    EVExpr = EntryValue->Expr;
+  }
+
+  Builder.insertDbgValueIntrinsic(DV, DIVar, DIExpr, NewLoc, SI, EV, EVExpr);
 }
 
 /// Inserts a llvm.dbg.value intrinsic before a load of an alloca'd value
 /// that has an associated llvm.dbg.declare or llvm.dbg.addr intrinsic.
 void llvm::ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII,
                                            LoadInst *LI, DIBuilder &Builder) {
   auto *DIVar = DII->getVariable();
   auto *DIExpr = DII->getExpression();

 
 TinyPtrVector<DbgDeclareInst *> llvm::FindDbgDeclareUses(Value *V) {
   TinyPtrVector<DbgDeclareInst *> DDIs;
   for (DbgVariableIntrinsic *DVI : FindDbgAddrUses(V))
     if (auto *DDI = dyn_cast<DbgDeclareInst>(DVI))
       DDIs.push_back(DDI);
   return DDIs;
 }
 
+Optional<EntryValue> llvm::findEntryValue(Value *V, Function &F) {
+  if (F.empty())
+    return None;
+
+  // TODO: Support types other than integer.
+  if (!V->getType()->isIntegerTy() || V->getType()->isPointerTy())
+    return None;
+  if (isa<ConstantInt>(V) || isa<ConstantPointerNull>(V))
+    return None;
+
+  DIExpression *DIExpr = DIExpression::get(F.getContext(), {});
+  // If the value is an entry itself.
+  if (isa<Argument>(V))
+    return EntryValue{V, DIExpr};
+
+  if (!isa<Instruction>(V))
+    return None;
+
+  Instruction *I = cast<Instruction>(V);
+
+  // Support binary operators only for now.
+  if (!isa<BinaryOperator>(V))
+    return None;
+
+  // TODO: Cover cases where an entry value is implicitly used. We need to call
+  // the salvageDebugInfoImpl() multiple times, until we find the entry value.
+
+  auto Op0 = I->getOperand(0);
+  // Not an entry value.
+  if (!isa<Argument>(Op0))
+    return None;
+
+  // Try to express the entry value in terms of DWARF.
+  DIExpr = salvageDebugInfoImpl(*I, DIExpr, true);
+  if (!DIExpr)
+    return None;
+
+  return EntryValue{Op0, DIExpr};
+}
+
 void llvm::findDbgValues(SmallVectorImpl<DbgValueInst *> &DbgValues, Value *V) {
   // This function is hot. Check whether the value has any metadata to avoid a
   // DenseMap lookup.
   if (!V->isUsedByMetadata())
     return;
   if (auto *L = LocalAsMetadata::getIfExists(V))
     if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L))
       for (User *U : MDV->users())
         if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(U))

llvm/lib/Transforms/Utils/ValueMapper.cpp

if (auto *LAM = dyn_cast<LocalAsMetadata>(MD)) {
       // FIXME: always return nullptr once Verifier::verifyDominatesUse()
       // ensures metadata operands only reference defined SSA values.
       return (Flags & RF_IgnoreMissingLocals)
                  ? nullptr
                  : MetadataAsValue::get(V->getContext(),
                                         MDTuple::get(V->getContext(), None));
     }
 
+    if (auto *EVM = dyn_cast<EntryValueAsMetadata>(MD)) {
+      if (Value *EV = mapValue(EVM->getValue())) {
+        if (V == EVM->getValue())
+          return const_cast<Value *>(V);
+        return MetadataAsValue::get(V->getContext(),
+                                    ValueAsMetadata::get(EV, true));
+      } else {
+        return MetadataAsValue::get(V->getContext(),
+                                    ValueAsMetadata::get(UndefValue::get(V->getType()),
+                                                         /*IsEntryValue*/ true));
+      }
+    }
+
     // If this is a module-level metadata and we know that nothing at the module
     // level is changing, then use an identity mapping.
     if (Flags & RF_NoModuleLevelChanges)
       return getVM()[V] = const_cast<Value *>(V);
 
     // Map the metadata and turn it into a value.
     auto *MappedMD = mapMetadata(MD);
     if (MD == MappedMD)
Optional<Metadata *> Mapper::mapSimpleMetadata(const Metadata *MD) {
   assert(isa<MDNode>(MD) && "Expected a metadata node");
 
   return None;
 }
 
 Metadata *Mapper::mapMetadata(const Metadata *MD) {
   assert(MD && "Expected valid metadata");
   assert(!isa<LocalAsMetadata>(MD) && "Unexpected local metadata");
+  assert(!isa<EntryValueAsMetadata>(MD) && "Unexpected entry-value metadata");
 
   if (Optional<Metadata *> NewMD = mapSimpleMetadata(MD))
     return *NewMD;
 
   return MDNodeMapper(*this).map(*cast<MDNode>(MD));
 }
 
 void Mapper::flush() {

llvm/test/Bindings/llvm-c/debug_info.ll

 ; RUN: llvm-c-test --test-dibuilder | FileCheck %s
 
 ; CHECK: ; ModuleID = 'debuginfo.c'
 ; CHECK-NEXT: source_filename = "debuginfo.c"
 
 ; CHECK:      define i64 @foo(i64 %0, i64 %1, <10 x i64> %2) !dbg !31 {
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT:   call void @llvm.dbg.declare(metadata i64 0, metadata !38, metadata !DIExpression()), !dbg !43
 ; CHECK-NEXT:   call void @llvm.dbg.declare(metadata i64 0, metadata !39, metadata !DIExpression()), !dbg !43
 ; CHECK-NEXT:   call void @llvm.dbg.declare(metadata i64 0, metadata !40, metadata !DIExpression()), !dbg !43
 ; CHECK:      vars:                                             ; No predecessors!
-; CHECK-NEXT:   call void @llvm.dbg.value(metadata i64 0, metadata !41, metadata !DIExpression(DW_OP_constu, 0, DW_OP_stack_value)), !dbg !44
+; CHECK-NEXT:   call void @llvm.dbg.value(metadata i64 0, metadata !41, metadata !DIExpression(DW_OP_constu, 0, DW_OP_stack_value), metadata i64 undef, metadata !DIExpression()), !dbg !44
 ; CHECK-NEXT: }
 
 ; CHECK:      ; Function Attrs: nounwind readnone speculatable
 ; CHECK-NEXT: declare void @llvm.dbg.declare(metadata, metadata, metadata) #0
 
 ; CHECK:      ; Function Attrs: nounwind readnone speculatable
-; CHECK-NEXT: declare void @llvm.dbg.value(metadata, metadata, metadata) #0
+; CHECK-NEXT: declare void @llvm.dbg.value(metadata, metadata, metadata, metadata, metadata) #0
 
 ; CHECK:      attributes #0 = { nounwind readnone speculatable willreturn }
 
 ; CHECK:      !llvm.dbg.cu = !{!0}
 ; CHECK-NEXT: !FooType = !{!28}
 ; CHECK-NEXT: !EnumTest = !{!3}
 
 ; CHECK:      !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "llvm-c-test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !11, imports: !19, macros: !23, splitDebugInlining: false, sysroot: "/")

llvm/test/Bitcode/upgrade-dbg-value.ll

 ; Test upgrade of dbg.dvalue intrinsics with offsets.
 ;
 ; RUN: llvm-dis < %s.bc | FileCheck %s
 ; RUN: verify-uselistorder < %s.bc
 
 define void @f() !dbg !3 {
 entry:
   ; CHECK-NOT: call void @llvm.dbg.value
-  ; CHECK: call void @llvm.dbg.value(metadata i32 42, metadata !8, metadata !DIExpression())
+  ; CHECK: call void @llvm.dbg.value(metadata i32 42, metadata !8, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression())
   call void @llvm.dbg.value(metadata i32 42, i64 0, metadata !8, metadata !9), !dbg !10
   ; CHECK-NOT: call void @llvm.dbg.value
   call void @llvm.dbg.value(metadata i32 0, i64 1, metadata !8, metadata !9), !dbg !10
   ret void
 }
 
-; CHECK: declare void @llvm.dbg.value(metadata, metadata, metadata)
+; CHECK: declare void @llvm.dbg.value(metadata, metadata, metadata, metadata, metadata)
 declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!2}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "llc r309174", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)
 !1 = !DIFile(filename: "a.c", directory: "/")
 !2 = !{i32 1, !"Debug Info Version", i32 3}
 !3 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 1, type: !4, isLocal: false, isDefinition: true, isOptimized: false, unit: !0, retainedNodes: !7)
 !4 = !DISubroutineType(types: !5)
 !5 = !{!6}
 !6 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !7 = !{!8}
 !8 = !DILocalVariable(name: "i", scope: !3, file: !1, line: 2, type: !6)
 !9 = !DIExpression()
 !10 = !DILocation(line: 2, scope: !3)

llvm/test/CodeGen/Generic/MIRDebugify/locations-and-values.mir

 # RUN: llc -run-pass=mir-debugify -o - %s | FileCheck --check-prefixes=ALL,VALUE %s
 # RUN: llc -run-pass=mir-debugify -debugify-level=locations -o - %s | FileCheck --check-prefixes=ALL --implicit-check-not=dbg.value %s
 # RUN: llc -run-pass=mir-debugify,mir-strip-debug,mir-debugify -o - %s | FileCheck --check-prefixes=ALL,VALUE %s
 --- |
   ; ModuleID = 'loc-only.ll'
   source_filename = "loc-only.ll"
   
   ; ALL-LABEL: @test
   define i32 @test(i32 %a, i32 %b) {
     %add = add i32 %a, 2
   ; ALL-NEXT:  %add = add i32 %a, 2, !dbg [[L1:![0-9]+]]
-  ; VALUE-NEXT: call void @llvm.dbg.value(metadata i32 %add, metadata [[add:![0-9]+]], metadata !DIExpression()), !dbg [[L1]]
+  ; VALUE-NEXT: call void @llvm.dbg.value(metadata i32 %add, metadata [[add:![0-9]+]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg [[L1]]
     %sub = sub i32 %add, %b
   ; ALL-NEXT: %sub = sub i32 %add, %b, !dbg [[L2:![0-9]+]]
-  ; VALUE-NEXT: call void @llvm.dbg.value(metadata i32 %sub, metadata [[sub:![0-9]+]], metadata !DIExpression()), !dbg [[L2]]
+  ; VALUE-NEXT: call void @llvm.dbg.value(metadata i32 %sub, metadata [[sub:![0-9]+]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg [[L2]]
   ; ALL-NEXT: ret i32 %sub, !dbg [[L3:![0-9]+]]
     ret i32 %sub
   }
 
   ; ALL: !llvm.dbg.cu = !{!0}
   ; ALL: !llvm.debugify =
   ; ALL: !llvm.module.flags = !{![[VERSION:[0-9]+]]}
   ; ALL: !0 = distinct !DICompileUnit(

llvm/test/CodeGen/Generic/MIRStripDebug/dont-strip-real-debug-info.mir

 # RUN: llc -run-pass=mir-strip-debug -o - %s | FileCheck %s
 # RUN: llc -run-pass=mir-strip-debug,mir-debugify,mir-strip-debug -o - %s | FileCheck %s
 --- |
   ; ModuleID = 'loc-only.ll'
   source_filename = "loc-only.ll"
   
   define i32 @test(i32 %a, i32 %b) !dbg !4 {
     %add = add i32 %a, 2, !dbg !10
     call void @llvm.dbg.value(metadata i32 %add, metadata !7, metadata !DIExpression()), !dbg !10
     %sub = sub i32 %add, %b, !dbg !11
     call void @llvm.dbg.value(metadata i32 %sub, metadata !9, metadata !DIExpression()), !dbg !11
     ret i32 %sub, !dbg !12
   }
   ; CHECK-LABEL: define i32 @test(i32 %a, i32 %b) !dbg !4 {
   ; CHECK-NEXT:    %add = add i32 %a, 2, !dbg !10
-  ; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 %add, metadata !7, metadata !DIExpression()), !dbg !10
+  ; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 %add, metadata !7, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !10
   ; CHECK-NEXT:    %sub = sub i32 %add, %b, !dbg !11
-  ; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 %sub, metadata !9, metadata !DIExpression()), !dbg !11
+  ; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 %sub, metadata !9, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !11
   ; CHECK-NEXT:    ret i32 %sub, !dbg !12
   ; CHECK-NEXT:  }
   
   ; Function Attrs: nounwind readnone speculatable willreturn
   declare void @llvm.dbg.value(metadata, metadata, metadata) #0
   
   ; Function Attrs: nounwind
   declare void @llvm.stackprotector(i8*, i8**) #1

llvm/test/CodeGen/X86/pr38763.ll

 
 ; CHECK-LABEL: entry
 ; CHECK:  %cmp = icmp eq i32 %foo.0., 4, !dbg !14
 ; CHECK:  %add = add nsw i32 %foo.0.4, 2, !dbg !16
 ; CHECK-NOT: @llvm.dbg.value(metadata i32 %add
 ; CHECK:  %sub = add nsw i32 %foo.0.4, -2, !dbg !16
 ; CHECK-NOT: @llvm.dbg.value(metadata i32 %sub
 ; CHECK:  %result.0 = select i1 %cmp, i32 %add, i32 %sub
-; CHECK:  call void @llvm.dbg.value(metadata i32 %result.0, metadata !12, metadata !DIExpression()), !dbg !13
+; CHECK:  call void @llvm.dbg.value(metadata i32 %result.0, metadata !12, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !13
 
 ; ModuleID = 'pr38763.cpp'
 source_filename = "pr38763.cpp"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 
 ; Function Attrs: norecurse nounwind uwtable
 define dso_local i32 @main() local_unnamed_addr #0 !dbg !7 {

llvm/test/DebugInfo/ARM/salvage-debug-info.ll

 entry:
   %0 = load i32, i32* @p, align 4, !dbg !25
   %tobool = icmp eq i32 %0, 0, !dbg !25
   br i1 %tobool, label %if.end, label %if.then, !dbg !26
 
 if.then:                                          ; preds = %entry
   %1 = inttoptr i32 %0 to %struct.info*, !dbg !27
   tail call void @llvm.dbg.value(metadata %struct.info* %1, metadata !22, metadata !DIExpression()), !dbg !28
-  ; CHECK: call void @llvm.dbg.value(metadata i32 %0, metadata !22, metadata !DIExpression())
+  ; CHECK: call void @llvm.dbg.value(metadata i32 %0, metadata !22, metadata !DIExpression(), metadata %struct.info* undef, metadata !DIExpression())
   tail call void @llvm.dbg.value(metadata i32 0, metadata !20, metadata !DIExpression()), !dbg !29
   %2 = load i32, i32* @n, align 4, !dbg !30
   %cmp5 = icmp eq i32 %2, 0, !dbg !33
   br i1 %cmp5, label %if.end, label %for.body.preheader, !dbg !34
 
 for.body.preheader:                               ; preds = %if.then
   ; CHECK: for.body.preheader:
   ; CHECK:   %2 = inttoptr i32 %0 to %struct.info*

llvm/test/DebugInfo/ARM/sroa-complex.ll

entry:
   %c.realp = getelementptr inbounds { double, double }, { double, double }* %c, i32 0, i32 0, !dbg !17
   %c.imagp = getelementptr inbounds { double, double }, { double, double }* %c, i32 0, i32 1, !dbg !17
   store double 0.000000e+00, double* %c.realp, align 8, !dbg !17
   ; SROA will split the complex double into two i64 values, because there is
   ; no native double data type available.
   ; Test that debug info for both values survives:
   ; CHECK: call void @llvm.dbg.value(metadata i64 0,
   ; CHECK-SAME:                      metadata ![[C:[^,]*]],
-  ; CHECK-SAME:                      metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64))
+  ; CHECK-SAME:                      metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64)
   store double 0.000000e+00, double* %c.imagp, align 8, !dbg !17
   ; CHECK: call void @llvm.dbg.value(metadata i64 0,
   ; CHECK-SAME:                      metadata ![[C]],
-  ; CHECK-SAME:                      metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64))
+  ; CHECK-SAME:                      metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)
   ret void, !dbg !18
 }
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
 
 attributes #0 = { nounwind }
 attributes #1 = { nounwind readnone }

llvm/test/DebugInfo/Generic/dbg-value-lower-linenos.ll

 ; In the following, the dbg.value created for the store should get the stores
 ; line number, the other dbg.values should be unknown.
 ; CHECK-LABEL: define void @bar
 ;
 ; CHECK:      dbg.value(metadata i32 %map, metadata ![[MAPVAR:[0-9]+]],{{.*}}),
 ; CHECK-SAME:           !dbg ![[UNKNOWN2:[0-9]+]]
 ; CHECK-NEXT: store
 ; CHECK-NEXT: dbg.value(metadata i32* %map.addr, metadata ![[MAPVAR]],
-; CHECK-SAME:           metadata !DIExpression(DW_OP_deref)),
+; CHECK-SAME:           metadata !DIExpression(DW_OP_deref), {{.*}}),
 ; CHECK-SAME:           !dbg ![[UNKNOWN2]]
 ; CHECK-NEXT: call
 ; CHECK-NEXT: load
 ; CHECK-NEXT: dbg.value(metadata i32 %{{[0-9]+}}, metadata ![[MAPVAR]],
 ; CHECK-SAME:           !dbg ![[UNKNOWN2]]
 
 define void @bar(i32 %map) !dbg !20 {
 entry:

llvm/test/DebugInfo/Generic/sroa-larger.ll

 
 define void @"\01?fn3@@YAXXZ"() local_unnamed_addr !dbg !6 {
 entry:
   %tmp = alloca %struct.F, align 8
   %0 = bitcast %struct.F* %tmp to i8*
   call void @llvm.lifetime.start.p0i8(i64 16, i8* %0)
   call void @llvm.dbg.declare(metadata %struct.F* %tmp, metadata !10, metadata !DIExpression()), !dbg !14
   ; CHECK-NOT: !DIExpression(DW_OP_LLVM_fragment, 32, 96)
-  ; CHECK: call void @llvm.dbg.value(metadata i32 0, metadata !10, metadata !DIExpression())
+  ; CHECK: call void @llvm.dbg.value(metadata i32 0, metadata !10, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression())
   %_Myval2.i.i.i.i.i = bitcast %struct.F* %tmp to i32*
   store i32 0, i32* %_Myval2.i.i.i.i.i, align 8
   ret void
 }
 
 ; Function Attrs: argmemonly nounwind
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
 

llvm/test/DebugInfo/Generic/sroa-samesize.ll

 
 define void @"\01?x9@@YAXXZ"() local_unnamed_addr !dbg !8 {
 entry:
   %agg.tmp.ensured = alloca %struct.B, align 8
   call void @llvm.dbg.declare(metadata %struct.B* %agg.tmp.ensured, metadata !11, metadata !DIExpression()), !dbg !24
   %call.i.i = call i32 @"\01?x4@@YAHXZ"(), !dbg !46, !noalias !47
   %x3.i.i.i = bitcast %struct.B* %agg.tmp.ensured to i32*, !dbg !50
   store i32 0, i32* %x3.i.i.i, align 4, !dbg !50, !tbaa !57, !alias.scope !47
-  ; CHECK: call void @llvm.dbg.value(metadata i32 0, metadata ![[A:.*]], metadata !DIExpression())
+  ; CHECK: call void @llvm.dbg.value(metadata i32 0, metadata ![[A:.*]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression())
   ; CHECK: ![[A]] = !DILocalVariable(name: "a",
   ret void, !dbg !62
 }
 
 ; Function Attrs: nounwind readnone speculatable
 declare void @llvm.dbg.value(metadata, metadata, metadata) #0
 
 attributes #0 = { nounwind readnone speculatable }

llvm/test/DebugInfo/X86/array2.ll

 ;   f(array);
 ;   return array[0];
 ; }
 ;
 ; RUN: opt %s -O2 -S -o - | FileCheck %s
 ; Test that we correctly lower dbg.declares for arrays.
 ;
 ; CHECK: define i32 @main
-; CHECK: call void @llvm.dbg.value(metadata i32 42, metadata ![[ARRAY:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32))
+; CHECK: call void @llvm.dbg.value(metadata i32 42, metadata ![[ARRAY:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32), metadata i32 undef, metadata !DIExpression())
 ; CHECK: ![[ARRAY]] = !DILocalVariable(name: "array",{{.*}} line: 6
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 
 @main.array = private unnamed_addr constant [4 x i32] [i32 0, i32 1, i32 2, i32 3], align 16
 
 ; Function Attrs: nounwind ssp uwtable
 define void @f(i32* %p) #0 !dbg !4 {

llvm/test/DebugInfo/X86/dbg-value-dropped-instcombine.ll

 ; struct bees foo(struct bees bumble)
 ; {
 ;   global = 1;
 ;   int temp = bumble.a + bumble.b;
 ;   return bumble;
 ; }
 
 ; CHECK: define dso_local i64 @foo
-; CHECK: @llvm.dbg.value(metadata i64 {{.*}}, metadata ![[BEE:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)),
-; CHECK: @llvm.dbg.value(metadata i64 {{.*}}, metadata ![[BEE]], metadata !DIExpression({{.*}}, DW_OP_LLVM_fragment, 32, 32)),
+; CHECK: @llvm.dbg.value(metadata i64 {{.*}}, metadata ![[BEE:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)
+; CHECK: @llvm.dbg.value(metadata i64 {{.*}}, metadata ![[BEE]], metadata !DIExpression({{.*}}, DW_OP_LLVM_fragment, 32, 32)
 
 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-unknown"
 
 @global = dso_local local_unnamed_addr global i32 0, align 4, !dbg !0
 
 define dso_local i64 @foo(i64 %bumble.coerce) local_unnamed_addr !dbg !11 {
 entry:

llvm/test/DebugInfo/X86/entry-values-after-sroa.ll

+; RUN: opt %s -sroa -instcombine -inline -instcombine -sroa -verify -S -o - | FileCheck %s
+
+;; C reproducer:
+;; void foo(int param) {
+;;   int i = param + 3;
+;;   int j = i + 6;
+;; }
+;; (clang -g -O2 -S -emit-llvm test.c -mllvm -disable-llvm-optzns)
+
+;; TODO: Express the value of "j" in terms of entry value.
+
+; CHECK: call void @llvm.dbg.value(metadata i32 %param, metadata !12, metadata !DIExpression(), metadata i32 %param, metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata i32 %param, metadata !13, metadata !DIExpression(DW_OP_plus_uconst, 3, DW_OP_stack_value), metadata i32 %param, metadata !DIExpression(DW_OP_plus_uconst, 3, DW_OP_stack_value))
+; CHECK: call void @llvm.dbg.value(metadata i32 %param, metadata !14, metadata !DIExpression(DW_OP_plus_uconst, 3, DW_OP_plus_uconst, 6, DW_OP_stack_value), metadata i32 undef, metadata !DIExpression())
+
+; ModuleID = '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: nounwind uwtable
+define dso_local void @foo(i32 %param) !dbg !7 {
+entry:
+  %param.addr = alloca i32, align 4
+  %i = alloca i32, align 4
+  %j = alloca i32, align 4
+  store i32 %param, i32* %param.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %param.addr, metadata !12, metadata !DIExpression()), !dbg !19
+  %0 = bitcast i32* %i to i8*, !dbg !20
+  call void @llvm.dbg.declare(metadata i32* %i, metadata !13, metadata !DIExpression()), !dbg !21
+  %1 = load i32, i32* %param.addr, align 4, !dbg !22
+  %add = add nsw i32 %1, 3, !dbg !23
+  store i32 %add, i32* %i, align 4, !dbg !21
+  %2 = bitcast i32* %j to i8*, !dbg !24
+  call void @llvm.dbg.declare(metadata i32* %j, metadata !14, metadata !DIExpression()), !dbg !25
+  %3 = load i32, i32* %i, align 4, !dbg !26
+  %add1 = add nsw i32 %3, 6, !dbg !27
+  store i32 %add1, i32* %j, align 4, !dbg !25
+  %4 = bitcast i32* %j to i8*, !dbg !28
+  %5 = bitcast i32* %i to i8*, !dbg !28
+  ret void, !dbg !28
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0"}
+!7 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!12, !13, !14}
+!12 = !DILocalVariable(name: "param", arg: 1, scope: !7, file: !1, line: 1, type: !10)
+!13 = !DILocalVariable(name: "i", scope: !7, file: !1, line: 2, type: !10)
+!14 = !DILocalVariable(name: "j", scope: !7, file: !1, line: 3, type: !10)
+!19 = !DILocation(line: 1, column: 14, scope: !7)
+!20 = !DILocation(line: 2, column: 3, scope: !7)
+!21 = !DILocation(line: 2, column: 7, scope: !7)
+!22 = !DILocation(line: 2, column: 11, scope: !7)
+!23 = !DILocation(line: 2, column: 17, scope: !7)
+!24 = !DILocation(line: 3, column: 3, scope: !7)
+!25 = !DILocation(line: 3, column: 7, scope: !7)
+!26 = !DILocation(line: 3, column: 11, scope: !7)
+!27 = !DILocation(line: 3, column: 13, scope: !7)
+!28 = !DILocation(line: 4, column: 1, scope: !7)

llvm/test/DebugInfo/X86/instcombine-demanded-bits-salvage.ll

 ; RUN: opt -mtriple=x86_64-- %s -S --instcombine  -o - | FileCheck %s
 ; Verify that demanded bits optimisations don't affect debuginfo 
 ; variable values.
 ; Bugzilla #44371
 
 @a = common dso_local local_unnamed_addr global i32 0, align 4
 
 define dso_local i32 @p() local_unnamed_addr !dbg !11 {
 entry:
   %conv = load i32, i32* @a, align 4, !dbg !14
   %0 = and i32 %conv, 65535, !dbg !14
-  ; CHECK: metadata !DIExpression(DW_OP_constu, 65535, DW_OP_and, DW_OP_stack_value))
+  ; CHECK: metadata !DIExpression(DW_OP_constu, 65535, DW_OP_and, DW_OP_stack_value)
   call void @llvm.dbg.value(metadata i32 %0, metadata !15, metadata !DIExpression()), !dbg !14
   %1 = lshr i32 %0, 12, !dbg !14
   %2 = and i32 %1, 8, !dbg !14
   %3 = xor i32 %2, 8, !dbg !14
   ret i32 0, !dbg !14
 }
 
 declare void @llvm.dbg.value(metadata, metadata, metadata)

llvm/test/DebugInfo/X86/sroasplit-1.ll

 ;      Inner i1 = outer.inner[1];
 ;      return i1.a;
 ;    }
 ;
 
 ; Verify that SROA creates a variable piece when splitting i1.
 ; CHECK: %[[I1:.*]] = alloca [12 x i8], align 4
 ; CHECK: call void @llvm.dbg.declare(metadata [12 x i8]* %[[I1]], metadata ![[VAR:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 32, 96))
-; CHECK: call void @llvm.dbg.value(metadata i32 %[[A:.*]], metadata ![[VAR]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32))
+; CHECK: call void @llvm.dbg.value(metadata i32 %[[A:.*]], metadata ![[VAR]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)
 ; CHECK: ret i32 %[[A]]
 ; Read Var and Piece:
 ; CHECK: ![[VAR]] = !DILocalVariable(name: "i1",{{.*}} line: 11,
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 
 %struct.Outer = type { [2 x %struct.Inner] }

llvm/test/DebugInfo/X86/sroasplit-2.ll

 ;
 ;    int foo(Outer outer) {
 ;      Inner i1 = outer.inner[1];
 ;      return i1.a;
 ;    }
 ;
 
 ; Verify that SROA creates a variable piece when splitting i1.
-; CHECK:  call void @llvm.dbg.value(metadata i64 %outer.coerce0, metadata ![[O:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64)),
-; CHECK:  call void @llvm.dbg.value(metadata i32 {{.*}}, metadata ![[O]], metadata !DIExpression(DW_OP_LLVM_fragment, 64, 32)),
-; CHECK:  call void @llvm.dbg.value(metadata i32 {{.*}}, metadata ![[O]], metadata !DIExpression(DW_OP_LLVM_fragment, 96, 32)),
-; CHECK:  call void @llvm.dbg.value({{.*}}, metadata ![[I1:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)),
+; CHECK:  call void @llvm.dbg.value(metadata i64 %outer.coerce0, metadata ![[O:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64)
+; CHECK:  call void @llvm.dbg.value(metadata i32 {{.*}}, metadata ![[O]], metadata !DIExpression(DW_OP_LLVM_fragment, 64, 32)
+; CHECK:  call void @llvm.dbg.value(metadata i32 {{.*}}, metadata ![[O]], metadata !DIExpression(DW_OP_LLVM_fragment, 96, 32)
+; CHECK:  call void @llvm.dbg.value({{.*}}, metadata ![[I1:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)
 ; CHECK-DAG: ![[O]] = !DILocalVariable(name: "outer",{{.*}} line: 10
 ; CHECK-DAG: ![[I1]] = !DILocalVariable(name: "i1",{{.*}} line: 11
 
 ; ModuleID = 'sroasplit-2.c'
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 
 %struct.Outer = type { [2 x %struct.Inner] }

llvm/test/DebugInfo/X86/sroasplit-3.ll

 ; RUN: opt %s -sroa -verify -S -o - | FileCheck %s
 ; ModuleID = 'test.c'
 ; Test that SROA updates the debug info correctly if an alloca was rewritten but
 ; not partitioned into multiple allocas.
 ;
-; CHECK: call void @llvm.dbg.value(metadata float %s.coerce, metadata ![[VAR:[0-9]+]], metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata float %s.coerce, metadata ![[VAR:[0-9]+]], metadata !DIExpression()
 ; CHECK: ![[VAR]] = !DILocalVariable(name: "s",{{.*}} line: 3,
 
 ;
 ; struct S { float f; };
 ;  
 ; float foo(struct S s) {
 ;   return s.f;
 ; }

llvm/test/DebugInfo/X86/sroasplit-4.ll

 ; RUN: opt -sroa < %s -S -o - | FileCheck %s
 ;
 ; Test that recursively splitting an alloca updates the debug info correctly.
 ; CHECK: %[[T:.*]] = load i64, i64* @t, align 8
-; CHECK: call void @llvm.dbg.value(metadata i64 %[[T]], metadata ![[Y:.*]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64))
+; CHECK: call void @llvm.dbg.value(metadata i64 %[[T]], metadata ![[Y:.*]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64)
 ; CHECK: %[[T1:.*]] = load i64, i64* @t, align 8
-; CHECK: call void @llvm.dbg.value(metadata i64 %[[T1]], metadata ![[Y]], metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64))
-; CHECK: call void @llvm.dbg.value(metadata i64 %[[T]], metadata ![[R:.*]], metadata !DIExpression(DW_OP_LLVM_fragment, 192, 64))
-; CHECK: call void @llvm.dbg.value(metadata i64 %[[T1]], metadata ![[R]], metadata !DIExpression(DW_OP_LLVM_fragment, 256, 64))
+; CHECK: call void @llvm.dbg.value(metadata i64 %[[T1]], metadata ![[Y]], metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)
+; CHECK: call void @llvm.dbg.value(metadata i64 %[[T]], metadata ![[R:.*]], metadata !DIExpression(DW_OP_LLVM_fragment, 192, 64)
+; CHECK: call void @llvm.dbg.value(metadata i64 %[[T1]], metadata ![[R]], metadata !DIExpression(DW_OP_LLVM_fragment, 256, 64)
 ; 
 ; struct p {
 ;   __SIZE_TYPE__ s;
 ;   __SIZE_TYPE__ t;
 ; };
 ;  
 ; struct r {
 ;   int i;

llvm/test/Instrumentation/HWAddressSanitizer/dbg-value-tag-offset.ll

 ; RUN: opt -hwasan -S -o - %s | FileCheck %s
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64-unknown-linux-android24"
 
 define dso_local void @f() sanitize_hwaddress !dbg !14 {
   %1 = alloca i32, align 4
   %2 = alloca i32, align 4
   %3 = bitcast i32* %1 to i8*, !dbg !21
   %4 = bitcast i32* %2 to i8*, !dbg !21
-; CHECK: call void @llvm.dbg.value(metadata i32 1, {{.*}}, metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata i32 1, {{.*}}, metadata !DIExpression()
   call void @llvm.dbg.value(metadata i32 1, metadata !20, metadata !DIExpression()), !dbg !22
   store i32 1, i32* %2, align 4, !dbg !23, !tbaa !24
-; CHECK: call void @llvm.dbg.value(metadata i32* {{.*}}, metadata !DIExpression(DW_OP_LLVM_tag_offset, 0, DW_OP_deref))
+; CHECK: call void @llvm.dbg.value(metadata i32* {{.*}}, metadata !DIExpression(DW_OP_LLVM_tag_offset, 0, DW_OP_deref)
   call void @llvm.dbg.value(metadata i32* %1, metadata !18, metadata !DIExpression(DW_OP_deref)), !dbg !22
   call void @use(i8* nonnull %3), !dbg !28
-; CHECK: call void @llvm.dbg.value(metadata i32* {{.*}}, metadata !DIExpression(DW_OP_LLVM_tag_offset, 128, DW_OP_deref))
+; CHECK: call void @llvm.dbg.value(metadata i32* {{.*}}, metadata !DIExpression(DW_OP_LLVM_tag_offset, 128, DW_OP_deref)
   call void @llvm.dbg.value(metadata i32* %2, metadata !20, metadata !DIExpression(DW_OP_deref)), !dbg !22
   call void @use(i8* nonnull %4), !dbg !29
   ret void, !dbg !30
 }
 
 declare !dbg !5 void @use(i8*)
 
 declare void @llvm.dbg.value(metadata, metadata, metadata)

llvm/test/Transforms/ArgumentPromotion/pr33641_remove_arg_dbgvalue.ll

 ;
   %tmp = alloca %fun_t
   store %fun_t @bar, %fun_t* %tmp
   ret void
 }
 
 define internal void @bar(%p_t %p)  {
 ; CHECK-LABEL: define {{[^@]+}}@bar()
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16* undef, metadata !3, metadata !DIExpression()), !dbg !5
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16* undef, metadata !3, metadata !DIExpression(), metadata i16* undef, metadata !DIExpression()), !dbg !5
 ; CHECK-NEXT:    ret void
 ;
   call void @llvm.dbg.value(metadata %p_t %p, metadata !4, metadata !5), !dbg !6
   ret void
 }
 
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
;
   store i32 10, i32* %f.1
   %res = call i32 @callee({i32, i32}* %tmp)
   ret i32 %res
 }
 
 define internal i32 @callee({i32, i32}* %ptr)  !dbg !7 {
 ; CHECK-LABEL: define {{[^@]+}}@callee
 ; CHECK-SAME: (i32 [[PTR_0_1_VAL:%.*]]) !dbg !6
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata { i32, i32 }* undef, metadata !7, metadata !DIExpression()), !dbg !8
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[PTR_0_1_VAL]], metadata !7, metadata !DIExpression()), !dbg !8
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata { i32, i32 }* undef, metadata !7, metadata !DIExpression(), metadata { i32, i32 }* undef, metadata !DIExpression()), !dbg !8
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[PTR_0_1_VAL]], metadata !7, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !8
 ; CHECK-NEXT:    ret i32 [[PTR_0_1_VAL]]
 ;
   call void @llvm.dbg.value(metadata {i32, i32}* %ptr, metadata !8, metadata !9), !dbg !10
   %f.1 = getelementptr {i32, i32}, {i32, i32}* %ptr, i32 0, i32 1
   %l.1 = load i32, i32* %f.1
   call void @llvm.dbg.value(metadata i32 %l.1, metadata !8, metadata !9), !dbg !10
   ret i32 %l.1
 }

llvm/test/Transforms/BDCE/basic.ll

 ; CHECK: ret i16
 }
 
 ; DEBUGIFY-LABEL: @tar9
 define signext i16 @tar9(i32 signext %x) #0 {
 entry:
   %call = tail call signext i32 @foo(i32 signext 5) #0
   %and = and i32 %call, 33554432
-; DEBUGIFY: call void @llvm.dbg.value(metadata i32 %call, metadata {{.*}}, metadata !DIExpression(DW_OP_constu, 33554432, DW_OP_and, DW_OP_stack_value))
+; DEBUGIFY: call void @llvm.dbg.value(metadata i32 %call, metadata {{.*}}, metadata !DIExpression(DW_OP_constu, 33554432, DW_OP_and, DW_OP_stack_value), metadata i32 undef, metadata !DIExpression())
   %cast = trunc i32 %call to i16
   ret i16 %cast
 }
 
 attributes #0 = { nounwind readnone }
 attributes #1 = { nounwind }
 

llvm/test/Transforms/BDCE/dbg-multipleuses.ll

 ; Test that BDCE doesn't destroy llvm.dbg.value's argument.
 ; RUN: opt -bdce %s -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK: define void @f()
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT: tail call void (...) @h()
 ; CHECK-NEXT: %[[CALL:.*]] = tail call i32 (...) @g()
-; CHECK-NEXT: tail call void @llvm.dbg.value(metadata i32 %[[CALL:.*]]
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 %[[CALL:.*]]
 
 define void @f() !dbg !6 {
 entry:
   tail call void (...) @h(), !dbg !9
   %call = tail call i32 (...) @g(), !dbg !10
   tail call void @llvm.dbg.value(metadata i32 %call, metadata !11, metadata !13), !dbg !14
   %patatino = xor i32 %call, %call
   tail call void (...) @h(), !dbg !15

llvm/test/Transforms/BDCE/pr26587.ll

 ; Test that BDCE doesn't destroy llvm.dbg.value's argument.
 ; RUN: opt -bdce %s -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK: define void @f()
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT: tail call void (...) @h()
 ; CHECK-NEXT: %[[CALL:.*]] = tail call i32 (...) @g()
-; CHECK-NEXT: tail call void @llvm.dbg.value(metadata i32 %[[CALL:.*]]
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 %[[CALL:.*]]
 
 define void @f() !dbg !6 {
 entry:
   tail call void (...) @h(), !dbg !9
   %call = tail call i32 (...) @g(), !dbg !10
   tail call void @llvm.dbg.value(metadata i32 %call, metadata !11, metadata !13), !dbg !14
   tail call void (...) @h(), !dbg !15
   ret void, !dbg !16

llvm/test/Transforms/CodeGenPrepare/sink-shift-and-trunc.ll

 ; REQUIRES: aarch64-registered-target
 ; RUN: opt < %s -codegenprepare -mtriple=arm64-apple-ios -S | FileCheck %s
 
 @first_ones = external global [65536 x i8]
 
 define i32 @fct19(i64 %arg1) #0 !dbg !6 {
 ; CHECK-LABEL: @fct19
 entry:
   %x.sroa.1.0.extract.shift = lshr i64 %arg1, 16, !dbg !35
   %x.sroa.1.0.extract.trunc = trunc i64 %x.sroa.1.0.extract.shift to i16, !dbg !36
 
   %x.sroa.3.0.extract.shift = lshr i64 %arg1, 32, !dbg !37
   call void @llvm.dbg.value(metadata i64 %x.sroa.3.0.extract.shift, metadata !13, metadata !DIExpression()), !dbg !37
-; CHECK: call void @llvm.dbg.value(metadata i64 %arg1, metadata {{.*}}, metadata !DIExpression(DW_OP_constu, 32, DW_OP_shr, DW_OP_stack_value)), !dbg [[shift2_loc:![0-9]+]]
+; CHECK: call void @llvm.dbg.value(metadata i64 %arg1, metadata {{.*}}, metadata !DIExpression(DW_OP_constu, 32, DW_OP_shr, DW_OP_stack_value), metadata i64 undef, metadata !DIExpression()), !dbg [[shift2_loc:![0-9]+]]
 
   %x.sroa.5.0.extract.shift = lshr i64 %arg1, 48, !dbg !38
   %tobool = icmp eq i64 %x.sroa.5.0.extract.shift, 0, !dbg !39
   br i1 %tobool, label %if.end, label %if.then, !dbg !40
 
 if.then:                                          ; preds = %entry
   %arrayidx3 = getelementptr inbounds [65536 x i8], [65536 x i8]* @first_ones, i64 0, i64 %x.sroa.5.0.extract.shift, !dbg !41
   %0 = load i8, i8* %arrayidx3, align 1, !dbg !42

llvm/test/Transforms/DCE/basic.ll

 ; RUN: opt -debugify -dce -S < %s | FileCheck %s
 ; RUN: opt -passes='module(debugify),function(dce)' -S < %s | FileCheck %s
 
 ; CHECK-LABEL: @test
 define void @test() {
   %add = add i32 1, 2
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 1, metadata [[add:![0-9]+]], metadata !DIExpression(DW_OP_plus_uconst, 2, DW_OP_stack_value))
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 1, metadata [[add:![0-9]+]], metadata !DIExpression(DW_OP_plus_uconst, 2, DW_OP_stack_value), metadata i32 undef, metadata !DIExpression())
   %sub = sub i32 %add, 1
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 1, metadata [[sub:![0-9]+]], metadata !DIExpression(DW_OP_plus_uconst, 2, DW_OP_constu, 1, DW_OP_minus, DW_OP_stack_value))
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 1, metadata [[sub:![0-9]+]], metadata !DIExpression(DW_OP_plus_uconst, 2, DW_OP_constu, 1, DW_OP_minus, DW_OP_stack_value), metadata i32 undef, metadata !DIExpression())
 ; CHECK-NEXT: ret void
   ret void
 }
 
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind
 
 ; CHECK-LABEL: @test_lifetime_alloca

llvm/test/Transforms/DCE/dbg-value-removal.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -S -redundant-dbg-inst-elim | FileCheck %s
 
 ; All dbg.value with location "!dbg !19" are redundant in the input.
 ; FIXME: We do not handle non-overlapping/overlapping fragments perfectly yet.
 
 define dso_local i16 @main(i16 %a1, i16 %a2) local_unnamed_addr #0 !dbg !7 {
 ; CHECK-LABEL: @main(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[BB0:%.*]]
 ; CHECK:       bb0:
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 13, metadata !13, metadata !DIExpression()), !dbg !16
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 14, metadata !14, metadata !DIExpression()), !dbg !18
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 13, metadata !13, metadata !DIExpression()), !dbg !18
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 12, metadata !12, metadata !DIExpression()), !dbg !18
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 13, metadata !13, metadata !DIExpression(), metadata i16 undef, metadata !DIExpression()), !dbg !16
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 14, metadata !14, metadata !DIExpression(), metadata i16 undef, metadata !DIExpression()), !dbg !18
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 13, metadata !13, metadata !DIExpression(), metadata i16 undef, metadata !DIExpression()), !dbg !18
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 12, metadata !12, metadata !DIExpression(), metadata i16 undef, metadata !DIExpression()), !dbg !18
 ; CHECK-NEXT:    br label [[BB1:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A1:%.*]], metadata !14, metadata !DIExpression()), !dbg !18
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 888, metadata !13, metadata !DIExpression()), !dbg !18
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A2:%.*]], metadata !12, metadata !DIExpression()), !dbg !18
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A1:%.*]], metadata !14, metadata !DIExpression(), metadata i16 undef, metadata !DIExpression()), !dbg !18
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 888, metadata !13, metadata !DIExpression(), metadata i16 undef, metadata !DIExpression()), !dbg !18
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A2:%.*]], metadata !12, metadata !DIExpression(), metadata i16 undef, metadata !DIExpression()), !dbg !18
 ; CHECK-NEXT:    [[T1:%.*]] = call i16 @bar(i16 0)
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[T1]], metadata !13, metadata !DIExpression()), !dbg !18
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A2]], metadata !12, metadata !DIExpression(DW_OP_constu, 2, DW_OP_shr, DW_OP_stack_value)), !dbg !18
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[T1]], metadata !13, metadata !DIExpression(), metadata i16 undef, metadata !DIExpression()), !dbg !18
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A2]], metadata !12, metadata !DIExpression(DW_OP_constu, 2, DW_OP_shr, DW_OP_stack_value), metadata i16 undef, metadata !DIExpression()), !dbg !18
 ; CHECK-NEXT:    br label [[BB2:%.*]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A1]], metadata !13, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 8)), !dbg !18
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A1]], metadata !13, metadata !DIExpression(DW_OP_LLVM_fragment, 8, 8)), !dbg !18
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A1]], metadata !13, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 8), metadata i16 undef, metadata !DIExpression()), !dbg !18
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A1]], metadata !13, metadata !DIExpression(DW_OP_LLVM_fragment, 8, 8), metadata i16 undef, metadata !DIExpression()), !dbg !18
 ; CHECK-NEXT:    [[T2:%.*]] = call i16 @bar(i16 [[T1]])
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[T2]], metadata !13, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 8)), !dbg !18
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A1]], metadata !13, metadata !DIExpression(DW_OP_LLVM_fragment, 8, 8)), !dbg !19
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[T2]], metadata !13, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 8), metadata i16 undef, metadata !DIExpression()), !dbg !18
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A1]], metadata !13, metadata !DIExpression(DW_OP_LLVM_fragment, 8, 8), metadata i16 undef, metadata !DIExpression()), !dbg !19
 ; CHECK-NEXT:    br label [[BB3:%.*]]
 ; CHECK:       bb3:
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A1]], metadata !13, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 8)), !dbg !19
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A1]], metadata !13, metadata !DIExpression()), !dbg !18
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A1]], metadata !13, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 8), metadata i16 undef, metadata !DIExpression()), !dbg !19
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[A1]], metadata !13, metadata !DIExpression(), metadata i16 undef, metadata !DIExpression()), !dbg !18
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i16 [[T2]]
 ;
 entry:
   br label %bb0
 
 bb0:

llvm/test/Transforms/DeadArgElim/dbginfo-preserve-dbgloc.ll

 }
 
 declare %struct.Channel* @foo(...) local_unnamed_addr #1
 
 ; Function Attrs: noinline nounwind uwtable
 define internal zeroext i1 @f1(i1 zeroext %is_y, %struct.Channel* %str) #4 !dbg !34 {
 entry:
   %frombool = zext i1 %is_y to i8
-; CHECK: call void @llvm.dbg.value(metadata i1 %is_y, metadata !39, metadata !DIExpression()), !dbg !42
+; CHECK: call void @llvm.dbg.value(metadata i1 %is_y, metadata !39, metadata !DIExpression(), metadata i1 undef, metadata !DIExpression()), !dbg !42
   call void @llvm.dbg.value(metadata i1 %is_y, metadata !39, metadata !DIExpression()), !dbg !42
-; CHECK: call void @llvm.dbg.value(metadata %struct.Channel* %str, metadata !40, metadata !DIExpression()), !dbg !43
+; CHECK: call void @llvm.dbg.value(metadata %struct.Channel* %str, metadata !40, metadata !DIExpression(), metadata %struct.Channel* undef, metadata !DIExpression()), !dbg !43
   call void @llvm.dbg.value(metadata %struct.Channel* %str, metadata !40, metadata !DIExpression()), !dbg !43
   call void @llvm.dbg.value(metadata %struct.Channel* null, metadata !41, metadata !DIExpression()), !dbg !44
   %tobool = icmp ne %struct.Channel* %str, null, !dbg !45
   br i1 %tobool, label %if.end, label %if.then, !dbg !47
 
 if.then:                                          ; preds = %entry
   call void (...) @baa(), !dbg !48
   br label %cleanup, !dbg !50

llvm/test/Transforms/DeadArgElim/dbginfo-update-dbgval.ll

 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 @s = common dso_local local_unnamed_addr global i32 0, align 4, !dbg !0
 
 ; Function Attrs: noinline nounwind uwtable
 define dso_local void @f2(i32 %k) local_unnamed_addr !dbg !11 {
 entry:
-; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata !15, metadata !DIExpression()), !dbg !16
+; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata !15, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !16
   call void @llvm.dbg.value(metadata i32 %k, metadata !15, metadata !DIExpression()), !dbg !16
   %0 = load i32, i32* @s, align 4, !dbg !17
   %inc = add nsw i32 %0, 1, !dbg !17
   store i32 %inc, i32* @s, align 4, !dbg !17
   call void @llvm.dbg.value(metadata i32* @s, metadata !15, metadata !DIExpression(DW_OP_deref)), !dbg !16
   ret void, !dbg !18
 }
 

llvm/test/Transforms/DeadStoreElimination/MSSA/debuginfo.ll

 ; RUN: opt < %s -debugify -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
 
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 declare noalias i8* @malloc(i32)
 
 declare void @test_f()
 
 define i32* @test_salvage(i32 %arg) {
 ; Check that all four original local variables have their values preserved.
 ; CHECK-LABEL: @test_salvage(
 ; CHECK-NEXT: malloc
-; CHECK-NEXT: @llvm.dbg.value(metadata i8* %p, metadata ![[p:.*]], metadata !DIExpression())
+; CHECK-NEXT: @llvm.dbg.value(metadata i8* %p, metadata ![[p:.*]], metadata !DIExpression(), metadata i8* undef, metadata !DIExpression())
 ; CHECK-NEXT: bitcast
-; CHECK-NEXT: @llvm.dbg.value(metadata i32* %P, metadata ![[P:.*]], metadata !DIExpression())
-; CHECK-NEXT: @llvm.dbg.value(metadata i32 %arg, metadata ![[DEAD:.*]], metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value))
+; CHECK-NEXT: @llvm.dbg.value(metadata i32* %P, metadata ![[P:.*]], metadata !DIExpression(), metadata i32* undef, metadata !DIExpression())
+; CHECK-NEXT: @llvm.dbg.value(metadata i32 %arg, metadata ![[DEAD:.*]], metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value), metadata i32 undef, metadata !DIExpression())
 ; CHECK-NEXT: call void @test_f()
 ; CHECK-NEXT: store i32 0, i32* %P
 
   %p = tail call i8* @malloc(i32 4)
   %P = bitcast i8* %p to i32*
   %DEAD = add i32 %arg, 1
   store i32 %DEAD, i32* %P
   call void @test_f()
   store i32 0, i32* %P
   ret i32* %P
 }
 
 ; CHECK: ![[p]] = !DILocalVariable(name: "1"
 ; CHECK: ![[P]] = !DILocalVariable(name: "2"
 ; CHECK: ![[DEAD]] = !DILocalVariable(name: "3"

llvm/test/Transforms/DeadStoreElimination/debuginfo.ll

 ; RUN: opt < %s -debugify -basic-aa -dse -S | FileCheck %s
 
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 declare noalias i8* @malloc(i32)
 
 declare void @test_f()
 
 define i32* @test_salvage(i32 %arg) {
 ; Check that all four original local variables have their values preserved.
 ; CHECK-LABEL: @test_salvage(
 ; CHECK-NEXT: malloc
-; CHECK-NEXT: @llvm.dbg.value(metadata i8* %p, metadata ![[p:.*]], metadata !DIExpression())
+; CHECK-NEXT: @llvm.dbg.value(metadata i8* %p, metadata ![[p:.*]], metadata !DIExpression(), metadata i8* undef, metadata !DIExpression())
 ; CHECK-NEXT: bitcast
-; CHECK-NEXT: @llvm.dbg.value(metadata i32* %P, metadata ![[P:.*]], metadata !DIExpression())
-; CHECK-NEXT: @llvm.dbg.value(metadata i32 %arg, metadata ![[DEAD:.*]], metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value))
+; CHECK-NEXT: @llvm.dbg.value(metadata i32* %P, metadata ![[P:.*]], metadata !DIExpression(), metadata i32* undef, metadata !DIExpression())
+; CHECK-NEXT: @llvm.dbg.value(metadata i32 %arg, metadata ![[DEAD:.*]], metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value), metadata i32 undef, metadata !DIExpression())
 ; CHECK-NEXT: call void @test_f()
 ; CHECK-NEXT: store i32 0, i32* %P
 
   %p = tail call i8* @malloc(i32 4)
   %P = bitcast i8* %p to i32*
   %DEAD = add i32 %arg, 1
   store i32 %DEAD, i32* %P
   call void @test_f()
   store i32 0, i32* %P
   ret i32* %P
 }
 
 ; CHECK: ![[p]] = !DILocalVariable(name: "1"
 ; CHECK: ![[P]] = !DILocalVariable(name: "2"
 ; CHECK: ![[DEAD]] = !DILocalVariable(name: "3"

llvm/test/Transforms/EarlyCSE/debug-info-undef.ll

 ; RUN: opt -S %s -early-cse | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 @a = global i8 25, align 1, !dbg !0
 
 define signext i16 @b() !dbg !12 {
 entry:
   call void @llvm.dbg.value(metadata i16 23680, metadata !17, metadata !DIExpression()), !dbg !18
   %0 = load i8, i8* @a, align 1, !dbg !19, !tbaa !20
   %conv = sext i8 %0 to i16, !dbg !19
 
-; CHECK: call void @llvm.dbg.value(metadata i8 %0, metadata !17, metadata !DIExpression(DW_OP_LLVM_convert, 8, DW_ATE_signed, DW_OP_LLVM_convert, 16, DW_ATE_signed, DW_OP_stack_value)), !dbg !18
+; CHECK: call void @llvm.dbg.value(metadata i8 %0, metadata !17, metadata !DIExpression(DW_OP_LLVM_convert, 8, DW_ATE_signed, DW_OP_LLVM_convert, 16, DW_ATE_signed, DW_OP_stack_value), metadata i16 undef, metadata !DIExpression()), !dbg !18
 ; CHECK-NEXT:  call i32 (...) @optimize_me_not()
 
   call void @llvm.dbg.value(metadata i16 %conv, metadata !17, metadata !DIExpression()), !dbg !18
   %call = call i32 (...) @optimize_me_not(), !dbg !23
   %1 = load i8, i8* @a, align 1, !dbg !24, !tbaa !20
   %conv1 = sext i8 %1 to i16, !dbg !24
   ret i16 %conv1, !dbg !25
 }

llvm/test/Transforms/EarlyCSE/debuginfo-dce.ll

 ; RUN: opt -early-cse -S %s -o - | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; Function Attrs: nounwind uwtable
 define i32 @foo() !dbg !6 {
 entry:
   %0 = call i64 @llvm.ctpop.i64(i64 0), !dbg !14
   %1 = inttoptr i64 %0 to i32*, !dbg !14
   call void @llvm.dbg.value(metadata i32* %1, i64 0, metadata !11, metadata !13), !dbg !14
-; CHECK: call void @llvm.dbg.value(metadata i64 0, metadata !11, metadata !DIExpression()), !dbg !13
+; CHECK: call void @llvm.dbg.value(metadata i64 0, metadata !11, metadata !DIExpression(), metadata i32* undef, metadata !DIExpression()), !dbg !13
   %call = call i32* (...) @baa(), !dbg !15
   %2 = ptrtoint i32* %call to i64, !dbg !16
   %3 = inttoptr i64 %2 to i32*, !dbg !16
   call void @llvm.dbg.value(metadata i32* %3, i64 0, metadata !11, metadata !13), !dbg !14
   %tobool = icmp ne i32* %3, null, !dbg !17
   br i1 %tobool, label %if.end, label %if.then, !dbg !19
 
 if.then:                                          ; preds = %entry

llvm/test/Transforms/GVN/PRE/phi-translate-2.ll

 ; CHECK: %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, %sub.ptr.rhs.cast
 ; CHECK: br i1 %cmp
 ; CHECK: if.then2:
 ; CHECK: %[[PTRTOINT:.*]] = ptrtoint i32* %add.ptr to i64
 ; CHECK: %[[SUB:.*]] = sub i64 %sub.ptr.lhs.cast, %[[PTRTOINT]]
 ; CHECK: br label %if.end3
 ; CHECK: if.end3:
 ; CHECK: %[[PREPHI:.*]] = phi i64 [ %sub.ptr.sub, %if.else ], [ %[[SUB]], %if.then2 ], [ %sub.ptr.sub, %entry ]
-; CHECK: call void @llvm.dbg.value(metadata i32* %p.0, metadata [[var_p0:![0-9]+]], metadata !DIExpression())
-; CHECK: call void @llvm.dbg.value(metadata i64 %sub.ptr.rhs.cast5.pre-phi, metadata [[var_sub_ptr:![0-9]+]], metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata i32* %p.0, metadata [[var_p0:![0-9]+]], metadata !DIExpression(), metadata i32* undef, metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata i64 %sub.ptr.rhs.cast5.pre-phi, metadata [[var_sub_ptr:![0-9]+]], metadata !DIExpression(), metadata i64 undef, metadata !DIExpression())
 ; CHECK: %[[DIV:.*]] = ashr exact i64 %[[PREPHI]], 2
 ; CHECK: ret i64 %[[DIV]]
 
 declare void @bar(...) local_unnamed_addr #1
 
 ; Function Attrs: nounwind uwtable
 define i64 @test5(i32* %start, i32* %e, i32 %n1, i32 %n2) local_unnamed_addr #0 {
 entry:

llvm/test/Transforms/HotColdSplit/transfer-debug-info.ll

 
 ; - Ditto (see above), calls are not special
 ; CHECK-NEXT: call void @sink(i32 [[ADD1]])
 
 ; - Line locations are preserved
 ; CHECK-NEXT: call void @sink(i32 [[ADD1]]), !dbg [[LINE1:![0-9]+]]
 
 ; - llvm.dbg.value intrinsics for values local to @foo.cold.1 are preserved
-; CHECK-NEXT: llvm.dbg.value(metadata i32 [[ADD1]], metadata [[VAR1:![0-9]+]], metadata !DIExpression()), !dbg [[LINE1]]
+; CHECK-NEXT: llvm.dbg.value(metadata i32 [[ADD1]], metadata [[VAR1:![0-9]+]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg [[LINE1]]
 
 ; - Expressions inside of dbg.value intrinsics are preserved
 ; CHECK-NEXT: llvm.dbg.value(metadata i32 [[ADD1]], metadata [[VAR1]], metadata !DIExpression(DW_OP_constu, 1, DW_OP_plus, DW_OP_stack_value)
 
 ; - The DISubprogram for @foo.cold.1 has an empty DISubroutineType
 ; CHECK: [[FILE:![0-9]+]] = !DIFile(filename: "<stdin>"
 ; CHECK: [[EMPTY_MD:![0-9]+]] = !{}
 ; CHECK: [[EMPTY_TYPE:![0-9]+]] = !DISubroutineType(types: [[EMPTY_MD]])

llvm/test/Transforms/IndVarSimplify/X86/indvar-debug-value.ll

 ; }
 
 ; clang++ -g -O -mllvm -disable-llvm-optzns -gno-column-info
 ; opt  -mem2reg -loop-rotate -scalar-evolution
 
 ; CHECK: @main
 ; CHECK: llvm.dbg.value(metadata i32 1, metadata [[METADATA_IDX1:![0-9]+]]
 ; CHECK: %[[VAR_NAME:.*]] = add nuw nsw i64
-; CHECK: llvm.dbg.value(metadata i64 %[[VAR_NAME]], metadata [[METADATA_IDX1]], metadata !DIExpression())
+; CHECK: llvm.dbg.value(metadata i64 %[[VAR_NAME]], metadata [[METADATA_IDX1]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression())
 ; CHECK: DICompileUnit
 ; CHECK: [[METADATA_IDX1]] = !DILocalVariable(name: "ArgIndex"
 
 source_filename = "test.cpp"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @.str = private unnamed_addr constant [20 x i8] c"\0A Argument %d:  %s\0A\00", align 1

llvm/test/Transforms/IndVarSimplify/X86/indvar-debug-value2.ll

 ; }
 
 ; clang++ -g -O -mllvm -disable-llvm-optzns -gno-column-info
 ; opt  -mem2reg -scalar-evolution
 
 ; CHECK: @main
 ; CHECK: llvm.dbg.value(metadata i32 1, metadata [[METADATA_IDX1:![0-9]+]]
 ; CHECK: %[[VAR_NAME:.*]] = add nuw nsw i64
-; CHECK: llvm.dbg.value(metadata i64 %[[VAR_NAME]], metadata [[METADATA_IDX1]], metadata !DIExpression())
+; CHECK: llvm.dbg.value(metadata i64 %[[VAR_NAME]], metadata [[METADATA_IDX1]], metadata !DIExpression(),  metadata i32 undef, metadata !DIExpression())
 ; CHECK: DICompileUnit
 ; CHECK: [[METADATA_IDX1]] = !DILocalVariable(name: "ArgIndex"
 
 source_filename = "test.cpp"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @.str = private unnamed_addr constant [20 x i8] c"\0A Argument %d:  %s\0A\00", align 1

llvm/test/Transforms/IndVarSimplify/X86/scev-phi-debug-info.ll

 ; RUN: opt %s -indvars -S -o - | FileCheck %s
 source_filename = "/Data/llvm/test/Transforms/IndVarSimplify/scev-phi-debug-info.ll"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.status = type { i32, i8* }
 
 @status = internal unnamed_addr global [32 x %struct.status] zeroinitializer, align 16, !dbg !0
 
 define void @f0() local_unnamed_addr !dbg !20 {
 entry:
   tail call void @llvm.dbg.value(metadata i32 0, metadata !23, metadata !DIExpression()), !dbg !24
   br label %for.cond, !dbg !24
 
 for.cond:                                         ; preds = %for.body, %entry
   ; CHECK: %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ 0, %entry ]
-  ; CHECK: call void @llvm.dbg.value(metadata i64 %indvars.iv, metadata !23, metadata !DIExpression()), !dbg !24
+  ; CHECK: call void @llvm.dbg.value(metadata i64 %indvars.iv, metadata !23, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !24
   %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
   tail call void @llvm.dbg.value(metadata i32 %i.0, metadata !23, metadata !DIExpression()), !dbg !24
   %cmp = icmp slt i32 %i.0, 32, !dbg !24
   br i1 %cmp, label %for.body, label %for.end, !dbg !24
 
 for.body:                                         ; preds = %for.cond
   %idxprom = sext i32 %i.0 to i64, !dbg !24
   %value = getelementptr inbounds [32 x %struct.status], [32 x %struct.status]* @status, i64 0, i64 %idxprom, i32 0, !dbg !24

llvm/test/Transforms/Inline/local-as-metadata-undominated-use.ll

 }
 
 ; CHECK-LABEL: define i32 @caller(
 define i32 @caller(i32 %i) {
 ; CHECK-NEXT: entry:
 entry:
 ; Although the inliner shouldn't crash, it can't be expected to get the
 ; "correct" SSA value since its assumptions have been violated.
-; CHECK-NEXT:   tail call void @llvm.dbg.value(metadata ![[EMPTY:[0-9]+]],
+; CHECK-NEXT:   call void @llvm.dbg.value(metadata ![[EMPTY:[0-9]+]],
 ; CHECK-NEXT:   %{{.*}} = add nsw
   %call = tail call i32 @foo(i32 %i)
   ret i32 %call
 }
 
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}

llvm/test/Transforms/InstCombine/assume.ll

 ; PR37726 - https://bugs.llvm.org/show_bug.cgi?id=37726
 ; There's a loophole in eliminating a redundant assumption when
 ; we have conflicting assumptions. Verify that debuginfo doesn't
 ; get in the way of the fold.
 
 define void @debug_interference(i8 %x) {
 ; CHECK-LABEL: @debug_interference(
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 [[X:%.*]], 0
-; CHECK-NEXT:    tail call void @llvm.dbg.value(metadata i32 5, metadata !7, metadata !DIExpression()), !dbg !9
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 5, metadata !7, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !9
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 false)
-; CHECK-NEXT:    tail call void @llvm.dbg.value(metadata i32 5, metadata !7, metadata !DIExpression()), !dbg !9
-; CHECK-NEXT:    tail call void @llvm.dbg.value(metadata i32 5, metadata !7, metadata !DIExpression()), !dbg !9
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 5, metadata !7, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !9
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 5, metadata !7, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !9
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP2]])
 ; CHECK-NEXT:    ret void
 ;
   %cmp1 = icmp eq i8 %x, 0
   %cmp2 = icmp ne i8 %x, 0
   tail call void @llvm.assume(i1 %cmp1)
   tail call void @llvm.dbg.value(metadata i32 5, metadata !1, metadata !DIExpression()), !dbg !9
   tail call void @llvm.assume(i1 %cmp1)

llvm/test/Transforms/InstCombine/cast-mul-select.ll

 ; RUN: opt < %s -instcombine -S | FileCheck %s
 ; RUN: opt -debugify -instcombine -S < %s | FileCheck %s -check-prefix DBGINFO
 
 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"
 
 define i32 @mul(i32 %x, i32 %y) {
 ; CHECK-LABEL: @mul(
 ; CHECK-NEXT:    [[C:%.*]] = mul i32 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[D:%.*]] = and i32 [[C]], 255
 ; CHECK-NEXT:    ret i32 [[D]]
 
 ; Test that when zext is evaluated in different type
 ; we preserve the debug information in the resulting
 ; instruction.
 ; DBGINFO-LABEL: @mul(
-; DBGINFO-NEXT:    call void @llvm.dbg.value(metadata i32 %x, {{.*}} !DIExpression(DW_OP_LLVM_convert, 32, DW_ATE_unsigned, DW_OP_LLVM_convert, 8, DW_ATE_unsigned, DW_OP_stack_value))
-; DBGINFO-NEXT:    call void @llvm.dbg.value(metadata i32 %y, {{.*}} !DIExpression(DW_OP_LLVM_convert, 32, DW_ATE_unsigned, DW_OP_LLVM_convert, 8, DW_ATE_unsigned, DW_OP_stack_value))
+; DBGINFO-NEXT:    call void @llvm.dbg.value(metadata i32 %x, {{.*}} !DIExpression(DW_OP_LLVM_convert, 32, DW_ATE_unsigned, DW_OP_LLVM_convert, 8, DW_ATE_unsigned, DW_OP_stack_value), metadata i8 undef, metadata !DIExpression())
+; DBGINFO-NEXT:    call void @llvm.dbg.value(metadata i32 %y, {{.*}} !DIExpression(DW_OP_LLVM_convert, 32, DW_ATE_unsigned, DW_OP_LLVM_convert, 8, DW_ATE_unsigned, DW_OP_stack_value), metadata i8 undef, metadata !DIExpression())
 ; DBGINFO-NEXT:    [[C:%.*]] = mul i32 {{.*}}
 ; DBGINFO-NEXT:    [[D:%.*]] = and i32 {{.*}}
 ; DBGINFO-NEXT:    call void @llvm.dbg.value(metadata i32 [[C]]
 ; DBGINFO-NEXT:    call void @llvm.dbg.value(metadata i32 [[D]]
 
   %A = trunc i32 %x to i8
   %B = trunc i32 %y to i8
   %C = mul i8 %A, %B

 
 exit:
   unreachable
 }
 
 ; Check that we don't drop debug info when a zext is removed.
 define i1 @foo(i1 zeroext %b) {
 ; DBGINFO-LABEL: @foo(
-; DBGINFO-NEXT:  call void @llvm.dbg.value(metadata i1 %b, {{.*}} !DIExpression(DW_OP_LLVM_convert, 1, DW_ATE_unsigned, DW_OP_LLVM_convert, 8, DW_ATE_unsigned, DW_OP_stack_value))
+; DBGINFO-NEXT:  call void @llvm.dbg.value(metadata i1 %b, {{.*}} !DIExpression(DW_OP_LLVM_convert, 1, DW_ATE_unsigned, DW_OP_LLVM_convert, 8, DW_ATE_unsigned, DW_OP_stack_value), metadata i8 undef, metadata !DIExpression())
 ; DBGINFO-NEXT:  ret i1 %b
 
   %frombool = zext i1 %b to i8 
   ret i1 %b
 }

llvm/test/Transforms/InstCombine/cast-set-preserve-signed-dbg-val.ll

define i16 @test5(i16 %A) !dbg !34 {
   ; The high 16 bits of the original 'and' require sign-extending the new 16-bit and:
   ; CHECK-NEXT: call void @llvm.dbg.value(metadata i16 [[and]], metadata [[C:![0-9]+]],
   ; CHECK-SAME:    metadata !DIExpression(DW_OP_LLVM_convert, 16, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value)
 
   %D = trunc i32 %C to i16, !dbg !42
   call void @llvm.dbg.value(metadata i16 %D, metadata !38, metadata !DIExpression()), !dbg !42
 
   ; The dbg.value for a truncate should simply point to the result of the 16-bit 'and'.
-  ; CHECK-NEXT: call void @llvm.dbg.value(metadata i16 [[and]], metadata [[D:![0-9]+]], metadata !DIExpression())
+  ; CHECK-NEXT: call void @llvm.dbg.value(metadata i16 [[and]], metadata [[D:![0-9]+]], metadata !DIExpression(), metadata i16 undef, metadata !DIExpression())
 
   ret i16 %D, !dbg !43
   ; CHECK-NEXT: ret i16 [[and]]
 }
 
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}

llvm/test/Transforms/InstCombine/debuginfo-dce.ll

 entry:
   %im_not_dead = alloca i8*
   %0 = bitcast %struct.entry* %queue to i8*, !dbg !23
   %1 = bitcast %struct.entry* %queue to i8*, !dbg !23
   call void @llvm.dbg.value(metadata i8* %1, metadata !24, metadata !20), !dbg !23
 ; CHECK: define void @salvage_bitcast
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT: call void @llvm.dbg.value(metadata %struct.entry* %queue,
-; CHECK-SAME:                           metadata !DIExpression(DW_OP_plus_uconst, 0))
+; CHECK-SAME:                           metadata !DIExpression(DW_OP_plus_uconst, 0)
   store i8* %1, i8** %im_not_dead, align 8
   ret void, !dbg !23
 }
 
 define void @salvage_gep0(%struct.entry* %queue, %struct.entry* %end) local_unnamed_addr #0 !dbg !25 {
 entry:
   %im_not_dead = alloca %struct.entry**
   %0 = getelementptr inbounds %struct.entry, %struct.entry* %queue, i32 -1, i32 0, !dbg !26
   %1 = getelementptr inbounds %struct.entry, %struct.entry* %queue, i32 -1, i32 0, !dbg !26
   call void @llvm.dbg.value(metadata %struct.entry** %1, metadata !27, metadata !20), !dbg !26
 ; CHECK: define void @salvage_gep0
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT: call void @llvm.dbg.value(metadata %struct.entry* %queue,
-; CHECK-SAME:                           metadata !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_plus_uconst, 0, DW_OP_stack_value))
+; CHECK-SAME:                           metadata !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_plus_uconst, 0, DW_OP_stack_value)
   store %struct.entry** %1, %struct.entry*** %im_not_dead, align 8
   ret void, !dbg !26
 }
 
 define void @salvage_gep1(%struct.entry* %queue, %struct.entry* %end) local_unnamed_addr #0 !dbg !28 {
 entry:
   %im_not_dead = alloca %struct.entry**
   %0 = getelementptr inbounds %struct.entry, %struct.entry* %queue, i32 -1, i32 0, !dbg !29
   %1 = getelementptr inbounds %struct.entry, %struct.entry* %queue, i32 -1, i32 0, !dbg !29
   call void @llvm.dbg.value(metadata %struct.entry** %1, metadata !30, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)), !dbg !29
 ; CHECK: define void @salvage_gep1
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT: call void @llvm.dbg.value(metadata %struct.entry* %queue,
-; CHECK-SAME:     metadata !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 32))
+; CHECK-SAME:     metadata !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 32)
   store %struct.entry** %1, %struct.entry*** %im_not_dead, align 8
   ret void, !dbg !29
 }
 
 define void @salvage_gep2(%struct.entry* %queue, %struct.entry* %end) local_unnamed_addr #0 !dbg !31 {
 entry:
   %im_not_dead = alloca %struct.entry**
   %0 = getelementptr inbounds %struct.entry, %struct.entry* %queue, i32 -1, i32 0, !dbg !32
   %1 = getelementptr inbounds %struct.entry, %struct.entry* %queue, i32 -1, i32 0, !dbg !32
   call void @llvm.dbg.value(metadata %struct.entry** %1, metadata !33, metadata !DIExpression(DW_OP_stack_value)), !dbg !32
 ; CHECK: define void @salvage_gep2
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT: call void @llvm.dbg.value(metadata %struct.entry* %queue,
-; CHECK-SAME:     metadata !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_stack_value))
+; CHECK-SAME:     metadata !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_stack_value)
   store %struct.entry** %1, %struct.entry*** %im_not_dead, align 8
   ret void, !dbg !32
 }
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.dbg.value(metadata, metadata, metadata) #1
 
 attributes #0 = { nounwind ssp uwtable }

llvm/test/Transforms/InstCombine/debuginfo-dce2.ll

entry:
   %0 = bitcast i8* %p to i32*, !dbg !19
   call void @llvm.dbg.value(metadata i32* %0, metadata !17, metadata !DIExpression()), !dbg !20
   %1 = bitcast i32* %0 to i8*, !dbg !21
   call void @use_as_void(i8* %1), !dbg !22
   ret void, !dbg !23
 }
 
 ; CHECK-LABEL: define void @f(i8* %p)
-; CHECK: call void @llvm.dbg.value(metadata i8* %p, metadata ![[P_VAR:[0-9]+]], metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata i8* %p, metadata ![[P_VAR:[0-9]+]], metadata !DIExpression(), metadata i8* undef, metadata !DIExpression())
 ; CHECK-NOT: bitcast
-; CHECK: call void @llvm.dbg.value(metadata i8* %p, metadata ![[Q_VAR:[0-9]+]], metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata i8* %p, metadata ![[Q_VAR:[0-9]+]], metadata !DIExpression(), metadata i32* undef, metadata !DIExpression())
 ; CHECK-NOT: bitcast
 ; CHECK: ret void
 
 ; CHECK: ![[P_VAR]] = !DILocalVariable(name: "p", {{.*}})
 ; CHECK: ![[Q_VAR]] = !DILocalVariable(name: "q", {{.*}})
 
 declare void @use_as_void(i8*)
 

llvm/test/Transforms/InstCombine/debuginfo-sink.ll

 ; RUN: opt  %s -instcombine -S | FileCheck %s
 
 ; Test sinking of dbg.values when instcombine sinks associated instructions.
 
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 ; This GEP is sunk, but can be folded into a DIExpression. Check that it
 ; gets folded. The dbg.value should be duplicated in the block its sunk
 ; into, to maximise liveness.
 ;
 ; CHECK-LABEL: define i32 @foo(i32*
 ; CHECK:       call void @llvm.dbg.value(metadata i32* %a, metadata !{{[0-9]+}},
-; CHECK-SAME:  metadata !DIExpression(DW_OP_plus_uconst, 4, DW_OP_stack_value))
+; CHECK-SAME:  metadata !DIExpression(DW_OP_plus_uconst, 4, DW_OP_stack_value)
 ; CHECK-NEXT:  br label %sink1
 
 define i32 @foo(i32 *%a) !dbg !7 {
 entry:
   %gep = getelementptr i32, i32 *%a, i32 1
   call void @llvm.dbg.value(metadata i32 *%gep, metadata !16, metadata !12), !dbg !15
   br label %sink1
 
 sink1:
 ; CHECK-LABEL: sink1:
 ; CHECK:       call void @llvm.dbg.value(metadata i32* %gep,
-; CHECK-SAME:                    metadata !{{[0-9]+}}, metadata !DIExpression())
+; CHECK-SAME:                    metadata !{{[0-9]+}}, metadata !DIExpression()
 ; CHECK-NEXT:  load
   %0 = load i32, i32* %gep, align 4, !dbg !15
   ret i32 %0, !dbg !15
 }
 
 ; In this example the GEP cannot (yet) be salvaged. Check that not only is the
 ; dbg.value sunk, but an undef dbg.value is left to terminate any earlier
 ; value range.
 
 ; CHECK-LABEL: define i32 @bar(
 ; CHECK:       call void @llvm.dbg.value(metadata i32* undef,
 ; CHECK-NEXT:  br label %sink2
 
 define i32 @bar(i32 *%a, i32 %b) !dbg !70 {
 entry:
   %gep = getelementptr i32, i32 *%a, i32 %b
   call void @llvm.dbg.value(metadata i32* %gep, metadata !73, metadata !12), !dbg !74
   br label %sink2
 
 sink2:
 ; CHECK-LABEL: sink2:
 ; CHECK:       call void @llvm.dbg.value(metadata i32* %gep,
-; CHECK-SAME:                    metadata !{{[0-9]+}}, metadata !DIExpression())
+; CHECK-SAME:                    metadata !{{[0-9]+}}, metadata !DIExpression()
 ; CHECK-NEXT:  load
 ; CHECK-NEXT:  ret
   %0 = load i32, i32* %gep
   ret i32 %0
 }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4, !5}

llvm/test/Transforms/InstCombine/debuginfo-variables.ll

 ; RUN: opt < %s -debugify -instcombine -S | FileCheck %s
 
 declare void @escape32(i32)
 
 define i64 @test_sext_zext(i16 %A) {
 ; CHECK-LABEL: @test_sext_zext(
 ; CHECK-NEXT:  [[C2:%.*]] = zext i16 %A to i64
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 [[C2]], {{.*}}, metadata !DIExpression())
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 [[C2]], {{.*}}, metadata !DIExpression())
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 [[C2]], {{.*}}, metadata !DIExpression()
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 [[C2]], {{.*}}, metadata !DIExpression()
   %c1 = zext i16 %A to i32
   %c2 = sext i32 %c1 to i64
   ret i64 %c2
 }
 
 define i64 @test_used_sext_zext(i16 %A) {
 ; CHECK-LABEL: @test_used_sext_zext(
 ; CHECK-NEXT:  [[C1:%.*]] = zext i16 %A to i32
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i32 [[C1]], {{.*}}, metadata !DIExpression())
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i32 [[C1]], {{.*}}, metadata !DIExpression()
 ; CHECK-NEXT:  [[C2:%.*]] = zext i16 %A to i64
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 [[C2]], {{.*}}, metadata !DIExpression())
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 [[C2]], {{.*}}, metadata !DIExpression()
 ; CHECK-NEXT:  call void @escape32(i32 %c1)
 ; CHECK-NEXT:  ret i64 %c2
   %c1 = zext i16 %A to i32
   %c2 = sext i32 %c1 to i64
   call void @escape32(i32 %c1)
   ret i64 %c2
 }
 
 define i32 @test_cast_select(i1 %cond) {
 ; CHECK-LABEL: @test_cast_select(
 ; CHECK-NEXT:  [[sel:%.*]] = select i1 %cond, i32 3, i32 5
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i32 [[sel]], {{.*}}, metadata !DIExpression())
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i32 [[sel]], {{.*}}, metadata !DIExpression())
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i32 [[sel]], {{.*}}, metadata !DIExpression()
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i32 [[sel]], {{.*}}, metadata !DIExpression()
 ; CHECK-NEXT:  ret i32 [[sel]]
   %sel = select i1 %cond, i16 3, i16 5
   %cast = zext i16 %sel to i32
   ret i32 %cast
 }
 
 define void @test_or(i64 %A) {
 ; CHECK-LABEL: @test_or(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 256, DW_OP_or, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 256, DW_OP_or, DW_OP_stack_value)
   %1 = or i64 %A, 256
   ret void
 }
 
 define void @test_xor(i32 %A) {
 ; CHECK-LABEL: @test_xor(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i32 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 1, DW_OP_xor, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i32 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 1, DW_OP_xor, DW_OP_stack_value)
   %1 = xor i32 %A, 1
   ret void
 }
 
 define void @test_sub_neg(i64 %A) {
 ; CHECK-LABEL: @test_sub_neg(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value)
   %1 = sub i64 %A, -1
   ret void
 }
 
 define void @test_sub_pos(i64 %A) {
 ; CHECK-LABEL: @test_sub_pos(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 1, DW_OP_minus, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 1, DW_OP_minus, DW_OP_stack_value)
   %1 = sub i64 %A, 1
   ret void
 }
 
 define void @test_shl(i64 %A) {
 ; CHECK-LABEL: @test_shl(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_shl, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_shl, DW_OP_stack_value)
   %1 = shl i64 %A, 7
   ret void
 }
 
 define void @test_lshr(i64 %A) {
 ; CHECK-LABEL: @test_lshr(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_shr, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_shr, DW_OP_stack_value)
   %1 = lshr i64 %A, 7
   ret void
 }
 
 define void @test_ashr(i64 %A) {
 ; CHECK-LABEL: @test_ashr(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_shra, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_shra, DW_OP_stack_value)
   %1 = ashr i64 %A, 7
   ret void
 }
 
 define void @test_mul(i64 %A) {
 ; CHECK-LABEL: @test_mul(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_mul, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_mul, DW_OP_stack_value)
   %1 = mul i64 %A, 7
   ret void
 }
 
 define void @test_sdiv(i64 %A) {
 ; CHECK-LABEL: @test_sdiv(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_div, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_div, DW_OP_stack_value)
   %1 = sdiv i64 %A, 7
   ret void
 }
 
 define void @test_srem(i64 %A) {
 ; CHECK-LABEL: @test_srem(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_mod, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_mod, DW_OP_stack_value)
   %1 = srem i64 %A, 7
   ret void
 }
 
 define void @test_ptrtoint(i64* %P) {
 ; CHECK-LABEL: @test_ptrtoint
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64* %P, {{.*}}, metadata !DIExpression())
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64* %P, {{.*}}, metadata !DIExpression()
   %1 = ptrtoint i64* %P to i64
   ret void
 }
 
 define void @test_and(i64 %A) {
 ; CHECK-LABEL: @test_and(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 256, DW_OP_and, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 256, DW_OP_and, DW_OP_stack_value)
   %1 = and i64 %A, 256
   ret void
 }

llvm/test/Transforms/InstCombine/debuginfo_add.ll

entry:
   tail call void @llvm.dbg.value(metadata i32 undef, metadata !23, metadata !DIExpression()), !dbg !32
   br i1 undef, label %for.end, label %for.body.lr.ph, !dbg !32
 
 for.body.lr.ph:                                   ; preds = %entry
   ; The 'load' and the 'add' are sunken to this basic block. So let's verify that the related dbg.values are sunken as well.
   ; The add is later eliminated, so we verify that the dbg.value is salvaged by using DW_OP_minus.
   ; CHECK-LABEL: for.body.lr.ph:
   ; CHECK-NEXT: %0 = load
-  ; CHECK-NEXT: call void @llvm.dbg.value(metadata i64 %0, metadata !26, metadata !DIExpression(DW_OP_constu, 4096, DW_OP_minus, DW_OP_stack_value)), !dbg !
-  ; CHECK-NEXT: call void @llvm.dbg.value(metadata i64 %0, metadata !25, metadata !DIExpression()), !dbg !
+  ; CHECK-NEXT: call void @llvm.dbg.value(metadata i64 %0, metadata !26, metadata !DIExpression(DW_OP_constu, 4096, DW_OP_minus, DW_OP_stack_value), metadata i64 undef, metadata !DIExpression()), !dbg !
+  ; CHECK-NEXT: call void @llvm.dbg.value(metadata i64 %0, metadata !25, metadata !DIExpression(), metadata i64 undef, metadata !DIExpression()), !dbg !
   br label %for.body, !dbg !32
 
 for.body:                                         ; preds = %for.body.lr.ph, %for.body
   ; CHECK-LABEL: for.body:
   %offset.010 = phi i64 [ %offset.08, %for.body.lr.ph ], [ %offset.0, %for.body ]
   %head_size.09 = phi i32 [ undef, %for.body.lr.ph ], [ %sub2, %for.body ]
   tail call void @llvm.dbg.value(metadata i32 %head_size.09, metadata !23, metadata !DIExpression()), !dbg !31
   %call = tail call i32 bitcast (i32 (...)* @use to i32 (i64, %struct.vm_object*)*)(i64 %offset.010, %struct.vm_object* %object) #3, !dbg !34
   %sub2 = add i32 %head_size.09, -4096, !dbg !37
   %offset.0 = add i64 %offset.010, -4096
   tail call void @llvm.dbg.value(metadata i64 %offset.0, metadata !26, metadata !DIExpression()), !dbg !30
-  ; CHECK: call void @llvm.dbg.value(metadata i64 %offset.010, metadata !26, metadata !DIExpression(DW_OP_constu, 4096, DW_OP_minus, DW_OP_stack_value)), !dbg !
+  ; CHECK: call void @llvm.dbg.value(metadata i64 %offset.010, metadata !26, metadata !DIExpression(DW_OP_constu, 4096, DW_OP_minus, DW_OP_stack_value), metadata i64 undef, metadata !DIExpression()), !dbg !
   tail call void @llvm.dbg.value(metadata i32 %sub2, metadata !23, metadata !DIExpression()), !dbg !31
   %tobool = icmp eq i32 %sub2, 0, !dbg !32
   br i1 %tobool, label %for.end, label %for.body, !dbg !32, !llvm.loop !38
 
 for.end:                                          ; preds = %for.body, %entry
   ret void, !dbg !40
 }
 

llvm/test/Transforms/InstCombine/lower-dbg-declare.ll

 ; CHECK-LABEL: @main
 define dso_local i32 @main() !dbg !12 {
 entry:
   %retval = alloca i32, align 4
   %d1 = alloca i32, align 4
   store i32 0, i32* %retval, align 4
   %0 = bitcast i32* %d1 to i8*, !dbg !17
   call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #4, !dbg !17
-; CHECK: dbg.value(metadata i32 42, metadata [[METADATA_IDX1:![0-9]+]], metadata !DIExpression())
+; CHECK: dbg.value(metadata i32 42, metadata [[METADATA_IDX1:![0-9]+]], metadata !DIExpression()
 ; CHECK-NEXT: store
   call void @llvm.dbg.declare(metadata i32* %d1, metadata !16, metadata !DIExpression()), !dbg !17
   store i32 42, i32* %d1, align 4, !dbg !17
   br label %while.cond, !dbg !22
 
 while.cond:                                       ; preds = %while.body, %entry
-; CHECK: dbg.value(metadata i32 %1, metadata [[METADATA_IDX1]], metadata !DIExpression())
+; CHECK: dbg.value(metadata i32 %1, metadata [[METADATA_IDX1]], metadata !DIExpression()
 ; CHECK-NEXT: call zeroext i1 @_ZL5emptyi
   %1 = load i32, i32* %d1, align 4, !dbg !22
   %call = call zeroext i1 @_ZL5emptyi(i32 %1), !dbg !22
   %lnot = xor i1 %call, true, !dbg !22
   br i1 %lnot, label %while.body, label %while.end, !dbg !22
 
 while.body:                                       ; preds = %while.cond
-; CHECK: dbg.value(metadata i32* %d1, metadata [[METADATA_IDX1]], metadata !DIExpression(DW_OP_deref))
+; CHECK: dbg.value(metadata i32* %d1, metadata [[METADATA_IDX1]], metadata !DIExpression(DW_OP_deref)
 ; CHECK-NEXT: call void @_ZL6escapeRi
   call void @_ZL6escapeRi(i32* dereferenceable(4) %d1), !dbg !23
   br label %while.cond, !dbg !22, !llvm.loop !24
 
 while.end:                                        ; preds = %while.cond
   %2 = bitcast i32* %d1 to i8*, !dbg !25
   call void @llvm.lifetime.end.p0i8(i64 4, i8* %2) #4, !dbg !25
   ret i32 0, !dbg !26

llvm/test/Transforms/InstCombine/unavailable-debug.ll

 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 ; Make sure to update the debug value after dead code elimination.
 ; CHECK: %call = call signext i8 @b(i32 6), !dbg !39
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i8 %call, metadata !30, metadata !DIExpression(DW_OP_LLVM_convert, 8, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value)), !dbg !38
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i8 %call, metadata !30, metadata !DIExpression(DW_OP_LLVM_convert, 8, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value), metadata i32 undef, metadata !DIExpression()), !dbg !38
 
 @e = common local_unnamed_addr global i8 0, align 1, !dbg !0
 @c = common local_unnamed_addr global i32 0, align 4, !dbg !6
 @d = common local_unnamed_addr global i32 0, align 4, !dbg !10
 
 define signext i8 @b(i32 %f) local_unnamed_addr #0 !dbg !18 {
 entry:
   call void @llvm.dbg.value(metadata i32 %f, metadata !22, metadata !DIExpression()), !dbg !23

llvm/test/Transforms/JumpThreading/redundant-dbg-info.ll

 
 if.end:                                           ; preds = %if.then, %entry
   %c.0 = phi i32 [ 0, %if.then ], [ 1, %entry ], !dbg !13
   call void @llvm.dbg.value(metadata i32 %c.0, metadata !14, metadata !DIExpression()), !dbg !13
   %tobool1 = icmp ne i32 %c.0, 0, !dbg !21
   br i1 %tobool1, label %if.else, label %if.then2, !dbg !23
 
 ; CHECK-LABEL: if.then2:
-; CHECK: call void @llvm.dbg.value({{.+}}, metadata ![[B:[0-9]+]], metadata !DIExpression())
-; CHECK: call void @llvm.dbg.value({{.+}}, metadata ![[B:[0-9]+]], metadata !DIExpression())
-; CHECK-NOT: call void @llvm.dbg.value({{.+}}, metadata ![[B]], metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value({{.+}}, metadata ![[B:[0-9]+]], metadata !DIExpression()
+; CHECK: call void @llvm.dbg.value({{.+}}, metadata ![[B:[0-9]+]], metadata !DIExpression()
+; CHECK-NOT: call void @llvm.dbg.value({{.+}}, metadata ![[B]], metadata !DIExpression()
 if.then2:                                         ; preds = %if.end
   call void @llvm.dbg.value(metadata i32 4, metadata !24, metadata !DIExpression()), !dbg !13
   br label %if.end3, !dbg !25
 
 ; CHECK-LABEL: if.end3:
 if.else:                                          ; preds = %if.end
   call void @llvm.dbg.value(metadata i32 6, metadata !24, metadata !DIExpression()), !dbg !13
   br label %if.end3

llvm/test/Transforms/LCSSA/rewrite-existing-dbg-values.ll

 ; RUN: opt -S -lcssa < %s | FileCheck %s
 
 ; Reproducer for PR39019.
 ;
 ; Verify that the llvm.dbg.values are updated to use the PHI nodes inserted by
 ; LCSSA.
 
 ; For the test case @single_exit, we can rewrite all llvm.dbg.value calls
 ; to use the inserted PHI.
 
 ; CHECK-LABEL: @single_exit(
 
 ; CHECK-LABEL: inner.body:
 ; CHECK: %add = add nsw i32 0, 2
-; CHECK: call void @llvm.dbg.value(metadata i32 %add, metadata [[VAR:![0-9]+]], metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata i32 %add, metadata [[VAR:![0-9]+]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression())
 
 
 ; CHECK-LABEL: outer.exit:
 ; CHECK-NEXT: [[PN:%[^ ]*]] = phi i32 [ %add.lcssa, %outer.latch ]
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 [[PN]], metadata [[VAR]], metadata !DIExpression())
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 [[PN]], metadata [[VAR]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression())
 ; CHECK-NEXT: call void @bar(i32 [[PN]])
 
 ; CHECK-LABEL: exit:
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 [[PN]], metadata [[VAR]], metadata !DIExpression())
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 [[PN]], metadata [[VAR]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression())
 
 define void @single_exit()  !dbg !6 {
 entry:
   br label %outer.header, !dbg !12
 
 outer.header:                                     ; preds = %outer.latch, %entry
   br label %inner.body, !dbg !12
 

 ; For the test case @multi_exit, we cannot update the llvm.dbg.value call in exit,
 ; because LCSSA did not insert a PHI node in %exit, as there is no non-debug
 ; use.
 
 ; CHECK-LABEL: @multi_exit()
 
 ; CHECK-LABEL: for.header:
 ; CHECK-NEXT: %add = add nsw i32 0, 2
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 %add, metadata [[VAR2:![0-9]+]], metadata !DIExpression())
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 %add, metadata [[VAR2:![0-9]+]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression())
 
 ; CHECK-LABEL: for.exit1:
 ; CHECK-NEXT: [[PN1:%[^ ]*]] = phi i32 [ %add, %for.header ]
 ; CHECK-NEXT: br label %for.exit1.succ
 
 ; CHECK-LABEL: for.exit1.succ:
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 [[PN1]], metadata [[VAR2]], metadata !DIExpression())
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 [[PN1]], metadata [[VAR2]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression())
 ; CHECK-NEXT: call void @bar(i32 [[PN1]])
 
 ; CHECK-LABEL: for.exit2:
 ; CHECK-NEXT: [[PN2:%[^ ]*]] = phi i32 [ %add, %for.latch ]
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 [[PN2]], metadata [[VAR2]], metadata !DIExpression())
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 [[PN2]], metadata [[VAR2]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression())
 ; CHECK-NEXT: call void @bar(i32 [[PN2]])
 
 ; CHECK-LABEL: exit:
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 %add, metadata [[VAR2]], metadata !DIExpression())
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 %add, metadata [[VAR2]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression())
 
 define void @multi_exit()  !dbg !13 {
 entry:
   br label %for.header, !dbg !14
 
 for.header:                                       ; preds = %for.latch, %entry
   %add = add nsw i32 0, 2, !dbg !14
   call void @llvm.dbg.value(metadata i32 %add, metadata !16, metadata !DIExpression()), !dbg !14

llvm/test/Transforms/LICM/debug-value.ll

 
 for.cond.backedge:                                ; preds = %for.body61, %for.body61.us, %for.body
   br i1 undef, label %for.end104, label %for.body, !dbg !15
 
 if.then:                                          ; preds = %for.body
   br i1 undef, label %if.then27, label %if.end.if.end.split_crit_edge.critedge, !dbg !16
 
 if.then27:                                        ; preds = %if.then
-; CHECK: tail call void @llvm.dbg.value
+; CHECK: call void @llvm.dbg.value
   tail call void @llvm.dbg.value(metadata double undef, metadata !19, metadata !DIExpression()), !dbg !21
   br label %for.body61.us
 
 if.end.if.end.split_crit_edge.critedge:           ; preds = %if.then
   br label %for.body61
 
 for.body61.us:                                    ; preds = %for.body61.us, %if.then27
   br i1 undef, label %for.cond.backedge, label %for.body61.us, !dbg !23

llvm/test/Transforms/LICM/sinking.ll

 ; CHECK-NEXT:  ret void
 
 ; The GEP in dead1 is adding a zero offset, so the DIExpression can be kept as
 ; a "register location".
 ; The GEP in dead2 is adding a 4 bytes to the pointer, so the DIExpression is
 ; turned into an "implicit location" using DW_OP_stack_value.
 ;
 ; DEBUGIFY-LABEL: @test11(
-; DEBUGIFY: call void @llvm.dbg.value(metadata %Ty* @X2, metadata {{.*}}, metadata !DIExpression())
-; DEBUGIFY: call void @llvm.dbg.value(metadata %Ty* @X2, metadata {{.*}}, metadata !DIExpression(DW_OP_plus_uconst, 4, DW_OP_stack_value))
+; DEBUGIFY: call void @llvm.dbg.value(metadata %Ty* @X2, metadata {{.*}}, metadata !DIExpression()
+; DEBUGIFY: call void @llvm.dbg.value(metadata %Ty* @X2, metadata {{.*}}, metadata !DIExpression(DW_OP_plus_uconst, 4, DW_OP_stack_value)
 }
 
 @c = common global [1 x i32] zeroinitializer, align 4
 
 ; Test a *many* way nested loop with multiple exit blocks both of which exit
 ; multiple loop nests. This exercises LCSSA corner cases.
 define i32 @PR18753(i1* %a, i1* %b, i1* %c, i1* %d) {
 entry:

llvm/test/Transforms/LoopDeletion/diundef.ll

 for.cond:                                         ; preds = %for.cond, %entry
   %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.cond ], !dbg !20
   call void @llvm.dbg.value(metadata i32 %i.0, metadata !16, metadata !DIExpression()), !dbg !17
   %inc = add nuw nsw i32 %i.0, 1, !dbg !21
   call void @llvm.dbg.value(metadata i32 %inc, metadata !16, metadata !DIExpression()), !dbg !17
   %exitcond = icmp ne i32 %inc, 3, !dbg !23
   br i1 %exitcond, label %for.cond, label %for.end, !dbg !24, !llvm.loop !25
 
-; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata !16, metadata !DIExpression()), !dbg !17
+; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata !16, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !17
 ; CHECK-NEXT: %call = tail call i32 {{.*}} @patatino()
 for.end:                                          ; preds = %for.cond
   %call = tail call i32 (...) @patatino() #3, !dbg !27
   %0 = load i32, i32* @a, align 4, !dbg !28
   ret i32 %0, !dbg !33
 }
 
 declare i32 @patatino(...) local_unnamed_addr

llvm/test/Transforms/LoopIdiom/memcpy-debugify-remarks.ll

 ; CHECK-NEXT:  bb.nph:
 ; CHECK-NEXT:    [[DEST1:%.*]] = bitcast i32* [[DEST:%.*]] to i8*
 ; CHECK-NEXT:    [[BASE2:%.*]] = bitcast i32* [[BASE:%.*]] to i8*
 ; CHECK-NEXT:    [[TMP0:%.*]] = shl nuw i64 [[SIZE:%.*]], 2, !dbg !18
 ; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 [[DEST1]], i8* align 1 [[BASE2]], i64 [[TMP0]], i1 false), !dbg !19
 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]], !dbg !18
 ; CHECK:       for.body:
 ; CHECK-NEXT:    [[INDVAR:%.*]] = phi i64 [ 0, [[BB_NPH:%.*]] ], [ [[INDVAR_NEXT:%.*]], [[FOR_BODY]] ], !dbg !20
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i64 [[INDVAR]], metadata !9, metadata !DIExpression()), !dbg !20
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i64 [[INDVAR]], metadata !9, metadata !DIExpression(), metadata i64 undef, metadata !DIExpression()), !dbg !20
 ; CHECK-NEXT:    [[I_0_014:%.*]] = getelementptr i32, i32* [[BASE]], i64 [[INDVAR]], !dbg !21
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[I_0_014]], metadata !11, metadata !DIExpression()), !dbg !21
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[I_0_014]], metadata !11, metadata !DIExpression(), metadata i32* undef, metadata !DIExpression()), !dbg !21
 ; CHECK-NEXT:    [[DESTI:%.*]] = getelementptr i32, i32* [[DEST]], i64 [[INDVAR]], !dbg !22
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[DESTI]], metadata !12, metadata !DIExpression()), !dbg !22
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[DESTI]], metadata !12, metadata !DIExpression(), metadata i32* undef, metadata !DIExpression()), !dbg !22
 ; CHECK-NEXT:    [[V:%.*]] = load i32, i32* [[I_0_014]], align 1, !dbg !23
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[V]], metadata !13, metadata !DIExpression()), !dbg !23
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[V]], metadata !13, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !23
 ; CHECK-NEXT:    [[INDVAR_NEXT]] = add i64 [[INDVAR]], 1, !dbg !24
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i64 [[INDVAR_NEXT]], metadata !15, metadata !DIExpression()), !dbg !24
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i64 [[INDVAR_NEXT]], metadata !15, metadata !DIExpression(), metadata i64 undef, metadata !DIExpression()), !dbg !24
 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVAR_NEXT]], [[SIZE]], !dbg !25
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i1 [[EXITCOND]], metadata !16, metadata !DIExpression()), !dbg !25
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i1 [[EXITCOND]], metadata !16, metadata !DIExpression(), metadata i1 undef, metadata !DIExpression()), !dbg !25
 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END:%.*]], label [[FOR_BODY]], !dbg !26
 ; CHECK:       for.end:
 ; CHECK-NEXT:    ret void, !dbg !27
 ;
 bb.nph:
   br label %for.body
 
 for.body:                                         ; preds = %bb.nph, %for.body

llvm/test/Transforms/LoopIdiom/memset-debugify-remarks.ll

 
 ; CHECK: remark: <stdin>:4:1: Transformed loop-strided store into a call to llvm.memset.p0i8.i64() function
 
 define void @_Z15my_basic_memsetPcS_c(i8* %ptr, i8* %end, i8 %value) {
 ; CHECK-LABEL: @_Z15my_basic_memsetPcS_c(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[PTR1:%.*]] = ptrtoint i8* [[PTR:%.*]] to i64
 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp eq i8* [[PTR]], [[END:%.*]], !dbg !15
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP3]], metadata !9, metadata !DIExpression()), !dbg !15
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP3]], metadata !9, metadata !DIExpression(), metadata i1 undef, metadata !DIExpression()), !dbg !15
 ; CHECK-NEXT:    br i1 [[CMP3]], label [[FOR_END:%.*]], label [[FOR_BODY_PREHEADER:%.*]], !dbg !16
 ; CHECK:       for.body.preheader:
 ; CHECK-NEXT:    [[TMP0:%.*]] = sub i64 0, [[PTR1]], !dbg !17
 ; CHECK-NEXT:    [[SCEVGEP:%.*]] = getelementptr i8, i8* [[END]], i64 [[TMP0]], !dbg !17
 ; CHECK-NEXT:    [[SCEVGEP2:%.*]] = ptrtoint i8* [[SCEVGEP]] to i64
 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* align 1 [[PTR]], i8 [[VALUE:%.*]], i64 [[SCEVGEP2]], i1 false), !dbg !18
 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]], !dbg !17
 ; CHECK:       for.body:
 ; CHECK-NEXT:    [[PTR_ADDR_04:%.*]] = phi i8* [ [[INCDEC_PTR:%.*]], [[FOR_BODY]] ], [ [[PTR]], [[FOR_BODY_PREHEADER]] ], !dbg !19
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i8* [[PTR_ADDR_04]], metadata !11, metadata !DIExpression()), !dbg !19
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i8* [[PTR_ADDR_04]], metadata !11, metadata !DIExpression(), metadata i8* undef, metadata !DIExpression()), !dbg !19
 ; CHECK-NEXT:    [[INCDEC_PTR]] = getelementptr inbounds i8, i8* [[PTR_ADDR_04]], i64 1, !dbg !20
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i8* [[INCDEC_PTR]], metadata !13, metadata !DIExpression()), !dbg !20
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i8* [[INCDEC_PTR]], metadata !13, metadata !DIExpression(), metadata i8* undef, metadata !DIExpression()), !dbg !20
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8* [[INCDEC_PTR]], [[END]], !dbg !21
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP]], metadata !14, metadata !DIExpression()), !dbg !21
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP]], metadata !14, metadata !DIExpression(), metadata i1 undef, metadata !DIExpression()), !dbg !21
 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_END_LOOPEXIT:%.*]], label [[FOR_BODY]], !dbg !17
 ; CHECK:       for.end.loopexit:
 ; CHECK-NEXT:    br label [[FOR_END]], !dbg !22
 ; CHECK:       for.end:
 ; CHECK-NEXT:    ret void, !dbg !22
 ;
 entry:
   %cmp3 = icmp eq i8* %ptr, %end

llvm/test/Transforms/LoopRotate/dbg-value-duplicates-2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -loop-rotate -S | FileCheck %s
 
 define dso_local i16 @main() local_unnamed_addr #0 !dbg !7 {
 ; CHECK-LABEL: @main(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 9, metadata !12, metadata !DIExpression()), !dbg !13
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 9, metadata !12, metadata !DIExpression(), metadata i16 undef, metadata !DIExpression()), !dbg !13
 ; CHECK-NEXT:    br label [[BB2:%.*]], !dbg !14
 ; CHECK:       bb2:
 ; CHECK-NEXT:    [[TMP1:%.*]] = phi i16 [ 9, [[ENTRY:%.*]] ], [ [[TMP5:%.*]], [[BB2]] ]
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[TMP1]], metadata !12, metadata !DIExpression()), !dbg !13
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[TMP1]], metadata !12, metadata !DIExpression(), metadata i16 undef, metadata !DIExpression()), !dbg !13
 ; CHECK-NEXT:    [[TMP4:%.*]] = call i16 @wibble(i16 [[TMP1]]), !dbg !14
 ; CHECK-NEXT:    [[TMP5]] = add nsw i16 [[TMP4]], [[TMP1]], !dbg !14
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[TMP5]], metadata !12, metadata !DIExpression()), !dbg !13
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i16 [[TMP5]], metadata !12, metadata !DIExpression(), metadata i16 undef, metadata !DIExpression()), !dbg !13
 ; CHECK-NEXT:    [[TMP6:%.*]] = call i16 @wibble(i16 [[TMP4]]), !dbg !14
 ; CHECK-NEXT:    [[TMP7:%.*]] = mul nsw i16 [[TMP6]], 3, !dbg !14
 ; CHECK-NEXT:    [[TMP8:%.*]] = call i16 @wibble(i16 [[TMP7]]), !dbg !14
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp slt i16 [[TMP5]], 17, !dbg !14
 ; CHECK-NEXT:    br i1 [[TMP2]], label [[BB2]], label [[BB3:%.*]], !dbg !14
 ; CHECK:       bb3:
 ; CHECK-NEXT:    [[TMP10:%.*]] = call i16 @wibble(i16 8), !dbg !14
 ; CHECK-NEXT:    ret i16 [[TMP10]], !dbg !14

llvm/test/Transforms/LoopRotate/dbg-value-duplicates.ll

 ; RUN: opt -S -loop-rotate < %s | FileCheck %s
 ; RUN: opt -S -loop-rotate -enable-mssa-loop-dependency=true -verify-memoryssa < %s | FileCheck %s
 source_filename = "/tmp/loop.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.13.0"
 
 ; Function Attrs: nounwind ssp uwtable
 define void @f(float* %input, i64 %n, i64 %s) local_unnamed_addr #0 !dbg !8 {
 entry:
   call void @llvm.dbg.value(metadata float* %input, metadata !15, metadata !DIExpression()), !dbg !20
   call void @llvm.dbg.value(metadata i64 %n, metadata !16, metadata !DIExpression()), !dbg !21
   call void @llvm.dbg.value(metadata i64 %s, metadata !17, metadata !DIExpression()), !dbg !22
   call void @llvm.dbg.value(metadata i64 0, metadata !18, metadata !DIExpression()), !dbg !23
-  ; CHECK:   call void @llvm.dbg.value(metadata i64 0, metadata !18, metadata !DIExpression()), !dbg !23
-  ; CHECK-NOT:   call void @llvm.dbg.value(metadata i64 0, metadata !18, metadata !DIExpression()), !dbg !23
+  ; CHECK:   call void @llvm.dbg.value(metadata i64 0, metadata !18, metadata !DIExpression(), metadata i64 undef, metadata !DIExpression()), !dbg !23
+  ; CHECK-NOT:   call void @llvm.dbg.value(metadata i64 0, metadata !18, metadata !DIExpression(), metadata i64 undef, metadata !DIExpression()), !dbg !23
   br label %for.cond, !dbg !24
 
 for.cond:                                         ; preds = %for.body, %entry
   ; CHECK: %i.02 = phi i64 [ 0, %for.body.lr.ph ], [ %add, %for.body ]
   %i.0 = phi i64 [ 0, %entry ], [ %add, %for.body ]
   call void @llvm.dbg.value(metadata i64 %i.0, metadata !18, metadata !DIExpression()), !dbg !23
   %cmp = icmp slt i64 %i.0, %n, !dbg !25
   br i1 %cmp, label %for.body, label %for.cond.cleanup, !dbg !27
 
 for.cond.cleanup:                                 ; preds = %for.cond
   ret void, !dbg !28
 
 for.body:                                         ; preds = %for.cond
   %arrayidx = getelementptr inbounds float, float* %input, i64 %i.0, !dbg !29
   %0 = load float, float* %arrayidx, align 4, !dbg !29, !tbaa !30
   call void @bar(float %0), !dbg !34
   %add = add nsw i64 %i.0, %s, !dbg !35
   call void @llvm.dbg.value(metadata i64 %add, metadata !18, metadata !DIExpression()), !dbg !23
-  ; CHECK:   call void @llvm.dbg.value(metadata i64 %add, metadata !18, metadata !DIExpression()), !dbg !23
-  ; CHECK-NOT:   call void @llvm.dbg.value(metadata i64 %add, metadata !18, metadata !DIExpression()), !dbg !23
+  ; CHECK:   call void @llvm.dbg.value(metadata i64 %add, metadata !18, metadata !DIExpression(), metadata i64 undef, metadata !DIExpression()), !dbg !23
+  ; CHECK-NOT:   call void @llvm.dbg.value(metadata i64 %add, metadata !18, metadata !DIExpression(), metadata i64 undef, metadata !DIExpression()), !dbg !23
   br label %for.cond, !dbg !36, !llvm.loop !37
 }
 
 declare void @bar(float) local_unnamed_addr #1
 
 ; Function Attrs: nounwind readnone speculatable
 declare void @llvm.dbg.value(metadata, metadata, metadata) #2
 

llvm/test/Transforms/LoopRotate/dbgvalue.ll

 ; RUN: opt -S -loop-rotate < %s | FileCheck %s
 ; RUN: opt -S -loop-rotate -enable-mssa-loop-dependency=true -verify-memoryssa < %s | FileCheck %s
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata) nounwind readnone
 declare void @llvm.dbg.value(metadata, metadata, metadata) nounwind readnone
 
 define i32 @tak(i32 %x, i32 %y, i32 %z) nounwind ssp !dbg !0 {
 ; CHECK-LABEL: define i32 @tak(
 ; CHECK: entry
 ; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 %x
-; CHECK: tail call void @llvm.dbg.value(metadata i32 %call
+; CHECK: call void @llvm.dbg.value(metadata i32 %call
 
 entry:
   br label %tailrecurse
 
 tailrecurse:                                      ; preds = %if.then, %entry
   %x.tr = phi i32 [ %x, %entry ], [ %call, %if.then ]
   %y.tr = phi i32 [ %y, %entry ], [ %call9, %if.then ]
   %z.tr = phi i32 [ %z, %entry ], [ %call14, %if.then ]

 
 return:                                           ; preds = %if.end
   ret i32 %z.tr, !dbg !17
 }
 
 define i32 @tak2(i32 %x, i32 %y, i32 %z) nounwind ssp !dbg !21 {
 ; CHECK-LABEL: define i32 @tak2(
 ; CHECK: entry
-; CHECK: tail call void @llvm.dbg.value(metadata i32 %x.tr
-; CHECK: tail call void @llvm.dbg.value(metadata i32 undef
+; CHECK: call void @llvm.dbg.value(metadata i32 %x.tr
+; CHECK: call void @llvm.dbg.value(metadata i32 undef
 
 entry:
   br label %tailrecurse
 
 tailrecurse:                                      ; preds = %if.then, %entry
   %x.tr = phi i32 [ %x, %entry ], [ %call, %if.then ]
   %y.tr = phi i32 [ %y, %entry ], [ %call9, %if.then ]
   %z.tr = phi i32 [ %z, %entry ], [ %call14, %if.then ]

 @channelColumns = external global i64
 @horzPlane = external global i8*, align 8
 
 define void @FindFreeHorzSeg(i64 %startCol, i64 %row, i64* %rowStart) {
 ; Ensure that the loop increment basic block is rotated into the tail of the
 ; body, even though it contains a debug intrinsic call.
 ; CHECK-LABEL: define void @FindFreeHorzSeg(
 ; CHECK: %dec = add
-; CHECK-NEXT: tail call void @llvm.dbg.value
+; CHECK-NEXT: call void @llvm.dbg.value
 ; CHECK: %cmp = icmp
 ; CHECK: br i1 %cmp
 ; CHECK: phi i64 [ %{{[^,]*}}, %{{[^,]*}} ]
 ; CHECK-NEXT: br label %for.end
 
 
 entry:
   br label %for.cond

llvm/test/Transforms/LoopRotate/phi-dbgvalue.ll

 ; RUN: opt -S -loop-rotate < %s | FileCheck %s
 ; RUN: opt -S -loop-rotate -enable-mssa-loop-dependency=true -verify-memoryssa < %s | FileCheck %s
 
 ;CHECK-LABEL: func
 ;CHECK-LABEL: entry
-;CHECK-NEXT: tail call void @llvm.dbg.value(metadata i32 %a
-;CHECK-NEXT: tail call void @llvm.dbg.value(metadata i32 1, metadata ![[I_VAR:[0-9]+]], metadata !DIExpression())
+;CHECK-NEXT: call void @llvm.dbg.value(metadata i32 %a
+;CHECK-NEXT: call void @llvm.dbg.value(metadata i32 1, metadata ![[I_VAR:[0-9]+]], metadata !DIExpression()
 ;CHECK-LABEL: for.body:
 ;CHECK-NEXT: [[I:%.*]] = phi i32 [ 1, %entry ], [ %inc, %for.body ]
-;CHECK-NEXT: tail call void @llvm.dbg.value(metadata i32 [[I]], metadata ![[I_VAR]], metadata !DIExpression())
+;CHECK-NEXT: call void @llvm.dbg.value(metadata i32 [[I]], metadata ![[I_VAR]], metadata !DIExpression()
 
 ; CHECK: ![[I_VAR]] = !DILocalVariable(name: "i",{{.*}})
 
 ; Function Attrs: noinline nounwind
 define void @func(i32 %a) local_unnamed_addr #0 !dbg !6 {
 entry:
   tail call void @llvm.dbg.value(metadata i32 %a, metadata !10, metadata !11), !dbg !12
   tail call void @llvm.dbg.value(metadata i32 1, metadata !13, metadata !11), !dbg !15

llvm/test/Transforms/LoopUnroll/debug-info.ll

for.cond.cleanup:                                 ; preds = %for.body
   ret void, !dbg !17
 
 for.body:                                         ; preds = %entry, %for.body
   %i.04 = phi i32 [ 1, %entry ], [ %shl, %for.body ]
   tail call void @llvm.dbg.value(metadata i32 %i.04, metadata !12, metadata !DIExpression()), !dbg !15
   %shr = ashr i32 %i.04, 1, !dbg !18
 
   ; The loop gets unrolled entirely.
-  ; CHECK: call void @llvm.dbg.value(metadata i32 1, metadata !12, metadata !DIExpression()), !dbg !15
-  ; CHECK: call void @llvm.dbg.value(metadata i32 4, metadata !12, metadata !DIExpression()), !dbg !15
-  ; CHECK: call void @llvm.dbg.value(metadata i32 16, metadata !12, metadata !DIExpression()), !dbg !15
-  ; CHECK: call void @llvm.dbg.value(metadata i32 64, metadata !12, metadata !DIExpression()), !dbg !15
+  ; CHECK: call void @llvm.dbg.value(metadata i32 1, metadata !12, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !15
+  ; CHECK: call void @llvm.dbg.value(metadata i32 4, metadata !12, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !15
+  ; CHECK: call void @llvm.dbg.value(metadata i32 16, metadata !12, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !15
+  ; CHECK: call void @llvm.dbg.value(metadata i32 64, metadata !12, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !15
   
   %call = tail call i32 (i32, ...) bitcast (i32 (...)* @bar to i32 (i32, ...)*)(i32 %shr) #3, !dbg !20
   %shl = shl i32 %i.04, 2, !dbg !21
   tail call void @llvm.dbg.value(metadata i32 %shl, metadata !12, metadata !DIExpression()), !dbg !15
   %cmp = icmp slt i32 %shl, 33, !dbg !22
   br i1 %cmp, label %for.body, label %for.cond.cleanup, !dbg !16, !llvm.loop !23
 }
 

llvm/test/Transforms/Mem2Reg/dbg-addr-inline-dse.ll

entry:
   store i32 2, i32* %x.addr, align 4, !dbg !23
   %ld.2 = load i32, i32* %x.addr, align 4, !dbg !19
   %inc.2 = add nsw i32 %ld.2, 1, !dbg !19
   store i32 %inc.2, i32* %x.addr, align 4, !dbg !19
   ret void, !dbg !25
 }
 
 ; CHECK-LABEL: define void @f(i32 %x)
-; CHECK: call void @llvm.dbg.value(metadata i32 %x, metadata !13, metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata i32 %x, metadata !13, metadata !DIExpression()
 ; CHECK: %inc.1 = add nsw i32 %x, 1
-; CHECK: call void @llvm.dbg.value(metadata i32 %inc.1, metadata !13, metadata !DIExpression())
-; CHECK: call void @llvm.dbg.value(metadata i32 1, metadata !13, metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata i32 %inc.1, metadata !13, metadata !DIExpression()
+; CHECK: call void @llvm.dbg.value(metadata i32 1, metadata !13, metadata !DIExpression()
 ; CHECK: store i32 1, i32* @global, align 4
-; CHECK: call void @llvm.dbg.value(metadata i32 2, metadata !13, metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata i32 2, metadata !13, metadata !DIExpression()
 ; CHECK: %inc.2 = add nsw i32 2, 1
-; CHECK: call void @llvm.dbg.value(metadata i32 %inc.2, metadata !13, metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata i32 %inc.2, metadata !13, metadata !DIExpression()
 ; CHECK: ret void
 
 attributes #0 = { nounwind uwtable }
 attributes #2 = { nounwind readnone speculatable }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4, !5, !6}
 !llvm.ident = !{!7}

llvm/test/Transforms/Mem2Reg/dbg-addr.ll

 if.end:                                           ; preds = %if.else, %if.then
   %rv = load i32, i32* %x, align 4, !dbg !37, !tbaa !17
   ret i32 %rv, !dbg !39
 }
 
 ; CHECK-LABEL: define i32 @if_else({{.*}})
 ; CHECK: entry:
 ; CHECK-NOT:   alloca i32
-; CHECK:   call void @llvm.dbg.value(metadata i32 %a, metadata ![[X_LOCAL:[0-9]+]], metadata !DIExpression())
+; CHECK:   call void @llvm.dbg.value(metadata i32 %a, metadata ![[X_LOCAL:[0-9]+]], metadata !DIExpression()
 ; CHECK: if.then:                                          ; preds = %entry
-; CHECK:   call void @llvm.dbg.value(metadata i32 0, metadata ![[X_LOCAL]], metadata !DIExpression())
+; CHECK:   call void @llvm.dbg.value(metadata i32 0, metadata ![[X_LOCAL]], metadata !DIExpression()
 ; CHECK: if.else:                                          ; preds = %entry
-; CHECK:   call void @llvm.dbg.value(metadata i32 %b, metadata ![[X_LOCAL]], metadata !DIExpression())
+; CHECK:   call void @llvm.dbg.value(metadata i32 %b, metadata ![[X_LOCAL]], metadata !DIExpression()
 ; CHECK: if.end:                                           ; preds = %if.else, %if.then
 ; CHECK:   %[[PHI:[^ ]*]] = phi i32 [ 0, %if.then ], [ %b, %if.else ]
-; CHECK:   call void @llvm.dbg.value(metadata i32 %[[PHI]], metadata ![[X_LOCAL]], metadata !DIExpression())
+; CHECK:   call void @llvm.dbg.value(metadata i32 %[[PHI]], metadata ![[X_LOCAL]], metadata !DIExpression()
 ; CHECK:   ret i32
 
 ; CHECK: ![[X_LOCAL]] = !DILocalVariable(name: "x", {{.*}})
 
 ; Function Attrs: nounwind readnone speculatable
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 declare void @llvm.dbg.addr(metadata, metadata, metadata)
 

llvm/test/Transforms/MergeFunc/mergefunc-preserve-debug-info.ll

 ; OPTIMIZATION_LEVEL_0-NEXT: store i32 %y, i32* %y.addr, align 4
 ; OPTIMIZATION_LEVEL_0-NEXT: call void @llvm.dbg.declare(metadata i32* %y.addr, metadata !{{[0-9]+}}, metadata !DIExpression()), !dbg !{{[0-9]+}}
 ; OPTIMIZATION_LEVEL_0-NEXT: %0 = tail call i32 @maxA(i32 %x, i32 %y), !dbg !{{[0-9]+}}
 ; OPTIMIZATION_LEVEL_0-NEXT: ret i32 %0, !dbg !{{[0-9]+}}
 ; OPTIMIZATION_LEVEL_0-NEXT: }
 
 ; OPTIMIZATION_LEVEL_2: define i32 @maxB(i32 %x, i32 %y)
 ; OPTIMIZATION_LEVEL_2-NEXT: entry:
-; OPTIMIZATION_LEVEL_2-NEXT: call void @llvm.dbg.value(metadata i32 %x, metadata !{{[0-9]+}}, metadata !DIExpression()), !dbg !{{[0-9]+}}
-; OPTIMIZATION_LEVEL_2-NEXT: call void @llvm.dbg.value(metadata i32 %y, metadata !{{[0-9]+}}, metadata !DIExpression()), !dbg !{{[0-9]+}}
+; OPTIMIZATION_LEVEL_2-NEXT: call void @llvm.dbg.value(metadata i32 %x, metadata !{{[0-9]+}}, metadata !DIExpression(), {{.*}}), !dbg !{{[0-9]+}}
+; OPTIMIZATION_LEVEL_2-NEXT: call void @llvm.dbg.value(metadata i32 %y, metadata !{{[0-9]+}}, metadata !DIExpression(), {{.*}}), !dbg !{{[0-9]+}}
 ; OPTIMIZATION_LEVEL_2-NEXT: %0 = tail call i32 @maxA(i32 %x, i32 %y) #{{[0-9]+}}, !dbg !{{[0-9]+}}
 ; OPTIMIZATION_LEVEL_2-NEXT: ret i32 %0, !dbg !{{[0-9]+}}
 ; OPTIMIZATION_LEVEL_2-NEXT: }
 
 entry:
   %x.addr = alloca i32, align 4
   %y.addr = alloca i32, align 4
   %i = alloca i32, align 4

llvm/test/Transforms/Reassociate/matching-binops.ll

;
   %r = fmul fast float %sy, %a
   ret float %r
 }
 
 ; Verify that debug info for modified instructions gets discarded (references become undef).
 
 define i32 @and_shl_dbg(i32 %x, i32 %y, i32 %z, i32 %shamt) {
 ; CHECK-LABEL: @and_shl_dbg(
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[X:%.*]], metadata !7, metadata !DIExpression()), !dbg !20
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[Y:%.*]], metadata !13, metadata !DIExpression()), !dbg !21
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[Z:%.*]], metadata !14, metadata !DIExpression()), !dbg !22
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[SHAMT:%.*]], metadata !15, metadata !DIExpression()), !dbg !23
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[X:%.*]], metadata !7, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !20
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[Y:%.*]], metadata !13, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !21
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[Z:%.*]], metadata !14, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !22
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[SHAMT:%.*]], metadata !15, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !23
 ; CHECK-NEXT:    [[SHL:%.*]] = shl i32 [[X]], [[SHAMT]], !dbg !24
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[SHL]], metadata !16, metadata !DIExpression()), !dbg !25
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[SHL]], metadata !16, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !25
 ; CHECK-NEXT:    [[SHL1:%.*]] = shl i32 [[Y]], [[SHAMT]], !dbg !26
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[SHL1]], metadata !17, metadata !DIExpression()), !dbg !27
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[SHL1]], metadata !17, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !27
 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[SHL]], [[Z]], !dbg !28
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[AND]], metadata !18, metadata !DIExpression()), !dbg !29
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[AND]], metadata !18, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !29
 ; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[AND]], [[SHL1]], !dbg !30
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[AND2]], metadata !19, metadata !DIExpression()), !dbg !31
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[AND2]], metadata !19, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !31
 ; CHECK-NEXT:    ret i32 [[AND2]], !dbg !32
 ;
   call void @llvm.dbg.value(metadata i32 %x, metadata !13, metadata !DIExpression()), !dbg !21
   call void @llvm.dbg.value(metadata i32 %y, metadata !14, metadata !DIExpression()), !dbg !22
   call void @llvm.dbg.value(metadata i32 %z, metadata !15, metadata !DIExpression()), !dbg !23
   call void @llvm.dbg.value(metadata i32 %shamt, metadata !16, metadata !DIExpression()), !dbg !24
   %shl = shl i32 %x, %shamt, !dbg !25
   call void @llvm.dbg.value(metadata i32 %shl, metadata !17, metadata !DIExpression()), !dbg !26

llvm/test/Transforms/Reassociate/reassociate_dbgvalue_discard.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -reassociate -S -o - | FileCheck %s
 
 ; After reassociation m1 and m2 aren't calculated as m1=c*a and m2=c*b any longer.
 ; So let's verify that the dbg.value nodes for m1 and m3 are invalidated.
 
 source_filename = "reassociate_dbgvalue_discard.c"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define dso_local i32 @test1(i32 %a, i32 %b, i32 %c, i32 %d) local_unnamed_addr #0 !dbg !7 {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 undef, metadata !16, metadata !DIExpression()), !dbg !20
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 undef, metadata !17, metadata !DIExpression()), !dbg !21
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 undef, metadata !16, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !20
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 undef, metadata !17, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !21
 ; CHECK-NEXT:    [[M1:%.*]] = mul i32 [[D:%.*]], [[C:%.*]], !dbg !22
 ; CHECK-NEXT:    [[M3:%.*]] = mul i32 [[M1]], [[A:%.*]], !dbg !23
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[M3]], metadata !18, metadata !DIExpression()), !dbg !24
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[M3]], metadata !18, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !24
 ; CHECK-NEXT:    [[M2:%.*]] = mul i32 [[D]], [[C]], !dbg !25
 ; CHECK-NEXT:    [[M4:%.*]] = mul i32 [[M2]], [[B:%.*]], !dbg !26
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[M4]], metadata !19, metadata !DIExpression()), !dbg !27
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[M4]], metadata !19, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !27
 ; CHECK-NEXT:    [[RES:%.*]] = xor i32 [[M3]], [[M4]]
 ; CHECK-NEXT:    ret i32 [[RES]], !dbg !28
 ;
 entry:
   %m1 = mul i32 %c, %a, !dbg !24
   call void @llvm.dbg.value(metadata i32 %m1, metadata !16, metadata !DIExpression()), !dbg !25
   %m2 = mul i32 %c, %b, !dbg !26
   call void @llvm.dbg.value(metadata i32 %m2, metadata !17, metadata !DIExpression()), !dbg !27

llvm/test/Transforms/Reassociate/reassociate_salvages_debug_info.ll

 ; RUN: opt < %s -reassociate -S | FileCheck %s
 
 ; Check that reassociate pass now salvages debug info when dropping instructions.
 
 define hidden i32 @main(i32 %argc, i8** %argv) {
 entry:
-  ; CHECK: call void @llvm.dbg.value(metadata i32 %argc, metadata [[VAR_B:![0-9]+]], metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value))
+  ; CHECK: call void @llvm.dbg.value(metadata i32 %argc, metadata [[VAR_B:![0-9]+]], metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value)
   %add = add nsw i32 %argc, 1, !dbg !26
   call void @llvm.dbg.value(metadata i32 %add, metadata !22, metadata !DIExpression()), !dbg !25
   %add1 = add nsw i32 %argc, %add, !dbg !27
   ret i32 %add1, !dbg !28
 }
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
 declare void @llvm.dbg.value(metadata, metadata, metadata) #1

llvm/test/Transforms/Reassociate/undef_intrinsics_when_deleting_instructions.ll

 ; RUN: opt < %s -reassociate -S | FileCheck %s
 
 ; Check that reassociate pass now undefs debug intrinsics that reference a value
 ; that gets dropped and cannot be salvaged.
 
 define hidden i32 @main() local_unnamed_addr {
 entry:
   %foo = alloca i32, align 4, !dbg !20
   %foo.0.foo.0..sroa_cast = bitcast i32* %foo to i8*, !dbg !20
   call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %foo.0.foo.0..sroa_cast), !dbg !20
   store volatile i32 4, i32* %foo, align 4, !dbg !20, !tbaa !21
   %foo.0.foo.0. = load volatile i32, i32* %foo, align 4, !dbg !25, !tbaa !21
   %foo.0.foo.0.15 = load volatile i32, i32* %foo, align 4, !dbg !27, !tbaa !21
   %foo.0.foo.0.16 = load volatile i32, i32* %foo, align 4, !dbg !28, !tbaa !21
   ; CHECK-NOT: %add = add nsw i32 %foo.0.foo.0., %foo.0.foo.0.15
   %add = add nsw i32 %foo.0.foo.0., %foo.0.foo.0.15, !dbg !29
-  ; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata [[VAR_A:![0-9]+]], metadata !DIExpression())
+  ; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata [[VAR_A:![0-9]+]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !28
   call void @llvm.dbg.value(metadata i32 %add, metadata !19, metadata !DIExpression()), !dbg !26
   %foo.0.foo.0.17 = load volatile i32, i32* %foo, align 4, !dbg !30, !tbaa !21
   %cmp = icmp eq i32 %foo.0.foo.0.17, 4, !dbg !30
   br i1 %cmp, label %if.then, label %if.end, !dbg !32
 
   ; CHECK-LABEL: if.then:
 if.then:
   ; CHECK-NOT: %add1 = add nsw i32 %add, %foo.0.foo.0.16
   %add1 = add nsw i32 %add, %foo.0.foo.0.16, !dbg !33
-  ; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata [[VAR_A]], metadata !DIExpression())
+  ; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata [[VAR_A]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !28
   call void @llvm.dbg.value(metadata i32 %add1, metadata !19, metadata !DIExpression()), !dbg !26
-  ; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata [[VAR_CHEESE:![0-9]+]], metadata !DIExpression())
+  ; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata [[VAR_CHEESE:![0-9]+]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !28
   call void @llvm.dbg.value(metadata i32 %add, metadata !18, metadata !DIExpression()), !dbg !26
   %sub = add nsw i32 %add, -12, !dbg !34
   %sub3 = sub nsw i32 %add1, %sub, !dbg !34
   %mul = mul nsw i32 %sub3, 20, !dbg !36
   %div = sdiv i32 %mul, 3, !dbg !37
   br label %if.end, !dbg !38
 
 if.end:

llvm/test/Transforms/SLPVectorizer/AArch64/spillcost-di.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Debug informations shouldn't affect spill cost.
 ; RUN: opt -S -slp-vectorizer %s -o - | FileCheck %s
 
 target triple = "aarch64"
 
 %struct.S = type { i64, i64 }
 
 define void @patatino(i64 %n, i64 %i, %struct.S* %p) !dbg !7 {
 ; CHECK-LABEL: @patatino(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i64 [[N:%.*]], metadata !18, metadata !DIExpression()), !dbg !23
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i64 [[I:%.*]], metadata !19, metadata !DIExpression()), !dbg !24
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata %struct.S* [[P:%.*]], metadata !20, metadata !DIExpression()), !dbg !25
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i64 [[N:%.*]], metadata !18, metadata !DIExpression(), metadata i64 undef, metadata !DIExpression()), !dbg !23
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i64 [[I:%.*]], metadata !19, metadata !DIExpression(), metadata i64 undef, metadata !DIExpression()), !dbg !24
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata %struct.S* [[P:%.*]], metadata !20, metadata !DIExpression(), metadata %struct.S* undef, metadata !DIExpression()), !dbg !25
 ; CHECK-NEXT:    [[X1:%.*]] = getelementptr inbounds [[STRUCT_S:%.*]], %struct.S* [[P]], i64 [[N]], i32 0, !dbg !26
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i64 undef, metadata !21, metadata !DIExpression()), !dbg !27
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i64 undef, metadata !21, metadata !DIExpression(), metadata i64 undef, metadata !DIExpression()), !dbg !27
 ; CHECK-NEXT:    [[Y3:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[P]], i64 [[N]], i32 1, !dbg !28
 ; CHECK-NEXT:    [[TMP0:%.*]] = bitcast i64* [[X1]] to <2 x i64>*, !dbg !26
 ; CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i64>, <2 x i64>* [[TMP0]], align 8, !dbg !26, !tbaa !29
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i64 undef, metadata !22, metadata !DIExpression()), !dbg !33
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i64 undef, metadata !22, metadata !DIExpression(), metadata i64 undef, metadata !DIExpression()), !dbg !33
 ; CHECK-NEXT:    [[X5:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[P]], i64 [[I]], i32 0, !dbg !34
 ; CHECK-NEXT:    [[Y7:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[P]], i64 [[I]], i32 1, !dbg !35
 ; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i64* [[X5]] to <2 x i64>*, !dbg !36
 ; CHECK-NEXT:    store <2 x i64> [[TMP1]], <2 x i64>* [[TMP2]], align 8, !dbg !36, !tbaa !29
 ; CHECK-NEXT:    ret void, !dbg !37
 ;
 entry:
   call void @llvm.dbg.value(metadata i64 %n, metadata !18, metadata !DIExpression()), !dbg !23

llvm/test/Transforms/SLPVectorizer/X86/debug_info.ll

 ;     y1 = A[5];
 ;   }
 ;   A[8] = y0; A[8+1] = y1;
 ; }
 
 define i32 @depth(double* nocapture %A, i32 %m) #0 !dbg !4 {
 ; CHECK-LABEL: @depth(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata double* [[A:%.*]], metadata !12, metadata !DIExpression()), !dbg !18
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[M:%.*]], metadata !13, metadata !DIExpression()), !dbg !18
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata double 0.000000e+00, metadata !14, metadata !DIExpression()), !dbg !19
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata double 2.000000e-01, metadata !15, metadata !DIExpression()), !dbg !19
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 0, metadata !16, metadata !DIExpression()), !dbg !20
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata double* [[A:%.*]], metadata !12, metadata !DIExpression(), metadata double* undef, metadata !DIExpression()), !dbg !18
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[M:%.*]], metadata !13, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !18
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata double 0.000000e+00, metadata !14, metadata !DIExpression(), metadata double undef, metadata !DIExpression()), !dbg !19
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata double 2.000000e-01, metadata !15, metadata !DIExpression(), metadata double undef, metadata !DIExpression()), !dbg !19
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 0, metadata !16, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !20
 ; CHECK-NEXT:    [[CMP8:%.*]] = icmp sgt i32 [[M]], 0, !dbg !20
 ; CHECK-NEXT:    br i1 [[CMP8]], label [[FOR_BODY_LR_PH:%.*]], label [[FOR_END:%.*]], !dbg !20
 ; CHECK:       for.body.lr.ph:
 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds double, double* [[A]], i64 4, !dbg !21
 ; CHECK-NEXT:    [[TMP0:%.*]] = bitcast double* [[ARRAYIDX]] to <2 x double>*, !dbg !21
 ; CHECK-NEXT:    [[TMP1:%.*]] = load <2 x double>, <2 x double>* [[TMP0]], align 8, !dbg !21
 ; CHECK-NEXT:    br label [[FOR_END]], !dbg !20
 ; CHECK:       for.end:

llvm/test/Transforms/SROA/dbg-addr-diamond.ll

if.end:                                           ; preds = %if.else, %if.then
   %1 = bitcast %struct.Pair* %p to i8*, !dbg !51
   %2 = bitcast %struct.Pair* @pair to i8*, !dbg !51
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %2, i8* align 4 %1, i64 8, i1 false), !dbg !51
   ret void
 }
 
 ; CHECK-LABEL: define void @if_else(i32 %cond, i32 %a, i32 %b)
 ; CHECK: entry:
-; CHECK:   call void @llvm.dbg.value(metadata i32 %a, metadata ![[PVAR:[0-9]+]], metadata ![[XFRAG:DIExpression\(DW_OP_LLVM_fragment, 0, 32\)]])
-; CHECK:   call void @llvm.dbg.value(metadata i32 %b, metadata ![[PVAR]], metadata ![[YFRAG:DIExpression\(DW_OP_LLVM_fragment, 32, 32\)]])
+; CHECK:   call void @llvm.dbg.value(metadata i32 %a, metadata ![[PVAR:[0-9]+]], metadata ![[XFRAG:DIExpression\(DW_OP_LLVM_fragment, 0, 32\)]]
+; CHECK:   call void @llvm.dbg.value(metadata i32 %b, metadata ![[PVAR]], metadata ![[YFRAG:DIExpression\(DW_OP_LLVM_fragment, 32, 32\)]]
 ; CHECK: if.then:
-; CHECK:   call void @llvm.dbg.value(metadata i32 0, metadata ![[PVAR]], metadata ![[XFRAG]])
-; CHECK:   call void @llvm.dbg.value(metadata i32 %a, metadata ![[PVAR]], metadata ![[YFRAG]])
+; CHECK:   call void @llvm.dbg.value(metadata i32 0, metadata ![[PVAR]], metadata ![[XFRAG]]
+; CHECK:   call void @llvm.dbg.value(metadata i32 %a, metadata ![[PVAR]], metadata ![[YFRAG]]
 ; CHECK: if.else:
-; CHECK:   call void @llvm.dbg.value(metadata i32 %b, metadata ![[PVAR]], metadata ![[XFRAG]])
-; CHECK:   call void @llvm.dbg.value(metadata i32 0, metadata ![[PVAR]], metadata ![[YFRAG]])
+; CHECK:   call void @llvm.dbg.value(metadata i32 %b, metadata ![[PVAR]], metadata ![[XFRAG]]
+; CHECK:   call void @llvm.dbg.value(metadata i32 0, metadata ![[PVAR]], metadata ![[YFRAG]]
 ; CHECK: if.end:
 ; CHECK:   %p.sroa.4.0 = phi i32 [ %a, %if.then ], [ 0, %if.else ]
 ; CHECK:   %p.sroa.0.0 = phi i32 [ 0, %if.then ], [ %b, %if.else ]
-; CHECK:   call void @llvm.dbg.value(metadata i32 %p.sroa.0.0, metadata ![[PVAR]], metadata ![[XFRAG]])
-; CHECK:   call void @llvm.dbg.value(metadata i32 %p.sroa.4.0, metadata ![[PVAR]], metadata ![[YFRAG]])
+; CHECK:   call void @llvm.dbg.value(metadata i32 %p.sroa.0.0, metadata ![[PVAR]], metadata ![[XFRAG]]
+; CHECK:   call void @llvm.dbg.value(metadata i32 %p.sroa.4.0, metadata ![[PVAR]], metadata ![[YFRAG]]
 
 ; CHECK: ![[PVAR]] = !DILocalVariable(name: "p", {{.*}})
 
 ; Function Attrs: argmemonly nounwind
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) #2
 
 ; Function Attrs: nounwind readnone speculatable
 declare void @llvm.dbg.addr(metadata, metadata, metadata)

llvm/test/Transforms/SROA/dbg-inline.ll

 ; Function Attrs: noinline optnone ssp uwtable
 define i64 @_Z1g4pair(i64 %p.coerce0, i64 %p.coerce1) #0 !dbg !8 {
 entry:
   %p = alloca %struct.pair, align 8
   %0 = getelementptr inbounds %struct.pair, %struct.pair* %p, i32 0, i32 0
   store i64 %p.coerce0, i64* %0, align 8
   %1 = getelementptr inbounds %struct.pair, %struct.pair* %p, i32 0, i32 1
   store i64 %p.coerce1, i64* %1, align 8
-  ; CHECK-DAG: call void @llvm.dbg.value(metadata i64 %p.coerce0, metadata ![[VAR:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64)), !dbg ![[LOC:[0-9]+]]
-  ; CHECK-DAG: call void @llvm.dbg.value(metadata i64 %p.coerce1, metadata ![[VAR]], metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)), !dbg ![[LOC]]
-  ; CHECK-DAG: call void @llvm.dbg.value(metadata i64 %p.coerce0, metadata ![[INLINED_VAR:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64)), !dbg ![[INLINED_LOC:[0-9]+]]
-  ; CHECK-DAG: call void @llvm.dbg.value(metadata i64 %p.coerce1, metadata ![[INLINED_VAR]], metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)), !dbg ![[INLINED_LOC]]
+  ; CHECK-DAG: call void @llvm.dbg.value(metadata i64 %p.coerce0, metadata ![[VAR:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64), metadata i64 %p.coerce0, metadata !DIExpression()), !dbg ![[LOC:[0-9]+]]
+  ; CHECK-DAG: call void @llvm.dbg.value(metadata i64 %p.coerce1, metadata ![[VAR]], metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64), metadata i64 %p.coerce1, metadata !DIExpression()), !dbg ![[LOC]]
+  ; CHECK-DAG: call void @llvm.dbg.value(metadata i64 %p.coerce0, metadata ![[INLINED_VAR:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64), metadata i64 undef, metadata !DIExpression()), !dbg ![[INLINED_LOC:[0-9]+]]
+  ; CHECK-DAG: call void @llvm.dbg.value(metadata i64 %p.coerce1, metadata ![[INLINED_VAR]], metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64), metadata i64 undef, metadata !DIExpression()), !dbg ![[INLINED_LOC]]
   call void @llvm.dbg.declare(metadata %struct.pair* %p, metadata !17, metadata !DIExpression()), !dbg !18
   call void @llvm.dbg.declare(metadata %struct.pair* %p, metadata !21, metadata !DIExpression()), !dbg !23
   %a.i = getelementptr inbounds %struct.pair, %struct.pair* %p, i32 0, i32 0, !dbg !25
   %x2 = load i64, i64* %0, align 8, !dbg !25
   ret i64 %x2, !dbg !26
 }
 
 ; Function Attrs: nounwind readnone speculatable willreturn

llvm/test/Transforms/SROA/dbg-single-piece.ll

 ; RUN: opt -sroa %s -S | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 %foo = type { [8 x i8], [8 x i8] }
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata) #0
 define void @_ZL18findInsertLocationPN4llvm17MachineBasicBlockENS_9SlotIndexERNS_13LiveIntervalsE() {
 entry:
   %retval = alloca %foo, align 8
   call void @llvm.dbg.declare(metadata %foo* %retval, metadata !1, metadata !7), !dbg !8
 ; Checks that SROA still inserts a bit_piece expression, even if it produces only one piece
 ; (as long as that piece is smaller than the whole thing)
 ; CHECK-NOT: call void @llvm.dbg.value
-; CHECK: call void @llvm.dbg.value(metadata %foo* undef, {{.*}}, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)), !dbg
+; CHECK: call void @llvm.dbg.value(metadata %foo* undef, {{.*}}, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64), metadata %foo* undef, {{.*}}), !dbg
 ; CHECK-NOT: call void @llvm.dbg.value
   %0 = bitcast %foo* %retval to i8*
   %1 = getelementptr inbounds i8, i8* %0, i64 8
   %2 = bitcast i8* %1 to %foo**
   store %foo* undef, %foo** %2, align 8
   ret void
 }
 

llvm/test/Transforms/SafeStack/X86/debug-loc-dynamic.ll

 ; RUN: opt -safe-stack -S -mtriple=i386-pc-linux-gnu < %s -o - | FileCheck %s
 
 ; Test llvm.dbg.value for dynamic allocas moved onto the unsafe stack.
 ; In the dynamic alloca case, the dbg.value does not change with the exception
 ; of the alloca pointer in the first argument being replaced with the new stack
 ; top address.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @f(i32 %n) safestack !dbg !6 {
 entry:
   tail call void @llvm.dbg.value(metadata i32 %n, metadata !11, metadata !14), !dbg !15
   %0 = zext i32 %n to i64, !dbg !16
 
 ; CHECK:  store i8* %[[VLA:.*]], i8** @__safestack_unsafe_stack_ptr
-; CHECK:  tail call void @llvm.dbg.value(metadata i8* %[[VLA]], metadata ![[TYPE:.*]], metadata !DIExpression(DW_OP_deref))
+; CHECK:  call void @llvm.dbg.value(metadata i8* %[[VLA]], metadata ![[TYPE:.*]], metadata !DIExpression(DW_OP_deref)
 ; CHECK:  call void @capture({{.*}} %[[VLA]])
 
   %vla = alloca i8, i64 %0, align 16, !dbg !16
   tail call void @llvm.dbg.value(metadata i8* %vla, metadata !12, metadata !17), !dbg !18
   call void @capture(i8* nonnull %vla), !dbg !19
   ret void, !dbg !20
 }
 

llvm/test/Transforms/SafeStack/X86/debug-loc2.ll

 entry:
 ; CHECK:   %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
   %x1 = alloca i32, align 4
   %x2 = alloca i32, align 4
   %0 = bitcast i32* %x1 to i8*, !dbg !13
   %1 = bitcast i32* %x2 to i8*, !dbg !14
 
 ; Unhandled dbg.value: expression does not start with OP_DW_deref
-; CHECK: call void @llvm.dbg.value(metadata i32* undef, metadata !{{.*}}, metadata !{{.*}})
+; CHECK: call void @llvm.dbg.value(metadata i32* undef, metadata !{{.*}}, metadata !{{.*}}
   tail call void @llvm.dbg.value(metadata i32* %x1, metadata !10, metadata !23), !dbg !16
 
 ; Unhandled dbg.value: expression does not start with OP_DW_deref
-; CHECK: call void @llvm.dbg.value(metadata i32* undef, metadata !{{.*}}, metadata !{{.*}})
+; CHECK: call void @llvm.dbg.value(metadata i32* undef, metadata !{{.*}}, metadata !{{.*}}
   tail call void @llvm.dbg.value(metadata i32* %x1, metadata !10, metadata !24), !dbg !16
 
 ; Supported dbg.value: rewritted based on the [[USP]] value.
-; CHECK: call void @llvm.dbg.value(metadata i8* %[[USP]], metadata ![[X1:.*]], metadata !DIExpression(DW_OP_constu, 4, DW_OP_minus, DW_OP_deref, DW_OP_LLVM_fragment, 0, 4))
+; CHECK: call void @llvm.dbg.value(metadata i8* %[[USP]], metadata ![[X1:.*]], metadata !DIExpression(DW_OP_constu, 4, DW_OP_minus, DW_OP_deref, DW_OP_LLVM_fragment, 0, 4)
   tail call void @llvm.dbg.value(metadata i32* %x1, metadata !10, metadata !25), !dbg !16
 
 ; Supported dbg.value: rewritted based on the [[USP]] value.
-; CHECK: call void @llvm.dbg.value(metadata i8* %[[USP]], metadata ![[X1:.*]], metadata !DIExpression(DW_OP_constu, 4, DW_OP_minus, DW_OP_deref))
+; CHECK: call void @llvm.dbg.value(metadata i8* %[[USP]], metadata ![[X1:.*]], metadata !DIExpression(DW_OP_constu, 4, DW_OP_minus, DW_OP_deref)
   tail call void @llvm.dbg.value(metadata i32* %x1, metadata !10, metadata !15), !dbg !16
   call void @capture(i32* nonnull %x1), !dbg !17
 
 ; An extra non-dbg.value metadata use of %x2. Replaced with undef.
 ; CHECK: call void @llvm.random.metadata.use(metadata i32* undef
   call void @llvm.random.metadata.use(metadata i32* %x2)
 
-; CHECK: call void @llvm.dbg.value(metadata i8* %[[USP]], metadata ![[X2:.*]], metadata !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref))
+; CHECK: call void @llvm.dbg.value(metadata i8* %[[USP]], metadata ![[X2:.*]], metadata !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref)
   call void @llvm.dbg.value(metadata i32* %x2, metadata !12, metadata !15), !dbg !18
   call void @capture(i32* nonnull %x2), !dbg !19
   ret void, !dbg !20
 }
 
 ; Function Attrs: argmemonly nounwind
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
 

llvm/test/Transforms/Scalarizer/dbginfo.ll

 ; CHECK: %c.i0 = bitcast <4 x i32>* %c to i32*
 ; CHECK: %c.i1 = getelementptr i32, i32* %c.i0, i32 1
 ; CHECK: %c.i2 = getelementptr i32, i32* %c.i0, i32 2
 ; CHECK: %c.i3 = getelementptr i32, i32* %c.i0, i32 3
 ; CHECK: %b.i0 = bitcast <4 x i32>* %b to i32*
 ; CHECK: %b.i1 = getelementptr i32, i32* %b.i0, i32 1
 ; CHECK: %b.i2 = getelementptr i32, i32* %b.i0, i32 2
 ; CHECK: %b.i3 = getelementptr i32, i32* %b.i0, i32 3
-; CHECK: tail call void @llvm.dbg.value(metadata <4 x i32>* %a, metadata !{{[0-9]+}}, metadata {{.*}}), !dbg !{{[0-9]+}}
-; CHECK: tail call void @llvm.dbg.value(metadata <4 x i32>* %b, metadata !{{[0-9]+}}, metadata {{.*}}), !dbg !{{[0-9]+}}
-; CHECK: tail call void @llvm.dbg.value(metadata <4 x i32>* %c, metadata !{{[0-9]+}}, metadata {{.*}}), !dbg !{{[0-9]+}}
+; CHECK: call void @llvm.dbg.value(metadata <4 x i32>* %a, metadata !{{[0-9]+}}, metadata {{.*}}, metadata <4 x i32>* undef, {{.*}}), !dbg !{{[0-9]+}}
+; CHECK: call void @llvm.dbg.value(metadata <4 x i32>* %b, metadata !{{[0-9]+}}, metadata {{.*}}, metadata <4 x i32>* undef, {{.*}}), !dbg !{{[0-9]+}}
+; CHECK: call void @llvm.dbg.value(metadata <4 x i32>* %c, metadata !{{[0-9]+}}, metadata {{.*}}, metadata <4 x i32>* undef, {{.*}}), !dbg !{{[0-9]+}}
 ; CHECK: %bval.i0 = load i32, i32* %b.i0, align 16, !dbg ![[TAG1:[0-9]+]], !tbaa ![[TAG2:[0-9]+]]
 ; CHECK: %bval.i1 = load i32, i32* %b.i1, align 4, !dbg ![[TAG1]], !tbaa ![[TAG2]]
 ; CHECK: %bval.i2 = load i32, i32* %b.i2, align 8, !dbg ![[TAG1]], !tbaa ![[TAG2]]
 ; CHECK: %bval.i3 = load i32, i32* %b.i3, align 4, !dbg ![[TAG1]], !tbaa ![[TAG2]]
 ; CHECK: %cval.i0 = load i32, i32* %c.i0, align 16, !dbg ![[TAG1]], !tbaa ![[TAG2]]
 ; CHECK: %cval.i1 = load i32, i32* %c.i1, align 4, !dbg ![[TAG1]], !tbaa ![[TAG2]]
 ; CHECK: %cval.i2 = load i32, i32* %c.i2, align 8, !dbg ![[TAG1]], !tbaa ![[TAG2]]
 ; CHECK: %cval.i3 = load i32, i32* %c.i3, align 4, !dbg ![[TAG1]], !tbaa ![[TAG2]]

llvm/test/Transforms/SimplifyCFG/X86/pr39187-g.ll

 ; CHECK-LABEL: entry
 ; CHECK:  %foo = alloca i32, align 4
 ; CHECK:  %face = alloca i8, align 1
 ; CHECK:  %foo.0..sroa_cast = bitcast i32* %foo to i8*
 ; CHECK:  store volatile i32 0, i32* %foo, align 4
 ; CHECK:  %foo.0. = load volatile i32, i32* %foo, align 4, !dbg !16
 ; CHECK:  %cmp = icmp eq i32 %foo.0., 4, !dbg !16
 ; CHECK:  %frombool = zext i1 %cmp to i8, !dbg !16
-; CHECK:  call void @llvm.dbg.value(metadata i8 %frombool, metadata !13, metadata !DIExpression()), !dbg !16
-; CHECK:  call void @llvm.dbg.value(metadata i32 0, metadata !15, metadata !DIExpression()), !dbg !17
+; CHECK:  call void @llvm.dbg.value(metadata i8 %frombool, metadata !13, metadata !DIExpression(), metadata i8 undef, metadata !DIExpression()), !dbg !16
+; CHECK:  call void @llvm.dbg.value(metadata i32 0, metadata !15, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !17
 ; CHECK:  %. = select i1 %cmp, i32 8, i32 4, !dbg ![[MERGEDLOC:[0-9]+]]
 ; CHECK:  ![[MERGEDLOC]] = !DILocation(line: 0, scope: !7)
 
 ; ModuleID = 'pr39187.cpp'
 source_filename = "pr39187.cpp"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 

llvm/test/Transforms/SimplifyCFG/speculate-dbgvalue.ll

 ; using
 ;   clang speculate-dbgvalue.c -S -emit-llvm -g -O3 -mllvm -disable-llvm-optzns -o - | opt -mem2reg -S
 
 
 ; Function Attrs: nounwind uwtable
 define i32 @test1(i32 %getdirt, i32 %dirt) #0 !dbg !7 {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[GETDIRT:%.*]], metadata !12, metadata !DIExpression()), !dbg !15
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[DIRT:%.*]], metadata !13, metadata !DIExpression()), !dbg !16
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 100, metadata !14, metadata !DIExpression()), !dbg !17
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[GETDIRT:%.*]], metadata !12, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !15
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[DIRT:%.*]], metadata !13, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !16
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 100, metadata !14, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !17
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[GETDIRT]], 0, !dbg !18
 ; *** We used to get an incorrect "call void @llvm.dbg.value(metadata i32 [[DIRT]], metadata !14, metadata !DIExpression()), !dbg !17" here, before the select. ***
 ; CHECK-NOT:     call void @llvm.dbg.value(metadata i32 [[DIRT]], metadata !14
 ; CHECK-NEXT:    [[RESULT:%.*]] = select i1 [[CMP]], i32 [[DIRT]], i32 100, !dbg !20
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[RESULT]], metadata !14, metadata !DIExpression()), !dbg !17
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[RESULT]], metadata !14, metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg !17
 ; CHECK-NEXT:    ret i32 [[RESULT]], !dbg !21
 ; CHECK: !12 = !DILocalVariable(name: "getdirt"
 ; CHECK: !13 = !DILocalVariable(name: "dirt"
 ; CHECK: !14 = !DILocalVariable(name: "result"
 ;
 entry:
   call void @llvm.dbg.value(metadata i32 %getdirt, metadata !12, metadata !DIExpression()), !dbg !15
   call void @llvm.dbg.value(metadata i32 %dirt, metadata !13, metadata !DIExpression()), !dbg !16

llvm/test/Transforms/Util/Debugify/loc-only.ll

 ; RUN: opt -debugify -S < %s | FileCheck --check-prefixes=ALL,VALUE %s
 ; RUN: opt -debugify -debugify-level=locations -S < %s | FileCheck --check-prefixes=ALL --implicit-check-not=dbg.value %s
 
 ; ALL-LABEL: @test
 define void @test() {
   %add = add i32 1, 2
 ; ALL-NEXT:  %add = add i32 1, 2, !dbg [[L1:![0-9]+]]
-; VALUE-NEXT: call void @llvm.dbg.value(metadata i32 %add, metadata [[add:![0-9]+]], metadata !DIExpression()), !dbg [[L1]]
+; VALUE-NEXT: call void @llvm.dbg.value(metadata i32 %add, metadata [[add:![0-9]+]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg [[L1]]
   %sub = sub i32 %add, 1
 ; ALL-NEXT: %sub = sub i32 %add, 1, !dbg [[L2:![0-9]+]]
-; VALUE-NEXT: call void @llvm.dbg.value(metadata i32 %sub, metadata [[sub:![0-9]+]], metadata !DIExpression()), !dbg [[L2]]
+; VALUE-NEXT: call void @llvm.dbg.value(metadata i32 %sub, metadata [[sub:![0-9]+]], metadata !DIExpression(), metadata i32 undef, metadata !DIExpression()), !dbg [[L2]]
 ; ALL-NEXT: ret void, !dbg [[L3:![0-9]+]]
   ret void
 }
 
 ; VALUE: [[add]] = !DILocalVariable
 ; VALUE: [[sub]] = !DILocalVariable
 
 ; ALL: [[L1]] = !DILocation(line: 1, column: 1, scope:
 ; ALL: [[L2]] = !DILocation(line: 2, column: 1, scope:
 ; ALL: [[L3]] = !DILocation(line: 3, column: 1, scope:

llvm/test/Transforms/Util/dbg-user-of-aext.ll

 ; * first starting at bit 0, 8 bits (for the bool)
 ; * second starting at bit 32, 32 bits (for the long)
 ; (this happens to create/demonstrate a gap from bits [7, 32))
 
 ; But also check that a complex expression is not used for a lone bool
 ; parameter. It can reference the register it's in directly without masking off
 ; high bits or anything
 
-; CHECK: call void @llvm.dbg.value(metadata i8 %g.coerce0, metadata ![[VAR_STRUCT:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 8))
-; CHECK: call void @llvm.dbg.value(metadata i64 %g.coerce1, metadata ![[VAR_STRUCT]], metadata !DIExpression(DW_OP_LLVM_fragment, 32, 64))
-; CHECK: call void @llvm.dbg.value(metadata i8 %frombool, metadata ![[VAR_BOOL:[0-9]+]], metadata !DIExpression())
-; CHECK: call void @llvm.dbg.value(metadata i8 %frombool1, metadata ![[VAR_FRAG:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 4))
+; CHECK: call void @llvm.dbg.value(metadata i8 %g.coerce0, metadata ![[VAR_STRUCT:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 8)
+; CHECK: call void @llvm.dbg.value(metadata i64 %g.coerce1, metadata ![[VAR_STRUCT]], metadata !DIExpression(DW_OP_LLVM_fragment, 32, 64)
+; CHECK: call void @llvm.dbg.value(metadata i8 %frombool, metadata ![[VAR_BOOL:[0-9]+]], metadata !DIExpression()
+; CHECK: call void @llvm.dbg.value(metadata i8 %frombool1, metadata ![[VAR_FRAG:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 4)
 
 %struct.foo = type { i8, i64 }
 
 ; Function Attrs: noinline nounwind uwtable
 define void @_Z1fbb3foo(i1 zeroext %b, i1 zeroext %frag, i8 %g.coerce0, i64 %g.coerce1) #0 !dbg !6 {
 entry:
   %g = alloca %struct.foo, align 8
   %b.addr = alloca i8, align 1

llvm/test/Verifier/diexpression-entry-value-llvm-ir.ll

 ; RUN: llvm-as -disable-output <%s 2>&1| FileCheck %s
 
 ; The DW_OP_LLVM_entry_value operation can only be used in MIR.
 
 ; CHECK: Entry values are only allowed in MIR
-; CHECK: call void @llvm.dbg.value(metadata i32 %param, metadata !{{.*}}, metadata !DIExpression(DW_OP_LLVM_entry_value, 1))
+; CHECK: call void @llvm.dbg.value(metadata i32 %param, metadata !{{.*}}, metadata !DIExpression(DW_OP_LLVM_entry_value, 1)
 ; CHECK: warning: ignoring invalid debug info
 
 define void @foo(i32 %param) !dbg !4 {
 entry:
   call void @llvm.dbg.value(metadata i32 %param, metadata !8, metadata !DIExpression(DW_OP_LLVM_entry_value, 1)), !dbg !9
   ret void
 }
 

llvm/test/Verifier/diexpression-valid-entry-value.ll

 ; RUN: opt -S < %s 2>&1 | FileCheck %s
 
-!named = !{!0}
+!named = !{!0, !1, !2}
 ; CHECK-NOT: invalid expression
 !0 = !DIExpression(DW_OP_LLVM_entry_value, 1)
+!1 = !DIExpression(DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 3, DW_OP_stack_value)
+!2 = !DIExpression(DW_OP_LLVM_entry_value, 1, DW_OP_constu, 9, DW_OP_minus, DW_OP_stack_value)

llvm/test/Verifier/llvm.dbg.intrinsic-dbg-attachment.ll

 ; CHECK-NEXT: void ()* @foo
 
   call void @llvm.dbg.value(
       metadata i8* undef,
       metadata !DILocalVariable(scope: !1),
       metadata !DIExpression()),
     !dbg !DILocation(scope: !2)
 ; CHECK-LABEL: mismatched subprogram between llvm.dbg.value variable and !dbg attachment
-; CHECK-NEXT: call void @llvm.dbg.value({{[^,]+}}, metadata ![[VAR:[0-9]+]], {{[^,]+}}), !dbg ![[LOC:[0-9]+]]
+; CHECK-NEXT: call void @llvm.dbg.value({{[^,]+}}, metadata ![[VAR:[0-9]+]], {{[^,]+}}, {{.*}}), !dbg ![[LOC:[0-9]+]]
 ; CHECK-NEXT: label %entry
 ; CHECK-NEXT: void ()* @foo
 ; CHECK-NEXT: ![[VAR]] = !DILocalVariable({{.*}}scope: ![[VARSP:[0-9]+]]
 ; CHECK-NEXT: ![[VARSP]] = distinct !DISubprogram(
 ; CHECK-NEXT: ![[LOC]] = !DILocation({{.*}}scope: ![[LOCSP:[0-9]+]]
 ; CHECK-NEXT: ![[LOCSP]] = distinct !DISubprogram(
 
   call void @llvm.dbg.declare(

llvm/unittests/IR/BasicBlockTest.cpp

TEST(BasicBlockTest, TestInstructionsWithoutDebug) {
   Argument *V = new Argument(Type::getInt32Ty(Ctx));
   Function *F = Function::Create(FT, Function::ExternalLinkage, "", M);
 
   Function *DbgAddr = Intrinsic::getDeclaration(M, Intrinsic::dbg_addr);
   Function *DbgDeclare = Intrinsic::getDeclaration(M, Intrinsic::dbg_declare);
   Function *DbgValue = Intrinsic::getDeclaration(M, Intrinsic::dbg_value);
   Value *DIV = MetadataAsValue::get(Ctx, (Metadata *)nullptr);
   SmallVector<Value *, 3> Args = {DIV, DIV, DIV};
+  SmallVector<Value *, 5> DbgValueArgs = {DIV, DIV, DIV, DIV, DIV};
 
   BasicBlock *BB1 = BasicBlock::Create(Ctx, "", F);
   const BasicBlock *BBConst = BB1;
   IRBuilder<> Builder1(BB1);
 
   AllocaInst *Var = Builder1.CreateAlloca(Builder1.getInt8Ty());
-  Builder1.CreateCall(DbgValue, Args);
+  Builder1.CreateCall(DbgValue, DbgValueArgs);
   Instruction *AddInst = cast<Instruction>(Builder1.CreateAdd(V, V));
   Instruction *MulInst = cast<Instruction>(Builder1.CreateMul(AddInst, V));
   Builder1.CreateCall(DbgDeclare, Args);
   Instruction *SubInst = cast<Instruction>(Builder1.CreateSub(MulInst, V));
   Builder1.CreateCall(DbgAddr, Args);
 
   SmallVector<Instruction *, 4> Exp = {Var, AddInst, MulInst, SubInst};
   CHECK_ITERATORS(BB1->instructionsWithoutDebug(), Exp);