Sync

dataset/140994.json

@@ -0,0 +1,265 @@
+{
+  "bug_id": "140994",
+  "issue_url": "https://github.com/llvm/llvm-project/issues/140994",
+  "bug_type": "miscompilation",
+  "base_commit": "7c080e267722ba14439e2f35789c5c293672ab84",
+  "knowledge_cutoff": "2025-05-22T02:48:33Z",
+  "lit_test_dir": [
+    "llvm/test/Transforms/InstCombine"
+  ],
+  "hints": {
+    "fix_commit": "3ec0c5c7fef03985b43432c6b914c289d8a5435e",
+    "components": [
+      "InstCombine"
+    ],
+    "bug_location_lineno": {
+      "llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp": [
+        [
+          25,
+          30
+        ],
+        [
+          3879,
+          3889
+        ]
+      ]
+    },
+    "bug_location_funcname": {
+      "llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp": [
+        "InstCombinerImpl::visitSelectInst"
+      ]
+    }
+  },
+  "patch": "commit 3ec0c5c7fef03985b43432c6b914c289d8a5435e\nAuthor: Yingwei Zheng <[email protected]>\nDate:   Sat May 31 16:25:10 2025 +0800\n\n    [InstCombine] Propagate FMF from select instead of fcmp (#141010)\n    \n    Previously,\n    https://github.com/llvm/llvm-project/commit/3d6b53980ce4ee855484fc8ae6ac3f99c85e48c3\n    propagates FMF from fcmp to avoid performance regressions. With the help\n    of https://github.com/llvm/llvm-project/pull/139861,\n    https://github.com/llvm/llvm-project/pull/141015, and\n    https://github.com/llvm/llvm-project/pull/141914, we can still convert\n    SPF into fabs/minnum/maxnum intrinsics even if some flags are missing.\n    This patch propagates FMF from select to address the long-standing\n    issue.\n    \n    Closes https://github.com/llvm/llvm-project/issues/140994.\n\ndiff --git a/llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp\nindex a791fc5db669..cca5705f6b58 100644\n--- a/llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp\n+++ b/llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp\n@@ -25,6 +25,7 @@\n #include \"llvm/IR/ConstantRange.h\"\n #include \"llvm/IR/Constants.h\"\n #include \"llvm/IR/DerivedTypes.h\"\n+#include \"llvm/IR/FMF.h\"\n #include \"llvm/IR/IRBuilder.h\"\n #include \"llvm/IR/InstrTypes.h\"\n #include \"llvm/IR/Instruction.h\"\n@@ -3879,11 +3880,16 @@ Instruction *InstCombinerImpl::visitSelectInst(SelectInst &SI) {\n       // (X ugt Y) ? X : Y -> (X ole Y) ? Y : X\n       if (FCmp->hasOneUse() && FCmpInst::isUnordered(Pred)) {\n         FCmpInst::Predicate InvPred = FCmp->getInversePredicate();\n-        // FIXME: The FMF should propagate from the select, not the fcmp.\n         Value *NewCond = Builder.CreateFCmpFMF(InvPred, Cmp0, Cmp1, FCmp,\n                                                FCmp->getName() + \".inv\");\n+        // Propagate ninf/nnan from fcmp to select.\n+        FastMathFlags FMF = SI.getFastMathFlags();\n+        if (FCmp->hasNoNaNs())\n+          FMF.setNoNaNs(true);\n+        if (FCmp->hasNoInfs())\n+          FMF.setNoInfs(true);\n         Value *NewSel =\n-            Builder.CreateSelectFMF(NewCond, FalseVal, TrueVal, FCmp);\n+            Builder.CreateSelectFMF(NewCond, FalseVal, TrueVal, FMF);\n         return replaceInstUsesWith(SI, NewSel);\n       }\n     }\n",
+  "tests": [
+    {
+      "file": "llvm/test/Transforms/InstCombine/clamp-to-minmax.ll",
+      "commands": [
+        "opt < %s -passes=instcombine -S",
+        "opt < %s -passes=instcombine -use-constant-fp-for-fixed-length-splat -use-constant-int-for-fixed-length-splat -S"
+      ],
+      "tests": [
+        {
+          "test_name": "clamp_negative_same_op",
+          "test_body": "define half @clamp_negative_same_op(half %x) {\n  %inner_cmp = fcmp nnan ninf nsz ult half %x, 2.550000e+02\n  %inner_sel = select i1 %inner_cmp, half %x, half 2.550000e+02\n  %outer_cmp = fcmp nnan ninf nsz ult half %x, 1.000000e+00\n  %r = select i1 %outer_cmp, half %inner_sel, half 1.000000e+00\n  ret half %r\n}\n"
+        },
+        {
+          "test_name": "clamp_float_fast_unordered_nonstrict_maxmin",
+          "test_body": "define half @clamp_float_fast_unordered_nonstrict_maxmin(half %x) {\n  %cmp2 = fcmp nnan ninf nsz ult half %x, 2.550000e+02\n  %min = select i1 %cmp2, half %x, half 2.550000e+02\n  %cmp1 = fcmp nnan ninf nsz ule half %x, 1.000000e+00\n  %r = select i1 %cmp1, half 1.000000e+00, half %min\n  ret half %r\n}\n"
+        },
+        {
+          "test_name": "clamp_float_fast_ordered_nonstrict_minmax",
+          "test_body": "define half @clamp_float_fast_ordered_nonstrict_minmax(half %x) {\n  %cmp2 = fcmp nnan ninf nsz ogt half %x, 1.000000e+00\n  %max = select i1 %cmp2, half %x, half 1.000000e+00\n  %cmp1 = fcmp nnan ninf nsz oge half %x, 2.550000e+02\n  %r = select i1 %cmp1, half 2.550000e+02, half %max\n  ret half %r\n}\n"
+        },
+        {
+          "test_name": "clamp_float_fast_ordered_strict_maxmin",
+          "test_body": "define half @clamp_float_fast_ordered_strict_maxmin(half %x) {\n  %cmp2 = fcmp nnan ninf nsz olt half %x, 2.550000e+02\n  %min = select i1 %cmp2, half %x, half 2.550000e+02\n  %cmp1 = fcmp nnan ninf nsz olt half %x, 1.000000e+00\n  %r = select i1 %cmp1, half 1.000000e+00, half %min\n  ret half %r\n}\n"
+        },
+        {
+          "test_name": "clamp_float_fast_ordered_strict_minmax",
+          "test_body": "define half @clamp_float_fast_ordered_strict_minmax(half %x) {\n  %cmp2 = fcmp nnan ninf nsz ogt half %x, 1.000000e+00\n  %max = select i1 %cmp2, half %x, half 1.000000e+00\n  %cmp1 = fcmp nnan ninf nsz ogt half %x, 2.550000e+02\n  %r = select i1 %cmp1, half 2.550000e+02, half %max\n  ret half %r\n}\n"
+        },
+        {
+          "test_name": "clamp_float_fast_ordered_nonstrict_maxmin",
+          "test_body": "define half @clamp_float_fast_ordered_nonstrict_maxmin(half %x) {\n  %cmp2 = fcmp nnan ninf nsz olt half %x, 2.550000e+02\n  %min = select i1 %cmp2, half %x, half 2.550000e+02\n  %cmp1 = fcmp nnan ninf nsz ole half %x, 1.000000e+00\n  %r = select i1 %cmp1, half 1.000000e+00, half %min\n  ret half %r\n}\n"
+        },
+        {
+          "test_name": "clamp_float_fast_unordered_nonstrict_minmax",
+          "test_body": "define half @clamp_float_fast_unordered_nonstrict_minmax(half %x) {\n  %cmp2 = fcmp nnan ninf nsz ugt half %x, 1.000000e+00\n  %max = select i1 %cmp2, half %x, half 1.000000e+00\n  %cmp1 = fcmp nnan ninf nsz uge half %x, 2.550000e+02\n  %r = select i1 %cmp1, half 2.550000e+02, half %max\n  ret half %r\n}\n"
+        },
+        {
+          "test_name": "clamp_test_1",
+          "test_body": "define half @clamp_test_1(half %x) {\n  %inner_cmp = fcmp nnan ninf nsz ult half %x, 2.550000e+02\n  %inner_sel = select i1 %inner_cmp, half %x, half 2.550000e+02\n  %outer_cmp = fcmp nnan ninf nsz ugt half %x, 1.000000e+00\n  %r = select i1 %outer_cmp, half %inner_sel, half 1.000000e+00\n  ret half %r\n}\n"
+        },
+        {
+          "test_name": "clamp_float_fast_unordered_strict_maxmin",
+          "test_body": "define half @clamp_float_fast_unordered_strict_maxmin(half %x) {\n  %cmp2 = fcmp nnan ninf nsz ult half %x, 2.550000e+02\n  %min = select i1 %cmp2, half %x, half 2.550000e+02\n  %cmp1 = fcmp nnan ninf nsz ult half %x, 1.000000e+00\n  %r = select i1 %cmp1, half 1.000000e+00, half %min\n  ret half %r\n}\n"
+        },
+        {
+          "test_name": "clamp_negative_wrong_const",
+          "test_body": "define half @clamp_negative_wrong_const(half %x) {\n  %inner_cmp = fcmp nnan ninf nsz ult half %x, 2.550000e+02\n  %inner_sel = select i1 %inner_cmp, half %x, half 2.550000e+02\n  %outer_cmp = fcmp nnan ninf nsz ugt half %x, 5.120000e+02\n  %r = select i1 %outer_cmp, half %inner_sel, half 5.120000e+02\n  ret half %r\n}\n"
+        },
+        {
+          "test_name": "clamp_float_fast_unordered_strict_minmax",
+          "test_body": "define half @clamp_float_fast_unordered_strict_minmax(half %x) {\n  %cmp2 = fcmp nnan ninf nsz ugt half %x, 1.000000e+00\n  %max = select i1 %cmp2, half %x, half 1.000000e+00\n  %cmp1 = fcmp nnan ninf nsz ugt half %x, 2.550000e+02\n  %r = select i1 %cmp1, half 2.550000e+02, half %max\n  ret half %r\n}\n"
+        }
+      ]
+    },
+    {
+      "file": "llvm/test/Transforms/InstCombine/fcmp-fadd-select.ll",
+      "commands": [
+        "opt < %s -passes=instcombine -S"
+      ],
+      "tests": [
+        {
+          "test_name": "test_fcmp_ugt_fadd_select_fastmath_preserve",
+          "test_body": "define half @test_fcmp_ugt_fadd_select_fastmath_preserve(half %in) {\n  %cmp1 = fcmp ugt half %in, 0.000000e+00\n  %add = fadd nnan half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half %add, half 1.000000e+00\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "test_fcmp_uge_fadd_select_fastmath_preserve",
+          "test_body": "define half @test_fcmp_uge_fadd_select_fastmath_preserve(half %in) {\n  %cmp1 = fcmp uge half %in, 0.000000e+00\n  %add = fadd nnan half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half %add, half 1.000000e+00\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "test_fcmp_ugt_fadd_select_neg_constant",
+          "test_body": "define half @test_fcmp_ugt_fadd_select_neg_constant(half %in) {\n  %cmp1 = fcmp ugt half %in, -0.000000e+00\n  %add = fadd half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half %add, half 1.000000e+00\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "test_fcmp_ugt_fadd_select_constant_swapped",
+          "test_body": "define half @test_fcmp_ugt_fadd_select_constant_swapped(half %in) {\n  %cmp1 = fcmp ugt half %in, 0.000000e+00\n  %add = fadd half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half 1.000000e+00, half %add\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "test_fcmp_uge_fadd_select_constant_swapped",
+          "test_body": "define half @test_fcmp_uge_fadd_select_constant_swapped(half %in) {\n  %cmp1 = fcmp uge half %in, 0.000000e+00\n  %add = fadd half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half 1.000000e+00, half %add\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "test_fcmp_ult_fadd_select_fastmath_preserve",
+          "test_body": "define half @test_fcmp_ult_fadd_select_fastmath_preserve(half %in) {\n  %cmp1 = fcmp ult half %in, 0.000000e+00\n  %add = fadd nnan half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half %add, half 1.000000e+00\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "test_fcmp_ule_fadd_select_constant_swapped",
+          "test_body": "define half @test_fcmp_ule_fadd_select_constant_swapped(half %in) {\n  %cmp1 = fcmp ule half %in, 0.000000e+00\n  %add = fadd half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half 1.000000e+00, half %add\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "test_fcmp_uge_fadd_select_neg_constant",
+          "test_body": "define half @test_fcmp_uge_fadd_select_neg_constant(half %in) {\n  %cmp1 = fcmp uge half %in, -0.000000e+00\n  %add = fadd half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half %add, half 1.000000e+00\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "test_fcmp_ule_fadd_select_neg_constant",
+          "test_body": "define half @test_fcmp_ule_fadd_select_neg_constant(half %in) {\n  %cmp1 = fcmp ule half %in, -0.000000e+00\n  %add = fadd half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half %add, half 1.000000e+00\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "test_fcmp_ult_fadd_select_constant_swapped",
+          "test_body": "define half @test_fcmp_ult_fadd_select_constant_swapped(half %in) {\n  %cmp1 = fcmp ult half %in, 0.000000e+00\n  %add = fadd half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half 1.000000e+00, half %add\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "test_fcmp_uge_fadd_select_constant",
+          "test_body": "define half @test_fcmp_uge_fadd_select_constant(half %in) {\n  %cmp1 = fcmp uge half %in, 0.000000e+00\n  %add = fadd half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half %add, half 1.000000e+00\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "test_fcmp_ult_fadd_select_neg_constant",
+          "test_body": "define half @test_fcmp_ult_fadd_select_neg_constant(half %in) {\n  %cmp1 = fcmp ult half %in, -0.000000e+00\n  %add = fadd half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half %add, half 1.000000e+00\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "test_fcmp_ugt_fadd_select_constant",
+          "test_body": "define half @test_fcmp_ugt_fadd_select_constant(half %in) {\n  %cmp1 = fcmp ugt half %in, 0.000000e+00\n  %add = fadd half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half %add, half 1.000000e+00\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "test_fcmp_ule_fadd_select_constant",
+          "test_body": "define half @test_fcmp_ule_fadd_select_constant(half %in) {\n  %cmp1 = fcmp ule half %in, 0.000000e+00\n  %add = fadd half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half %add, half 1.000000e+00\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "test_fcmp_ule_fadd_select_fastmath_preserve",
+          "test_body": "define half @test_fcmp_ule_fadd_select_fastmath_preserve(half %in) {\n  %cmp1 = fcmp ule half %in, 0.000000e+00\n  %add = fadd nnan half %in, 1.000000e+00\n  %sel = select nnan nsz i1 %cmp1, half %add, half 1.000000e+00\n  ret half %sel\n}\n"
+        }
+      ]
+    },
+    {
+      "file": "llvm/test/Transforms/InstCombine/minmax-fold.ll",
+      "commands": [
+        "opt -S -passes=instcombine < %s"
+      ],
+      "tests": [
+        {
+          "test_name": "common_factor_umax_extra_use_both",
+          "test_body": "declare void @extra_use(i32)\n\ndefine i32 @common_factor_umax_extra_use_both(i32 %a, i32 %b, i32 %c) {\n  %cmp_bc = icmp ugt i32 %b, %c\n  %max_bc = select i1 %cmp_bc, i32 %b, i32 %c\n  %cmp_ba = icmp ugt i32 %b, %a\n  %max_ba = select i1 %cmp_ba, i32 %b, i32 %a\n  %cmp_bc_ba = icmp ugt i32 %max_bc, %max_ba\n  %max_abc = select i1 %cmp_bc_ba, i32 %max_bc, i32 %max_ba\n  call void @extra_use(i32 %max_bc)\n  call void @extra_use(i32 %max_ba)\n  ret i32 %max_abc\n}\n"
+        },
+        {
+          "test_name": "not_min_of_min",
+          "test_body": "define half @not_min_of_min(i8 %i, half %x) {\n  %cmp1 = fcmp nnan ninf nsz ult half %x, 1.000000e+00\n  %min1 = select i1 %cmp1, half %x, half 1.000000e+00\n  %cmp2 = fcmp nnan ninf nsz ult half %x, 2.000000e+00\n  %min2 = select i1 %cmp2, half %x, half 2.000000e+00\n  %cmp3 = icmp ult i8 %i, 16\n  %r = select i1 %cmp3, half %min1, half %min2\n  ret half %r\n}\n"
+        }
+      ]
+    },
+    {
+      "file": "llvm/test/Transforms/InstCombine/minmax-fp.ll",
+      "commands": [
+        "opt -S -passes=instcombine < %s"
+      ],
+      "tests": [
+        {
+          "test_name": "t15",
+          "test_body": "define i8 @t15(half %a) {\n  %1 = fcmp nsz ule half %a, 0.000000e+00\n  %2 = fptosi half %a to i8\n  %3 = select i1 %1, i8 %2, i8 0\n  ret i8 %3\n}\n"
+        },
+        {
+          "test_name": "fneg_fmax",
+          "test_body": "define half @fneg_fmax(half %x, half %y) {\n  %n1 = fneg half %x\n  %n2 = fneg half %y\n  %cond = fcmp nnan ogt half %n1, %n2\n  %max = select i1 %cond, half %n1, half %n2\n  ret half %max\n}\n"
+        },
+        {
+          "test_name": "t11",
+          "test_body": "define i8 @t11(half %a, half %b) {\n  %1 = fcmp nnan ninf nsz ult half %b, %a\n  %2 = fptosi half %a to i8\n  %3 = fptosi half %b to i8\n  %4 = select i1 %1, i8 %3, i8 %2\n  ret i8 %4\n}\n"
+        },
+        {
+          "test_name": "fneg_fmin",
+          "test_body": "define double @fneg_fmin(double %x, double %y) {\n  %n1 = fneg double %x\n  %n2 = fneg double %y\n  %cond = fcmp nnan nsz ule double %n1, %n2\n  %max = select i1 %cond, double %n1, double %n2\n  ret double %max\n}\n"
+        },
+        {
+          "test_name": "t14_commute",
+          "test_body": "define i8 @t14_commute(half %a) {\n  %1 = fcmp ule half %a, 0.000000e+00\n  %2 = fptosi half %a to i8\n  %3 = select i1 %1, i8 0, i8 %2\n  ret i8 %3\n}\n"
+        },
+        {
+          "test_name": "t9",
+          "test_body": "define i8 @t9(half %a) {\n  %1 = fcmp ult half %a, 0.000000e+00\n  %2 = fptosi half %a to i8\n  %3 = select i1 %1, i8 %2, i8 0\n  ret i8 %3\n}\n"
+        }
+      ]
+    },
+    {
+      "file": "llvm/test/Transforms/InstCombine/unordered-fcmp-select.ll",
+      "commands": [
+        "opt -S -passes=instcombine < %s"
+      ],
+      "tests": [
+        {
+          "test_name": "select_min_ugt",
+          "test_body": "define half @select_min_ugt(half %a, half %b) {\n  %cmp = fcmp nnan ninf nsz ugt half %a, %b\n  %sel = select i1 %cmp, half %b, half %a\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "select_fcmp_une",
+          "test_body": "define half @select_fcmp_une(half %a, half %b) {\n  %cmp = fcmp une half %a, %b\n  %sel = select nnan i1 %cmp, half %a, half %b\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "select_min_uge",
+          "test_body": "define half @select_min_uge(half %a, half %b) {\n  %cmp = fcmp nsz uge half %a, %b\n  %sel = select nnan ninf nsz i1 %cmp, half %b, half %a\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "select_max_uge",
+          "test_body": "define half @select_max_uge(half %a, half %b) {\n  %cmp = fcmp nnan uge half %a, %b\n  %sel = select ninf i1 %cmp, half %a, half %b\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "select_fcmp_ueq",
+          "test_body": "define half @select_fcmp_ueq(half %a, half %b) {\n  %cmp = fcmp ueq half %a, %b\n  %sel = select nnan i1 %cmp, half %a, half %b\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "select_min_ule",
+          "test_body": "define half @select_min_ule(half %a, half %b) {\n  %cmp = fcmp ule half %a, %b\n  %sel = select ninf i1 %cmp, half %a, half %b\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "select_max_ugt",
+          "test_body": "define half @select_max_ugt(half %a, half %b) {\n  %cmp = fcmp ugt half %a, %b\n  %sel = select i1 %cmp, half %a, half %b\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "select_max_ule",
+          "test_body": "define half @select_max_ule(half %a, half %b) {\n  %cmp = fcmp nnan ninf nsz ule half %a, %b\n  %sel = select nsz i1 %cmp, half %b, half %a\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "select_min_ult",
+          "test_body": "define half @select_min_ult(half %a, half %b) {\n  %cmp = fcmp nsz ult half %a, %b\n  %sel = select nnan ninf nsz i1 %cmp, half %a, half %b\n  ret half %sel\n}\n"
+        },
+        {
+          "test_name": "select_max_ult",
+          "test_body": "define half @select_max_ult(half %a, half %b) {\n  %cmp = fcmp ult half %a, %b\n  %sel = select nnan ninf i1 %cmp, half %b, half %a\n  ret half %sel\n}\n"
+        }
+      ]
+    }
+  ],
+  "issue": {
+    "title": "[InstCombine] `(fcmp une T, F) ? T : F --> T` should not rely on the nsz flag on fcmp",
+    "body": "Reproducer: https://alive2.llvm.org/ce/z/_FgncC\n```\ndefine double @src(double %x, double %y) {\n  %cmp = fcmp nsz une double %x, %y\n  %cond = select i1 %cmp, double %x, double %y\n  ret double %cond\n}\n\ndefine double @tgt(double returned %x, double %y) {\n  ret double %x\n}\n```\n```\nTransformation doesn't verify!\n\nERROR: Value mismatch\n\nExample:\ndouble %x = #x8000000000000000 (-0.0)\ndouble %y = #x0000000000000000 (+0.0)\n\nSource:\ni1 %cmp = #x0 (0)\ndouble %cond = #x0000000000000000 (+0.0)\n\nTarget:\nSource value: #x0000000000000000 (+0.0)\nTarget value: #x8000000000000000 (-0.0)\n```\n`nsz` flag should not be propagated from fcmp into select.\n",
+    "author": "dtcxzyw",
+    "labels": [
+      "miscompilation",
+      "llvm:instcombine",
+      "floating-point"
+    ],
+    "comments": []
+  },
+  "verified": true
+}

