shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
llvm-project/llvm/test/Transforms/InstSimplify/ldexp.ll
Nikita Popov d9a5aa8e2d
[PatternMatch] Do not accept undef elements in m_AllOnes() and friends (#88217) 
Change all the cstval_pred_ty based PatternMatch helpers (things like
m_AllOnes and m_Zero) to only allow poison elements inside vector
splats, not undef elements.

Historically, we used to represent non-demanded elements in vectors
using undef. Nowadays, we use poison instead. As such, I believe that
support for undef in vector splats is no longer useful.

At the same time, while poison splat elements are pretty much always
safe to ignore, this is not generally the case for undef elements. We
have existing miscompiles in our tests due to this (see the
masked-merge-*.ll tests changed here) and it's easy to miss such cases
in the future, now that we write tests using poison instead of undef
elements.

I think overall, keeping support for undef elements no longer makes
sense, and we should drop it. Once this is done consistently, I think we
may also consider allowing poison in m_APInt by default, as doing that
change is much less risky than doing the same with undef.

This change involves a substantial amount of test changes. For most
tests, I've just replaced undef with poison, as I don't think there is
value in retaining both. For some tests (where the distinction between
undef and poison is important), I've duplicated tests.
2024-04-17 18:22:05 +09:00

507 lines
28 KiB
LLVM
Raw Permalink Blame History

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
define float @ldexp_f32_undef_undef() {
; CHECK-LABEL: @ldexp_f32_undef_undef(
; CHECK-NEXT: ret float 0x7FF8000000000000
;
%call = call float @llvm.ldexp.f32.i32(float undef, i32 undef)
ret float %call
}
define float @ldexp_f32_poison_undef() {
; CHECK-LABEL: @ldexp_f32_poison_undef(
; CHECK-NEXT: ret float poison
;
%call = call float @llvm.ldexp.f32.i32(float poison, i32 undef)
ret float %call
}
define float @ldexp_f32_undef_poison() {
; CHECK-LABEL: @ldexp_f32_undef_poison(
; CHECK-NEXT: ret float undef
;
%call = call float @llvm.ldexp.f32.i32(float undef, i32 poison)
ret float %call
}
define float @ldexp_f32_poison_poison() {
; CHECK-LABEL: @ldexp_f32_poison_poison(
; CHECK-NEXT: ret float poison
;
%call = call float @llvm.ldexp.f32.i32(float poison, i32 poison)
ret float %call
}
; If the exponent is 0, it doesn't matter if the first argument is
; constant or not.
define void @ldexp_f32_exp0(float %x) {
; CHECK-LABEL: @ldexp_f32_exp0(
; CHECK-NEXT: store volatile float [[X:%.*]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float [[X]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[ONE:%.*]] = call float @llvm.ldexp.f32.i32(float [[X]], i32 1)
; CHECK-NEXT: store volatile float [[ONE]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: ret void
;
%zero = call float @llvm.ldexp.f32.i32(float %x, i32 0)
store volatile float %zero, ptr addrspace(1) undef
%undef = call float @llvm.ldexp.f32.i32(float %x, i32 undef)
store volatile float %undef, ptr addrspace(1) undef
%one = call float @llvm.ldexp.f32.i32(float %x, i32 1)
store volatile float %one, ptr addrspace(1) undef
ret void
}
define void @ldexp_v2f32_exp0(<2 x float> %x) {
; CHECK-LABEL: @ldexp_v2f32_exp0(
; CHECK-NEXT: store volatile <2 x float> [[X:%.*]], ptr addrspace(1) undef, align 8
; CHECK-NEXT: [[PART_UNDEF1:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> [[X]], <2 x i32> <i32 undef, i32 0>)
; CHECK-NEXT: store volatile <2 x float> [[PART_UNDEF1]], ptr addrspace(1) undef, align 8
; CHECK-NEXT: store volatile <2 x float> [[X]], ptr addrspace(1) undef, align 8
; CHECK-NEXT: ret void
;
%part.undef0 = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %x, <2 x i32> <i32 0, i32 poison>)
store volatile <2 x float> %part.undef0, ptr addrspace(1) undef
%part.undef1 = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %x, <2 x i32> <i32 undef, i32 0>)
store volatile <2 x float> %part.undef1, ptr addrspace(1) undef
%zero = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %x, <2 x i32> zeroinitializer)
store volatile <2 x float> %zero, ptr addrspace(1) undef
ret void
}
; Test variable exponent but zero or undef value.
define void @ldexp_f32_val0(i32 %y) {
; CHECK-LABEL: @ldexp_f32_val0(
; CHECK-NEXT: store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float -0.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0x7FF8000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: ret void
;
%zero = call float @llvm.ldexp.f32.i32(float 0.0, i32 %y)
store volatile float %zero, ptr addrspace(1) undef
%neg.zero = call float @llvm.ldexp.f32.i32(float -0.0, i32 %y)
store volatile float %neg.zero, ptr addrspace(1) undef
%undef = call float @llvm.ldexp.f32.i32(float undef, i32 %y)
store volatile float %undef, ptr addrspace(1) undef
ret void
}
define void @ldexp_f32_val_infinity(i32 %y) {
; CHECK-LABEL: @ldexp_f32_val_infinity(
; CHECK-NEXT: store volatile float 0x7FF0000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0xFFF0000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0x7FF0000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0xFFF0000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: ret void
;
%inf = call float @llvm.ldexp.f32.i32(float 0x7ff0000000000000, i32 %y)
store volatile float %inf, ptr addrspace(1) undef
%neg.inf = call float @llvm.ldexp.f32.i32(float 0xfff0000000000000, i32 %y)
store volatile float %neg.inf, ptr addrspace(1) undef
%inf.zero = call float @llvm.ldexp.f32.i32(float 0x7ff0000000000000, i32 0)
store volatile float %inf.zero, ptr addrspace(1) undef
%neg.inf.zero = call float @llvm.ldexp.f32.i32(float 0xfff0000000000000, i32 0)
store volatile float %neg.inf.zero, ptr addrspace(1) undef
ret void
}
; Signaling nan should be quieted.
; Technically this depends on the ieee_mode in the mode register.
define void @ldexp_f32_val_nan(i32 %y) {
; CHECK-LABEL: @ldexp_f32_val_nan(
; CHECK-NEXT: store volatile float 0x7FF8001000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0xFFF8000100000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0x7FF8000020000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0xFFFFFFFFE0000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: ret void
;
%plus.qnan = call float @llvm.ldexp.f32.i32(float 0x7ff0001000000000, i32 %y)
store volatile float %plus.qnan, ptr addrspace(1) undef
%neg.qnan = call float @llvm.ldexp.f32.i32(float 0xfff0000100000000, i32 %y)
store volatile float %neg.qnan, ptr addrspace(1) undef
%plus.snan = call float @llvm.ldexp.f32.i32(float 0x7FF0000020000000, i32 %y)
store volatile float %plus.snan, ptr addrspace(1) undef
%neg.snan = call float @llvm.ldexp.f32.i32(float 0xFFF7FFFFE0000000, i32 %y)
store volatile float %neg.snan, ptr addrspace(1) undef
ret void
}
define void @ldexp_f32_val_nan_strictfp_maytrap(i32 %y) #0 {
; CHECK-LABEL: @ldexp_f32_val_nan_strictfp_maytrap(
; CHECK-NEXT: [[PLUS_QNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0001000000000, i32 [[Y:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0:[0-9]+]]
; CHECK-NEXT: store volatile float [[PLUS_QNAN]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[NEG_QNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xFFF0000100000000, i32 [[Y]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[NEG_QNAN]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[PLUS_SNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 [[Y]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[PLUS_SNAN]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[NEG_SNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xFFF7FFFFE0000000, i32 [[Y]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[NEG_SNAN]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0x7FF8000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: ret void
;
%plus.qnan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7ff0001000000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %plus.qnan, ptr addrspace(1) undef
%neg.qnan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xfff0000100000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %neg.qnan, ptr addrspace(1) undef
%plus.snan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %plus.snan, ptr addrspace(1) undef
%neg.snan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xFFF7FFFFE0000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %neg.snan, ptr addrspace(1) undef
%undef = call float @llvm.experimental.constrained.ldexp.f32.i32(float undef, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %undef, ptr addrspace(1) undef
ret void
}
define void @ldexp_f32_val_nan_strictfp_strict(i32 %y) #0 {
; CHECK-LABEL: @ldexp_f32_val_nan_strictfp_strict(
; CHECK-NEXT: [[PLUS_QNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0001000000000, i32 [[Y:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[PLUS_QNAN]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[NEG_QNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xFFF0000100000000, i32 [[Y]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[NEG_QNAN]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[PLUS_SNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 [[Y]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[PLUS_SNAN]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[NEG_SNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xFFF7FFFFE0000000, i32 [[Y]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[NEG_SNAN]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[UNDEF:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float undef, i32 [[Y]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
; CHECK-NEXT: store volatile float 0x7FF8000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: ret void
;
%plus.qnan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7ff0001000000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
store volatile float %plus.qnan, ptr addrspace(1) undef
%neg.qnan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xfff0000100000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
store volatile float %neg.qnan, ptr addrspace(1) undef
%plus.snan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
store volatile float %plus.snan, ptr addrspace(1) undef
%neg.snan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xFFF7FFFFE0000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
store volatile float %neg.snan, ptr addrspace(1) undef
%undef = call float @llvm.experimental.constrained.ldexp.f32.i32(float undef, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
store volatile float %undef, ptr addrspace(1) undef
ret void
}
define void @ldexp_f32_0() {
; CHECK-LABEL: @ldexp_f32_0(
; CHECK-NEXT: store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float -0.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: ret void
;
%zero = call float @llvm.ldexp.f32.i32(float 0.0, i32 0)
store volatile float %zero, ptr addrspace(1) undef
%neg.zero = call float @llvm.ldexp.f32.i32(float -0.0, i32 0)
store volatile float %neg.zero, ptr addrspace(1) undef
%one = call float @llvm.ldexp.f32.i32(float 0.0, i32 1)
store volatile float %one, ptr addrspace(1) undef
%min.exp = call float @llvm.ldexp.f32.i32(float 0.0, i32 -126)
store volatile float %min.exp, ptr addrspace(1) undef
%min.exp.sub1 = call float @llvm.ldexp.f32.i32(float 0.0, i32 -127)
store volatile float %min.exp.sub1, ptr addrspace(1) undef
%max.exp = call float @llvm.ldexp.f32.i32(float 0.0, i32 127)
store volatile float %max.exp, ptr addrspace(1) undef
%max.exp.plus1 = call float @llvm.ldexp.f32.i32(float 0.0, i32 128)
store volatile float %max.exp.plus1, ptr addrspace(1) undef
ret void
}
define void @ldexp_f32_undef_strictfp(float %x, i32 %y) #0 {
; CHECK-LABEL: @ldexp_f32_undef_strictfp(
; CHECK-NEXT: [[UNDEF_EXP:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float [[X:%.*]], i32 undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[UNDEF_EXP]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float [[X]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0x7FF8000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float poison, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float poison, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float undef, ptr addrspace(1) undef, align 4
; CHECK-NEXT: ret void
;
%undef.exp = call float @llvm.experimental.constrained.ldexp.f32.i32(float %x, i32 undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %undef.exp, ptr addrspace(1) undef
%poison.exp = call float @llvm.experimental.constrained.ldexp.f32.i32(float %x, i32 poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %poison.exp, ptr addrspace(1) undef
%undef.val = call float @llvm.experimental.constrained.ldexp.f32.i32(float undef, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %undef.val, ptr addrspace(1) undef
%poison.val = call float @llvm.experimental.constrained.ldexp.f32.i32(float poison, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %poison.val, ptr addrspace(1) undef
%poison.undef = call float @llvm.experimental.constrained.ldexp.f32.i32(float poison, i32 undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %poison.undef, ptr addrspace(1) undef
%undef.poison = call float @llvm.experimental.constrained.ldexp.f32.i32(float undef, i32 poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %undef.poison, ptr addrspace(1) undef
ret void
}
; Should be able to ignore strictfp in this case
define void @ldexp_f32_0_strictfp(float %x) #0 {
; CHECK-LABEL: @ldexp_f32_0_strictfp(
; CHECK-NEXT: store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float -0.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[UNKNOWN_ZERO:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float [[X:%.*]], i32 0, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[UNKNOWN_ZERO]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[UNKNOWN_UNDEF:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float [[X]], i32 undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[UNKNOWN_UNDEF]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[DENORMAL_0:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x380FFFFFC0000000, i32 0, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[DENORMAL_0]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[DENORMAL_1:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x380FFFFFC0000000, i32 1, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[DENORMAL_1]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: ret void
;
%zero = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0.0, i32 0, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %zero, ptr addrspace(1) undef
%neg.zero = call float @llvm.experimental.constrained.ldexp.f32.i32(float -0.0, i32 0, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %neg.zero, ptr addrspace(1) undef
%one = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0.0, i32 1, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %one, ptr addrspace(1) undef
%unknown.zero = call float @llvm.experimental.constrained.ldexp.f32.i32(float %x, i32 0, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %unknown.zero, ptr addrspace(1) undef
%unknown.undef = call float @llvm.experimental.constrained.ldexp.f32.i32(float %x, i32 undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %unknown.undef, ptr addrspace(1) undef
%denormal.0 = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x380FFFFFC0000000, i32 0, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %denormal.0, ptr addrspace(1) undef
%denormal.1 = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x380FFFFFC0000000, i32 1, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
store volatile float %denormal.1, ptr addrspace(1) undef
ret void
}
define void @ldexp_f32() {
; CHECK-LABEL: @ldexp_f32(
; CHECK-NEXT: store volatile float 2.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 4.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 8.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 5.000000e-01, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0x3810000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0x3800000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0x47E0000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0x7FF0000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float -2.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float -4.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float -8.000000e+00, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float -5.000000e-01, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0xB810000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0xB800000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0xC7E0000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0xFFF0000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0x44D5000000000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: ret void
;
%one.one = call float @llvm.ldexp.f32.i32(float 1.0, i32 1)
store volatile float %one.one, ptr addrspace(1) undef
%one.two = call float @llvm.ldexp.f32.i32(float 1.0, i32 2)
store volatile float %one.two, ptr addrspace(1) undef
%one.three = call float @llvm.ldexp.f32.i32(float 1.0, i32 3)
store volatile float %one.three, ptr addrspace(1) undef
%one.negone = call float @llvm.ldexp.f32.i32(float 1.0, i32 -1)
store volatile float %one.negone, ptr addrspace(1) undef
%one.min.exp = call float @llvm.ldexp.f32.i32(float 1.0, i32 -126)
store volatile float %one.min.exp, ptr addrspace(1) undef
%one.min.exp.sub1 = call float @llvm.ldexp.f32.i32(float 1.0, i32 -127)
store volatile float %one.min.exp.sub1, ptr addrspace(1) undef
%one.max.exp = call float @llvm.ldexp.f32.i32(float 1.0, i32 127)
store volatile float %one.max.exp, ptr addrspace(1) undef
%one.max.exp.plus1 = call float @llvm.ldexp.f32.i32(float 1.0, i32 128)
store volatile float %one.max.exp.plus1, ptr addrspace(1) undef
%neg.one.one = call float @llvm.ldexp.f32.i32(float -1.0, i32 1)
store volatile float %neg.one.one, ptr addrspace(1) undef
%neg.one.two = call float @llvm.ldexp.f32.i32(float -1.0, i32 2)
store volatile float %neg.one.two, ptr addrspace(1) undef
%neg.one.three = call float @llvm.ldexp.f32.i32(float -1.0, i32 3)
store volatile float %neg.one.three, ptr addrspace(1) undef
%neg.one.negone = call float @llvm.ldexp.f32.i32(float -1.0, i32 -1)
store volatile float %neg.one.negone, ptr addrspace(1) undef
%neg.one.min.exp = call float @llvm.ldexp.f32.i32(float -1.0, i32 -126)
store volatile float %neg.one.min.exp, ptr addrspace(1) undef
%neg.one.min.exp.sub1 = call float @llvm.ldexp.f32.i32(float -1.0, i32 -127)
store volatile float %neg.one.min.exp.sub1, ptr addrspace(1) undef
%neg.one.max.exp = call float @llvm.ldexp.f32.i32(float -1.0, i32 127)
store volatile float %neg.one.max.exp, ptr addrspace(1) undef
%neg.one.max.exp.plus1 = call float @llvm.ldexp.f32.i32(float -1.0, i32 128)
store volatile float %neg.one.max.exp.plus1, ptr addrspace(1) undef
%fortytwo.seven = call float @llvm.ldexp.f32.i32(float 42.0, i32 73)
store volatile float %fortytwo.seven, ptr addrspace(1) undef
ret void
}
; Technically we should probably flush these depending on the expected
; denormal mode of the function, but no other IR constant folding
; considers this.
define void @ldexp_f32_denormal() {
; CHECK-LABEL: @ldexp_f32_denormal(
; CHECK-NEXT: store volatile float 0x380FFFFFC0000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: store volatile float 0x381FFFFFC0000000, ptr addrspace(1) undef, align 4
; CHECK-NEXT: ret void
;
%denormal.0 = call float @llvm.ldexp.f32.i32(float 0x380FFFFFC0000000, i32 0)
store volatile float %denormal.0, ptr addrspace(1) undef
%denormal.1 = call float @llvm.ldexp.f32.i32(float 0x380FFFFFC0000000, i32 1)
store volatile float %denormal.1, ptr addrspace(1) undef
ret void
}
define void @ldexp_f64() {
; CHECK-LABEL: @ldexp_f64(
; CHECK-NEXT: store volatile double 2.000000e+00, ptr addrspace(1) undef, align 8
; CHECK-NEXT: store volatile double 4.000000e+00, ptr addrspace(1) undef, align 8
; CHECK-NEXT: store volatile double 0x44D5000000000000, ptr addrspace(1) undef, align 8
; CHECK-NEXT: ret void
;
%one.one = call double @llvm.ldexp.f64.i32(double 1.0, i32 1)
store volatile double %one.one, ptr addrspace(1) undef
%one.two = call double @llvm.ldexp.f64.i32(double 1.0, i32 2)
store volatile double %one.two, ptr addrspace(1) undef
%fortytwo.seven = call double @llvm.ldexp.f64.i32(double 42.0, i32 73)
store volatile double %fortytwo.seven, ptr addrspace(1) undef
ret void
}
define void @ldexp_f16() {
; CHECK-LABEL: @ldexp_f16(
; CHECK-NEXT: store volatile half 0xH4000, ptr addrspace(1) undef, align 2
; CHECK-NEXT: store volatile half 0xH4400, ptr addrspace(1) undef, align 2
; CHECK-NEXT: store volatile half 0xH7C00, ptr addrspace(1) undef, align 2
; CHECK-NEXT: ret void
;
%one.one = call half @llvm.ldexp.f16.i32(half 1.0, i32 1)
store volatile half %one.one, ptr addrspace(1) undef
%one.two = call half @llvm.ldexp.f16.i32(half 1.0, i32 2)
store volatile half %one.two, ptr addrspace(1) undef
%fortytwo.seven = call half @llvm.ldexp.f16.i32(half 42.0, i32 73)
store volatile half %fortytwo.seven, ptr addrspace(1) undef
ret void
}
define void @ldexp_ppcf128() {
; CHECK-LABEL: @ldexp_ppcf128(
; CHECK-NEXT: store volatile ppc_fp128 0xMFFF00000000000000000000000000000, ptr addrspace(1) undef, align 16
; CHECK-NEXT: store volatile ppc_fp128 0xMFFFC0000000000000000000000000000, ptr addrspace(1) undef, align 16
; CHECK-NEXT: store volatile ppc_fp128 0xM3FD00000000000000000000000000000, ptr addrspace(1) undef, align 16
; CHECK-NEXT: store volatile ppc_fp128 0xM41700000000000000000000000000000, ptr addrspace(1) undef, align 16
; CHECK-NEXT: store volatile ppc_fp128 0xMC0700000000000000000000000000000, ptr addrspace(1) undef, align 16
; CHECK-NEXT: ret void
;
%neginf = call ppc_fp128 @llvm.ldexp.ppcf128.i32(ppc_fp128 0xMFFF00000000000000000000000000000, i32 0)
store volatile ppc_fp128 %neginf, ptr addrspace(1) undef
%snan = call ppc_fp128 @llvm.ldexp.ppcf128.i32(ppc_fp128 0xMFFFC0000000000000000000000000000, i32 0)
store volatile ppc_fp128 %snan, ptr addrspace(1) undef
%one.neg2 = call ppc_fp128 @llvm.ldexp.ppcf128.i32(ppc_fp128 0xM3FF00000000000000000000000000000, i32 -2)
store volatile ppc_fp128 %one.neg2, ptr addrspace(1) undef
%one.24 = call ppc_fp128 @llvm.ldexp.ppcf128.i32(ppc_fp128 0xM3FF00000000000000000000000000000, i32 24)
store volatile ppc_fp128 %one.24, ptr addrspace(1) undef
%negone.8 = call ppc_fp128 @llvm.ldexp.ppcf128.i32(ppc_fp128 0xMBFF00000000000000000000000000000, i32 8)
store volatile ppc_fp128 %negone.8, ptr addrspace(1) undef
ret void
}
define void @constant_fold_ldexp_f32_val_strictfp(i32 %y) #0 {
; CHECK-LABEL: @constant_fold_ldexp_f32_val_strictfp(
; CHECK-NEXT: [[SNAN_MAY_TRAP:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 3, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[SNAN_MAY_TRAP]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[SNAN_MAY_NOT_TRAP:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 3, metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[SNAN_MAY_NOT_TRAP]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[UNKNOWN_ROUNDING:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 2.500000e+00, i32 42, metadata !"round.dynamic", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[UNKNOWN_ROUNDING]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[NORMAL:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 2.500000e+00, i32 42, metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[NORMAL]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: [[NORMAL_DOWN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 2.500000e+00, i32 42, metadata !"round.downward", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: store volatile float [[NORMAL_DOWN]], ptr addrspace(1) undef, align 4
; CHECK-NEXT: ret void
;
%snan.may.trap = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 3, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
store volatile float %snan.may.trap, ptr addrspace(1) undef
%snan.may.not.trap = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 3, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
store volatile float %snan.may.not.trap, ptr addrspace(1) undef
%unknown.rounding = call float @llvm.experimental.constrained.ldexp.f32.i32(float 2.5, i32 42, metadata !"round.dynamic", metadata !"fpexcept.ignore") #0
store volatile float %unknown.rounding, ptr addrspace(1) undef
%normal = call float @llvm.experimental.constrained.ldexp.f32.i32(float 2.5, i32 42, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
store volatile float %normal, ptr addrspace(1) undef
%normal.down = call float @llvm.experimental.constrained.ldexp.f32.i32(float 2.5, i32 42, metadata !"round.downward", metadata !"fpexcept.ignore") #0
store volatile float %normal.down, ptr addrspace(1) undef
ret void
}
declare half @llvm.ldexp.f16.i32(half, i32) #1
declare float @llvm.ldexp.f32.i32(float, i32) #1
declare double @llvm.ldexp.f64.i32(double, i32) #1
declare <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float>, <2 x i32>) #1
declare float @llvm.experimental.constrained.ldexp.f32.i32(float, i32, metadata, metadata) #1
declare ppc_fp128 @llvm.ldexp.ppcf128.i32(ppc_fp128, i32) #1
attributes #0 = { strictfp }
attributes #1 = { nounwind readnone speculatable }
Reference in New Issue View Git Blame Copy Permalink