Addressed review feedback:

1. Moved the salvage code to selectionDAG::salvageDebugInfo, this also
ensures that the old SDDbgValue is invalidated and removed.

Author: rastogishubham

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

@@ -14458,44 +14458,17 @@ static SDValue tryToFoldExtOfLoad(SelectionDAG &DAG, DAGCombiner &Combiner,
                                    LN0->getBasePtr(), N0.getValueType(),
                                    LN0->getMemOperand());
   Combiner.ExtendSetCCUses(SetCCs, N0, ExtLoad, ExtOpc);
-  unsigned Opcode = N->getOpcode();
-  bool IsSigned = Opcode == ISD::SIGN_EXTEND ? true : false;
+
   // If the load value is used only by N, replace it via CombineTo N.
   SDValue OldLoadVal(LN0, 0);
   SDValue OldExtValue(N, 0);
   bool NoReplaceTrunc = OldLoadVal.hasOneUse();
   Combiner.CombineTo(N, ExtLoad);
 
-  // Because we are replacing a load and a sext with a load-sext instruction,
-  // the dbg_value attached to the load will be of a smaller bit width, and we
-  // have to add a DW_OP_LLVM_fragment to the DIExpression.
-  auto SalvageToOldLoadSize = [&](SDValue From, SDValue To, bool IsSigned) {
-    for (SDDbgValue *Dbg : DAG.GetDbgValues(From.getNode())) {
-      unsigned VarBitsFrom = From->getValueSizeInBits(0);
-      unsigned VarBitsTo = To->getValueSizeInBits(0);
-
-      // Build a convert expression for the s|z extend.
-      const DIExpression *OldE = Dbg->getExpression();
-      SmallVector<uint64_t, 8> Ops;
-      dwarf::TypeKind TK =
-          IsSigned ? dwarf::DW_ATE_signed : dwarf::DW_ATE_unsigned;
-      Ops.append({dwarf::DW_OP_LLVM_convert, VarBitsFrom, TK,
-                  dwarf::DW_OP_LLVM_convert, VarBitsTo, TK});
-      auto *NewE = DIExpression::get(OldE->getContext(), Ops);
-
-      // // Create a new SDDbgValue that points at the widened node with the
-      // // fragment.
-      SDDbgValue *NewDV = DAG.getDbgValue(
-          Dbg->getVariable(), NewE, To.getNode(), To.getResNo(),
-          Dbg->isIndirect(), Dbg->getDebugLoc(), Dbg->getOrder());
-      DAG.AddDbgValue(NewDV, /*isParametet*/ false);
-    }
-  };
-
   if (NoReplaceTrunc) {
     if (LN0->getHasDebugValue()) {
       DAG.transferDbgValues(OldLoadVal, ExtLoad);
-      SalvageToOldLoadSize(OldLoadVal, ExtLoad, IsSigned);
+      DAG.salvageDebugInfo(*ExtLoad.getNode());
     }
     if (N->getHasDebugValue())
       DAG.transferDbgValues(OldExtValue, ExtLoad);
@@ -14506,7 +14479,7 @@ static SDValue tryToFoldExtOfLoad(SelectionDAG &DAG, DAGCombiner &Combiner,
         DAG.getNode(ISD::TRUNCATE, SDLoc(N0), N0.getValueType(), ExtLoad);
     if (LN0->getHasDebugValue()) {
       DAG.transferDbgValues(OldLoadVal, Trunc);
-      SalvageToOldLoadSize(OldLoadVal, Trunc, IsSigned);
+      DAG.salvageDebugInfo(*Trunc.getNode());
     }
     if (N->getHasDebugValue())
       DAG.transferDbgValues(OldExtValue, Trunc);

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

@@ -12123,6 +12123,46 @@ void SelectionDAG::salvageDebugInfo(SDNode &N) {
                  dbgs() << " into " << *DbgExpression << '\n');
       break;
     }
+    case ISD::LOAD: {
+      SDValue N0 = N.getOperand(0);
+      if (const LoadSDNode *LD = dyn_cast<LoadSDNode>(&N)) {
+
+        // Currently, this is written to only work for S|Z EXT.
+        if (LD->getExtensionType() == ISD::NON_EXTLOAD ||
+            LD->getExtensionType() == ISD::EXTLOAD)
+          break;
+
+        // Because we are replacing a load and a s|zext with a load-s|zext
+        // instruction, the dbg_value attached to the load will be of a smaller
+        // bit width, and we have to add a DW_OP_LLVM_fragment to the
+        // DIExpression.
+        unsigned VarBitsTo = LD->getValueSizeInBits(0);
+        unsigned VarBitsFrom = LD->getMemoryVT().getSizeInBits();
+        bool IsSigned = LD->getExtensionType() == ISD::SEXTLOAD;
+
+        // Build a convert expression for the s|z extend.
+        const DIExpression *OldE = DV->getExpression();
+        SmallVector<uint64_t, 8> Ops;
+        dwarf::TypeKind TK =
+            IsSigned ? dwarf::DW_ATE_signed : dwarf::DW_ATE_unsigned;
+        Ops.append({dwarf::DW_OP_LLVM_convert, VarBitsFrom, TK,
+                    dwarf::DW_OP_LLVM_convert, VarBitsTo, TK});
+        auto *NewE = DIExpression::get(OldE->getContext(), Ops);
+
+        // Create a new SDDbgValue that points at the widened node with the
+        // fragment.
+        SDDbgValue *NewDV =
+            getDbgValue(DV->getVariable(), NewE, &N, N0.getResNo(),
+                        DV->isIndirect(), DV->getDebugLoc(), DV->getOrder());
+        ClonedDVs.push_back(NewDV);
+        DV->setIsInvalidated();
+        DV->setIsEmitted();
+        LLVM_DEBUG(dbgs() << "SALVAGE: Rewriting";
+                   N0.getNode()->dumprFull(this);
+                   dbgs() << " into " << *NewE << '\n');
+        break;
+      }
+    }
     }
   }
 

llvm/test/DebugInfo/X86/selectionDAG-load-sext.ll

@@ -7,7 +7,6 @@
 ; MIR: ![[IDX:[0-9]+]] = !DILocalVariable(name: "Idx"
 ; MIR-LABEL: bb.0
 ; MIR: %{{[0-9a-f]+}}{{.*}} = MOVSX64rm32 ${{.*}}, 1, $noreg, @GlobArr, $noreg, debug-instr-number [[INSTR_NUM:[0-9]+]]
-; MIR-NEXT: DBG_INSTR_REF ![[IDX]], !DIExpression(DW_OP_LLVM_arg, 0), dbg-instr-ref([[INSTR_NUM]], 0)
 ; MIR-NEXT: DBG_INSTR_REF ![[IDX]], !DIExpression(DW_OP_LLVM_arg, 0,  DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_LLVM_convert, 64, DW_ATE_signed), dbg-instr-ref([[INSTR_NUM]], 0)
 
 ; DUMP: DW_AT_location	(indexed ({{[0-9a-f]+}}x{{[0-9a-f]+}}) loclist = 0x{{[0-9]+}}: