Skip to content

[InstCombine] Fold frexp of select to select of frexp #121227

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 4 commits into from
Jan 31, 2025
Merged

[InstCombine] Fold frexp of select to select of frexp #121227

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
7e22e93
[InstCombine] Pre-Commit Tests
vortex73 Jan 2, 2025
b738a1d
[InstCombine] InstCombine should fold frexp of select to select of frexp
vortex73 Jan 3, 2025
1e656c8
[InstCombine] Refactor and Preserve fast math flags
vortex73 Jan 6, 2025
ad6c501
[InstCombine] Refactor PatternMatch and add scalable Vector tests
vortex73 Jan 30, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
53 changes: 53 additions & 0 deletions llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,6 +33,7 @@
//===----------------------------------------------------------------------===//

#include "InstCombineInternal.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
Expand Down Expand Up @@ -4069,6 +4070,49 @@ InstCombinerImpl::foldExtractOfOverflowIntrinsic(ExtractValueInst &EV) {
return nullptr;
}

static Value *foldFrexpOfSelect(ExtractValueInst &EV, IntrinsicInst *FrexpCall,
SelectInst *SelectInst,
InstCombiner::BuilderTy &Builder) {
// Helper to fold frexp of select to select of frexp.

if (!SelectInst->hasOneUse() || !FrexpCall->hasOneUse())
return nullptr;
Value *Cond = SelectInst->getCondition();
Value *TrueVal = SelectInst->getTrueValue();
Value *FalseVal = SelectInst->getFalseValue();

const APFloat *ConstVal = nullptr;
Value *VarOp = nullptr;
bool ConstIsTrue = false;

if (match(TrueVal, m_APFloat(ConstVal))) {
VarOp = FalseVal;
ConstIsTrue = true;
} else if (match(FalseVal, m_APFloat(ConstVal))) {
VarOp = TrueVal;
ConstIsTrue = false;
} else {
return nullptr;
}

Builder.SetInsertPoint(&EV);

CallInst *NewFrexp =
Builder.CreateCall(FrexpCall->getCalledFunction(), {VarOp}, "frexp");
NewFrexp->copyIRFlags(FrexpCall);

Value *NewEV = Builder.CreateExtractValue(NewFrexp, 0, "mantissa");

int Exp;
APFloat Mantissa = frexp(*ConstVal, Exp, APFloat::rmNearestTiesToEven);

Constant *ConstantMantissa = ConstantFP::get(TrueVal->getType(), Mantissa);

Value *NewSel = Builder.CreateSelectFMF(
Cond, ConstIsTrue ? ConstantMantissa : NewEV,
ConstIsTrue ? NewEV : ConstantMantissa, SelectInst, "select.frexp");
return NewSel;
}
Instruction *InstCombinerImpl::visitExtractValueInst(ExtractValueInst &EV) {
Value *Agg = EV.getAggregateOperand();

Expand All @@ -4079,6 +4123,15 @@ Instruction *InstCombinerImpl::visitExtractValueInst(ExtractValueInst &EV) {
SQ.getWithInstruction(&EV)))
return replaceInstUsesWith(EV, V);

