[FPEnv] Remove unnecessary rounding mode argument for constrained intrinsics

The following intrinsics currently carry a rounding mode metadata argument:

    llvm.experimental.constrained.minnum
    llvm.experimental.constrained.maxnum
    llvm.experimental.constrained.ceil
    llvm.experimental.constrained.floor
    llvm.experimental.constrained.round
    llvm.experimental.constrained.trunc

This is not useful since the semantics of those intrinsics do not in any way
depend on the rounding mode. In similar cases, other constrained intrinsics
do not have the rounding mode argument. Remove it here as well.

Reviewed By: craig.topper

Differential Revision: https://reviews.llvm.org/D71218
This commit is contained in:
Ulrich Weigand 2019-12-17 21:08:18 +01:00
parent 39252e1884
commit 527a7ef69a
17 changed files with 227 additions and 398 deletions

View File

@ -16478,7 +16478,6 @@ Syntax:
declare <type>
@llvm.experimental.constrained.maxnum(<type> <op1>, <type> <op2>
metadata <rounding mode>,
metadata <exception behavior>)
Overview:
@ -16493,16 +16492,12 @@ Arguments:
The first two arguments and the return value are floating-point numbers
of the same type.
The third and forth arguments specify the rounding mode and exception
behavior as described above.
The third argument specifies the exception behavior as described above.
Semantics:
""""""""""
This function follows the IEEE-754 semantics for maxNum. The rounding mode is
described, not determined, by the rounding mode argument. The actual rounding
mode is determined by the runtime floating-point environment. The rounding
mode argument is only intended as information to the compiler.
This function follows the IEEE-754 semantics for maxNum.
'``llvm.experimental.constrained.minnum``' Intrinsic
@ -16515,7 +16510,6 @@ Syntax:
declare <type>
@llvm.experimental.constrained.minnum(<type> <op1>, <type> <op2>
metadata <rounding mode>,
metadata <exception behavior>)
Overview:
@ -16530,16 +16524,12 @@ Arguments:
The first two arguments and the return value are floating-point numbers
of the same type.
The third and forth arguments specify the rounding mode and exception
behavior as described above.
The third argument specifies the exception behavior as described above.
Semantics:
""""""""""
This function follows the IEEE-754 semantics for minNum. The rounding mode is
described, not determined, by the rounding mode argument. The actual rounding
mode is determined by the runtime floating-point environment. The rounding
mode argument is only intended as information to the compiler.
This function follows the IEEE-754 semantics for minNum.
'``llvm.experimental.constrained.ceil``' Intrinsic
@ -16552,7 +16542,6 @@ Syntax:
declare <type>
@llvm.experimental.constrained.ceil(<type> <op1>,
metadata <rounding mode>,
metadata <exception behavior>)
Overview:
@ -16567,9 +16556,7 @@ Arguments:
The first argument and the return value are floating-point numbers of the same
type.
The second and third arguments specify the rounding mode and exception
behavior as described above. The rounding mode is currently unused for this
intrinsic.
The second argument specifies the exception behavior as described above.
Semantics:
""""""""""
@ -16588,7 +16575,6 @@ Syntax:
declare <type>
@llvm.experimental.constrained.floor(<type> <op1>,
metadata <rounding mode>,
metadata <exception behavior>)
Overview:
@ -16603,9 +16589,7 @@ Arguments:
The first argument and the return value are floating-point numbers of the same
type.
The second and third arguments specify the rounding mode and exception
behavior as described above. The rounding mode is currently unused for this
intrinsic.
The second argument specifies the exception behavior as described above.
Semantics:
""""""""""
@ -16624,7 +16608,6 @@ Syntax:
declare <type>
@llvm.experimental.constrained.round(<type> <op1>,
metadata <rounding mode>,
metadata <exception behavior>)
Overview:
@ -16639,9 +16622,7 @@ Arguments:
The first argument and the return value are floating-point numbers of the same
type.
The second and third arguments specify the rounding mode and exception
behavior as described above. The rounding mode is currently unused for this
intrinsic.
The second argument specifies the exception behavior as described above.
Semantics:
""""""""""
@ -16736,7 +16717,6 @@ Syntax:
declare <type>
@llvm.experimental.constrained.trunc(<type> <op1>,
metadata <truncing mode>,
metadata <exception behavior>)
Overview:
@ -16752,9 +16732,7 @@ Arguments:
The first argument and the return value are floating-point numbers of the same
type.
The second and third arguments specify the truncing mode and exception
behavior as described above. The truncing mode is currently unused for this
intrinsic.
The second argument specifies the exception behavior as described above.
Semantics:
""""""""""

View File

@ -55,11 +55,11 @@ CMP_INSTRUCTION(FCmp, 2, 0, experimental_constrained_fcmps, FSETCCS)
// Theses are definitions for intrinsic functions, that are converted into
// constrained intrinsics.
//
FUNCTION(ceil, 1, 1, experimental_constrained_ceil, FCEIL)
FUNCTION(ceil, 1, 0, experimental_constrained_ceil, FCEIL)
FUNCTION(cos, 1, 1, experimental_constrained_cos, FCOS)
FUNCTION(exp, 1, 1, experimental_constrained_exp, FEXP)
FUNCTION(exp2, 1, 1, experimental_constrained_exp2, FEXP2)
FUNCTION(floor, 1, 1, experimental_constrained_floor, FFLOOR)
FUNCTION(floor, 1, 0, experimental_constrained_floor, FFLOOR)
FUNCTION(fma, 3, 1, experimental_constrained_fma, FMA)
FUNCTION(log, 1, 1, experimental_constrained_log, FLOG)
FUNCTION(log10, 1, 1, experimental_constrained_log10, FLOG10)
@ -68,16 +68,16 @@ FUNCTION(lrint, 1, 1, experimental_constrained_lrint, LRINT)
FUNCTION(llrint, 1, 1, experimental_constrained_llrint, LLRINT)
FUNCTION(lround, 1, 0, experimental_constrained_lround, LROUND)
FUNCTION(llround, 1, 0, experimental_constrained_llround, LLROUND)
FUNCTION(maxnum, 2, 1, experimental_constrained_maxnum, FMAXNUM)
FUNCTION(minnum, 2, 1, experimental_constrained_minnum, FMINNUM)
FUNCTION(maxnum, 2, 0, experimental_constrained_maxnum, FMAXNUM)
FUNCTION(minnum, 2, 0, experimental_constrained_minnum, FMINNUM)
FUNCTION(nearbyint, 1, 1, experimental_constrained_nearbyint, FNEARBYINT)
FUNCTION(pow, 2, 1, experimental_constrained_pow, FPOW)
FUNCTION(powi, 2, 1, experimental_constrained_powi, FPOWI)
FUNCTION(rint, 1, 1, experimental_constrained_rint, FRINT)
FUNCTION(round, 1, 1, experimental_constrained_round, FROUND)
FUNCTION(round, 1, 0, experimental_constrained_round, FROUND)
FUNCTION(sin, 1, 1, experimental_constrained_sin, FSIN)
FUNCTION(sqrt, 1, 1, experimental_constrained_sqrt, FSQRT)
FUNCTION(trunc, 1, 1, experimental_constrained_trunc, FTRUNC)
FUNCTION(trunc, 1, 0, experimental_constrained_trunc, FTRUNC)
#undef INSTRUCTION
#undef FUNCTION

View File

