[Salvage] Change salvage debug info implementation to use new DW_OP_LLVM_convert where needed

[StephenTozer]

Summary

Fixes issue: https://bugs.llvm.org/show_bug.cgi?id=40645

Previously, LLVM had no functional way of performing casts inside of a DIExpression(), which made salvaging cast instructions other than Noop casts impossible. With the recent addition of DW_OP_LLVM_convert this salvaging is now possible, and so can be used to fix the attached bug as well as any cases where SExt instruction results are lost in the debugging metadata. This patch introduces this fix by expanding the salvage debug info method to cover these cases using the new operator.

[dstenb]

llvm/lib/Transforms/Utils/Local.cpp

1693

There is a early bail-out for ZExtInst above:

if (CI->isNoopCast(DL) || isa<ZExtInst>(&I))
  return SrcDIExpr;

so that condition in this if statement appears to be dead code as it is now.

I assume that we no longer should bail out for zexts (?).

[StephenTozer]

As per the previous comment, ZExt is equivalent to a Noop on the DWARF expression stack, so can be caught by the same early exit.

[markus]

Have you verified that this results in the desired DW_OPs being emitted in the end and that the (or a) debugger makes sense out of it?

Since the expression stack is a bit sloppy about types it defaults to the generic type (size of address on the target machine), so without having previously set the type to something else a single DW_OP_LLVM_convert does not mean much. This is the reason that llvm::replaceAllDbgUsesWith in lib/Transforms/Utils/Local.cpp inserts a pair (the first one is simply used to set the type of the current stack element and the second one performs the actual conversion).

For now inserting a pair would probably be the easiest way forward. A bit prettier would be to introduce a DW_OP_LLVM_reinterpret op to do that job. Longer term it would be helpful if all values had a specified type immediately when they are put on the stack.

[dstenb]

llvm/lib/Transforms/Utils/Local.cpp

1693

Also, perhaps this should be inverted to an early exit instead?

[markus]

In D61184#1480359, @markus wrote:

A bit prettier would be to introduce a DW_OP_LLVM_reinterpret op to do that job.

I am preparing a patch for that right now. Regardless of this review it should make the existing DW_OP_LLVM_convert stuff a bit cleaner.

[markus]

In D61184#1481992, @markus wrote:

In D61184#1480359, @markus wrote:

A bit prettier would be to introduce a DW_OP_LLVM_reinterpret op to do that job.

I am preparing a patch for that right now. Regardless of this review it should make the existing DW_OP_LLVM_convert stuff a bit cleaner.

Actually forget all I said about DW_OP_reinterpret, it turns out that I did not read the spec properly and did not pay attention to the last sentence saying that: The type of the operand and result type must have the same size in bits.

So clearly it cannot be used like I suggested.

What I said about using two DW_OP_LLVM_convert in sequence still holds though.

[StephenTozer]

Updated to use convert OP correctly as suggested by markus.

[aprantl]

llvm/lib/Transforms/Utils/Local.cpp

1707

clang-format?

[StephenTozer]

Remove incorrectly included lines.

[markus]

The DW_OP_LLVM_convert stuff looks-good-to-me but I don't feel that I have authority to approve for the rest so please don't wait for any input from my part.

[probinson]

llvm/lib/Transforms/Utils/Local.cpp

1690

Looks to me like this 'if' does more than check for vectors?

[StephenTozer]

Update comment

[probinson]

LGTM after you add the full-stop noted below.

llvm/lib/Transforms/Utils/Local.cpp

1690

Needs a full-stop at the end of the sentence.

[mstorsjo]

This broke compilation of libtiff for arm, see https://bugs.llvm.org/show_bug.cgi?id=41931 for details.

[djtodoro]

Thanks for working on this, it seems very useful! Any updates?

[StephenTozer]

Reopening, as the merged patch caused a regression issue and needed to be reverted; this update should fix said regression issue.

[aprantl]

What was the fix for the regression and is it also tested?

[StephenTozer]

