[InstCombine] Ensure Safe Handling of Flags in foldFNegIntoConstant #94148

SahilPatidar · 2024-06-02T06:43:02Z

Fix #93769

alive2: https://alive2.llvm.org/ce/z/MHShQY

SahilPatidar · 2024-06-02T06:43:34Z

@arsenm

llvm/test/Transforms/InstCombine/fneg.ll

arsenm · 2024-06-06T18:30:25Z

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

+        return BinaryOperator::CreateFMulFMF(
+            X, NegC,
+            I.getFastMathFlags() &
+                cast<FPMathOperator>(I.getOperand(0))->getFastMathFlags());


pull the cast to FPMathOperator up and use it for the no-infs check?

arsenm · 2024-06-06T18:30:53Z

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

+        return BinaryOperator::CreateFMulFMF(
+            X, NegC,
+            I.getFastMathFlags() &
+                cast<FPMathOperator>(I.getOperand(0))->getFastMathFlags());


I think the correct logic is and flags, but can or-in NSZ or nnan from either op

Could we do it this way?

FastMathFlags FMF = cast<FPMathOperator>(I.getOperand(0))->getFastMathFlags(); if (I.getFastMathFlags().noInfs() && !FMF.noInfs()) { return BinaryOperator::CreateFMulFMF(X, NegC, FMF); }

It really ought to be a function that produces the new correct FMF, rather than conditionally preserving the original flags

Ok, we need to check all alive2 cases and then generate the flags.

alive2: https://alive2.llvm.org/ce/z/DHmA7a
I apologize for the delay; I was quite busy. Based on my observation, I came up with this combination: if we have nnan in any instruction, we can propagate flags to our transformation.

FastMathFlags NF1 = F1 & F2; FastMathFlags NF2 = F1 | F2; if (NF2.noNaNs()) { return F2; } if (NF1.any() || (F1.none() && F2.none())) { return NF1; } if (F1.all() || F2.all()) { return F2; } return NF1;

Let me know what you think.

NF1.any() || (F1.none() && F2.none()) case is equivalent to just NF1.any.

Not sure why you need the all || all fixup either

Yeah, you're right. I was just making combinations, so is that what you're looking for?

I think ninf is the only problematic flag, since ninf on the fneg does not imply fneg on fmul, and fmul inf * 0 = nan.

So you need something like

Flags = FnegFlags | FMulFlags
Flags.ninf &= FmulFlags.ninf

arsenm · 2024-06-06T18:32:40Z

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