Value *Cond, *TrueVal, *FalseVal;
if (match(&EV, m_ExtractValue<0>(m_Intrinsic<Intrinsic::frexp>(m_Select(
m_Value(Cond), m_Value(TrueVal), m_Value(FalseVal)))))) {
auto *SelInst =
cast<SelectInst>(cast<IntrinsicInst>(Agg)->getArgOperand(0));
if (Value *Result =
foldFrexpOfSelect(EV, cast<IntrinsicInst>(Agg), SelInst, Builder))
return replaceInstUsesWith(EV, Result);
}
if (InsertValueInst *IV = dyn_cast<InsertValueInst>(Agg)) {
// We're extracting from an insertvalue instruction, compare the indices
const unsigned *exti, *exte, *insi, *inse;
Expand Down
191 changes: 191 additions & 0 deletions llvm/test/Transforms/InstCombine/select_frexp.ll
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,191 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
; RUN: opt -passes=instcombine -S < %s | FileCheck %s

declare { float, i32 } @llvm.frexp.f32.i32(float)
declare void @use(float)

; Basic test case - constant in true position
define float @test_select_frexp_basic(float %x, i1 %cond) {
; CHECK-LABEL: define float @test_select_frexp_basic(
; CHECK-SAME: float [[X:%.*]], i1 [[COND:%.*]]) {
; CHECK-NEXT: [[FREXP:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[X]])
; CHECK-NEXT: [[FREXP_0:%.*]] = extractvalue { float, i32 } [[FREXP]], 0
; CHECK-NEXT: [[SELECT_FREXP:%.*]] = select i1 [[COND]], float 5.000000e-01, float [[FREXP_0]]
; CHECK-NEXT: ret float [[SELECT_FREXP]]
;
%sel = select i1 %cond, float 1.000000e+00, float %x
%frexp = call { float, i32 } @llvm.frexp.f32.i32(float %sel)
%frexp.0 = extractvalue { float, i32 } %frexp, 0
ret float %frexp.0
}

; Test with constant in false position
define float @test_select_frexp_const_false(float %x, i1 %cond) {
; CHECK-LABEL: define float @test_select_frexp_const_false(
; CHECK-SAME: float [[X:%.*]], i1 [[COND:%.*]]) {
; CHECK-NEXT: [[FREXP:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[X]])
; CHECK-NEXT: [[FREXP_0:%.*]] = extractvalue { float, i32 } [[FREXP]], 0
; CHECK-NEXT: [[SELECT_FREXP:%.*]] = select i1 [[COND]], float [[FREXP_0]], float 5.000000e-01
; CHECK-NEXT: ret float [[SELECT_FREXP]]
;
%sel = select i1 %cond, float %x, float 1.000000e+00
%frexp = call { float, i32 } @llvm.frexp.f32.i32(float %sel)
%frexp.0 = extractvalue { float, i32 } %frexp, 0
ret float %frexp.0
}

; Multi-use test
define float @test_select_frexp_multi_use(float %x, i1 %cond) {
; CHECK-LABEL: define float @test_select_frexp_multi_use(
; CHECK-SAME: float [[X:%.*]], i1 [[COND:%.*]]) {
; CHECK-NEXT: [[SEL:%.*]] = select i1 [[COND]], float 1.000000e+00, float [[X]]
; CHECK-NEXT: call void @use(float [[SEL]])
; CHECK-NEXT: [[FREXP:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[SEL]])
; CHECK-NEXT: [[FREXP_0:%.*]] = extractvalue { float, i32 } [[FREXP]], 0
; CHECK-NEXT: ret float [[FREXP_0]]
;
%sel = select i1 %cond, float 1.000000e+00, float %x
call void @use(float %sel)
%frexp = call { float, i32 } @llvm.frexp.f32.i32(float %sel)
%frexp.0 = extractvalue { float, i32 } %frexp, 0
ret float %frexp.0
}

; Vector test - splat constant
define <2 x float> @test_select_frexp_vec_splat(<2 x float> %x, <2 x i1> %cond) {
; CHECK-LABEL: define <2 x float> @test_select_frexp_vec_splat(
; CHECK-SAME: <2 x float> [[X:%.*]], <2 x i1> [[COND:%.*]]) {
; CHECK-NEXT: [[FREXP:%.*]] = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> [[X]])
; CHECK-NEXT: [[FREXP_0:%.*]] = extractvalue { <2 x float>, <2 x i32> } [[FREXP]], 0
; CHECK-NEXT: [[SELECT_FREXP:%.*]] = select <2 x i1> [[COND]], <2 x float> splat (float 5.000000e-01), <2 x float> [[FREXP_0]]
; CHECK-NEXT: ret <2 x float> [[SELECT_FREXP]]
;
%sel = select <2 x i1> %cond, <2 x float> <float 1.000000e+00, float 1.000000e+00>, <2 x float> %x
%frexp = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %sel)
%frexp.0 = extractvalue { <2 x float>, <2 x i32> } %frexp, 0
ret <2 x float> %frexp.0
}

; Vector test with poison
define <2 x float> @test_select_frexp_vec_poison(<2 x float> %x, <2 x i1> %cond) {
; CHECK-LABEL: define <2 x float> @test_select_frexp_vec_poison(
; CHECK-SAME: <2 x float> [[X:%.*]], <2 x i1> [[COND:%.*]]) {
; CHECK-NEXT: [[SEL:%.*]] = select <2 x i1> [[COND]], <2 x float> <float 1.000000e+00, float poison>, <2 x float> [[X]]
; CHECK-NEXT: [[FREXP:%.*]] = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> [[SEL]])
; CHECK-NEXT: [[FREXP_0:%.*]] = extractvalue { <2 x float>, <2 x i32> } [[FREXP]], 0
; CHECK-NEXT: ret <2 x float> [[FREXP_0]]
;
%sel = select <2 x i1> %cond, <2 x float> <float 1.000000e+00, float poison>, <2 x float> %x
%frexp = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %sel)
%frexp.0 = extractvalue { <2 x float>, <2 x i32> } %frexp, 0
ret <2 x float> %frexp.0
}

; Vector test - non-splat (should not fold)
define <2 x float> @test_select_frexp_vec_nonsplat(<2 x float> %x, <2 x i1> %cond) {
; CHECK-LABEL: define <2 x float> @test_select_frexp_vec_nonsplat(
; CHECK-SAME: <2 x float> [[X:%.*]], <2 x i1> [[COND:%.*]]) {
; CHECK-NEXT: [[SEL:%.*]] = select <2 x i1> [[COND]], <2 x float> <float 1.000000e+00, float 2.000000e+00>, <2 x float> [[X]]
; CHECK-NEXT: [[FREXP:%.*]] = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> [[SEL]])
; CHECK-NEXT: [[FREXP_0:%.*]] = extractvalue { <2 x float>, <2 x i32> } [[FREXP]], 0
; CHECK-NEXT: ret <2 x float> [[FREXP_0]]
;
%sel = select <2 x i1> %cond, <2 x float> <float 1.000000e+00, float 2.000000e+00>, <2 x float> %x
%frexp = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %sel)
%frexp.0 = extractvalue { <2 x float>, <2 x i32> } %frexp, 0
ret <2 x float> %frexp.0
}

; Negative test - both operands non-constant
define float @test_select_frexp_no_const(float %x, float %y, i1 %cond) {
; CHECK-LABEL: define float @test_select_frexp_no_const(
; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]], i1 [[COND:%.*]]) {
; CHECK-NEXT: [[SEL:%.*]] = select i1 [[COND]], float [[X]], float [[Y]]
; CHECK-NEXT: [[FREXP:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[SEL]])
; CHECK-NEXT: [[FREXP_0:%.*]] = extractvalue { float, i32 } [[FREXP]], 0
; CHECK-NEXT: ret float [[FREXP_0]]
;
%sel = select i1 %cond, float %x, float %y
%frexp = call { float, i32 } @llvm.frexp.f32.i32(float %sel)
%frexp.0 = extractvalue { float, i32 } %frexp, 0
ret float %frexp.0
}