dataset/141017.json

@@ -0,0 +1,71 @@
+{
+  "bug_id": "141017",
+  "issue_url": "https://github.com/llvm/llvm-project/issues/141017",
+  "bug_type": "miscompilation",
+  "base_commit": "b3fd2ea88875e58c66dd67870ff822cedf2570cf",
+  "knowledge_cutoff": "2025-05-22T07:55:25Z",
+  "lit_test_dir": [
+    "llvm/test/Transforms/InstCombine"
+  ],
+  "hints": {
+    "fix_commit": "1984c7539ebeb2697233f8163a051a2ce0d4fa50",
+    "components": [
+      "ValueTracking"
+    ],
+    "bug_location_lineno": {
+      "llvm/include/llvm/Analysis/ValueTracking.h": [
+        [
+          889,
+          895
+        ]
+      ],
+      "llvm/lib/Analysis/ValueTracking.cpp": [
+        [
+          8898,
+          8916
+        ]
+      ]
+    },
+    "bug_location_funcname": {
+      "llvm/lib/Analysis/ValueTracking.cpp": [
+        "llvm::matchDecomposedSelectPattern",
+        "llvm::matchSelectPattern"
+      ]
+    }
+  },
+  "patch": "commit 1984c7539ebeb2697233f8163a051a2ce0d4fa50\nAuthor: Yingwei Zheng <[email protected]>\nDate:   Mon Jun 2 18:21:14 2025 +0800\n\n    [ValueTracking] Do not use FMF from fcmp (#142266)\n    \n    This patch introduces an FMF parameter for\n    `matchDecomposedSelectPattern` to pass FMF flags from select, instead of\n    fcmp.\n    \n    Closes https://github.com/llvm/llvm-project/issues/137998.\n    Closes https://github.com/llvm/llvm-project/issues/141017.\n\ndiff --git a/llvm/include/llvm/Analysis/ValueTracking.h b/llvm/include/llvm/Analysis/ValueTracking.h\nindex d81c3f10bba9..feb7a1fa2cb3 100644\n--- a/llvm/include/llvm/Analysis/ValueTracking.h\n+++ b/llvm/include/llvm/Analysis/ValueTracking.h\n@@ -889,7 +889,8 @@ inline SelectPatternResult matchSelectPattern(const Value *V, const Value *&LHS,\n /// predicate and given values as its true/false operands would match.\n LLVM_ABI SelectPatternResult matchDecomposedSelectPattern(\n     CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS,\n-    Instruction::CastOps *CastOp = nullptr, unsigned Depth = 0);\n+    FastMathFlags FMF = FastMathFlags(), Instruction::CastOps *CastOp = nullptr,\n+    unsigned Depth = 0);\n \n /// Determine the pattern for predicate `X Pred Y ? X : Y`.\n LLVM_ABI SelectPatternResult getSelectPattern(\ndiff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp\nindex 3d8bb6249eaf..7f30cd73d57c 100644\n--- a/llvm/lib/Analysis/ValueTracking.cpp\n+++ b/llvm/lib/Analysis/ValueTracking.cpp\n@@ -8898,19 +8898,20 @@ SelectPatternResult llvm::matchSelectPattern(Value *V, Value *&LHS, Value *&RHS,\n   Value *TrueVal = SI->getTrueValue();\n   Value *FalseVal = SI->getFalseValue();\n \n-  return llvm::matchDecomposedSelectPattern(CmpI, TrueVal, FalseVal, LHS, RHS,\n-                                            CastOp, Depth);\n+  return llvm::matchDecomposedSelectPattern(\n+      CmpI, TrueVal, FalseVal, LHS, RHS,\n+      isa<FPMathOperator>(SI) ? SI->getFastMathFlags() : FastMathFlags(),\n+      CastOp, Depth);\n }\n \n SelectPatternResult llvm::matchDecomposedSelectPattern(\n     CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS,\n-    Instruction::CastOps *CastOp, unsigned Depth) {\n+    FastMathFlags FMF, Instruction::CastOps *CastOp, unsigned Depth) {\n   CmpInst::Predicate Pred = CmpI->getPredicate();\n   Value *CmpLHS = CmpI->getOperand(0);\n   Value *CmpRHS = CmpI->getOperand(1);\n-  FastMathFlags FMF;\n-  if (isa<FPMathOperator>(CmpI))\n-    FMF = CmpI->getFastMathFlags();\n+  if (isa<FPMathOperator>(CmpI) && CmpI->hasNoNaNs())\n+    FMF.setNoNaNs();\n \n   // Bail out early.\n   if (CmpI->isEquality())\n",
+  "tests": [
+    {
+      "file": "llvm/test/Transforms/InstCombine/unordered-fcmp-select.ll",
+      "commands": [
+        "opt -S -passes=instcombine < %s"
+      ],
+      "tests": [
+        {
+          "test_name": "pr141017_select_nsz",
+          "test_body": "define float @pr141017_select_nsz(float %x) {\n  %cmp = fcmp olt float %x, 0.000000e+00\n  %sel = select nsz i1 %cmp, float -0.000000e+00, float %x\n  ret float %sel\n}\n"
+        },
+        {
+          "test_name": "pr141017",
+          "test_body": "define float @pr141017(float %x) {\n  %cmp = fcmp nsz olt float %x, 0.000000e+00\n  %sel = select i1 %cmp, float -0.000000e+00, float %x\n  ret float %sel\n}\n"
+        },
+        {
+          "test_name": "select_min_uge_2_use_cmp",
+          "test_body": "declare void @foo(i1)\n\ndefine float @select_min_uge_2_use_cmp(float %a, float %b) {\n  %cmp = fcmp ninf uge float %a, %b\n  call void @foo(i1 %cmp)\n  %sel = select nsz i1 %cmp, float %b, float %a\n  ret float %sel\n}\n"
+        }
+      ]
+    }
+  ],
+  "issue": {
+    "title": "[InstCombine] Miscompilation `select (fcmp nsz olt X, 0.0), -0.0, X -> select (fcmp nsz ole X, -0.0), -0.0, X`",
+    "body": "Reproducer: https://alive2.llvm.org/ce/z/Uydp8F\n```\ndefine float @src(float %x) {\n  %cmp = fcmp nsz olt float %x, 0.0\n  %sel = select i1 %cmp, float -0.0, float %x\n  ret float %sel\n}\n\ndefine float @tgt(float %x) {\n  %.inv = fcmp nsz ole float %x, -0.000000e+00\n  %sel1 = select i1 %.inv, float -0.000000e+00, float %x\n  ret float %sel1\n}\n```\n```\nTransformation doesn't verify!\n\nERROR: Target's return value is more undefined\n\nExample:\nfloat %x = #x00000000 (+0.0)\n\nSource:\ni1 %cmp = #x0 (0)\nfloat %sel = #x00000000 (+0.0)\n\nTarget:\ni1 %.inv = #x1 (1)\nfloat %sel1 = #x00000000 (+0.0)\nSource value: #x00000000 (+0.0)\nTarget value: #x00000000 (+0.0)\n```\n",
+    "author": "dtcxzyw",
+    "labels": [
+      "miscompilation",
+      "floating-point",
+      "llvm:analysis"
+    ],
+    "comments": []
+  },
+  "verified": true
+}

dataset/142895.json