The regression issue is documented in the bug above: https://bugs.llvm.org/show_bug.cgi?id=41931
The main issue can be summarised briefly as "splitting a fragment DIExpression across multiple registers is currently broken", which is what I've submitted a fix for (see comments in SelectionDAGBuilder.cpp); the test for the new behaviour is in fragmented-args-multiple-regs.ll

[djtodoro]

Thanks for this (a few comments added).

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

5611

I guess this is unwanted.

llvm/test/CodeGen/ARM/fragmented-args-multiple-regs.ll

35

We can delete this.

36

And this as well.

42

We can also update the version to 10.0.0.

49

Here as well.

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

22

Here as well.

[djtodoro]

Looks like this was accepted (with minor nitpicks) long time ago. Please let us know if you have any obstacle to commit it.

[aprantl]

llvm/lib/IR/DebugInfoMetadata.cpp

1154

Should this be a separate commit? This seems unrelated to the SDag change?

llvm/test/CodeGen/ARM/fragmented-args-multiple-regs.ll

36

Still needs to happen.

[djtodoro]

llvm/lib/IR/DebugInfoMetadata.cpp

1154

I think as well. This needs to be different patch.

[StephenTozer]

llvm/lib/IR/DebugInfoMetadata.cpp

1154

I'm currently investigating whether this is necessary for the bug fix or not - in this case, immediately prior to CodeGen we have the variable i64 %j, which represents two source variables:

define dso_local i32 @h(i64 %j) local_unnamed_addr #0 !dbg !8 {
entry:
  call void @llvm.dbg.value(metadata i64 %j, metadata !14, metadata !DIExpression()), !dbg !29
  call void @llvm.dbg.value(metadata i64 %j, metadata !15, metadata !DIExpression(DW_OP_LLVM_convert, 64, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_unsigned, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 32)), !dbg !29
  call void @llvm.dbg.value(metadata i64 %j, metadata !15, metadata !DIExpression(DW_OP_constu, 32, DW_OP_shr, DW_OP_LLVM_convert, 64, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_unsigned, DW_OP_stack_value, DW_OP_LLVM_fragment, 32, 32)), !dbg !29

At the ISel stage, the target architecture requires the i64 variable to be split across two 32 bit registers. We now have two 32 bit registers (one "low", one "high") which map exactly to two 32 bit source variables, but due to the previous transforms the finalized MIR looks like:

%1:gpr = COPY $r1
DBG_VALUE %1, $noreg, !14, !DIExpression(DW_OP_LLVM_fragment, 32, 32), debug-location !29
%0:gpr = COPY $r0
DBG_VALUE %0, $noreg, !14, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !29
DBG_VALUE %0, $noreg, !15, !DIExpression(DW_OP_LLVM_convert, 64, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_unsigned, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 32), debug-location !29
DBG_VALUE %0, $noreg, !15, !DIExpression(DW_OP_constu, 32, DW_OP_shr, DW_OP_LLVM_convert, 64, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_unsigned, DW_OP_stack_value, DW_OP_LLVM_fragment, 32, 32), debug-location !29

As you can see the 32 bit DW_OP_shr is now being applied to the low 32 bit register in order to get the value in the high register, which won't work. Any operation which expects any kind of "carry over" will fail in the same way when a DBG_VALUE is split. I'm currently looking into whether there's a better way to specifically handle shift operations, since adding DW_OP_shr here still results in a variable being set as "undef" when it could potentially be recoverable.

[aprantl]

llvm/lib/IR/DebugInfoMetadata.cpp

1154

I'm not opposed to supporting shr here, I just think it should be a separately tested patch that can land in preparation of this one.

[djtodoro]

I think this one is almost (with the comments addressed) ready to go, but I think that the D70248 is preparation for this one? Should we create a stack of patches for those two patches?

If D70498 is landed, please make sure to use the API here.

[StephenTozer]

Rebased and updated for latest master, fixed clang version and unused attributes in tests.

[vsk]

This seems to be in good shape overall and the SelectionDAG changes look reasonable. I don't intend my comments here to block committing.

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

26