@ -2171,21 +2171,24 @@ public:
UseFMF = FMFSource->getFastMathFlags();
CallInst *C;
bool HasRoundingMD = false;
switch (ID) {
default: {
default:
break;
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \
case Intrinsic::INTRINSIC: \
HasRoundingMD = ROUND_MODE; \
break;
#include "llvm/IR/ConstrainedOps.def"
}
if (HasRoundingMD) {
Value *RoundingV = getConstrainedFPRounding(Rounding);
C = CreateIntrinsic(ID, {DestTy, V->getType()}, {V, RoundingV, ExceptV},
nullptr, Name);
} break;
case Intrinsic::experimental_constrained_fpext:
case Intrinsic::experimental_constrained_fptoui:
case Intrinsic::experimental_constrained_fptosi:
case Intrinsic::experimental_constrained_lround:
case Intrinsic::experimental_constrained_llround:
} else
C = CreateIntrinsic(ID, {DestTy, V->getType()}, {V, ExceptV}, nullptr,
Name);
break;
}
setConstrainedFPCallAttr(C);
if (isa<FPMathOperator>(C))
@ -2402,18 +2405,18 @@ public:
for (auto *OneArg : Args)
UseArgs.push_back(OneArg);
Function *F = cast<Function>(Callee);
bool HasRoundingMD = false;
switch (F->getIntrinsicID()) {
default:
UseArgs.push_back(getConstrainedFPRounding(Rounding));
break;
case Intrinsic::experimental_constrained_fpext:
case Intrinsic::experimental_constrained_fptoui:
case Intrinsic::experimental_constrained_fptosi:
case Intrinsic::experimental_constrained_lround:
case Intrinsic::experimental_constrained_llround:
// No rounding metadata for these intrinsics.
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \
case Intrinsic::INTRINSIC: \
HasRoundingMD = ROUND_MODE; \
break;
#include "llvm/IR/ConstrainedOps.def"
}
if (HasRoundingMD)
UseArgs.push_back(getConstrainedFPRounding(Rounding));
UseArgs.push_back(getConstrainedFPExcept(Except));
CallInst *C = CreateCall(

View File

@ -724,20 +724,16 @@ let IntrProperties = [IntrInaccessibleMemOnly, IntrWillReturn] in {
def int_experimental_constrained_maxnum : Intrinsic<[ llvm_anyfloat_ty ],
[ LLVMMatchType<0>,
LLVMMatchType<0>,
llvm_metadata_ty,
llvm_metadata_ty ]>;
def int_experimental_constrained_minnum : Intrinsic<[ llvm_anyfloat_ty ],
[ LLVMMatchType<0>,
LLVMMatchType<0>,
llvm_metadata_ty,
llvm_metadata_ty ]>;
def int_experimental_constrained_ceil : Intrinsic<[ llvm_anyfloat_ty ],
[ LLVMMatchType<0>,
llvm_metadata_ty,
llvm_metadata_ty ]>;
def int_experimental_constrained_floor : Intrinsic<[ llvm_anyfloat_ty ],
[ LLVMMatchType<0>,
llvm_metadata_ty,
llvm_metadata_ty ]>;
def int_experimental_constrained_lround : Intrinsic<[ llvm_anyint_ty ],
[ llvm_anyfloat_ty,
@ -747,11 +743,9 @@ let IntrProperties = [IntrInaccessibleMemOnly, IntrWillReturn] in {
llvm_metadata_ty ]>;
def int_experimental_constrained_round : Intrinsic<[ llvm_anyfloat_ty ],
[ LLVMMatchType<0>,
llvm_metadata_ty,
llvm_metadata_ty ]>;
def int_experimental_constrained_trunc : Intrinsic<[ llvm_anyfloat_ty ],
[ LLVMMatchType<0>,
llvm_metadata_ty,
llvm_metadata_ty ]>;
// Constrained floating-point comparison (quiet and signaling variants).

View File

@ -182,7 +182,7 @@ define i32 @llrint_f32(float %x) #0 {
; CHECK-NOSP: bl fmaxf
; CHECK-SP: vmaxnm.f32
define float @maxnum_f32(float %x, float %y) #0 {
%val = call float @llvm.experimental.constrained.maxnum.f32(float %x, float %y, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
%val = call float @llvm.experimental.constrained.maxnum.f32(float %x, float %y, metadata !"fpexcept.strict") #0
ret float %val
}
@ -190,7 +190,7 @@ define float @maxnum_f32(float %x, float %y) #0 {
; CHECK-NOSP: bl fminf
; CHECK-SP: vminnm.f32
define float @minnum_f32(float %x, float %y) #0 {
%val = call float @llvm.experimental.constrained.minnum.f32(float %x, float %y, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
%val = call float @llvm.experimental.constrained.minnum.f32(float %x, float %y, metadata !"fpexcept.strict") #0
ret float %val
}
@ -198,7 +198,7 @@ define float @minnum_f32(float %x, float %y) #0 {
; CHECK-NOSP: bl ceilf
; CHECK-SP: vrintp.f32
define float @ceil_f32(float %x) #0 {
%val = call float @llvm.experimental.constrained.ceil.f32(float %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
%val = call float @llvm.experimental.constrained.ceil.f32(float %x, metadata !"fpexcept.strict") #0
ret float %val
}
@ -206,7 +206,7 @@ define float @ceil_f32(float %x) #0 {
; CHECK-NOSP: bl floorf
; CHECK-SP: vrintm.f32
define float @floor_f32(float %x) #0 {
%val = call float @llvm.experimental.constrained.floor.f32(float %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
%val = call float @llvm.experimental.constrained.floor.f32(float %x, metadata !"fpexcept.strict") #0
ret float %val
}
@ -228,7 +228,7 @@ define i32 @llround_f32(float %x) #0 {
; CHECK-NOSP: bl roundf
; CHECK-SP: vrinta.f32
define float @round_f32(float %x) #0 {
%val = call float @llvm.experimental.constrained.round.f32(float %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
%val = call float @llvm.experimental.constrained.round.f32(float %x, metadata !"fpexcept.strict") #0
ret float %val
}
@ -236,7 +236,7 @@ define float @round_f32(float %x) #0 {
; CHECK-NOSP: bl truncf
; CHECK-SP: vrintz.f32
define float @trunc_f32(float %x) #0 {
%val = call float @llvm.experimental.constrained.trunc.f32(float %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
%val = call float @llvm.experimental.constrained.trunc.f32(float %x, metadata !"fpexcept.strict") #0
ret float %val
}
@ -411,7 +411,7 @@ define i32 @llrint_f64(double %x) #0 {
; CHECK-NODP: bl fmax
; CHECK-DP: vmaxnm.f64
define double @maxnum_f64(double %x, double %y) #0 {
%val = call double @llvm.experimental.constrained.maxnum.f64(double %x, double %y, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
%val = call double @llvm.experimental.constrained.maxnum.f64(double %x, double %y, metadata !"fpexcept.strict") #0
ret double %val
}
@ -419,7 +419,7 @@ define double @maxnum_f64(double %x, double %y) #0 {
; CHECK-NODP: bl fmin
; CHECK-DP: vminnm.f64
define double @minnum_f64(double %x, double %y) #0 {
%val = call double @llvm.experimental.constrained.minnum.f64(double %x, double %y, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
%val = call double @llvm.experimental.constrained.minnum.f64(double %x, double %y, metadata !"fpexcept.strict") #0
ret double %val
}
@ -427,7 +427,7 @@ define double @minnum_f64(double %x, double %y) #0 {
; CHECK-NODP: bl ceil
; CHECK-DP: vrintp.f64
define double @ceil_f64(double %x) #0 {
%val = call double @llvm.experimental.constrained.ceil.f64(double %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
%val = call double @llvm.experimental.constrained.ceil.f64(double %x, metadata !"fpexcept.strict") #0
ret double %val
}
@ -435,7 +435,7 @@ define double @ceil_f64(double %x) #0 {
; CHECK-NODP: bl floor
; CHECK-DP: vrintm.f64
define double @floor_f64(double %x) #0 {
%val = call double @llvm.experimental.constrained.floor.f64(double %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
%val = call double @llvm.experimental.constrained.floor.f64(double %x, metadata !"fpexcept.strict") #0
ret double %val
}
@ -457,7 +457,7 @@ define i32 @llround_f64(double %x) #0 {
; CHECK-NODP: bl round
; CHECK-DP: vrinta.f64
define double @round_f64(double %x) #0 {
%val = call double @llvm.experimental.constrained.round.f64(double %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
%val = call double @llvm.experimental.constrained.round.f64(double %x, metadata !"fpexcept.strict") #0
ret double %val
}
@ -465,7 +465,7 @@ define double @round_f64(double %x) #0 {
; CHECK-NODP: bl trunc
; CHECK-DP: vrintz.f64
define double @trunc_f64(double %x) #0 {
%val = call double @llvm.experimental.constrained.trunc.f64(double %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
%val = call double @llvm.experimental.constrained.trunc.f64(double %x, metadata !"fpexcept.strict") #0
ret double %val
}
@ -513,14 +513,14 @@ declare float @llvm.experimental.constrained.rint.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.nearbyint.f32(float, metadata, metadata)
declare i32 @llvm.experimental.constrained.lrint.f32(float, metadata, metadata)
declare i32 @llvm.experimental.constrained.llrint.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata, metadata)
declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata, metadata)
declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata)
declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata)
declare float @llvm.experimental.constrained.ceil.f32(float, metadata)
declare float @llvm.experimental.constrained.floor.f32(float, metadata)
declare i32 @llvm.experimental.constrained.lround.f32(float, metadata)
declare i32 @llvm.experimental.constrained.llround.f32(float, metadata)
declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.round.f32(float, metadata)
declare float @llvm.experimental.constrained.trunc.f32(float, metadata)
declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
declare double @llvm.experimental.constrained.fsub.f64(double, double, metadata, metadata)
@ -544,14 +544,14 @@ declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadat
declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
declare i32 @llvm.experimental.constrained.lrint.f64(double, metadata, metadata)
declare i32 @llvm.experimental.constrained.llrint.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.maxnum.f64(double, double, metadata, metadata)
declare double @llvm.experimental.constrained.minnum.f64(double, double, metadata, metadata)
declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.maxnum.f64(double, double, metadata)
declare double @llvm.experimental.constrained.minnum.f64(double, double, metadata)
declare double @llvm.experimental.constrained.ceil.f64(double, metadata)
declare double @llvm.experimental.constrained.floor.f64(double, metadata)
declare i32 @llvm.experimental.constrained.lround.f64(double, metadata)
declare i32 @llvm.experimental.constrained.llround.f64(double, metadata)
declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.round.f64(double, metadata)
declare double @llvm.experimental.constrained.trunc.f64(double, metadata)
declare float @llvm.experimental.constrained.fptrunc.f32.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.fpext.f64.f32(float, metadata)

View File

@ -848,7 +848,6 @@ entry:
%maxnum = call ppc_fp128 @llvm.experimental.constrained.maxnum.ppcf128(
ppc_fp128 %first,
ppc_fp128 %second,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
ret ppc_fp128 %maxnum
}
@ -893,7 +892,6 @@ entry:
%minnum = call ppc_fp128 @llvm.experimental.constrained.minnum.ppcf128(
ppc_fp128 %first,
ppc_fp128 %second,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
ret ppc_fp128 %minnum
}
@ -937,7 +935,6 @@ define ppc_fp128 @test_ceil_ppc_fp128(ppc_fp128 %first) nounwind {
entry:
%ceil = call ppc_fp128 @llvm.experimental.constrained.ceil.ppcf128(
ppc_fp128 %first,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
ret ppc_fp128 %ceil
}
@ -981,7 +978,6 @@ define ppc_fp128 @test_floor_ppc_fp128(ppc_fp128 %first) nounwind {
entry:
%floor = call ppc_fp128 @llvm.experimental.constrained.floor.ppcf128(
ppc_fp128 %first,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
ret ppc_fp128 %floor
}
@ -1025,7 +1021,6 @@ define ppc_fp128 @test_round_ppc_fp128(ppc_fp128 %first) nounwind {
entry:
%round = call ppc_fp128 @llvm.experimental.constrained.round.ppcf128(
ppc_fp128 %first,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
ret ppc_fp128 %round
}
@ -1069,7 +1064,6 @@ define ppc_fp128 @test_trunc_ppc_fp128(ppc_fp128 %first) nounwind {
entry:
%trunc = call ppc_fp128 @llvm.experimental.constrained.trunc.ppcf128(
ppc_fp128 %first,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
ret ppc_fp128 %trunc
}
@ -1536,12 +1530,12 @@ define void @test_constrained_libcall_multichain(float* %firstptr, ppc_fp128* %r
}
declare ppc_fp128 @llvm.experimental.constrained.fadd.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.ceil.ppcf128(ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.ceil.ppcf128(ppc_fp128, metadata)
declare ppc_fp128 @llvm.experimental.constrained.cos.ppcf128(ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.fdiv.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.exp.ppcf128(ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.exp2.ppcf128(ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.floor.ppcf128(ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.floor.ppcf128(ppc_fp128, metadata)
declare ppc_fp128 @llvm.experimental.constrained.fma.ppcf128(ppc_fp128, ppc_fp128, ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.fpext.f32.ppcf128(float, metadata)
declare ppc_fp128 @llvm.experimental.constrained.fpext.f64.ppcf128(double, metadata)
@ -1550,19 +1544,19 @@ declare double @llvm.experimental.constrained.fptrunc.ppcf128.f64(ppc_fp128, met
declare ppc_fp128 @llvm.experimental.constrained.log.ppcf128(ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.log10.ppcf128(ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.log2.ppcf128(ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.maxnum.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.minnum.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.maxnum.ppcf128(ppc_fp128, ppc_fp128, metadata)
declare ppc_fp128 @llvm.experimental.constrained.minnum.ppcf128(ppc_fp128, ppc_fp128, metadata)
declare ppc_fp128 @llvm.experimental.constrained.fmul.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.nearbyint.ppcf128(ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.pow.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.powi.ppcf128(ppc_fp128, i32, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.frem.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.rint.ppcf128(ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.round.ppcf128(ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.round.ppcf128(ppc_fp128, metadata)
declare ppc_fp128 @llvm.experimental.constrained.sin.ppcf128(ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.sqrt.ppcf128(ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.fsub.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.trunc.ppcf128(ppc_fp128, metadata, metadata)
declare ppc_fp128 @llvm.experimental.constrained.trunc.ppcf128(ppc_fp128, metadata)
declare i64 @llvm.experimental.constrained.fptosi.i64.ppcf128(ppc_fp128, metadata)
declare i32 @llvm.experimental.constrained.fptosi.i32.ppcf128(ppc_fp128, metadata)
declare i64 @llvm.experimental.constrained.fptoui.i64.ppcf128(ppc_fp128, metadata)

View File

@ -5490,7 +5490,6 @@ define <1 x float> @constrained_vector_maxnum_v1f32() #0 {
entry:
%max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32(
<1 x float> <float 42.0>, <1 x float> <float 41.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <1 x float> %max
}
@ -5555,7 +5554,6 @@ entry:
%max = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64(
<2 x double> <double 43.0, double 42.0>,
<2 x double> <double 41.0, double 40.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <2 x double> %max
}
@ -5658,7 +5656,6 @@ entry:
%max = call <3 x float> @llvm.experimental.constrained.maxnum.v3f32(
<3 x float> <float 43.0, float 44.0, float 45.0>,
<3 x float> <float 41.0, float 42.0, float 43.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <3 x float> %max
}
@ -5749,7 +5746,6 @@ entry:
%max = call <3 x double> @llvm.experimental.constrained.maxnum.v3f64(
<3 x double> <double 43.0, double 44.0, double 45.0>,
<3 x double> <double 40.0, double 41.0, double 42.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <3 x double> %max
}
@ -5860,7 +5856,6 @@ entry:
double 46.0, double 47.0>,
<4 x double> <double 40.0, double 41.0,
double 42.0, double 43.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <4 x double> %max
}
@ -5904,7 +5899,6 @@ define <1 x float> @constrained_vector_minnum_v1f32() #0 {
entry:
%min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32(
<1 x float> <float 42.0>, <1 x float> <float 41.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <1 x float> %min
}
@ -5969,7 +5963,6 @@ entry:
%min = call <2 x double> @llvm.experimental.constrained.minnum.v2f64(
<2 x double> <double 43.0, double 42.0>,
<2 x double> <double 41.0, double 40.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <2 x double> %min
}
@ -6072,7 +6065,6 @@ entry:
%min = call <3 x float> @llvm.experimental.constrained.minnum.v3f32(
<3 x float> <float 43.0, float 44.0, float 45.0>,
<3 x float> <float 41.0, float 42.0, float 43.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <3 x float> %min
}
@ -6163,7 +6155,6 @@ entry:
%min = call <3 x double> @llvm.experimental.constrained.minnum.v3f64(
<3 x double> <double 43.0, double 44.0, double 45.0>,
<3 x double> <double 40.0, double 41.0, double 42.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <3 x double> %min
}
@ -6274,7 +6265,6 @@ entry:
double 46.0, double 47.0>,
<4 x double> <double 40.0, double 41.0,
double 42.0, double 43.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <4 x double> %min
}
@ -6574,7 +6564,6 @@ define <1 x float> @constrained_vector_ceil_v1f32() #0 {
entry:
%ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <1 x float> %ceil
}
@ -6599,7 +6588,6 @@ define <2 x double> @constrained_vector_ceil_v2f64() #0 {
entry:
%ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <2 x double> %ceil
}
@ -6655,7 +6643,6 @@ define <3 x float> @constrained_vector_ceil_v3f32() #0 {
entry:
%ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <3 x float> %ceil
}
@ -6692,7 +6679,6 @@ define <3 x double> @constrained_vector_ceil_v3f64() #0 {
entry:
%ceil = call <3 x double> @llvm.experimental.constrained.ceil.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <3 x double> %ceil
}
@ -6718,7 +6704,6 @@ define <1 x float> @constrained_vector_floor_v1f32() #0 {
entry:
%floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <1 x float> %floor
}
@ -6744,7 +6729,6 @@ define <2 x double> @constrained_vector_floor_v2f64() #0 {
entry:
%floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <2 x double> %floor
}
@ -6800,7 +6784,6 @@ define <3 x float> @constrained_vector_floor_v3f32() #0 {
entry:
%floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <3 x float> %floor
}
@ -6837,7 +6820,6 @@ define <3 x double> @constrained_vector_floor_v3f64() #0 {
entry:
%floor = call <3 x double> @llvm.experimental.constrained.floor.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <3 x double> %floor
}
@ -6863,7 +6845,6 @@ define <1 x float> @constrained_vector_round_v1f32() #0 {
entry:
%round = call <1 x float> @llvm.experimental.constrained.round.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <1 x float> %round
}
@ -6888,7 +6869,6 @@ define <2 x double> @constrained_vector_round_v2f64() #0 {
entry:
%round = call <2 x double> @llvm.experimental.constrained.round.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <2 x double> %round
}
@ -6944,7 +6924,6 @@ define <3 x float> @constrained_vector_round_v3f32() #0 {
entry:
%round = call <3 x float> @llvm.experimental.constrained.round.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <3 x float> %round
}
@ -6982,7 +6961,6 @@ define <3 x double> @constrained_vector_round_v3f64() #0 {
entry:
%round = call <3 x double> @llvm.experimental.constrained.round.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <3 x double> %round
}
@ -7008,7 +6986,6 @@ define <1 x float> @constrained_vector_trunc_v1f32() #0 {
entry:
%trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <1 x float> %trunc
}
@ -7033,7 +7010,6 @@ define <2 x double> @constrained_vector_trunc_v2f64() #0 {
entry:
%trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <2 x double> %trunc
}
@ -7089,7 +7065,6 @@ define <3 x float> @constrained_vector_trunc_v3f32() #0 {
entry:
%trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <3 x float> %trunc
}
@ -7126,7 +7101,6 @@ define <3 x double> @constrained_vector_trunc_v3f64() #0 {
entry:
%trunc = call <3 x double> @llvm.experimental.constrained.trunc.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #1
ret <3 x double> %trunc
}
@ -7152,14 +7126,14 @@ declare <2 x double> @llvm.experimental.constrained.log10.v2f64(<2 x double>, me
declare <2 x double> @llvm.experimental.constrained.log2.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.rint.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata)
declare <2 x float> @llvm.experimental.constrained.fptrunc.v2f32.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.fpext.v2f64.v2f32(<2 x float>, metadata)
declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata)
; Scalar width declarations
declare <1 x float> @llvm.experimental.constrained.fadd.v1f32(<1 x float>, <1 x float>, metadata, metadata)
@ -7179,14 +7153,14 @@ declare <1 x float> @llvm.experimental.constrained.log10.v1f32(<1 x float>, meta
declare <1 x float> @llvm.experimental.constrained.log2.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.rint.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.nearbyint.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.maxnum.v1f32(<1 x float>, <1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.minnum.v1f32(<1 x float>, <1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.maxnum.v1f32(<1 x float>, <1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.minnum.v1f32(<1 x float>, <1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.fptrunc.v1f32.v1f64(<1 x double>, metadata, metadata)
declare <1 x double> @llvm.experimental.constrained.fpext.v1f64.v1f32(<1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.ceil.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.floor.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.round.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.trunc.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.ceil.v1f32(<1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.floor.v1f32(<1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.round.v1f32(<1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.trunc.v1f32(<1 x float>, metadata)
; Illegal width declarations
declare <3 x float> @llvm.experimental.constrained.fadd.v3f32(<3 x float>, <3 x float>, metadata, metadata)
@ -7223,20 +7197,20 @@ declare <3 x float> @llvm.experimental.constrained.rint.v3f32(<3 x float>, metad
declare <3 x double> @llvm.experimental.constrained.rint.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.nearbyint.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.nearbyint.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.maxnum.v3f32(<3 x float>, <3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.maxnum.v3f64(<3 x double>, <3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.minnum.v3f32(<3 x float>, <3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.minnum.v3f64(<3 x double>, <3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.maxnum.v3f32(<3 x float>, <3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.maxnum.v3f64(<3 x double>, <3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.minnum.v3f32(<3 x float>, <3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.minnum.v3f64(<3 x double>, <3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.fptrunc.v3f32.v3f64(<3 x double>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.fpext.v3f64.v3f32(<3 x float>, metadata)
declare <3 x float> @llvm.experimental.constrained.ceil.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.ceil.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.floor.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.floor.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.round.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.round.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.trunc.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.trunc.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.ceil.v3f32(<3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.ceil.v3f64(<3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.floor.v3f32(<3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.floor.v3f64(<3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.round.v3f32(<3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.round.v3f64(<3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.trunc.v3f32(<3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.trunc.v3f64(<3 x double>, metadata)
; Double width declarations
declare <4 x double> @llvm.experimental.constrained.fadd.v4f64(<4 x double>, <4 x double>, metadata, metadata)
@ -7256,11 +7230,11 @@ declare <4 x double> @llvm.experimental.constrained.log10.v4f64(<4 x double>, me
declare <4 x double> @llvm.experimental.constrained.log2.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.rint.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.nearbyint.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.maxnum.v4f64(<4 x double>, <4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.minnum.v4f64(<4 x double>, <4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.maxnum.v4f64(<4 x double>, <4 x double>, metadata)
declare <4 x double> @llvm.experimental.constrained.minnum.v4f64(<4 x double>, <4 x double>, metadata)
declare <4 x float> @llvm.experimental.constrained.fptrunc.v4f32.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.fpext.v4f64.v4f32(<4 x float>, metadata)
declare <4 x double> @llvm.experimental.constrained.ceil.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.floor.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.round.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.trunc.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.ceil.v4f64(<4 x double>, metadata)
declare <4 x double> @llvm.experimental.constrained.floor.v4f64(<4 x double>, metadata)
declare <4 x double> @llvm.experimental.constrained.round.v4f64(<4 x double>, metadata)
declare <4 x double> @llvm.experimental.constrained.trunc.v4f64(<4 x double>, metadata)

View File

@ -85,33 +85,31 @@ define void @f6(fp128 *%ptr) #0 {
}
; Test floor for f32.
declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.floor.f32(float, metadata)
define float @f7(float %f) #0 {
; CHECK-LABEL: f7:
; CHECK: brasl %r14, floorf@PLT
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.floor.f32(
float %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
; Test floor for f64.
declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.floor.f64(double, metadata)
define double @f8(double %f) #0 {
; CHECK-LABEL: f8:
; CHECK: brasl %r14, floor@PLT
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.floor.f64(
double %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
; Test floor for f128.
declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata)
define void @f9(fp128 *%ptr) #0 {
; CHECK-LABEL: f9:
; CHECK: brasl %r14, floorl@PLT
@ -119,40 +117,37 @@ define void @f9(fp128 *%ptr) #0 {
%src = load fp128, fp128 *%ptr
%res = call fp128 @llvm.experimental.constrained.floor.f128(
fp128 %src,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test ceil for f32.
declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.ceil.f32(float, metadata)
define float @f10(float %f) #0 {
; CHECK-LABEL: f10:
; CHECK: brasl %r14, ceilf@PLT
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.ceil.f32(
float %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
; Test ceil for f64.
declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.ceil.f64(double, metadata)
define double @f11(double %f) #0 {
; CHECK-LABEL: f11:
; CHECK: brasl %r14, ceil@PLT
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.ceil.f64(
double %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
; Test ceil for f128.
declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata)
define void @f12(fp128 *%ptr) #0 {
; CHECK-LABEL: f12:
; CHECK: brasl %r14, ceill@PLT
@ -160,40 +155,37 @@ define void @f12(fp128 *%ptr) #0 {
%src = load fp128, fp128 *%ptr
%res = call fp128 @llvm.experimental.constrained.ceil.f128(
fp128 %src,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test trunc for f32.
declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.trunc.f32(float, metadata)
define float @f13(float %f) #0 {
; CHECK-LABEL: f13:
; CHECK: brasl %r14, truncf@PLT
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.trunc.f32(
float %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
; Test trunc for f64.
declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.trunc.f64(double, metadata)
define double @f14(double %f) #0 {
; CHECK-LABEL: f14:
; CHECK: brasl %r14, trunc@PLT
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.trunc.f64(
double %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
; Test trunc for f128.
declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata)
define void @f15(fp128 *%ptr) #0 {
; CHECK-LABEL: f15:
; CHECK: brasl %r14, truncl@PLT
@ -201,40 +193,37 @@ define void @f15(fp128 *%ptr) #0 {
%src = load fp128, fp128 *%ptr
%res = call fp128 @llvm.experimental.constrained.trunc.f128(
fp128 %src,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test round for f32.
declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.round.f32(float, metadata)
define float @f16(float %f) #0 {
; CHECK-LABEL: f16:
; CHECK: brasl %r14, roundf@PLT
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.round.f32(
float %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
; Test round for f64.
declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.round.f64(double, metadata)
define double @f17(double %f) #0 {
; CHECK-LABEL: f17:
; CHECK: brasl %r14, round@PLT
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.round.f64(
double %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
; Test round for f128.
declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata)
define void @f18(fp128 *%ptr) #0 {
; CHECK-LABEL: f18:
; CHECK: brasl %r14, roundl@PLT
@ -242,7 +231,6 @@ define void @f18(fp128 *%ptr) #0 {
%src = load fp128, fp128 *%ptr
%res = call fp128 @llvm.experimental.constrained.round.f128(
fp128 %src,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void

View File

@ -89,33 +89,31 @@ define void @f6(fp128 *%ptr) #0 {
}
; Test floor for f32.
declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.floor.f32(float, metadata)
define float @f7(float %f) #0 {
; CHECK-LABEL: f7:
; CHECK: fiebra %f0, 7, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.floor.f32(
float %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
; Test floor for f64.
declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.floor.f64(double, metadata)
define double @f8(double %f) #0 {
; CHECK-LABEL: f8:
; CHECK: fidbra %f0, 7, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.floor.f64(
double %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
; Test floor for f128.
declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata)
define void @f9(fp128 *%ptr) #0 {
; CHECK-LABEL: f9:
; CHECK: fixbra %f0, 7, %f0, 4
@ -123,40 +121,37 @@ define void @f9(fp128 *%ptr) #0 {
%src = load fp128, fp128 *%ptr
%res = call fp128 @llvm.experimental.constrained.floor.f128(
fp128 %src,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test ceil for f32.
declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.ceil.f32(float, metadata)
define float @f10(float %f) #0 {
; CHECK-LABEL: f10:
; CHECK: fiebra %f0, 6, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.ceil.f32(
float %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
; Test ceil for f64.
declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.ceil.f64(double, metadata)
define double @f11(double %f) #0 {
; CHECK-LABEL: f11:
; CHECK: fidbra %f0, 6, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.ceil.f64(
double %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
; Test ceil for f128.
declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata)
define void @f12(fp128 *%ptr) #0 {
; CHECK-LABEL: f12:
; CHECK: fixbra %f0, 6, %f0, 4
@ -164,40 +159,37 @@ define void @f12(fp128 *%ptr) #0 {
%src = load fp128, fp128 *%ptr
%res = call fp128 @llvm.experimental.constrained.ceil.f128(
fp128 %src,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test trunc for f32.
declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.trunc.f32(float, metadata)
define float @f13(float %f) #0 {
; CHECK-LABEL: f13:
; CHECK: fiebra %f0, 5, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.trunc.f32(
float %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
; Test trunc for f64.
declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.trunc.f64(double, metadata)
define double @f14(double %f) #0 {
; CHECK-LABEL: f14:
; CHECK: fidbra %f0, 5, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.trunc.f64(
double %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
; Test trunc for f128.
declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata)
define void @f15(fp128 *%ptr) #0 {
; CHECK-LABEL: f15:
; CHECK: fixbra %f0, 5, %f0, 4
@ -205,40 +197,37 @@ define void @f15(fp128 *%ptr) #0 {
%src = load fp128, fp128 *%ptr
%res = call fp128 @llvm.experimental.constrained.trunc.f128(
fp128 %src,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test round for f32.
declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.round.f32(float, metadata)
define float @f16(float %f) #0 {
; CHECK-LABEL: f16:
; CHECK: fiebra %f0, 1, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.round.f32(
float %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
; Test round for f64.
declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.round.f64(double, metadata)
define double @f17(double %f) #0 {
; CHECK-LABEL: f17:
; CHECK: fidbra %f0, 1, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.round.f64(
double %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
; Test round for f128.
declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata)
define void @f18(fp128 *%ptr) #0 {
; CHECK-LABEL: f18:
; CHECK: fixbra %f0, 1, %f0, 4
@ -246,7 +235,6 @@ define void @f18(fp128 *%ptr) #0 {
%src = load fp128, fp128 *%ptr
%res = call fp128 @llvm.experimental.constrained.round.f128(
fp128 %src,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void

View File

@ -89,33 +89,31 @@ define void @f6(fp128 *%ptr) #0 {
}
; Test floor for f32.
declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.floor.f32(float, metadata)
define float @f7(float %f) #0 {
; CHECK-LABEL: f7:
; CHECK: fiebra %f0, 7, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.floor.f32(
float %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
; Test floor for f64.
declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.floor.f64(double, metadata)
define double @f8(double %f) #0 {
; CHECK-LABEL: f8:
; CHECK: fidbra %f0, 7, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.floor.f64(
double %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
; Test floor for f128.
declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata)
define void @f9(fp128 *%ptr) #0 {
; CHECK-LABEL: f9:
; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
@ -125,40 +123,37 @@ define void @f9(fp128 *%ptr) #0 {
%src = load fp128, fp128 *%ptr
%res = call fp128 @llvm.experimental.constrained.floor.f128(
fp128 %src,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test ceil for f32.
declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.ceil.f32(float, metadata)
define float @f10(float %f) #0 {
; CHECK-LABEL: f10:
; CHECK: fiebra %f0, 6, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.ceil.f32(
float %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
; Test ceil for f64.
declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.ceil.f64(double, metadata)
define double @f11(double %f) #0 {
; CHECK-LABEL: f11:
; CHECK: fidbra %f0, 6, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.ceil.f64(
double %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
; Test ceil for f128.
declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata)
define void @f12(fp128 *%ptr) #0 {
; CHECK-LABEL: f12:
; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
@ -168,40 +163,37 @@ define void @f12(fp128 *%ptr) #0 {
%src = load fp128, fp128 *%ptr
%res = call fp128 @llvm.experimental.constrained.ceil.f128(
fp128 %src,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test trunc for f32.
declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.trunc.f32(float, metadata)
define float @f13(float %f) #0 {
; CHECK-LABEL: f13:
; CHECK: fiebra %f0, 5, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.trunc.f32(
float %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
; Test trunc for f64.
declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.trunc.f64(double, metadata)
define double @f14(double %f) #0 {
; CHECK-LABEL: f14:
; CHECK: fidbra %f0, 5, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.trunc.f64(
double %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
; Test trunc for f128.
declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata)
define void @f15(fp128 *%ptr) #0 {
; CHECK-LABEL: f15:
; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
@ -211,40 +203,37 @@ define void @f15(fp128 *%ptr) #0 {
%src = load fp128, fp128 *%ptr
%res = call fp128 @llvm.experimental.constrained.trunc.f128(
fp128 %src,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test round for f32.
declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.round.f32(float, metadata)
define float @f16(float %f) #0 {
; CHECK-LABEL: f16:
; CHECK: fiebra %f0, 1, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.round.f32(
float %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
; Test round for f64.
declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.round.f64(double, metadata)
define double @f17(double %f) #0 {
; CHECK-LABEL: f17:
; CHECK: fidbra %f0, 1, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.round.f64(
double %f,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
; Test round for f128.
declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata)
define void @f18(fp128 *%ptr) #0 {
; CHECK-LABEL: f18:
; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
@ -254,7 +243,6 @@ define void @f18(fp128 *%ptr) #0 {
%src = load fp128, fp128 *%ptr
%res = call fp128 @llvm.experimental.constrained.round.f128(
fp128 %src,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void

View File

@ -2,13 +2,13 @@
;
; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z14 | FileCheck %s
declare double @llvm.experimental.constrained.maxnum.f64(double, double, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
declare double @llvm.experimental.constrained.maxnum.f64(double, double, metadata)
declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata)
declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata, metadata)
declare <4 x float> @llvm.experimental.constrained.maxnum.v4f32(<4 x float>, <4 x float>, metadata, metadata)
declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata)
declare <4 x float> @llvm.experimental.constrained.maxnum.v4f32(<4 x float>, <4 x float>, metadata)
declare fp128 @llvm.experimental.constrained.maxnum.f128(fp128, fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.maxnum.f128(fp128, fp128, metadata)
; Test the f64 maxnum intrinsic.
define double @f1(double %dummy, double %val1, double %val2) #0 {
@ -17,7 +17,6 @@ define double @f1(double %dummy, double %val1, double %val2) #0 {
; CHECK: br %r14
%ret = call double @llvm.experimental.constrained.maxnum.f64(
double %val1, double %val2,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %ret
}
@ -30,7 +29,6 @@ define <2 x double> @f2(<2 x double> %dummy, <2 x double> %val1,
; CHECK: br %r14
%ret = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64(
<2 x double> %val1, <2 x double> %val2,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %ret
}
@ -42,7 +40,6 @@ define float @f3(float %dummy, float %val1, float %val2) #0 {
; CHECK: br %r14
%ret = call float @llvm.experimental.constrained.maxnum.f32(
float %val1, float %val2,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %ret
}
@ -55,7 +52,6 @@ define <4 x float> @f4(<4 x float> %dummy, <4 x float> %val1,
; CHECK: br %r14
%ret = call <4 x float> @llvm.experimental.constrained.maxnum.v4f32(
<4 x float> %val1, <4 x float> %val2,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <4 x float> %ret
}
@ -72,7 +68,6 @@ define void @f5(fp128 *%ptr1, fp128 *%ptr2, fp128 *%dst) #0 {
%val2 = load fp128, fp128* %ptr2
%res = call fp128 @llvm.experimental.constrained.maxnum.f128(
fp128 %val1, fp128 %val2,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store fp128 %res, fp128* %dst
ret void

View File

@ -2,13 +2,13 @@
;
; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z14 | FileCheck %s
declare double @llvm.experimental.constrained.minnum.f64(double, double, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
declare double @llvm.experimental.constrained.minnum.f64(double, double, metadata)
declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata)
declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata, metadata)
declare <4 x float> @llvm.experimental.constrained.minnum.v4f32(<4 x float>, <4 x float>, metadata, metadata)
declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata)
declare <4 x float> @llvm.experimental.constrained.minnum.v4f32(<4 x float>, <4 x float>, metadata)
declare fp128 @llvm.experimental.constrained.minnum.f128(fp128, fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.minnum.f128(fp128, fp128, metadata)
; Test the f64 minnum intrinsic.
define double @f1(double %dummy, double %val1, double %val2) #0 {
@ -17,7 +17,6 @@ define double @f1(double %dummy, double %val1, double %val2) #0 {
; CHECK: br %r14
%ret = call double @llvm.experimental.constrained.minnum.f64(
double %val1, double %val2,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %ret
}
@ -30,7 +29,6 @@ define <2 x double> @f2(<2 x double> %dummy, <2 x double> %val1,
; CHECK: br %r14
%ret = call <2 x double> @llvm.experimental.constrained.minnum.v2f64(
<2 x double> %val1, <2 x double> %val2,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %ret
}
@ -42,7 +40,6 @@ define float @f3(float %dummy, float %val1, float %val2) #0 {
; CHECK: br %r14
%ret = call float @llvm.experimental.constrained.minnum.f32(
float %val1, float %val2,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %ret
}
@ -55,7 +52,6 @@ define <4 x float> @f4(<4 x float> %dummy, <4 x float> %val1,
; CHECK: br %r14
%ret = call <4 x float> @llvm.experimental.constrained.minnum.v4f32(
<4 x float> %val1, <4 x float> %val2,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <4 x float> %ret
}
@ -72,7 +68,6 @@ define void @f5(fp128 *%ptr1, fp128 *%ptr2, fp128 *%dst) #0 {
%val2 = load fp128, fp128* %ptr2
%res = call fp128 @llvm.experimental.constrained.minnum.f128(
fp128 %val1, fp128 %val2,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store fp128 %res, fp128* %dst
ret void

View File

@ -4,16 +4,16 @@
declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.floor.f64(double, metadata)
declare double @llvm.experimental.constrained.ceil.f64(double, metadata)
declare double @llvm.experimental.constrained.trunc.f64(double, metadata)
declare double @llvm.experimental.constrained.round.f64(double, metadata)
declare <2 x double> @llvm.experimental.constrained.rint.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata)
define <2 x double> @f1(<2 x double> %val) #0 {
; CHECK-LABEL: f1:
@ -43,7 +43,6 @@ define <2 x double> @f3(<2 x double> %val) #0 {
; CHECK: br %r14
%res = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
<2 x double> %val,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
@ -54,7 +53,6 @@ define <2 x double> @f4(<2 x double> %val) #0 {
; CHECK: br %r14
%res = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
<2 x double> %val,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
@ -65,7 +63,6 @@ define <2 x double> @f5(<2 x double> %val) #0 {
; CHECK: br %r14
%res = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
<2 x double> %val,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
@ -76,7 +73,6 @@ define <2 x double> @f6(<2 x double> %val) #0 {
; CHECK: br %r14
%res = call <2 x double> @llvm.experimental.constrained.round.v2f64(
<2 x double> %val,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
@ -112,7 +108,6 @@ define double @f9(<2 x double> %val) #0 {
%scalar = extractelement <2 x double> %val, i32 0
%res = call double @llvm.experimental.constrained.floor.f64(
double %scalar,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
@ -125,7 +120,6 @@ define double @f10(<2 x double> %val) #0 {
%scalar = extractelement <2 x double> %val, i32 0
%res = call double @llvm.experimental.constrained.ceil.f64(
double %scalar,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
@ -137,7 +131,6 @@ define double @f11(<2 x double> %val) #0 {
%scalar = extractelement <2 x double> %val, i32 0
%res = call double @llvm.experimental.constrained.trunc.f64(
double %scalar,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}
@ -149,7 +142,6 @@ define double @f12(<2 x double> %val) #0 {
%scalar = extractelement <2 x double> %val, i32 0
%res = call double @llvm.experimental.constrained.round.f64(
double %scalar,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret double %res
}

View File

@ -4,16 +4,16 @@
declare float @llvm.experimental.constrained.rint.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.nearbyint.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
declare float @llvm.experimental.constrained.floor.f32(float, metadata)
declare float @llvm.experimental.constrained.ceil.f32(float, metadata)
declare float @llvm.experimental.constrained.trunc.f32(float, metadata)
declare float @llvm.experimental.constrained.round.f32(float, metadata)
declare <4 x float> @llvm.experimental.constrained.rint.v4f32(<4 x float>, metadata, metadata)
declare <4 x float> @llvm.experimental.constrained.nearbyint.v4f32(<4 x float>, metadata, metadata)
declare <4 x float> @llvm.experimental.constrained.floor.v4f32(<4 x float>, metadata, metadata)
declare <4 x float> @llvm.experimental.constrained.ceil.v4f32(<4 x float>, metadata, metadata)
declare <4 x float> @llvm.experimental.constrained.trunc.v4f32(<4 x float>, metadata, metadata)
declare <4 x float> @llvm.experimental.constrained.round.v4f32(<4 x float>, metadata, metadata)
declare <4 x float> @llvm.experimental.constrained.floor.v4f32(<4 x float>, metadata)
declare <4 x float> @llvm.experimental.constrained.ceil.v4f32(<4 x float>, metadata)
declare <4 x float> @llvm.experimental.constrained.trunc.v4f32(<4 x float>, metadata)
declare <4 x float> @llvm.experimental.constrained.round.v4f32(<4 x float>, metadata)
define <4 x float> @f1(<4 x float> %val) #0 {
; CHECK-LABEL: f1:
@ -43,7 +43,6 @@ define <4 x float> @f3(<4 x float> %val) #0 {
; CHECK: br %r14
%res = call <4 x float> @llvm.experimental.constrained.floor.v4f32(
<4 x float> %val,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
@ -54,7 +53,6 @@ define <4 x float> @f4(<4 x float> %val) #0 {
; CHECK: br %r14
%res = call <4 x float> @llvm.experimental.constrained.ceil.v4f32(
<4 x float> %val,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
@ -65,7 +63,6 @@ define <4 x float> @f5(<4 x float> %val) #0 {
; CHECK: br %r14
%res = call <4 x float> @llvm.experimental.constrained.trunc.v4f32(
<4 x float> %val,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
@ -76,7 +73,6 @@ define <4 x float> @f6(<4 x float> %val) #0 {
; CHECK: br %r14
%res = call <4 x float> @llvm.experimental.constrained.round.v4f32(
<4 x float> %val,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
@ -112,7 +108,6 @@ define float @f9(<4 x float> %val) #0 {
%scalar = extractelement <4 x float> %val, i32 0
%res = call float @llvm.experimental.constrained.floor.f32(
float %scalar,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
@ -124,7 +119,6 @@ define float @f10(<4 x float> %val) #0 {
%scalar = extractelement <4 x float> %val, i32 0
%res = call float @llvm.experimental.constrained.ceil.f32(
float %scalar,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
@ -136,7 +130,6 @@ define float @f11(<4 x float> %val) #0 {
%scalar = extractelement <4 x float> %val, i32 0
%res = call float @llvm.experimental.constrained.trunc.f32(
float %scalar,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}
@ -148,7 +141,6 @@ define float @f12(<4 x float> %val) #0 {
%scalar = extractelement <4 x float> %val, i32 0
%res = call float @llvm.experimental.constrained.round.f32(
float %scalar,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret float %res
}

View File

@ -4619,7 +4619,6 @@ define <1 x float> @constrained_vector_maxnum_v1f32() #0 {
entry:
%max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32(
<1 x float> <float 42.0>, <1 x float> <float 41.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <1 x float> %max
}
@ -4680,7 +4679,6 @@ entry:
%max = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64(
<2 x double> <double 43.0, double 42.0>,
<2 x double> <double 41.0, double 40.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %max
}
@ -4768,7 +4766,6 @@ entry:
%max = call <3 x float> @llvm.experimental.constrained.maxnum.v3f32(
<3 x float> <float 43.0, float 44.0, float 45.0>,
<3 x float> <float 41.0, float 42.0, float 43.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x float> %max
}
@ -4859,7 +4856,6 @@ entry:
%max = call <3 x double> @llvm.experimental.constrained.maxnum.v3f64(
<3 x double> %b,
<3 x double> <double 40.0, double 41.0, double 42.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store <3 x double> %max, <3 x double>* %a
ret void
@ -4962,7 +4958,6 @@ entry:
double 46.0, double 47.0>,
<4 x double> <double 40.0, double 41.0,
double 42.0, double 43.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <4 x double> %max
}
@ -5002,7 +4997,6 @@ define <1 x float> @constrained_vector_minnum_v1f32() #0 {
entry:
%min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32(
<1 x float> <float 42.0>, <1 x float> <float 41.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <1 x float> %min
}
@ -5063,7 +5057,6 @@ entry:
%min = call <2 x double> @llvm.experimental.constrained.minnum.v2f64(
<2 x double> <double 43.0, double 42.0>,
<2 x double> <double 41.0, double 40.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %min
}
@ -5151,7 +5144,6 @@ entry:
%min = call <3 x float> @llvm.experimental.constrained.minnum.v3f32(
<3 x float> <float 43.0, float 44.0, float 45.0>,
<3 x float> <float 41.0, float 42.0, float 43.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x float> %min
}
@ -5246,7 +5238,6 @@ entry:
%min = call <3 x double> @llvm.experimental.constrained.minnum.v3f64(
<3 x double> %b,
<3 x double> <double 3.0, double 3.0, double 3.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store <3 x double> %min, <3 x double>* %a
ret void
@ -5349,7 +5340,6 @@ entry:
double 46.0, double 47.0>,
<4 x double> <double 40.0, double 41.0,
double 42.0, double 43.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <4 x double> %min
}
@ -5629,7 +5619,6 @@ define <1 x float> @constrained_vector_ceil_v1f32() #0 {
entry:
%ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <1 x float> %ceil
}
@ -5667,7 +5656,6 @@ define <2 x double> @constrained_vector_ceil_v2f64() #0 {
entry:
%ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %ceil
}
@ -5722,7 +5710,6 @@ define <3 x float> @constrained_vector_ceil_v3f32() #0 {
entry:
%ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x float> %ceil
}
@ -5775,7 +5762,6 @@ entry:
%b = load <3 x double>, <3 x double>* %a
%ceil = call <3 x double> @llvm.experimental.constrained.ceil.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store <3 x double> %ceil, <3 x double>* %a
ret void
@ -5804,7 +5790,6 @@ define <1 x float> @constrained_vector_floor_v1f32() #0 {
entry:
%floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <1 x float> %floor
}
@ -5843,7 +5828,6 @@ define <2 x double> @constrained_vector_floor_v2f64() #0 {
entry:
%floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %floor
}
@ -5898,7 +5882,6 @@ define <3 x float> @constrained_vector_floor_v3f32() #0 {
entry:
%floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x float> %floor
}
@ -5951,7 +5934,6 @@ entry:
%b = load <3 x double>, <3 x double>* %a
%floor = call <3 x double> @llvm.experimental.constrained.floor.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store <3 x double> %floor, <3 x double>* %a
ret void
@ -5980,7 +5962,6 @@ define <1 x float> @constrained_vector_round_v1f32() #0 {
entry:
%round = call <1 x float> @llvm.experimental.constrained.round.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <1 x float> %round
}
@ -6018,7 +5999,6 @@ define <2 x double> @constrained_vector_round_v2f64() #0 {
entry:
%round = call <2 x double> @llvm.experimental.constrained.round.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %round
}
@ -6073,7 +6053,6 @@ define <3 x float> @constrained_vector_round_v3f32() #0 {
entry:
%round = call <3 x float> @llvm.experimental.constrained.round.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x float> %round
}
@ -6127,7 +6106,6 @@ entry:
%b = load <3 x double>, <3 x double>* %a
%round = call <3 x double> @llvm.experimental.constrained.round.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store <3 x double> %round, <3 x double>* %a
ret void
@ -6156,7 +6134,6 @@ define <1 x float> @constrained_vector_trunc_v1f32() #0 {
entry:
%trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <1 x float> %trunc
}
@ -6194,7 +6171,6 @@ define <2 x double> @constrained_vector_trunc_v2f64() #0 {
entry:
%trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %trunc
}
@ -6249,7 +6225,6 @@ define <3 x float> @constrained_vector_trunc_v3f32() #0 {
entry:
%trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x float> %trunc
}
@ -6302,7 +6277,6 @@ entry:
%b = load <3 x double>, <3 x double>* %a
%trunc = call <3 x double> @llvm.experimental.constrained.trunc.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
store <3 x double> %trunc, <3 x double>* %a
ret void
@ -6327,14 +6301,14 @@ declare <2 x double> @llvm.experimental.constrained.log10.v2f64(<2 x double>, me
declare <2 x double> @llvm.experimental.constrained.log2.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.rint.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata)
declare <2 x float> @llvm.experimental.constrained.fptrunc.v2f32.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.fpext.v2f64.v2f32(<2 x float>, metadata)
declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata)
declare <1 x float> @llvm.experimental.constrained.fadd.v1f32(<1 x float>, <1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.fsub.v1f32(<1 x float>, <1 x float>, metadata, metadata)
@ -6353,14 +6327,14 @@ declare <1 x float> @llvm.experimental.constrained.log10.v1f32(<1 x float>, meta
declare <1 x float> @llvm.experimental.constrained.log2.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.rint.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.nearbyint.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.maxnum.v1f32(<1 x float>, <1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.minnum.v1f32(<1 x float>, <1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.maxnum.v1f32(<1 x float>, <1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.minnum.v1f32(<1 x float>, <1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.fptrunc.v1f32.v1f64(<1 x double>, metadata, metadata)
declare <1 x double> @llvm.experimental.constrained.fpext.v1f64.v1f32(<1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.ceil.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.floor.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.round.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.trunc.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.ceil.v1f32(<1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.floor.v1f32(<1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.round.v1f32(<1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.trunc.v1f32(<1 x float>, metadata)
declare <3 x float> @llvm.experimental.constrained.fadd.v3f32(<3 x float>, <3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.fadd.v3f64(<3 x double>, <3 x double>, metadata, metadata)
@ -6396,20 +6370,20 @@ declare <3 x float> @llvm.experimental.constrained.rint.v3f32(<3 x float>, metad
declare <3 x double> @llvm.experimental.constrained.rint.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.nearbyint.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.nearbyint.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.maxnum.v3f32(<3 x float>, <3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.maxnum.v3f64(<3 x double>, <3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.minnum.v3f32(<3 x float>, <3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.minnum.v3f64(<3 x double>, <3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.maxnum.v3f32(<3 x float>, <3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.maxnum.v3f64(<3 x double>, <3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.minnum.v3f32(<3 x float>, <3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.minnum.v3f64(<3 x double>, <3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.fptrunc.v3f32.v3f64(<3 x double>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.fpext.v3f64.v3f32(<3 x float>, metadata)
declare <3 x float> @llvm.experimental.constrained.ceil.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.ceil.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.floor.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.floor.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.round.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.round.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.trunc.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.trunc.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.ceil.v3f32(<3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.ceil.v3f64(<3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.floor.v3f32(<3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.floor.v3f64(<3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.round.v3f32(<3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.round.v3f64(<3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.trunc.v3f32(<3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.trunc.v3f64(<3 x double>, metadata)
declare <4 x double> @llvm.experimental.constrained.fadd.v4f64(<4 x double>, <4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.fsub.v4f64(<4 x double>, <4 x double>, metadata, metadata)
@ -6428,11 +6402,11 @@ declare <4 x double> @llvm.experimental.constrained.log10.v4f64(<4 x double>, me
declare <4 x double> @llvm.experimental.constrained.log2.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.rint.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.nearbyint.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.maxnum.v4f64(<4 x double>, <4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.minnum.v4f64(<4 x double>, <4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.maxnum.v4f64(<4 x double>, <4 x double>, metadata)
declare <4 x double> @llvm.experimental.constrained.minnum.v4f64(<4 x double>, <4 x double>, metadata)
declare <4 x float> @llvm.experimental.constrained.fptrunc.v4f32.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.fpext.v4f64.v4f32(<4 x float>, metadata)
declare <4 x double> @llvm.experimental.constrained.ceil.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.floor.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.round.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.trunc.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.ceil.v4f64(<4 x double>, metadata)
declare <4 x double> @llvm.experimental.constrained.floor.v4f64(<4 x double>, metadata)
declare <4 x double> @llvm.experimental.constrained.round.v4f64(<4 x double>, metadata)
declare <4 x double> @llvm.experimental.constrained.trunc.v4f64(<4 x double>, metadata)

View File

@ -322,7 +322,7 @@ define fp128 @ceil(fp128 %x) nounwind strictfp {
; X86-NEXT: popl %edi
; X86-NEXT: retl $4
entry:
%ceil = call fp128 @llvm.experimental.constrained.ceil.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
%ceil = call fp128 @llvm.experimental.constrained.ceil.f128(fp128 %x, metadata !"fpexcept.strict") #0
ret fp128 %ceil
}
@ -486,7 +486,7 @@ define fp128 @floor(fp128 %x) nounwind strictfp {
; X86-NEXT: popl %edi
; X86-NEXT: retl $4
entry:
%floor = call fp128 @llvm.experimental.constrained.floor.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
%floor = call fp128 @llvm.experimental.constrained.floor.f128(fp128 %x, metadata !"fpexcept.strict") #0
ret fp128 %floor
}
@ -654,7 +654,7 @@ define fp128 @maxnum(fp128 %x, fp128 %y) nounwind strictfp {
; X86-NEXT: popl %edi
; X86-NEXT: retl $4
entry:
%maxnum = call fp128 @llvm.experimental.constrained.maxnum.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
%maxnum = call fp128 @llvm.experimental.constrained.maxnum.f128(fp128 %x, fp128 %y, metadata !"fpexcept.strict") #0
ret fp128 %maxnum
}
@ -699,7 +699,7 @@ define fp128 @minnum(fp128 %x, fp128 %y) nounwind strictfp {
; X86-NEXT: popl %edi
; X86-NEXT: retl $4
entry:
%minnum = call fp128 @llvm.experimental.constrained.minnum.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
%minnum = call fp128 @llvm.experimental.constrained.minnum.f128(fp128 %x, fp128 %y, metadata !"fpexcept.strict") #0
ret fp128 %minnum
}
@ -909,7 +909,7 @@ define fp128 @round(fp128 %x) nounwind strictfp {
; X86-NEXT: popl %edi
; X86-NEXT: retl $4
entry:
%round = call fp128 @llvm.experimental.constrained.round.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
%round = call fp128 @llvm.experimental.constrained.round.f128(fp128 %x, metadata !"fpexcept.strict") #0
ret fp128 %round
}
@ -1032,7 +1032,7 @@ define fp128 @trunc(fp128 %x) nounwind strictfp {
; X86-NEXT: popl %edi
; X86-NEXT: retl $4
entry:
%trunc = call fp128 @llvm.experimental.constrained.trunc.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
%trunc = call fp128 @llvm.experimental.constrained.trunc.f128(fp128 %x, metadata !"fpexcept.strict") #0
ret fp128 %trunc
}
@ -1136,24 +1136,24 @@ declare fp128 @llvm.experimental.constrained.fmul.f128(fp128, fp128, metadata, m
declare fp128 @llvm.experimental.constrained.fdiv.f128(fp128, fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.fma.f128(fp128, fp128, fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.frem.f128(fp128, fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata)
declare fp128 @llvm.experimental.constrained.cos.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.exp.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.exp2.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata)
declare fp128 @llvm.experimental.constrained.log.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.log10.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.log2.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.maxnum.f128(fp128, fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.minnum.f128(fp128, fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.maxnum.f128(fp128, fp128, metadata)
declare fp128 @llvm.experimental.constrained.minnum.f128(fp128, fp128, metadata)
declare fp128 @llvm.experimental.constrained.nearbyint.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.pow.f128(fp128, fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.powi.f128(fp128, i32, metadata, metadata)
declare fp128 @llvm.experimental.constrained.rint.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata)
declare fp128 @llvm.experimental.constrained.sin.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.sqrt.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata)
declare i32 @llvm.experimental.constrained.lrint.i32.f128(fp128, metadata, metadata)
declare i64 @llvm.experimental.constrained.llrint.i64.f128(fp128, metadata, metadata)
declare i32 @llvm.experimental.constrained.lround.i32.f128(fp128, metadata)

View File

@ -3373,7 +3373,6 @@ define <1 x float> @constrained_vector_maxnum_v1f32() #0 {
entry:
%max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32(
<1 x float> <float 42.0>, <1 x float> <float 41.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <1 x float> %max
}
@ -3416,7 +3415,6 @@ entry:
%max = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64(
<2 x double> <double 43.0, double 42.0>,
<2 x double> <double 41.0, double 40.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %max
}
@ -3472,7 +3470,6 @@ entry:
%max = call <3 x float> @llvm.experimental.constrained.maxnum.v3f32(
<3 x float> <float 43.0, float 44.0, float 45.0>,
<3 x float> <float 41.0, float 42.0, float 43.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x float> %max
}
@ -3530,7 +3527,6 @@ entry:
%max = call <3 x double> @llvm.experimental.constrained.maxnum.v3f64(
<3 x double> <double 43.0, double 44.0, double 45.0>,
<3 x double> <double 40.0, double 41.0, double 42.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x double> %max
}
@ -3598,7 +3594,6 @@ entry:
double 46.0, double 47.0>,
<4 x double> <double 40.0, double 41.0,
double 42.0, double 43.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <4 x double> %max
}
@ -3628,7 +3623,6 @@ define <1 x float> @constrained_vector_minnum_v1f32() #0 {
entry:
%min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32(
<1 x float> <float 42.0>, <1 x float> <float 41.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <1 x float> %min
}
@ -3671,7 +3665,6 @@ entry:
%min = call <2 x double> @llvm.experimental.constrained.minnum.v2f64(
<2 x double> <double 43.0, double 42.0>,
<2 x double> <double 41.0, double 40.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %min
}
@ -3727,7 +3720,6 @@ entry:
%min = call <3 x float> @llvm.experimental.constrained.minnum.v3f32(
<3 x float> <float 43.0, float 44.0, float 45.0>,
<3 x float> <float 41.0, float 42.0, float 43.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x float> %min
}
@ -3785,7 +3777,6 @@ entry:
%min = call <3 x double> @llvm.experimental.constrained.minnum.v3f64(
<3 x double> <double 43.0, double 44.0, double 45.0>,
<3 x double> <double 40.0, double 41.0, double 42.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x double> %min
}
@ -3853,7 +3844,6 @@ entry:
double 46.0, double 47.0>,
<4 x double> <double 40.0, double 41.0,
double 42.0, double 43.0>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <4 x double> %min
}
@ -5244,7 +5234,6 @@ define <1 x float> @constrained_vector_ceil_v1f32() #0 {
entry:
%ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <1 x float> %ceil
}
@ -5272,7 +5261,6 @@ define <2 x double> @constrained_vector_ceil_v2f64() #0 {
entry:
%ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %ceil
}
@ -5313,7 +5301,6 @@ define <3 x float> @constrained_vector_ceil_v3f32() #0 {
entry:
%ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x float> %ceil
}
@ -5351,7 +5338,6 @@ define <3 x double> @constrained_vector_ceil_v3f64() #0 {
entry:
%ceil = call <3 x double> @llvm.experimental.constrained.ceil.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x double> %ceil
}
@ -5375,7 +5361,6 @@ define <1 x float> @constrained_vector_floor_v1f32() #0 {
entry:
%floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <1 x float> %floor
}
@ -5404,7 +5389,6 @@ define <2 x double> @constrained_vector_floor_v2f64() #0 {
entry:
%floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %floor
}
@ -5445,7 +5429,6 @@ define <3 x float> @constrained_vector_floor_v3f32() #0 {
entry:
%floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x float> %floor
}
@ -5483,7 +5466,6 @@ define <3 x double> @constrained_vector_floor_v3f64() #0 {
entry:
%floor = call <3 x double> @llvm.experimental.constrained.floor.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x double> %floor
}
@ -5511,7 +5493,6 @@ define <1 x float> @constrained_vector_round_v1f32() #0 {
entry:
%round = call <1 x float> @llvm.experimental.constrained.round.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <1 x float> %round
}
@ -5549,7 +5530,6 @@ define <2 x double> @constrained_vector_round_v2f64() #0 {
entry:
%round = call <2 x double> @llvm.experimental.constrained.round.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %round
}
@ -5598,7 +5578,6 @@ define <3 x float> @constrained_vector_round_v3f32() #0 {
entry:
%round = call <3 x float> @llvm.experimental.constrained.round.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x float> %round
}
@ -5650,7 +5629,6 @@ define <3 x double> @constrained_vector_round_v3f64() #0 {
entry:
%round = call <3 x double> @llvm.experimental.constrained.round.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x double> %round
}
@ -5674,7 +5652,6 @@ define <1 x float> @constrained_vector_trunc_v1f32() #0 {
entry:
%trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <1 x float> %trunc
}
@ -5702,7 +5679,6 @@ define <2 x double> @constrained_vector_trunc_v2f64() #0 {
entry:
%trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <2 x double> %trunc
}
@ -5743,7 +5719,6 @@ define <3 x float> @constrained_vector_trunc_v3f32() #0 {
entry:
%trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x float> %trunc
}
@ -5781,7 +5756,6 @@ define <3 x double> @constrained_vector_trunc_v3f64() #0 {
entry:
%trunc = call <3 x double> @llvm.experimental.constrained.trunc.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
ret <3 x double> %trunc
}
@ -7313,8 +7287,8 @@ declare <2 x double> @llvm.experimental.constrained.log10.v2f64(<2 x double>, me
declare <2 x double> @llvm.experimental.constrained.log2.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.rint.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata)
declare <2 x i32> @llvm.experimental.constrained.fptosi.v2i32.v2f32(<2 x float>, metadata)
declare <2 x i64> @llvm.experimental.constrained.fptosi.v2i64.v2f32(<2 x float>, metadata)
declare <2 x i32> @llvm.experimental.constrained.fptosi.v2i32.v2f64(<2 x double>, metadata)
@ -7325,10 +7299,10 @@ declare <2 x i32> @llvm.experimental.constrained.fptoui.v2i32.v2f64(<2 x double>
declare <2 x i64> @llvm.experimental.constrained.fptoui.v2i64.v2f64(<2 x double>, metadata)
declare <2 x float> @llvm.experimental.constrained.fptrunc.v2f32.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.fpext.v2f64.v2f32(<2 x float>, metadata)
declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata)
declare <2 x double> @llvm.experimental.constrained.sitofp.v2f64.v2i32(<2 x i32>, metadata, metadata)
declare <2 x float> @llvm.experimental.constrained.sitofp.v2f32.v2i32(<2 x i32>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.sitofp.v2f64.v2i64(<2 x i64>, metadata, metadata)
@ -7356,8 +7330,8 @@ declare <1 x float> @llvm.experimental.constrained.log10.v1f32(<1 x float>, meta
declare <1 x float> @llvm.experimental.constrained.log2.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.rint.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.nearbyint.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.maxnum.v1f32(<1 x float>, <1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.minnum.v1f32(<1 x float>, <1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.maxnum.v1f32(<1 x float>, <1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.minnum.v1f32(<1 x float>, <1 x float>, metadata)
declare <1 x i32> @llvm.experimental.constrained.fptosi.v1i32.v1f32(<1 x float>, metadata)
declare <1 x i64> @llvm.experimental.constrained.fptosi.v1i64.v1f32(<1 x float>, metadata)
declare <1 x i32> @llvm.experimental.constrained.fptosi.v1i32.v1f64(<1 x double>, metadata)
@ -7368,10 +7342,10 @@ declare <1 x i32> @llvm.experimental.constrained.fptoui.v1i32.v1f64(<1 x double>
declare <1 x i64> @llvm.experimental.constrained.fptoui.v1i64.v1f64(<1 x double>, metadata)
declare <1 x float> @llvm.experimental.constrained.fptrunc.v1f32.v1f64(<1 x double>, metadata, metadata)
declare <1 x double> @llvm.experimental.constrained.fpext.v1f64.v1f32(<1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.ceil.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.floor.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.round.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.trunc.v1f32(<1 x float>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.ceil.v1f32(<1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.floor.v1f32(<1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.round.v1f32(<1 x float>, metadata)
declare <1 x float> @llvm.experimental.constrained.trunc.v1f32(<1 x float>, metadata)
declare <1 x double> @llvm.experimental.constrained.sitofp.v1f64.v1i32(<1 x i32>, metadata, metadata)
declare <1 x float> @llvm.experimental.constrained.sitofp.v1f32.v1i32(<1 x i32>, metadata, metadata)
declare <1 x double> @llvm.experimental.constrained.sitofp.v1f64.v1i64(<1 x i64>, metadata, metadata)
@ -7416,10 +7390,10 @@ declare <3 x float> @llvm.experimental.constrained.rint.v3f32(<3 x float>, metad
declare <3 x double> @llvm.experimental.constrained.rint.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.nearbyint.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.nearbyint.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.maxnum.v3f32(<3 x float>, <3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.maxnum.v3f64(<3 x double>, <3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.minnum.v3f32(<3 x float>, <3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.minnum.v3f64(<3 x double>, <3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.maxnum.v3f32(<3 x float>, <3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.maxnum.v3f64(<3 x double>, <3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.minnum.v3f32(<3 x float>, <3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.minnum.v3f64(<3 x double>, <3 x double>, metadata)
declare <3 x i32> @llvm.experimental.constrained.fptosi.v3i32.v3f32(<3 x float>, metadata)
declare <3 x i64> @llvm.experimental.constrained.fptosi.v3i64.v3f32(<3 x float>, metadata)
declare <3 x i32> @llvm.experimental.constrained.fptosi.v3i32.v3f64(<3 x double>, metadata)
@ -7430,14 +7404,14 @@ declare <3 x i32> @llvm.experimental.constrained.fptoui.v3i32.v3f64(<3 x double>
declare <3 x i64> @llvm.experimental.constrained.fptoui.v3i64.v3f64(<3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.fptrunc.v3f32.v3f64(<3 x double>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.fpext.v3f64.v3f32(<3 x float>, metadata)
declare <3 x float> @llvm.experimental.constrained.ceil.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.ceil.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.floor.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.floor.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.round.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.round.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.trunc.v3f32(<3 x float>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.trunc.v3f64(<3 x double>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.ceil.v3f32(<3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.ceil.v3f64(<3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.floor.v3f32(<3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.floor.v3f64(<3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.round.v3f32(<3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.round.v3f64(<3 x double>, metadata)
declare <3 x float> @llvm.experimental.constrained.trunc.v3f32(<3 x float>, metadata)
declare <3 x double> @llvm.experimental.constrained.trunc.v3f64(<3 x double>, metadata)
declare <3 x double> @llvm.experimental.constrained.sitofp.v3f64.v3i32(<3 x i32>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.sitofp.v3f32.v3i32(<3 x i32>, metadata, metadata)
declare <3 x double> @llvm.experimental.constrained.sitofp.v3f64.v3i64(<3 x i64>, metadata, metadata)
@ -7465,8 +7439,8 @@ declare <4 x double> @llvm.experimental.constrained.log10.v4f64(<4 x double>, me
declare <4 x double> @llvm.experimental.constrained.log2.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.rint.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.nearbyint.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.maxnum.v4f64(<4 x double>, <4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.minnum.v4f64(<4 x double>, <4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.maxnum.v4f64(<4 x double>, <4 x double>, metadata)
declare <4 x double> @llvm.experimental.constrained.minnum.v4f64(<4 x double>, <4 x double>, metadata)
declare <4 x i32> @llvm.experimental.constrained.fptosi.v4i32.v4f32(<4 x float>, metadata)
declare <4 x i64> @llvm.experimental.constrained.fptosi.v4i64.v4f32(<4 x float>, metadata)
declare <4 x i32> @llvm.experimental.constrained.fptosi.v4i32.v4f64(<4 x double>, metadata)
@ -7477,10 +7451,10 @@ declare <4 x i32> @llvm.experimental.constrained.fptoui.v4i32.v4f64(<4 x double>
declare <4 x i64> @llvm.experimental.constrained.fptoui.v4i64.v4f64(<4 x double>, metadata)
declare <4 x float> @llvm.experimental.constrained.fptrunc.v4f32.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.fpext.v4f64.v4f32(<4 x float>, metadata)
declare <4 x double> @llvm.experimental.constrained.ceil.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.floor.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.round.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.trunc.v4f64(<4 x double>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.ceil.v4f64(<4 x double>, metadata)
declare <4 x double> @llvm.experimental.constrained.floor.v4f64(<4 x double>, metadata)
declare <4 x double> @llvm.experimental.constrained.round.v4f64(<4 x double>, metadata)
declare <4 x double> @llvm.experimental.constrained.trunc.v4f64(<4 x double>, metadata)
declare <4 x double> @llvm.experimental.constrained.sitofp.v4f64.v4i32(<4 x i32>, metadata, metadata)
declare <4 x float> @llvm.experimental.constrained.sitofp.v4f32.v4i32(<4 x i32>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.sitofp.v4f64.v4i64(<4 x i64>, metadata, metadata)