@@ -0,0 +1,69 @@
+{
+  "bug_id": "142895",
+  "issue_url": "https://github.com/llvm/llvm-project/issues/142895",
+  "bug_type": "crash",
+  "base_commit": "d5d6f60632c6c6ef5a4342439f767e10880784e1",
+  "knowledge_cutoff": "2025-06-05T03:42:55Z",
+  "lit_test_dir": [
+    "llvm/test/Transforms/LoopUnroll"
+  ],
+  "hints": {
+    "fix_commit": "4eac8daa38990871e50b804c0cc19a3ad9c98db2",
+    "components": [
+      "LoopPeel"
+    ],
+    "bug_location_lineno": {
+      "llvm/lib/Transforms/Utils/LoopPeel.cpp": [
+        [
+          1257,
+          1263
+        ]
+      ]
+    },
+    "bug_location_funcname": {
+      "llvm/lib/Transforms/Utils/LoopPeel.cpp": [
+        "llvm::peelLoop"
+      ]
+    }
+  },
+  "patch": "commit 4eac8daa38990871e50b804c0cc19a3ad9c98db2\nAuthor: Yingwei Zheng <[email protected]>\nDate:   Fri Jun 6 12:56:28 2025 +0800\n\n    [LoopPeel] Handle non-local instructions/arguments when updating exiting values (#142993)\n    \n    Similar to\n    https://github.com/llvm/llvm-project/commit/7e14161f49b32387988cf9d937bbfaa27d0fbdd5,\n    the exiting value may be a non-local instruction or an argument.\n    \n    Closes https://github.com/llvm/llvm-project/issues/142895.\n\ndiff --git a/llvm/lib/Transforms/Utils/LoopPeel.cpp b/llvm/lib/Transforms/Utils/LoopPeel.cpp\nindex bd025fddd0cf..9149f71941db 100644\n--- a/llvm/lib/Transforms/Utils/LoopPeel.cpp\n+++ b/llvm/lib/Transforms/Utils/LoopPeel.cpp\n@@ -1257,7 +1257,11 @@ bool llvm::peelLoop(Loop *L, unsigned PeelCount, bool PeelLast, LoopInfo *LI,\n     // Now adjust users of the original exit values by replacing them with the\n     // exit value from the peeled iteration and remove them.\n     for (const auto &[P, E] : ExitValues) {\n-      P->replaceAllUsesWith(isa<Constant>(E) ? E : &*VMap.lookup(E));\n+      Instruction *ExitInst = dyn_cast<Instruction>(E);\n+      if (ExitInst && L->contains(ExitInst))\n+        P->replaceAllUsesWith(&*VMap[ExitInst]);\n+      else\n+        P->replaceAllUsesWith(E);\n       P->eraseFromParent();\n     }\n     formLCSSA(*L, DT, LI, SE);\n",
+  "tests": [
+    {
+      "file": "llvm/test/Transforms/LoopUnroll/unroll-and-peel-last-iteration.ll",
+      "commands": [
+        "opt -p loop-unroll -S %s"
+      ],
+      "tests": [
+        {
+          "test_name": "pr142895_exit_value_is_inst",
+          "test_body": "define i32 @pr142895_exit_value_is_inst(i32 %arg) {\nentry:\n  %mul = mul i32 %arg, 7\n  br label %loop\n\nloop:                                             ; preds = %loop, %entry\n  %indvar = phi i32 [ 0, %entry ], [ %inc, %loop ]\n  %cmp1 = icmp eq i32 %indvar, 32\n  %sel = select i1 %cmp1, i32 0, i32 0\n  %sub = sub i32 0, 0\n  %xor = xor i32 0, 0\n  %inc = add i32 %indvar, 1\n  %exitcond = icmp ne i32 %inc, 33\n  br i1 %exitcond, label %loop, label %exit\n\nexit:                                             ; preds = %loop\n  %exit.lcssa = phi i32 [ %mul, %loop ]\n  ret i32 %exit.lcssa\n}\n"
+        },
+        {
+          "test_name": "pr142895_exit_value_is_arg",
+          "test_body": "define i32 @pr142895_exit_value_is_arg(i32 %arg) {\nentry:\n  br label %loop\n\nloop:                                             ; preds = %loop, %entry\n  %indvar = phi i32 [ 0, %entry ], [ %inc, %loop ]\n  %cmp1 = icmp eq i32 %indvar, 32\n  %sel = select i1 %cmp1, i32 0, i32 0\n  %sub = sub i32 0, 0\n  %xor = xor i32 0, 0\n  %inc = add i32 %indvar, 1\n  %exitcond = icmp ne i32 %inc, 33\n  br i1 %exitcond, label %loop, label %exit\n\nexit:                                             ; preds = %loop\n  %exit.lcssa = phi i32 [ %arg, %loop ]\n  ret i32 %exit.lcssa\n}\n"
+        }
+      ]
+    }
+  ],
+  "issue": {
+    "title": "[LoopPeel] Assertion `V && \"Dereferencing deleted ValueHandle\"' failed.",
+    "body": "Crash is reproducible on Godbolt:\n[https://godbolt.org/z/4axfWq4dq](https://godbolt.org/z/4axfWq4dq)\n\nReproduce code (compile with `clang-21 -O3 foo.c`):\n```c\nchar func(char a, int b) {\n    return b < 32 ? b : 0;\n}\n\nint a;\nint b;\nint main() {\n    char v[4][4] = {};\n    for (int i = 0; i < 33; i++) {\n        for (int j = 0; j < 4; j++) {\n            for (int k = 0; k < 4; k++) {\n                a ^= v[0][k] - func(b ^= v[0][j], i);\n            }\n        }\n    }\n    return 0;\n}\n\n```\n\nStack dump:\n```\n #0 0x0000000003c94d38 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/opt/compiler-explorer/clang-trunk/bin/clang+0x3c94d38)\n #1 0x0000000003c92e7c llvm::sys::CleanupOnSignal(unsigned long) (/opt/compiler-explorer/clang-trunk/bin/clang+0x3c92e7c)\n #2 0x0000000003be36d8 CrashRecoverySignalHandler(int) CrashRecoveryContext.cpp:0:0\n #3 0x000074a5bf042520 (/lib/x86_64-linux-gnu/libc.so.6+0x42520)\n #4 0x0000000005876204 (anonymous namespace)::VectorCombine::foldSingleElementStore(llvm::Instruction&) VectorCombine.cpp:0:0\n #5 0x00000000058805d9 (anonymous namespace)::VectorCombine::run()::'lambda'(llvm::Instruction&)::operator()(llvm::Instruction&) const (.isra.0) VectorCombine.cpp:0:0\n #6 0x0000000005881057 llvm::VectorCombinePass::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x5881057)\n #7 0x0000000004e48f3e llvm::detail::PassModel<llvm::Function, llvm::VectorCombinePass, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x4e48f3e)\n #8 0x0000000003656ddf llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x3656ddf)\n #9 0x00000000011b1a9e llvm::detail::PassModel<llvm::Function, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x11b1a9e)\n#10 0x0000000002bec20e llvm::CGSCCToFunctionPassAdaptor::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x2bec20e)\n#11 0x00000000011b1f0e llvm::detail::PassModel<llvm::LazyCallGraph::SCC, llvm::CGSCCToFunctionPassAdaptor, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&>::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x11b1f0e)\n#12 0x0000000002be55c6 llvm::PassManager<llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&>::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x2be55c6)\n#13 0x0000000004e489ee llvm::detail::PassModel<llvm::LazyCallGraph::SCC, llvm::PassManager<llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&>, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&>::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x4e489ee)\n#14 0x0000000002bed3e9 llvm::DevirtSCCRepeatedPass::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x2bed3e9)\n#15 0x0000000004e48a0e llvm::detail::PassModel<llvm::LazyCallGraph::SCC, llvm::DevirtSCCRepeatedPass, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&>::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x4e48a0e)\n#16 0x0000000002be8043 llvm::ModuleToPostOrderCGSCCPassAdaptor::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x2be8043)\n#17 0x0000000004e489ce llvm::detail::PassModel<llvm::Module, llvm::ModuleToPostOrderCGSCCPassAdaptor, llvm::AnalysisManager<llvm::Module>>::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x4e489ce)\n#18 0x000000000365991f llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x365991f)\n#19 0x00000000054e64b9 llvm::ModuleInlinerWrapperPass::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x54e64b9)\n#20 0x0000000004d00f8e llvm::detail::PassModel<llvm::Module, llvm::ModuleInlinerWrapperPass, llvm::AnalysisManager<llvm::Module>>::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x4d00f8e)\n#21 0x000000000365991f llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x365991f)\n#22 0x0000000003f4491a (anonymous namespace)::EmitAssemblyHelper::RunOptimizationPipeline(clang::BackendAction, std::unique_ptr<llvm::raw_pwrite_stream, std::default_delete<llvm::raw_pwrite_stream>>&, std::unique_ptr<llvm::ToolOutputFile, std::default_delete<llvm::ToolOutputFile>>&, clang::BackendConsumer*) BackendUtil.cpp:0:0\n#23 0x0000000003f47412 clang::emitBackendOutput(clang::CompilerInstance&, clang::CodeGenOptions&, llvm::StringRef, llvm::Module*, clang::BackendAction, llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem>, std::unique_ptr<llvm::raw_pwrite_stream, std::default_delete<llvm::raw_pwrite_stream>>, clang::BackendConsumer*) (/opt/compiler-explorer/clang-trunk/bin/clang+0x3f47412)\n#24 0x00000000045e01e8 clang::BackendConsumer::HandleTranslationUnit(clang::ASTContext&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x45e01e8)\n#25 0x000000000624133c clang::ParseAST(clang::Sema&, bool, bool) (/opt/compiler-explorer/clang-trunk/bin/clang+0x624133c)\n#26 0x00000000045e0dbd clang::CodeGenAction::ExecuteAction() (/opt/compiler-explorer/clang-trunk/bin/clang+0x45e0dbd)\n#27 0x00000000048f107a clang::FrontendAction::Execute() (/opt/compiler-explorer/clang-trunk/bin/clang+0x48f107a)\n#28 0x000000000486ca6b clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x486ca6b)\n#29 0x00000000049e5683 clang::ExecuteCompilerInvocation(clang::CompilerInstance*) (/opt/compiler-explorer/clang-trunk/bin/clang+0x49e5683)\n#30 0x0000000000dcab25 cc1_main(llvm::ArrayRef<char const*>, char const*, void*) (/opt/compiler-explorer/clang-trunk/bin/clang+0xdcab25)\n#31 0x0000000000dc296d ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&, llvm::ToolContext const&) driver.cpp:0:0\n#32 0x0000000004652b59 void llvm::function_ref<void ()>::callback_fn<clang::driver::CC1Command::Execute(llvm::ArrayRef<std::optional<llvm::StringRef>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*) const::'lambda'()>(long) Job.cpp:0:0\n#33 0x0000000003be3af3 llvm::CrashRecoveryContext::RunSafely(llvm::function_ref<void ()>) (/opt/compiler-explorer/clang-trunk/bin/clang+0x3be3af3)\n#34 0x0000000004652d79 clang::driver::CC1Command::Execute(llvm::ArrayRef<std::optional<llvm::StringRef>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*) const (.part.0) Job.cpp:0:0\n#35 0x00000000046159ed clang::driver::Compilation::ExecuteCommand(clang::driver::Command const&, clang::driver::Command const*&, bool) const (/opt/compiler-explorer/clang-trunk/bin/clang+0x46159ed)\n#36 0x00000000046169b1 clang::driver::Compilation::ExecuteJobs(clang::driver::JobList const&, llvm::SmallVectorImpl<std::pair<int, clang::driver::Command const*>>&, bool) const (/opt/compiler-explorer/clang-trunk/bin/clang+0x46169b1)\n#37 0x00000000046212dc clang::driver::Driver::ExecuteCompilation(clang::driver::Compilation&, llvm::SmallVectorImpl<std::pair<int, clang::driver::Command const*>>&) (/opt/compiler-explorer/clang-trunk/bin/clang+0x46212dc)\n#38 0x0000000000dc72b1 clang_main(int, char**, llvm::ToolContext const&) (/opt/compiler-explorer/clang-trunk/bin/clang+0xdc72b1)\n#39 0x0000000000c47e24 main (/opt/compiler-explorer/clang-trunk/bin/clang+0xc47e24)\n#40 0x000074a5bf029d90 (/lib/x86_64-linux-gnu/libc.so.6+0x29d90)\n#41 0x000074a5bf029e40 __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x29e40)\n#42 0x0000000000dc2405 _start (/opt/compiler-explorer/clang-trunk/bin/clang+0xdc2405)\n```",
+    "author": "rivertale",
+    "labels": [
+      "regression",
+      "crash",
+      "llvm:transforms"
+    ],
+    "comments": [
+      {
+        "author": "shafik",
+        "body": "Looks like a regression on trunk: https://godbolt.org/z/d6P7cfxox"
+      },
+      {
+        "author": "dtcxzyw",
+        "body": "Reduced: https://godbolt.org/z/na9veEo6z\n```\n; bin/opt -passes=\"loop(loop-unroll-full)\" test.ll -S\ntarget datalayout = \"e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128\"\ntarget triple = \"x86_64-unknown-linux-gnu\"\n\ndefine i32 @main(i32 %b.promoted) {\nentry:\n  br label %for.cond1.preheader\n\nfor.cond1.preheader:                              ; preds = %for.cond1.preheader, %entry\n  %i.045 = phi i32 [ 0, %entry ], [ %inc21, %for.cond1.preheader ]\n  %cmp.i.not = icmp eq i32 %i.045, 32\n  %conv15 = select i1 %cmp.i.not, i32 0, i32 0\n  %sub.3.3 = sub i32 0, 0\n  %xor16.3.3 = xor i32 0, 0\n  %inc21 = add i32 %i.045, 1\n  %exitcond = icmp ne i32 %inc21, 33\n  br i1 %exitcond, label %for.cond1.preheader, label %for.cond.cleanup\n\nfor.cond.cleanup:                                 ; preds = %for.cond1.preheader\n  %xor.lcssa.lcssa.lcssa = phi i32 [ %b.promoted, %for.cond1.preheader ]\n  ret i32 %xor.lcssa.lcssa.lcssa\n}\n```\n```\nopt: /root/llvm-project/llvm/include/llvm/IR/ValueHandle.h:95: llvm::Value& llvm::ValueHandleBase::operator*() const: Assertion `V && \"Dereferencing deleted ValueHandle\"' failed.\nPLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace.\nStack dump:\n0.\tProgram arguments: /opt/compiler-explorer/clang-assertions-trunk/bin/opt -o /app/output.s -S -passes=loop(loop-unroll-full) <source>\n1.\tRunning pass \"function(loop(loop-unroll-full))\" on module \"<source>\"\n2.\tRunning pass \"loop(loop-unroll-full)\" on function \"main\"\n #0 0x0000000005628878 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x5628878)\n #1 0x0000000005626204 SignalHandler(int, siginfo_t*, void*) Signals.cpp:0:0\n #2 0x0000784aa1a42520 (/lib/x86_64-linux-gnu/libc.so.6+0x42520)\n #3 0x0000784aa1a969fc pthread_kill (/lib/x86_64-linux-gnu/libc.so.6+0x969fc)\n #4 0x0000784aa1a42476 gsignal (/lib/x86_64-linux-gnu/libc.so.6+0x42476)\n #5 0x0000784aa1a287f3 abort (/lib/x86_64-linux-gnu/libc.so.6+0x287f3)\n #6 0x0000784aa1a2871b (/lib/x86_64-linux-gnu/libc.so.6+0x2871b)\n #7 0x0000784aa1a39e96 (/lib/x86_64-linux-gnu/libc.so.6+0x39e96)\n #8 0x0000000004875d88 llvm::peelLoop(llvm::Loop*, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree&, llvm::AssumptionCache*, bool, llvm::ValueMap<llvm::Value const*, llvm::WeakTrackingVH, llvm::ValueMapConfig<llvm::Value const*, llvm::sys::SmartMutex<false>>>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x4875d88)\n #9 0x0000000004468359 tryToUnrollLoop(llvm::Loop*, llvm::DominatorTree&, llvm::LoopInfo*, llvm::ScalarEvolution&, llvm::TargetTransformInfo const&, llvm::AssumptionCache&, llvm::OptimizationRemarkEmitter&, llvm::BlockFrequencyInfo*, llvm::ProfileSummaryInfo*, bool, int, bool, bool, bool, std::optional<unsigned int>, std::optional<unsigned int>, std::optional<bool>, std::optional<bool>, std::optional<bool>, std::optional<bool>, std::optional<bool>, std::optional<unsigned int>, llvm::AAResults*) LoopUnrollPass.cpp:0:0\n#10 0x00000000044691af llvm::LoopFullUnrollPass::run(llvm::Loop&, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>&, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x44691af)\n#11 0x0000000002d9b20e llvm::detail::PassModel<llvm::Loop, llvm::LoopFullUnrollPass, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&>::run(llvm::Loop&, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>&, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x2d9b20e)\n#12 0x000000000440d346 std::optional<llvm::PreservedAnalyses> llvm::PassManager<llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&>::runSinglePass<llvm::Loop, std::unique_ptr<llvm::detail::PassConcept<llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&>, std::default_delete<llvm::detail::PassConcept<llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&>>>>(llvm::Loop&, std::unique_ptr<llvm::detail::PassConcept<llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&>, std::default_delete<llvm::detail::PassConcept<llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&>>>&, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>&, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&, llvm::PassInstrumentation&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x440d346)\n#13 0x000000000440d4ee llvm::PassManager<llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&>::runWithoutLoopNestPasses(llvm::Loop&, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>&, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x440d4ee)\n#14 0x000000000440e854 llvm::PassManager<llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&>::run(llvm::Loop&, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>&, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x440e854)\n#15 0x000000000440f35d llvm::FunctionToLoopPassAdaptor::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x440f35d)\n#16 0x0000000000ea0b8e llvm::detail::PassModel<llvm::Function, llvm::FunctionToLoopPassAdaptor, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0xea0b8e)\n#17 0x000000000541eae0 llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x541eae0)\n#18 0x0000000000ea19fe llvm::detail::PassModel<llvm::Function, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0xea19fe)\n#19 0x000000000541eff3 llvm::ModuleToFunctionPassAdaptor::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x541eff3)\n#20 0x0000000000ea084e llvm::detail::PassModel<llvm::Module, llvm::ModuleToFunctionPassAdaptor, llvm::AnalysisManager<llvm::Module>>::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0xea084e)\n#21 0x000000000541cc10 llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x541cc10)\n#22 0x0000000000956bba llvm::runPassPipeline(llvm::StringRef, llvm::Module&, llvm::TargetMachine*, llvm::TargetLibraryInfoImpl*, llvm::ToolOutputFile*, llvm::ToolOutputFile*, llvm::ToolOutputFile*, llvm::StringRef, llvm::ArrayRef<llvm::PassPlugin>, llvm::ArrayRef<std::function<void (llvm::PassBuilder&)>>, llvm::opt_tool::OutputKind, llvm::opt_tool::VerifierKind, bool, bool, bool, bool, bool, bool, bool) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x956bba)\n#23 0x000000000094a38c optMain (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x94a38c)\n#24 0x0000784aa1a29d90 (/lib/x86_64-linux-gnu/libc.so.6+0x29d90)\n#25 0x0000784aa1a29e40 __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x29e40)\n#26 0x0000000000941fc5 _start (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x941fc5)\nProgram terminated with signal: SIGSEGV\nCompiler returned: 139\n```"
+      }
+    ]
+  },
+  "verified": true
+}