This looks like it would have matched before this patch. Consider ; CHECK: @llvm.dbg.value(metadata i32 %{{.*}},?

llvm/test/Transforms/InstCombine/pr43893.ll

16

I'm not sure I understand this change. Why is the dbg.value for %conv deleted?

[djtodoro]

Please address my comments and try using the DIExpression::appendExt(). Thanks.

[djtodoro]

llvm/lib/Transforms/Utils/Local.cpp

1705

More precisely, the DIExpression::appendExt() should be used here.

[StephenTozer]

llvm/test/Transforms/InstCombine/pr43893.ll

16

The purpose of this test as stated in the comment at the top was to check that, when the trivially deletable %conv was deleted, metadata that depended on it was set to undef. Reading that comment it seemed that the important component of the test wasn't the existence of the dbg.value itself, but confirming that it would be set undef rather than being given an incorrect value. As of this patch however, %conv can be salvaged, which seems to defeat the point of the test. As %udiv cannot be salvaged, it seemed like an appropriate stand-in.

[StephenTozer]

Use shared functionality for zero/sign extension ops, fix tests

[vsk]

llvm/test/Transforms/InstCombine/pr43893.ll

16

Ah, got it, sgtm.

[StephenTozer]

@djtodoro Does this latest change look good to you?

Since the only other outstanding comments were not intended to block committing, if this is considered resolved and there are no further comments I'll consider this implicitly LGTM'd; although an explicit response as of the latest changes would be preferred.

[djtodoro]

LGTM, thanks!

[djtodoro]

Sorry, one more nit included.

llvm/include/llvm/IR/DebugInfoMetadata.h

2556

Have you considered using the using for declaration of the std::array<uint64_t, 6 return type?

[StephenTozer]

Format, addressing review comments

[djtodoro]

Looks good to me! Thanks!

[StephenTozer]

Merged in commit: llvmorg-10-init-12272-g89d19d60adb9

llvm/include/llvm/IR/DebugInfoMetadata.h

static int fragmentCmp(const FragmentInfo &A, const FragmentInfo &B) {
     if (r1 <= l2)
       return -1;
     else if (r2 <= l1)
       return 1;
     else
       return 0;
   }
 
+  using ExtOps = std::array<uint64_t, 6>;
+
+  /// Returns the ops for a zero- or sign-extension in a DIExpression.
+  static ExtOps getExtOps(unsigned FromSize, unsigned ToSize, bool Signed);
+
   /// Append a zero- or sign-extension to \p Expr. Converts the expression to a
   /// stack value if it isn't one already.
   static DIExpression *appendExt(const DIExpression *Expr, unsigned FromSize,
                                  unsigned ToSize, bool Signed);
 
   /// Check if fragments overlap between a pair of FragmentInfos.
   static bool fragmentsOverlap(const FragmentInfo &A, const FragmentInfo &B) {
     return fragmentCmp(A, B) == 0;

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

bool SelectionDAGBuilder::EmitFuncArgumentDbgValue(
   }
 
   if (!Op) {
     // Create a DBG_VALUE for each decomposed value in ArgRegs to cover Reg
     auto splitMultiRegDbgValue
       = [&](ArrayRef<std::pair<unsigned, unsigned>> SplitRegs) {
       unsigned Offset = 0;
       for (auto RegAndSize : SplitRegs) {
+        // If the expression is already a fragment, the current register
+        // offset+size might extend beyond the fragment. In this case, only
+        // the register bits that are inside the fragment are relevant.
+        int RegFragmentSizeInBits = RegAndSize.second;
+        if (auto ExprFragmentInfo = Expr->getFragmentInfo()) {
+          uint64_t ExprFragmentSizeInBits = ExprFragmentInfo->SizeInBits;
+          // The register is entirely outside the expression fragment,
+          // so is irrelevant for debug info.
+          if (Offset >= ExprFragmentSizeInBits)
+            break;
+          // The register is partially outside the expression fragment, only
+          // the low bits within the fragment are relevant for debug info.
+          if (Offset + RegFragmentSizeInBits > ExprFragmentSizeInBits) {
+            RegFragmentSizeInBits = ExprFragmentSizeInBits - Offset;
+          }
+        }
+
         auto FragmentExpr = DIExpression::createFragmentExpression(
-          Expr, Offset, RegAndSize.second);
+            Expr, Offset, RegFragmentSizeInBits);
+        Offset += RegAndSize.second;
         // If a valid fragment expression cannot be created, the variable's
         // correct value cannot be determined and so it is set as Undef.
         if (!FragmentExpr) {
           SDDbgValue *SDV = DAG.getConstantDbgValue(
               Variable, Expr, UndefValue::get(V->getType()), DL, SDNodeOrder);
           DAG.AddDbgValue(SDV, nullptr, false);
           continue;
         }
         assert(!IsDbgDeclare && "DbgDeclare operand is not in memory?");
         FuncInfo.ArgDbgValues.push_back(
           BuildMI(MF, DL, TII->get(TargetOpcode::DBG_VALUE), false,
                   RegAndSize.first, Variable, *FragmentExpr));
-        Offset += RegAndSize.second;
       }
     };
 
     // Check if ValueMap has reg number.
     DenseMap<const Value *, unsigned>::const_iterator
       VMI = FuncInfo.ValueMap.find(V);
     if (VMI != FuncInfo.ValueMap.end()) {
       const auto &TLI = DAG.getTargetLoweringInfo();
if (VMI != FuncInfo.ValueMap.end()) {
       splitMultiRegDbgValue(ArgRegsAndSizes);
       return true;
     }
   }
 
   if (!Op)
     return false;
 
   assert(Variable->isValidLocationForIntrinsic(DL) &&
          "Expected inlined-at fields to agree");
 
   // If the argument arrives in a stack slot, then what the IR thought was a
   // normal Value is actually in memory, and we must add a deref to load it.
   if (Op->isFI()) {
     int FI = Op->getIndex();
     unsigned Size = DAG.getMachineFunction().getFrameInfo().getObjectSize(FI);
     if (Expr->isImplicit()) {

llvm/lib/IR/DebugInfoMetadata.cpp

 Optional<DIExpression *> DIExpression::createFragmentExpression(
     const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits) {
   SmallVector<uint64_t, 8> Ops;
   // Copy over the expression, but leave off any trailing DW_OP_LLVM_fragment.
   if (Expr) {
     for (auto Op : Expr->expr_ops()) {
       switch (Op.getOp()) {
       default: break;
       case dwarf::DW_OP_shr:
       case dwarf::DW_OP_shra:
       case dwarf::DW_OP_shl:
       case dwarf::DW_OP_plus:
       case dwarf::DW_OP_plus_uconst:
       case dwarf::DW_OP_minus:
         // We can't safely split arithmetic or shift operations into multiple
         // fragments because we can't express carry-over between fragments.
         //
bool DIExpression::isConstant() const {
   if (getElement(0) != dwarf::DW_OP_constu ||
       getElement(2) != dwarf::DW_OP_stack_value)
     return false;
   if (getNumElements() == 6 && getElement(3) != dwarf::DW_OP_LLVM_fragment)
     return false;
   return true;
 }
 
+DIExpression::ExtOps DIExpression::getExtOps(unsigned FromSize, unsigned ToSize,
+                                             bool Signed) {
+  dwarf::TypeKind TK = Signed ? dwarf::DW_ATE_signed : dwarf::DW_ATE_unsigned;
+  DIExpression::ExtOps Ops({dwarf::DW_OP_LLVM_convert, FromSize, TK,
+                            dwarf::DW_OP_LLVM_convert, ToSize, TK});
+  return Ops;
+}
+
 DIExpression *DIExpression::appendExt(const DIExpression *Expr,
                                       unsigned FromSize, unsigned ToSize,
                                       bool Signed) {
-  dwarf::TypeKind TK = Signed ? dwarf::DW_ATE_signed : dwarf::DW_ATE_unsigned;
-  uint64_t Ops[] = {dwarf::DW_OP_LLVM_convert, FromSize, TK,
-                    dwarf::DW_OP_LLVM_convert, ToSize,   TK};
-  return appendToStack(Expr, Ops);
+  return appendToStack(Expr, getExtOps(FromSize, ToSize, Signed));
 }
 
 DIGlobalVariableExpression *
 DIGlobalVariableExpression::getImpl(LLVMContext &Context, Metadata *Variable,
                                     Metadata *Expression, StorageType Storage,
                                     bool ShouldCreate) {
   DEFINE_GETIMPL_LOOKUP(DIGlobalVariableExpression, (Variable, Expression));
   Metadata *Ops[] = {Variable, Expression};

llvm/lib/Transforms/Utils/Local.cpp

DIExpression *llvm::salvageDebugInfoImpl(Instruction &I,
   // Apply the given offset to the source DIExpression.
   auto applyOffset = [&](uint64_t Offset) -> DIExpression * {
     SmallVector<uint64_t, 8> Ops;
     DIExpression::appendOffset(Ops, Offset);
     return doSalvage(Ops);
   };
 
   // initializer-list helper for applying operators to the source DIExpression.
-  auto applyOps =
-      [&](std::initializer_list<uint64_t> Opcodes) -> DIExpression * {
-    SmallVector<uint64_t, 8> Ops(Opcodes);
+  auto applyOps = [&](ArrayRef<uint64_t> Opcodes) -> DIExpression * {
+    SmallVector<uint64_t, 8> Ops(Opcodes.begin(), Opcodes.end());
     return doSalvage(Ops);
   };
 
   if (auto *CI = dyn_cast<CastInst>(&I)) {
     // No-op casts and zexts are irrelevant for debug info.
     if (CI->isNoopCast(DL) || isa<ZExtInst>(&I))
       return SrcDIExpr;
+
+    Type *Type = CI->getType();
+    // Casts other than Trunc or SExt to scalar types cannot be salvaged.
+    if (Type->isVectorTy() || (!isa<TruncInst>(&I) && !isa<SExtInst>(&I)))
       return nullptr;
-  } else if (auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
+
+    Value *FromValue = CI->getOperand(0);
+    unsigned FromTypeBitSize = FromValue->getType()->getScalarSizeInBits();
+    unsigned ToTypeBitSize = Type->getScalarSizeInBits();
+
+    return applyOps(DIExpression::getExtOps(FromTypeBitSize, ToTypeBitSize,
+                                            isa<SExtInst>(&I)));
+  }
+
+  if (auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
     unsigned BitWidth =
         M.getDataLayout().getIndexSizeInBits(GEP->getPointerAddressSpace());
     // Rewrite a constant GEP into a DIExpression.
     APInt Offset(BitWidth, 0);
     if (GEP->accumulateConstantOffset(M.getDataLayout(), Offset)) {
       return applyOffset(Offset.getSExtValue());
     } else {
       return nullptr;
     }
   } else if (auto *BI = dyn_cast<BinaryOperator>(&I)) {
     // Rewrite binary operations with constant integer operands.
     auto *ConstInt = dyn_cast<ConstantInt>(I.getOperand(1));
     if (!ConstInt || ConstInt->getBitWidth() > 64)

llvm/test/CodeGen/ARM/fragmented-args-multiple-regs.ll

+; RUN: llc < %s -mtriple=armv7-linux-gnueabihf -O1 -stop-after=finalize-isel | FileCheck %s
+
+define dso_local i32 @h(i64 %j) local_unnamed_addr !dbg !8 {
+entry:
+  call void @llvm.dbg.value(metadata i64 %j, metadata !14, metadata !DIExpression()), !dbg !29
+  call void @llvm.dbg.value(metadata i64 %j, metadata !15, metadata !DIExpression(DW_OP_LLVM_convert, 64, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_unsigned, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 32)), !dbg !29
+  call void @llvm.dbg.value(metadata i64 %j, metadata !15, metadata !DIExpression(DW_OP_constu, 32, DW_OP_shr, DW_OP_LLVM_convert, 64, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_unsigned, DW_OP_stack_value, DW_OP_LLVM_fragment, 32, 32)), !dbg !29
+  %tobool = icmp ult i64 %j, 4294967296, !dbg !30
+  br i1 %tobool, label %cleanup, label %if.then, !dbg !31
+
+if.then:                                          ; preds = %entry
+  call void @llvm.dbg.value(metadata i64 %j, metadata !15, metadata !DIExpression(DW_OP_LLVM_convert, 64, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_unsigned, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 32)), !dbg !29
+  %conv = sitofp i64 %j to double, !dbg !32
+  %add = fadd double %conv, 0x43F0000000000000, !dbg !33
+  call void @llvm.dbg.value(metadata double %add, metadata !25, metadata !DIExpression()), !dbg !34
+  %conv2 = fptosi double %add to i32, !dbg !35
+  br label %cleanup
+
+cleanup:                                          ; preds = %entry, %if.then
+  %retval.0 = phi i32 [ %conv2, %if.then ], [ undef, %entry ]
+  ret i32 %retval.0, !dbg !36
+}
+
+; CHECK-LABEL: bb.0.entry:
+; CHECK: DBG_VALUE [[REG1:%[0-9]+]], $noreg, !14, !DIExpression(DW_OP_LLVM_fragment, 32, 32
+; CHECK: DBG_VALUE [[REG2:%[0-9]+]], $noreg, !14, !DIExpression(DW_OP_LLVM_fragment, 0, 32
+; CHECK: DBG_VALUE [[REG2]], $noreg, !15, !DIExpression({{.+}}DW_OP_LLVM_fragment, 0, 32
+; CHECK: DBG_VALUE $noreg, $noreg, !15, !DIExpression({{.+}}DW_OP_LLVM_fragment, 32, 32
+
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5, !6}
+!llvm.ident = !{!7}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 10.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
+!1 = !DIFile(filename: "tif_aux.c", directory: "/tmp")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{i32 1, !"min_enum_size", i32 4}
+!7 = !{!"clang version 10.0.0 "}
+!8 = distinct !DISubprogram(name: "h", scope: !1, file: !1, line: 10, type: !9, scopeLine: 10, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !13)
+!9 = !DISubroutineType(types: !10)
+!10 = !{!11, !12}
+!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!12 = !DIBasicType(name: "long long int", size: 64, encoding: DW_ATE_signed)
+!13 = !{!14, !15, !25}
+!14 = !DILocalVariable(name: "j", arg: 1, scope: !8, file: !1, line: 10, type: !12)
+!15 = !DILocalVariable(name: "i", scope: !8, file: !1, line: 11, type: !16)
+!16 = !DIDerivedType(tag: DW_TAG_typedef, name: "g", file: !1, line: 8, baseType: !17)
+!17 = distinct !DICompositeType(tag: DW_TAG_union_type, file: !1, line: 5, size: 64, elements: !18)
+!18 = !{!19, !24}
+!19 = !DIDerivedType(tag: DW_TAG_member, name: "e", scope: !17, file: !1, line: 6, baseType: !20, size: 64)
+!20 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "b", file: !1, line: 1, size: 64, elements: !21)
+!21 = !{!22, !23}
+!22 = !DIDerivedType(tag: DW_TAG_member, name: "c", scope: !20, file: !1, line: 2, baseType: !11, size: 32)
+!23 = !DIDerivedType(tag: DW_TAG_member, name: "d", scope: !20, file: !1, line: 2, baseType: !11, size: 32, offset: 32)
+!24 = !DIDerivedType(tag: DW_TAG_member, name: "f", scope: !17, file: !1, line: 7, baseType: !12, size: 64)
+!25 = !DILocalVariable(name: "a", scope: !26, file: !1, line: 14, type: !28)
+!26 = distinct !DILexicalBlock(scope: !27, file: !1, line: 13, column: 14)
+!27 = distinct !DILexicalBlock(scope: !8, file: !1, line: 13, column: 7)
+!28 = !DIBasicType(name: "double", size: 64, encoding: DW_ATE_float)
+!29 = !DILocation(line: 0, scope: !8)
+!30 = !DILocation(line: 13, column: 7, scope: !27)
+!31 = !DILocation(line: 13, column: 7, scope: !8)
+!32 = !DILocation(line: 14, column: 16, scope: !26)
+!33 = !DILocation(line: 14, column: 20, scope: !26)
+!34 = !DILocation(line: 0, scope: !26)
+!35 = !DILocation(line: 15, column: 12, scope: !26)
+!36 = !DILocation(line: 17, column: 1, scope: !8)

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 ![[BEE:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)),
-; CHECK: @llvm.dbg.value(metadata i32 undef, 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:
   %bumble.sroa.0.0.extract.trunc = trunc i64 %bumble.coerce to i32

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

+; RUN: opt %s -debugify -early-cse -S | FileCheck %s
+define i32 @foo(i64 %nose, i32 %more) {
+; CHECK-LABEL: @foo(
+; CHECK: call void @llvm.dbg.value(metadata i64 %nose, metadata [[V1:![0-9]+]], metadata !DIExpression(DW_OP_LLVM_convert, 64, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_unsigned
+; CHECK: call void @llvm.dbg.value(metadata i64 %nose.shift, metadata [[V2:![0-9]+]]
+; CHECK: call void @llvm.dbg.value(metadata i64 %nose.shift, metadata [[V3:![0-9]+]], metadata !DIExpression(DW_OP_LLVM_convert, 64, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_unsigned
+
+entry:
+  %nose.trunc = trunc i64 %nose to i32
+  %nose.shift = lshr i64 %nose, 32
+  %nose.trunc.2 = trunc i64 %nose.shift to i32
+  %add = add nsw i32 %more, 1
+  ret i32 %add
+}
+
+!llvm.module.flags = !{!0, !1}
+!llvm.ident = !{!2}
+
+!0 = !{i32 1, !"wchar_size", i32 2}
+!1 = !{i32 7, !"PIC Level", i32 2}
+!2 = !{!"clang version 10.0.0 "}
+
+; CHECK: [[V1]] = !DILocalVariable(
+; CHECK: [[V2]] = !DILocalVariable(
+; CHECK: [[V3]] = !DILocalVariable(

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 i16 undef, metadata !17, metadata !DIExpression()), !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)), !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/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 i8 undef
-; DBGINFO-NEXT:    call void @llvm.dbg.value(metadata i8 undef
+; DBGINFO-NEXT:    call void @llvm.dbg.value(metadata i32 %x
+; DBGINFO-NEXT:    call void @llvm.dbg.value(metadata i32 %y
 ; 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

llvm/test/Transforms/InstCombine/pr43893.ll

 ; Check for setting dbg.value as undef which depends on trivially dead instructions.
 ; RUN: opt -instcombine -S -o - %s | FileCheck %s
 
 @a = common dso_local global i8 0, align 1, !dbg !0
 @b = common dso_local global i8 0, align 1, !dbg !6
 
 define dso_local i32 @main() !dbg !13 {
 entry:
   %0 = load i8, i8* @a, align 1, !dbg !17
   %dec = add i8 %0, -1, !dbg !17
   store i8 %dec, i8* @a, align 1, !dbg !17
 ;CHECK: call void @llvm.dbg.value(metadata i32 undef
 ;CHECK: call void @llvm.dbg.value(metadata i32 -8
 ;CHECK: call void @llvm.dbg.value(metadata i32 undef
   %conv = sext i8 %dec to i32, !dbg !17
-  call void @llvm.dbg.value(metadata i32 %conv, metadata !18, metadata !DIExpression()), !dbg !19
+  %udiv = udiv i32 %conv, 4, !dbg !17
+  call void @llvm.dbg.value(metadata i32 %udiv, metadata !18, metadata !DIExpression()), !dbg !19
   call void @llvm.dbg.value(metadata i32 -8, metadata !20, metadata !DIExpression()), !dbg !19
-  call void @llvm.dbg.value(metadata i32 %conv, metadata !20, metadata !DIExpression()), !dbg !19
+  call void @llvm.dbg.value(metadata i32 %udiv, metadata !20, metadata !DIExpression()), !dbg !19
   store i8 0, i8* @b, align 1, !dbg !21
   %cmp = icmp sgt i32 %conv, 0, !dbg !22
   %conv1 = zext i1 %cmp to i32, !dbg !22
   ret i32 0, !dbg !23
 }
 
 declare void @llvm.dbg.value(metadata, metadata, metadata) 
 

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 i32 undef, metadata !30, metadata !DIExpression()), !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)), !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