@@ -2653,8 +2653,15 @@ static Instruction *foldFNegIntoConstant(Instruction &I, const DataLayout &DL) {
  // Fold negation into constant operand.
  // -(X * C) --> X * (-C)
  if (match(FNegOp, m_FMul(m_Value(X), m_Constant(C))))
-    if (Constant *NegC = ConstantFoldUnaryOpOperand(Instruction::FNeg, C, DL))
+    if (Constant *NegC = ConstantFoldUnaryOpOperand(Instruction::FNeg, C, DL)) {
+      if (match(C, m_AnyZeroFP()) && I.getFastMathFlags().noInfs()) {


Directionally this feels wrong. A constant, but not known literal 0/-0 may end up resolving to a 0 (e.g. degenerate constant expression casts or undef). I think this should first be written to handle the flags conservatively regardless of the value and we can try to refine for the known-non-0 cases if necessary

jayfoad · 2024-07-08T09:27:26Z

Why not just copy FMF from FNegOp (the fmul) instead of from I (the fneg)? It's simple and correct and it seems pretty unlikely that you'd ever get a real world case where the flags on the fneg would add any extra useful information.

SahilPatidar · 2024-07-10T04:35:11Z

Since it was breaking the fsub test with the reassoc flag, I conditionally propagated the FNegOp FMF flag.

jayfoad · 2024-07-10T09:58:46Z

Since it was breaking the fsub test with the reassoc flag, I conditionally propagated the FNegOp FMF flag.

Personally I think all cases in this function should be copying FMF from FNegOp, not from I. That is simple, correct (I think!) and useful.

In some cases you might be able to infer additional flags from I but that is much more subtle and (I assert!) far less useful. For example copying nnan from I is probably OK, but in that case it should be ORed into the flags from FNegOp.

jayfoad · 2024-07-10T10:02:03Z

Since it was breaking the fsub test with the reassoc flag, I conditionally propagated the FNegOp FMF flag.

Maybe we should just update the expected output for that test? It is not at all clear to me that propagating reassoc from the fsub to the fmul is desirable or even correct.

SahilPatidar · 2024-07-10T11:12:07Z

This is a test we are breaking:

; With nsz and reassoc: Y - ((X * 5) + Y) --> X * -5

define float @sub_add_neg_x(float %x, float %y) {
; CHECK-LABEL: @sub_add_neg_x(
; CHECK-NEXT:    [[R:%.*]] = fmul float [[X:%.*]], -5.000000e+00
; CHECK-NEXT:    ret float [[R]]
;
  %mul = fmul float %x, 5.000000e+00
  %add = fadd float %mul, %y
  %r = fsub nsz reassoc float %y, %add
  ret float %r
}

arsenm · 2024-08-16T17:54:27Z

reverse ping

SahilPatidar · 2024-08-21T15:53:33Z

If we directly use FNegOp, it breaks some reassoc tests.

arsenm · 2024-08-22T14:48:47Z

If we directly use FNegOp, it breaks some reassoc tests.

Do you have an example? Those tests might just be wrong

SahilPatidar · 2024-08-23T08:15:16Z

@arsenm Now check that out. Does it look alright?

arsenm · 2024-09-25T11:40:12Z

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

+      FastMathFlags Flag = I.getFastMathFlags() | FNegOp->getFastMathFlags();
+      Flag.setNoInfs(I.getFastMathFlags().noInfs() &&
+                     FNegOp->getFastMathFlags().noInfs());


Avoid repeated calls to I.getFastMathFlags() and FNegOp->getFastMathFlags()?

arsenm · 2024-09-25T11:41:25Z

llvm/test/Transforms/InstCombine/fneg.ll

+  %f2 = fneg nnan ninf <2 x float> %f1
+  ret <2 x float> %f2
+}
+


Missing a test where ninf is present on both, and is preservable

Let me know if we need more tests of that kind?.

The ninf combinations are most important because you need to special case them

Should also test reassoc on one, other, and both instructions. Best to require it be present on both instructions

@arsenm We require the reassoc flag to be present on both instructions before propagating it, but only if noinf is also present, right?

No, there is no direct connection between reassoc and ninf. They both separately are anded

This change causes the test to fail:

; With nsz and reassoc: Y - ((X * 5) + Y) --> X * -5 define float @sub_add_neg_x(float %x, float %y) { ; CHECK-LABEL: @sub_add_neg_x( ; CHECK-NEXT: [[R:%.*]] = fmul nsz float [[X:%.*]], -5.000000e+00 ; CHECK-NEXT: ret float [[R]] ; %mul = fmul float %x, 5.000000e+00 %add = fadd float %mul, %y %r = fsub nsz reassoc float %y, %add ret float %r }

Fail, meaning it now preserves nsz and not the reassoc? That's fine. That is more in line with what the LangRef states the rules are for reassoc: https://llvm.org/docs/LangRef.html#rewrite-based-flags

; With nsz and reassoc: Y - ((X * 5) + Y) --> X * -5

That transformation should require nnan or isKnownNeverNaN(Y)

Somewhere else's bug though

arsenm · 2024-09-30T13:33:08Z

llvm/test/Transforms/InstCombine/fneg.ll

+  %f1 = fmul ninf <2 x float> %a, <float 0.000000, float -0.000000>
+  %f2 = fneg nnan ninf <2 x float> %f1
+  ret <2 x float> %f2


I would have tested the ninf preservation case above with the scalar case, but this covers it

arsenm · 2024-09-30T13:34:06Z

llvm/test/Transforms/InstCombine/fneg.ll

+  %f2 = fneg nnan ninf <2 x float> %f1
+  ret <2 x float> %f2
+}
+


The ninf combinations are most important because you need to special case them

llvmbot · 2024-09-30T13:34:18Z

@llvm/pr-subscribers-llvm-transforms

Author: None (SahilPatidar)

Changes

Fix #93769

alive2: https://alive2.llvm.org/ce/z/MHShQY

Full diff: https://github.com/llvm/llvm-project/pull/94148.diff

2 Files Affected:

(modified) llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp (+7-2)
(modified) llvm/test/Transforms/InstCombine/fneg.ll (+102)

diff --git a/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp b/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
index e5c3a20e1a6487..9e9c3fc7b25fba 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
@@ -2757,8 +2757,13 @@ static Instruction *foldFNegIntoConstant(Instruction &I, const DataLayout &DL) {
   // Fold negation into constant operand.
   // -(X * C) --> X * (-C)
   if (match(FNegOp, m_FMul(m_Value(X), m_Constant(C))))
-    if (Constant *NegC = ConstantFoldUnaryOpOperand(Instruction::FNeg, C, DL))
-      return BinaryOperator::CreateFMulFMF(X, NegC, &I);
+    if (Constant *NegC = ConstantFoldUnaryOpOperand(Instruction::FNeg, C, DL)) {
+      FastMathFlags FMF = I.getFastMathFlags();
+      FastMathFlags OpFMF = FNegOp->getFastMathFlags();
+      FastMathFlags Flag = FMF | OpFMF;
+      Flag.setNoInfs(FMF.noInfs() && OpFMF.noInfs());
+      return BinaryOperator::CreateFMulFMF(X, NegC, Flag);
+    }
   // -(X / C) --> X / (-C)
   if (match(FNegOp, m_FDiv(m_Value(X), m_Constant(C))))
     if (Constant *NegC = ConstantFoldUnaryOpOperand(Instruction::FNeg, C, DL))
diff --git a/llvm/test/Transforms/InstCombine/fneg.ll b/llvm/test/Transforms/InstCombine/fneg.ll
index 3c4088832feaaa..4d68faf178d9cf 100644
--- a/llvm/test/Transforms/InstCombine/fneg.ll
+++ b/llvm/test/Transforms/InstCombine/fneg.ll
@@ -1109,4 +1109,106 @@ define float @test_fneg_select_maxnum(float %x) {
   ret float %neg
 }
 
+define float @test_fneg_ninf_mul_with_anyzero(float %a) {
+; CHECK-LABEL: @test_fneg_ninf_mul_with_anyzero(
+; CHECK-NEXT:    [[F:%.*]] = fmul float [[A:%.*]], -0.000000e+00
+; CHECK-NEXT:    ret float [[F]]
+;
+  %mul = fmul float %a, 0.0
+  %f = fneg ninf float %mul
+  ret float %f
+}
+
+define float @test_fsub_ninf_mul_with_anyzero(float %a) {
+; CHECK-LABEL: @test_fsub_ninf_mul_with_anyzero(
+; CHECK-NEXT:    [[F2:%.*]] = fmul nsz float [[A:%.*]], -0.000000e+00
+; CHECK-NEXT:    ret float [[F2]]
+;
+  %f1 = fmul nsz float %a, 0.000000
+  %f2 = fsub ninf float -0.000000, %f1
+  ret float %f2
+}
+
+define float @test_fneg_nnan_mul_with_anyzero(float %a) {
+; CHECK-LABEL: @test_fneg_nnan_mul_with_anyzero(
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg nnan float [[A:%.*]]
+; CHECK-NEXT:    [[F2:%.*]] = call nnan float @llvm.copysign.f32(float 0.000000e+00, float [[TMP1]])
+; CHECK-NEXT:    ret float [[F2]]
+;
+  %f1 = fmul ninf float %a, 0.000000
+  %f2 = fneg nnan float %f1
+  ret float %f2
+}
+
+define float @test_fneg_nsz_mul_with_anyzero(float %a) {
+; CHECK-LABEL: @test_fneg_nsz_mul_with_anyzero(
+; CHECK-NEXT:    [[F2:%.*]] = fmul nsz float [[A:%.*]], -0.000000e+00
+; CHECK-NEXT:    ret float [[F2]]
+;
+  %f1 = fmul ninf float %a, 0.000000
+  %f2 = fneg nsz float %f1
+  ret float %f2
+}
+
+define float @test_fneg_ninf_mul_nnan_with_const(float %a) {
+; CHECK-LABEL: @test_fneg_ninf_mul_nnan_with_const(
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg float [[A:%.*]]
+; CHECK-NEXT:    [[F2:%.*]] = call float @llvm.copysign.f32(float 0.000000e+00, float [[TMP1]])
+; CHECK-NEXT:    ret float [[F2]]
+;
+  %f1 = fmul nnan float %a, 0.000000
+  %f2 = fneg ninf float %f1
+  ret float %f2
+}
+
+define float @test_fneg_ninf_mul_nsz_with_const(float %a) {
+; CHECK-LABEL: @test_fneg_ninf_mul_nsz_with_const(
+; CHECK-NEXT:    [[F2:%.*]] = fmul nsz float [[A:%.*]], -0.000000e+00
+; CHECK-NEXT:    ret float [[F2]]
+;
+  %f1 = fmul nsz float %a, 0.000000
+  %f2 = fneg ninf float %f1
+  ret float %f2
+}
+
+define <2 x float> @test_fneg_ninf_mul_nnan_with_vec_const(<2 x float> %a) {
+; CHECK-LABEL: @test_fneg_ninf_mul_nnan_with_vec_const(
+; CHECK-NEXT:    [[F2:%.*]] = fmul nnan <2 x float> [[A:%.*]], <float -0.000000e+00, float 0.000000e+00>
+; CHECK-NEXT:    ret <2 x float> [[F2]]
+;
+  %f1 = fmul nnan <2 x float> %a, <float 0.000000, float -0.000000>
+  %f2 = fneg ninf <2 x float> %f1
+  ret <2 x float> %f2
+}
+
+define <2 x float> @test_fneg_ninf_mul_nsz_with_vec_const(<2 x float> %a) {
+; CHECK-LABEL: @test_fneg_ninf_mul_nsz_with_vec_const(
+; CHECK-NEXT:    [[F2:%.*]] = fmul nsz <2 x float> [[A:%.*]], <float -0.000000e+00, float 0.000000e+00>
+; CHECK-NEXT:    ret <2 x float> [[F2]]
+;
+  %f1 = fmul nsz <2 x float> %a, <float 0.000000, float -0.000000>
+  %f2 = fneg ninf <2 x float> %f1
+  ret <2 x float> %f2
+}
+
+define <2 x float> @test_fneg_nnan_ninf_mul_with_vec_const(<2 x float> %a) {
+; CHECK-LABEL: @test_fneg_nnan_ninf_mul_with_vec_const(
+; CHECK-NEXT:    [[F2:%.*]] = fmul nnan <2 x float> [[A:%.*]], <float -0.000000e+00, float 0.000000e+00>
+; CHECK-NEXT:    ret <2 x float> [[F2]]
+;
+  %f1 = fmul <2 x float> %a, <float 0.000000, float -0.000000>
+  %f2 = fneg nnan ninf <2 x float> %f1
+  ret <2 x float> %f2
+}
+
+define <2 x float> @test_fneg_nnan_ninf_mul_ninf_with_vec_const(<2 x float> %a) {
+; CHECK-LABEL: @test_fneg_nnan_ninf_mul_ninf_with_vec_const(
+; CHECK-NEXT:    [[F2:%.*]] = fmul nnan ninf <2 x float> [[A:%.*]], <float -0.000000e+00, float 0.000000e+00>
+; CHECK-NEXT:    ret <2 x float> [[F2]]
+;
+  %f1 = fmul ninf <2 x float> %a, <float 0.000000, float -0.000000>
+  %f2 = fneg nnan ninf <2 x float> %f1
+  ret <2 x float> %f2
+}
+
 !0 = !{}

arsenm · 2024-09-30T13:38:17Z

llvm/test/Transforms/InstCombine/fneg.ll

+  %f2 = fneg nnan ninf <2 x float> %f1
+  ret <2 x float> %f2
+}
+


Should also test reassoc on one, other, and both instructions. Best to require it be present on both instructions

arsenm · 2024-09-30T13:38:25Z

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

+      FastMathFlags FMF = I.getFastMathFlags();
+      FastMathFlags OpFMF = FNegOp->getFastMathFlags();
+      FastMathFlags Flag = FMF | OpFMF;
+      Flag.setNoInfs(FMF.noInfs() && OpFMF.noInfs());


Should and the rewrite flags too (reassoc, contract, afn). We probably should have a helper for the rewrite flags

arsenm · 2024-10-09T20:04:08Z

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

+static FastMathFlags combineFastMathFlagsForFNeg(FastMathFlags FMF,
+                                                 FastMathFlags OpFMF) {
+  FastMathFlags Flag = FMF | OpFMF;
+  Flag.setNoInfs(FMF.noInfs() && OpFMF.noInfs());
+  Flag.setAllowReassoc(FMF.allowReassoc() && OpFMF.allowReassoc());
+  Flag.setApproxFunc(FMF.approxFunc() && OpFMF.approxFunc());
+  Flag.setAllowReciprocal(FMF.allowReciprocal() && OpFMF.allowReciprocal());
+  Flag.setAllowContract(FMF.allowContract() && OpFMF.allowContract());
+  return Flag;
+}


We should have an | value flag & rewrite flag helper in FastMathFlags but can do API cleanups later

arsenm · 2024-11-05T16:59:17Z

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

@@ -2742,6 +2742,17 @@ Instruction *InstCombinerImpl::visitSub(BinaryOperator &I) {
  return TryToNarrowDeduceFlags();
 }

+static FastMathFlags combineFastMathFlagsForFNeg(FastMathFlags FMF,


Name is too specific, but I'm not sure what to call this. Also, it should be directly in FastMathFlags.

Maybe unionWithRewriteIntersect? Plus the no infinity special case can be applied after

Can we try this approach in FMF?

FastMathFlags Result = this->Flags & Other.Flags; Result.setNoNaNs(this->noNaNs() || Other.noNaNs()); Result.setNoSignedZeros(this->noSignedZeros() || Other.noSignedZeros()); return Result;

vgvassilev · 2025-06-11T07:27:22Z

Any plans on landing this?

dtcxzyw

LGTM. Thank you!
However, this PR only fixes FMF propagation for fneg + fmul. The remaining part of the original issue (fsub + fmul and fneg + fdiv) is still outstanding: https://alive2.llvm.org/ce/z/Jt3n6P

dtcxzyw · 2025-06-12T16:27:45Z

The remaining part of the original issue (fsub + fmul and fneg + fdiv) is still outstanding: https://alive2.llvm.org/ce/z/Jt3n6P

Double confirmed that they don't exist: https://alive2.llvm.org/ce/z/GELV_d

…lvm#94148) Fix llvm#93769 alive2: https://alive2.llvm.org/ce/z/MHShQY

arsenm reviewed Jun 6, 2024

View reviewed changes

arsenm added miscompilation floating-point Floating-point math llvm:instcombine Covers the InstCombine, InstSimplify and AggressiveInstCombine passes labels Jun 7, 2024

SahilPatidar mentioned this pull request Jul 8, 2024

[InstCombine] Fold (X * 0.0) * constant => X * 0.0 #85241 #92512

Open

SahilPatidar force-pushed the resolve93769 branch from 677324d to bf2263b Compare August 21, 2024 15:51

arsenm requested review from spavloff, andykaylor and jcranmer-intel September 25, 2024 11:21

arsenm reviewed Sep 25, 2024

View reviewed changes

SahilPatidar force-pushed the resolve93769 branch from 25542cd to 8a40c65 Compare September 27, 2024 14:16

arsenm marked this pull request as ready for review September 30, 2024 13:33

arsenm requested a review from nikic as a code owner September 30, 2024 13:33

llvmbot added the llvm:transforms label Sep 30, 2024

arsenm reviewed Sep 30, 2024

View reviewed changes

nikic removed their request for review September 30, 2024 13:59

SahilPatidar force-pushed the resolve93769 branch from e2e5860 to cad89bf Compare October 5, 2024 10:54

arsenm approved these changes Oct 9, 2024

View reviewed changes

arsenm reviewed Oct 9, 2024

View reviewed changes

SahilPatidar force-pushed the resolve93769 branch from cad89bf to 8f6a647 Compare November 5, 2024 06:06

arsenm reviewed Nov 5, 2024

View reviewed changes

SahilPatidar added 7 commits March 15, 2025 09:21

[InstCombine] Ensure Safe Handling of Flags in foldFNegIntoConstant

e69cbb4

Fixes logic and update tests

9973683

Propagate the FNegOp FMF flag instead of I.

12ab999

Update Flag Propagation Logic

c47dc0a

Refactor logic and add additional tests

0aff15a

Add helper function for flag rewriting

def9464

Update test

699be90

SahilPatidar force-pushed the resolve93769 branch from 8f6a647 to 699be90 Compare March 15, 2025 08:26

arsenm requested a review from dtcxzyw June 11, 2025 12:36

This was referenced Jun 11, 2025

Task submission dtcxzyw/llvm-opt-benchmark#1312

Open

Fuzz PR94148 dtcxzyw/llvm-mutation-based-fuzz-service#58

Closed

pre-commit: PR94148 dtcxzyw/llvm-opt-benchmark#2423

Closed

dtcxzyw approved these changes Jun 12, 2025

View reviewed changes

arsenm merged commit 971c49f into llvm:main Jun 12, 2025
11 checks passed

tomtor pushed a commit to tomtor/llvm-project that referenced this pull request Jun 14, 2025

[InstCombine] Ensure Safe Handling of Flags in foldFNegIntoConstant (l…

9952456

…lvm#94148) Fix llvm#93769 alive2: https://alive2.llvm.org/ce/z/MHShQY

akuhlens pushed a commit to akuhlens/llvm-project that referenced this pull request Jun 24, 2025

[InstCombine] Ensure Safe Handling of Flags in foldFNegIntoConstant (l…

63b1f00

…lvm#94148) Fix llvm#93769 alive2: https://alive2.llvm.org/ce/z/MHShQY

[InstCombine] Ensure Safe Handling of Flags in foldFNegIntoConstant #94148

[InstCombine] Ensure Safe Handling of Flags in foldFNegIntoConstant #94148

Uh oh!

Conversation

SahilPatidar commented Jun 2, 2024

Uh oh!

SahilPatidar commented Jun 2, 2024

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jayfoad commented Jul 8, 2024

Uh oh!

SahilPatidar commented Jul 10, 2024

Uh oh!

jayfoad commented Jul 10, 2024

Uh oh!

jayfoad commented Jul 10, 2024

Uh oh!

SahilPatidar commented Jul 10, 2024

Uh oh!

arsenm commented Aug 16, 2024

Uh oh!

SahilPatidar commented Aug 21, 2024

Uh oh!

arsenm commented Aug 22, 2024

Uh oh!

SahilPatidar commented Aug 23, 2024

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

llvmbot commented Sep 30, 2024

Uh oh!

Choose a reason for hiding this comment

Uh oh!