[FPEnv] Remove unnecessary rounding mode argument for constrained intrinsics

[uweigand]

Summary

The following intrinsics currently carry a rounding mode metadata argument:

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

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

[kpn]

I think this is a good idea.

Random thought: Do we need to document which version of 754 this conforms to?

[craig.topper]

I've also been wondering if we should drop rounding from ceil, floor, trunc, and round. Looks like lround/llround don't have rounding.

[uweigand]

In D71218#1775689, @kpn wrote:

Random thought: Do we need to document which version of 754 this conforms to?

This seems to be a much more complicated topic than I expected, there are different versions of IEEE 754 and different versions of the C standard and different implementations in various libc versions, and none of them completely agree with each other ... In any case, to avoid duplication we probably should only say the the constrained version follows the same semantics as the "regular" LLVM intrinsics.

[uweigand]

In D71218#1775695, @craig.topper wrote:

I've also been wondering if we should drop rounding from ceil, floor, trunc, and round. Looks like lround/llround don't have rounding.

Yes, I think it is probably best to only have the rounding mode argument for those functions that actually depend on the current rounding mode. I can remove it from those four as well.

[uweigand]

Updated to accommodate upstream changes in clang and the IRBuilder.

[uweigand]

Ping

[craig.topper]

LGTM

clang/test/CodeGen/constrained-math-builtins.c

// CHECK: declare x86_fp80 @llvm.experimental.constrained.pow.f80(x86_fp80, x86_fp80, metadata, metadata)
   __builtin_powi(f,f);        __builtin_powif(f,f);       __builtin_powil(f,f);
 
 // CHECK: declare double @llvm.experimental.constrained.powi.f64(double, i32, metadata, metadata)
 // CHECK: declare float @llvm.experimental.constrained.powi.f32(float, i32, metadata, metadata)
 // CHECK: declare x86_fp80 @llvm.experimental.constrained.powi.f80(x86_fp80, i32, metadata, metadata)
 
   __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); 
 
 // CHECK: declare double @llvm.experimental.constrained.cos.f64(double, metadata, metadata)
 // CHECK: declare float @llvm.experimental.constrained.cos.f32(float, metadata, metadata)
 // CHECK: declare x86_fp80 @llvm.experimental.constrained.cos.f80(x86_fp80, metadata, metadata)
 
   __builtin_exp(f);        __builtin_expf(f);       __builtin_expl(f);
 
 // CHECK: declare double @llvm.experimental.constrained.exp.f64(double, metadata, metadata)
 // CHECK: declare float @llvm.experimental.constrained.exp.f32(float, metadata, metadata)
 // CHECK: declare x86_fp80 @llvm.experimental.constrained.exp.f80(x86_fp80, metadata, metadata)
 
   __builtin_exp2(f);       __builtin_exp2f(f);      __builtin_exp2l(f); 
 
 // CHECK: declare double @llvm.experimental.constrained.exp2.f64(double, metadata, metadata)
 // CHECK: declare float @llvm.experimental.constrained.exp2.f32(float, metadata, metadata)
 // CHECK: declare x86_fp80 @llvm.experimental.constrained.exp2.f80(x86_fp80, metadata, metadata)
 
   __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);
 
 // CHECK: declare double @llvm.experimental.constrained.fma.f64(double, double, double, metadata, metadata)
 // CHECK: declare float @llvm.experimental.constrained.fma.f32(float, float, float, metadata, metadata)
 // CHECK: declare x86_fp80 @llvm.experimental.constrained.fma.f80(x86_fp80, x86_fp80, x86_fp80, metadata, metadata)
 
   __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);
 
 // CHECK: declare i64 @llvm.experimental.constrained.llrint.i64.f64(double, metadata, metadata)
 // CHECK: declare i64 @llvm.experimental.constrained.llrint.i64.f32(float, metadata, metadata)
 // CHECK: declare i64 @llvm.experimental.constrained.llrint.i64.f80(x86_fp80, metadata, metadata)
 
   __builtin_llround(f);    __builtin_llroundf(f);   __builtin_llroundl(f);
// CHECK: declare x86_fp80 @llvm.experimental.constrained.nearbyint.f80(x86_fp80, metadata, metadata)
   __builtin_rint(f);       __builtin_rintf(f);      __builtin_rintl(f);
 
 // CHECK: declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
 // CHECK: declare float @llvm.experimental.constrained.rint.f32(float, metadata, metadata)
 // CHECK: declare x86_fp80 @llvm.experimental.constrained.rint.f80(x86_fp80, metadata, metadata)
 
   __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);
 
 // CHECK: declare double @llvm.experimental.constrained.sin.f64(double, metadata, metadata)
 // CHECK: declare float @llvm.experimental.constrained.sin.f32(float, metadata, metadata)
 // CHECK: declare x86_fp80 @llvm.experimental.constrained.sin.f80(x86_fp80, metadata, metadata)
 
   __builtin_sqrt(f);       __builtin_sqrtf(f);      __builtin_sqrtl(f); 
 
 // CHECK: declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata)
 // CHECK: declare float @llvm.experimental.constrained.sqrt.f32(float, metadata, metadata)
 // CHECK: declare x86_fp80 @llvm.experimental.constrained.sqrt.f80(x86_fp80, metadata, metadata)
 
   __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)
 };
 

llvm/docs/LangRef.rst

 
 Syntax:
 """""""
 
 ::
 
       declare <type>
       @llvm.experimental.constrained.maxnum(<type> <op1>, <type> <op2>
-                                            metadata <rounding mode>,
                                             metadata <exception behavior>)
 
 Overview:
 """""""""
 
 The '``llvm.experimental.constrained.maxnum``' intrinsic returns the maximum
 of the two arguments.
 
 Arguments:
 """"""""""
 
 The first two arguments and the return value are floating-point numbers
 of the same type.
 
-The third and forth arguments specify the rounding mode and exception
-behavior as described above.
+The third argument specifies the exception behavior as described above.
 
 Semantics:
 """"""""""
 
-This function follows the IEEE-754 semantics for maxNum. The rounding mode is
-described, not determined, by the rounding mode argument. The actual rounding
-mode is determined by the runtime floating-point environment. The rounding
-mode argument is only intended as information to the compiler.
+This function follows the IEEE-754 semantics for maxNum.
 
 
 '``llvm.experimental.constrained.minnum``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
       declare <type>
       @llvm.experimental.constrained.minnum(<type> <op1>, <type> <op2>
-                                            metadata <rounding mode>,
                                             metadata <exception behavior>)
 
 Overview:
 """""""""
 
 The '``llvm.experimental.constrained.minnum``' intrinsic returns the minimum
 of the two arguments.
 
 Arguments:
 """"""""""
 
 The first two arguments and the return value are floating-point numbers
 of the same type.
 
-The third and forth arguments specify the rounding mode and exception
-behavior as described above.
+The third argument specifies the exception behavior as described above.
 
 Semantics:
 """"""""""
 
-This function follows the IEEE-754 semantics for minNum. The rounding mode is
-described, not determined, by the rounding mode argument. The actual rounding
-mode is determined by the runtime floating-point environment. The rounding
-mode argument is only intended as information to the compiler.
+This function follows the IEEE-754 semantics for minNum.
 
 
 '``llvm.experimental.constrained.ceil``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
       declare <type>
       @llvm.experimental.constrained.ceil(<type> <op1>,
-                                          metadata <rounding mode>,
                                           metadata <exception behavior>)
 
 Overview:
 """""""""
 
 The '``llvm.experimental.constrained.ceil``' intrinsic returns the ceiling of the
 first operand.
 
 Arguments:
 """"""""""
 
 The first argument and the return value are floating-point numbers of the same
 type.
 
-The second and third arguments specify the rounding mode and exception
-behavior as described above. The rounding mode is currently unused for this
-intrinsic.
+The second argument specifies the exception behavior as described above.
 
 Semantics:
 """"""""""
 
 This function returns the same values as the libm ``ceil`` functions
 would and handles error conditions in the same way.
 
 
 '``llvm.experimental.constrained.floor``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
       declare <type>
       @llvm.experimental.constrained.floor(<type> <op1>,
-                                           metadata <rounding mode>,
                                            metadata <exception behavior>)
 
 Overview:
 """""""""
 
 The '``llvm.experimental.constrained.floor``' intrinsic returns the floor of the
 first operand.
 
 Arguments:
 """"""""""
 
 The first argument and the return value are floating-point numbers of the same
 type.
 
-The second and third arguments specify the rounding mode and exception
-behavior as described above. The rounding mode is currently unused for this
-intrinsic.
+The second argument specifies the exception behavior as described above.
 
 Semantics:
 """"""""""
 
 This function returns the same values as the libm ``floor`` functions
 would and handles error conditions in the same way.
 
 
 '``llvm.experimental.constrained.round``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
       declare <type>
       @llvm.experimental.constrained.round(<type> <op1>,
-                                           metadata <rounding mode>,
                                            metadata <exception behavior>)
 
 Overview:
 """""""""
 
 The '``llvm.experimental.constrained.round``' intrinsic returns the first
 operand rounded to the nearest integer.
 
 Arguments:
 """"""""""
 
 The first argument and the return value are floating-point numbers of the same
 type.
 
-The second and third arguments specify the rounding mode and exception
-behavior as described above. The rounding mode is currently unused for this
-intrinsic.
+The second argument specifies the exception behavior as described above.
 
 Semantics:
 """"""""""
 
 This function returns the same values as the libm ``round`` functions
 would and handles error conditions in the same way.
 
 

 
 Syntax:
 """""""
 
 ::
 
       declare <type>
       @llvm.experimental.constrained.trunc(<type> <op1>,
-                                           metadata <truncing mode>,
                                            metadata <exception behavior>)
 
 Overview:
 """""""""
 
 The '``llvm.experimental.constrained.trunc``' intrinsic returns the first
 operand rounded to the nearest integer not larger in magnitude than the
 operand.
 
 Arguments:
 """"""""""
 
 The first argument and the return value are floating-point numbers of the same
 type.
 
-The second and third arguments specify the truncing mode and exception
-behavior as described above. The truncing mode is currently unused for this
-intrinsic.
+The second argument specifies the exception behavior as described above.
 
 Semantics:
 """"""""""
 
 This function returns the same values as the libm ``trunc`` functions
 would and handles error conditions in the same way.
 
 

llvm/include/llvm/IR/ConstrainedOps.def

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

llvm/include/llvm/IR/IRBuilder.h

CallInst *CreateConstrainedFPCast(
       Optional<fp::ExceptionBehavior> Except = None) {
     Value *ExceptV = getConstrainedFPExcept(Except);
 
     FastMathFlags UseFMF = FMF;
     if (FMFSource)
       UseFMF = FMFSource->getFastMathFlags();
 
     CallInst *C;
+    bool HasRoundingMD = false;
     switch (ID) {
-    default: {
+    default:
+      break;
+#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)  \
+    case Intrinsic::INTRINSIC:                                \
+      HasRoundingMD = ROUND_MODE;                             \
+      break;
+#include "llvm/IR/ConstrainedOps.def"
+    }
+    if (HasRoundingMD) {
       Value *RoundingV = getConstrainedFPRounding(Rounding);
       C = CreateIntrinsic(ID, {DestTy, V->getType()}, {V, RoundingV, ExceptV},
                           nullptr, Name);
-    } break;
-    case Intrinsic::experimental_constrained_fpext:
-    case Intrinsic::experimental_constrained_fptoui:
-    case Intrinsic::experimental_constrained_fptosi:
-    case Intrinsic::experimental_constrained_lround:
-    case Intrinsic::experimental_constrained_llround:
+    } else
       C = CreateIntrinsic(ID, {DestTy, V->getType()}, {V, ExceptV}, nullptr,
                           Name);
-      break;
-    }
+
     setConstrainedFPCallAttr(C);
 
     if (isa<FPMathOperator>(C))
       setFPAttrs(C, FPMathTag, UseFMF);
     return C;
   }
 
   // Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a
CallInst *CreateConstrainedFPCall(
       Value *Callee, ArrayRef<Value *> Args, const Twine &Name = "",
       Optional<fp::RoundingMode> Rounding = None,
       Optional<fp::ExceptionBehavior> Except = None) {
     llvm::SmallVector<Value *, 6> UseArgs;
 
     for (auto *OneArg : Args)
       UseArgs.push_back(OneArg);
     Function *F = cast<Function>(Callee);
+    bool HasRoundingMD = false;
     switch (F->getIntrinsicID()) {
     default:
-      UseArgs.push_back(getConstrainedFPRounding(Rounding));
       break;
-    case Intrinsic::experimental_constrained_fpext:
-    case Intrinsic::experimental_constrained_fptoui:
-    case Intrinsic::experimental_constrained_fptosi:
-    case Intrinsic::experimental_constrained_lround:
-    case Intrinsic::experimental_constrained_llround:
-      // No rounding metadata for these intrinsics.
+#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)  \
+    case Intrinsic::INTRINSIC:                                \
+      HasRoundingMD = ROUND_MODE;                             \
       break;
+#include "llvm/IR/ConstrainedOps.def"
     }
+    if (HasRoundingMD)
+      UseArgs.push_back(getConstrainedFPRounding(Rounding));
     UseArgs.push_back(getConstrainedFPExcept(Except));
 
     CallInst *C = CreateCall(
         cast<FunctionType>(Callee->getType()->getPointerElementType()), Callee,
         UseArgs, Name);
     setConstrainedFPCallAttr(C);
     return C;
   }

llvm/include/llvm/IR/Intrinsics.td

def int_experimental_constrained_lrint : Intrinsic<[ llvm_anyint_ty ],
                                                        llvm_metadata_ty ]>;
   def int_experimental_constrained_llrint : Intrinsic<[ llvm_anyint_ty ],
                                                       [ llvm_anyfloat_ty,
                                                         llvm_metadata_ty,
                                                         llvm_metadata_ty ]>;
   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,
                                                         llvm_metadata_ty ]>;
   def int_experimental_constrained_llround : Intrinsic<[ llvm_anyint_ty ],
                                                        [ llvm_anyfloat_ty,
                                                          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).
   // Third operand is the predicate represented as a metadata string.
   def int_experimental_constrained_fcmp
       : Intrinsic<[ LLVMScalarOrSameVectorWidth<0, llvm_i1_ty> ],
                   [ llvm_anyfloat_ty, LLVMMatchType<0>,
                     llvm_metadata_ty, llvm_metadata_ty ]>;

llvm/test/CodeGen/ARM/fp-intrinsics.ll

define i32 @llrint_f32(float %x) #0 {
   %val = call i32 @llvm.experimental.constrained.llrint.f32(float %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
   ret i32 %val
 }
 
 ; CHECK-LABEL: maxnum_f32:
 ; 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
 }
 
 ; CHECK-LABEL: minnum_f32:
 ; 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
 }
 
 ; CHECK-LABEL: ceil_f32:
 ; 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
 }
 
 ; CHECK-LABEL: floor_f32:
 ; 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
 }
 
 ; CHECK-LABEL: lround_f32:
 ; CHECK: bl lroundf
 define i32 @lround_f32(float %x) #0 {
   %val = call i32 @llvm.experimental.constrained.lround.f32(float %x, metadata !"fpexcept.strict") #0
   ret i32 %val
 }
 
 ; CHECK-LABEL: llround_f32:
 ; CHECK: bl llroundf
 define i32 @llround_f32(float %x) #0 {
   %val = call i32 @llvm.experimental.constrained.llround.f32(float %x, metadata !"fpexcept.strict") #0
   ret i32 %val
 }
 
 ; CHECK-LABEL: round_f32:
 ; 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
 }
 
 ; CHECK-LABEL: trunc_f32:
 ; 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
 }
 
 
 ; Double-precision intrinsics
 
 ; CHECK-LABEL: add_f64:
 ; CHECK-NODP: bl __aeabi_dadd
define i32 @llrint_f64(double %x) #0 {
   %val = call i32 @llvm.experimental.constrained.llrint.f64(double %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
   ret i32 %val
 }
 
 ; CHECK-LABEL: maxnum_f64:
 ; 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
 }
 
 ; CHECK-LABEL: minnum_f64:
 ; 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
 }
 
 ; CHECK-LABEL: ceil_f64:
 ; 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
 }
 
 ; CHECK-LABEL: floor_f64:
 ; 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
 }
 
 ; CHECK-LABEL: lround_f64:
 ; CHECK: bl lround
 define i32 @lround_f64(double %x) #0 {
   %val = call i32 @llvm.experimental.constrained.lround.f64(double %x, metadata !"fpexcept.strict") #0
   ret i32 %val
 }
 
 ; CHECK-LABEL: llround_f64:
 ; CHECK: bl llround
 define i32 @llround_f64(double %x) #0 {
   %val = call i32 @llvm.experimental.constrained.llround.f64(double %x, metadata !"fpexcept.strict") #0
   ret i32 %val
 }
 
 ; CHECK-LABEL: round_f64:
 ; 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
 }
 
 ; CHECK-LABEL: trunc_f64:
 ; 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
 }
 
 
 ; Single/Double conversion intrinsics
 
 ; CHECK-LABEL: fptrunc_f32:
 ; CHECK-NODP: bl __aeabi_d2f

 declare float @llvm.experimental.constrained.log10.f32(float, metadata, metadata)
 declare float @llvm.experimental.constrained.log2.f32(float, metadata, metadata)
 declare float @llvm.experimental.constrained.exp.f32(float, metadata, metadata)
 declare float @llvm.experimental.constrained.exp2.f32(float, metadata, metadata)
 declare float @llvm.experimental.constrained.rint.f32(float, metadata, metadata)
 declare float @llvm.experimental.constrained.nearbyint.f32(float, metadata, metadata)
 declare i32 @llvm.experimental.constrained.lrint.f32(float, metadata, metadata)
 declare i32 @llvm.experimental.constrained.llrint.f32(float, metadata, metadata)
-declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata, metadata)
-declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata, metadata)
-declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
-declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata)
+declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata)
+declare float @llvm.experimental.constrained.ceil.f32(float, metadata)
+declare float @llvm.experimental.constrained.floor.f32(float, metadata)
 declare i32 @llvm.experimental.constrained.lround.f32(float, metadata)
 declare i32 @llvm.experimental.constrained.llround.f32(float, metadata)
-declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
-declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.round.f32(float, metadata)
+declare float @llvm.experimental.constrained.trunc.f32(float, metadata)
 
 declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
 declare double @llvm.experimental.constrained.fsub.f64(double, double, metadata, metadata)
 declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata)
 declare double @llvm.experimental.constrained.fdiv.f64(double, double, metadata, metadata)
 declare double @llvm.experimental.constrained.frem.f64(double, double, metadata, metadata)
 declare double @llvm.experimental.constrained.fma.f64(double, double, double, metadata, metadata)
 declare i32 @llvm.experimental.constrained.fptosi.f64(double, metadata)
 declare i32 @llvm.experimental.constrained.fptoui.f64(double, metadata)
 declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.powi.f64(double, i32, metadata, metadata)
 declare double @llvm.experimental.constrained.sin.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.cos.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.pow.f64(double, double, metadata, metadata)
 declare double @llvm.experimental.constrained.log.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.log10.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.log2.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.exp.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.exp2.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
 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)

llvm/test/CodeGen/PowerPC/ppcf128-constrained-fp-intrinsics.ll

 ; PC64-NEXT:    addi 1, 1, 112
 ; PC64-NEXT:    ld 0, 16(1)
 ; PC64-NEXT:    mtlr 0
 ; PC64-NEXT:    blr
 entry:
   %maxnum = call ppc_fp128 @llvm.experimental.constrained.maxnum.ppcf128(
                     ppc_fp128 %first,
                     ppc_fp128 %second,
-                    metadata !"round.dynamic",
                     metadata !"fpexcept.strict")
   ret ppc_fp128 %maxnum
 }
 
 define ppc_fp128 @test_minnum_ppc_fp128(ppc_fp128 %first, ppc_fp128 %second) nounwind {
 ; PC64LE-LABEL: test_minnum_ppc_fp128:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    mflr 0

 ; PC64-NEXT:    addi 1, 1, 112
 ; PC64-NEXT:    ld 0, 16(1)
 ; PC64-NEXT:    mtlr 0
 ; PC64-NEXT:    blr
 entry:
   %minnum = call ppc_fp128 @llvm.experimental.constrained.minnum.ppcf128(
                     ppc_fp128 %first,
                     ppc_fp128 %second,
-                    metadata !"round.dynamic",
                     metadata !"fpexcept.strict")
   ret ppc_fp128 %minnum
 }
 
 define ppc_fp128 @test_ceil_ppc_fp128(ppc_fp128 %first) nounwind {
 ; PC64LE-LABEL: test_ceil_ppc_fp128:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    mflr 0

 ; PC64-NEXT:    nop
 ; PC64-NEXT:    addi 1, 1, 112
 ; PC64-NEXT:    ld 0, 16(1)
 ; PC64-NEXT:    mtlr 0
 ; PC64-NEXT:    blr
 entry:
   %ceil = call ppc_fp128 @llvm.experimental.constrained.ceil.ppcf128(
                     ppc_fp128 %first,
-                    metadata !"round.dynamic",
                     metadata !"fpexcept.strict")
   ret ppc_fp128 %ceil
 }
 
 define ppc_fp128 @test_floor_ppc_fp128(ppc_fp128 %first) nounwind {
 ; PC64LE-LABEL: test_floor_ppc_fp128:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    mflr 0

 ; PC64-NEXT:    nop
 ; PC64-NEXT:    addi 1, 1, 112
 ; PC64-NEXT:    ld 0, 16(1)
 ; PC64-NEXT:    mtlr 0
 ; PC64-NEXT:    blr
 entry:
   %floor = call ppc_fp128 @llvm.experimental.constrained.floor.ppcf128(
                     ppc_fp128 %first,
-                    metadata !"round.dynamic",
                     metadata !"fpexcept.strict")
   ret ppc_fp128 %floor
 }
 
 define ppc_fp128 @test_round_ppc_fp128(ppc_fp128 %first) nounwind {
 ; PC64LE-LABEL: test_round_ppc_fp128:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    mflr 0

 ; PC64-NEXT:    nop
 ; PC64-NEXT:    addi 1, 1, 112
 ; PC64-NEXT:    ld 0, 16(1)
 ; PC64-NEXT:    mtlr 0
 ; PC64-NEXT:    blr
 entry:
   %round = call ppc_fp128 @llvm.experimental.constrained.round.ppcf128(
                     ppc_fp128 %first,
-                    metadata !"round.dynamic",
                     metadata !"fpexcept.strict")
   ret ppc_fp128 %round
 }
 
 define ppc_fp128 @test_trunc_ppc_fp128(ppc_fp128 %first) nounwind {
 ; PC64LE-LABEL: test_trunc_ppc_fp128:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    mflr 0

 ; PC64-NEXT:    nop
 ; PC64-NEXT:    addi 1, 1, 112
 ; PC64-NEXT:    ld 0, 16(1)
 ; PC64-NEXT:    mtlr 0
 ; PC64-NEXT:    blr
 entry:
   %trunc = call ppc_fp128 @llvm.experimental.constrained.trunc.ppcf128(
                     ppc_fp128 %first,
-                    metadata !"round.dynamic",
                     metadata !"fpexcept.strict")
   ret ppc_fp128 %trunc
 }
 
 define float @test_fptrunc_ppc_fp128_f32(ppc_fp128 %first) nounwind {
 ; PC64LE-LABEL: test_fptrunc_ppc_fp128_f32:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    frsp 1, 1
%tinypow = call float @llvm.experimental.constrained.fptrunc.ppcf128.f32(
                     metadata !"fpexcept.strict")
   store float %tinypow, float* %firstptr
   %stridxn1 = getelementptr ppc_fp128, ppc_fp128* %result, i32 -1
   store ppc_fp128 %powi, ppc_fp128* %stridxn1
   ret void
 }
 
 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)
 declare float @llvm.experimental.constrained.fptrunc.ppcf128.f32(ppc_fp128, metadata, metadata)
 declare double @llvm.experimental.constrained.fptrunc.ppcf128.f64(ppc_fp128, metadata, metadata)
 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)
 declare i32 @llvm.experimental.constrained.fptoui.i32.ppcf128(ppc_fp128, metadata)

llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll

 ; PC64LE9-NEXT:    xxsldwi 34, 0, 0, 1
 ; PC64LE9-NEXT:    addi 1, 1, 32
 ; PC64LE9-NEXT:    ld 0, 16(1)
 ; PC64LE9-NEXT:    mtlr 0
 ; PC64LE9-NEXT:    blr
 entry:
   %max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32(
                                <1 x float> <float 42.0>, <1 x float> <float 41.0>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #1
   ret <1 x float> %max
 }
 
 define <2 x double> @constrained_vector_maxnum_v2f64() #0 {
 ; PC64LE-LABEL: constrained_vector_maxnum_v2f64:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    mflr 0

 ; PC64LE9-NEXT:    addi 1, 1, 48
 ; PC64LE9-NEXT:    ld 0, 16(1)
 ; PC64LE9-NEXT:    mtlr 0
 ; PC64LE9-NEXT:    blr
 entry:
   %max = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64(
                                 <2 x double> <double 43.0, double 42.0>,
                                 <2 x double> <double 41.0, double 40.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <2 x double> %max
 }
 
 define <3 x float> @constrained_vector_maxnum_v3f32() #0 {
 ; PC64LE-LABEL: constrained_vector_maxnum_v3f32:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    mflr 0

 ; PC64LE9-NEXT:    lfd 31, -8(1) # 8-byte Folded Reload
 ; PC64LE9-NEXT:    lfd 30, -16(1) # 8-byte Folded Reload
 ; PC64LE9-NEXT:    lfd 29, -24(1) # 8-byte Folded Reload
 ; PC64LE9-NEXT:    blr
 entry:
   %max = call <3 x float> @llvm.experimental.constrained.maxnum.v3f32(
                               <3 x float> <float 43.0, float 44.0, float 45.0>,
                               <3 x float> <float 41.0, float 42.0, float 43.0>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #1
   ret <3 x float> %max
 }
 
 define <3 x double> @constrained_vector_max_v3f64() #0 {
 ; PC64LE-LABEL: constrained_vector_max_v3f64:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    mflr 0

 ; PC64LE9-NEXT:    addi 1, 1, 64
 ; PC64LE9-NEXT:    ld 0, 16(1)
 ; PC64LE9-NEXT:    mtlr 0
 ; PC64LE9-NEXT:    blr
 entry:
   %max = call <3 x double> @llvm.experimental.constrained.maxnum.v3f64(
                           <3 x double> <double 43.0, double 44.0, double 45.0>,
                           <3 x double> <double 40.0, double 41.0, double 42.0>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #1
   ret <3 x double> %max
 }
 
 define <4 x double> @constrained_vector_maxnum_v4f64() #0 {
 ; PC64LE-LABEL: constrained_vector_maxnum_v4f64:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    mflr 0

 ; PC64LE9-NEXT:    mtlr 0
 ; PC64LE9-NEXT:    blr
 entry:
   %max = call <4 x double> @llvm.experimental.constrained.maxnum.v4f64(
                                 <4 x double> <double 44.0, double 45.0,
                                               double 46.0, double 47.0>,
                                 <4 x double> <double 40.0, double 41.0,
                                               double 42.0, double 43.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <4 x double> %max
 }
 
 define <1 x float> @constrained_vector_minnum_v1f32() #0 {
 ; PC64LE-LABEL: constrained_vector_minnum_v1f32:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    mflr 0

 ; PC64LE9-NEXT:    xxsldwi 34, 0, 0, 1
 ; PC64LE9-NEXT:    addi 1, 1, 32
 ; PC64LE9-NEXT:    ld 0, 16(1)
 ; PC64LE9-NEXT:    mtlr 0
 ; PC64LE9-NEXT:    blr
  entry:
   %min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32(
                                <1 x float> <float 42.0>, <1 x float> <float 41.0>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #1
   ret <1 x float> %min
 }
 
 define <2 x double> @constrained_vector_minnum_v2f64() #0 {
 ; PC64LE-LABEL: constrained_vector_minnum_v2f64:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    mflr 0

 ; PC64LE9-NEXT:    addi 1, 1, 48
 ; PC64LE9-NEXT:    ld 0, 16(1)
 ; PC64LE9-NEXT:    mtlr 0
 ; PC64LE9-NEXT:    blr
 entry:
   %min = call <2 x double> @llvm.experimental.constrained.minnum.v2f64(
                                 <2 x double> <double 43.0, double 42.0>,
                                 <2 x double> <double 41.0, double 40.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <2 x double> %min
 }
 
 define <3 x float> @constrained_vector_minnum_v3f32() #0 {
 ; PC64LE-LABEL: constrained_vector_minnum_v3f32:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    mflr 0

 ; PC64LE9-NEXT:    lfd 31, -8(1) # 8-byte Folded Reload
 ; PC64LE9-NEXT:    lfd 30, -16(1) # 8-byte Folded Reload
 ; PC64LE9-NEXT:    lfd 29, -24(1) # 8-byte Folded Reload
 ; PC64LE9-NEXT:    blr
 entry:
   %min = call <3 x float> @llvm.experimental.constrained.minnum.v3f32(
                               <3 x float> <float 43.0, float 44.0, float 45.0>,
                               <3 x float> <float 41.0, float 42.0, float 43.0>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #1
   ret <3 x float> %min
 }
 
 define <3 x double> @constrained_vector_min_v3f64() #0 {
 ; PC64LE-LABEL: constrained_vector_min_v3f64:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    mflr 0

 ; PC64LE9-NEXT:    addi 1, 1, 64
 ; PC64LE9-NEXT:    ld 0, 16(1)
 ; PC64LE9-NEXT:    mtlr 0
 ; PC64LE9-NEXT:    blr
 entry:
  %min = call <3 x double> @llvm.experimental.constrained.minnum.v3f64(
                           <3 x double> <double 43.0, double 44.0, double 45.0>,
                           <3 x double> <double 40.0, double 41.0, double 42.0>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #1
   ret <3 x double> %min
 }
 
 define <4 x double> @constrained_vector_minnum_v4f64() #0 {
 ; PC64LE-LABEL: constrained_vector_minnum_v4f64:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    mflr 0

 ; PC64LE9-NEXT:    mtlr 0
 ; PC64LE9-NEXT:    blr
 entry:
   %min = call <4 x double> @llvm.experimental.constrained.minnum.v4f64(
                                 <4 x double> <double 44.0, double 45.0,
                                               double 46.0, double 47.0>,
                                 <4 x double> <double 40.0, double 41.0,
                                               double 42.0, double 43.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <4 x double> %min
 }
 
 define <1 x float> @constrained_vector_fptrunc_v1f64() #0 {
 ; PC64LE-LABEL: constrained_vector_fptrunc_v1f64:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    addis 3, 2, .LCPI95_0@toc@ha

 ; PC64LE9-NEXT:    lfs 0, .LCPI103_0@toc@l(3)
 ; PC64LE9-NEXT:    frip 0, 0
 ; PC64LE9-NEXT:    xscvdpspn 0, 0
 ; PC64LE9-NEXT:    xxsldwi 34, 0, 0, 1
 ; PC64LE9-NEXT:    blr
 entry:
   %ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #1
   ret <1 x float> %ceil
 }
 
 define <2 x double> @constrained_vector_ceil_v2f64() #0 {
 ; PC64LE-LABEL: constrained_vector_ceil_v2f64:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    addis 3, 2, .LCPI104_0@toc@ha
 ; PC64LE-NEXT:    addi 3, 3, .LCPI104_0@toc@l
 ; PC64LE-NEXT:    lxvd2x 0, 0, 3
 ; PC64LE-NEXT:    xxswapd 0, 0
 ; PC64LE-NEXT:    xvrdpip 34, 0
 ; PC64LE-NEXT:    blr
 ;
 ; PC64LE9-LABEL: constrained_vector_ceil_v2f64:
 ; PC64LE9:       # %bb.0: # %entry
 ; PC64LE9-NEXT:    addis 3, 2, .LCPI104_0@toc@ha
 ; PC64LE9-NEXT:    addi 3, 3, .LCPI104_0@toc@l
 ; PC64LE9-NEXT:    lxvx 0, 0, 3
 ; PC64LE9-NEXT:    xvrdpip 34, 0
 ; PC64LE9-NEXT:    blr
 entry:
   %ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <2 x double> %ceil
 }
 
 define <3 x float> @constrained_vector_ceil_v3f32() #0 {
 ; PC64LE-LABEL: constrained_vector_ceil_v3f32:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    addis 3, 2, .LCPI105_2@toc@ha

 ; PC64LE9-NEXT:    xxsldwi 34, 2, 2, 1
 ; PC64LE9-NEXT:    vmrglw 2, 3, 2
 ; PC64LE9-NEXT:    lxvx 35, 0, 3
 ; PC64LE9-NEXT:    vperm 2, 4, 2, 3
 ; PC64LE9-NEXT:    blr
 entry:
   %ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #1
   ret <3 x float> %ceil
 }
 
 define <3 x double> @constrained_vector_ceil_v3f64() #0 {
 ; PC64LE-LABEL: constrained_vector_ceil_v3f64:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    addis 3, 2, .LCPI106_1@toc@ha

 ; PC64LE9-NEXT:    xvrdpip 2, 0
 ; PC64LE9-NEXT:    xxswapd 1, 2
 ; PC64LE9-NEXT:    # kill: def $f1 killed $f1 killed $vsl1
 ; PC64LE9-NEXT:    # kill: def $f2 killed $f2 killed $vsl2
 ; PC64LE9-NEXT:    blr
 entry:
   %ceil = call <3 x double> @llvm.experimental.constrained.ceil.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #1
   ret <3 x double> %ceil
 }
 
 define <1 x float> @constrained_vector_floor_v1f32() #0 {
 ; PC64LE-LABEL: constrained_vector_floor_v1f32:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    addis 3, 2, .LCPI107_0@toc@ha

 ; PC64LE9-NEXT:    lfs 0, .LCPI107_0@toc@l(3)
 ; PC64LE9-NEXT:    frim 0, 0
 ; PC64LE9-NEXT:    xscvdpspn 0, 0
 ; PC64LE9-NEXT:    xxsldwi 34, 0, 0, 1
 ; PC64LE9-NEXT:    blr
 entry:
   %floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #1
   ret <1 x float> %floor
 }
 
 
 define <2 x double> @constrained_vector_floor_v2f64() #0 {
 ; PC64LE-LABEL: constrained_vector_floor_v2f64:
 ; PC64LE:       # %bb.0: # %entry

 ; PC64LE9-NEXT:    addis 3, 2, .LCPI108_0@toc@ha
 ; PC64LE9-NEXT:    addi 3, 3, .LCPI108_0@toc@l
 ; PC64LE9-NEXT:    lxvx 0, 0, 3
 ; PC64LE9-NEXT:    xvrdpim 34, 0
 ; PC64LE9-NEXT:    blr
 entry:
   %floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <2 x double> %floor
 }
 
 define <3 x float> @constrained_vector_floor_v3f32() #0 {
 ; PC64LE-LABEL: constrained_vector_floor_v3f32:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    addis 3, 2, .LCPI109_2@toc@ha

 ; PC64LE9-NEXT:    xxsldwi 34, 2, 2, 1
 ; PC64LE9-NEXT:    vmrglw 2, 3, 2
 ; PC64LE9-NEXT:    lxvx 35, 0, 3
 ; PC64LE9-NEXT:    vperm 2, 4, 2, 3
 ; PC64LE9-NEXT:    blr
 entry:
   %floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #1
   ret <3 x float> %floor
 }
 
 define <3 x double> @constrained_vector_floor_v3f64() #0 {
 ; PC64LE-LABEL: constrained_vector_floor_v3f64:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    addis 3, 2, .LCPI110_1@toc@ha

 ; PC64LE9-NEXT:    xvrdpim 2, 0
 ; PC64LE9-NEXT:    xxswapd 1, 2
 ; PC64LE9-NEXT:    # kill: def $f1 killed $f1 killed $vsl1
 ; PC64LE9-NEXT:    # kill: def $f2 killed $f2 killed $vsl2
 ; PC64LE9-NEXT:    blr
 entry:
   %floor = call <3 x double> @llvm.experimental.constrained.floor.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #1
   ret <3 x double> %floor
 }
 
 define <1 x float> @constrained_vector_round_v1f32() #0 {
 ; PC64LE-LABEL: constrained_vector_round_v1f32:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    addis 3, 2, .LCPI111_0@toc@ha

 ; PC64LE9-NEXT:    lfs 0, .LCPI111_0@toc@l(3)
 ; PC64LE9-NEXT:    frin 0, 0
 ; PC64LE9-NEXT:    xscvdpspn 0, 0
 ; PC64LE9-NEXT:    xxsldwi 34, 0, 0, 1
 ; PC64LE9-NEXT:    blr
 entry:
   %round = call <1 x float> @llvm.experimental.constrained.round.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #1
   ret <1 x float> %round
 }
 
 define <2 x double> @constrained_vector_round_v2f64() #0 {
 ; PC64LE-LABEL: constrained_vector_round_v2f64:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    addis 3, 2, .LCPI112_0@toc@ha
 ; PC64LE-NEXT:    addi 3, 3, .LCPI112_0@toc@l
 ; PC64LE-NEXT:    lxvd2x 0, 0, 3
 ; PC64LE-NEXT:    xxswapd 0, 0
 ; PC64LE-NEXT:    xvrdpi 34, 0
 ; PC64LE-NEXT:    blr
 ;
 ; PC64LE9-LABEL: constrained_vector_round_v2f64:
 ; PC64LE9:       # %bb.0: # %entry
 ; PC64LE9-NEXT:    addis 3, 2, .LCPI112_0@toc@ha
 ; PC64LE9-NEXT:    addi 3, 3, .LCPI112_0@toc@l
 ; PC64LE9-NEXT:    lxvx 0, 0, 3
 ; PC64LE9-NEXT:    xvrdpi 34, 0
 ; PC64LE9-NEXT:    blr
 entry:
   %round = call <2 x double> @llvm.experimental.constrained.round.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <2 x double> %round
 }
 
 define <3 x float> @constrained_vector_round_v3f32() #0 {
 ; PC64LE-LABEL: constrained_vector_round_v3f32:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    addis 3, 2, .LCPI113_2@toc@ha

 ; PC64LE9-NEXT:    xxsldwi 34, 2, 2, 1
 ; PC64LE9-NEXT:    vmrglw 2, 3, 2
 ; PC64LE9-NEXT:    lxvx 35, 0, 3
 ; PC64LE9-NEXT:    vperm 2, 4, 2, 3
 ; PC64LE9-NEXT:    blr
 entry:
   %round = call <3 x float> @llvm.experimental.constrained.round.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #1
   ret <3 x float> %round
 }
 
 
 define <3 x double> @constrained_vector_round_v3f64() #0 {
 ; PC64LE-LABEL: constrained_vector_round_v3f64:
 ; PC64LE:       # %bb.0: # %entry

 ; PC64LE9-NEXT:    xvrdpi 2, 0
 ; PC64LE9-NEXT:    xxswapd 1, 2
 ; PC64LE9-NEXT:    # kill: def $f1 killed $f1 killed $vsl1
 ; PC64LE9-NEXT:    # kill: def $f2 killed $f2 killed $vsl2
 ; PC64LE9-NEXT:    blr
 entry:
   %round = call <3 x double> @llvm.experimental.constrained.round.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #1
   ret <3 x double> %round
 }
 
 define <1 x float> @constrained_vector_trunc_v1f32() #0 {
 ; PC64LE-LABEL: constrained_vector_trunc_v1f32:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    addis 3, 2, .LCPI115_0@toc@ha

 ; PC64LE9-NEXT:    lfs 0, .LCPI115_0@toc@l(3)
 ; PC64LE9-NEXT:    friz 0, 0
 ; PC64LE9-NEXT:    xscvdpspn 0, 0
 ; PC64LE9-NEXT:    xxsldwi 34, 0, 0, 1
 ; PC64LE9-NEXT:    blr
 entry:
   %trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #1
   ret <1 x float> %trunc
 }
 
 define <2 x double> @constrained_vector_trunc_v2f64() #0 {
 ; PC64LE-LABEL: constrained_vector_trunc_v2f64:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    addis 3, 2, .LCPI116_0@toc@ha
 ; PC64LE-NEXT:    addi 3, 3, .LCPI116_0@toc@l
 ; PC64LE-NEXT:    lxvd2x 0, 0, 3
 ; PC64LE-NEXT:    xxswapd 0, 0
 ; PC64LE-NEXT:    xvrdpiz 34, 0
 ; PC64LE-NEXT:    blr
 ;
 ; PC64LE9-LABEL: constrained_vector_trunc_v2f64:
 ; PC64LE9:       # %bb.0: # %entry
 ; PC64LE9-NEXT:    addis 3, 2, .LCPI116_0@toc@ha
 ; PC64LE9-NEXT:    addi 3, 3, .LCPI116_0@toc@l
 ; PC64LE9-NEXT:    lxvx 0, 0, 3
 ; PC64LE9-NEXT:    xvrdpiz 34, 0
 ; PC64LE9-NEXT:    blr
 entry:
   %trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <2 x double> %trunc
 }
 
 define <3 x float> @constrained_vector_trunc_v3f32() #0 {
 ; PC64LE-LABEL: constrained_vector_trunc_v3f32:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    addis 3, 2, .LCPI117_2@toc@ha

 ; PC64LE9-NEXT:    xxsldwi 34, 2, 2, 1
 ; PC64LE9-NEXT:    vmrglw 2, 3, 2
 ; PC64LE9-NEXT:    lxvx 35, 0, 3
 ; PC64LE9-NEXT:    vperm 2, 4, 2, 3
 ; PC64LE9-NEXT:    blr
 entry:
   %trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #1
   ret <3 x float> %trunc
 }
 
 define <3 x double> @constrained_vector_trunc_v3f64() #0 {
 ; PC64LE-LABEL: constrained_vector_trunc_v3f64:
 ; PC64LE:       # %bb.0: # %entry
 ; PC64LE-NEXT:    addis 3, 2, .LCPI118_1@toc@ha

 ; PC64LE9-NEXT:    xvrdpiz 2, 0
 ; PC64LE9-NEXT:    xxswapd 1, 2
 ; PC64LE9-NEXT:    # kill: def $f1 killed $f1 killed $vsl1
 ; PC64LE9-NEXT:    # kill: def $f2 killed $f2 killed $vsl2
 ; PC64LE9-NEXT:    blr
 entry:
   %trunc = call <3 x double> @llvm.experimental.constrained.trunc.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #1
   ret <3 x double> %trunc
 }
 
 attributes #0 = { nounwind strictfp noimplicitfloat }
 attributes #1 = { strictfp }
 
 ; Single width declarations

 declare <2 x double> @llvm.experimental.constrained.cos.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.exp.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.exp2.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.log.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.log10.v2f64(<2 x double>, metadata, metadata)
 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)
 declare <1 x float> @llvm.experimental.constrained.fsub.v1f32(<1 x float>, <1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.fmul.v1f32(<1 x float>, <1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.fdiv.v1f32(<1 x float>, <1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.frem.v1f32(<1 x float>, <1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.sqrt.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.pow.v1f32(<1 x float>, <1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.powi.v1f32(<1 x float>, i32, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.sin.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.cos.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.exp.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.exp2.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.log.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.log10.v1f32(<1 x float>, metadata, metadata)
 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)
 declare <3 x double> @llvm.experimental.constrained.fadd.v3f64(<3 x double>, <3 x double>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.fsub.v3f32(<3 x float>, <3 x float>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.fsub.v3f64(<3 x double>, <3 x double>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.fmul.v3f32(<3 x float>, <3 x float>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.fmul.v3f64(<3 x double>, <3 x double>, metadata, metadata)

 declare <3 x float> @llvm.experimental.constrained.log10.v3f32(<3 x float>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.log10.v3f64(<3 x double>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.log2.v3f32(<3 x float>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.log2.v3f64(<3 x double>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.rint.v3f32(<3 x float>, metadata, metadata)
 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)
 declare <4 x double> @llvm.experimental.constrained.fsub.v4f64(<4 x double>, <4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.fmul.v4f64(<4 x double>, <4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.fdiv.v4f64(<4 x double>, <4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.frem.v4f64(<4 x double>, <4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.sqrt.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.pow.v4f64(<4 x double>, <4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.powi.v4f64(<4 x double>, i32, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.sin.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.cos.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.exp.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.exp2.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.log.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.log10.v4f64(<4 x double>, metadata, metadata)
 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)

llvm/test/CodeGen/SystemZ/fp-strict-round-01.ll

%res = call fp128 @llvm.experimental.constrained.nearbyint.f128(
                         fp128 %src,
                         metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
 }
 
 ; 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
 ; CHECK: br %r14
   %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
 ; CHECK: br %r14
   %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
 ; CHECK: br %r14
   %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
 ; CHECK: br %r14
   %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
 }
 
 attributes #0 = { strictfp }

llvm/test/CodeGen/SystemZ/fp-strict-round-02.ll

%res = call fp128 @llvm.experimental.constrained.nearbyint.f128(
                         fp128 %src,
                         metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
 }
 
 ; 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
 ; CHECK: br %r14
   %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
 ; CHECK: br %r14
   %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
 ; CHECK: br %r14
   %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
 ; CHECK: br %r14
   %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
 }
 
 attributes #0 = { strictfp }

llvm/test/CodeGen/SystemZ/fp-strict-round-03.ll

%res = call fp128 @llvm.experimental.constrained.nearbyint.f128(
                         fp128 %src,
                         metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
 }
 
 ; 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)
 ; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 4, 7
 ; CHECK: vst [[RES]], 0(%r2)
 ; CHECK: br %r14
   %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)
 ; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 4, 6
 ; CHECK: vst [[RES]], 0(%r2)
 ; CHECK: br %r14
   %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)
 ; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 4, 5
 ; CHECK: vst [[RES]], 0(%r2)
 ; CHECK: br %r14
   %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)
 ; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 4, 1
 ; CHECK: vst [[RES]], 0(%r2)
 ; CHECK: br %r14
   %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
 }
 
 attributes #0 = { strictfp }

llvm/test/CodeGen/SystemZ/vec-strict-max-01.ll

 ; Test strict vector maximum on z14.
 ;
 ; 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 {
 ; CHECK-LABEL: f1:
 ; CHECK: wfmaxdb %f0, %f2, %f4, 4
 ; 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
 }
 
 ; Test the v2f64 maxnum intrinsic.
 define <2 x double> @f2(<2 x double> %dummy, <2 x double> %val1,
                         <2 x double> %val2) #0 {
 ; CHECK-LABEL: f2:
 ; CHECK: vfmaxdb %v24, %v26, %v28, 4
 ; 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
 }
 
 ; Test the f32 maxnum intrinsic.
 define float @f3(float %dummy, float %val1, float %val2) #0 {
 ; CHECK-LABEL: f3:
 ; CHECK: wfmaxsb %f0, %f2, %f4, 4
 ; 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
 }
 
 ; Test the v4f32 maxnum intrinsic.
 define <4 x float> @f4(<4 x float> %dummy, <4 x float> %val1,
                        <4 x float> %val2) #0 {
 ; CHECK-LABEL: f4:
 ; CHECK: vfmaxsb %v24, %v26, %v28, 4
 ; 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
 }
 
 ; Test the f128 maxnum intrinsic.
 define void @f5(fp128 *%ptr1, fp128 *%ptr2, fp128 *%dst) #0 {
 ; CHECK-LABEL: f5:
 ; CHECK-DAG: vl [[REG1:%v[0-9]+]], 0(%r2)
 ; CHECK-DAG: vl [[REG2:%v[0-9]+]], 0(%r3)
 ; CHECK: wfmaxxb [[RES:%v[0-9]+]], [[REG1]], [[REG2]], 4
 ; CHECK: vst [[RES]], 0(%r4)
 ; CHECK: br %r14
   %val1 = load fp128, fp128* %ptr1
   %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
 }
 
 attributes #0 = { strictfp }

llvm/test/CodeGen/SystemZ/vec-strict-min-01.ll

 ; Test strict vector minimum on z14.
 ;
 ; 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 {
 ; CHECK-LABEL: f1:
 ; CHECK: wfmindb %f0, %f2, %f4, 4
 ; 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
 }
 
 ; Test the v2f64 minnum intrinsic.
 define <2 x double> @f2(<2 x double> %dummy, <2 x double> %val1,
                         <2 x double> %val2) #0 {
 ; CHECK-LABEL: f2:
 ; CHECK: vfmindb %v24, %v26, %v28, 4
 ; 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
 }
 
 ; Test the f32 minnum intrinsic.
 define float @f3(float %dummy, float %val1, float %val2) #0 {
 ; CHECK-LABEL: f3:
 ; CHECK: wfminsb %f0, %f2, %f4, 4
 ; 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
 }
 
 ; Test the v4f32 minnum intrinsic.
 define <4 x float> @f4(<4 x float> %dummy, <4 x float> %val1,
                        <4 x float> %val2) #0 {
 ; CHECK-LABEL: f4:
 ; CHECK: vfminsb %v24, %v26, %v28, 4
 ; 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
 }
 
 ; Test the f128 minnum intrinsic.
 define void @f5(fp128 *%ptr1, fp128 *%ptr2, fp128 *%dst) #0 {
 ; CHECK-LABEL: f5:
 ; CHECK-DAG: vl [[REG1:%v[0-9]+]], 0(%r2)
 ; CHECK-DAG: vl [[REG2:%v[0-9]+]], 0(%r3)
 ; CHECK: wfminxb [[RES:%v[0-9]+]], [[REG1]], [[REG2]], 4
 ; CHECK: vst [[RES]], 0(%r4)
 ; CHECK: br %r14
   %val1 = load fp128, fp128* %ptr1
   %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
 }
 
 attributes #0 = { strictfp }

llvm/test/CodeGen/SystemZ/vec-strict-round-01.ll

 ; Test strict v2f64 rounding.
 ;
 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z13 | FileCheck %s
 
 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:
 ; CHECK: vfidb %v24, %v24, 0, 0
 ; CHECK: br %r14
   %res = call <2 x double> @llvm.experimental.constrained.rint.v2f64(
                         <2 x double> %val,
                         metadata !"round.dynamic",

 }
 
 define <2 x double> @f3(<2 x double> %val) #0 {
 ; CHECK-LABEL: f3:
 ; CHECK: vfidb %v24, %v24, 4, 7
 ; 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
 }
 
 define <2 x double> @f4(<2 x double> %val) #0 {
 ; CHECK-LABEL: f4:
 ; CHECK: vfidb %v24, %v24, 4, 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
 }
 
 define <2 x double> @f5(<2 x double> %val) #0 {
 ; CHECK-LABEL: f5:
 ; CHECK: vfidb %v24, %v24, 4, 5
 ; 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
 }
 
 define <2 x double> @f6(<2 x double> %val) #0 {
 ; CHECK-LABEL: f6:
 ; CHECK: vfidb %v24, %v24, 4, 1
 ; 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
 }
 
 define double @f7(<2 x double> %val) #0 {
 ; CHECK-LABEL: f7:
 ; CHECK: wfidb %f0, %v24, 0, 0
 ; CHECK: br %r14

 
 define double @f9(<2 x double> %val) #0 {
 ; CHECK-LABEL: f9:
 ; CHECK: wfidb %f0, %v24, 4, 7
 ; CHECK: br %r14
   %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
 }
 
 
 define double @f10(<2 x double> %val) #0 {
 ; CHECK-LABEL: f10:
 ; CHECK: wfidb %f0, %v24, 4, 6
 ; CHECK: br %r14
   %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
 }
 
 define double @f11(<2 x double> %val) #0 {
 ; CHECK-LABEL: f11:
 ; CHECK: wfidb %f0, %v24, 4, 5
 ; CHECK: br %r14
   %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
 }
 
 define double @f12(<2 x double> %val) #0 {
 ; CHECK-LABEL: f12:
 ; CHECK: wfidb %f0, %v24, 4, 1
 ; CHECK: br %r14
   %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
 }
 
 attributes #0 = { strictfp }