dataset/143513.json

@@ -0,0 +1,114 @@
+{
+  "bug_id": "143513",
+  "issue_url": "https://github.com/llvm/llvm-project/issues/143513",
+  "bug_type": "crash",
+  "base_commit": "cf637b7e3554976419a0d672ad4c252137dc34f3",
+  "knowledge_cutoff": "2025-06-10T12:05:35Z",
+  "lit_test_dir": [
+    "llvm/test/Transforms/PhaseOrdering",
+    "llvm/test/Transforms/SLPVectorizer"
+  ],
+  "hints": {
+    "fix_commit": "0108a5908cab5e418c683ef9b6e1810755344b5e",
+    "components": [
+      "SLPVectorizer"
+    ],
+    "bug_location_lineno": {
+      "llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp": [
+        [
+          12085,
+          12091
+        ],
+        [
+          12130,
+          12136
+        ],
+        [
+          12152,
+          12159
+        ],
+        [
+          12171,
+          12182
+        ]
+      ]
+    },
+    "bug_location_funcname": {
+      "llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp": [
+        "computeExtractCost"
+      ]
+    }
+  },
+  "patch": "commit 0108a5908cab5e418c683ef9b6e1810755344b5e\nAuthor: Alexey Bataev <[email protected]>\nDate:   Tue Jun 17 07:55:52 2025 -0700\n\n    [SLP]Fix a crash on an subvector size calculation for non-power-of-2 vector\n    \n    Patch fixes cost estimation for the extractelements from non-power-of-2\n    vectors, defined as subvector extracts. In this case the subvector size\n    might be not adjusted to a whole register size, need to get the minimum\n    between whole vector size and the actual difference to prevent compiler\n    crash.\n    \n    Fixes #143513\n\ndiff --git a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp\nindex d811e9d77d18..4551a365a696 100644\n--- a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp\n+++ b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp\n@@ -12085,7 +12085,8 @@ class BoUpSLP::ShuffleCostEstimator : public BaseShuffleAnalysis {\n     // FIXME: this must be moved to TTI for better estimation.\n     unsigned EltsPerVector = getPartNumElems(VL.size(), NumParts);\n     auto CheckPerRegistersShuffle = [&](MutableArrayRef<int> Mask,\n-                                        SmallVectorImpl<unsigned> &Indices)\n+                                        SmallVectorImpl<unsigned> &Indices,\n+                                        SmallVectorImpl<unsigned> &SubVecSizes)\n         -> std::optional<TTI::ShuffleKind> {\n       if (NumElts <= EltsPerVector)\n         return std::nullopt;\n@@ -12130,7 +12131,9 @@ class BoUpSLP::ShuffleCostEstimator : public BaseShuffleAnalysis {\n                       return std::min(S, I);\n                     }),\n                 EltsPerVector);\n-            Indices.push_back(OffsetReg1 % NumElts);\n+            unsigned Index = OffsetReg1 % NumElts;\n+            Indices.push_back(Index);\n+            SubVecSizes.push_back(std::min(NumElts - Index, EltsPerVector));\n           }\n           Idx = I - OffsetReg1;\n         }\n@@ -12152,8 +12155,9 @@ class BoUpSLP::ShuffleCostEstimator : public BaseShuffleAnalysis {\n       SmallVector<int> SubMask(EltsPerVector, PoisonMaskElem);\n       copy(MaskSlice, SubMask.begin());\n       SmallVector<unsigned, 2> Indices;\n+      SmallVector<unsigned, 2> SubVecSizes;\n       std::optional<TTI::ShuffleKind> RegShuffleKind =\n-          CheckPerRegistersShuffle(SubMask, Indices);\n+          CheckPerRegistersShuffle(SubMask, Indices, SubVecSizes);\n       if (!RegShuffleKind) {\n         if (*ShuffleKinds[Part] != TTI::SK_PermuteSingleSrc ||\n             !ShuffleVectorInst::isIdentityMask(\n@@ -12171,12 +12175,12 @@ class BoUpSLP::ShuffleCostEstimator : public BaseShuffleAnalysis {\n       }\n       const unsigned BaseVF = getFullVectorNumberOfElements(\n           *R.TTI, VL.front()->getType(), alignTo(NumElts, EltsPerVector));\n-      for (unsigned Idx : Indices) {\n-        assert((Idx + EltsPerVector) <= BaseVF &&\n+      for (const auto [Idx, SubVecSize] : zip(Indices, SubVecSizes)) {\n+        assert((Idx + SubVecSize) <= BaseVF &&\n                \"SK_ExtractSubvector index out of range\");\n         Cost += ::getShuffleCost(TTI, TTI::SK_ExtractSubvector,\n                                  getWidenedType(ScalarTy, BaseVF), {}, CostKind,\n-                                 Idx, getWidenedType(ScalarTy, EltsPerVector));\n+                                 Idx, getWidenedType(ScalarTy, SubVecSize));\n       }\n       // Second attempt to check, if just a permute is better estimated than\n       // subvector extract.\n",
+  "tests": [
+    {
+      "file": "llvm/test/Transforms/PhaseOrdering/X86/hadd.ll",
+      "commands": [
+        "opt < %s -O3 -S -mtriple=x86_64-- -mcpu=x86-64",
+        "opt < %s -O3 -S -mtriple=x86_64-- -mcpu=x86-64-v2",
+        "opt < %s -O3 -S -mtriple=x86_64-- -mcpu=x86-64-v3",
+        "opt < %s -O3 -S -mtriple=x86_64-- -mcpu=x86-64-v4",
+        "opt < %s -passes=\"default<O3>\" -S -mtriple=x86_64-- -mcpu=x86-64",
+        "opt < %s -passes=\"default<O3>\" -S -mtriple=x86_64-- -mcpu=x86-64-v2",
+        "opt < %s -passes=\"default<O3>\" -S -mtriple=x86_64-- -mcpu=x86-64-v3",
+        "opt < %s -passes=\"default<O3>\" -S -mtriple=x86_64-- -mcpu=x86-64-v4"
+      ],
+      "tests": [
+        {
+          "test_name": "add_v16i16_0123u56789uBCDEF",
+          "test_body": "define <16 x i16> @add_v16i16_0123u56789uBCDEF(<16 x i16> %a, <16 x i16> %b) {\n  %a0 = extractelement <16 x i16> %a, i32 0\n  %a1 = extractelement <16 x i16> %a, i32 1\n  %a2 = extractelement <16 x i16> %a, i32 2\n  %a3 = extractelement <16 x i16> %a, i32 3\n  %a4 = extractelement <16 x i16> %a, i32 4\n  %a5 = extractelement <16 x i16> %a, i32 5\n  %a6 = extractelement <16 x i16> %a, i32 6\n  %a7 = extractelement <16 x i16> %a, i32 7\n  %a8 = extractelement <16 x i16> %a, i32 8\n  %a9 = extractelement <16 x i16> %a, i32 9\n  %aA = extractelement <16 x i16> %a, i32 10\n  %aB = extractelement <16 x i16> %a, i32 11\n  %aC = extractelement <16 x i16> %a, i32 12\n  %aD = extractelement <16 x i16> %a, i32 13\n  %aE = extractelement <16 x i16> %a, i32 14\n  %aF = extractelement <16 x i16> %a, i32 15\n  %a01 = add i16 %a0, %a1\n  %a23 = add i16 %a2, %a3\n  %a45 = add i16 %a4, %a5\n  %a67 = add i16 %a6, %a7\n  %a89 = add i16 %a8, %a9\n  %aAB = add i16 %aA, %aB\n  %aCD = add i16 %aC, %aD\n  %aEF = add i16 %aE, %aF\n  %b0 = extractelement <16 x i16> %b, i32 0\n  %b1 = extractelement <16 x i16> %b, i32 1\n  %b2 = extractelement <16 x i16> %b, i32 2\n  %b3 = extractelement <16 x i16> %b, i32 3\n  %b4 = extractelement <16 x i16> %b, i32 4\n  %b5 = extractelement <16 x i16> %b, i32 5\n  %b6 = extractelement <16 x i16> %b, i32 6\n  %b7 = extractelement <16 x i16> %b, i32 7\n  %b8 = extractelement <16 x i16> %b, i32 8\n  %b9 = extractelement <16 x i16> %b, i32 9\n  %bA = extractelement <16 x i16> %b, i32 10\n  %bB = extractelement <16 x i16> %b, i32 11\n  %bC = extractelement <16 x i16> %b, i32 12\n  %bD = extractelement <16 x i16> %b, i32 13\n  %bE = extractelement <16 x i16> %b, i32 14\n  %bF = extractelement <16 x i16> %b, i32 15\n  %b01 = add i16 %b0, %b1\n  %b23 = add i16 %b2, %b3\n  %b45 = add i16 %b4, %b5\n  %b67 = add i16 %b6, %b7\n  %b89 = add i16 %b8, %b9\n  %bAB = add i16 %bA, %bB\n  %bCD = add i16 %bC, %bD\n  %bEF = add i16 %bE, %bF\n  %hadd0 = insertelement <16 x i16> poison, i16 %a01, i32 0\n  %hadd1 = insertelement <16 x i16> %hadd0, i16 %a23, i32 1\n  %hadd2 = insertelement <16 x i16> %hadd1, i16 %a45, i32 2\n  %hadd3 = insertelement <16 x i16> %hadd2, i16 %a67, i32 3\n  %hadd4 = insertelement <16 x i16> %hadd3, i16 %b01, i32 4\n  %hadd5 = insertelement <16 x i16> %hadd4, i16 %b23, i32 5\n  %hadd6 = insertelement <16 x i16> %hadd5, i16 %b45, i32 6\n  %hadd7 = insertelement <16 x i16> %hadd6, i16 %b67, i32 7\n  %hadd8 = insertelement <16 x i16> %hadd7, i16 %a89, i32 8\n  %hadd9 = insertelement <16 x i16> %hadd8, i16 %aAB, i32 9\n  %haddA = insertelement <16 x i16> %hadd9, i16 %aCD, i32 10\n  %haddB = insertelement <16 x i16> %haddA, i16 %aEF, i32 11\n  %haddC = insertelement <16 x i16> %haddB, i16 %b89, i32 12\n  %haddD = insertelement <16 x i16> %haddC, i16 %bAB, i32 13\n  %haddE = insertelement <16 x i16> %haddD, i16 %bCD, i32 14\n  %haddF = insertelement <16 x i16> %haddE, i16 %bEF, i32 15\n  %result = shufflevector <16 x i16> %haddF, <16 x i16> %a, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 poison, i32 5, i32 6, i32 7, i32 8, i32 9, i32 poison, i32 11, i32 12, i32 13, i32 14, i32 15>\n  ret <16 x i16> %result\n}\n"
+        },
+        {
+          "test_name": "add_v16i16_0123456789ABCDEF",
+          "test_body": "define <16 x i16> @add_v16i16_0123456789ABCDEF(<16 x i16> %a, <16 x i16> %b) {\n  %a0 = extractelement <16 x i16> %a, i32 0\n  %a1 = extractelement <16 x i16> %a, i32 1\n  %a2 = extractelement <16 x i16> %a, i32 2\n  %a3 = extractelement <16 x i16> %a, i32 3\n  %a4 = extractelement <16 x i16> %a, i32 4\n  %a5 = extractelement <16 x i16> %a, i32 5\n  %a6 = extractelement <16 x i16> %a, i32 6\n  %a7 = extractelement <16 x i16> %a, i32 7\n  %a8 = extractelement <16 x i16> %a, i32 8\n  %a9 = extractelement <16 x i16> %a, i32 9\n  %aA = extractelement <16 x i16> %a, i32 10\n  %aB = extractelement <16 x i16> %a, i32 11\n  %aC = extractelement <16 x i16> %a, i32 12\n  %aD = extractelement <16 x i16> %a, i32 13\n  %aE = extractelement <16 x i16> %a, i32 14\n  %aF = extractelement <16 x i16> %a, i32 15\n  %a01 = add i16 %a0, %a1\n  %a23 = add i16 %a2, %a3\n  %a45 = add i16 %a4, %a5\n  %a67 = add i16 %a6, %a7\n  %a89 = add i16 %a8, %a9\n  %aAB = add i16 %aA, %aB\n  %aCD = add i16 %aC, %aD\n  %aEF = add i16 %aE, %aF\n  %b0 = extractelement <16 x i16> %b, i32 0\n  %b1 = extractelement <16 x i16> %b, i32 1\n  %b2 = extractelement <16 x i16> %b, i32 2\n  %b3 = extractelement <16 x i16> %b, i32 3\n  %b4 = extractelement <16 x i16> %b, i32 4\n  %b5 = extractelement <16 x i16> %b, i32 5\n  %b6 = extractelement <16 x i16> %b, i32 6\n  %b7 = extractelement <16 x i16> %b, i32 7\n  %b8 = extractelement <16 x i16> %b, i32 8\n  %b9 = extractelement <16 x i16> %b, i32 9\n  %bA = extractelement <16 x i16> %b, i32 10\n  %bB = extractelement <16 x i16> %b, i32 11\n  %bC = extractelement <16 x i16> %b, i32 12\n  %bD = extractelement <16 x i16> %b, i32 13\n  %bE = extractelement <16 x i16> %b, i32 14\n  %bF = extractelement <16 x i16> %b, i32 15\n  %b01 = add i16 %b0, %b1\n  %b23 = add i16 %b2, %b3\n  %b45 = add i16 %b4, %b5\n  %b67 = add i16 %b6, %b7\n  %b89 = add i16 %b8, %b9\n  %bAB = add i16 %bA, %bB\n  %bCD = add i16 %bC, %bD\n  %bEF = add i16 %bE, %bF\n  %hadd0 = insertelement <16 x i16> poison, i16 %a01, i32 0\n  %hadd1 = insertelement <16 x i16> %hadd0, i16 %a23, i32 1\n  %hadd2 = insertelement <16 x i16> %hadd1, i16 %a45, i32 2\n  %hadd3 = insertelement <16 x i16> %hadd2, i16 %a67, i32 3\n  %hadd4 = insertelement <16 x i16> %hadd3, i16 %b01, i32 4\n  %hadd5 = insertelement <16 x i16> %hadd4, i16 %b23, i32 5\n  %hadd6 = insertelement <16 x i16> %hadd5, i16 %b45, i32 6\n  %hadd7 = insertelement <16 x i16> %hadd6, i16 %b67, i32 7\n  %hadd8 = insertelement <16 x i16> %hadd7, i16 %a89, i32 8\n  %hadd9 = insertelement <16 x i16> %hadd8, i16 %aAB, i32 9\n  %haddA = insertelement <16 x i16> %hadd9, i16 %aCD, i32 10\n  %haddB = insertelement <16 x i16> %haddA, i16 %aEF, i32 11\n  %haddC = insertelement <16 x i16> %haddB, i16 %b89, i32 12\n  %haddD = insertelement <16 x i16> %haddC, i16 %bAB, i32 13\n  %haddE = insertelement <16 x i16> %haddD, i16 %bCD, i32 14\n  %haddF = insertelement <16 x i16> %haddE, i16 %bEF, i32 15\n  %result = shufflevector <16 x i16> %haddF, <16 x i16> %a, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>\n  ret <16 x i16> %result\n}\n"
+        }
+      ]
+    },
+    {
+      "file": "llvm/test/Transforms/PhaseOrdering/X86/hsub.ll",
+      "commands": [
+        "opt < %s -O3 -S -mtriple=x86_64-- -mcpu=x86-64",
+        "opt < %s -O3 -S -mtriple=x86_64-- -mcpu=x86-64-v2",
+        "opt < %s -O3 -S -mtriple=x86_64-- -mcpu=x86-64-v3",
+        "opt < %s -O3 -S -mtriple=x86_64-- -mcpu=x86-64-v4",
+        "opt < %s -passes=\"default<O3>\" -S -mtriple=x86_64-- -mcpu=x86-64",
+        "opt < %s -passes=\"default<O3>\" -S -mtriple=x86_64-- -mcpu=x86-64-v2",
+        "opt < %s -passes=\"default<O3>\" -S -mtriple=x86_64-- -mcpu=x86-64-v3",
+        "opt < %s -passes=\"default<O3>\" -S -mtriple=x86_64-- -mcpu=x86-64-v4"
+      ],
+      "tests": [
+        {
+          "test_name": "sub_v16i16_0123456789ABCDEF",
+          "test_body": "define <16 x i16> @sub_v16i16_0123456789ABCDEF(<16 x i16> %a, <16 x i16> %b) {\n  %a0 = extractelement <16 x i16> %a, i32 0\n  %a1 = extractelement <16 x i16> %a, i32 1\n  %a2 = extractelement <16 x i16> %a, i32 2\n  %a3 = extractelement <16 x i16> %a, i32 3\n  %a4 = extractelement <16 x i16> %a, i32 4\n  %a5 = extractelement <16 x i16> %a, i32 5\n  %a6 = extractelement <16 x i16> %a, i32 6\n  %a7 = extractelement <16 x i16> %a, i32 7\n  %a8 = extractelement <16 x i16> %a, i32 8\n  %a9 = extractelement <16 x i16> %a, i32 9\n  %aA = extractelement <16 x i16> %a, i32 10\n  %aB = extractelement <16 x i16> %a, i32 11\n  %aC = extractelement <16 x i16> %a, i32 12\n  %aD = extractelement <16 x i16> %a, i32 13\n  %aE = extractelement <16 x i16> %a, i32 14\n  %aF = extractelement <16 x i16> %a, i32 15\n  %a01 = sub i16 %a0, %a1\n  %a23 = sub i16 %a2, %a3\n  %a45 = sub i16 %a4, %a5\n  %a67 = sub i16 %a6, %a7\n  %a89 = sub i16 %a8, %a9\n  %aAB = sub i16 %aA, %aB\n  %aCD = sub i16 %aC, %aD\n  %aEF = sub i16 %aE, %aF\n  %b0 = extractelement <16 x i16> %b, i32 0\n  %b1 = extractelement <16 x i16> %b, i32 1\n  %b2 = extractelement <16 x i16> %b, i32 2\n  %b3 = extractelement <16 x i16> %b, i32 3\n  %b4 = extractelement <16 x i16> %b, i32 4\n  %b5 = extractelement <16 x i16> %b, i32 5\n  %b6 = extractelement <16 x i16> %b, i32 6\n  %b7 = extractelement <16 x i16> %b, i32 7\n  %b8 = extractelement <16 x i16> %b, i32 8\n  %b9 = extractelement <16 x i16> %b, i32 9\n  %bA = extractelement <16 x i16> %b, i32 10\n  %bB = extractelement <16 x i16> %b, i32 11\n  %bC = extractelement <16 x i16> %b, i32 12\n  %bD = extractelement <16 x i16> %b, i32 13\n  %bE = extractelement <16 x i16> %b, i32 14\n  %bF = extractelement <16 x i16> %b, i32 15\n  %b01 = sub i16 %b0, %b1\n  %b23 = sub i16 %b2, %b3\n  %b45 = sub i16 %b4, %b5\n  %b67 = sub i16 %b6, %b7\n  %b89 = sub i16 %b8, %b9\n  %bAB = sub i16 %bA, %bB\n  %bCD = sub i16 %bC, %bD\n  %bEF = sub i16 %bE, %bF\n  %hsub0 = insertelement <16 x i16> poison, i16 %a01, i32 0\n  %hsub1 = insertelement <16 x i16> %hsub0, i16 %a23, i32 1\n  %hsub2 = insertelement <16 x i16> %hsub1, i16 %a45, i32 2\n  %hsub3 = insertelement <16 x i16> %hsub2, i16 %a67, i32 3\n  %hsub4 = insertelement <16 x i16> %hsub3, i16 %b01, i32 4\n  %hsub5 = insertelement <16 x i16> %hsub4, i16 %b23, i32 5\n  %hsub6 = insertelement <16 x i16> %hsub5, i16 %b45, i32 6\n  %hsub7 = insertelement <16 x i16> %hsub6, i16 %b67, i32 7\n  %hsub8 = insertelement <16 x i16> %hsub7, i16 %a89, i32 8\n  %hsub9 = insertelement <16 x i16> %hsub8, i16 %aAB, i32 9\n  %hsubA = insertelement <16 x i16> %hsub9, i16 %aCD, i32 10\n  %hsubB = insertelement <16 x i16> %hsubA, i16 %aEF, i32 11\n  %hsubC = insertelement <16 x i16> %hsubB, i16 %b89, i32 12\n  %hsubD = insertelement <16 x i16> %hsubC, i16 %bAB, i32 13\n  %hsubE = insertelement <16 x i16> %hsubD, i16 %bCD, i32 14\n  %hsubF = insertelement <16 x i16> %hsubE, i16 %bEF, i32 15\n  %result = shufflevector <16 x i16> %hsubF, <16 x i16> %a, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>\n  ret <16 x i16> %result\n}\n"
+        },
+        {
+          "test_name": "sub_v16i16_0123u56789uBCDEF",
+          "test_body": "define <16 x i16> @sub_v16i16_0123u56789uBCDEF(<16 x i16> %a, <16 x i16> %b) {\n  %a0 = extractelement <16 x i16> %a, i32 0\n  %a1 = extractelement <16 x i16> %a, i32 1\n  %a2 = extractelement <16 x i16> %a, i32 2\n  %a3 = extractelement <16 x i16> %a, i32 3\n  %a4 = extractelement <16 x i16> %a, i32 4\n  %a5 = extractelement <16 x i16> %a, i32 5\n  %a6 = extractelement <16 x i16> %a, i32 6\n  %a7 = extractelement <16 x i16> %a, i32 7\n  %a8 = extractelement <16 x i16> %a, i32 8\n  %a9 = extractelement <16 x i16> %a, i32 9\n  %aA = extractelement <16 x i16> %a, i32 10\n  %aB = extractelement <16 x i16> %a, i32 11\n  %aC = extractelement <16 x i16> %a, i32 12\n  %aD = extractelement <16 x i16> %a, i32 13\n  %aE = extractelement <16 x i16> %a, i32 14\n  %aF = extractelement <16 x i16> %a, i32 15\n  %a01 = sub i16 %a0, %a1\n  %a23 = sub i16 %a2, %a3\n  %a45 = sub i16 %a4, %a5\n  %a67 = sub i16 %a6, %a7\n  %a89 = sub i16 %a8, %a9\n  %aAB = sub i16 %aA, %aB\n  %aCD = sub i16 %aC, %aD\n  %aEF = sub i16 %aE, %aF\n  %b0 = extractelement <16 x i16> %b, i32 0\n  %b1 = extractelement <16 x i16> %b, i32 1\n  %b2 = extractelement <16 x i16> %b, i32 2\n  %b3 = extractelement <16 x i16> %b, i32 3\n  %b4 = extractelement <16 x i16> %b, i32 4\n  %b5 = extractelement <16 x i16> %b, i32 5\n  %b6 = extractelement <16 x i16> %b, i32 6\n  %b7 = extractelement <16 x i16> %b, i32 7\n  %b8 = extractelement <16 x i16> %b, i32 8\n  %b9 = extractelement <16 x i16> %b, i32 9\n  %bA = extractelement <16 x i16> %b, i32 10\n  %bB = extractelement <16 x i16> %b, i32 11\n  %bC = extractelement <16 x i16> %b, i32 12\n  %bD = extractelement <16 x i16> %b, i32 13\n  %bE = extractelement <16 x i16> %b, i32 14\n  %bF = extractelement <16 x i16> %b, i32 15\n  %b01 = sub i16 %b0, %b1\n  %b23 = sub i16 %b2, %b3\n  %b45 = sub i16 %b4, %b5\n  %b67 = sub i16 %b6, %b7\n  %b89 = sub i16 %b8, %b9\n  %bAB = sub i16 %bA, %bB\n  %bCD = sub i16 %bC, %bD\n  %bEF = sub i16 %bE, %bF\n  %hsub0 = insertelement <16 x i16> poison, i16 %a01, i32 0\n  %hsub1 = insertelement <16 x i16> %hsub0, i16 %a23, i32 1\n  %hsub2 = insertelement <16 x i16> %hsub1, i16 %a45, i32 2\n  %hsub3 = insertelement <16 x i16> %hsub2, i16 %a67, i32 3\n  %hsub4 = insertelement <16 x i16> %hsub3, i16 %b01, i32 4\n  %hsub5 = insertelement <16 x i16> %hsub4, i16 %b23, i32 5\n  %hsub6 = insertelement <16 x i16> %hsub5, i16 %b45, i32 6\n  %hsub7 = insertelement <16 x i16> %hsub6, i16 %b67, i32 7\n  %hsub8 = insertelement <16 x i16> %hsub7, i16 %a89, i32 8\n  %hsub9 = insertelement <16 x i16> %hsub8, i16 %aAB, i32 9\n  %hsubA = insertelement <16 x i16> %hsub9, i16 %aCD, i32 10\n  %hsubB = insertelement <16 x i16> %hsubA, i16 %aEF, i32 11\n  %hsubC = insertelement <16 x i16> %hsubB, i16 %b89, i32 12\n  %hsubD = insertelement <16 x i16> %hsubC, i16 %bAB, i32 13\n  %hsubE = insertelement <16 x i16> %hsubD, i16 %bCD, i32 14\n  %hsubF = insertelement <16 x i16> %hsubE, i16 %bEF, i32 15\n  %result = shufflevector <16 x i16> %hsubF, <16 x i16> %a, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 poison, i32 5, i32 6, i32 7, i32 8, i32 9, i32 poison, i32 11, i32 12, i32 13, i32 14, i32 15>\n  ret <16 x i16> %result\n}\n"
+        }
+      ]
+    },
+    {
+      "file": "llvm/test/Transforms/SLPVectorizer/SystemZ/non-power-2-subvector-extract.ll",
+      "commands": [
+        "opt -S --passes=slp-vectorizer -mtriple=s390x-ibm-linux -mcpu=z13 -slp-max-reg-size=256 -slp-vectorize-hor-store -slp-vectorize-non-power-of-2 < %s"
+      ],
+      "tests": [
+        {
+          "test_name": "<module>",
+          "test_body": "\n@c = external global [1 x [10 x i32]]\[email protected] = external global i32\n\ndefine void @p() {\n;\nentry:\n  %arrayidx12.promoted.5.i = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 200), align 4\n  %conv14.5.i = xor i32 %arrayidx12.promoted.5.i, 1\n  store i32 %conv14.5.i, ptr getelementptr inbounds nuw (i8, ptr @c, i64 200), align 4\n  %arrayidx12.promoted.5.i.1 = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 204), align 4\n  %conv14.5.i.1 = xor i32 %arrayidx12.promoted.5.i.1, 1\n  store i32 %conv14.5.i.1, ptr getelementptr inbounds nuw (i8, ptr @c, i64 204), align 4\n  %arrayidx12.promoted.5.i.2 = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 208), align 4\n  %conv14.5.i.2 = xor i32 %arrayidx12.promoted.5.i.2, 1\n  store i32 %conv14.5.i.2, ptr getelementptr inbounds nuw (i8, ptr @c, i64 208), align 4\n  %arrayidx12.promoted.1.i.3 = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 52), align 4\n  %conv14.1.i.3 = xor i32 %arrayidx12.promoted.1.i.3, 1\n  store i32 %conv14.1.i.3, ptr getelementptr inbounds nuw (i8, ptr @c, i64 52), align 4\n  %arrayidx12.promoted.5.i.3 = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 212), align 4\n  %conv14.5.i.3 = xor i32 %arrayidx12.promoted.5.i.3, 1\n  store i32 %conv14.5.i.3, ptr getelementptr inbounds nuw (i8, ptr @c, i64 212), align 4\n  %arrayidx12.promoted.6.i.3 = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 252), align 4\n  %conv14.6.i.3 = xor i32 %arrayidx12.promoted.6.i.3, 1\n  %or.1.5.i.3 = or i32 %arrayidx12.promoted.1.i.3, %arrayidx12.promoted.5.i.3\n  store i32 %conv14.6.i.3, ptr getelementptr inbounds nuw (i8, ptr @c, i64 252), align 4\n  store i32 %or.1.5.i.3, ptr @j.0, align 4\n  %arrayidx12.promoted.1.i.4 = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 56), align 4\n  %conv14.1.i.4 = xor i32 %arrayidx12.promoted.1.i.4, 1\n  store i32 %conv14.1.i.4, ptr getelementptr inbounds nuw (i8, ptr @c, i64 56), align 4\n  %arrayidx12.promoted.5.i.4 = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 216), align 4\n  %conv14.5.i.4 = xor i32 %arrayidx12.promoted.5.i.4, 1\n  store i32 %conv14.5.i.4, ptr getelementptr inbounds nuw (i8, ptr @c, i64 216), align 4\n  %arrayidx12.promoted.6.i.4 = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 256), align 4\n  %conv14.6.i.4 = xor i32 %arrayidx12.promoted.6.i.4, 1\n  store i32 %conv14.6.i.4, ptr getelementptr inbounds nuw (i8, ptr @c, i64 256), align 4\n  %arrayidx12.promoted.1.i.5 = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 60), align 4\n  %conv14.1.i.5 = xor i32 %arrayidx12.promoted.1.i.5, 1\n  store i32 %conv14.1.i.5, ptr getelementptr inbounds nuw (i8, ptr @c, i64 60), align 4\n  %arrayidx12.promoted.5.i.5 = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 220), align 4\n  %conv14.5.i.5 = xor i32 %arrayidx12.promoted.5.i.5, 1\n  store i32 %conv14.5.i.5, ptr getelementptr inbounds nuw (i8, ptr @c, i64 220), align 4\n  %arrayidx12.promoted.6.i.5 = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 260), align 4\n  %conv14.6.i.5 = xor i32 %arrayidx12.promoted.6.i.5, 1\n  %0 = or i32 %arrayidx12.promoted.6.i.4, %arrayidx12.promoted.1.i.5\n  %or.1.5.i.5 = or i32 %0, %arrayidx12.promoted.5.i.5\n  %or.1.6.i.5 = or i32 %or.1.5.i.5, %arrayidx12.promoted.6.i.5\n  store i32 %conv14.6.i.5, ptr getelementptr inbounds nuw (i8, ptr @c, i64 260), align 4\n  store i32 %or.1.6.i.5, ptr @j.0, align 4\n  %arrayidx12.promoted.1.i.6 = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 64), align 4\n  %conv14.1.i.6 = xor i32 %arrayidx12.promoted.1.i.6, 1\n  store i32 %conv14.1.i.6, ptr getelementptr inbounds nuw (i8, ptr @c, i64 64), align 4\n  %arrayidx12.promoted.5.i.6 = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 224), align 4\n  %conv14.5.i.6 = xor i32 %arrayidx12.promoted.5.i.6, 1\n  store i32 %conv14.5.i.6, ptr getelementptr inbounds nuw (i8, ptr @c, i64 224), align 4\n  %arrayidx12.promoted.6.i.6 = load i32, ptr getelementptr inbounds nuw (i8, ptr @c, i64 264), align 4\n  %conv14.6.i.6 = xor i32 %arrayidx12.promoted.6.i.6, 1\n  store i32 %conv14.6.i.6, ptr getelementptr inbounds nuw (i8, ptr @c, i64 264), align 4\n  ret void\n}"
+        }
+      ]
+    }
+  ],
+  "issue": {
+    "title": "SLP Vectorizer Options trigger Assertion in cost computation on `s390x`",
+    "body": "While running experiments with `csmith`, i ran into the following example (already reduced with `cvise`):\n```C\nstatic int c[][10];\nshort d;\nlong *e;\nlong f;\nint g, k;\nchar h, i;\nstatic int j[3];\nvoid l();\nstatic int *m() {\n  short *n = &d;\n  d = 0;\n  for (; d <= 2;)\n    if (*n)\n      ;\n    else\n      return j;\n  return &g;\n}\nvoid p() { l(); }\nvoid l() {\n  int *q;\n  h = 0;\n  for (; h <= 6; h++) {\n    int **r = &q;\n    *e = 4073709551615;\n    *r = m();\n    k = 0;\n    for (; k <= 6; k++) {\n      i = 2;\n      for (; i <= 6; i++)\n        **r |= c[k][h] ^= f;\n    }\n  }\n}\n```\n When compiling this with the options\n```\n  -O3 \\\n  -S \\\n  -w \\\n  -c \\\n  -o a.out \\\n  --target=s390x-ibm-linux \\\n  -march=z13 \\\n  -mllvm -slp-max-reg-size=256 \\\n  -mllvm -slp-vectorize-hor-store \\\n  -mllvm -slp-vectorize-non-power-of-2 \\\n  -mllvm -enable-tbaa=false \\\n```\nThe assertion `(Idx + EltsPerVector) <= BaseVF && \"SK_ExtractSubvector index out of range\"` fails in `llvm::slpvectorizer::BoUpSLP::ShuffleCostEstimator::computeExtractCost`. This does not seem to be an issue on X86.\n\n[repro.tar.gz](https://github.com/user-attachments/files/20672338/repro.tar.gz)",
+    "author": "dominik-steenken",
+    "labels": [
+      "llvm:SLPVectorizer",
+      "crash"
+    ],
+    "comments": []
+  },
+  "verified": true
+}

dataset/144212.json

@@ -0,0 +1,82 @@
+{
+  "bug_id": "144212",
+  "issue_url": "https://github.com/llvm/llvm-project/issues/144212",
+  "bug_type": "crash",
+  "base_commit": "a383b1a95b63cf120b3dea554c2d66ccfaee066b",
+  "knowledge_cutoff": "2025-06-14T07:41:27Z",
+  "lit_test_dir": [
+    "llvm/test/Transforms/LoopVectorize"
+  ],
+  "hints": {
+    "fix_commit": "30b16ec3415e7ddb597d096f818d011b1b4e6a63",
+    "components": [
+      "LoopVectorize"
+    ],
+    "bug_location_lineno": {
+      "llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp": [
+        [
+          1141,
+          1146
+        ]
+      ]
+    },
+    "bug_location_funcname": {
+      "llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp": [
+        "simplifyRecipe"
+      ]
+    }
+  },
+  "patch": "commit 30b16ec3415e7ddb597d096f818d011b1b4e6a63\nAuthor: Florian Hahn <[email protected]>\nDate:   Mon Jun 16 22:54:25 2025 +0100\n\n    [VPlan] Simplify trivial VPFirstOrderRecurrencePHI recipes.\n    \n    VPFirstOrderRecurrencePHIRecipes where the incoming values are the same\n    can be simplified and removed.\n    \n    Fixes https://github.com/llvm/llvm-project/issues/144212.\n    \n    The new test is added together with other related tests from\n    first-order-recurrence.ll\n\ndiff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp\nindex 44a72755b9cf..05a0e15f9a19 100644\n--- a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp\n+++ b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp\n@@ -1141,6 +1141,12 @@ static void simplifyRecipe(VPRecipeBase &R, VPTypeAnalysis &TypeInfo) {\n     return;\n   }\n \n+  if (auto *Phi = dyn_cast<VPFirstOrderRecurrencePHIRecipe>(Def)) {\n+    if (Phi->getOperand(0) == Phi->getOperand(1))\n+      Def->replaceAllUsesWith(Phi->getOperand(0));\n+    return;\n+  }\n+\n   // Some simplifications can only be applied after unrolling. Perform them\n   // below.\n   if (!Plan->isUnrolled())\n",
+  "tests": [
+    {
+      "file": "llvm/test/Transforms/LoopVectorize/first-order-recurrence-dead-instructions.ll",
+      "commands": [
+        "opt -passes=loop-vectorize -force-vector-width=4 -force-vector-interleave=2 -S %s"
+      ],
+      "tests": [
+        {
+          "test_name": "<module>",
+          "test_body": "\n; Test case for https://github.com/llvm/llvm-project/issues/144212.\ndefine i8 @recurrence_phi_with_same_incoming_values_after_simplifications(i8 %for.start, ptr %dst) {\n;\nentry:\n  br label %loop\n\nloop:\n  %iv = phi i32 [ 1, %entry ], [ %iv.next, %loop ]\n  %for = phi i8 [ %for.start, %entry ], [ %for.next, %loop ]\n  %for.next = and i8 %for.start, -1\n  %iv.next = add i32 %iv, 1\n  %gep.dst = getelementptr inbounds i8, ptr %dst, i32 %iv\n  store i8 %for, ptr %gep.dst\n  %ec = icmp eq i32 %iv.next, 0\n  br i1 %ec, label %exit, label %loop\n\nexit:\n  ret i8 %for.next\n}\n\n; %vec.dead will be marked as dead instruction in the vector loop and no recipe\n; will be created for it. Make sure a valid sink target is used.\ndefine i32 @sink_after_dead_inst(ptr %A.ptr) {\n;\nentry:\n  br label %loop\n\nloop:\n  %iv = phi i16 [ 0, %entry ], [ %iv.next, %loop ]\n  %for = phi i32 [ 0, %entry ], [ %for.prev, %loop ]\n  %cmp = icmp eq i32 %for, 15\n  %C = icmp eq i1 %cmp, true\n  %vec.dead = and i1 %C, 1\n  %iv.next = add i16 %iv, 1\n  %B1 = or i16 %iv.next, %iv.next\n  %B3 = and i1 %cmp, %C\n  %for.prev = zext i16 %B1 to i32\n\n  %ext = zext i1 %B3 to i32\n  %A.gep = getelementptr i32, ptr %A.ptr, i16 %iv\n  store i32 0, ptr %A.gep\n  br i1 %vec.dead, label %for.end, label %loop\n\nfor.end:\n  ret i32 %for\n}\n\n; Dead instructions, like the exit condition are not part of the actual VPlan\n; and do not need to be sunk. PR44634.\ndefine void @sink_dead_inst(ptr %a) {\n;\nentry:\n  br label %for.cond\n\nfor.cond:\n  %iv = phi i16 [ -27, %entry ], [ %iv.next, %for.cond ]\n  %rec.1 = phi i16 [ 0, %entry ], [ %rec.1.prev, %for.cond ]\n  %rec.2 = phi i32 [ -27, %entry ], [ %rec.2.prev, %for.cond ]\n  %use.rec.1 = sub i16 %rec.1, 10\n  %cmp = icmp eq i32 %rec.2, 15\n  %iv.next = add i16 %iv, 1\n  %rec.2.prev = zext i16 %iv.next to i32\n  %rec.1.prev = add i16 %iv.next, 5\n  %gep = getelementptr i16, ptr %a, i16 %iv\n  store i16 %use.rec.1, ptr %gep\n  br i1 %cmp, label %for.end, label %for.cond\n\nfor.end:\n  ret void\n}\n\n; %rec.1 only has %use.rec.1 as use, which can be removed. This enables %rec.1\n; to be removed also.\ndefine void @unused_recurrence(ptr %a) {\n;\nentry:\n  br label %for.cond\n\nfor.cond:\n  %iv = phi i16 [ -27, %entry ], [ %iv.next, %for.cond ]\n  %rec.1 = phi i16 [ 0, %entry ], [ %rec.1.prev, %for.cond ]\n  %use.rec.1 = sub i16 %rec.1, 10\n  %iv.next= add i16 %iv, 1\n  %rec.1.prev = add i16 %iv.next, 5\n  %cmp = icmp eq i16 %iv, 1000\n  br i1 %cmp, label %for.end, label %for.cond\n\nfor.end:\n  ret void\n}"
+        }
+      ]
+    },
+    {
+      "file": "llvm/test/Transforms/LoopVectorize/first-order-recurrence.ll",
+      "commands": [
+        "opt < %s -passes=loop-vectorize -force-vector-width=4 -force-vector-interleave=2 -force-widen-divrem-via-safe-divisor=0 -S",
+        "opt < %s -passes=loop-vectorize -force-vector-width=1 -force-vector-interleave=2 -force-widen-divrem-via-safe-divisor=0 -S",
+        "opt < %s -passes=loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -force-widen-divrem-via-safe-divisor=0 -S"
+      ],
+      "tests": [
+        {
+          "test_name": "recurence_uniform_load",
+          "test_body": "target datalayout = \"e-m:e-i64:64-i128:128-n32:64-S128\"\n\ndefine i32 @recurence_uniform_load(ptr %src, ptr noalias %dst) {\nentry:\n  br label %loop\n\nloop:                                             ; preds = %loop, %entry\n  %phi = phi i64 [ 0, %entry ], [ %add, %loop ]\n  %recur = phi i32 [ 0, %entry ], [ %load, %loop ]\n  %add = add i64 %phi, 1\n  %load = load i32, ptr %src, align 4\n  %icmp = icmp ult i64 %phi, 1\n  br i1 %icmp, label %loop, label %exit\n\nexit:                                             ; preds = %loop\n  ret i32 0\n}\n"
+        },
+        {
+          "test_name": "sink_into_replication_region",
+          "test_body": "target datalayout = \"e-m:e-i64:64-i128:128-n32:64-S128\"\n\ndefine i32 @sink_into_replication_region(i32 %y, ptr %dst) {\nbb:\n  br label %bb2\n\nbb1:                                              ; preds = %bb2\n  %var = phi i32 [ %var6, %bb2 ]\n  ret i32 %var\n\nbb2:                                              ; preds = %bb2, %bb\n  %var3 = phi i32 [ %var8, %bb2 ], [ %y, %bb ]\n  %var4 = phi i32 [ %var7, %bb2 ], [ 0, %bb ]\n  %var5 = phi i32 [ %var6, %bb2 ], [ 0, %bb ]\n  %var6 = add i32 %var5, %var4\n  %var7 = udiv i32 219220132, %var3\n  %var8 = add nsw i32 %var3, -1\n  store i32 %var4, ptr %dst, align 4\n  %var9 = icmp slt i32 %var3, 2\n  br i1 %var9, label %bb1, label %bb2, !prof !0\n}\n\n!0 = !{!\"branch_weights\", i32 1, i32 1}\n"
+        }
+      ]
+    }
+  ],
+  "issue": {
+    "title": "[LoopVectorize] Assertion failure: Instruction does not dominate all uses!",
+    "body": "Reproducer: https://godbolt.org/z/WqTM1vavE\n```\n; bin/opt -passes=loop-vectorize test.ll -S\ntarget datalayout = \"e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128\"\ntarget triple = \"x86_64-unknown-linux-gnu\"\n\ndefine i8 @test(ptr %p) {\nentry:\n  %.promoted835.i = load i8, ptr %p, align 1\n  br label %for.inc346.i\n\nfor.inc346.i:                                     ; preds = %for.inc346.i, %entry\n  %storemerge827.i = phi i32 [ 1, %entry ], [ %inc347.i, %for.inc346.i ]\n  %conv267822825.i = phi i8 [ %.promoted835.i, %entry ], [ %conv267.i, %for.inc346.i ]\n  %conv267.i = and i8 %.promoted835.i, -1\n  %inc347.i = add i32 %storemerge827.i, 1\n  %exitcond.not.i217 = icmp eq i32 %inc347.i, 0\n  br i1 %exitcond.not.i217, label %cleanup636.thread812.i, label %for.inc346.i\n\ncleanup636.thread812.i:                           ; preds = %for.inc346.i\n  ret i8 %conv267.i\n}\n```\n```\nInstruction does not dominate all uses!\n  %broadcast.splat2 = shufflevector <16 x i8> %broadcast.splatinsert1, <16 x i8> poison, <16 x i32> zeroinitializer\n  %vector.recur = phi <16 x i8> [ %vector.recur.init, %vector.ph ], [ %broadcast.splat2, %vector.body ]\nopt: /root/llvm-project/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp:10329: bool llvm::LoopVectorizePass::processLoop(llvm::Loop*): Assertion `!verifyFunction(*L->getHeader()->getParent(), &dbgs())' failed.\nPLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace.\nStack dump:\n0.\tProgram arguments: /opt/compiler-explorer/clang-assertions-trunk/bin/opt -o /app/output.s -S -passes=loop-vectorize <source>\n1.\tRunning pass \"function(loop-vectorize<no-interleave-forced-only;no-vectorize-forced-only;>)\" on module \"<source>\"\n2.\tRunning pass \"loop-vectorize<no-interleave-forced-only;no-vectorize-forced-only;>\" on function \"test\"\n #0 0x000000000563b448 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x563b448)\n #1 0x0000000005638dd4 SignalHandler(int, siginfo_t*, void*) Signals.cpp:0:0\n #2 0x000072139da42520 (/lib/x86_64-linux-gnu/libc.so.6+0x42520)\n #3 0x000072139da969fc pthread_kill (/lib/x86_64-linux-gnu/libc.so.6+0x969fc)\n #4 0x000072139da42476 gsignal (/lib/x86_64-linux-gnu/libc.so.6+0x42476)\n #5 0x000072139da287f3 abort (/lib/x86_64-linux-gnu/libc.so.6+0x287f3)\n #6 0x000072139da2871b (/lib/x86_64-linux-gnu/libc.so.6+0x2871b)\n #7 0x000072139da39e96 (/lib/x86_64-linux-gnu/libc.so.6+0x39e96)\n #8 0x000000000348514a llvm::LoopVectorizePass::processLoop(llvm::Loop*) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x348514a)\n #9 0x0000000003486e90 llvm::LoopVectorizePass::runImpl(llvm::Function&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x3486e90)\n#10 0x00000000034874e3 llvm::LoopVectorizePass::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x34874e3)\n#11 0x0000000002da157e llvm::detail::PassModel<llvm::Function, llvm::LoopVectorizePass, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x2da157e)\n#12 0x000000000542c281 llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x542c281)\n#13 0x0000000000ea33fe llvm::detail::PassModel<llvm::Function, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0xea33fe)\n#14 0x000000000542c763 llvm::ModuleToFunctionPassAdaptor::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x542c763)\n#15 0x0000000000ea224e llvm::detail::PassModel<llvm::Module, llvm::ModuleToFunctionPassAdaptor, llvm::AnalysisManager<llvm::Module>>::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0xea224e)\n#16 0x000000000542a331 llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x542a331)\n#17 0x000000000095988a llvm::runPassPipeline(llvm::StringRef, llvm::Module&, llvm::TargetMachine*, llvm::TargetLibraryInfoImpl*, llvm::ToolOutputFile*, llvm::ToolOutputFile*, llvm::ToolOutputFile*, llvm::StringRef, llvm::ArrayRef<llvm::PassPlugin>, llvm::ArrayRef<std::function<void (llvm::PassBuilder&)>>, llvm::opt_tool::OutputKind, llvm::opt_tool::VerifierKind, bool, bool, bool, bool, bool, bool, bool) (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x95988a)\n#18 0x000000000094d05c optMain (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x94d05c)\n#19 0x000072139da29d90 (/lib/x86_64-linux-gnu/libc.so.6+0x29d90)\n#20 0x000072139da29e40 __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x29e40)\n#21 0x0000000000944c95 _start (/opt/compiler-explorer/clang-assertions-trunk/bin/opt+0x944c95)\nProgram terminated with signal: SIGSEGV\nCompiler returned: 139\n```\ncc @fhahn ",
+    "author": "dtcxzyw",
+    "labels": [
+      "vectorizers",
+      "crash-on-valid"
+    ],
+    "comments": [
+      {
+        "author": "fhahn",
+        "body": "Taking a look. I assume this is coming from a larger reproducer? Looks like there are missed scalar folding opportunities."
+      },
+      {
+        "author": "lukel97",
+        "body": "Bisected back to 5f39be591714eba1be413e2b3ed6fc152a15bb8e"
+      }
+    ]
+  },
+  "verified": true
+}

dataset/144279.json

@@ -0,0 +1,60 @@
+{
+  "bug_id": "144279",
+  "issue_url": "https://github.com/llvm/llvm-project/issues/144279",
+  "bug_type": "crash",
+  "base_commit": "7e6c1bd3edf4fc19be70587a4ac33a76bab78c02",
+  "knowledge_cutoff": "2025-06-15T21:04:55Z",
+  "lit_test_dir": [
+    "llvm/test/Transforms/InstSimplify/ConstProp"
+  ],
+  "hints": {
+    "fix_commit": "80b79ce432bbe12701fd9fe495ff9feeb5e4b9ca",
+    "components": [
+      "ConstantFold"
+    ],
+    "bug_location_lineno": {
+      "llvm/lib/Analysis/ConstantFolding.cpp": [
+        [
+          432,
+          437
+        ]
+      ]
+    },
+    "bug_location_funcname": {
+      "llvm/lib/Analysis/ConstantFolding.cpp": [
+        "ReadDataFromGlobal"
+      ]
+    }
+  },
+  "patch": "commit 80b79ce432bbe12701fd9fe495ff9feeb5e4b9ca\nAuthor: Nikita Popov <[email protected]>\nDate:   Tue Jun 17 09:30:28 2025 +0200\n\n    [ConstantFolding] Handle reading from type padding (#144330)\n    \n    ReadDataFromGlobal() did not handle reads from the padding of types (in\n    the sense of type store size != type alloc size, rather than struct\n    padding).\n    \n    Return zero in that case.\n    \n    Fixes https://github.com/llvm/llvm-project/issues/144279.\n\ndiff --git a/llvm/lib/Analysis/ConstantFolding.cpp b/llvm/lib/Analysis/ConstantFolding.cpp\nindex 2b7a438a9ef0..b58f9b26a865 100644\n--- a/llvm/lib/Analysis/ConstantFolding.cpp\n+++ b/llvm/lib/Analysis/ConstantFolding.cpp\n@@ -432,6 +432,10 @@ bool ReadDataFromGlobal(Constant *C, uint64_t ByteOffset, unsigned char *CurPtr,\n   assert(ByteOffset <= DL.getTypeAllocSize(C->getType()) &&\n          \"Out of range access\");\n \n+  // Reading type padding, return zero.\n+  if (ByteOffset >= DL.getTypeStoreSize(C->getType()))\n+    return true;\n+\n   // If this element is zero or undefined, we can just return since *CurPtr is\n   // zero initialized.\n   if (isa<ConstantAggregateZero>(C) || isa<UndefValue>(C))\n",
+  "tests": [
+    {
+      "file": "llvm/test/Transforms/InstSimplify/ConstProp/loads.ll",
+      "commands": [
+        "opt < %s -passes=instsimplify -S"
+      ],
+      "tests": [
+        {
+          "test_name": "<module>",
+          "test_body": "@i40_struct = constant { i40, i8 } { i40 0, i8 1 }\n@i40_array = constant [2 x i40] [i40 0, i40 1]\n\ndefine i8 @load_i40_struct_padding() {\n  %v = load i8, ptr getelementptr (i8, ptr @i40_struct, i64 6)\n  ret i8 %v\n}\n"
+        }
+      ]
+    }
+  ],
+  "issue": {
+    "title": "[AggressiveInstCombine] assertion failure loading from non-power-of-two byte-sized zero field of global struct",
+    "body": "```llvm\n@0 = constant { i40, i1 } { i40 0, i1 1 }\ndefine void @f() {\n  %1 = load i1, ptr @0\n  ret void\n}\n```\n```\n$ opt --version\nLLVM (http://llvm.org/):\n  LLVM version 20.1.7\n  DEBUG build with assertions.\n  Default target: x86_64-unknown-linux-gnu\n  Host CPU: znver5\n$ opt -S -passes aggressive-instcombine reduced.ll\nopt: llvm/lib/Support/APInt.cpp:457: APInt llvm::APInt::extractBits(unsigned int, unsigned int) const: Assertion `bitPosition < BitWidth && (numBits + bitPosition) <= BitWidth && \"Illegal bit extraction\"' failed.\nPLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace.\nStack dump:\n0.\tProgram arguments: 20.x-Debug/bin/opt -passes aggressive-instcombine reduced.ll -S\n1.\tRunning pass \"function(aggressive-instcombine)\" on module \"reduced.ll\"\n2.\tRunning pass \"aggressive-instcombine\" on function \"f\"\n #0 0x00007f6af9311bc6 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) llvm/lib/Support/Unix/Signals.inc:799:11\n #1 0x00007f6af931212f PrintStackTraceSignalHandler(void*) llvm/lib/Support/Unix/Signals.inc:875:1\n #2 0x00007f6af93101a0 llvm::sys::RunSignalHandlers() llvm/lib/Support/Signals.cpp:105:5\n #3 0x00007f6af931275e SignalHandler(int) llvm/lib/Support/Unix/Signals.inc:415:1\n #4 0x00007f6af8b56750 (/usr/lib64/libc.so.6+0x3d750)\n #5 0x00007f6af8bafa9c (/usr/lib64/libc.so.6+0x96a9c)\n #6 0x00007f6af8b56616 raise (/usr/lib64/libc.so.6+0x3d616)\n #7 0x00007f6af8b3e28d abort (/usr/lib64/libc.so.6+0x2528d)\n #8 0x00007f6af8b3e1f5 __assert_perror_fail (/usr/lib64/libc.so.6+0x251f5)\n #9 0x00007f6af91021db llvm::APInt::extractBits(unsigned int, unsigned int) const llvm/lib/Support/APInt.cpp:0:3\n#10 0x00007f6afaa4c319 (anonymous namespace)::ReadDataFromGlobal(llvm::Constant*, unsigned long, unsigned char*, unsigned int, llvm::DataLayout const&) llvm/lib/Analysis/ConstantFolding.cpp:445:45\n#11 0x00007f6afaa4c68b (anonymous namespace)::ReadDataFromGlobal(llvm::Constant*, unsigned long, unsigned char*, unsigned int, llvm::DataLayout const&) llvm/lib/Analysis/ConstantFolding.cpp:478:32\n#12 0x00007f6afaa4d3ee (anonymous namespace)::FoldReinterpretLoadFromConst(llvm::Constant*, llvm::Type*, long, llvm::DataLayout const&) llvm/lib/Analysis/ConstantFolding.cpp:622:7\n#13 0x00007f6afaa4cf72 llvm::ConstantFoldLoadFromConst(llvm::Constant*, llvm::Type*, llvm::APInt const&, llvm::DataLayout const&) llvm/lib/Analysis/ConstantFolding.cpp:723:19\n#14 0x00007f6afc550eb3 foldPatternedLoads(llvm::Instruction&, llvm::DataLayout const&) llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp:910:15\n#15 0x00007f6afc54dca8 foldUnusualPatterns(llvm::Function&, llvm::DominatorTree&, llvm::TargetTransformInfo&, llvm::TargetLibraryInfo&, llvm::AAResults&, llvm::AssumptionCache&, bool&) llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp:1253:21\n#16 0x00007f6afc54d9bd runImpl(llvm::Function&, llvm::AssumptionCache&, llvm::TargetTransformInfo&, llvm::TargetLibraryInfo&, llvm::DominatorTree&, llvm::AAResults&, bool&) llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp:1278:17\n#17 0x00007f6afc54d855 llvm::AggressiveInstCombinePass::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp:1290:7\n#18 0x00007f6aff99a1d8 llvm::detail::PassModel<llvm::Function, llvm::AggressiveInstCombinePass, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) llvm/include/llvm/IR/PassManagerInternal.h:91:17\n#19 0x00007f6af9de0ed2 llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) llvm/include/llvm/IR/PassManagerImpl.h:85:5\n#20 0x00007f6b06c0be58 llvm::detail::PassModel<llvm::Function, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) llvm/include/llvm/IR/PassManagerInternal.h:91:17\n#21 0x00007f6af9ddf7f5 llvm::ModuleToFunctionPassAdaptor::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) llvm/lib/IR/PassManager.cpp:124:38\n#22 0x00007f6b06c2d648 llvm::detail::PassModel<llvm::Module, llvm::ModuleToFunctionPassAdaptor, llvm::AnalysisManager<llvm::Module>>::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) llvm/include/llvm/IR/PassManagerInternal.h:91:17\n#23 0x00007f6af9ddfdf2 llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) llvm/include/llvm/IR/PassManagerImpl.h:85:5\n#24 0x00007f6b088241ce llvm::runPassPipeline(llvm::StringRef, llvm::Module&, llvm::TargetMachine*, llvm::TargetLibraryInfoImpl*, llvm::ToolOutputFile*, llvm::ToolOutputFile*, llvm::ToolOutputFile*, llvm::StringRef, llvm::ArrayRef<llvm::PassPlugin>, llvm::ArrayRef<std::__1::function<void (llvm::PassBuilder&)>>, llvm::opt_tool::OutputKind, llvm::opt_tool::VerifierKind, bool, bool, bool, bool, bool, bool, bool) llvm/tools/opt/NewPMDriver.cpp:541:3\n#25 0x00007f6b08861f85 optMain llvm/tools/opt/optdriver.cpp:739:12\n#26 0x00005575215c34a9 main llvm/tools/opt/opt.cpp:25:42\n#27 0x00007f6af8b403fb (/usr/lib64/libc.so.6+0x273fb)\n#28 0x00007f6af8b404ab __libc_start_main (/usr/lib64/libc.so.6+0x274ab)\n#29 0x00005575215c33b5 _start (20.x-Debug/bin/opt+0x23b5)\n```\nAlso repros at 087a6ac420ad99c523b9dd517351e0c6d1f1a980.",
+    "author": "jacobly0",
+    "labels": [
+      "crash",
+      "llvm:analysis"
+    ],
+    "comments": [
+      {
+        "author": "nikic",
+        "body": "To make it clearer what the core problem is:\n```\n; RUN: opt -S -passes=instsimplify\n@g = constant { i40, i8 } { i40 0, i8 1 }\ndefine i8 @f() {\n  %v = load i8, ptr getelementptr (i8, ptr @g, i64 6)\n  ret i8 %v\n}\n```\nThis is accessing the padding between the store size and the alloc size of `i40`, which ReadDataFromGlobal does not correctly handle."
+      }
+    ]
+  },
+  "verified": true
+}

