Index: clang/test/CodeGen/constrained-math-builtins.c =================================================================== --- clang/test/CodeGen/constrained-math-builtins.c +++ clang/test/CodeGen/constrained-math-builtins.c @@ -23,9 +23,9 @@ __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 @@ __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 @@ __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 @@ __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 @@ __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) }; Index: llvm/docs/LangRef.rst =================================================================== --- llvm/docs/LangRef.rst +++ llvm/docs/LangRef.rst @@ -16406,7 +16406,6 @@ declare @llvm.experimental.constrained.maxnum( , - metadata , metadata ) Overview: @@ -16421,16 +16420,12 @@ 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 @@ -16443,7 +16438,6 @@ declare @llvm.experimental.constrained.minnum( , - metadata , metadata ) Overview: @@ -16458,16 +16452,12 @@ 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 @@ -16480,7 +16470,6 @@ declare @llvm.experimental.constrained.ceil( , - metadata , metadata ) Overview: @@ -16495,9 +16484,7 @@ 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: """""""""" @@ -16516,7 +16503,6 @@ declare @llvm.experimental.constrained.floor( , - metadata , metadata ) Overview: @@ -16531,9 +16517,7 @@ 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: """""""""" @@ -16552,7 +16536,6 @@ declare @llvm.experimental.constrained.round( , - metadata , metadata ) Overview: @@ -16567,9 +16550,7 @@ 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: """""""""" @@ -16664,7 +16645,6 @@ declare @llvm.experimental.constrained.trunc( , - metadata , metadata ) Overview: @@ -16680,9 +16660,7 @@ 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: """""""""" Index: llvm/include/llvm/IR/ConstrainedOps.def =================================================================== --- llvm/include/llvm/IR/ConstrainedOps.def +++ llvm/include/llvm/IR/ConstrainedOps.def @@ -53,11 +53,11 @@ // 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) @@ -66,16 +66,16 @@ 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 Index: llvm/include/llvm/IR/IRBuilder.h =================================================================== --- llvm/include/llvm/IR/IRBuilder.h +++ llvm/include/llvm/IR/IRBuilder.h @@ -2157,21 +2157,24 @@ 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(C)) @@ -2388,18 +2391,18 @@ for (auto *OneArg : Args) UseArgs.push_back(OneArg); Function *F = cast(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( Index: llvm/include/llvm/IR/Intrinsics.td =================================================================== --- llvm/include/llvm/IR/Intrinsics.td +++ llvm/include/llvm/IR/Intrinsics.td @@ -714,20 +714,16 @@ 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, @@ -737,11 +733,9 @@ 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). Index: llvm/test/CodeGen/ARM/fp-intrinsics.ll =================================================================== --- llvm/test/CodeGen/ARM/fp-intrinsics.ll +++ llvm/test/CodeGen/ARM/fp-intrinsics.ll @@ -182,7 +182,7 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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.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.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) Index: llvm/test/CodeGen/PowerPC/ppcf128-constrained-fp-intrinsics.ll =================================================================== --- llvm/test/CodeGen/PowerPC/ppcf128-constrained-fp-intrinsics.ll +++ llvm/test/CodeGen/PowerPC/ppcf128-constrained-fp-intrinsics.ll @@ -848,7 +848,6 @@ %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 @@ %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 @@ 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 @@ 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 @@ 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 @@ 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 @@ } 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 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) Index: llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll =================================================================== --- llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll +++ llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll @@ -5490,7 +5490,6 @@ entry: %max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32( <1 x float> , <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <1 x float> %max } @@ -5555,7 +5554,6 @@ %max = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64( <2 x double> , <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <2 x double> %max } @@ -5658,7 +5656,6 @@ %max = call <3 x float> @llvm.experimental.constrained.maxnum.v3f32( <3 x float> , <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <3 x float> %max } @@ -5749,7 +5746,6 @@ %max = call <3 x double> @llvm.experimental.constrained.maxnum.v3f64( <3 x double> , <3 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <3 x double> %max } @@ -5860,7 +5856,6 @@ double 46.0, double 47.0>, <4 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <4 x double> %max } @@ -5904,7 +5899,6 @@ entry: %min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32( <1 x float> , <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <1 x float> %min } @@ -5969,7 +5963,6 @@ %min = call <2 x double> @llvm.experimental.constrained.minnum.v2f64( <2 x double> , <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <2 x double> %min } @@ -6072,7 +6065,6 @@ %min = call <3 x float> @llvm.experimental.constrained.minnum.v3f32( <3 x float> , <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <3 x float> %min } @@ -6163,7 +6155,6 @@ %min = call <3 x double> @llvm.experimental.constrained.minnum.v3f64( <3 x double> , <3 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <3 x double> %min } @@ -6274,7 +6265,6 @@ double 46.0, double 47.0>, <4 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <4 x double> %min } @@ -6574,7 +6564,6 @@ entry: %ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32( <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <1 x float> %ceil } @@ -6599,7 +6588,6 @@ entry: %ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64( <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <2 x double> %ceil } @@ -6655,7 +6643,6 @@ entry: %ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32( <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <3 x float> %ceil } @@ -6692,7 +6679,6 @@ entry: %ceil = call <3 x double> @llvm.experimental.constrained.ceil.v3f64( <3 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <3 x double> %ceil } @@ -6718,7 +6704,6 @@ entry: %floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32( <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <1 x float> %floor } @@ -6744,7 +6729,6 @@ entry: %floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64( <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <2 x double> %floor } @@ -6800,7 +6784,6 @@ entry: %floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32( <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <3 x float> %floor } @@ -6837,7 +6820,6 @@ entry: %floor = call <3 x double> @llvm.experimental.constrained.floor.v3f64( <3 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <3 x double> %floor } @@ -6863,7 +6845,6 @@ entry: %round = call <1 x float> @llvm.experimental.constrained.round.v1f32( <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <1 x float> %round } @@ -6888,7 +6869,6 @@ entry: %round = call <2 x double> @llvm.experimental.constrained.round.v2f64( <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <2 x double> %round } @@ -6944,7 +6924,6 @@ entry: %round = call <3 x float> @llvm.experimental.constrained.round.v3f32( <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <3 x float> %round } @@ -6982,7 +6961,6 @@ entry: %round = call <3 x double> @llvm.experimental.constrained.round.v3f64( <3 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <3 x double> %round } @@ -7008,7 +6986,6 @@ entry: %trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32( <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <1 x float> %trunc } @@ -7033,7 +7010,6 @@ entry: %trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64( <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <2 x double> %trunc } @@ -7089,7 +7065,6 @@ entry: %trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32( <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <3 x float> %trunc } @@ -7126,7 +7101,6 @@ entry: %trunc = call <3 x double> @llvm.experimental.constrained.trunc.v3f64( <3 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #1 ret <3 x double> %trunc } @@ -7152,14 +7126,14 @@ 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.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 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.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) Index: llvm/test/CodeGen/SystemZ/fp-strict-round-01.ll =================================================================== --- llvm/test/CodeGen/SystemZ/fp-strict-round-01.ll +++ llvm/test/CodeGen/SystemZ/fp-strict-round-01.ll @@ -85,33 +85,31 @@ } ; Test floor for f32. -declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata) +declare float @llvm.experimental.constrained.floor.f32(float, metadata) define float @f7(float %f) #0 { ; CHECK-LABEL: f7: ; CHECK: brasl %r14, floorf@PLT ; CHECK: br %r14 %res = call float @llvm.experimental.constrained.floor.f32( float %f, - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret float %res } ; Test floor for f64. -declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata) +declare double @llvm.experimental.constrained.floor.f64(double, metadata) define double @f8(double %f) #0 { ; CHECK-LABEL: f8: ; CHECK: brasl %r14, floor@PLT ; CHECK: br %r14 %res = call double @llvm.experimental.constrained.floor.f64( double %f, - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret double %res } ; Test floor for f128. -declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata) +declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata) define void @f9(fp128 *%ptr) #0 { ; CHECK-LABEL: f9: ; CHECK: brasl %r14, floorl@PLT @@ -119,40 +117,37 @@ %src = load fp128, fp128 *%ptr %res = call fp128 @llvm.experimental.constrained.floor.f128( fp128 %src, - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 store fp128 %res, fp128 *%ptr ret void } ; Test ceil for f32. -declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata) +declare float @llvm.experimental.constrained.ceil.f32(float, metadata) define float @f10(float %f) #0 { ; CHECK-LABEL: f10: ; CHECK: brasl %r14, ceilf@PLT ; CHECK: br %r14 %res = call float @llvm.experimental.constrained.ceil.f32( float %f, - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret float %res } ; Test ceil for f64. -declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata) +declare double @llvm.experimental.constrained.ceil.f64(double, metadata) define double @f11(double %f) #0 { ; CHECK-LABEL: f11: ; CHECK: brasl %r14, ceil@PLT ; CHECK: br %r14 %res = call double @llvm.experimental.constrained.ceil.f64( double %f, - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret double %res } ; Test ceil for f128. -declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata) +declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata) define void @f12(fp128 *%ptr) #0 { ; CHECK-LABEL: f12: ; CHECK: brasl %r14, ceill@PLT @@ -160,40 +155,37 @@ %src = load fp128, fp128 *%ptr %res = call fp128 @llvm.experimental.constrained.ceil.f128( fp128 %src, - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 store fp128 %res, fp128 *%ptr ret void } ; Test trunc for f32. -declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata) +declare float @llvm.experimental.constrained.trunc.f32(float, metadata) define float @f13(float %f) #0 { ; CHECK-LABEL: f13: ; CHECK: brasl %r14, truncf@PLT ; CHECK: br %r14 %res = call float @llvm.experimental.constrained.trunc.f32( float %f, - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret float %res } ; Test trunc for f64. -declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata) +declare double @llvm.experimental.constrained.trunc.f64(double, metadata) define double @f14(double %f) #0 { ; CHECK-LABEL: f14: ; CHECK: brasl %r14, trunc@PLT ; CHECK: br %r14 %res = call double @llvm.experimental.constrained.trunc.f64( double %f, - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret double %res } ; Test trunc for f128. -declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata) +declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata) define void @f15(fp128 *%ptr) #0 { ; CHECK-LABEL: f15: ; CHECK: brasl %r14, truncl@PLT @@ -201,40 +193,37 @@ %src = load fp128, fp128 *%ptr %res = call fp128 @llvm.experimental.constrained.trunc.f128( fp128 %src, - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 store fp128 %res, fp128 *%ptr ret void } ; Test round for f32. -declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata) +declare float @llvm.experimental.constrained.round.f32(float, metadata) define float @f16(float %f) #0 { ; CHECK-LABEL: f16: ; CHECK: brasl %r14, roundf@PLT ; CHECK: br %r14 %res = call float @llvm.experimental.constrained.round.f32( float %f, - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret float %res } ; Test round for f64. -declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata) +declare double @llvm.experimental.constrained.round.f64(double, metadata) define double @f17(double %f) #0 { ; CHECK-LABEL: f17: ; CHECK: brasl %r14, round@PLT ; CHECK: br %r14 %res = call double @llvm.experimental.constrained.round.f64( double %f, - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret double %res } ; Test round for f128. -declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata) +declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata) define void @f18(fp128 *%ptr) #0 { ; CHECK-LABEL: f18: ; CHECK: brasl %r14, roundl@PLT @@ -242,7 +231,6 @@ %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 Index: llvm/test/CodeGen/SystemZ/fp-strict-round-02.ll =================================================================== --- llvm/test/CodeGen/SystemZ/fp-strict-round-02.ll +++ llvm/test/CodeGen/SystemZ/fp-strict-round-02.ll @@ -89,33 +89,31 @@ } ; 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 @@ %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 @@ %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 @@ %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 @@ %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 Index: llvm/test/CodeGen/SystemZ/fp-strict-round-03.ll =================================================================== --- llvm/test/CodeGen/SystemZ/fp-strict-round-03.ll +++ llvm/test/CodeGen/SystemZ/fp-strict-round-03.ll @@ -89,33 +89,31 @@ } ; 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 @@ %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 @@ %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 @@ %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 @@ %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 Index: llvm/test/CodeGen/SystemZ/vec-strict-max-01.ll =================================================================== --- llvm/test/CodeGen/SystemZ/vec-strict-max-01.ll +++ 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ %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 Index: llvm/test/CodeGen/SystemZ/vec-strict-min-01.ll =================================================================== --- llvm/test/CodeGen/SystemZ/vec-strict-min-01.ll +++ 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ %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 Index: llvm/test/CodeGen/SystemZ/vec-strict-round-01.ll =================================================================== --- llvm/test/CodeGen/SystemZ/vec-strict-round-01.ll +++ 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ %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 @@ %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 @@ %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 @@ %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 } Index: llvm/test/CodeGen/SystemZ/vec-strict-round-02.ll =================================================================== --- llvm/test/CodeGen/SystemZ/vec-strict-round-02.ll +++ 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ %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 @@ %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 @@ %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 @@ %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 } Index: llvm/test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll =================================================================== --- llvm/test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll +++ llvm/test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll @@ -4619,7 +4619,6 @@ entry: %max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32( <1 x float> , <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <1 x float> %max } @@ -4680,7 +4679,6 @@ %max = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64( <2 x double> , <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <2 x double> %max } @@ -4768,7 +4766,6 @@ %max = call <3 x float> @llvm.experimental.constrained.maxnum.v3f32( <3 x float> , <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x float> %max } @@ -4859,7 +4856,6 @@ %max = call <3 x double> @llvm.experimental.constrained.maxnum.v3f64( <3 x double> %b, <3 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 store <3 x double> %max, <3 x double>* %a ret void @@ -4962,7 +4958,6 @@ double 46.0, double 47.0>, <4 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <4 x double> %max } @@ -5002,7 +4997,6 @@ entry: %min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32( <1 x float> , <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <1 x float> %min } @@ -5063,7 +5057,6 @@ %min = call <2 x double> @llvm.experimental.constrained.minnum.v2f64( <2 x double> , <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <2 x double> %min } @@ -5151,7 +5144,6 @@ %min = call <3 x float> @llvm.experimental.constrained.minnum.v3f32( <3 x float> , <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x float> %min } @@ -5246,7 +5238,6 @@ %min = call <3 x double> @llvm.experimental.constrained.minnum.v3f64( <3 x double> %b, <3 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 store <3 x double> %min, <3 x double>* %a ret void @@ -5349,7 +5340,6 @@ double 46.0, double 47.0>, <4 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <4 x double> %min } @@ -5629,7 +5619,6 @@ entry: %ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32( <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <1 x float> %ceil } @@ -5667,7 +5656,6 @@ entry: %ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64( <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <2 x double> %ceil } @@ -5722,7 +5710,6 @@ entry: %ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32( <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x float> %ceil } @@ -5775,7 +5762,6 @@ %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 @@ entry: %floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32( <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <1 x float> %floor } @@ -5843,7 +5828,6 @@ entry: %floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64( <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <2 x double> %floor } @@ -5898,7 +5882,6 @@ entry: %floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32( <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x float> %floor } @@ -5951,7 +5934,6 @@ %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 @@ entry: %round = call <1 x float> @llvm.experimental.constrained.round.v1f32( <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <1 x float> %round } @@ -6018,7 +5999,6 @@ entry: %round = call <2 x double> @llvm.experimental.constrained.round.v2f64( <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <2 x double> %round } @@ -6073,7 +6053,6 @@ entry: %round = call <3 x float> @llvm.experimental.constrained.round.v3f32( <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x float> %round } @@ -6127,7 +6106,6 @@ %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 @@ entry: %trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32( <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <1 x float> %trunc } @@ -6194,7 +6171,6 @@ entry: %trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64( <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <2 x double> %trunc } @@ -6249,7 +6225,6 @@ entry: %trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32( <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x float> %trunc } @@ -6302,7 +6277,6 @@ %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.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.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 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.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) Index: llvm/test/CodeGen/X86/fp128-libcalls-strict.ll =================================================================== --- llvm/test/CodeGen/X86/fp128-libcalls-strict.ll +++ llvm/test/CodeGen/X86/fp128-libcalls-strict.ll @@ -322,7 +322,7 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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 @@ ; 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.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) Index: llvm/test/CodeGen/X86/vector-constrained-fp-intrinsics.ll =================================================================== --- llvm/test/CodeGen/X86/vector-constrained-fp-intrinsics.ll +++ llvm/test/CodeGen/X86/vector-constrained-fp-intrinsics.ll @@ -3373,7 +3373,6 @@ entry: %max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32( <1 x float> , <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <1 x float> %max } @@ -3416,7 +3415,6 @@ %max = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64( <2 x double> , <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <2 x double> %max } @@ -3472,7 +3470,6 @@ %max = call <3 x float> @llvm.experimental.constrained.maxnum.v3f32( <3 x float> , <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x float> %max } @@ -3530,7 +3527,6 @@ %max = call <3 x double> @llvm.experimental.constrained.maxnum.v3f64( <3 x double> , <3 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x double> %max } @@ -3598,7 +3594,6 @@ double 46.0, double 47.0>, <4 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <4 x double> %max } @@ -3628,7 +3623,6 @@ entry: %min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32( <1 x float> , <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <1 x float> %min } @@ -3671,7 +3665,6 @@ %min = call <2 x double> @llvm.experimental.constrained.minnum.v2f64( <2 x double> , <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <2 x double> %min } @@ -3727,7 +3720,6 @@ %min = call <3 x float> @llvm.experimental.constrained.minnum.v3f32( <3 x float> , <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x float> %min } @@ -3785,7 +3777,6 @@ %min = call <3 x double> @llvm.experimental.constrained.minnum.v3f64( <3 x double> , <3 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x double> %min } @@ -3853,7 +3844,6 @@ double 46.0, double 47.0>, <4 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <4 x double> %min } @@ -5244,7 +5234,6 @@ entry: %ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32( <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <1 x float> %ceil } @@ -5272,7 +5261,6 @@ entry: %ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64( <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <2 x double> %ceil } @@ -5313,7 +5301,6 @@ entry: %ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32( <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x float> %ceil } @@ -5351,7 +5338,6 @@ entry: %ceil = call <3 x double> @llvm.experimental.constrained.ceil.v3f64( <3 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x double> %ceil } @@ -5375,7 +5361,6 @@ entry: %floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32( <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <1 x float> %floor } @@ -5404,7 +5389,6 @@ entry: %floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64( <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <2 x double> %floor } @@ -5445,7 +5429,6 @@ entry: %floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32( <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x float> %floor } @@ -5483,7 +5466,6 @@ entry: %floor = call <3 x double> @llvm.experimental.constrained.floor.v3f64( <3 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x double> %floor } @@ -5511,7 +5493,6 @@ entry: %round = call <1 x float> @llvm.experimental.constrained.round.v1f32( <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <1 x float> %round } @@ -5549,7 +5530,6 @@ entry: %round = call <2 x double> @llvm.experimental.constrained.round.v2f64( <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <2 x double> %round } @@ -5598,7 +5578,6 @@ entry: %round = call <3 x float> @llvm.experimental.constrained.round.v3f32( <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x float> %round } @@ -5650,7 +5629,6 @@ entry: %round = call <3 x double> @llvm.experimental.constrained.round.v3f64( <3 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x double> %round } @@ -5674,7 +5652,6 @@ entry: %trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32( <1 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <1 x float> %trunc } @@ -5702,7 +5679,6 @@ entry: %trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64( <2 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <2 x double> %trunc } @@ -5743,7 +5719,6 @@ entry: %trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32( <3 x float> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x float> %trunc } @@ -5781,7 +5756,6 @@ entry: %trunc = call <3 x double> @llvm.experimental.constrained.trunc.v3f64( <3 x double> , - metadata !"round.dynamic", metadata !"fpexcept.strict") #0 ret <3 x double> %trunc } @@ -5806,8 +5780,8 @@ 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) @@ -5818,10 +5792,10 @@ 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) ; Scalar width declarations declare <1 x float> @llvm.experimental.constrained.fadd.v1f32(<1 x float>, <1 x float>, metadata, metadata) @@ -5841,8 +5815,8 @@ 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) @@ -5853,10 +5827,10 @@ 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) ; Illegal width declarations declare <3 x float> @llvm.experimental.constrained.fadd.v3f32(<3 x float>, <3 x float>, metadata, metadata) @@ -5893,10 +5867,10 @@ 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) @@ -5907,14 +5881,14 @@ 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) ; Double width declarations declare <4 x double> @llvm.experimental.constrained.fadd.v4f64(<4 x double>, <4 x double>, metadata, metadata) @@ -5934,8 +5908,8 @@ 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) @@ -5946,7 +5920,7 @@ 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)