[clang] 1e89188 - [FPEnv] Remove unnecessary rounding mode argument for constrained intrinsics
Ulrich Weigand via cfe-commits
cfe-commits at lists.llvm.org
Tue Dec 17 12:11:23 PST 2019
Author: Ulrich Weigand
Date: 2019-12-17T21:10:36+01:00
New Revision: 1e89188d3537d419f6bdc3276ab8848adf6752f5
URL: https://github.com/llvm/llvm-project/commit/1e89188d3537d419f6bdc3276ab8848adf6752f5
DIFF: https://github.com/llvm/llvm-project/commit/1e89188d3537d419f6bdc3276ab8848adf6752f5.diff
LOG: [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
Added:
Modified:
clang/test/CodeGen/constrained-math-builtins.c
llvm/docs/LangRef.rst
llvm/include/llvm/IR/ConstrainedOps.def
llvm/include/llvm/IR/IRBuilder.h
llvm/include/llvm/IR/Intrinsics.td
llvm/test/CodeGen/ARM/fp-intrinsics.ll
llvm/test/CodeGen/PowerPC/ppcf128-constrained-fp-intrinsics.ll
llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll
llvm/test/CodeGen/SystemZ/fp-strict-round-01.ll
llvm/test/CodeGen/SystemZ/fp-strict-round-02.ll
llvm/test/CodeGen/SystemZ/fp-strict-round-03.ll
llvm/test/CodeGen/SystemZ/vec-strict-max-01.ll
llvm/test/CodeGen/SystemZ/vec-strict-min-01.ll
llvm/test/CodeGen/SystemZ/vec-strict-round-01.ll
llvm/test/CodeGen/SystemZ/vec-strict-round-02.ll
llvm/test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll
llvm/test/CodeGen/X86/fp128-libcalls-strict.ll
llvm/test/CodeGen/X86/vector-constrained-fp-intrinsics.ll
Removed:
################################################################################
diff --git a/clang/test/CodeGen/constrained-math-builtins.c b/clang/test/CodeGen/constrained-math-builtins.c
index c7897ca0a047..72c2918dca96 100644
--- a/clang/test/CodeGen/constrained-math-builtins.c
+++ b/clang/test/CodeGen/constrained-math-builtins.c
@@ -23,9 +23,9 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) {
__builtin_ceil(f); __builtin_ceilf(f); __builtin_ceill(f);
-// CHECK: declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
-// CHECK: declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
-// CHECK: declare x86_fp80 @llvm.experimental.constrained.ceil.f80(x86_fp80, metadata, metadata)
+// CHECK: declare double @llvm.experimental.constrained.ceil.f64(double, metadata)
+// CHECK: declare float @llvm.experimental.constrained.ceil.f32(float, metadata)
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.ceil.f80(x86_fp80, metadata)
__builtin_cos(f); __builtin_cosf(f); __builtin_cosl(f);
@@ -47,9 +47,9 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) {
__builtin_floor(f); __builtin_floorf(f); __builtin_floorl(f);
-// CHECK: declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
-// CHECK: declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
-// CHECK: declare x86_fp80 @llvm.experimental.constrained.floor.f80(x86_fp80, metadata, metadata)
+// CHECK: declare double @llvm.experimental.constrained.floor.f64(double, metadata)
+// CHECK: declare float @llvm.experimental.constrained.floor.f32(float, metadata)
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.floor.f80(x86_fp80, metadata)
__builtin_fma(f,f,f); __builtin_fmaf(f,f,f); __builtin_fmal(f,f,f);
@@ -59,15 +59,15 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) {
__builtin_fmax(f,f); __builtin_fmaxf(f,f); __builtin_fmaxl(f,f);
-// CHECK: declare double @llvm.experimental.constrained.maxnum.f64(double, double, metadata, metadata)
-// CHECK: declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata, metadata)
-// CHECK: declare x86_fp80 @llvm.experimental.constrained.maxnum.f80(x86_fp80, x86_fp80, metadata, metadata)
+// CHECK: declare double @llvm.experimental.constrained.maxnum.f64(double, double, metadata)
+// CHECK: declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata)
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.maxnum.f80(x86_fp80, x86_fp80, metadata)
__builtin_fmin(f,f); __builtin_fminf(f,f); __builtin_fminl(f,f);
-// CHECK: declare double @llvm.experimental.constrained.minnum.f64(double, double, metadata, metadata)
-// CHECK: declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata, metadata)
-// CHECK: declare x86_fp80 @llvm.experimental.constrained.minnum.f80(x86_fp80, x86_fp80, metadata, metadata)
+// CHECK: declare double @llvm.experimental.constrained.minnum.f64(double, double, metadata)
+// CHECK: declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata)
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.minnum.f80(x86_fp80, x86_fp80, metadata)
__builtin_llrint(f); __builtin_llrintf(f); __builtin_llrintl(f);
@@ -125,9 +125,9 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) {
__builtin_round(f); __builtin_roundf(f); __builtin_roundl(f);
-// CHECK: declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
-// CHECK: declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
-// CHECK: declare x86_fp80 @llvm.experimental.constrained.round.f80(x86_fp80, metadata, metadata)
+// CHECK: declare double @llvm.experimental.constrained.round.f64(double, metadata)
+// CHECK: declare float @llvm.experimental.constrained.round.f32(float, metadata)
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.round.f80(x86_fp80, metadata)
__builtin_sin(f); __builtin_sinf(f); __builtin_sinl(f);
@@ -143,8 +143,8 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) {
__builtin_trunc(f); __builtin_truncf(f); __builtin_truncl(f);
-// CHECK: declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
-// CHECK: declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
-// CHECK: declare x86_fp80 @llvm.experimental.constrained.trunc.f80(x86_fp80, metadata, metadata)
+// CHECK: declare double @llvm.experimental.constrained.trunc.f64(double, metadata)
+// CHECK: declare float @llvm.experimental.constrained.trunc.f32(float, metadata)
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.trunc.f80(x86_fp80, metadata)
};
diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst
index 5bc07cae65f2..e98cd3cdfd47 100644
--- a/llvm/docs/LangRef.rst
+++ b/llvm/docs/LangRef.rst
@@ -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:
""""""""""
diff --git a/llvm/include/llvm/IR/ConstrainedOps.def b/llvm/include/llvm/IR/ConstrainedOps.def
index d0d062b81437..5bd1d60049d6 100644
--- a/llvm/include/llvm/IR/ConstrainedOps.def
+++ b/llvm/include/llvm/IR/ConstrainedOps.def
@@ -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
diff --git a/llvm/include/llvm/IR/IRBuilder.h b/llvm/include/llvm/IR/IRBuilder.h
index 8179e388fa11..d36934986d7b 100644
--- a/llvm/include/llvm/IR/IRBuilder.h
+++ b/llvm/include/llvm/IR/IRBuilder.h
@@ -2171,21 +2171,24 @@ class IRBuilder : public IRBuilderBase, public Inserter {
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 @@ class IRBuilder : public IRBuilderBase, public Inserter {
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(
diff --git a/llvm/include/llvm/IR/Intrinsics.td b/llvm/include/llvm/IR/Intrinsics.td
index 1d8f97cc8a19..100d1ba59479 100644
--- a/llvm/include/llvm/IR/Intrinsics.td
+++ b/llvm/include/llvm/IR/Intrinsics.td
@@ -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).
diff --git a/llvm/test/CodeGen/ARM/fp-intrinsics.ll b/llvm/test/CodeGen/ARM/fp-intrinsics.ll
index 8d4a6376a977..5eb201664834 100644
--- a/llvm/test/CodeGen/ARM/fp-intrinsics.ll
+++ b/llvm/test/CodeGen/ARM/fp-intrinsics.ll
@@ -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)
diff --git a/llvm/test/CodeGen/PowerPC/ppcf128-constrained-fp-intrinsics.ll b/llvm/test/CodeGen/PowerPC/ppcf128-constrained-fp-intrinsics.ll
index 179ddc1980a9..497703e8c40f 100644
--- a/llvm/test/CodeGen/PowerPC/ppcf128-constrained-fp-intrinsics.ll
+++ b/llvm/test/CodeGen/PowerPC/ppcf128-constrained-fp-intrinsics.ll
@@ -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)
diff --git a/llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll b/llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll
index 0b802d528376..41eb3903dff2 100644
--- a/llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll
+++ b/llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll
@@ -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)
diff --git a/llvm/test/CodeGen/SystemZ/fp-strict-round-01.ll b/llvm/test/CodeGen/SystemZ/fp-strict-round-01.ll
index 92b5bdc65f59..5b70054998dc 100644
--- a/llvm/test/CodeGen/SystemZ/fp-strict-round-01.ll
+++ b/llvm/test/CodeGen/SystemZ/fp-strict-round-01.ll
@@ -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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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
diff --git a/llvm/test/CodeGen/SystemZ/fp-strict-round-02.ll b/llvm/test/CodeGen/SystemZ/fp-strict-round-02.ll
index 223e1a076bb8..c51e87bf5623 100644
--- a/llvm/test/CodeGen/SystemZ/fp-strict-round-02.ll
+++ b/llvm/test/CodeGen/SystemZ/fp-strict-round-02.ll
@@ -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
diff --git a/llvm/test/CodeGen/SystemZ/fp-strict-round-03.ll b/llvm/test/CodeGen/SystemZ/fp-strict-round-03.ll
index 811fe8340f1e..4b452ceb15f2 100644
--- a/llvm/test/CodeGen/SystemZ/fp-strict-round-03.ll
+++ b/llvm/test/CodeGen/SystemZ/fp-strict-round-03.ll
@@ -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
diff --git a/llvm/test/CodeGen/SystemZ/vec-strict-max-01.ll b/llvm/test/CodeGen/SystemZ/vec-strict-max-01.ll
index c734a6aa5fee..161c75eeb52e 100644
--- a/llvm/test/CodeGen/SystemZ/vec-strict-max-01.ll
+++ b/llvm/test/CodeGen/SystemZ/vec-strict-max-01.ll
@@ -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
diff --git a/llvm/test/CodeGen/SystemZ/vec-strict-min-01.ll b/llvm/test/CodeGen/SystemZ/vec-strict-min-01.ll
index 25882568bdc3..d48a020f8805 100644
--- a/llvm/test/CodeGen/SystemZ/vec-strict-min-01.ll
+++ b/llvm/test/CodeGen/SystemZ/vec-strict-min-01.ll
@@ -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
diff --git a/llvm/test/CodeGen/SystemZ/vec-strict-round-01.ll b/llvm/test/CodeGen/SystemZ/vec-strict-round-01.ll
index 9f73c73c212b..b82cb8082b7b 100644
--- a/llvm/test/CodeGen/SystemZ/vec-strict-round-01.ll
+++ b/llvm/test/CodeGen/SystemZ/vec-strict-round-01.ll
@@ -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
}
diff --git a/llvm/test/CodeGen/SystemZ/vec-strict-round-02.ll b/llvm/test/CodeGen/SystemZ/vec-strict-round-02.ll
index 9eec926f4cb2..701dd5b2302f 100644
--- a/llvm/test/CodeGen/SystemZ/vec-strict-round-02.ll
+++ b/llvm/test/CodeGen/SystemZ/vec-strict-round-02.ll
@@ -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
}
diff --git a/llvm/test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll b/llvm/test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll
index 931e11831f41..e7c4e3a4466e 100644
--- a/llvm/test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll
+++ b/llvm/test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll
@@ -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)
diff --git a/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll b/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll
index a02e9280c6ca..bf20bac2d731 100644
--- a/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll
+++ b/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll
@@ -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)
diff --git a/llvm/test/CodeGen/X86/vector-constrained-fp-intrinsics.ll b/llvm/test/CodeGen/X86/vector-constrained-fp-intrinsics.ll
index ccdda7399a03..f68a80fa0c37 100644
--- a/llvm/test/CodeGen/X86/vector-constrained-fp-intrinsics.ll
+++ b/llvm/test/CodeGen/X86/vector-constrained-fp-intrinsics.ll
@@ -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)
More information about the cfe-commits
mailing list