[InstCombine] Fold expression using basic properties of floor and ceiling function #107107

c8ef · 2024-09-03T13:33:31Z

alive2: ~~https://alive2.llvm.org/ce/z/Ag3Ki7~~ https://alive2.llvm.org/ce/z/ywP5t2
related: #76438

This patch adds the following foldings: floor(x) <= x --> true and x <= ceil(x) --> true. We leverage the properties of these math functions and ensure there is no floating point input of nan.

llvmbot · 2024-09-03T13:34:05Z

@llvm/pr-subscribers-llvm-transforms

@llvm/pr-subscribers-llvm-analysis

Author: None (c8ef)

Changes

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

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

2 Files Affected:

(modified) llvm/lib/Analysis/InstructionSimplify.cpp (+33-5)
(added) llvm/test/Transforms/InstSimplify/fp-floor-ceil.ll (+114)

diff --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp
index 32a9f1ab34fb3f..e67a2875733416 100644
--- a/llvm/lib/Analysis/InstructionSimplify.cpp
+++ b/llvm/lib/Analysis/InstructionSimplify.cpp
@@ -4130,12 +4130,9 @@ static Value *simplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
   //
   // This catches the 2 variable input case, constants are handled below as a
   // class-like compare.
+  KnownFPClass LHSClass = computeKnownFPClass(LHS, fcAllFlags, /*Depth=*/0, Q);
+  KnownFPClass RHSClass = computeKnownFPClass(RHS, fcAllFlags, /*Depth=*/0, Q);
   if (Pred == FCmpInst::FCMP_ORD || Pred == FCmpInst::FCMP_UNO) {
-    KnownFPClass RHSClass =
-        computeKnownFPClass(RHS, fcAllFlags, /*Depth=*/0, Q);
-    KnownFPClass LHSClass =
-        computeKnownFPClass(LHS, fcAllFlags, /*Depth=*/0, Q);
-
     if (FMF.noNaNs() ||
         (RHSClass.isKnownNeverNaN() && LHSClass.isKnownNeverNaN()))
       return ConstantInt::get(RetTy, Pred == FCmpInst::FCMP_ORD);
@@ -4143,6 +4140,37 @@ static Value *simplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
     if (RHSClass.isKnownAlwaysNaN() || LHSClass.isKnownAlwaysNaN())
       return ConstantInt::get(RetTy, Pred == CmpInst::FCMP_UNO);
   }
+  // floor(x) <= x --> true; x <= ceil(x) --> true
+  if (LHSClass.isKnownNeverNaN() &&
+          match(LHS, m_Intrinsic<Intrinsic::floor>(m_Specific(RHS))) ||
+      RHSClass.isKnownNeverNaN() &&
+          match(RHS, m_Intrinsic<Intrinsic::ceil>(m_Specific(LHS)))) {
+    switch (Pred) {
+    case FCmpInst::FCMP_OLE:
+    case FCmpInst::FCMP_ULE:
+      return getTrue(RetTy);
+    case FCmpInst::FCMP_OGT:
+    case FCmpInst::FCMP_UGT:
+      return getFalse(RetTy);
+    default:
+      break;
+    }
+  }
+  if (RHSClass.isKnownNeverNaN() &&
+          match(RHS, m_Intrinsic<Intrinsic::floor>(m_Specific(LHS))) ||
+      LHSClass.isKnownNeverNaN() &&
+          match(LHS, m_Intrinsic<Intrinsic::ceil>(m_Specific(RHS)))) {
+    switch (Pred) {
+    case FCmpInst::FCMP_OGE:
+    case FCmpInst::FCMP_UGE:
+      return getTrue(RetTy);
+    case FCmpInst::FCMP_OLT:
+    case FCmpInst::FCMP_ULT:
+      return getFalse(RetTy);
+    default:
+      break;
+    }
+  }
 
   const APFloat *C = nullptr;
   match(RHS, m_APFloatAllowPoison(C));