llvm/test/CodeGen/SystemZ/vec-strict-round-02.ll

 ; Test strict v4f32 rounding on z14.
 ;
 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z14 | FileCheck %s
 
 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:
 ; CHECK: vfisb %v24, %v24, 0, 0
 ; CHECK: br %r14
   %res = call <4 x float> @llvm.experimental.constrained.rint.v4f32(
                         <4 x float> %val,
                         metadata !"round.dynamic",

 }
 
 define <4 x float> @f3(<4 x float> %val) #0 {
 ; CHECK-LABEL: f3:
 ; CHECK: vfisb %v24, %v24, 4, 7
 ; 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
 }
 
 define <4 x float> @f4(<4 x float> %val) #0 {
 ; CHECK-LABEL: f4:
 ; CHECK: vfisb %v24, %v24, 4, 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
 }
 
 define <4 x float> @f5(<4 x float> %val) #0 {
 ; CHECK-LABEL: f5:
 ; CHECK: vfisb %v24, %v24, 4, 5
 ; 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
 }
 
 define <4 x float> @f6(<4 x float> %val) #0 {
 ; CHECK-LABEL: f6:
 ; CHECK: vfisb %v24, %v24, 4, 1
 ; 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
 }
 
 define float @f7(<4 x float> %val) #0 {
 ; CHECK-LABEL: f7:
 ; CHECK: wfisb %f0, %v24, 0, 0
 ; CHECK: br %r14

 
 define float @f9(<4 x float> %val) #0 {
 ; CHECK-LABEL: f9:
 ; CHECK: wfisb %f0, %v24, 4, 7
 ; CHECK: br %r14
   %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
 }
 
 define float @f10(<4 x float> %val) #0 {
 ; CHECK-LABEL: f10:
 ; CHECK: wfisb %f0, %v24, 4, 6
 ; CHECK: br %r14
   %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
 }
 
 define float @f11(<4 x float> %val) #0 {
 ; CHECK-LABEL: f11:
 ; CHECK: wfisb %f0, %v24, 4, 5
 ; CHECK: br %r14
   %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
 }
 
 define float @f12(<4 x float> %val) #0 {
 ; CHECK-LABEL: f12:
 ; CHECK: wfisb %f0, %v24, 4, 1
 ; CHECK: br %r14
   %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
 }
 
 attributes #0 = { strictfp }