dataset/93769.json

@@ -0,0 +1,138 @@
+{
+  "bug_id": "93769",
+  "issue_url": "https://github.com/llvm/llvm-project/issues/93769",
+  "bug_type": "miscompilation",
+  "base_commit": "d517f15e09e49e172387cb6deb76e4ee2d45d0e4",
+  "knowledge_cutoff": "2024-05-30T04:55:57Z",
+  "lit_test_dir": [
+    "llvm/test/Transforms/InstCombine"
+  ],
+  "hints": {
+    "fix_commit": "971c49fbf361c22ccf20913f61a58c28b26c4e27",
+    "components": [
+      "InstCombine"
+    ],
+    "bug_location_lineno": {
+      "llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp": [
+        [
+          2857,
+          2864
+        ]
+      ]
+    },
+    "bug_location_funcname": {
+      "llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp": [
+        "foldFNegIntoConstant"
+      ]
+    }
+  },
+  "patch": "commit 971c49fbf361c22ccf20913f61a58c28b26c4e27\nAuthor: SahilPatidar <[email protected]>\nDate:   Thu Jun 12 16:01:43 2025 +0530\n\n    [InstCombine] Ensure Safe Handling of Flags in foldFNegIntoConstant (#94148)\n    \n    Fix #93769\n    \n    alive2: https://alive2.llvm.org/ce/z/MHShQY\n\ndiff --git a/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp b/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp\nindex fc7dd302b27a..f0f709bb16d8 100644\n--- a/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp\n+++ b/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp\n@@ -2857,8 +2857,14 @@ static Instruction *foldFNegIntoConstant(Instruction &I, const DataLayout &DL) {\n   // Fold negation into constant operand.\n   // -(X * C) --> X * (-C)\n   if (match(FNegOp, m_FMul(m_Value(X), m_Constant(C))))\n-    if (Constant *NegC = ConstantFoldUnaryOpOperand(Instruction::FNeg, C, DL))\n-      return BinaryOperator::CreateFMulFMF(X, NegC, &I);\n+    if (Constant *NegC = ConstantFoldUnaryOpOperand(Instruction::FNeg, C, DL)) {\n+      FastMathFlags FNegF = I.getFastMathFlags();\n+      FastMathFlags OpF = FNegOp->getFastMathFlags();\n+      FastMathFlags FMF = FastMathFlags::unionValue(FNegF, OpF) |\n+                          FastMathFlags::intersectRewrite(FNegF, OpF);\n+      FMF.setNoInfs(FNegF.noInfs() && OpF.noInfs());\n+      return BinaryOperator::CreateFMulFMF(X, NegC, FMF);\n+    }\n   // -(X / C) --> X / (-C)\n   if (match(FNegOp, m_FDiv(m_Value(X), m_Constant(C))))\n     if (Constant *NegC = ConstantFoldUnaryOpOperand(Instruction::FNeg, C, DL))\n",
+  "tests": [
+    {
+      "file": "llvm/test/Transforms/InstCombine/fneg.ll",
+      "commands": [
+        "opt < %s -passes=instcombine -S",
+        "opt < %s -passes=instcombine -use-constant-fp-for-fixed-length-splat -S"
+      ],
+      "tests": [
+        {
+          "test_name": "test_fneg_mul_combine_nsz_ninf_with_vec_const",
+          "test_body": "define <2 x float> @test_fneg_mul_combine_nsz_ninf_with_vec_const(<2 x float> %a) {\n  %f1 = fmul nsz <2 x float> %a, <float 0.000000e+00, float -0.000000e+00>\n  %f2 = fneg ninf <2 x float> %f1\n  ret <2 x float> %f2\n}\n"
+        },
+        {
+          "test_name": "test_fneg_mul_combine_reassoc_ninf_with_vec_const1",
+          "test_body": "define <2 x float> @test_fneg_mul_combine_reassoc_ninf_with_vec_const1(<2 x float> %a) {\n  %f1 = fmul <2 x float> %a, <float 0.000000e+00, float -0.000000e+00>\n  %f2 = fneg ninf <2 x float> %f1\n  ret <2 x float> %f2\n}\n"
+        },
+        {
+          "test_name": "test_fneg_ninf_mul_with_anyzero",
+          "test_body": "define float @test_fneg_ninf_mul_with_anyzero(float %a) {\n  %mul = fmul float %a, 0.000000e+00\n  %f = fneg ninf float %mul\n  ret float %f\n}\n"
+        },
+        {
+          "test_name": "test_fneg_mul_combine_contract_ninf_with_vec_const2",
+          "test_body": "define <2 x float> @test_fneg_mul_combine_contract_ninf_with_vec_const2(<2 x float> %a) {\n  %f1 = fmul ninf <2 x float> %a, <float 0.000000e+00, float -0.000000e+00>\n  %f2 = fneg ninf <2 x float> %f1\n  ret <2 x float> %f2\n}\n"
+        },
+        {
+          "test_name": "fmul_fneg",
+          "test_body": "define float @fmul_fneg(float %x) {\n  %m = fmul float %x, 4.200000e+01\n  %r = fneg float %m\n  ret float %r\n}\n"
+        },
+        {
+          "test_name": "fmul_fsub_fmf",
+          "test_body": "define float @fmul_fsub_fmf(float %x) {\n  %m = fmul float %x, 4.200000e+01\n  %r = fsub nsz float -0.000000e+00, %m\n  ret float %r\n}\n"
+        },
+        {
+          "test_name": "test_fneg_nnan_mul_with_anyzero",
+          "test_body": "define float @test_fneg_nnan_mul_with_anyzero(float %a) {\n  %f1 = fmul ninf float %a, 0.000000e+00\n  %f2 = fneg nnan float %f1\n  ret float %f2\n}\n"
+        },
+        {
+          "test_name": "test_fneg_mul_combine_nnan_ninf_with_vec_const2",
+          "test_body": "define <2 x float> @test_fneg_mul_combine_nnan_ninf_with_vec_const2(<2 x float> %a) {\n  %f1 = fmul ninf <2 x float> %a, <float 0.000000e+00, float -0.000000e+00>\n  %f2 = fneg nnan ninf <2 x float> %f1\n  ret <2 x float> %f2\n}\n"
+        },
+        {
+          "test_name": "test_fsub_ninf_mul_with_anyzero",
+          "test_body": "define float @test_fsub_ninf_mul_with_anyzero(float %a) {\n  %f1 = fmul nsz float %a, 0.000000e+00\n  %f2 = fsub ninf float -0.000000e+00, %f1\n  ret float %f2\n}\n"
+        },
+        {
+          "test_name": "test_fneg_nsz_mul_with_anyzero",
+          "test_body": "define float @test_fneg_nsz_mul_with_anyzero(float %a) {\n  %f1 = fmul ninf float %a, 0.000000e+00\n  %f2 = fneg nsz float %f1\n  ret float %f2\n}\n"
+        },
+        {
+          "test_name": "test_fneg_ninf_mul_nnan_with_const",
+          "test_body": "define float @test_fneg_ninf_mul_nnan_with_const(float %a) {\n  %f1 = fmul nnan float %a, 0.000000e+00\n  %f2 = fneg ninf float %f1\n  ret float %f2\n}\n"
+        },
+        {
+          "test_name": "test_fneg_ninf_nnan_mul_with_vec_const",
+          "test_body": "define <2 x float> @test_fneg_ninf_nnan_mul_with_vec_const(<2 x float> %a) {\n  %f1 = fmul <2 x float> %a, <float 0.000000e+00, float -0.000000e+00>\n  %f2 = fneg nnan ninf <2 x float> %f1\n  ret <2 x float> %f2\n}\n"
+        },
+        {
+          "test_name": "test_fneg_mul_combine_reassoc_ninf_with_vec_const3",
+          "test_body": "define <2 x float> @test_fneg_mul_combine_reassoc_ninf_with_vec_const3(<2 x float> %a) {\n  %f1 = fmul <2 x float> %a, <float 0.000000e+00, float -0.000000e+00>\n  %f2 = fneg ninf <2 x float> %f1\n  ret <2 x float> %f2\n}\n"
+        },
+        {
+          "test_name": "test_fneg_mul_combine_contract_ninf_with_vec_const1",
+          "test_body": "define <2 x float> @test_fneg_mul_combine_contract_ninf_with_vec_const1(<2 x float> %a) {\n  %f1 = fmul <2 x float> %a, <float 0.000000e+00, float -0.000000e+00>\n  %f2 = fneg ninf <2 x float> %f1\n  ret <2 x float> %f2\n}\n"
+        },
+        {
+          "test_name": "fmul_fneg_fmf",
+          "test_body": "define float @fmul_fneg_fmf(float %x) {\n  %m = fmul float %x, 4.200000e+01\n  %r = fneg nsz float %m\n  ret float %r\n}\n"
+        },
+        {
+          "test_name": "test_fneg_mul_combine_nnan_ninf_with_vec_const",
+          "test_body": "define <2 x float> @test_fneg_mul_combine_nnan_ninf_with_vec_const(<2 x float> %a) {\n  %f1 = fmul nnan <2 x float> %a, <float 0.000000e+00, float -0.000000e+00>\n  %f2 = fneg ninf <2 x float> %f1\n  ret <2 x float> %f2\n}\n"
+        },
+        {
+          "test_name": "test_fneg_mul_combine_reassoc_ninf_with_vec_const2",
+          "test_body": "define <2 x float> @test_fneg_mul_combine_reassoc_ninf_with_vec_const2(<2 x float> %a) {\n  %f1 = fmul ninf <2 x float> %a, <float 0.000000e+00, float -0.000000e+00>\n  %f2 = fneg ninf <2 x float> %f1\n  ret <2 x float> %f2\n}\n"
+        },
+        {
+          "test_name": "test_fneg_mul_combine_contract_ninf_with_vec_const3",
+          "test_body": "define <2 x float> @test_fneg_mul_combine_contract_ninf_with_vec_const3(<2 x float> %a) {\n  %f1 = fmul <2 x float> %a, <float 0.000000e+00, float -0.000000e+00>\n  %f2 = fneg ninf <2 x float> %f1\n  ret <2 x float> %f2\n}\n"
+        },
+        {
+          "test_name": "test_fneg_ninf_mul_nsz_with_const",
+          "test_body": "define float @test_fneg_ninf_mul_nsz_with_const(float %a) {\n  %f1 = fmul nsz float %a, 0.000000e+00\n  %f2 = fneg ninf float %f1\n  ret float %f2\n}\n"
+        }
+      ]
+    }
+  ],
+  "issue": {
+    "title": "foldFNegIntoConstant incorrectly preserves fast math flags for 0 constants",
+    "body": "> https://alive2.llvm.org/ce/z/MHShQY longer version\r\n\r\n_Originally posted by @arsenm in https://github.com/llvm/llvm-project/pull/92512#discussion_r1619895371_\r\n\r\n\r\nSome of the combines in foldFNegIntoConstant are unsafely taking the flags directly from the original fneg instruction, when the preservation logic requires dropping ninf in some cases. ",
+    "author": "arsenm",
+    "labels": [
+      "miscompilation",
+      "llvm:instcombine",
+      "floating-point"
+    ],
+    "comments": [
+      {
+        "author": "SahilPatidar",
+        "body": "@arsenm, could we use the same logic you shared in #92512 for dropping `ninf`?\r\n```cpp\r\n      FastMathFlags FMF = match(C, m_AnyZeroFP())? I.getFastMathFlags() &\r\n                          cast<FPMathOperator>(I.getOperand(0))->getFastMathFlags():\r\n                          I.getFastMathFlags();\r\n```\r\nHowever, this logic will also drop `nnan` and other flags. Should we check specifically for ninf instead?"
+      },
+      {
+        "author": "arsenm",
+        "body": "> However, this logic will also drop `nnan` and other flags. Should we check specifically for ninf instead?\r\n\r\nThat will be conservatively correct, but I think this can do better. For example, nnan on the fneg should be sufficient to preserve nnan on the final result, same with nsz "
+      }
+    ]
+  },
+  "verified": true
+}