; Negative test - extracting exp instead of mantissa
define i32 @test_select_frexp_extract_exp(float %x, i1 %cond) {
; CHECK-LABEL: define i32 @test_select_frexp_extract_exp(
; CHECK-SAME: float [[X:%.*]], i1 [[COND:%.*]]) {
; CHECK-NEXT: [[SEL:%.*]] = select i1 [[COND]], float 1.000000e+00, float [[X]]
; CHECK-NEXT: [[FREXP:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[SEL]])
; CHECK-NEXT: [[FREXP_1:%.*]] = extractvalue { float, i32 } [[FREXP]], 1
; CHECK-NEXT: ret i32 [[FREXP_1]]
;
%sel = select i1 %cond, float 1.000000e+00, float %x
%frexp = call { float, i32 } @llvm.frexp.f32.i32(float %sel)
%frexp.1 = extractvalue { float, i32 } %frexp, 1
ret i32 %frexp.1
}

; Test with fast math flags
define float @test_select_frexp_fast_math_select(float %x, i1 %cond) {
; CHECK-LABEL: define float @test_select_frexp_fast_math_select(
; CHECK-SAME: float [[X:%.*]], i1 [[COND:%.*]]) {
; CHECK-NEXT: [[FREXP1:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[X]])
; CHECK-NEXT: [[MANTISSA:%.*]] = extractvalue { float, i32 } [[FREXP1]], 0
; CHECK-NEXT: [[SELECT_FREXP:%.*]] = select nnan ninf nsz i1 [[COND]], float 5.000000e-01, float [[MANTISSA]]
; CHECK-NEXT: ret float [[SELECT_FREXP]]
;
%sel = select nnan ninf nsz i1 %cond, float 1.000000e+00, float %x
%frexp = call { float, i32 } @llvm.frexp.f32.i32(float %sel)
%frexp.0 = extractvalue { float, i32 } %frexp, 0
ret float %frexp.0
}


; Test vector case with fast math flags
define <2 x float> @test_select_frexp_vec_fast_math(<2 x float> %x, <2 x i1> %cond) {
; CHECK-LABEL: define <2 x float> @test_select_frexp_vec_fast_math(
; CHECK-SAME: <2 x float> [[X:%.*]], <2 x i1> [[COND:%.*]]) {
; CHECK-NEXT: [[FREXP1:%.*]] = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> [[X]])
; CHECK-NEXT: [[MANTISSA:%.*]] = extractvalue { <2 x float>, <2 x i32> } [[FREXP1]], 0
; CHECK-NEXT: [[SELECT_FREXP:%.*]] = select nnan ninf nsz <2 x i1> [[COND]], <2 x float> splat (float 5.000000e-01), <2 x float> [[MANTISSA]]
; CHECK-NEXT: ret <2 x float> [[SELECT_FREXP]]
;
%sel = select nnan ninf nsz <2 x i1> %cond, <2 x float> <float 1.000000e+00, float 1.000000e+00>, <2 x float> %x
%frexp = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %sel)
%frexp.0 = extractvalue { <2 x float>, <2 x i32> } %frexp, 0
ret <2 x float> %frexp.0
}

; Test with scalable vectors with constant at True Position
define <vscale x 2 x float> @test_select_frexp_scalable_vec0(<vscale x 2 x float> %x, <vscale x 2 x i1> %cond) {
; CHECK-LABEL: define <vscale x 2 x float> @test_select_frexp_scalable_vec0(
; CHECK-SAME: <vscale x 2 x float> [[X:%.*]], <vscale x 2 x i1> [[COND:%.*]]) {
; CHECK-NEXT: [[FREXP1:%.*]] = call { <vscale x 2 x float>, <vscale x 2 x i32> } @llvm.frexp.nxv2f32.nxv2i32(<vscale x 2 x float> [[X]])
; CHECK-NEXT: [[MANTISSA:%.*]] = extractvalue { <vscale x 2 x float>, <vscale x 2 x i32> } [[FREXP1]], 0
; CHECK-NEXT: [[SELECT_FREXP:%.*]] = select <vscale x 2 x i1> [[COND]], <vscale x 2 x float> splat (float 5.000000e-01), <vscale x 2 x float> [[MANTISSA]]
; CHECK-NEXT: ret <vscale x 2 x float> [[SELECT_FREXP]]
;
%sel = select <vscale x 2 x i1> %cond, <vscale x 2 x float> splat (float 1.000000e+00), <vscale x 2 x float> %x
%frexp = call { <vscale x 2 x float>, <vscale x 2 x i32> } @llvm.frexp.nxv2f32.nxv2i32(<vscale x 2 x float> %sel)
%frexp.0 = extractvalue { <vscale x 2 x float>, <vscale x 2 x i32> } %frexp, 0
ret <vscale x 2 x float> %frexp.0
}

; Test with scalable vectors with constant at False Position
define <vscale x 2 x float> @test_select_frexp_scalable_vec1(<vscale x 2 x float> %x, <vscale x 2 x i1> %cond) {
; CHECK-LABEL: define <vscale x 2 x float> @test_select_frexp_scalable_vec1(
; CHECK-SAME: <vscale x 2 x float> [[X:%.*]], <vscale x 2 x i1> [[COND:%.*]]) {
; CHECK-NEXT: [[FREXP1:%.*]] = call { <vscale x 2 x float>, <vscale x 2 x i32> } @llvm.frexp.nxv2f32.nxv2i32(<vscale x 2 x float> [[X]])
; CHECK-NEXT: [[MANTISSA:%.*]] = extractvalue { <vscale x 2 x float>, <vscale x 2 x i32> } [[FREXP1]], 0
; CHECK-NEXT: [[SELECT_FREXP:%.*]] = select <vscale x 2 x i1> [[COND]], <vscale x 2 x float> [[MANTISSA]], <vscale x 2 x float> splat (float 5.000000e-01)
; CHECK-NEXT: ret <vscale x 2 x float> [[SELECT_FREXP]]
;
%sel = select <vscale x 2 x i1> %cond, <vscale x 2 x float> %x, <vscale x 2 x float> splat (float 1.000000e+00)
%frexp = call { <vscale x 2 x float>, <vscale x 2 x i32> } @llvm.frexp.nxv2f32.nxv2i32(<vscale x 2 x float> %sel)
%frexp.0 = extractvalue { <vscale x 2 x float>, <vscale x 2 x i32> } %frexp, 0
ret <vscale x 2 x float> %frexp.0
}

declare { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float>)
declare { <vscale x 2 x float>, <vscale x 2 x i32> } @llvm.frexp.nxv2f32.nxv2i32(<vscale x 2 x float>)