llvm/test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll

 ; SZ13-NEXT:    brasl %r14, fmaxf@PLT
 ; SZ13-NEXT:    # kill: def $f0s killed $f0s def $v0
 ; SZ13-NEXT:    vlr %v24, %v0
 ; SZ13-NEXT:    lmg %r14, %r15, 272(%r15)
 ; SZ13-NEXT:    br %r14
 entry:
   %max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32(
                                <1 x float> <float 42.0>, <1 x float> <float 41.0>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %max
 }
 
 define <2 x double> @constrained_vector_maxnum_v2f64() #0 {
 ; S390X-LABEL: constrained_vector_maxnum_v2f64:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r14, %r15, 112(%r15)

 ; SZ13-NEXT:    # kill: def $f0d killed $f0d def $v0
 ; SZ13-NEXT:    vmrhg %v24, %v0, %v1
 ; SZ13-NEXT:    lmg %r14, %r15, 288(%r15)
 ; SZ13-NEXT:    br %r14
 entry:
   %max = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64(
                                 <2 x double> <double 43.0, double 42.0>,
                                 <2 x double> <double 41.0, double 40.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %max
 }
 
 define <3 x float> @constrained_vector_maxnum_v3f32() #0 {
 ; S390X-LABEL: constrained_vector_maxnum_v3f32:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r14, %r15, 112(%r15)

 ; SZ13-NEXT:    vrepf %v1, %v1, 0
 ; SZ13-NEXT:    vmrhg %v24, %v0, %v1
 ; SZ13-NEXT:    lmg %r14, %r15, 312(%r15)
 ; SZ13-NEXT:    br %r14
 entry:
   %max = call <3 x float> @llvm.experimental.constrained.maxnum.v3f32(
                               <3 x float> <float 43.0, float 44.0, float 45.0>,
                               <3 x float> <float 41.0, float 42.0, float 43.0>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %max
 }
 
 define void @constrained_vector_log10_maxnum_v3f64(<3 x double>* %a) #0 {
 ; S390X-LABEL: constrained_vector_log10_maxnum_v3f64:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r13, %r15, 104(%r15)

 ; SZ13-NEXT:    vst %v0, 0(%r13), 4
 ; SZ13-NEXT:    lmg %r13, %r15, 304(%r15)
 ; SZ13-NEXT:    br %r14
 entry:
   %b = load <3 x double>, <3 x double>* %a
   %max = call <3 x double> @llvm.experimental.constrained.maxnum.v3f64(
                           <3 x double> %b,
                           <3 x double> <double 40.0, double 41.0, double 42.0>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   store <3 x double> %max, <3 x double>* %a
   ret void
 }
 
 define <4 x double> @constrained_vector_maxnum_v4f64() #0 {
 ; S390X-LABEL: constrained_vector_maxnum_v4f64:
 ; S390X:       # %bb.0: # %entry

 ; SZ13-NEXT:    lmg %r14, %r15, 304(%r15)
 ; SZ13-NEXT:    br %r14
 entry:
   %max = call <4 x double> @llvm.experimental.constrained.maxnum.v4f64(
                                 <4 x double> <double 44.0, double 45.0,
                                               double 46.0, double 47.0>,
                                 <4 x double> <double 40.0, double 41.0,
                                               double 42.0, double 43.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <4 x double> %max
 }
 
 define <1 x float> @constrained_vector_minnum_v1f32() #0 {
 ; S390X-LABEL: constrained_vector_minnum_v1f32:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r14, %r15, 112(%r15)

 ; SZ13-NEXT:    brasl %r14, fminf@PLT
 ; SZ13-NEXT:    # kill: def $f0s killed $f0s def $v0
 ; SZ13-NEXT:    vlr %v24, %v0
 ; SZ13-NEXT:    lmg %r14, %r15, 272(%r15)
 ; SZ13-NEXT:    br %r14
  entry:
   %min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32(
                                <1 x float> <float 42.0>, <1 x float> <float 41.0>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %min
 }
 
 define <2 x double> @constrained_vector_minnum_v2f64() #0 {
 ; S390X-LABEL: constrained_vector_minnum_v2f64:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r14, %r15, 112(%r15)

 ; SZ13-NEXT:    # kill: def $f0d killed $f0d def $v0
 ; SZ13-NEXT:    vmrhg %v24, %v0, %v1
 ; SZ13-NEXT:    lmg %r14, %r15, 288(%r15)
 ; SZ13-NEXT:    br %r14
 entry:
   %min = call <2 x double> @llvm.experimental.constrained.minnum.v2f64(
                                 <2 x double> <double 43.0, double 42.0>,
                                 <2 x double> <double 41.0, double 40.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %min
 }
 
 define <3 x float> @constrained_vector_minnum_v3f32() #0 {
 ; S390X-LABEL: constrained_vector_minnum_v3f32:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r14, %r15, 112(%r15)

 ; SZ13-NEXT:    vrepf %v1, %v1, 0
 ; SZ13-NEXT:    vmrhg %v24, %v0, %v1
 ; SZ13-NEXT:    lmg %r14, %r15, 312(%r15)
 ; SZ13-NEXT:    br %r14
 entry:
   %min = call <3 x float> @llvm.experimental.constrained.minnum.v3f32(
                               <3 x float> <float 43.0, float 44.0, float 45.0>,
                               <3 x float> <float 41.0, float 42.0, float 43.0>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %min
 }
 
 define void @constrained_vector_minnum_v3f64(<3 x double>* %a) #0 {
 ; S390X-LABEL: constrained_vector_minnum_v3f64:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r13, %r15, 104(%r15)

 ; SZ13-NEXT:    vst %v0, 0(%r13), 4
 ; SZ13-NEXT:    lmg %r13, %r15, 312(%r15)
 ; SZ13-NEXT:    br %r14
 entry:
  %b = load <3 x double>, <3 x double>* %a
  %min = call <3 x double> @llvm.experimental.constrained.minnum.v3f64(
                           <3 x double> %b,
                           <3 x double> <double 3.0, double 3.0, double 3.0>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   store <3 x double> %min, <3 x double>* %a
   ret void
 }
 
 define <4 x double> @constrained_vector_minnum_v4f64() #0 {
 ; S390X-LABEL: constrained_vector_minnum_v4f64:
 ; S390X:       # %bb.0: # %entry

 ; SZ13-NEXT:    lmg %r14, %r15, 304(%r15)
 ; SZ13-NEXT:    br %r14
 entry:
   %min = call <4 x double> @llvm.experimental.constrained.minnum.v4f64(
                                 <4 x double> <double 44.0, double 45.0,
                                               double 46.0, double 47.0>,
                                 <4 x double> <double 40.0, double 41.0,
                                               double 42.0, double 43.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <4 x double> %min
 }
 
 define <1 x float> @constrained_vector_fptrunc_v1f64() #0 {
 ; S390X-LABEL: constrained_vector_fptrunc_v1f64:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    larl %r1, .LCPI95_0

 ; SZ13:       # %bb.0: # %entry
 ; SZ13-NEXT:    vgmf %v0, 2, 9
 ; SZ13-NEXT:    fiebra %f0, 6, %f0, 4
 ; SZ13-NEXT:    vlr %v24, %v0
 ; SZ13-NEXT:    br %r14
 entry:
   %ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %ceil
 }
 
 define <2 x double> @constrained_vector_ceil_v2f64() #0 {
 ; S390X-LABEL: constrained_vector_ceil_v2f64:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r14, %r15, 112(%r15)

 ; SZ13:       # %bb.0: # %entry
 ; SZ13-NEXT:    larl %r1, .LCPI104_0
 ; SZ13-NEXT:    vl %v0, 0(%r1), 3
 ; SZ13-NEXT:    vfidb %v24, %v0, 4, 6
 ; SZ13-NEXT:    br %r14
 entry:
   %ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %ceil
 }
 
 define <3 x float> @constrained_vector_ceil_v3f32() #0 {
 ; S390X-LABEL: constrained_vector_ceil_v3f32:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r14, %r15, 112(%r15)

 ; SZ13-NEXT:    fiebra %f2, 6, %f2, 4
 ; SZ13-NEXT:    vmrhf %v1, %v1, %v2
 ; SZ13-NEXT:    vrepf %v0, %v0, 0
 ; SZ13-NEXT:    vmrhg %v24, %v1, %v0
 ; SZ13-NEXT:    br %r14
 entry:
   %ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %ceil
 }
 
 define void @constrained_vector_ceil_v3f64(<3 x double>* %a) #0 {
 ; S390X-LABEL: constrained_vector_ceil_v3f64:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r13, %r15, 104(%r15)

 ; SZ13-NEXT:    fidbra %f1, 6, %f1, 4
 ; SZ13-NEXT:    vst %v0, 0(%r2), 4
 ; SZ13-NEXT:    std %f1, 16(%r2)
 ; SZ13-NEXT:    br %r14
 entry:
   %b = load <3 x double>, <3 x double>* %a
   %ceil = call <3 x double> @llvm.experimental.constrained.ceil.v3f64(
                           <3 x double> %b,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   store <3 x double> %ceil, <3 x double>* %a
   ret void
 }
 
 define <1 x float> @constrained_vector_floor_v1f32() #0 {
 ; S390X-LABEL: constrained_vector_floor_v1f32:
 ; S390X:       # %bb.0: # %entry

 ; SZ13:       # %bb.0: # %entry
 ; SZ13-NEXT:    vgmf %v0, 2, 9
 ; SZ13-NEXT:    fiebra %f0, 7, %f0, 4
 ; SZ13-NEXT:    vlr %v24, %v0
 ; SZ13-NEXT:    br %r14
 entry:
   %floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %floor
 }
 
 
 define <2 x double> @constrained_vector_floor_v2f64() #0 {
 ; S390X-LABEL: constrained_vector_floor_v2f64:
 ; S390X:       # %bb.0: # %entry

 ; SZ13:       # %bb.0: # %entry
 ; SZ13-NEXT:    larl %r1, .LCPI108_0
 ; SZ13-NEXT:    vl %v0, 0(%r1), 3
 ; SZ13-NEXT:    vfidb %v24, %v0, 4, 7
 ; SZ13-NEXT:    br %r14
 entry:
   %floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %floor
 }
 
 define <3 x float> @constrained_vector_floor_v3f32() #0 {
 ; S390X-LABEL: constrained_vector_floor_v3f32:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r14, %r15, 112(%r15)

 ; SZ13-NEXT:    fiebra %f2, 7, %f2, 4
 ; SZ13-NEXT:    vmrhf %v1, %v1, %v2
 ; SZ13-NEXT:    vrepf %v0, %v0, 0
 ; SZ13-NEXT:    vmrhg %v24, %v1, %v0
 ; SZ13-NEXT:    br %r14
 entry:
   %floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %floor
 }
 
 define void @constrained_vector_floor_v3f64(<3 x double>* %a) #0 {
 ; S390X-LABEL: constrained_vector_floor_v3f64:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r13, %r15, 104(%r15)

 ; SZ13-NEXT:    fidbra %f1, 7, %f1, 4
 ; SZ13-NEXT:    vst %v0, 0(%r2), 4
 ; SZ13-NEXT:    std %f1, 16(%r2)
 ; SZ13-NEXT:    br %r14
 entry:
   %b = load <3 x double>, <3 x double>* %a
   %floor = call <3 x double> @llvm.experimental.constrained.floor.v3f64(
                           <3 x double> %b,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   store <3 x double> %floor, <3 x double>* %a
   ret void
 }
 
 define <1 x float> @constrained_vector_round_v1f32() #0 {
 ; S390X-LABEL: constrained_vector_round_v1f32:
 ; S390X:       # %bb.0: # %entry

 ; SZ13:       # %bb.0: # %entry
 ; SZ13-NEXT:    vgmf %v0, 2, 9
 ; SZ13-NEXT:    fiebra %f0, 1, %f0, 4
 ; SZ13-NEXT:    vlr %v24, %v0
 ; SZ13-NEXT:    br %r14
 entry:
   %round = call <1 x float> @llvm.experimental.constrained.round.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %round
 }
 
 define <2 x double> @constrained_vector_round_v2f64() #0 {
 ; S390X-LABEL: constrained_vector_round_v2f64:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r14, %r15, 112(%r15)

 ; SZ13:       # %bb.0: # %entry
 ; SZ13-NEXT:    larl %r1, .LCPI112_0
 ; SZ13-NEXT:    vl %v0, 0(%r1), 3
 ; SZ13-NEXT:    vfidb %v24, %v0, 4, 1
 ; SZ13-NEXT:    br %r14
 entry:
   %round = call <2 x double> @llvm.experimental.constrained.round.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %round
 }
 
 define <3 x float> @constrained_vector_round_v3f32() #0 {
 ; S390X-LABEL: constrained_vector_round_v3f32:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r14, %r15, 112(%r15)

 ; SZ13-NEXT:    fiebra %f2, 1, %f2, 4
 ; SZ13-NEXT:    vmrhf %v1, %v1, %v2
 ; SZ13-NEXT:    vrepf %v0, %v0, 0
 ; SZ13-NEXT:    vmrhg %v24, %v1, %v0
 ; SZ13-NEXT:    br %r14
 entry:
   %round = call <3 x float> @llvm.experimental.constrained.round.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %round
 }
 
 
 define void @constrained_vector_round_v3f64(<3 x double>* %a) #0 {
 ; S390X-LABEL: constrained_vector_round_v3f64:
 ; S390X:       # %bb.0: # %entry

 ; SZ13-NEXT:    fidbra %f1, 1, %f1, 4
 ; SZ13-NEXT:    vst %v0, 0(%r2), 4
 ; SZ13-NEXT:    std %f1, 16(%r2)
 ; SZ13-NEXT:    br %r14
 entry:
   %b = load <3 x double>, <3 x double>* %a
   %round = call <3 x double> @llvm.experimental.constrained.round.v3f64(
                           <3 x double> %b,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   store <3 x double> %round, <3 x double>* %a
   ret void
 }
 
 define <1 x float> @constrained_vector_trunc_v1f32() #0 {
 ; S390X-LABEL: constrained_vector_trunc_v1f32:
 ; S390X:       # %bb.0: # %entry

 ; SZ13:       # %bb.0: # %entry
 ; SZ13-NEXT:    vgmf %v0, 2, 9
 ; SZ13-NEXT:    fiebra %f0, 5, %f0, 4
 ; SZ13-NEXT:    vlr %v24, %v0
 ; SZ13-NEXT:    br %r14
 entry:
   %trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %trunc
 }
 
 define <2 x double> @constrained_vector_trunc_v2f64() #0 {
 ; S390X-LABEL: constrained_vector_trunc_v2f64:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r14, %r15, 112(%r15)

 ; SZ13:       # %bb.0: # %entry
 ; SZ13-NEXT:    larl %r1, .LCPI116_0
 ; SZ13-NEXT:    vl %v0, 0(%r1), 3
 ; SZ13-NEXT:    vfidb %v24, %v0, 4, 5
 ; SZ13-NEXT:    br %r14
 entry:
   %trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %trunc
 }
 
 define <3 x float> @constrained_vector_trunc_v3f32() #0 {
 ; S390X-LABEL: constrained_vector_trunc_v3f32:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r14, %r15, 112(%r15)

 ; SZ13-NEXT:    fiebra %f2, 5, %f2, 4
 ; SZ13-NEXT:    vmrhf %v1, %v1, %v2
 ; SZ13-NEXT:    vrepf %v0, %v0, 0
 ; SZ13-NEXT:    vmrhg %v24, %v1, %v0
 ; SZ13-NEXT:    br %r14
 entry:
   %trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %trunc
 }
 
 define void @constrained_vector_trunc_v3f64(<3 x double>* %a) #0 {
 ; S390X-LABEL: constrained_vector_trunc_v3f64:
 ; S390X:       # %bb.0: # %entry
 ; S390X-NEXT:    stmg %r13, %r15, 104(%r15)

 ; SZ13-NEXT:    fidbra %f1, 5, %f1, 4
 ; SZ13-NEXT:    vst %v0, 0(%r2), 4
 ; SZ13-NEXT:    std %f1, 16(%r2)
 ; SZ13-NEXT:    br %r14
 entry:
   %b = load <3 x double>, <3 x double>* %a
   %trunc = call <3 x double> @llvm.experimental.constrained.trunc.v3f64(
                           <3 x double> %b,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   store <3 x double> %trunc, <3 x double>* %a
   ret void
 }
 
 attributes #0 = { strictfp }
 
 declare <2 x double> @llvm.experimental.constrained.fadd.v2f64(<2 x double>, <2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.fsub.v2f64(<2 x double>, <2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.fmul.v2f64(<2 x double>, <2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.fdiv.v2f64(<2 x double>, <2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.frem.v2f64(<2 x double>, <2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.sqrt.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.pow.v2f64(<2 x double>, <2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.powi.v2f64(<2 x double>, i32, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.sin.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.cos.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.exp.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.exp2.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.log.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.log10.v2f64(<2 x double>, metadata, metadata)
 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)
 declare <1 x float> @llvm.experimental.constrained.fmul.v1f32(<1 x float>, <1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.fdiv.v1f32(<1 x float>, <1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.frem.v1f32(<1 x float>, <1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.sqrt.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.pow.v1f32(<1 x float>, <1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.powi.v1f32(<1 x float>, i32, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.sin.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.cos.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.exp.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.exp2.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.log.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.log10.v1f32(<1 x float>, metadata, metadata)
 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)
 declare <3 x float> @llvm.experimental.constrained.fsub.v3f32(<3 x float>, <3 x float>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.fsub.v3f64(<3 x double>, <3 x double>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.fmul.v3f32(<3 x float>, <3 x float>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.fmul.v3f64(<3 x double>, <3 x double>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.fdiv.v3f32(<3 x float>, <3 x float>, metadata, metadata)

 declare <3 x float> @llvm.experimental.constrained.log10.v3f32(<3 x float>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.log10.v3f64(<3 x double>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.log2.v3f32(<3 x float>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.log2.v3f64(<3 x double>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.rint.v3f32(<3 x float>, metadata, metadata)
 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)
 declare <4 x double> @llvm.experimental.constrained.fmul.v4f64(<4 x double>, <4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.fdiv.v4f64(<4 x double>, <4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.frem.v4f64(<4 x double>, <4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.sqrt.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.pow.v4f64(<4 x double>, <4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.powi.v4f64(<4 x double>, i32, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.sin.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.cos.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.exp.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.exp2.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.log.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.log10.v4f64(<4 x double>, metadata, metadata)
 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)

llvm/test/CodeGen/X86/fp128-libcalls-strict.ll

 ; X86-NEXT:    movl %ecx, 4(%esi)
 ; X86-NEXT:    movl %eax, (%esi)
 ; X86-NEXT:    movl %esi, %eax
 ; X86-NEXT:    addl $20, %esp
 ; X86-NEXT:    popl %esi
 ; 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
 }
 
 define fp128 @cos(fp128 %x) nounwind strictfp {
 ; CHECK-LABEL: cos:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    pushq %rax
 ; CHECK-NEXT:    callq cosl

 ; X86-NEXT:    movl %ecx, 4(%esi)
 ; X86-NEXT:    movl %eax, (%esi)
 ; X86-NEXT:    movl %esi, %eax
 ; X86-NEXT:    addl $20, %esp
 ; X86-NEXT:    popl %esi
 ; 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
 }
 
 define fp128 @log(fp128 %x) nounwind strictfp {
 ; CHECK-LABEL: log:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    pushq %rax
 ; CHECK-NEXT:    callq logl

 ; X86-NEXT:    movl %ecx, 4(%esi)
 ; X86-NEXT:    movl %eax, (%esi)
 ; X86-NEXT:    movl %esi, %eax
 ; X86-NEXT:    addl $20, %esp
 ; X86-NEXT:    popl %esi
 ; 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
 }
 
 define fp128 @minnum(fp128 %x, fp128 %y) nounwind strictfp {
 ; CHECK-LABEL: minnum:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    pushq %rax
 ; CHECK-NEXT:    callq fminl

 ; X86-NEXT:    movl %ecx, 4(%esi)
 ; X86-NEXT:    movl %eax, (%esi)
 ; X86-NEXT:    movl %esi, %eax
 ; X86-NEXT:    addl $20, %esp
 ; X86-NEXT:    popl %esi
 ; 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
 }
 
 define fp128 @nearbyint(fp128 %x) nounwind strictfp {
 ; CHECK-LABEL: nearbyint:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    pushq %rax
 ; CHECK-NEXT:    callq nearbyintl

 ; X86-NEXT:    movl %ecx, 4(%esi)
 ; X86-NEXT:    movl %eax, (%esi)
 ; X86-NEXT:    movl %esi, %eax
 ; X86-NEXT:    addl $20, %esp
 ; X86-NEXT:    popl %esi
 ; 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
 }
 
 define fp128 @sin(fp128 %x) nounwind strictfp {
 ; CHECK-LABEL: sin:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    pushq %rax
 ; CHECK-NEXT:    callq sinl

 ; X86-NEXT:    movl %ecx, 4(%esi)
 ; X86-NEXT:    movl %eax, (%esi)
 ; X86-NEXT:    movl %esi, %eax
 ; X86-NEXT:    addl $20, %esp
 ; X86-NEXT:    popl %esi
 ; 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
 }
 
 define i32 @lrint(fp128 %x) nounwind strictfp {
 ; CHECK-LABEL: lrint:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    pushq %rax
 ; CHECK-NEXT:    callq lrintl

 attributes #0 = { strictfp }
 
 declare fp128 @llvm.experimental.constrained.fadd.f128(fp128, fp128, metadata, metadata)
 declare fp128 @llvm.experimental.constrained.fsub.f128(fp128, fp128, metadata, metadata)
 declare fp128 @llvm.experimental.constrained.fmul.f128(fp128, fp128, metadata, metadata)
 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)
 declare i64 @llvm.experimental.constrained.llround.i64.f128(fp128, metadata)

llvm/test/CodeGen/X86/vector-constrained-fp-intrinsics.ll

 ; AVX-NEXT:    vmovss {{.*#+}} xmm1 = mem[0],zero,zero,zero
 ; AVX-NEXT:    callq fmaxf
 ; AVX-NEXT:    popq %rax
 ; AVX-NEXT:    .cfi_def_cfa_offset 8
 ; AVX-NEXT:    retq
 entry:
   %max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32(
                                <1 x float> <float 42.0>, <1 x float> <float 41.0>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %max
 }
 
 define <2 x double> @constrained_vector_maxnum_v2f64() #0 {
 ; CHECK-LABEL: constrained_vector_maxnum_v2f64:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $24, %rsp

 ; AVX-NEXT:    # xmm0 = xmm0[0],mem[0]
 ; AVX-NEXT:    addq $24, %rsp
 ; AVX-NEXT:    .cfi_def_cfa_offset 8
 ; AVX-NEXT:    retq
 entry:
   %max = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64(
                                 <2 x double> <double 43.0, double 42.0>,
                                 <2 x double> <double 41.0, double 40.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %max
 }
 
 define <3 x float> @constrained_vector_maxnum_v3f32() #0 {
 ; CHECK-LABEL: constrained_vector_maxnum_v3f32:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $40, %rsp

 ; AVX-NEXT:    # xmm0 = xmm0[0,1],mem[0],xmm0[3]
 ; AVX-NEXT:    addq $40, %rsp
 ; AVX-NEXT:    .cfi_def_cfa_offset 8
 ; AVX-NEXT:    retq
 entry:
   %max = call <3 x float> @llvm.experimental.constrained.maxnum.v3f32(
                               <3 x float> <float 43.0, float 44.0, float 45.0>,
                               <3 x float> <float 41.0, float 42.0, float 43.0>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %max
 }
 
 define <3 x double> @constrained_vector_max_v3f64() #0 {
 ; CHECK-LABEL: constrained_vector_max_v3f64:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $24, %rsp

 ; AVX-NEXT:    vinsertf128 $1, %xmm0, %ymm1, %ymm0
 ; AVX-NEXT:    addq $56, %rsp
 ; AVX-NEXT:    .cfi_def_cfa_offset 8
 ; AVX-NEXT:    retq
 entry:
   %max = call <3 x double> @llvm.experimental.constrained.maxnum.v3f64(
                           <3 x double> <double 43.0, double 44.0, double 45.0>,
                           <3 x double> <double 40.0, double 41.0, double 42.0>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   ret <3 x double> %max
 }
 
 define <4 x double> @constrained_vector_maxnum_v4f64() #0 {
 ; CHECK-LABEL: constrained_vector_maxnum_v4f64:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $40, %rsp

 ; AVX-NEXT:    .cfi_def_cfa_offset 8
 ; AVX-NEXT:    retq
 entry:
   %max = call <4 x double> @llvm.experimental.constrained.maxnum.v4f64(
                                 <4 x double> <double 44.0, double 45.0,
                                               double 46.0, double 47.0>,
                                 <4 x double> <double 40.0, double 41.0,
                                               double 42.0, double 43.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <4 x double> %max
 }
 
 define <1 x float> @constrained_vector_minnum_v1f32() #0 {
 ; CHECK-LABEL: constrained_vector_minnum_v1f32:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    pushq %rax

 ; AVX-NEXT:    vmovss {{.*#+}} xmm1 = mem[0],zero,zero,zero
 ; AVX-NEXT:    callq fminf
 ; AVX-NEXT:    popq %rax
 ; AVX-NEXT:    .cfi_def_cfa_offset 8
 ; AVX-NEXT:    retq
  entry:
   %min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32(
                                <1 x float> <float 42.0>, <1 x float> <float 41.0>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %min
 }
 
 define <2 x double> @constrained_vector_minnum_v2f64() #0 {
 ; CHECK-LABEL: constrained_vector_minnum_v2f64:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $24, %rsp

 ; AVX-NEXT:    # xmm0 = xmm0[0],mem[0]
 ; AVX-NEXT:    addq $24, %rsp
 ; AVX-NEXT:    .cfi_def_cfa_offset 8
 ; AVX-NEXT:    retq
 entry:
   %min = call <2 x double> @llvm.experimental.constrained.minnum.v2f64(
                                 <2 x double> <double 43.0, double 42.0>,
                                 <2 x double> <double 41.0, double 40.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %min
 }
 
 define <3 x float> @constrained_vector_minnum_v3f32() #0 {
 ; CHECK-LABEL: constrained_vector_minnum_v3f32:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $40, %rsp

 ; AVX-NEXT:    # xmm0 = xmm0[0,1],mem[0],xmm0[3]
 ; AVX-NEXT:    addq $40, %rsp
 ; AVX-NEXT:    .cfi_def_cfa_offset 8
 ; AVX-NEXT:    retq
 entry:
   %min = call <3 x float> @llvm.experimental.constrained.minnum.v3f32(
                               <3 x float> <float 43.0, float 44.0, float 45.0>,
                               <3 x float> <float 41.0, float 42.0, float 43.0>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %min
 }
 
 define <3 x double> @constrained_vector_min_v3f64() #0 {
 ; CHECK-LABEL: constrained_vector_min_v3f64:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $24, %rsp

 ; AVX-NEXT:    vinsertf128 $1, %xmm0, %ymm1, %ymm0
 ; AVX-NEXT:    addq $56, %rsp
 ; AVX-NEXT:    .cfi_def_cfa_offset 8
 ; AVX-NEXT:    retq
 entry:
  %min = call <3 x double> @llvm.experimental.constrained.minnum.v3f64(
                           <3 x double> <double 43.0, double 44.0, double 45.0>,
                           <3 x double> <double 40.0, double 41.0, double 42.0>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   ret <3 x double> %min
 }
 
 define <4 x double> @constrained_vector_minnum_v4f64() #0 {
 ; CHECK-LABEL: constrained_vector_minnum_v4f64:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $40, %rsp

 ; AVX-NEXT:    .cfi_def_cfa_offset 8
 ; AVX-NEXT:    retq
 entry:
   %min = call <4 x double> @llvm.experimental.constrained.minnum.v4f64(
                                 <4 x double> <double 44.0, double 45.0,
                                               double 46.0, double 47.0>,
                                 <4 x double> <double 40.0, double 41.0,
                                               double 42.0, double 43.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <4 x double> %min
 }
 
 define <1 x i32> @constrained_vector_fptosi_v1i32_v1f32() #0 {
 ; CHECK-LABEL: constrained_vector_fptosi_v1i32_v1f32:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    cvttss2si {{.*}}(%rip), %eax

 ; AVX-LABEL: constrained_vector_ceil_v1f32:
 ; AVX:       # %bb.0: # %entry
 ; AVX-NEXT:    vmovss {{.*#+}} xmm0 = mem[0],zero,zero,zero
 ; AVX-NEXT:    vroundss $10, %xmm0, %xmm0, %xmm0
 ; AVX-NEXT:    retq
 entry:
   %ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %ceil
 }
 
 define <2 x double> @constrained_vector_ceil_v2f64() #0 {
 ; CHECK-LABEL: constrained_vector_ceil_v2f64:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $24, %rsp

 ;
 ; AVX-LABEL: constrained_vector_ceil_v2f64:
 ; AVX:       # %bb.0: # %entry
 ; AVX-NEXT:    vroundpd $10, {{.*}}(%rip), %xmm0
 ; AVX-NEXT:    retq
 entry:
   %ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %ceil
 }
 
 define <3 x float> @constrained_vector_ceil_v3f32() #0 {
 ; CHECK-LABEL: constrained_vector_ceil_v3f32:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $40, %rsp

 ; AVX-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
 ; AVX-NEXT:    vroundss $10, %xmm2, %xmm2, %xmm2
 ; AVX-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0],xmm2[0],xmm1[2,3]
 ; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1],xmm0[0],xmm1[3]
 ; AVX-NEXT:    retq
 entry:
   %ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %ceil
 }
 
 define <3 x double> @constrained_vector_ceil_v3f64() #0 {
 ; CHECK-LABEL: constrained_vector_ceil_v3f64:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $24, %rsp

 ; AVX-NEXT:    vmovsd {{.*#+}} xmm0 = mem[0],zero
 ; AVX-NEXT:    vroundsd $10, %xmm0, %xmm0, %xmm0
 ; AVX-NEXT:    vroundpd $10, {{.*}}(%rip), %xmm1
 ; AVX-NEXT:    vinsertf128 $1, %xmm0, %ymm1, %ymm0
 ; AVX-NEXT:    retq
 entry:
   %ceil = call <3 x double> @llvm.experimental.constrained.ceil.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   ret <3 x double> %ceil
 }
 
 define <1 x float> @constrained_vector_floor_v1f32() #0 {
 ; CHECK-LABEL: constrained_vector_floor_v1f32:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    pushq %rax
 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 ; CHECK-NEXT:    movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
 ; CHECK-NEXT:    callq floorf
 ; CHECK-NEXT:    popq %rax
 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 ; CHECK-NEXT:    retq
 ;
 ; AVX-LABEL: constrained_vector_floor_v1f32:
 ; AVX:       # %bb.0: # %entry
 ; AVX-NEXT:    vmovss {{.*#+}} xmm0 = mem[0],zero,zero,zero
 ; AVX-NEXT:    vroundss $9, %xmm0, %xmm0, %xmm0
 ; AVX-NEXT:    retq
 entry:
   %floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %floor
 }
 
 
 define <2 x double> @constrained_vector_floor_v2f64() #0 {
 ; CHECK-LABEL: constrained_vector_floor_v2f64:
 ; CHECK:       # %bb.0: # %entry

 ;
 ; AVX-LABEL: constrained_vector_floor_v2f64:
 ; AVX:       # %bb.0: # %entry
 ; AVX-NEXT:    vroundpd $9, {{.*}}(%rip), %xmm0
 ; AVX-NEXT:    retq
 entry:
   %floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %floor
 }
 
 define <3 x float> @constrained_vector_floor_v3f32() #0 {
 ; CHECK-LABEL: constrained_vector_floor_v3f32:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $40, %rsp

 ; AVX-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
 ; AVX-NEXT:    vroundss $9, %xmm2, %xmm2, %xmm2
 ; AVX-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0],xmm2[0],xmm1[2,3]
 ; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1],xmm0[0],xmm1[3]
 ; AVX-NEXT:    retq
 entry:
   %floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %floor
 }
 
 define <3 x double> @constrained_vector_floor_v3f64() #0 {
 ; CHECK-LABEL: constrained_vector_floor_v3f64:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $24, %rsp

 ; AVX-NEXT:    vmovsd {{.*#+}} xmm0 = mem[0],zero
 ; AVX-NEXT:    vroundsd $9, %xmm0, %xmm0, %xmm0
 ; AVX-NEXT:    vroundpd $9, {{.*}}(%rip), %xmm1
 ; AVX-NEXT:    vinsertf128 $1, %xmm0, %ymm1, %ymm0
 ; AVX-NEXT:    retq
 entry:
   %floor = call <3 x double> @llvm.experimental.constrained.floor.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   ret <3 x double> %floor
 }
 
 define <1 x float> @constrained_vector_round_v1f32() #0 {
 ; CHECK-LABEL: constrained_vector_round_v1f32:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    pushq %rax

 ; AVX-NEXT:    vmovss {{.*#+}} xmm0 = mem[0],zero,zero,zero
 ; AVX-NEXT:    callq roundf
 ; AVX-NEXT:    popq %rax
 ; AVX-NEXT:    .cfi_def_cfa_offset 8
 ; AVX-NEXT:    retq
 entry:
   %round = call <1 x float> @llvm.experimental.constrained.round.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %round
 }
 
 define <2 x double> @constrained_vector_round_v2f64() #0 {
 ; CHECK-LABEL: constrained_vector_round_v2f64:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $24, %rsp

 ; AVX-NEXT:    vunpcklpd (%rsp), %xmm0, %xmm0 # 16-byte Folded Reload
 ; AVX-NEXT:    # xmm0 = xmm0[0],mem[0]
 ; AVX-NEXT:    addq $24, %rsp
 ; AVX-NEXT:    .cfi_def_cfa_offset 8
 ; AVX-NEXT:    retq
 entry:
   %round = call <2 x double> @llvm.experimental.constrained.round.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %round
 }
 
 define <3 x float> @constrained_vector_round_v3f32() #0 {
 ; CHECK-LABEL: constrained_vector_round_v3f32:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $40, %rsp

 ; AVX-NEXT:    vinsertps $32, {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
 ; AVX-NEXT:    # xmm0 = xmm0[0,1],mem[0],xmm0[3]
 ; AVX-NEXT:    addq $40, %rsp
 ; AVX-NEXT:    .cfi_def_cfa_offset 8
 ; AVX-NEXT:    retq
 entry:
   %round = call <3 x float> @llvm.experimental.constrained.round.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %round
 }
 
 
 define <3 x double> @constrained_vector_round_v3f64() #0 {
 ; CHECK-LABEL: constrained_vector_round_v3f64:
 ; CHECK:       # %bb.0: # %entry

 ; AVX-NEXT:    vmovups (%rsp), %ymm1 # 32-byte Reload
 ; AVX-NEXT:    vinsertf128 $1, %xmm0, %ymm1, %ymm0
 ; AVX-NEXT:    addq $56, %rsp
 ; AVX-NEXT:    .cfi_def_cfa_offset 8
 ; AVX-NEXT:    retq
 entry:
   %round = call <3 x double> @llvm.experimental.constrained.round.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   ret <3 x double> %round
 }
 
 define <1 x float> @constrained_vector_trunc_v1f32() #0 {
 ; CHECK-LABEL: constrained_vector_trunc_v1f32:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    pushq %rax
 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 ; CHECK-NEXT:    movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
 ; CHECK-NEXT:    callq truncf
 ; CHECK-NEXT:    popq %rax
 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 ; CHECK-NEXT:    retq
 ;
 ; AVX-LABEL: constrained_vector_trunc_v1f32:
 ; AVX:       # %bb.0: # %entry
 ; AVX-NEXT:    vmovss {{.*#+}} xmm0 = mem[0],zero,zero,zero
 ; AVX-NEXT:    vroundss $11, %xmm0, %xmm0, %xmm0
 ; AVX-NEXT:    retq
 entry:
   %trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %trunc
 }
 
 define <2 x double> @constrained_vector_trunc_v2f64() #0 {
 ; CHECK-LABEL: constrained_vector_trunc_v2f64:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $24, %rsp

 ;
 ; AVX-LABEL: constrained_vector_trunc_v2f64:
 ; AVX:       # %bb.0: # %entry
 ; AVX-NEXT:    vroundpd $11, {{.*}}(%rip), %xmm0
 ; AVX-NEXT:    retq
 entry:
   %trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %trunc
 }
 
 define <3 x float> @constrained_vector_trunc_v3f32() #0 {
 ; CHECK-LABEL: constrained_vector_trunc_v3f32:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $40, %rsp

 ; AVX-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
 ; AVX-NEXT:    vroundss $11, %xmm2, %xmm2, %xmm2
 ; AVX-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0],xmm2[0],xmm1[2,3]
 ; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1],xmm0[0],xmm1[3]
 ; AVX-NEXT:    retq
 entry:
   %trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %trunc
 }
 
 define <3 x double> @constrained_vector_trunc_v3f64() #0 {
 ; CHECK-LABEL: constrained_vector_trunc_v3f64:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    subq $24, %rsp

 ; AVX-NEXT:    vmovsd {{.*#+}} xmm0 = mem[0],zero
 ; AVX-NEXT:    vroundsd $11, %xmm0, %xmm0, %xmm0
 ; AVX-NEXT:    vroundpd $11, {{.*}}(%rip), %xmm1
 ; AVX-NEXT:    vinsertf128 $1, %xmm0, %ymm1, %ymm0
 ; AVX-NEXT:    retq
 entry:
   %trunc = call <3 x double> @llvm.experimental.constrained.trunc.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   ret <3 x double> %trunc
 }
 
 define <1 x double> @constrained_vector_sitofp_v1f64_v1i32(<1 x i32> %x) #0 {
 ; CHECK-LABEL: constrained_vector_sitofp_v1f64_v1i32:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    cvtsi2sd %edi, %xmm0

 declare <2 x double> @llvm.experimental.constrained.cos.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.exp.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.exp2.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.log.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.log10.v2f64(<2 x double>, metadata, metadata)
 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)
 declare <2 x i64> @llvm.experimental.constrained.fptosi.v2i64.v2f64(<2 x double>, metadata)
 declare <2 x i32> @llvm.experimental.constrained.fptoui.v2i32.v2f32(<2 x float>, metadata)
 declare <2 x i64> @llvm.experimental.constrained.fptoui.v2i64.v2f32(<2 x float>, metadata)
 declare <2 x i32> @llvm.experimental.constrained.fptoui.v2i32.v2f64(<2 x double>, metadata)
 declare <2 x i64> @llvm.experimental.constrained.fptoui.v2i64.v2f64(<2 x double>, metadata)
 declare <2 x float> @llvm.experimental.constrained.fptrunc.v2f32.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.fpext.v2f64.v2f32(<2 x float>, metadata)
-declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata, metadata)
+declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata)
 declare <2 x double> @llvm.experimental.constrained.sitofp.v2f64.v2i32(<2 x i32>, metadata, metadata)
 declare <2 x float> @llvm.experimental.constrained.sitofp.v2f32.v2i32(<2 x i32>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.sitofp.v2f64.v2i64(<2 x i64>, metadata, metadata)
 declare <2 x float> @llvm.experimental.constrained.sitofp.v2f32.v2i64(<2 x i64>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.uitofp.v2f64.v2i32(<2 x i32>, metadata, metadata)
 declare <2 x float> @llvm.experimental.constrained.uitofp.v2f32.v2i32(<2 x i32>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.uitofp.v2f64.v2i64(<2 x i64>, metadata, metadata)
 declare <2 x float> @llvm.experimental.constrained.uitofp.v2f32.v2i64(<2 x i64>, metadata, metadata)

 declare <1 x float> @llvm.experimental.constrained.cos.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.exp.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.exp2.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.log.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.log10.v1f32(<1 x float>, metadata, metadata)
 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)
 declare <1 x i64> @llvm.experimental.constrained.fptosi.v1i64.v1f64(<1 x double>, metadata)
 declare <1 x i32> @llvm.experimental.constrained.fptoui.v1i32.v1f32(<1 x float>, metadata)
 declare <1 x i64> @llvm.experimental.constrained.fptoui.v1i64.v1f32(<1 x float>, metadata)
 declare <1 x i32> @llvm.experimental.constrained.fptoui.v1i32.v1f64(<1 x double>, metadata)
 declare <1 x i64> @llvm.experimental.constrained.fptoui.v1i64.v1f64(<1 x double>, metadata)
 declare <1 x float> @llvm.experimental.constrained.fptrunc.v1f32.v1f64(<1 x double>, metadata, metadata)
 declare <1 x double> @llvm.experimental.constrained.fpext.v1f64.v1f32(<1 x float>, metadata)
-declare <1 x float> @llvm.experimental.constrained.ceil.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.floor.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.round.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.trunc.v1f32(<1 x float>, metadata, metadata)
+declare <1 x float> @llvm.experimental.constrained.ceil.v1f32(<1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.floor.v1f32(<1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.round.v1f32(<1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.trunc.v1f32(<1 x float>, metadata)
 declare <1 x double> @llvm.experimental.constrained.sitofp.v1f64.v1i32(<1 x i32>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.sitofp.v1f32.v1i32(<1 x i32>, metadata, metadata)
 declare <1 x double> @llvm.experimental.constrained.sitofp.v1f64.v1i64(<1 x i64>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.sitofp.v1f32.v1i64(<1 x i64>, metadata, metadata)
 declare <1 x double> @llvm.experimental.constrained.uitofp.v1f64.v1i32(<1 x i32>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.uitofp.v1f32.v1i32(<1 x i32>, metadata, metadata)
 declare <1 x double> @llvm.experimental.constrained.uitofp.v1f64.v1i64(<1 x i64>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.uitofp.v1f32.v1i64(<1 x i64>, metadata, metadata)

 declare <3 x float> @llvm.experimental.constrained.log10.v3f32(<3 x float>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.log10.v3f64(<3 x double>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.log2.v3f32(<3 x float>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.log2.v3f64(<3 x double>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.rint.v3f32(<3 x float>, metadata, metadata)
 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)
 declare <3 x i64> @llvm.experimental.constrained.fptosi.v3i64.v3f64(<3 x double>, metadata)
 declare <3 x i32> @llvm.experimental.constrained.fptoui.v3i32.v3f32(<3 x float>, metadata)
 declare <3 x i64> @llvm.experimental.constrained.fptoui.v3i64.v3f32(<3 x float>, metadata)
 declare <3 x i32> @llvm.experimental.constrained.fptoui.v3i32.v3f64(<3 x double>, metadata)
 declare <3 x i64> @llvm.experimental.constrained.fptoui.v3i64.v3f64(<3 x double>, metadata)
 declare <3 x float> @llvm.experimental.constrained.fptrunc.v3f32.v3f64(<3 x double>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.fpext.v3f64.v3f32(<3 x float>, metadata)
-declare <3 x float> @llvm.experimental.constrained.ceil.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.ceil.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.floor.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.floor.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.round.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.round.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.trunc.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.trunc.v3f64(<3 x double>, metadata, metadata)
+declare <3 x float> @llvm.experimental.constrained.ceil.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.ceil.v3f64(<3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.floor.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.floor.v3f64(<3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.round.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.round.v3f64(<3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.trunc.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.trunc.v3f64(<3 x double>, metadata)
 declare <3 x double> @llvm.experimental.constrained.sitofp.v3f64.v3i32(<3 x i32>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.sitofp.v3f32.v3i32(<3 x i32>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.sitofp.v3f64.v3i64(<3 x i64>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.sitofp.v3f32.v3i64(<3 x i64>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.uitofp.v3f64.v3i32(<3 x i32>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.uitofp.v3f32.v3i32(<3 x i32>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.uitofp.v3f64.v3i64(<3 x i64>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.uitofp.v3f32.v3i64(<3 x i64>, metadata, metadata)

 declare <4 x double> @llvm.experimental.constrained.cos.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.exp.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.exp2.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.log.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.log10.v4f64(<4 x double>, metadata, metadata)
 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)
 declare <4 x i64> @llvm.experimental.constrained.fptosi.v4i64.v4f64(<4 x double>, metadata)
 declare <4 x i32> @llvm.experimental.constrained.fptoui.v4i32.v4f32(<4 x float>, metadata)
 declare <4 x i64> @llvm.experimental.constrained.fptoui.v4i64.v4f32(<4 x float>, metadata)
 declare <4 x i32> @llvm.experimental.constrained.fptoui.v4i32.v4f64(<4 x double>, metadata)
 declare <4 x i64> @llvm.experimental.constrained.fptoui.v4i64.v4f64(<4 x double>, metadata)
 declare <4 x float> @llvm.experimental.constrained.fptrunc.v4f32.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.fpext.v4f64.v4f32(<4 x float>, metadata)
-declare <4 x double> @llvm.experimental.constrained.ceil.v4f64(<4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.floor.v4f64(<4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.round.v4f64(<4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.trunc.v4f64(<4 x double>, metadata, metadata)
+declare <4 x double> @llvm.experimental.constrained.ceil.v4f64(<4 x double>, metadata)
+declare <4 x double> @llvm.experimental.constrained.floor.v4f64(<4 x double>, metadata)
+declare <4 x double> @llvm.experimental.constrained.round.v4f64(<4 x double>, metadata)
+declare <4 x double> @llvm.experimental.constrained.trunc.v4f64(<4 x double>, metadata)
 declare <4 x double> @llvm.experimental.constrained.sitofp.v4f64.v4i32(<4 x i32>, metadata, metadata)
 declare <4 x float> @llvm.experimental.constrained.sitofp.v4f32.v4i32(<4 x i32>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.sitofp.v4f64.v4i64(<4 x i64>, metadata, metadata)
 declare <4 x float> @llvm.experimental.constrained.sitofp.v4f32.v4i64(<4 x i64>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.uitofp.v4f64.v4i32(<4 x i32>, metadata, metadata)
 declare <4 x float> @llvm.experimental.constrained.uitofp.v4f32.v4i32(<4 x i32>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.uitofp.v4f64.v4i64(<4 x i64>, metadata, metadata)
 declare <4 x float> @llvm.experimental.constrained.uitofp.v4f32.v4i64(<4 x i64>, metadata, metadata)