[llvm] [SelectionDAG] Reland debuginfo salvage for load/ext combines (PR #194700)
Shubham Sandeep Rastogi via llvm-commits
llvm-commits at lists.llvm.org
Tue Apr 28 11:46:18 PDT 2026
https://github.com/rastogishubham updated https://github.com/llvm/llvm-project/pull/194700
>From 71cc12be0608a12bf43f116d00f796de533cb021 Mon Sep 17 00:00:00 2001
From: Shubham Sandeep Rastogi <Shubham.Rastogi at sony.com>
Date: Tue, 28 Apr 2026 10:28:37 -0700
Subject: [PATCH 1/2] Reapply "[SelectionDAG] Salvage debuginfo when combining
load and z|s ext instrs. (#188544)" (#193554)
This reverts commit 91fe498ccc31ca2ac3cfe9d83bd8c9e22be3b566.
---
llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp | 92 ++++++++++++++++++-
.../DebugInfo/X86/sdag-load-sext-trunc.ll | 70 ++++++++++++++
llvm/test/DebugInfo/X86/sdag-load-sext.ll | 61 ++++++++++++
.../X86/sdag-load-zext-multiple-args.ll | 48 ++++++++++
4 files changed, 268 insertions(+), 3 deletions(-)
create mode 100644 llvm/test/DebugInfo/X86/sdag-load-sext-trunc.ll
create mode 100644 llvm/test/DebugInfo/X86/sdag-load-sext.ll
create mode 100644 llvm/test/DebugInfo/X86/sdag-load-zext-multiple-args.ll
diff --git a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
index 302393ffbe036..52b04f7b13cbe 100644
--- a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
@@ -52,6 +52,7 @@
#include "llvm/IR/Attributes.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/Metadata.h"
@@ -79,6 +80,7 @@
#include <variant>
#include "MatchContext.h"
+#include "SDNodeDbgValue.h"
using namespace llvm;
using namespace llvm::SDPatternMatch;
@@ -14987,6 +14989,7 @@ static SDValue tryToFoldExtOfLoad(SelectionDAG &DAG, DAGCombiner &Combiner,
ISD::LoadExtType ExtLoadType,
ISD::NodeType ExtOpc,
bool NonNegZExt = false) {
+
bool Frozen = N0.getOpcode() == ISD::FREEZE;
SDValue Freeze = Frozen ? N0 : SDValue();
auto *Load = dyn_cast<LoadSDNode>(Frozen ? N0.getOperand(0) : N0);
@@ -15030,8 +15033,80 @@ static SDValue tryToFoldExtOfLoad(SelectionDAG &DAG, DAGCombiner &Combiner,
return {};
SDLoc DL(Load);
- // If the load value is used only by N, replace it via CombineTo N.
- bool NoReplaceTrunc = N0.hasOneUse();
+
+ auto SalvageDbgValue = [&](SDDbgValue *Dbg, SDValue Old, SDValue New,
+ unsigned OldBits, unsigned NewBits,
+ bool IsSigned) {
+ SmallVector<SDDbgOperand> Locs = Dbg->copyLocationOps();
+ bool Changed = false;
+
+ bool IsVariadic = Dbg->isVariadic();
+ SmallVector<unsigned, 2> AffectedArgs;
+
+ for (unsigned I = 0, E = Locs.size(); I != E; ++I) {
+ SDDbgOperand &Op = Locs[I];
+ if (Op.getKind() != SDDbgOperand::SDNODE)
+ continue;
+
+ if (Op.getSDNode() == Old.getNode() && Op.getResNo() == Old.getResNo()) {
+ Op = SDDbgOperand::fromNode(New.getNode(), New.getResNo());
+ Changed = true;
+
+ if (IsVariadic)
+ AffectedArgs.push_back(I);
+ }
+ }
+
+ if (!Changed)
+ return;
+
+ const DIExpression *OldExpr = Dbg->getExpression();
+ const DIExpression *NewExpr = nullptr;
+
+ if (!IsVariadic) {
+ // Do not introduce DW_OP_LLVM_arg into ordinary single-location
+ // DBG_VALUEs.
+ NewExpr = DIExpression::appendExt(OldExpr, NewBits, OldBits, IsSigned);
+ } else {
+ auto ExtOps = DIExpression::getExtOps(NewBits, OldBits, IsSigned);
+
+ NewExpr = DIExpression::convertToVariadicExpression(OldExpr);
+
+ for (unsigned ArgNo : AffectedArgs)
+ NewExpr = DIExpression::appendOpsToArg(NewExpr, ExtOps, ArgNo,
+ /*StackValue=*/false);
+ }
+
+ SDDbgValue *NewDV = DAG.getDbgValueList(
+ Dbg->getVariable(), const_cast<DIExpression *>(NewExpr), Locs,
+ Dbg->getAdditionalDependencies(), Dbg->isIndirect(), Dbg->getDebugLoc(),
+ Dbg->getOrder(), Dbg->isVariadic());
+
+ Dbg->setIsInvalidated();
+ Dbg->setIsEmitted();
+ DAG.AddDbgValue(NewDV, /*isParameter=*/false);
+ };
+
+ // Because we are replacing a load and a s|z ext with a load-s|z ext
+ // instruction, the dbg_value attached to the load will be of a smaller bit
+ // width, and we have to add a DW_OP_LLVM_convert expression to get the
+ // correct size.
+ auto SalvageToOldLoadSize = [&](SDValue Old, SDValue New, bool IsSigned) {
+ SmallVector<SDDbgValue *, 4> DbgVals(
+ DAG.GetDbgValues(Old.getNode()).begin(),
+ DAG.GetDbgValues(Old.getNode()).end());
+
+ unsigned VarBitsOld = Old.getValueSizeInBits();
+ unsigned VarBitsNew = New.getValueSizeInBits();
+
+ for (SDDbgValue *Dbg : DbgVals) {
+ if (Dbg->isInvalidated())
+ continue;
+
+ SalvageDbgValue(Dbg, Old, New, VarBitsOld, VarBitsNew, IsSigned);
+ }
+ };
+
SDValue ExtLoad =
DAG.getExtLoad(ExtLoadType, DL, VT, Load->getChain(), Load->getBasePtr(),
Load->getValueType(0), Load->getMemOperand());
@@ -15044,8 +15119,18 @@ static SDValue tryToFoldExtOfLoad(SelectionDAG &DAG, DAGCombiner &Combiner,
DAG.getValueType(Load->getValueType(0).getScalarType()));
}
Combiner.ExtendSetCCUses(SetCCs, N0, Res, ExtOpc);
- Combiner.CombineTo(N, Res);
+ // If the load value is used only by N, replace it via CombineTo N.
+ unsigned Opcode_N = N->getOpcode();
+ bool IsSigned = Opcode_N == ISD::SIGN_EXTEND;
+ SDValue OldLoadVal(Load, 0);
+ SDValue OldExtValue(N, 0);
+ bool NoReplaceTrunc = N0.hasOneUse();
if (NoReplaceTrunc) {
+ if (Load->getHasDebugValue())
+ SalvageToOldLoadSize(OldLoadVal, ExtLoad, IsSigned);
+
+ if (N->getHasDebugValue())
+ DAG.transferDbgValues(OldExtValue, ExtLoad);
DAG.ReplaceAllUsesOfValueWith(SDValue(Load, 1), ExtLoad.getValue(1));
Combiner.recursivelyDeleteUnusedNodes(N0.getNode());
} else {
@@ -15057,6 +15142,7 @@ static SDValue tryToFoldExtOfLoad(SelectionDAG &DAG, DAGCombiner &Combiner,
Combiner.CombineTo(Load, Trunc, ExtLoad.getValue(1));
}
}
+ Combiner.CombineTo(N, Res);
return SDValue(N, 0); // Return N so it doesn't get rechecked!
}
diff --git a/llvm/test/DebugInfo/X86/sdag-load-sext-trunc.ll b/llvm/test/DebugInfo/X86/sdag-load-sext-trunc.ll
new file mode 100644
index 0000000000000..46afb9c598a74
--- /dev/null
+++ b/llvm/test/DebugInfo/X86/sdag-load-sext-trunc.ll
@@ -0,0 +1,70 @@
+; This test checks that after SelectionDAG runs, it preserves the debug info that is lost due to the DAGCombiner combining a load and a sext instruction, where the #dbg_value is pointing to the result of the load.
+; However, in this case, the load has multiple uses.
+
+; RUN: llc %s -mtriple=x86_64-unkown-linux -start-before=x86-isel -stop-after=x86-isel -o - | FileCheck %s --check-prefix=MIR
+; RUN: llc -O2 %s -start-before=x86-isel -mtriple=x86_64-unkown-linux --filetype=obj -o %t.o
+; RUN: llvm-dwarfdump %t.o --name Idx | FileCheck %s --check-prefix=DUMP
+; RUN: llvm-dwarfdump %t.o --name Idx2 | FileCheck %s --check-prefix=DUMP2
+
+; MIR: ![[IDX:[0-9]+]] = !DILocalVariable(name: "Idx"
+; MIR: ![[IDX2:[0-9]+]] = !DILocalVariable(name: "Idx2"
+; MIR: name: _Z8useValuei
+; MIR: name: main
+; MIR: debugValueSubstitutions
+; MIR-NEXT: - { srcinst: [[INSTR_NUM2:[0-9]+]], srcop: 0, dstinst: [[INSTR_NUM:[0-9]+]], dstop: 0, subreg: 6 }
+; MIR-LABEL: bb.0 (%ir-block.0)
+; MIR: %{{[0-9a-f]+}}{{.*}} = MOVSX64rm32 ${{.*}}, 1, $noreg, @GlobArr, $noreg, debug-instr-number [[INSTR_NUM]]
+; MIR-NEXT: {{.*}} = COPY %0.sub_32bit
+; MIR-NEXT DBG_INSTR_REF ![[IDX]], !DIExpression(DW_OP_LLVM_arg, 0), dbg-instr-ref([[INSTR_NUM2]], 0)
+; MIR-NEXT DBG_INSTR_REF ![[IDX2]], !DIExpression(DW_OP_LLVM_arg, 0), dbg-instr-ref([[INSTR_NUM]], 0)
+
+; DUMP: DW_AT_location (indexed ({{[0-9a-f]+}}x{{[0-9a-f]+}}) loclist = 0x{{[0-9a-f]+}}:
+; DUMP-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_reg3 RBX)
+
+; DUMP2: DW_AT_location (indexed ({{[0-9a-f]+}}x{{[0-9a-f]+}}) loclist = 0x{{[0-9a-f]+}}:
+; DUMP2-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_reg3 RBX)
+
+
+
+ @GlobArr = dso_local local_unnamed_addr global [5 x i32] [i32 1, i32 1, i32 2, i32 3, i32 5], align 16, !dbg !0
+ @__const.main.Data = private unnamed_addr constant [7 x i32] [i32 10, i32 20, i32 30, i32 40, i32 50, i32 60, i32 70], align 16
+ define dso_local void @_Z8useValuei(i32 noundef %0) local_unnamed_addr #0 !dbg !22 {
+ ret void, !dbg !28
+ }
+ define dso_local noundef i32 @main() local_unnamed_addr #1 !dbg !29 {
+ %1 = load i32, ptr @GlobArr
+ #dbg_value(i32 %1, !43, !DIExpression(), !52)
+ %2 = sext i32 %1 to i64
+ #dbg_value(i64 %2, !57, !DIExpression(), !52)
+ tail call void @_Z8useValuei(i32 noundef %1), !dbg !56
+ %3 = getelementptr inbounds i32, ptr @__const.main.Data, i64 %2
+ %4 = load i32, ptr %3
+ tail call void @_Z8useValuei(i32 noundef %4), !dbg !56
+ ret i32 0
+ }
+ !llvm.dbg.cu = !{!2}
+ !llvm.module.flags = !{!10, !11, !16}
+ !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+ !1 = distinct !DIGlobalVariable(type: !6, isDefinition: true)
+ !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, emissionKind: FullDebug, nameTableKind: None)
+ !3 = !DIFile(filename: "/tmp/test.cpp", directory: "/Users/srastogi/Development/llvm-project/build_ninja", checksumkind: CSK_MD5, checksum: "0fe735937e606b4db3e3b2e9253eff90")
+ !6 = !DICompositeType(tag: DW_TAG_array_type, elements: !8)
+ !7 = !DIBasicType()
+ !8 = !{}
+ !10 = !{i32 7, !"Dwarf Version", i32 5}
+ !11 = !{i32 2, !"Debug Info Version", i32 3}
+ !16 = !{i32 7, !"debug-info-assignment-tracking", i1 true}
+ !22 = distinct !DISubprogram(type: !23, unit: !2, keyInstructions: true)
+ !23 = !DISubroutineType(types: !24)
+ !24 = !{}
+ !28 = !DILocation(scope: !22, atomRank: 1)
+ !29 = distinct !DISubprogram(type: !30, unit: !2, keyInstructions: true)
+ !30 = !DISubroutineType(types: !31)
+ !31 = !{}
+ !38 = distinct !DILexicalBlock(scope: !29, line: 5, column: 3)
+ !43 = !DILocalVariable(name: "Idx", scope: !44, type: !7)
+ !44 = distinct !DILexicalBlock(scope: !38, line: 5, column: 3)
+ !46 = distinct !DILexicalBlock(scope: !44, line: 5, column: 27)
+ !52 = !DILocation(scope: !44)
+ !56 = !DILocation(scope: !46)
+ !57 = !DILocalVariable(name: "Idx2", scope: !44, type: !7)
diff --git a/llvm/test/DebugInfo/X86/sdag-load-sext.ll b/llvm/test/DebugInfo/X86/sdag-load-sext.ll
new file mode 100644
index 0000000000000..c09923205105f
--- /dev/null
+++ b/llvm/test/DebugInfo/X86/sdag-load-sext.ll
@@ -0,0 +1,61 @@
+; This test checks that after SelectionDAG runs, it preserves the debug info that is lost due to the DAGCombiner combining a load and a sext instruction, where the #dbg_value is pointing to the result of the load.
+; RUN: llc %s -mtriple=x86_64-unkown-linux -start-before=x86-isel -stop-after=x86-isel -o - | FileCheck %s --check-prefix=MIR
+; RUN: llc -O2 %s -start-before=x86-isel -mtriple=x86_64-unkown-linux --filetype=obj -o %t.o
+; RUN: llvm-dwarfdump %t.o --name Idx | FileCheck %s --check-prefix=DUMP
+; RUN: llvm-dwarfdump %t.o --name Idx2 | FileCheck %s --check-prefix=DUMP2
+
+; MIR: ![[IDX:[0-9]+]] = !DILocalVariable(name: "Idx"
+; MIR: ![[IDX2:[0-9]+]] = !DILocalVariable(name: "Idx2"
+; 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, DW_OP_LLVM_convert, 64, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value), dbg-instr-ref([[INSTR_NUM]], 0)
+; MIR-NEXT: DBG_INSTR_REF ![[IDX2]], !DIExpression(DW_OP_LLVM_arg, 0), dbg-instr-ref([[INSTR_NUM]], 0)
+
+; DUMP: DW_AT_location (indexed ({{[0-9a-f]+}}x{{[0-9a-f]+}}) loclist = 0x{{[0-9a-f]+}}:
+; DUMP-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_breg0 RAX+0, DW_OP_convert (0x{{[0-9a-f]+}}) "DW_ATE_signed_64", DW_OP_convert (0x{{[0-9a-f]+}}) "DW_ATE_signed_32", DW_OP_stack_value)
+
+; DUMP2: DW_AT_location (indexed ({{[0-9a-f]+}}x{{[0-9a-f]+}}) loclist = 0x{{[0-9a-f]+}}:
+; DUMP2-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_reg0 RAX)
+
+
+ @GlobArr = dso_local local_unnamed_addr global [5 x i32] [i32 1, i32 1, i32 2, i32 3, i32 5], align 16, !dbg !0
+ @__const.main.Data = private unnamed_addr constant [7 x i32] [i32 10, i32 20, i32 30, i32 40, i32 50, i32 60, i32 70], align 16
+ define dso_local void @_Z8useValuei(i32 noundef %0) local_unnamed_addr #0 !dbg !22 {
+ ret void, !dbg !28
+ }
+ define dso_local noundef i32 @main() local_unnamed_addr #1 !dbg !29 {
+ %1 = load i32, ptr @GlobArr
+ #dbg_value(i32 %1, !43, !DIExpression(), !52)
+ %2 = sext i32 %1 to i64
+ #dbg_value(i64 %2, !57, !DIExpression(), !52)
+ %3 = getelementptr inbounds i32, ptr @__const.main.Data, i64 %2
+ %4 = load i32, ptr %3
+ tail call void @_Z8useValuei(i32 noundef %4), !dbg !56
+ ret i32 0
+ }
+ !llvm.dbg.cu = !{!2}
+ !llvm.module.flags = !{!10, !11, !16}
+ !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+ !1 = distinct !DIGlobalVariable(type: !6, isDefinition: true)
+ !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, emissionKind: FullDebug, nameTableKind: None)
+ !3 = !DIFile(filename: "/tmp/test.cpp", directory: "/Users/srastogi/Development/llvm-project/build_ninja", checksumkind: CSK_MD5, checksum: "0fe735937e606b4db3e3b2e9253eff90")
+ !6 = !DICompositeType(tag: DW_TAG_array_type, elements: !8)
+ !7 = !DIBasicType()
+ !8 = !{}
+ !10 = !{i32 7, !"Dwarf Version", i32 5}
+ !11 = !{i32 2, !"Debug Info Version", i32 3}
+ !16 = !{i32 7, !"debug-info-assignment-tracking", i1 true}
+ !22 = distinct !DISubprogram(type: !23, unit: !2, keyInstructions: true)
+ !23 = !DISubroutineType(types: !24)
+ !24 = !{}
+ !28 = !DILocation(scope: !22, atomRank: 1)
+ !29 = distinct !DISubprogram(type: !30, unit: !2, keyInstructions: true)
+ !30 = !DISubroutineType(types: !31)
+ !31 = !{}
+ !38 = distinct !DILexicalBlock(scope: !29, line: 5, column: 3)
+ !43 = !DILocalVariable(name: "Idx", scope: !44, type: !7)
+ !44 = distinct !DILexicalBlock(scope: !38, line: 5, column: 3)
+ !46 = distinct !DILexicalBlock(scope: !44, line: 5, column: 27)
+ !52 = !DILocation(scope: !44)
+ !56 = !DILocation(scope: !46)
+ !57 = !DILocalVariable(name: "Idx2", scope: !44, type: !7)
diff --git a/llvm/test/DebugInfo/X86/sdag-load-zext-multiple-args.ll b/llvm/test/DebugInfo/X86/sdag-load-zext-multiple-args.ll
new file mode 100644
index 0000000000000..ee0bdd3a9fbfc
--- /dev/null
+++ b/llvm/test/DebugInfo/X86/sdag-load-zext-multiple-args.ll
@@ -0,0 +1,48 @@
+; This test checks that after SelectionDAG runs, it preserves the debug info that is lost due to the DAGCombiner combining a load and a zext instruction, where the #dbg_value is pointing to the result of the load. However, this test also ensures that the DIExpression, which has multiple DW_OP_LLVM_arg's is handled correctly when the debug info is preserved in selectioDAG.
+; RUN: llc %s -mtriple=x86_64-unkown-linux-gnu -start-before=x86-isel -stop-after=x86-isel -o - | FileCheck %s --check-prefix=MIR
+; RUN: llc -O2 %s -start-before=x86-isel -mtriple=x86_64-unkown-linux --filetype=obj -o %t.o
+
+; MIR: ![[V:[0-9]+]] = !DILocalVariable(name: "v"
+; MIR-LABEL: bb.0
+; MIR: %{{[0-9a-f]+}}{{.*}} = MOVZX32rm8 {{.*}}, 1, $noreg, 0, $noreg, debug-instr-number [[INSTR_NUM:[0-9]+]]
+; MIR-NEXT: DBG_INSTR_REF ![[V]], !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_convert, 32, DW_ATE_unsigned, DW_OP_LLVM_convert, 8, DW_ATE_unsigned, DW_OP_constu, 45, DW_OP_eq, DW_OP_LLVM_arg, 1, DW_OP_LLVM_convert, 32, DW_ATE_unsigned, DW_OP_LLVM_convert, 8, DW_ATE_unsigned, DW_OP_constu, 114, DW_OP_eq, DW_OP_or, DW_OP_stack_value), dbg-instr-ref([[INSTR_NUM]], 0), dbg-instr-ref([[INSTR_NUM]], 0)
+
+ @.str = private unnamed_addr constant [105 x i8] c"/Users/srastogi/Development/llvm-project-2/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_linux.cpp\00"
+ @.str.1 = private unnamed_addr constant [45 x i8] c"((IsOneOf(*data_.current, '-', 'r'))) != (0)\00"
+ define hidden noundef zeroext i1 @_ZN11__sanitizer19MemoryMappingLayout4NextEPNS_19MemoryMappedSegmentE(ptr noundef nonnull readonly align 8 captures(none) dereferenceable(32) %this, ptr noundef readonly captures(none) %segment) unnamed_addr #0 align 2 !dbg !64 {
+ %current = getelementptr inbounds nuw i8, ptr %this, i64 24
+ %3 = load ptr, ptr %current, !dbg !95
+ %4 = load i8, ptr %3
+ #dbg_value(!DIArgList(i8 %4, i8 %4), !71, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_constu, 45, DW_OP_eq, DW_OP_LLVM_arg, 1, DW_OP_constu, 114, DW_OP_eq, DW_OP_or, DW_OP_stack_value), !98)
+ %5 = zext i8 %4 to i32
+ switch i32 %5, label %if.then [
+ i32 114, label %if.end
+ i32 45, label %if.end
+ ]
+ if.then: ; preds = %entry
+ tail call void @_ZN11__sanitizer11CheckFailedEPKciS1_yy(ptr noundef nonnull @.str, i32 noundef 45, ptr noundef nonnull @.str.1, i64 noundef 0, i64 noundef 0) #5
+ unreachable
+ if.end: ; preds = %entry, %entry
+ ret i1 true
+ }
+ declare void @_ZN11__sanitizer11CheckFailedEPKciS1_yy(ptr noundef, i32 noundef, ptr noundef, i64 noundef, i64 noundef) local_unnamed_addr #2
+ !llvm.dbg.cu = !{!15}
+ !llvm.module.flags = !{!55, !58}
+ !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+ !1 = distinct !DIGlobalVariable()
+ !2 = !DIFile(filename: "san.pp.cpp", directory: "/Users/srastogi/Development/Delta", checksumkind: CSK_MD5, checksum: "386698ddde6c66899ec76581efaeabe2")
+ !15 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !16, emissionKind: FullDebug, nameTableKind: None)
+ !16 = !DIFile(filename: "/Users/srastogi/Development/Delta/san.pp.cpp", directory: "/Users/srastogi/Development/Delta", checksumkind: CSK_MD5, checksum: "386698ddde6c66899ec76581efaeabe2")
+ !19 = !DIDerivedType(tag: DW_TAG_typedef,baseType: !21)
+ !21 = !DIBasicType()
+ !22 = !DIDerivedType(tag: DW_TAG_typedef, baseType: !23)
+ !23 = !DIBasicType()
+ !46 = !DISubroutineType(types: !47)
+ !47 = !{}
+ !55 = !{i32 2, !"Debug Info Version", i32 3}
+ !58 = !{i32 7, !"debug-info-assignment-tracking", i1 true}
+ !64 = distinct !DISubprogram( type: !46, unit: !15, keyInstructions: true)
+ !71 = !DILocalVariable(name: "v", scope: !72, type: !19)
+ !72 = distinct !DILexicalBlock(scope: !64, line: 187, column: 6)
+ !95 = !DILocation( scope: !72)
+ !98 = !DILocation(scope: !72)
>From f6982e508d0373982ed40a66df44d49e1ad69782 Mon Sep 17 00:00:00 2001
From: Shubham Sandeep Rastogi <Shubham.Rastogi at sony.com>
Date: Tue, 28 Apr 2026 10:13:09 -0700
Subject: [PATCH 2/2] [SelectionDAG] Fix extload fold use-replacement ordering
in DAGCombiner
Move CombineTo(N, Res) before deleting or rewriting the folded nodes in
tryToFoldExtOfLoad(), and transfer debug values before the replacement
path runs.
This avoids a crash when folding an extend-of-load pattern with the
truncate replacement path. Add an X86 regression test.
---
llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp | 8 +++---
.../CodeGen/X86/sdag-extload-combine-crash.ll | 27 +++++++++++++++++++
2 files changed, 31 insertions(+), 4 deletions(-)
create mode 100644 llvm/test/CodeGen/X86/sdag-extload-combine-crash.ll
diff --git a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
index 52b04f7b13cbe..2433e4390b1c2 100644
--- a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
@@ -15125,15 +15125,16 @@ static SDValue tryToFoldExtOfLoad(SelectionDAG &DAG, DAGCombiner &Combiner,
SDValue OldLoadVal(Load, 0);
SDValue OldExtValue(N, 0);
bool NoReplaceTrunc = N0.hasOneUse();
+ if (N->getHasDebugValue())
+ DAG.transferDbgValues(OldExtValue, ExtLoad);
if (NoReplaceTrunc) {
if (Load->getHasDebugValue())
SalvageToOldLoadSize(OldLoadVal, ExtLoad, IsSigned);
-
- if (N->getHasDebugValue())
- DAG.transferDbgValues(OldExtValue, ExtLoad);
DAG.ReplaceAllUsesOfValueWith(SDValue(Load, 1), ExtLoad.getValue(1));
+ Combiner.CombineTo(N, Res);
Combiner.recursivelyDeleteUnusedNodes(N0.getNode());
} else {
+ Combiner.CombineTo(N, Res);
SDValue Trunc = DAG.getNode(ISD::TRUNCATE, DL, Load->getValueType(0), Res);
if (Frozen) {
Combiner.CombineTo(Freeze.getNode(), Trunc);
@@ -15142,7 +15143,6 @@ static SDValue tryToFoldExtOfLoad(SelectionDAG &DAG, DAGCombiner &Combiner,
Combiner.CombineTo(Load, Trunc, ExtLoad.getValue(1));
}
}
- Combiner.CombineTo(N, Res);
return SDValue(N, 0); // Return N so it doesn't get rechecked!
}
diff --git a/llvm/test/CodeGen/X86/sdag-extload-combine-crash.ll b/llvm/test/CodeGen/X86/sdag-extload-combine-crash.ll
new file mode 100644
index 0000000000000..55f57367495a4
--- /dev/null
+++ b/llvm/test/CodeGen/X86/sdag-extload-combine-crash.ll
@@ -0,0 +1,27 @@
+; This test checks that after SelectionDAG runs, DAGCombiner can combine a
+; load and a zext instruction without crashing in tryToFoldExtOfLoad(),
+; even when the folded load result is still used along the truncate
+; replacement path.
+
+; RUN: llc -O3 -mtriple=x86_64-unknown-linux-gnu -filetype=null < %s
+
+ at ak = external global i16
+ at s = external global i16
+
+define i32 @main() {
+entry:
+ %0 = load i16, ptr @ak, align 2
+ %1 = load volatile i16, ptr @s, align 2
+ %2 = load i16, ptr @ak, align 2
+ %3 = xor i16 %2, -1
+ %conv4211404 = zext i16 %3 to i64
+ %xor422 = xor i64 1, %conv4211404
+ %conv3591399 = zext i16 %0 to i64
+ %or424 = or i64 %xor422, %conv3591399
+ %conv333 = sext i16 %0 to i32
+ %conv434 = zext i16 %2 to i32
+ %4 = trunc i64 %or424 to i32
+ %or436 = or i32 %conv434, %4
+ %conv453 = xor i32 %conv333, %or436
+ ret i32 %conv453
+}
More information about the llvm-commits
mailing list