diff --git a/llvm/test/Transforms/InstSimplify/fp-floor-ceil.ll b/llvm/test/Transforms/InstSimplify/fp-floor-ceil.ll
new file mode 100644
index 00000000000000..fe78656b014ae0
--- /dev/null
+++ b/llvm/test/Transforms/InstSimplify/fp-floor-ceil.ll
@@ -0,0 +1,114 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
+
+define i1 @x_floor_ole(float %0) {
+; CHECK-LABEL: @x_floor_ole(
+; CHECK-NEXT:    ret i1 true
+;
+  %2 = call nnan float @llvm.floor.f32(float %0)
+  %3 = fcmp ole float %2, %0
+  ret i1 %3
+}
+
+define i1 @x_floor_ule(float %0) {
+; CHECK-LABEL: @x_floor_ule(
+; CHECK-NEXT:    ret i1 true
+;
+  %2 = call nnan float @llvm.floor.f32(float %0)
+  %3 = fcmp ule float %2, %0
+  ret i1 %3
+}
+
+define i1 @x_floor_ogt(float %0) {
+; CHECK-LABEL: @x_floor_ogt(
+; CHECK-NEXT:    ret i1 false
+;
+  %2 = call nnan float @llvm.floor.f32(float %0)
+  %3 = fcmp ogt float %2, %0
+  ret i1 %3
+}
+
+define i1 @x_floor_ugt(float %0) {
+; CHECK-LABEL: @x_floor_ugt(
+; CHECK-NEXT:    ret i1 false
+;
+  %2 = call nnan float @llvm.floor.f32(float %0)
+  %3 = fcmp ugt float %2, %0
+  ret i1 %3
+}
+
+define i1 @x_floor_ueq(float %0) {
+; CHECK-LABEL: @x_floor_ueq(
+; CHECK-NEXT:    [[TMP2:%.*]] = call nnan float @llvm.floor.f32(float [[TMP0:%.*]])
+; CHECK-NEXT:    [[TMP3:%.*]] = fcmp ueq float [[TMP2]], [[TMP0]]
+; CHECK-NEXT:    ret i1 [[TMP3]]
+;
+  %2 = call nnan float @llvm.floor.f32(float %0)
+  %3 = fcmp ueq float %2, %0
+  ret i1 %3
+}
+
+define <2 x i1> @x_floor_ugt_vec(<2 x float> %0) {
+; CHECK-LABEL: @x_floor_ugt_vec(
+; CHECK-NEXT:    ret <2 x i1> zeroinitializer
+;
+  %2 = call nnan <2 x float> @llvm.floor.v2f32(<2 x float> %0)
+  %3 = fcmp ugt <2 x float> %2, %0
+  ret <2 x i1> %3
+}
+
+define i1 @x_ceil_ole(float %0) {
+; CHECK-LABEL: @x_ceil_ole(
+; CHECK-NEXT:    ret i1 false
+;
+  %2 = call nnan float @llvm.ceil.f32(float %0)
+  %3 = fcmp olt float %2, %0
+  ret i1 %3
+}
+
+define i1 @x_ceil_ule(float %0) {
+; CHECK-LABEL: @x_ceil_ule(
+; CHECK-NEXT:    ret i1 false
+;
+  %2 = call nnan float @llvm.ceil.f32(float %0)
+  %3 = fcmp ult float %2, %0
+  ret i1 %3
+}
+
+define i1 @x_ceil_ogt(float %0) {
+; CHECK-LABEL: @x_ceil_ogt(
+; CHECK-NEXT:    ret i1 true
+;
+  %2 = call nnan float @llvm.ceil.f32(float %0)
+  %3 = fcmp oge float %2, %0
+  ret i1 %3
+}
+
+define i1 @x_ceil_ugt(float %0) {
+; CHECK-LABEL: @x_ceil_ugt(
+; CHECK-NEXT:    ret i1 true
+;
+  %2 = call nnan float @llvm.ceil.f32(float %0)
+  %3 = fcmp uge float %2, %0
+  ret i1 %3
+}
+
+define i1 @x_ceil_ueq(float %0) {
+; CHECK-LABEL: @x_ceil_ueq(
+; CHECK-NEXT:    [[TMP2:%.*]] = call nnan float @llvm.ceil.f32(float [[TMP0:%.*]])
+; CHECK-NEXT:    [[TMP3:%.*]] = fcmp ueq float [[TMP2]], [[TMP0]]
+; CHECK-NEXT:    ret i1 [[TMP3]]
+;
+  %2 = call nnan float @llvm.ceil.f32(float %0)
+  %3 = fcmp ueq float %2, %0
+  ret i1 %3
+}
+
+define <2 x i1> @x_ceil_ugt_vec(<2 x float> %0) {
+; CHECK-LABEL: @x_ceil_ugt_vec(
+; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
+;
+  %2 = call nnan <2 x float> @llvm.ceil.f32(<2 x float> %0)
+  %3 = fcmp uge <2 x float> %2, %0
+  ret <2 x i1> %3
+}

arsenm · 2024-09-04T04:19:14Z

llvm/lib/Analysis/InstructionSimplify.cpp

+  KnownFPClass LHSClass = computeKnownFPClass(LHS, fcAllFlags, /*Depth=*/0, Q);
+  KnownFPClass RHSClass = computeKnownFPClass(RHS, fcAllFlags, /*Depth=*/0, Q);


These queries can be expensive and you should try to defer them as late as possible (and prefer to early exit on the RHS query before the LHS, as the RHS is canonically cheaper)

arsenm · 2024-09-04T04:19:36Z

llvm/lib/Analysis/InstructionSimplify.cpp

    if (FMF.noNaNs() ||
        (RHSClass.isKnownNeverNaN() && LHSClass.isKnownNeverNaN()))
      return ConstantInt::get(RetTy, Pred == FCmpInst::FCMP_ORD);

    if (RHSClass.isKnownAlwaysNaN() || LHSClass.isKnownAlwaysNaN())
      return ConstantInt::get(RetTy, Pred == CmpInst::FCMP_UNO);
  }
+  // floor(x) <= x --> true; x <= ceil(x) --> true


Separate lines for each of these comments

arsenm · 2024-09-04T04:20:09Z

llvm/lib/Analysis/InstructionSimplify.cpp

    if (FMF.noNaNs() ||
        (RHSClass.isKnownNeverNaN() && LHSClass.isKnownNeverNaN()))
      return ConstantInt::get(RetTy, Pred == FCmpInst::FCMP_ORD);

    if (RHSClass.isKnownAlwaysNaN() || LHSClass.isKnownAlwaysNaN())
      return ConstantInt::get(RetTy, Pred == CmpInst::FCMP_UNO);
  }
+  // floor(x) <= x --> true; x <= ceil(x) --> true
+  if (LHSClass.isKnownNeverNaN() &&
+          match(LHS, m_Intrinsic<Intrinsic::floor>(m_Specific(RHS))) ||


Match the intrinsic before the expensive class query

arsenm · 2024-09-04T04:23:34Z

llvm/lib/Analysis/InstructionSimplify.cpp

+      break;
+    }
+  }
+  if (RHSClass.isKnownNeverNaN() &&


You wouldn't need the known never nan checks if you can replace with an fcmp ord/uno, but then you have to create a new instruction. Maybe it would be better to just handle this in instcombine?

If I understand your idea correctly, it seems that we might only need the following transformation. The existing code in InstSimplify should then be able to simplify these to either true or false?

define i1 @src_x_floor_ole(float %0) { %2 = call float @llvm.floor.f32(float %0) %3 = fcmp ole float %2, %0 ret i1 %3 } define i1 @tgt_x_floor_ole(float %0) { %2 = call float @llvm.floor.f32(float %0) %3 = fcmp ord float %2, %0 ret i1 %3 }

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

You don't need the floor at all: https://alive2.llvm.org/ce/z/E4erNR

Got it, I'll move the patch to InstCombineCompares.cpp tonight.

arsenm · 2024-09-04T04:24:23Z

llvm/test/Transforms/InstSimplify/fp-floor-ceil.ll

+; CHECK-LABEL: @x_floor_ole(
+; CHECK-NEXT:    ret i1 true
+;
+  %2 = call nnan float @llvm.floor.f32(float %0)


Use named values in tests.

Also test a case where the known-never-nan comes from the source value, not the instruction flag (e.g. nofpclass(nan) on the incoming function argument)

c8ef · 2024-09-04T04:42:48Z

Hi @dtcxzyw, could you help me verify if the transformation in the patch has any real-world use cases?

dtcxzyw · 2024-09-04T04:46:26Z

Hi @dtcxzyw, could you help me verify if the transformation in the patch has any real-world use cases?

This pattern is simple so I think it is ok to handle this regardless of its real-world usefulness.

arsenm · 2024-09-04T14:23:26Z

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

+    if (Pred == FCmpInst::FCMP_OLE ||
+        Pred == FCmpInst::FCMP_ULE &&


Do the pred checks first?

Did you mean check pred before matching operand?

arsenm · 2024-09-04T14:23:50Z

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

+            isKnownNeverNaN(LHS, 0,
+                            CI.getSimplifyQuery().getWithInstruction(&I))) {


You do not need to call isKnownNeverNaN. The only reason it was useful in instsimplify was you could not insert the new fcmp required to preserve the nan behavior

But without nnan, the following transformation seems to be invalid?

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

define i1 @src_x_floor_ole(float %0) { %2 = call float @llvm.floor.f32(float %0) %3 = fcmp ule float %2, %0 ret i1 %3 } define i1 @tgt_x_floor_ole(float %0) { %3 = fcmp ord float %0, 0.0 ret i1 %3 }

It needs some adjustment, but you can avoid it: https://alive2.llvm.org/ce/z/YZfsRb

You are right👍

;fcmp ole floor(x), x => fcmp ord x, 0 ;fcmp ogt floor(x), x => false ;fcmp oge x, floor(x) => fcmp ord x, 0 ;fcmp olt x, floor(x) => false ;fcmp ole x, ceil(x) => fcmp ord x, 0 ;fcmp ogt x, ceil(x) => false ;fcmp oge ceil(x), x => fcmp ord x, 0 ;fcmp olt ceil(x), x => false ;fcmp ule floor(x), x => fcmp ule float 0xFFF0000000000000, x ;fcmp ugt floor(x), x => fcmp ugt float 0xFFF0000000000000, x ;fcmp uge x, floor(x) => fcmp uge float x, 0xFFF0000000000000 ;fcmp ult x, floor(x) => fcmp ult float x, 0xFFF0000000000000 ;fcmp ule x, ceil(x) => fcmp ule float x, 0x7FF0000000000000 ;fcmp ugt x, ceil(x) => fcmp ugt float x, 0x7FF0000000000000 ;fcmp uge ceil(x), x => fcmp uge float 0x7FF0000000000000, x ;fcmp ult ceil(x), x => fcmp ult float 0x7FF0000000000000, x

Please update the alive2 link in your PR description.

Done. The culmination of all 16 transformations results in a timeout. By disabling either the first half or the second half, you can observe the expected outcome.

llvm/test/Transforms/InstCombine/fp-floor-ceil.ll

nikic · 2024-09-05T07:29:12Z

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

+  bool floor_x = match(LHS, m_Intrinsic<Intrinsic::floor>(m_Specific(RHS)));
+  bool x_floor = match(RHS, m_Intrinsic<Intrinsic::floor>(m_Specific(LHS)));
+  bool ceil_x = match(LHS, m_Intrinsic<Intrinsic::ceil>(m_Specific(RHS)));
+  bool x_ceil = match(RHS, m_Intrinsic<Intrinsic::ceil>(m_Specific(LHS)));


I think it would be cleaner if you swapped operands so floor/ceil is always on the left, instead of always checking both variants.

Perhaps I can check whether x_floor or x_ceil has occurred. If so, I will swap the LHS and the RHS and obtain the swapped predicate.

c8ef · 2024-09-06T08:22:09Z

Dear reviewers, would you please take another look? @arsenm @dtcxzyw @nikic

arsenm · 2024-09-07T02:03:19Z

llvm/test/Transforms/InstCombine/fp-floor-ceil.ll

+  %ceil = call float @llvm.ceil.f32(float %x)
+  %ret = fcmp oge float %x, %ceil
+  ret i1 %ret
+}


Negative tests for the other compare types, like oeq/one/une/ord/uno

Done. Other types of negative comparison tests have been added.

arsenm · 2024-09-07T02:06:11Z

llvm/test/Transforms/InstCombine/fp-floor-ceil.ll

+; CHECK-NEXT:    ret i1 [[RET]]
+;
+  %ceil = call float @llvm.ceil.f32(float %x)
+  %ret = fcmp ninf oge float %ceil, %x


This is the only flag preserving test, but it only covers oge. Should have one for each of these handled cases (i.e. have a test with a flag with ole, oge, ule, ugt, uge, and ult)

Done. All positive transformations resulting in a fcmp now have the corresponding fmf flags.

arsenm · 2024-09-07T02:12:01Z

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

+  if (x_floor || x_ceil) {
+    std::swap(LHS, RHS);
+    Pred = I.getSwappedPredicate();
+    (x_floor ? floor_x : ceil_x) = true;


Instead of pre-matching all the cases, you could match the preferred direction and then only try the other match if they both failed. You can also then directly assign floor_x / ceil_x from the match function when commuting.

Also variable names should be camel case

Done. Code style issues have also been addressed.

c8ef · 2024-09-08T00:24:15Z

Ping. @arsenm @nikic

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

dtcxzyw · 2024-09-08T01:47:29Z

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

+                          "", &I);
+    break;
+  case FCmpInst::FCMP_UGT:
+    // fcmp ugt floor(x), x => fcmp ugt -inf, x


Suggested change

// fcmp ugt floor(x), x => fcmp ugt -inf, x

// fcmp ugt floor(x), x => fcmp uno x, 0

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

llvm-project/llvm/test/Transforms/InstCombine/fp-floor-ceil.ll

Lines 32 to 40 in b0a37fb

define i1 @floor_x_ugt(float %x) {

; CHECK-LABEL: @floor_x_ugt(

; CHECK-NEXT: [[RET:%.*]] = fcmp ninf uno float [[X:%.*]], 0.000000e+00

; CHECK-NEXT: ret i1 [[RET]]

;

%floor = call float @llvm.floor.f32(float %x)

%ret = fcmp ninf ugt float %floor, %x

ret i1 %ret

}

From the test case above, we can see that the instructions will ultimately be converted to 'fcmp uno'. However, I believe we should keep this comment unchanged to align with the actual transformation in this exact function.

I mean you should modify both the comment and the transform below.

Done. The alive2 test was also updated.

PR Link: llvm/llvm-project#107107

Co-authored-by: Yingwei Zheng <[email protected]>

github-actions · 2024-09-08T02:01:49Z

✅ With the latest revision this PR passed the C/C++ code formatter.

c8ef · 2024-09-10T01:08:38Z

Dear reviewers, is the PR good to go, or does it need further adjustments, or should it be abandoned due to its lack of real-world usefulness? @arsenm @dtcxzyw @nikic

dtcxzyw

LGTM. Thank you!
Please wait for additional approval from other reviewers :)

c8ef · 2024-09-10T15:22:51Z

�_bk;t=1725980729112�Timed Out Tests (1):

�_bk;t=1725980729112�  lldb-api :: functionalities/fork/concurrent_vfork/TestConcurrentVFork.py

This seems irrelevant to my patch.

nikic

Looks fine to me, but I didn't review in detail.

nikic · 2024-09-11T08:53:47Z

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

+      std::swap(LHS, RHS);
+      Pred = I.getSwappedPredicate();
+    }
+  }


FWIW, I think it's usually more elegant to do this by calling foldFCmpWithFloorAndCeil(Pred, Op0, Op1) and then foldFCmpWithFloorAndCeil(getSwappedPredicate(), Op1, Op0), so the method itself only has to deal with one variant. But the way you did it is fine as well.

~~That's a great idea. I'll make the changes you suggested.~~

I believe we still need to include the fcmp instruction in the function to preserve the fmf flags. The current implementation should be sufficient.

c8ef · 2024-09-13T12:52:29Z

@arsenm, could you please take another look?

arsenm · 2024-09-13T18:22:06Z

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

+                          "", &I);
+    break;
+  default:
+    break;


This isn't handling the cases that use infinities?

The infinite case will eventually be transformed into constants, uno, or ord. Therefore, in earlier commits, we directly transform it into the final result.

See also: #107107 (comment)

floor(x) <= x --> true

c9e8bbd

c8ef requested a review from nikic as a code owner September 3, 2024 13:33

llvmbot added llvm:analysis Includes value tracking, cost tables and constant folding llvm:transforms labels Sep 3, 2024

dtcxzyw requested review from arsenm and jcranmer-intel September 3, 2024 13:37

arsenm reviewed Sep 4, 2024

View reviewed changes

address CR

2555d8f

arsenm reviewed Sep 4, 2024

View reviewed changes

nikic added the floating-point Floating-point math label Sep 4, 2024

c8ef added 2 commits September 4, 2024 22:40

fmf

f6ccb18

inf

a028107

c8ef changed the title ~~[InstSimplify] Fold expression using basic properties of floor and ceiling function~~ [InstCombine] Fold expression using basic properties of floor and ceiling function Sep 5, 2024

ninf

cab149d

c8ef requested a review from arsenm September 5, 2024 02:04

add missing break

1f1a8f8

c8ef requested a review from dtcxzyw September 5, 2024 06:37

nikic reviewed Sep 5, 2024

View reviewed changes

swap operand

34a8e5b

c8ef requested a review from nikic September 5, 2024 12:46

arsenm reviewed Sep 7, 2024

View reviewed changes

CR

1a4fa35

c8ef requested a review from arsenm September 7, 2024 03:01

dtcxzyw reviewed Sep 8, 2024

View reviewed changes

dtcxzyw added a commit to dtcxzyw/llvm-opt-benchmark that referenced this pull request Sep 8, 2024

pre-commit: test PR107107

4581509

PR Link: llvm/llvm-project#107107

dtcxzyw mentioned this pull request Sep 8, 2024

pre-commit: test PR107107 dtcxzyw/llvm-opt-benchmark#1283

Closed

c8ef and others added 2 commits September 8, 2024 09:57

Update llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

d4cbb1e

Co-authored-by: Yingwei Zheng <[email protected]>

Update llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

b0a37fb

Co-authored-by: Yingwei Zheng <[email protected]>

c8ef added 3 commits September 8, 2024 10:04

fmt

b206a3b

fmt

0cded41

Update InstCombineCompares.cpp

aeef4a4

c8ef requested a review from dtcxzyw September 8, 2024 03:53

CR

430db43

dtcxzyw approved these changes Sep 10, 2024

View reviewed changes

nikic reviewed Sep 11, 2024

View reviewed changes

c8ef added 2 commits September 11, 2024 20:43

Merge branch 'main' into floor

470f671

Merge branch 'main' into floor

63468ae

arsenm approved these changes Sep 13, 2024

View reviewed changes

arsenm reviewed Sep 13, 2024

View reviewed changes

c8ef requested a review from arsenm September 15, 2024 01:17

arsenm approved these changes Sep 15, 2024

View reviewed changes

arsenm merged commit 86f0399 into llvm:main Sep 15, 2024
8 checks passed

c8ef deleted the floor branch September 15, 2024 11:04

		KnownFPClass LHSClass = computeKnownFPClass(LHS, fcAllFlags, /Depth=/0, Q);
		KnownFPClass RHSClass = computeKnownFPClass(RHS, fcAllFlags, /Depth=/0, Q);

		if (Pred == FCmpInst::FCMP_OLE \|\|
		Pred == FCmpInst::FCMP_ULE &&

		isKnownNeverNaN(LHS, 0,
		CI.getSimplifyQuery().getWithInstruction(&I))) {

	// fcmp ugt floor(x), x => fcmp ugt -inf, x
	// fcmp ugt floor(x), x => fcmp uno x, 0

	define i1 @floor_x_ugt(float %x) {
	; CHECK-LABEL: @floor_x_ugt(
	; CHECK-NEXT: [[RET:%.]] = fcmp ninf uno float [[X:%.]], 0.000000e+00
	; CHECK-NEXT: ret i1 [[RET]]
	;
	%floor = call float @llvm.floor.f32(float %x)
	%ret = fcmp ninf ugt float %floor, %x
	ret i1 %ret
	}

[InstCombine] Fold expression using basic properties of floor and ceiling function #107107

[InstCombine] Fold expression using basic properties of floor and ceiling function #107107

Uh oh!

Conversation

c8ef commented Sep 3, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

llvmbot commented Sep 3, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

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!

c8ef commented Sep 4, 2024

Uh oh!

dtcxzyw commented Sep 4, 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!

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!

c8ef commented Sep 6, 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!

c8ef commented Sep 8, 2024

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

c8ef commented Sep 3, 2024 •

edited

Loading

llvmbot commented Sep 3, 2024 •

edited

Loading

github-actions bot commented Sep 8, 2024 •

edited

Loading

c8ef Sep 11, 2024 •

edited

Loading