scripts/llvm_helper.py

@@ -25,9 +25,12 @@ llvm_dir = os.environ["LAB_LLVM_DIR"]
 llvm_build_dir = os.environ["LAB_LLVM_BUILD_DIR"]
 llvm_alive_tv = os.environ["LAB_LLVM_ALIVE_TV"]
 dataset_dir = os.environ["LAB_DATASET_DIR"]
-if '--quiet' not in subprocess.run(["ninja", "--help"], capture_output=True).stderr.decode("utf-8"):
+if "--quiet" not in subprocess.run(
+    ["ninja", "--help"], capture_output=True
+).stderr.decode("utf-8"):
     raise RuntimeError("Please update ninja to version 1.11.0 or later")
 
+
 def git_execute(args):
     return subprocess.check_output(
         ["git", "-C", llvm_dir] + args, cwd=llvm_dir, stderr=subprocess.DEVNULL
@@ -104,7 +107,7 @@ def decode_output(output):
     return output.decode()
 
 
-def build(max_build_jobs: int, additional_cmake_args = []):
+def build(max_build_jobs: int, additional_cmake_args=[]):
     os.makedirs(llvm_build_dir, exist_ok=True)
     log = ""
     try:
@@ -126,7 +129,8 @@ def build(max_build_jobs: int, additional_cmake_args = []):
                 "-DLLVM_TARGETS_TO_BUILD='X86;RISCV;AArch64;SystemZ;Hexagon;PowerPC;'",
                 "-DLLVM_PARALLEL_LINK_JOBS=4",
                 "-DLLVM_INCLUDE_EXAMPLES=OFF",
-            ] + additional_cmake_args,
+            ]
+            + additional_cmake_args,
             stderr=subprocess.STDOUT,
             cwd=llvm_build_dir,
         ).decode()

scripts/postfix_extract.py

@@ -148,6 +148,7 @@ fix_commit_map = {
     "139308": None,  # Duplicate of #139103
     "139729": None,  # Non-deterministic bug
     "140215": None,  # Cannot reproduce with Alive2
+    "140238": None,  # Cannot reproduce with Alive2
     "140992": None,  # Meta issue
     "142091": None,  # Duplicate of #141968
 }