diff --git a/clang/test/CodeGen/constrained-math-builtins.c b/clang/test/CodeGen/constrained-math-builtins.c
--- a/clang/test/CodeGen/constrained-math-builtins.c
+++ b/clang/test/CodeGen/constrained-math-builtins.c
@@ -23,9 +23,9 @@
 
   __builtin_ceil(f);       __builtin_ceilf(f);      __builtin_ceill(f);
 
-// CHECK: declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
-// CHECK: declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
-// CHECK: declare x86_fp80 @llvm.experimental.constrained.ceil.f80(x86_fp80, metadata, metadata)
+// CHECK: declare double @llvm.experimental.constrained.ceil.f64(double, metadata)
+// CHECK: declare float @llvm.experimental.constrained.ceil.f32(float, metadata)
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.ceil.f80(x86_fp80, metadata)
 
   __builtin_cos(f);        __builtin_cosf(f);       __builtin_cosl(f); 
 
@@ -47,9 +47,9 @@
 
   __builtin_floor(f);      __builtin_floorf(f);     __builtin_floorl(f);
 
-// CHECK: declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
-// CHECK: declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
-// CHECK: declare x86_fp80 @llvm.experimental.constrained.floor.f80(x86_fp80, metadata, metadata)
+// CHECK: declare double @llvm.experimental.constrained.floor.f64(double, metadata)
+// CHECK: declare float @llvm.experimental.constrained.floor.f32(float, metadata)
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.floor.f80(x86_fp80, metadata)
 
   __builtin_fma(f,f,f);        __builtin_fmaf(f,f,f);       __builtin_fmal(f,f,f);
 
@@ -59,15 +59,15 @@
 
   __builtin_fmax(f,f);       __builtin_fmaxf(f,f);      __builtin_fmaxl(f,f);
 
-// CHECK: declare double @llvm.experimental.constrained.maxnum.f64(double, double, metadata, metadata)
-// CHECK: declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata, metadata)
-// CHECK: declare x86_fp80 @llvm.experimental.constrained.maxnum.f80(x86_fp80, x86_fp80, metadata, metadata)
+// CHECK: declare double @llvm.experimental.constrained.maxnum.f64(double, double, metadata)
+// CHECK: declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata)
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.maxnum.f80(x86_fp80, x86_fp80, metadata)
 
   __builtin_fmin(f,f);       __builtin_fminf(f,f);      __builtin_fminl(f,f);
 
-// CHECK: declare double @llvm.experimental.constrained.minnum.f64(double, double, metadata, metadata)
-// CHECK: declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata, metadata)
-// CHECK: declare x86_fp80 @llvm.experimental.constrained.minnum.f80(x86_fp80, x86_fp80, metadata, metadata)
+// CHECK: declare double @llvm.experimental.constrained.minnum.f64(double, double, metadata)
+// CHECK: declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata)
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.minnum.f80(x86_fp80, x86_fp80, metadata)
 
   __builtin_llrint(f);     __builtin_llrintf(f);    __builtin_llrintl(f);
 
@@ -125,9 +125,9 @@
 
   __builtin_round(f);      __builtin_roundf(f);     __builtin_roundl(f);
 
-// CHECK: declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
-// CHECK: declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
-// CHECK: declare x86_fp80 @llvm.experimental.constrained.round.f80(x86_fp80, metadata, metadata)
+// CHECK: declare double @llvm.experimental.constrained.round.f64(double, metadata)
+// CHECK: declare float @llvm.experimental.constrained.round.f32(float, metadata)
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.round.f80(x86_fp80, metadata)
 
   __builtin_sin(f);        __builtin_sinf(f);       __builtin_sinl(f);
 
@@ -143,8 +143,8 @@
 
   __builtin_trunc(f);      __builtin_truncf(f);     __builtin_truncl(f);
 
-// CHECK: declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
-// CHECK: declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
-// CHECK: declare x86_fp80 @llvm.experimental.constrained.trunc.f80(x86_fp80, metadata, metadata)
+// CHECK: declare double @llvm.experimental.constrained.trunc.f64(double, metadata)
+// CHECK: declare float @llvm.experimental.constrained.trunc.f32(float, metadata)
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.trunc.f80(x86_fp80, metadata)
 };
 
diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst
--- a/llvm/docs/LangRef.rst
+++ b/llvm/docs/LangRef.rst
@@ -16478,7 +16478,6 @@
 
       declare <type>
       @llvm.experimental.constrained.maxnum(<type> <op1>, <type> <op2>
-                                            metadata <rounding mode>,
                                             metadata <exception behavior>)
 
 Overview:
@@ -16493,16 +16492,12 @@
 The first two arguments and the return value are floating-point numbers
 of the same type.
 
-The third and forth arguments specify the rounding mode and exception
-behavior as described above.
+The third argument specifies the exception behavior as described above.
 
 Semantics:
 """"""""""
 
-This function follows the IEEE-754 semantics for maxNum. The rounding mode is
-described, not determined, by the rounding mode argument. The actual rounding
-mode is determined by the runtime floating-point environment. The rounding
-mode argument is only intended as information to the compiler.
+This function follows the IEEE-754 semantics for maxNum.
 
 
 '``llvm.experimental.constrained.minnum``' Intrinsic
@@ -16515,7 +16510,6 @@
 
       declare <type>
       @llvm.experimental.constrained.minnum(<type> <op1>, <type> <op2>
-                                            metadata <rounding mode>,
                                             metadata <exception behavior>)
 
 Overview:
@@ -16530,16 +16524,12 @@
 The first two arguments and the return value are floating-point numbers
 of the same type.
 
-The third and forth arguments specify the rounding mode and exception
-behavior as described above.
+The third argument specifies the exception behavior as described above.
 
 Semantics:
 """"""""""
 
-This function follows the IEEE-754 semantics for minNum. The rounding mode is
-described, not determined, by the rounding mode argument. The actual rounding
-mode is determined by the runtime floating-point environment. The rounding
-mode argument is only intended as information to the compiler.
+This function follows the IEEE-754 semantics for minNum.
 
 
 '``llvm.experimental.constrained.ceil``' Intrinsic
@@ -16552,7 +16542,6 @@
 
       declare <type>
       @llvm.experimental.constrained.ceil(<type> <op1>,
-                                          metadata <rounding mode>,
                                           metadata <exception behavior>)
 
 Overview:
@@ -16567,9 +16556,7 @@
 The first argument and the return value are floating-point numbers of the same
 type.
 
-The second and third arguments specify the rounding mode and exception
-behavior as described above. The rounding mode is currently unused for this
-intrinsic.
+The second argument specifies the exception behavior as described above.
 
 Semantics:
 """"""""""
@@ -16588,7 +16575,6 @@
 
       declare <type>
       @llvm.experimental.constrained.floor(<type> <op1>,
-                                           metadata <rounding mode>,
                                            metadata <exception behavior>)
 
 Overview:
@@ -16603,9 +16589,7 @@
 The first argument and the return value are floating-point numbers of the same
 type.
 
-The second and third arguments specify the rounding mode and exception
-behavior as described above. The rounding mode is currently unused for this
-intrinsic.
+The second argument specifies the exception behavior as described above.
 
 Semantics:
 """"""""""
@@ -16624,7 +16608,6 @@
 
       declare <type>
       @llvm.experimental.constrained.round(<type> <op1>,
-                                           metadata <rounding mode>,
                                            metadata <exception behavior>)
 
 Overview:
@@ -16639,9 +16622,7 @@
 The first argument and the return value are floating-point numbers of the same
 type.
 
-The second and third arguments specify the rounding mode and exception
-behavior as described above. The rounding mode is currently unused for this
-intrinsic.
+The second argument specifies the exception behavior as described above.
 
 Semantics:
 """"""""""
@@ -16736,7 +16717,6 @@
 
       declare <type>
       @llvm.experimental.constrained.trunc(<type> <op1>,
-                                           metadata <truncing mode>,
                                            metadata <exception behavior>)
 
 Overview:
@@ -16752,9 +16732,7 @@
 The first argument and the return value are floating-point numbers of the same
 type.
 
-The second and third arguments specify the truncing mode and exception
-behavior as described above. The truncing mode is currently unused for this
-intrinsic.
+The second argument specifies the exception behavior as described above.
 
 Semantics:
 """"""""""
diff --git a/llvm/include/llvm/IR/ConstrainedOps.def b/llvm/include/llvm/IR/ConstrainedOps.def
--- a/llvm/include/llvm/IR/ConstrainedOps.def
+++ b/llvm/include/llvm/IR/ConstrainedOps.def
@@ -55,11 +55,11 @@
 // Theses are definitions for intrinsic functions, that are converted into
 // constrained intrinsics.
 //
-FUNCTION(ceil,            1, 1, experimental_constrained_ceil,       FCEIL)
+FUNCTION(ceil,            1, 0, experimental_constrained_ceil,       FCEIL)
 FUNCTION(cos,             1, 1, experimental_constrained_cos,        FCOS)
 FUNCTION(exp,             1, 1, experimental_constrained_exp,        FEXP)
 FUNCTION(exp2,            1, 1, experimental_constrained_exp2,       FEXP2)
-FUNCTION(floor,           1, 1, experimental_constrained_floor,      FFLOOR)
+FUNCTION(floor,           1, 0, experimental_constrained_floor,      FFLOOR)
 FUNCTION(fma,             3, 1, experimental_constrained_fma,        FMA)
 FUNCTION(log,             1, 1, experimental_constrained_log,        FLOG)
 FUNCTION(log10,           1, 1, experimental_constrained_log10,      FLOG10)
@@ -68,16 +68,16 @@
 FUNCTION(llrint,          1, 1, experimental_constrained_llrint,     LLRINT)
 FUNCTION(lround,          1, 0, experimental_constrained_lround,     LROUND)
 FUNCTION(llround,         1, 0, experimental_constrained_llround,    LLROUND)
-FUNCTION(maxnum,          2, 1, experimental_constrained_maxnum,     FMAXNUM)
-FUNCTION(minnum,          2, 1, experimental_constrained_minnum,     FMINNUM)
+FUNCTION(maxnum,          2, 0, experimental_constrained_maxnum,     FMAXNUM)
+FUNCTION(minnum,          2, 0, experimental_constrained_minnum,     FMINNUM)
 FUNCTION(nearbyint,       1, 1, experimental_constrained_nearbyint,  FNEARBYINT)
 FUNCTION(pow,             2, 1, experimental_constrained_pow,        FPOW)
 FUNCTION(powi,            2, 1, experimental_constrained_powi,       FPOWI)
 FUNCTION(rint,            1, 1, experimental_constrained_rint,       FRINT)
-FUNCTION(round,           1, 1, experimental_constrained_round,      FROUND)
+FUNCTION(round,           1, 0, experimental_constrained_round,      FROUND)
 FUNCTION(sin,             1, 1, experimental_constrained_sin,        FSIN)
 FUNCTION(sqrt,            1, 1, experimental_constrained_sqrt,       FSQRT)
-FUNCTION(trunc,           1, 1, experimental_constrained_trunc,      FTRUNC)
+FUNCTION(trunc,           1, 0, experimental_constrained_trunc,      FTRUNC)
 
 #undef INSTRUCTION
 #undef FUNCTION
diff --git a/llvm/include/llvm/IR/IRBuilder.h b/llvm/include/llvm/IR/IRBuilder.h
--- a/llvm/include/llvm/IR/IRBuilder.h
+++ b/llvm/include/llvm/IR/IRBuilder.h
@@ -2171,21 +2171,24 @@
       UseFMF = FMFSource->getFastMathFlags();
 
     CallInst *C;
+    bool HasRoundingMD = false;
     switch (ID) {
-    default: {
+    default:
+      break;
+#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)  \
+    case Intrinsic::INTRINSIC:                                \
+      HasRoundingMD = ROUND_MODE;                             \
+      break;
+#include "llvm/IR/ConstrainedOps.def"
+    }
+    if (HasRoundingMD) {
       Value *RoundingV = getConstrainedFPRounding(Rounding);
       C = CreateIntrinsic(ID, {DestTy, V->getType()}, {V, RoundingV, ExceptV},
                           nullptr, Name);
-    } break;
-    case Intrinsic::experimental_constrained_fpext:
-    case Intrinsic::experimental_constrained_fptoui:
-    case Intrinsic::experimental_constrained_fptosi:
-    case Intrinsic::experimental_constrained_lround:
-    case Intrinsic::experimental_constrained_llround:
+    } else
       C = CreateIntrinsic(ID, {DestTy, V->getType()}, {V, ExceptV}, nullptr,
                           Name);
-      break;
-    }
+
     setConstrainedFPCallAttr(C);
 
     if (isa<FPMathOperator>(C))
@@ -2402,18 +2405,18 @@
     for (auto *OneArg : Args)
       UseArgs.push_back(OneArg);
     Function *F = cast<Function>(Callee);
+    bool HasRoundingMD = false;
     switch (F->getIntrinsicID()) {
     default:
-      UseArgs.push_back(getConstrainedFPRounding(Rounding));
       break;
-    case Intrinsic::experimental_constrained_fpext:
-    case Intrinsic::experimental_constrained_fptoui:
-    case Intrinsic::experimental_constrained_fptosi:
-    case Intrinsic::experimental_constrained_lround:
-    case Intrinsic::experimental_constrained_llround:
-      // No rounding metadata for these intrinsics.
+#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)  \
+    case Intrinsic::INTRINSIC:                                \
+      HasRoundingMD = ROUND_MODE;                             \
       break;
+#include "llvm/IR/ConstrainedOps.def"
     }
+    if (HasRoundingMD)
+      UseArgs.push_back(getConstrainedFPRounding(Rounding));
     UseArgs.push_back(getConstrainedFPExcept(Except));
 
     CallInst *C = CreateCall(
diff --git a/llvm/include/llvm/IR/Intrinsics.td b/llvm/include/llvm/IR/Intrinsics.td
--- a/llvm/include/llvm/IR/Intrinsics.td
+++ b/llvm/include/llvm/IR/Intrinsics.td
@@ -724,20 +724,16 @@
   def int_experimental_constrained_maxnum : Intrinsic<[ llvm_anyfloat_ty ],
                                                       [ LLVMMatchType<0>,
                                                         LLVMMatchType<0>,
-                                                        llvm_metadata_ty,
                                                         llvm_metadata_ty ]>;
   def int_experimental_constrained_minnum : Intrinsic<[ llvm_anyfloat_ty ],
                                                       [ LLVMMatchType<0>,
                                                         LLVMMatchType<0>,
-                                                        llvm_metadata_ty,
                                                         llvm_metadata_ty ]>;
   def int_experimental_constrained_ceil : Intrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
-                                                      llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
   def int_experimental_constrained_floor : Intrinsic<[ llvm_anyfloat_ty ],
                                                      [ LLVMMatchType<0>,
-                                                       llvm_metadata_ty,
                                                        llvm_metadata_ty ]>;
   def int_experimental_constrained_lround : Intrinsic<[ llvm_anyint_ty ],
                                                       [ llvm_anyfloat_ty,
@@ -747,11 +743,9 @@
                                                          llvm_metadata_ty ]>;
   def int_experimental_constrained_round : Intrinsic<[ llvm_anyfloat_ty ],
                                                      [ LLVMMatchType<0>,
-                                                      llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
   def int_experimental_constrained_trunc : Intrinsic<[ llvm_anyfloat_ty ],
                                                      [ LLVMMatchType<0>,
-                                                       llvm_metadata_ty,
                                                        llvm_metadata_ty ]>;
 
   // Constrained floating-point comparison (quiet and signaling variants).
diff --git a/llvm/test/CodeGen/ARM/fp-intrinsics.ll b/llvm/test/CodeGen/ARM/fp-intrinsics.ll
--- a/llvm/test/CodeGen/ARM/fp-intrinsics.ll
+++ b/llvm/test/CodeGen/ARM/fp-intrinsics.ll
@@ -182,7 +182,7 @@
 ; CHECK-NOSP: bl fmaxf
 ; CHECK-SP: vmaxnm.f32
 define float @maxnum_f32(float %x, float %y) #0 {
-  %val = call float @llvm.experimental.constrained.maxnum.f32(float %x, float %y, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
+  %val = call float @llvm.experimental.constrained.maxnum.f32(float %x, float %y, metadata !"fpexcept.strict") #0
   ret float %val
 }
 
@@ -190,7 +190,7 @@
 ; CHECK-NOSP: bl fminf
 ; CHECK-SP: vminnm.f32
 define float @minnum_f32(float %x, float %y) #0 {
-  %val = call float @llvm.experimental.constrained.minnum.f32(float %x, float %y, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
+  %val = call float @llvm.experimental.constrained.minnum.f32(float %x, float %y, metadata !"fpexcept.strict") #0
   ret float %val
 }
 
@@ -198,7 +198,7 @@
 ; CHECK-NOSP: bl ceilf
 ; CHECK-SP: vrintp.f32
 define float @ceil_f32(float %x) #0 {
-  %val = call float @llvm.experimental.constrained.ceil.f32(float %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
+  %val = call float @llvm.experimental.constrained.ceil.f32(float %x, metadata !"fpexcept.strict") #0
   ret float %val
 }
 
@@ -206,7 +206,7 @@
 ; CHECK-NOSP: bl floorf
 ; CHECK-SP: vrintm.f32
 define float @floor_f32(float %x) #0 {
-  %val = call float @llvm.experimental.constrained.floor.f32(float %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
+  %val = call float @llvm.experimental.constrained.floor.f32(float %x, metadata !"fpexcept.strict") #0
   ret float %val
 }
 
@@ -228,7 +228,7 @@
 ; CHECK-NOSP: bl roundf
 ; CHECK-SP: vrinta.f32
 define float @round_f32(float %x) #0 {
-  %val = call float @llvm.experimental.constrained.round.f32(float %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
+  %val = call float @llvm.experimental.constrained.round.f32(float %x, metadata !"fpexcept.strict") #0
   ret float %val
 }
 
@@ -236,7 +236,7 @@
 ; CHECK-NOSP: bl truncf
 ; CHECK-SP: vrintz.f32
 define float @trunc_f32(float %x) #0 {
-  %val = call float @llvm.experimental.constrained.trunc.f32(float %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
+  %val = call float @llvm.experimental.constrained.trunc.f32(float %x, metadata !"fpexcept.strict") #0
   ret float %val
 }
 
@@ -411,7 +411,7 @@
 ; CHECK-NODP: bl fmax
 ; CHECK-DP: vmaxnm.f64
 define double @maxnum_f64(double %x, double %y) #0 {
-  %val = call double @llvm.experimental.constrained.maxnum.f64(double %x, double %y, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
+  %val = call double @llvm.experimental.constrained.maxnum.f64(double %x, double %y, metadata !"fpexcept.strict") #0
   ret double %val
 }
 
@@ -419,7 +419,7 @@
 ; CHECK-NODP: bl fmin
 ; CHECK-DP: vminnm.f64
 define double @minnum_f64(double %x, double %y) #0 {
-  %val = call double @llvm.experimental.constrained.minnum.f64(double %x, double %y, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
+  %val = call double @llvm.experimental.constrained.minnum.f64(double %x, double %y, metadata !"fpexcept.strict") #0
   ret double %val
 }
 
@@ -427,7 +427,7 @@
 ; CHECK-NODP: bl ceil
 ; CHECK-DP: vrintp.f64
 define double @ceil_f64(double %x) #0 {
-  %val = call double @llvm.experimental.constrained.ceil.f64(double %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
+  %val = call double @llvm.experimental.constrained.ceil.f64(double %x, metadata !"fpexcept.strict") #0
   ret double %val
 }
 
@@ -435,7 +435,7 @@
 ; CHECK-NODP: bl floor
 ; CHECK-DP: vrintm.f64
 define double @floor_f64(double %x) #0 {
-  %val = call double @llvm.experimental.constrained.floor.f64(double %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
+  %val = call double @llvm.experimental.constrained.floor.f64(double %x, metadata !"fpexcept.strict") #0
   ret double %val
 }
 
@@ -457,7 +457,7 @@
 ; CHECK-NODP: bl round
 ; CHECK-DP: vrinta.f64
 define double @round_f64(double %x) #0 {
-  %val = call double @llvm.experimental.constrained.round.f64(double %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
+  %val = call double @llvm.experimental.constrained.round.f64(double %x, metadata !"fpexcept.strict") #0
   ret double %val
 }
 
@@ -465,7 +465,7 @@
 ; CHECK-NODP: bl trunc
 ; CHECK-DP: vrintz.f64
 define double @trunc_f64(double %x) #0 {
-  %val = call double @llvm.experimental.constrained.trunc.f64(double %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
+  %val = call double @llvm.experimental.constrained.trunc.f64(double %x, metadata !"fpexcept.strict") #0
   ret double %val
 }
 
@@ -513,14 +513,14 @@
 declare float @llvm.experimental.constrained.nearbyint.f32(float, metadata, metadata)
 declare i32 @llvm.experimental.constrained.lrint.f32(float, metadata, metadata)
 declare i32 @llvm.experimental.constrained.llrint.f32(float, metadata, metadata)
-declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata, metadata)
-declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata, metadata)
-declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
-declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata)
+declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata)
+declare float @llvm.experimental.constrained.ceil.f32(float, metadata)
+declare float @llvm.experimental.constrained.floor.f32(float, metadata)
 declare i32 @llvm.experimental.constrained.lround.f32(float, metadata)
 declare i32 @llvm.experimental.constrained.llround.f32(float, metadata)
-declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
-declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.round.f32(float, metadata)
+declare float @llvm.experimental.constrained.trunc.f32(float, metadata)
 
 declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
 declare double @llvm.experimental.constrained.fsub.f64(double, double, metadata, metadata)
@@ -544,14 +544,14 @@
 declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
 declare i32 @llvm.experimental.constrained.lrint.f64(double, metadata, metadata)
 declare i32 @llvm.experimental.constrained.llrint.f64(double, metadata, metadata)
-declare double @llvm.experimental.constrained.maxnum.f64(double, double, metadata, metadata)
-declare double @llvm.experimental.constrained.minnum.f64(double, double, metadata, metadata)
-declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
-declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.maxnum.f64(double, double, metadata)
+declare double @llvm.experimental.constrained.minnum.f64(double, double, metadata)
+declare double @llvm.experimental.constrained.ceil.f64(double, metadata)
+declare double @llvm.experimental.constrained.floor.f64(double, metadata)
 declare i32 @llvm.experimental.constrained.lround.f64(double, metadata)
 declare i32 @llvm.experimental.constrained.llround.f64(double, metadata)
-declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
-declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.round.f64(double, metadata)
+declare double @llvm.experimental.constrained.trunc.f64(double, metadata)
 
 declare float @llvm.experimental.constrained.fptrunc.f32.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.fpext.f64.f32(float, metadata)
diff --git a/llvm/test/CodeGen/PowerPC/ppcf128-constrained-fp-intrinsics.ll b/llvm/test/CodeGen/PowerPC/ppcf128-constrained-fp-intrinsics.ll
--- a/llvm/test/CodeGen/PowerPC/ppcf128-constrained-fp-intrinsics.ll
+++ b/llvm/test/CodeGen/PowerPC/ppcf128-constrained-fp-intrinsics.ll
@@ -848,7 +848,6 @@
   %maxnum = call ppc_fp128 @llvm.experimental.constrained.maxnum.ppcf128(
                     ppc_fp128 %first,
                     ppc_fp128 %second,
-                    metadata !"round.dynamic",
                     metadata !"fpexcept.strict")
   ret ppc_fp128 %maxnum
 }
@@ -893,7 +892,6 @@
   %minnum = call ppc_fp128 @llvm.experimental.constrained.minnum.ppcf128(
                     ppc_fp128 %first,
                     ppc_fp128 %second,
-                    metadata !"round.dynamic",
                     metadata !"fpexcept.strict")
   ret ppc_fp128 %minnum
 }
@@ -937,7 +935,6 @@
 entry:
   %ceil = call ppc_fp128 @llvm.experimental.constrained.ceil.ppcf128(
                     ppc_fp128 %first,
-                    metadata !"round.dynamic",
                     metadata !"fpexcept.strict")
   ret ppc_fp128 %ceil
 }
@@ -981,7 +978,6 @@
 entry:
   %floor = call ppc_fp128 @llvm.experimental.constrained.floor.ppcf128(
                     ppc_fp128 %first,
-                    metadata !"round.dynamic",
                     metadata !"fpexcept.strict")
   ret ppc_fp128 %floor
 }
@@ -1025,7 +1021,6 @@
 entry:
   %round = call ppc_fp128 @llvm.experimental.constrained.round.ppcf128(
                     ppc_fp128 %first,
-                    metadata !"round.dynamic",
                     metadata !"fpexcept.strict")
   ret ppc_fp128 %round
 }
@@ -1069,7 +1064,6 @@
 entry:
   %trunc = call ppc_fp128 @llvm.experimental.constrained.trunc.ppcf128(
                     ppc_fp128 %first,
-                    metadata !"round.dynamic",
                     metadata !"fpexcept.strict")
   ret ppc_fp128 %trunc
 }
@@ -1536,12 +1530,12 @@
 }
 
 declare ppc_fp128 @llvm.experimental.constrained.fadd.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
-declare ppc_fp128 @llvm.experimental.constrained.ceil.ppcf128(ppc_fp128, metadata, metadata)
+declare ppc_fp128 @llvm.experimental.constrained.ceil.ppcf128(ppc_fp128, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.cos.ppcf128(ppc_fp128, metadata, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.fdiv.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.exp.ppcf128(ppc_fp128, metadata, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.exp2.ppcf128(ppc_fp128, metadata, metadata)
-declare ppc_fp128 @llvm.experimental.constrained.floor.ppcf128(ppc_fp128, metadata, metadata)
+declare ppc_fp128 @llvm.experimental.constrained.floor.ppcf128(ppc_fp128, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.fma.ppcf128(ppc_fp128, ppc_fp128, ppc_fp128, metadata, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.fpext.f32.ppcf128(float, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.fpext.f64.ppcf128(double, metadata)
@@ -1550,19 +1544,19 @@
 declare ppc_fp128 @llvm.experimental.constrained.log.ppcf128(ppc_fp128, metadata, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.log10.ppcf128(ppc_fp128, metadata, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.log2.ppcf128(ppc_fp128, metadata, metadata)
-declare ppc_fp128 @llvm.experimental.constrained.maxnum.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
-declare ppc_fp128 @llvm.experimental.constrained.minnum.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
+declare ppc_fp128 @llvm.experimental.constrained.maxnum.ppcf128(ppc_fp128, ppc_fp128, metadata)
+declare ppc_fp128 @llvm.experimental.constrained.minnum.ppcf128(ppc_fp128, ppc_fp128, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.fmul.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.nearbyint.ppcf128(ppc_fp128, metadata, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.pow.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.powi.ppcf128(ppc_fp128, i32, metadata, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.frem.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.rint.ppcf128(ppc_fp128, metadata, metadata)
-declare ppc_fp128 @llvm.experimental.constrained.round.ppcf128(ppc_fp128, metadata, metadata)
+declare ppc_fp128 @llvm.experimental.constrained.round.ppcf128(ppc_fp128, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.sin.ppcf128(ppc_fp128, metadata, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.sqrt.ppcf128(ppc_fp128, metadata, metadata)
 declare ppc_fp128 @llvm.experimental.constrained.fsub.ppcf128(ppc_fp128, ppc_fp128, metadata, metadata)
-declare ppc_fp128 @llvm.experimental.constrained.trunc.ppcf128(ppc_fp128, metadata, metadata)
+declare ppc_fp128 @llvm.experimental.constrained.trunc.ppcf128(ppc_fp128, metadata)
 declare i64 @llvm.experimental.constrained.fptosi.i64.ppcf128(ppc_fp128, metadata)
 declare i32 @llvm.experimental.constrained.fptosi.i32.ppcf128(ppc_fp128, metadata)
 declare i64 @llvm.experimental.constrained.fptoui.i64.ppcf128(ppc_fp128, metadata)
diff --git a/llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll b/llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll
--- a/llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll
+++ b/llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll
@@ -5490,7 +5490,6 @@
 entry:
   %max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32(
                                <1 x float> <float 42.0>, <1 x float> <float 41.0>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #1
   ret <1 x float> %max
 }
@@ -5555,7 +5554,6 @@
   %max = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64(
                                 <2 x double> <double 43.0, double 42.0>,
                                 <2 x double> <double 41.0, double 40.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <2 x double> %max
 }
@@ -5658,7 +5656,6 @@
   %max = call <3 x float> @llvm.experimental.constrained.maxnum.v3f32(
                               <3 x float> <float 43.0, float 44.0, float 45.0>,
                               <3 x float> <float 41.0, float 42.0, float 43.0>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #1
   ret <3 x float> %max
 }
@@ -5749,7 +5746,6 @@
   %max = call <3 x double> @llvm.experimental.constrained.maxnum.v3f64(
                           <3 x double> <double 43.0, double 44.0, double 45.0>,
                           <3 x double> <double 40.0, double 41.0, double 42.0>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #1
   ret <3 x double> %max
 }
@@ -5860,7 +5856,6 @@
                                               double 46.0, double 47.0>,
                                 <4 x double> <double 40.0, double 41.0,
                                               double 42.0, double 43.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <4 x double> %max
 }
@@ -5904,7 +5899,6 @@
  entry:
   %min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32(
                                <1 x float> <float 42.0>, <1 x float> <float 41.0>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #1
   ret <1 x float> %min
 }
@@ -5969,7 +5963,6 @@
   %min = call <2 x double> @llvm.experimental.constrained.minnum.v2f64(
                                 <2 x double> <double 43.0, double 42.0>,
                                 <2 x double> <double 41.0, double 40.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <2 x double> %min
 }
@@ -6072,7 +6065,6 @@
   %min = call <3 x float> @llvm.experimental.constrained.minnum.v3f32(
                               <3 x float> <float 43.0, float 44.0, float 45.0>,
                               <3 x float> <float 41.0, float 42.0, float 43.0>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #1
   ret <3 x float> %min
 }
@@ -6163,7 +6155,6 @@
  %min = call <3 x double> @llvm.experimental.constrained.minnum.v3f64(
                           <3 x double> <double 43.0, double 44.0, double 45.0>,
                           <3 x double> <double 40.0, double 41.0, double 42.0>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #1
   ret <3 x double> %min
 }
@@ -6274,7 +6265,6 @@
                                               double 46.0, double 47.0>,
                                 <4 x double> <double 40.0, double 41.0,
                                               double 42.0, double 43.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <4 x double> %min
 }
@@ -6574,7 +6564,6 @@
 entry:
   %ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #1
   ret <1 x float> %ceil
 }
@@ -6599,7 +6588,6 @@
 entry:
   %ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <2 x double> %ceil
 }
@@ -6655,7 +6643,6 @@
 entry:
   %ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #1
   ret <3 x float> %ceil
 }
@@ -6692,7 +6679,6 @@
 entry:
   %ceil = call <3 x double> @llvm.experimental.constrained.ceil.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #1
   ret <3 x double> %ceil
 }
@@ -6718,7 +6704,6 @@
 entry:
   %floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #1
   ret <1 x float> %floor
 }
@@ -6744,7 +6729,6 @@
 entry:
   %floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <2 x double> %floor
 }
@@ -6800,7 +6784,6 @@
 entry:
   %floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #1
   ret <3 x float> %floor
 }
@@ -6837,7 +6820,6 @@
 entry:
   %floor = call <3 x double> @llvm.experimental.constrained.floor.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #1
   ret <3 x double> %floor
 }
@@ -6863,7 +6845,6 @@
 entry:
   %round = call <1 x float> @llvm.experimental.constrained.round.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #1
   ret <1 x float> %round
 }
@@ -6888,7 +6869,6 @@
 entry:
   %round = call <2 x double> @llvm.experimental.constrained.round.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <2 x double> %round
 }
@@ -6944,7 +6924,6 @@
 entry:
   %round = call <3 x float> @llvm.experimental.constrained.round.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #1
   ret <3 x float> %round
 }
@@ -6982,7 +6961,6 @@
 entry:
   %round = call <3 x double> @llvm.experimental.constrained.round.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #1
   ret <3 x double> %round
 }
@@ -7008,7 +6986,6 @@
 entry:
   %trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #1
   ret <1 x float> %trunc
 }
@@ -7033,7 +7010,6 @@
 entry:
   %trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #1
   ret <2 x double> %trunc
 }
@@ -7089,7 +7065,6 @@
 entry:
   %trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #1
   ret <3 x float> %trunc
 }
@@ -7126,7 +7101,6 @@
 entry:
   %trunc = call <3 x double> @llvm.experimental.constrained.trunc.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #1
   ret <3 x double> %trunc
 }
@@ -7152,14 +7126,14 @@
 declare <2 x double> @llvm.experimental.constrained.log2.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.rint.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
+declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata)
 declare <2 x float> @llvm.experimental.constrained.fptrunc.v2f32.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.fpext.v2f64.v2f32(<2 x float>, metadata)
-declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata, metadata)
+declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata)
 
 ; Scalar width declarations
 declare <1 x float> @llvm.experimental.constrained.fadd.v1f32(<1 x float>, <1 x float>, metadata, metadata)
@@ -7179,14 +7153,14 @@
 declare <1 x float> @llvm.experimental.constrained.log2.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.rint.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.nearbyint.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.maxnum.v1f32(<1 x float>, <1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.minnum.v1f32(<1 x float>, <1 x float>, metadata, metadata)
+declare <1 x float> @llvm.experimental.constrained.maxnum.v1f32(<1 x float>, <1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.minnum.v1f32(<1 x float>, <1 x float>, metadata)
 declare <1 x float> @llvm.experimental.constrained.fptrunc.v1f32.v1f64(<1 x double>, metadata, metadata)
 declare <1 x double> @llvm.experimental.constrained.fpext.v1f64.v1f32(<1 x float>, metadata)
-declare <1 x float> @llvm.experimental.constrained.ceil.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.floor.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.round.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.trunc.v1f32(<1 x float>, metadata, metadata)
+declare <1 x float> @llvm.experimental.constrained.ceil.v1f32(<1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.floor.v1f32(<1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.round.v1f32(<1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.trunc.v1f32(<1 x float>, metadata)
 
 ; Illegal width declarations
 declare <3 x float> @llvm.experimental.constrained.fadd.v3f32(<3 x float>, <3 x float>, metadata, metadata)
@@ -7223,20 +7197,20 @@
 declare <3 x double> @llvm.experimental.constrained.rint.v3f64(<3 x double>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.nearbyint.v3f32(<3 x float>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.nearbyint.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.maxnum.v3f32(<3 x float>, <3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.maxnum.v3f64(<3 x double>, <3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.minnum.v3f32(<3 x float>, <3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.minnum.v3f64(<3 x double>, <3 x double>, metadata, metadata)
+declare <3 x float> @llvm.experimental.constrained.maxnum.v3f32(<3 x float>, <3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.maxnum.v3f64(<3 x double>, <3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.minnum.v3f32(<3 x float>, <3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.minnum.v3f64(<3 x double>, <3 x double>, metadata)
 declare <3 x float> @llvm.experimental.constrained.fptrunc.v3f32.v3f64(<3 x double>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.fpext.v3f64.v3f32(<3 x float>, metadata)
-declare <3 x float> @llvm.experimental.constrained.ceil.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.ceil.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.floor.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.floor.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.round.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.round.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.trunc.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.trunc.v3f64(<3 x double>, metadata, metadata)
+declare <3 x float> @llvm.experimental.constrained.ceil.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.ceil.v3f64(<3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.floor.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.floor.v3f64(<3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.round.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.round.v3f64(<3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.trunc.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.trunc.v3f64(<3 x double>, metadata)
 
 ; Double width declarations
 declare <4 x double> @llvm.experimental.constrained.fadd.v4f64(<4 x double>, <4 x double>, metadata, metadata)
@@ -7256,11 +7230,11 @@
 declare <4 x double> @llvm.experimental.constrained.log2.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.rint.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.nearbyint.v4f64(<4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.maxnum.v4f64(<4 x double>, <4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.minnum.v4f64(<4 x double>, <4 x double>, metadata, metadata)
+declare <4 x double> @llvm.experimental.constrained.maxnum.v4f64(<4 x double>, <4 x double>, metadata)
+declare <4 x double> @llvm.experimental.constrained.minnum.v4f64(<4 x double>, <4 x double>, metadata)
 declare <4 x float> @llvm.experimental.constrained.fptrunc.v4f32.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.fpext.v4f64.v4f32(<4 x float>, metadata)
-declare <4 x double> @llvm.experimental.constrained.ceil.v4f64(<4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.floor.v4f64(<4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.round.v4f64(<4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.trunc.v4f64(<4 x double>, metadata, metadata)
+declare <4 x double> @llvm.experimental.constrained.ceil.v4f64(<4 x double>, metadata)
+declare <4 x double> @llvm.experimental.constrained.floor.v4f64(<4 x double>, metadata)
+declare <4 x double> @llvm.experimental.constrained.round.v4f64(<4 x double>, metadata)
+declare <4 x double> @llvm.experimental.constrained.trunc.v4f64(<4 x double>, metadata)
diff --git a/llvm/test/CodeGen/SystemZ/fp-strict-round-01.ll b/llvm/test/CodeGen/SystemZ/fp-strict-round-01.ll
--- a/llvm/test/CodeGen/SystemZ/fp-strict-round-01.ll
+++ b/llvm/test/CodeGen/SystemZ/fp-strict-round-01.ll
@@ -85,33 +85,31 @@
 }
 
 ; Test floor for f32.
-declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.floor.f32(float, metadata)
 define float @f7(float %f) #0 {
 ; CHECK-LABEL: f7:
 ; CHECK: brasl %r14, floorf@PLT
 ; CHECK: br %r14
   %res = call float @llvm.experimental.constrained.floor.f32(
                         float %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
 
 ; Test floor for f64.
-declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.floor.f64(double, metadata)
 define double @f8(double %f) #0 {
 ; CHECK-LABEL: f8:
 ; CHECK: brasl %r14, floor@PLT
 ; CHECK: br %r14
   %res = call double @llvm.experimental.constrained.floor.f64(
                         double %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
 
 ; Test floor for f128.
-declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata)
 define void @f9(fp128 *%ptr) #0 {
 ; CHECK-LABEL: f9:
 ; CHECK: brasl %r14, floorl@PLT
@@ -119,40 +117,37 @@
   %src = load fp128, fp128 *%ptr
   %res = call fp128 @llvm.experimental.constrained.floor.f128(
                         fp128 %src,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
 }
 
 ; Test ceil for f32.
-declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.ceil.f32(float, metadata)
 define float @f10(float %f) #0 {
 ; CHECK-LABEL: f10:
 ; CHECK: brasl %r14, ceilf@PLT
 ; CHECK: br %r14
   %res = call float @llvm.experimental.constrained.ceil.f32(
                         float %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
 
 ; Test ceil for f64.
-declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.ceil.f64(double, metadata)
 define double @f11(double %f) #0 {
 ; CHECK-LABEL: f11:
 ; CHECK: brasl %r14, ceil@PLT
 ; CHECK: br %r14
   %res = call double @llvm.experimental.constrained.ceil.f64(
                         double %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
 
 ; Test ceil for f128.
-declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata)
 define void @f12(fp128 *%ptr) #0 {
 ; CHECK-LABEL: f12:
 ; CHECK: brasl %r14, ceill@PLT
@@ -160,40 +155,37 @@
   %src = load fp128, fp128 *%ptr
   %res = call fp128 @llvm.experimental.constrained.ceil.f128(
                         fp128 %src,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
 }
 
 ; Test trunc for f32.
-declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.trunc.f32(float, metadata)
 define float @f13(float %f) #0 {
 ; CHECK-LABEL: f13:
 ; CHECK: brasl %r14, truncf@PLT
 ; CHECK: br %r14
   %res = call float @llvm.experimental.constrained.trunc.f32(
                         float %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
 
 ; Test trunc for f64.
-declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.trunc.f64(double, metadata)
 define double @f14(double %f) #0 {
 ; CHECK-LABEL: f14:
 ; CHECK: brasl %r14, trunc@PLT
 ; CHECK: br %r14
   %res = call double @llvm.experimental.constrained.trunc.f64(
                         double %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
 
 ; Test trunc for f128.
-declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata)
 define void @f15(fp128 *%ptr) #0 {
 ; CHECK-LABEL: f15:
 ; CHECK: brasl %r14, truncl@PLT
@@ -201,40 +193,37 @@
   %src = load fp128, fp128 *%ptr
   %res = call fp128 @llvm.experimental.constrained.trunc.f128(
                         fp128 %src,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
 }
 
 ; Test round for f32.
-declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.round.f32(float, metadata)
 define float @f16(float %f) #0 {
 ; CHECK-LABEL: f16:
 ; CHECK: brasl %r14, roundf@PLT
 ; CHECK: br %r14
   %res = call float @llvm.experimental.constrained.round.f32(
                         float %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
 
 ; Test round for f64.
-declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.round.f64(double, metadata)
 define double @f17(double %f) #0 {
 ; CHECK-LABEL: f17:
 ; CHECK: brasl %r14, round@PLT
 ; CHECK: br %r14
   %res = call double @llvm.experimental.constrained.round.f64(
                         double %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
 
 ; Test round for f128.
-declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata)
 define void @f18(fp128 *%ptr) #0 {
 ; CHECK-LABEL: f18:
 ; CHECK: brasl %r14, roundl@PLT
@@ -242,7 +231,6 @@
   %src = load fp128, fp128 *%ptr
   %res = call fp128 @llvm.experimental.constrained.round.f128(
                         fp128 %src,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
diff --git a/llvm/test/CodeGen/SystemZ/fp-strict-round-02.ll b/llvm/test/CodeGen/SystemZ/fp-strict-round-02.ll
--- a/llvm/test/CodeGen/SystemZ/fp-strict-round-02.ll
+++ b/llvm/test/CodeGen/SystemZ/fp-strict-round-02.ll
@@ -89,33 +89,31 @@
 }
 
 ; Test floor for f32.
-declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.floor.f32(float, metadata)
 define float @f7(float %f) #0 {
 ; CHECK-LABEL: f7:
 ; CHECK: fiebra %f0, 7, %f0, 4
 ; CHECK: br %r14
   %res = call float @llvm.experimental.constrained.floor.f32(
                         float %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
 
 ; Test floor for f64.
-declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.floor.f64(double, metadata)
 define double @f8(double %f) #0 {
 ; CHECK-LABEL: f8:
 ; CHECK: fidbra %f0, 7, %f0, 4
 ; CHECK: br %r14
   %res = call double @llvm.experimental.constrained.floor.f64(
                         double %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
 
 ; Test floor for f128.
-declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata)
 define void @f9(fp128 *%ptr) #0 {
 ; CHECK-LABEL: f9:
 ; CHECK: fixbra %f0, 7, %f0, 4
@@ -123,40 +121,37 @@
   %src = load fp128, fp128 *%ptr
   %res = call fp128 @llvm.experimental.constrained.floor.f128(
                         fp128 %src,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
 }
 
 ; Test ceil for f32.
-declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.ceil.f32(float, metadata)
 define float @f10(float %f) #0 {
 ; CHECK-LABEL: f10:
 ; CHECK: fiebra %f0, 6, %f0, 4
 ; CHECK: br %r14
   %res = call float @llvm.experimental.constrained.ceil.f32(
                         float %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
 
 ; Test ceil for f64.
-declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.ceil.f64(double, metadata)
 define double @f11(double %f) #0 {
 ; CHECK-LABEL: f11:
 ; CHECK: fidbra %f0, 6, %f0, 4
 ; CHECK: br %r14
   %res = call double @llvm.experimental.constrained.ceil.f64(
                         double %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
 
 ; Test ceil for f128.
-declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata)
 define void @f12(fp128 *%ptr) #0 {
 ; CHECK-LABEL: f12:
 ; CHECK: fixbra %f0, 6, %f0, 4
@@ -164,40 +159,37 @@
   %src = load fp128, fp128 *%ptr
   %res = call fp128 @llvm.experimental.constrained.ceil.f128(
                         fp128 %src,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
 }
 
 ; Test trunc for f32.
-declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.trunc.f32(float, metadata)
 define float @f13(float %f) #0 {
 ; CHECK-LABEL: f13:
 ; CHECK: fiebra %f0, 5, %f0, 4
 ; CHECK: br %r14
   %res = call float @llvm.experimental.constrained.trunc.f32(
                         float %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
 
 ; Test trunc for f64.
-declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.trunc.f64(double, metadata)
 define double @f14(double %f) #0 {
 ; CHECK-LABEL: f14:
 ; CHECK: fidbra %f0, 5, %f0, 4
 ; CHECK: br %r14
   %res = call double @llvm.experimental.constrained.trunc.f64(
                         double %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
 
 ; Test trunc for f128.
-declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata)
 define void @f15(fp128 *%ptr) #0 {
 ; CHECK-LABEL: f15:
 ; CHECK: fixbra %f0, 5, %f0, 4
@@ -205,40 +197,37 @@
   %src = load fp128, fp128 *%ptr
   %res = call fp128 @llvm.experimental.constrained.trunc.f128(
                         fp128 %src,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
 }
 
 ; Test round for f32.
-declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.round.f32(float, metadata)
 define float @f16(float %f) #0 {
 ; CHECK-LABEL: f16:
 ; CHECK: fiebra %f0, 1, %f0, 4
 ; CHECK: br %r14
   %res = call float @llvm.experimental.constrained.round.f32(
                         float %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
 
 ; Test round for f64.
-declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.round.f64(double, metadata)
 define double @f17(double %f) #0 {
 ; CHECK-LABEL: f17:
 ; CHECK: fidbra %f0, 1, %f0, 4
 ; CHECK: br %r14
   %res = call double @llvm.experimental.constrained.round.f64(
                         double %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
 
 ; Test round for f128.
-declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata)
 define void @f18(fp128 *%ptr) #0 {
 ; CHECK-LABEL: f18:
 ; CHECK: fixbra %f0, 1, %f0, 4
@@ -246,7 +235,6 @@
   %src = load fp128, fp128 *%ptr
   %res = call fp128 @llvm.experimental.constrained.round.f128(
                         fp128 %src,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
diff --git a/llvm/test/CodeGen/SystemZ/fp-strict-round-03.ll b/llvm/test/CodeGen/SystemZ/fp-strict-round-03.ll
--- a/llvm/test/CodeGen/SystemZ/fp-strict-round-03.ll
+++ b/llvm/test/CodeGen/SystemZ/fp-strict-round-03.ll
@@ -89,33 +89,31 @@
 }
 
 ; Test floor for f32.
-declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.floor.f32(float, metadata)
 define float @f7(float %f) #0 {
 ; CHECK-LABEL: f7:
 ; CHECK: fiebra %f0, 7, %f0, 4
 ; CHECK: br %r14
   %res = call float @llvm.experimental.constrained.floor.f32(
                         float %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
 
 ; Test floor for f64.
-declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.floor.f64(double, metadata)
 define double @f8(double %f) #0 {
 ; CHECK-LABEL: f8:
 ; CHECK: fidbra %f0, 7, %f0, 4
 ; CHECK: br %r14
   %res = call double @llvm.experimental.constrained.floor.f64(
                         double %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
 
 ; Test floor for f128.
-declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata)
 define void @f9(fp128 *%ptr) #0 {
 ; CHECK-LABEL: f9:
 ; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
@@ -125,40 +123,37 @@
   %src = load fp128, fp128 *%ptr
   %res = call fp128 @llvm.experimental.constrained.floor.f128(
                         fp128 %src,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
 }
 
 ; Test ceil for f32.
-declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.ceil.f32(float, metadata)
 define float @f10(float %f) #0 {
 ; CHECK-LABEL: f10:
 ; CHECK: fiebra %f0, 6, %f0, 4
 ; CHECK: br %r14
   %res = call float @llvm.experimental.constrained.ceil.f32(
                         float %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
 
 ; Test ceil for f64.
-declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.ceil.f64(double, metadata)
 define double @f11(double %f) #0 {
 ; CHECK-LABEL: f11:
 ; CHECK: fidbra %f0, 6, %f0, 4
 ; CHECK: br %r14
   %res = call double @llvm.experimental.constrained.ceil.f64(
                         double %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
 
 ; Test ceil for f128.
-declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata)
 define void @f12(fp128 *%ptr) #0 {
 ; CHECK-LABEL: f12:
 ; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
@@ -168,40 +163,37 @@
   %src = load fp128, fp128 *%ptr
   %res = call fp128 @llvm.experimental.constrained.ceil.f128(
                         fp128 %src,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
 }
 
 ; Test trunc for f32.
-declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.trunc.f32(float, metadata)
 define float @f13(float %f) #0 {
 ; CHECK-LABEL: f13:
 ; CHECK: fiebra %f0, 5, %f0, 4
 ; CHECK: br %r14
   %res = call float @llvm.experimental.constrained.trunc.f32(
                         float %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
 
 ; Test trunc for f64.
-declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.trunc.f64(double, metadata)
 define double @f14(double %f) #0 {
 ; CHECK-LABEL: f14:
 ; CHECK: fidbra %f0, 5, %f0, 4
 ; CHECK: br %r14
   %res = call double @llvm.experimental.constrained.trunc.f64(
                         double %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
 
 ; Test trunc for f128.
-declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata)
 define void @f15(fp128 *%ptr) #0 {
 ; CHECK-LABEL: f15:
 ; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
@@ -211,40 +203,37 @@
   %src = load fp128, fp128 *%ptr
   %res = call fp128 @llvm.experimental.constrained.trunc.f128(
                         fp128 %src,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
 }
 
 ; Test round for f32.
-declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.round.f32(float, metadata)
 define float @f16(float %f) #0 {
 ; CHECK-LABEL: f16:
 ; CHECK: fiebra %f0, 1, %f0, 4
 ; CHECK: br %r14
   %res = call float @llvm.experimental.constrained.round.f32(
                         float %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
 
 ; Test round for f64.
-declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.round.f64(double, metadata)
 define double @f17(double %f) #0 {
 ; CHECK-LABEL: f17:
 ; CHECK: fidbra %f0, 1, %f0, 4
 ; CHECK: br %r14
   %res = call double @llvm.experimental.constrained.round.f64(
                         double %f,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
 
 ; Test round for f128.
-declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata)
 define void @f18(fp128 *%ptr) #0 {
 ; CHECK-LABEL: f18:
 ; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
@@ -254,7 +243,6 @@
   %src = load fp128, fp128 *%ptr
   %res = call fp128 @llvm.experimental.constrained.round.f128(
                         fp128 %src,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128 *%ptr
   ret void
diff --git a/llvm/test/CodeGen/SystemZ/vec-strict-max-01.ll b/llvm/test/CodeGen/SystemZ/vec-strict-max-01.ll
--- a/llvm/test/CodeGen/SystemZ/vec-strict-max-01.ll
+++ b/llvm/test/CodeGen/SystemZ/vec-strict-max-01.ll
@@ -2,13 +2,13 @@
 ;
 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z14 | FileCheck %s
 
-declare double @llvm.experimental.constrained.maxnum.f64(double, double, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
+declare double @llvm.experimental.constrained.maxnum.f64(double, double, metadata)
+declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata)
 
-declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata, metadata)
-declare <4 x float> @llvm.experimental.constrained.maxnum.v4f32(<4 x float>, <4 x float>, metadata, metadata)
+declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata)
+declare <4 x float> @llvm.experimental.constrained.maxnum.v4f32(<4 x float>, <4 x float>, metadata)
 
-declare fp128 @llvm.experimental.constrained.maxnum.f128(fp128, fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.maxnum.f128(fp128, fp128, metadata)
 
 ; Test the f64 maxnum intrinsic.
 define double @f1(double %dummy, double %val1, double %val2) #0 {
@@ -17,7 +17,6 @@
 ; CHECK: br %r14
   %ret = call double @llvm.experimental.constrained.maxnum.f64(
                         double %val1, double %val2,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %ret
 }
@@ -30,7 +29,6 @@
 ; CHECK: br %r14
   %ret = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64(
                         <2 x double> %val1, <2 x double> %val2,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <2 x double> %ret
 }
@@ -42,7 +40,6 @@
 ; CHECK: br %r14
   %ret = call float @llvm.experimental.constrained.maxnum.f32(
                         float %val1, float %val2,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %ret
 }
@@ -55,7 +52,6 @@
 ; CHECK: br %r14
   %ret = call <4 x float> @llvm.experimental.constrained.maxnum.v4f32(
                         <4 x float> %val1, <4 x float> %val2,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <4 x float> %ret
 }
@@ -72,7 +68,6 @@
   %val2 = load fp128, fp128* %ptr2
   %res = call fp128 @llvm.experimental.constrained.maxnum.f128(
                         fp128 %val1, fp128 %val2,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128* %dst
   ret void
diff --git a/llvm/test/CodeGen/SystemZ/vec-strict-min-01.ll b/llvm/test/CodeGen/SystemZ/vec-strict-min-01.ll
--- a/llvm/test/CodeGen/SystemZ/vec-strict-min-01.ll
+++ b/llvm/test/CodeGen/SystemZ/vec-strict-min-01.ll
@@ -2,13 +2,13 @@
 ;
 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z14 | FileCheck %s
 
-declare double @llvm.experimental.constrained.minnum.f64(double, double, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
+declare double @llvm.experimental.constrained.minnum.f64(double, double, metadata)
+declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata)
 
-declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata, metadata)
-declare <4 x float> @llvm.experimental.constrained.minnum.v4f32(<4 x float>, <4 x float>, metadata, metadata)
+declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata)
+declare <4 x float> @llvm.experimental.constrained.minnum.v4f32(<4 x float>, <4 x float>, metadata)
 
-declare fp128 @llvm.experimental.constrained.minnum.f128(fp128, fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.minnum.f128(fp128, fp128, metadata)
 
 ; Test the f64 minnum intrinsic.
 define double @f1(double %dummy, double %val1, double %val2) #0 {
@@ -17,7 +17,6 @@
 ; CHECK: br %r14
   %ret = call double @llvm.experimental.constrained.minnum.f64(
                         double %val1, double %val2,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %ret
 }
@@ -30,7 +29,6 @@
 ; CHECK: br %r14
   %ret = call <2 x double> @llvm.experimental.constrained.minnum.v2f64(
                         <2 x double> %val1, <2 x double> %val2,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <2 x double> %ret
 }
@@ -42,7 +40,6 @@
 ; CHECK: br %r14
   %ret = call float @llvm.experimental.constrained.minnum.f32(
                         float %val1, float %val2,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %ret
 }
@@ -55,7 +52,6 @@
 ; CHECK: br %r14
   %ret = call <4 x float> @llvm.experimental.constrained.minnum.v4f32(
                         <4 x float> %val1, <4 x float> %val2,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <4 x float> %ret
 }
@@ -72,7 +68,6 @@
   %val2 = load fp128, fp128* %ptr2
   %res = call fp128 @llvm.experimental.constrained.minnum.f128(
                         fp128 %val1, fp128 %val2,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   store fp128 %res, fp128* %dst
   ret void
diff --git a/llvm/test/CodeGen/SystemZ/vec-strict-round-01.ll b/llvm/test/CodeGen/SystemZ/vec-strict-round-01.ll
--- a/llvm/test/CodeGen/SystemZ/vec-strict-round-01.ll
+++ b/llvm/test/CodeGen/SystemZ/vec-strict-round-01.ll
@@ -4,16 +4,16 @@
 
 declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
-declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
-declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
-declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
-declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.floor.f64(double, metadata)
+declare double @llvm.experimental.constrained.ceil.f64(double, metadata)
+declare double @llvm.experimental.constrained.trunc.f64(double, metadata)
+declare double @llvm.experimental.constrained.round.f64(double, metadata)
 declare <2 x double> @llvm.experimental.constrained.rint.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata, metadata)
+declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata)
 
 define <2 x double> @f1(<2 x double> %val) #0 {
 ; CHECK-LABEL: f1:
@@ -43,7 +43,6 @@
 ; CHECK: br %r14
   %res = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
                         <2 x double> %val,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <2 x double> %res
 }
@@ -54,7 +53,6 @@
 ; CHECK: br %r14
   %res = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
                         <2 x double> %val,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <2 x double> %res
 }
@@ -65,7 +63,6 @@
 ; CHECK: br %r14
   %res = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
                         <2 x double> %val,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <2 x double> %res
 }
@@ -76,7 +73,6 @@
 ; CHECK: br %r14
   %res = call <2 x double> @llvm.experimental.constrained.round.v2f64(
                         <2 x double> %val,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <2 x double> %res
 }
@@ -112,7 +108,6 @@
   %scalar = extractelement <2 x double> %val, i32 0
   %res = call double @llvm.experimental.constrained.floor.f64(
                         double %scalar,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
@@ -125,7 +120,6 @@
   %scalar = extractelement <2 x double> %val, i32 0
   %res = call double @llvm.experimental.constrained.ceil.f64(
                         double %scalar,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
@@ -137,7 +131,6 @@
   %scalar = extractelement <2 x double> %val, i32 0
   %res = call double @llvm.experimental.constrained.trunc.f64(
                         double %scalar,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
@@ -149,7 +142,6 @@
   %scalar = extractelement <2 x double> %val, i32 0
   %res = call double @llvm.experimental.constrained.round.f64(
                         double %scalar,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret double %res
 }
diff --git a/llvm/test/CodeGen/SystemZ/vec-strict-round-02.ll b/llvm/test/CodeGen/SystemZ/vec-strict-round-02.ll
--- a/llvm/test/CodeGen/SystemZ/vec-strict-round-02.ll
+++ b/llvm/test/CodeGen/SystemZ/vec-strict-round-02.ll
@@ -4,16 +4,16 @@
 
 declare float @llvm.experimental.constrained.rint.f32(float, metadata, metadata)
 declare float @llvm.experimental.constrained.nearbyint.f32(float, metadata, metadata)
-declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
-declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
-declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
-declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
+declare float @llvm.experimental.constrained.floor.f32(float, metadata)
+declare float @llvm.experimental.constrained.ceil.f32(float, metadata)
+declare float @llvm.experimental.constrained.trunc.f32(float, metadata)
+declare float @llvm.experimental.constrained.round.f32(float, metadata)
 declare <4 x float> @llvm.experimental.constrained.rint.v4f32(<4 x float>, metadata, metadata)
 declare <4 x float> @llvm.experimental.constrained.nearbyint.v4f32(<4 x float>, metadata, metadata)
-declare <4 x float> @llvm.experimental.constrained.floor.v4f32(<4 x float>, metadata, metadata)
-declare <4 x float> @llvm.experimental.constrained.ceil.v4f32(<4 x float>, metadata, metadata)
-declare <4 x float> @llvm.experimental.constrained.trunc.v4f32(<4 x float>, metadata, metadata)
-declare <4 x float> @llvm.experimental.constrained.round.v4f32(<4 x float>, metadata, metadata)
+declare <4 x float> @llvm.experimental.constrained.floor.v4f32(<4 x float>, metadata)
+declare <4 x float> @llvm.experimental.constrained.ceil.v4f32(<4 x float>, metadata)
+declare <4 x float> @llvm.experimental.constrained.trunc.v4f32(<4 x float>, metadata)
+declare <4 x float> @llvm.experimental.constrained.round.v4f32(<4 x float>, metadata)
 
 define <4 x float> @f1(<4 x float> %val) #0 {
 ; CHECK-LABEL: f1:
@@ -43,7 +43,6 @@
 ; CHECK: br %r14
   %res = call <4 x float> @llvm.experimental.constrained.floor.v4f32(
                         <4 x float> %val,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <4 x float> %res
 }
@@ -54,7 +53,6 @@
 ; CHECK: br %r14
   %res = call <4 x float> @llvm.experimental.constrained.ceil.v4f32(
                         <4 x float> %val,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <4 x float> %res
 }
@@ -65,7 +63,6 @@
 ; CHECK: br %r14
   %res = call <4 x float> @llvm.experimental.constrained.trunc.v4f32(
                         <4 x float> %val,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <4 x float> %res
 }
@@ -76,7 +73,6 @@
 ; CHECK: br %r14
   %res = call <4 x float> @llvm.experimental.constrained.round.v4f32(
                         <4 x float> %val,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <4 x float> %res
 }
@@ -112,7 +108,6 @@
   %scalar = extractelement <4 x float> %val, i32 0
   %res = call float @llvm.experimental.constrained.floor.f32(
                         float %scalar,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
@@ -124,7 +119,6 @@
   %scalar = extractelement <4 x float> %val, i32 0
   %res = call float @llvm.experimental.constrained.ceil.f32(
                         float %scalar,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
@@ -136,7 +130,6 @@
   %scalar = extractelement <4 x float> %val, i32 0
   %res = call float @llvm.experimental.constrained.trunc.f32(
                         float %scalar,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
@@ -148,7 +141,6 @@
   %scalar = extractelement <4 x float> %val, i32 0
   %res = call float @llvm.experimental.constrained.round.f32(
                         float %scalar,
-                        metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret float %res
 }
diff --git a/llvm/test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll b/llvm/test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll
--- a/llvm/test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll
+++ b/llvm/test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll
@@ -4619,7 +4619,6 @@
 entry:
   %max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32(
                                <1 x float> <float 42.0>, <1 x float> <float 41.0>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %max
 }
@@ -4680,7 +4679,6 @@
   %max = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64(
                                 <2 x double> <double 43.0, double 42.0>,
                                 <2 x double> <double 41.0, double 40.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %max
 }
@@ -4768,7 +4766,6 @@
   %max = call <3 x float> @llvm.experimental.constrained.maxnum.v3f32(
                               <3 x float> <float 43.0, float 44.0, float 45.0>,
                               <3 x float> <float 41.0, float 42.0, float 43.0>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %max
 }
@@ -4859,7 +4856,6 @@
   %max = call <3 x double> @llvm.experimental.constrained.maxnum.v3f64(
                           <3 x double> %b,
                           <3 x double> <double 40.0, double 41.0, double 42.0>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   store <3 x double> %max, <3 x double>* %a
   ret void
@@ -4962,7 +4958,6 @@
                                               double 46.0, double 47.0>,
                                 <4 x double> <double 40.0, double 41.0,
                                               double 42.0, double 43.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <4 x double> %max
 }
@@ -5002,7 +4997,6 @@
  entry:
   %min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32(
                                <1 x float> <float 42.0>, <1 x float> <float 41.0>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %min
 }
@@ -5063,7 +5057,6 @@
   %min = call <2 x double> @llvm.experimental.constrained.minnum.v2f64(
                                 <2 x double> <double 43.0, double 42.0>,
                                 <2 x double> <double 41.0, double 40.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %min
 }
@@ -5151,7 +5144,6 @@
   %min = call <3 x float> @llvm.experimental.constrained.minnum.v3f32(
                               <3 x float> <float 43.0, float 44.0, float 45.0>,
                               <3 x float> <float 41.0, float 42.0, float 43.0>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %min
 }
@@ -5246,7 +5238,6 @@
  %min = call <3 x double> @llvm.experimental.constrained.minnum.v3f64(
                           <3 x double> %b,
                           <3 x double> <double 3.0, double 3.0, double 3.0>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   store <3 x double> %min, <3 x double>* %a
   ret void
@@ -5349,7 +5340,6 @@
                                               double 46.0, double 47.0>,
                                 <4 x double> <double 40.0, double 41.0,
                                               double 42.0, double 43.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <4 x double> %min
 }
@@ -5629,7 +5619,6 @@
 entry:
   %ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %ceil
 }
@@ -5667,7 +5656,6 @@
 entry:
   %ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %ceil
 }
@@ -5722,7 +5710,6 @@
 entry:
   %ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %ceil
 }
@@ -5775,7 +5762,6 @@
   %b = load <3 x double>, <3 x double>* %a
   %ceil = call <3 x double> @llvm.experimental.constrained.ceil.v3f64(
                           <3 x double> %b,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   store <3 x double> %ceil, <3 x double>* %a
   ret void
@@ -5804,7 +5790,6 @@
 entry:
   %floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %floor
 }
@@ -5843,7 +5828,6 @@
 entry:
   %floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %floor
 }
@@ -5898,7 +5882,6 @@
 entry:
   %floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %floor
 }
@@ -5951,7 +5934,6 @@
   %b = load <3 x double>, <3 x double>* %a
   %floor = call <3 x double> @llvm.experimental.constrained.floor.v3f64(
                           <3 x double> %b,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   store <3 x double> %floor, <3 x double>* %a
   ret void
@@ -5980,7 +5962,6 @@
 entry:
   %round = call <1 x float> @llvm.experimental.constrained.round.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %round
 }
@@ -6018,7 +5999,6 @@
 entry:
   %round = call <2 x double> @llvm.experimental.constrained.round.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %round
 }
@@ -6073,7 +6053,6 @@
 entry:
   %round = call <3 x float> @llvm.experimental.constrained.round.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %round
 }
@@ -6127,7 +6106,6 @@
   %b = load <3 x double>, <3 x double>* %a
   %round = call <3 x double> @llvm.experimental.constrained.round.v3f64(
                           <3 x double> %b,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   store <3 x double> %round, <3 x double>* %a
   ret void
@@ -6156,7 +6134,6 @@
 entry:
   %trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %trunc
 }
@@ -6194,7 +6171,6 @@
 entry:
   %trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %trunc
 }
@@ -6249,7 +6225,6 @@
 entry:
   %trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %trunc
 }
@@ -6302,7 +6277,6 @@
   %b = load <3 x double>, <3 x double>* %a
   %trunc = call <3 x double> @llvm.experimental.constrained.trunc.v3f64(
                           <3 x double> %b,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   store <3 x double> %trunc, <3 x double>* %a
   ret void
@@ -6327,14 +6301,14 @@
 declare <2 x double> @llvm.experimental.constrained.log2.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.rint.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
+declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata)
 declare <2 x float> @llvm.experimental.constrained.fptrunc.v2f32.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.fpext.v2f64.v2f32(<2 x float>, metadata)
-declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata, metadata)
+declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata)
 
 declare <1 x float> @llvm.experimental.constrained.fadd.v1f32(<1 x float>, <1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.fsub.v1f32(<1 x float>, <1 x float>, metadata, metadata)
@@ -6353,14 +6327,14 @@
 declare <1 x float> @llvm.experimental.constrained.log2.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.rint.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.nearbyint.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.maxnum.v1f32(<1 x float>, <1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.minnum.v1f32(<1 x float>, <1 x float>, metadata, metadata)
+declare <1 x float> @llvm.experimental.constrained.maxnum.v1f32(<1 x float>, <1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.minnum.v1f32(<1 x float>, <1 x float>, metadata)
 declare <1 x float> @llvm.experimental.constrained.fptrunc.v1f32.v1f64(<1 x double>, metadata, metadata)
 declare <1 x double> @llvm.experimental.constrained.fpext.v1f64.v1f32(<1 x float>, metadata)
-declare <1 x float> @llvm.experimental.constrained.ceil.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.floor.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.round.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.trunc.v1f32(<1 x float>, metadata, metadata)
+declare <1 x float> @llvm.experimental.constrained.ceil.v1f32(<1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.floor.v1f32(<1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.round.v1f32(<1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.trunc.v1f32(<1 x float>, metadata)
 
 declare <3 x float> @llvm.experimental.constrained.fadd.v3f32(<3 x float>, <3 x float>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.fadd.v3f64(<3 x double>, <3 x double>, metadata, metadata)
@@ -6396,20 +6370,20 @@
 declare <3 x double> @llvm.experimental.constrained.rint.v3f64(<3 x double>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.nearbyint.v3f32(<3 x float>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.nearbyint.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.maxnum.v3f32(<3 x float>, <3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.maxnum.v3f64(<3 x double>, <3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.minnum.v3f32(<3 x float>, <3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.minnum.v3f64(<3 x double>, <3 x double>, metadata, metadata)
+declare <3 x float> @llvm.experimental.constrained.maxnum.v3f32(<3 x float>, <3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.maxnum.v3f64(<3 x double>, <3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.minnum.v3f32(<3 x float>, <3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.minnum.v3f64(<3 x double>, <3 x double>, metadata)
 declare <3 x float> @llvm.experimental.constrained.fptrunc.v3f32.v3f64(<3 x double>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.fpext.v3f64.v3f32(<3 x float>, metadata)
-declare <3 x float> @llvm.experimental.constrained.ceil.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.ceil.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.floor.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.floor.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.round.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.round.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.trunc.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.trunc.v3f64(<3 x double>, metadata, metadata)
+declare <3 x float> @llvm.experimental.constrained.ceil.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.ceil.v3f64(<3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.floor.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.floor.v3f64(<3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.round.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.round.v3f64(<3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.trunc.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.trunc.v3f64(<3 x double>, metadata)
 
 declare <4 x double> @llvm.experimental.constrained.fadd.v4f64(<4 x double>, <4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.fsub.v4f64(<4 x double>, <4 x double>, metadata, metadata)
@@ -6428,11 +6402,11 @@
 declare <4 x double> @llvm.experimental.constrained.log2.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.rint.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.nearbyint.v4f64(<4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.maxnum.v4f64(<4 x double>, <4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.minnum.v4f64(<4 x double>, <4 x double>, metadata, metadata)
+declare <4 x double> @llvm.experimental.constrained.maxnum.v4f64(<4 x double>, <4 x double>, metadata)
+declare <4 x double> @llvm.experimental.constrained.minnum.v4f64(<4 x double>, <4 x double>, metadata)
 declare <4 x float> @llvm.experimental.constrained.fptrunc.v4f32.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.fpext.v4f64.v4f32(<4 x float>, metadata)
-declare <4 x double> @llvm.experimental.constrained.ceil.v4f64(<4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.floor.v4f64(<4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.round.v4f64(<4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.trunc.v4f64(<4 x double>, metadata, metadata)
+declare <4 x double> @llvm.experimental.constrained.ceil.v4f64(<4 x double>, metadata)
+declare <4 x double> @llvm.experimental.constrained.floor.v4f64(<4 x double>, metadata)
+declare <4 x double> @llvm.experimental.constrained.round.v4f64(<4 x double>, metadata)
+declare <4 x double> @llvm.experimental.constrained.trunc.v4f64(<4 x double>, metadata)
diff --git a/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll b/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll
--- a/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll
+++ b/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll
@@ -322,7 +322,7 @@
 ; X86-NEXT:    popl %edi
 ; X86-NEXT:    retl $4
 entry:
-  %ceil = call fp128 @llvm.experimental.constrained.ceil.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  %ceil = call fp128 @llvm.experimental.constrained.ceil.f128(fp128 %x, metadata !"fpexcept.strict") #0
   ret fp128 %ceil
 }
 
@@ -486,7 +486,7 @@
 ; X86-NEXT:    popl %edi
 ; X86-NEXT:    retl $4
 entry:
-  %floor = call fp128 @llvm.experimental.constrained.floor.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  %floor = call fp128 @llvm.experimental.constrained.floor.f128(fp128 %x, metadata !"fpexcept.strict") #0
   ret fp128 %floor
 }
 
@@ -654,7 +654,7 @@
 ; X86-NEXT:    popl %edi
 ; X86-NEXT:    retl $4
 entry:
-  %maxnum = call fp128 @llvm.experimental.constrained.maxnum.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  %maxnum = call fp128 @llvm.experimental.constrained.maxnum.f128(fp128 %x, fp128 %y, metadata !"fpexcept.strict") #0
   ret fp128 %maxnum
 }
 
@@ -699,7 +699,7 @@
 ; X86-NEXT:    popl %edi
 ; X86-NEXT:    retl $4
 entry:
-  %minnum = call fp128 @llvm.experimental.constrained.minnum.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  %minnum = call fp128 @llvm.experimental.constrained.minnum.f128(fp128 %x, fp128 %y, metadata !"fpexcept.strict") #0
   ret fp128 %minnum
 }
 
@@ -909,7 +909,7 @@
 ; X86-NEXT:    popl %edi
 ; X86-NEXT:    retl $4
 entry:
-  %round = call fp128 @llvm.experimental.constrained.round.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  %round = call fp128 @llvm.experimental.constrained.round.f128(fp128 %x, metadata !"fpexcept.strict") #0
   ret fp128 %round
 }
 
@@ -1032,7 +1032,7 @@
 ; X86-NEXT:    popl %edi
 ; X86-NEXT:    retl $4
 entry:
-  %trunc = call fp128 @llvm.experimental.constrained.trunc.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  %trunc = call fp128 @llvm.experimental.constrained.trunc.f128(fp128 %x, metadata !"fpexcept.strict") #0
   ret fp128 %trunc
 }
 
@@ -1136,24 +1136,24 @@
 declare fp128 @llvm.experimental.constrained.fdiv.f128(fp128, fp128, metadata, metadata)
 declare fp128 @llvm.experimental.constrained.fma.f128(fp128, fp128, fp128, metadata, metadata)
 declare fp128 @llvm.experimental.constrained.frem.f128(fp128, fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata)
 declare fp128 @llvm.experimental.constrained.cos.f128(fp128, metadata, metadata)
 declare fp128 @llvm.experimental.constrained.exp.f128(fp128, metadata, metadata)
 declare fp128 @llvm.experimental.constrained.exp2.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata)
 declare fp128 @llvm.experimental.constrained.log.f128(fp128, metadata, metadata)
 declare fp128 @llvm.experimental.constrained.log10.f128(fp128, metadata, metadata)
 declare fp128 @llvm.experimental.constrained.log2.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.maxnum.f128(fp128, fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.minnum.f128(fp128, fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.maxnum.f128(fp128, fp128, metadata)
+declare fp128 @llvm.experimental.constrained.minnum.f128(fp128, fp128, metadata)
 declare fp128 @llvm.experimental.constrained.nearbyint.f128(fp128, metadata, metadata)
 declare fp128 @llvm.experimental.constrained.pow.f128(fp128, fp128, metadata, metadata)
 declare fp128 @llvm.experimental.constrained.powi.f128(fp128, i32, metadata, metadata)
 declare fp128 @llvm.experimental.constrained.rint.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata)
 declare fp128 @llvm.experimental.constrained.sin.f128(fp128, metadata, metadata)
 declare fp128 @llvm.experimental.constrained.sqrt.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata)
 declare i32 @llvm.experimental.constrained.lrint.i32.f128(fp128, metadata, metadata)
 declare i64 @llvm.experimental.constrained.llrint.i64.f128(fp128, metadata, metadata)
 declare i32 @llvm.experimental.constrained.lround.i32.f128(fp128, metadata)
diff --git a/llvm/test/CodeGen/X86/vector-constrained-fp-intrinsics.ll b/llvm/test/CodeGen/X86/vector-constrained-fp-intrinsics.ll
--- a/llvm/test/CodeGen/X86/vector-constrained-fp-intrinsics.ll
+++ b/llvm/test/CodeGen/X86/vector-constrained-fp-intrinsics.ll
@@ -3373,7 +3373,6 @@
 entry:
   %max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32(
                                <1 x float> <float 42.0>, <1 x float> <float 41.0>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %max
 }
@@ -3416,7 +3415,6 @@
   %max = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64(
                                 <2 x double> <double 43.0, double 42.0>,
                                 <2 x double> <double 41.0, double 40.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %max
 }
@@ -3472,7 +3470,6 @@
   %max = call <3 x float> @llvm.experimental.constrained.maxnum.v3f32(
                               <3 x float> <float 43.0, float 44.0, float 45.0>,
                               <3 x float> <float 41.0, float 42.0, float 43.0>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %max
 }
@@ -3530,7 +3527,6 @@
   %max = call <3 x double> @llvm.experimental.constrained.maxnum.v3f64(
                           <3 x double> <double 43.0, double 44.0, double 45.0>,
                           <3 x double> <double 40.0, double 41.0, double 42.0>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   ret <3 x double> %max
 }
@@ -3598,7 +3594,6 @@
                                               double 46.0, double 47.0>,
                                 <4 x double> <double 40.0, double 41.0,
                                               double 42.0, double 43.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <4 x double> %max
 }
@@ -3628,7 +3623,6 @@
  entry:
   %min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32(
                                <1 x float> <float 42.0>, <1 x float> <float 41.0>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %min
 }
@@ -3671,7 +3665,6 @@
   %min = call <2 x double> @llvm.experimental.constrained.minnum.v2f64(
                                 <2 x double> <double 43.0, double 42.0>,
                                 <2 x double> <double 41.0, double 40.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %min
 }
@@ -3727,7 +3720,6 @@
   %min = call <3 x float> @llvm.experimental.constrained.minnum.v3f32(
                               <3 x float> <float 43.0, float 44.0, float 45.0>,
                               <3 x float> <float 41.0, float 42.0, float 43.0>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %min
 }
@@ -3785,7 +3777,6 @@
  %min = call <3 x double> @llvm.experimental.constrained.minnum.v3f64(
                           <3 x double> <double 43.0, double 44.0, double 45.0>,
                           <3 x double> <double 40.0, double 41.0, double 42.0>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   ret <3 x double> %min
 }
@@ -3853,7 +3844,6 @@
                                               double 46.0, double 47.0>,
                                 <4 x double> <double 40.0, double 41.0,
                                               double 42.0, double 43.0>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <4 x double> %min
 }
@@ -5244,7 +5234,6 @@
 entry:
   %ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %ceil
 }
@@ -5272,7 +5261,6 @@
 entry:
   %ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %ceil
 }
@@ -5313,7 +5301,6 @@
 entry:
   %ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %ceil
 }
@@ -5351,7 +5338,6 @@
 entry:
   %ceil = call <3 x double> @llvm.experimental.constrained.ceil.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   ret <3 x double> %ceil
 }
@@ -5375,7 +5361,6 @@
 entry:
   %floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %floor
 }
@@ -5404,7 +5389,6 @@
 entry:
   %floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %floor
 }
@@ -5445,7 +5429,6 @@
 entry:
   %floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %floor
 }
@@ -5483,7 +5466,6 @@
 entry:
   %floor = call <3 x double> @llvm.experimental.constrained.floor.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   ret <3 x double> %floor
 }
@@ -5511,7 +5493,6 @@
 entry:
   %round = call <1 x float> @llvm.experimental.constrained.round.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %round
 }
@@ -5549,7 +5530,6 @@
 entry:
   %round = call <2 x double> @llvm.experimental.constrained.round.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %round
 }
@@ -5598,7 +5578,6 @@
 entry:
   %round = call <3 x float> @llvm.experimental.constrained.round.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %round
 }
@@ -5650,7 +5629,6 @@
 entry:
   %round = call <3 x double> @llvm.experimental.constrained.round.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   ret <3 x double> %round
 }
@@ -5674,7 +5652,6 @@
 entry:
   %trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32(
                                <1 x float> <float 1.5>,
-                               metadata !"round.dynamic",
                                metadata !"fpexcept.strict") #0
   ret <1 x float> %trunc
 }
@@ -5702,7 +5679,6 @@
 entry:
   %trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
                                 <2 x double> <double 1.1, double 1.9>,
-                                metadata !"round.dynamic",
                                 metadata !"fpexcept.strict") #0
   ret <2 x double> %trunc
 }
@@ -5743,7 +5719,6 @@
 entry:
   %trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32(
                               <3 x float> <float 1.5, float 2.5, float 3.5>,
-                              metadata !"round.dynamic",
                               metadata !"fpexcept.strict") #0
   ret <3 x float> %trunc
 }
@@ -5781,7 +5756,6 @@
 entry:
   %trunc = call <3 x double> @llvm.experimental.constrained.trunc.v3f64(
                           <3 x double> <double 1.1, double 1.9, double 1.5>,
-                          metadata !"round.dynamic",
                           metadata !"fpexcept.strict") #0
   ret <3 x double> %trunc
 }
@@ -7313,8 +7287,8 @@
 declare <2 x double> @llvm.experimental.constrained.log2.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.rint.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata, metadata)
+declare <2 x double> @llvm.experimental.constrained.maxnum.v2f64(<2 x double>, <2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata)
 declare <2 x i32> @llvm.experimental.constrained.fptosi.v2i32.v2f32(<2 x float>, metadata)
 declare <2 x i64> @llvm.experimental.constrained.fptosi.v2i64.v2f32(<2 x float>, metadata)
 declare <2 x i32> @llvm.experimental.constrained.fptosi.v2i32.v2f64(<2 x double>, metadata)
@@ -7325,10 +7299,10 @@
 declare <2 x i64> @llvm.experimental.constrained.fptoui.v2i64.v2f64(<2 x double>, metadata)
 declare <2 x float> @llvm.experimental.constrained.fptrunc.v2f32.v2f64(<2 x double>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.fpext.v2f64.v2f32(<2 x float>, metadata)
-declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata, metadata)
-declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata, metadata)
+declare <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata)
+declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata)
 declare <2 x double> @llvm.experimental.constrained.sitofp.v2f64.v2i32(<2 x i32>, metadata, metadata)
 declare <2 x float> @llvm.experimental.constrained.sitofp.v2f32.v2i32(<2 x i32>, metadata, metadata)
 declare <2 x double> @llvm.experimental.constrained.sitofp.v2f64.v2i64(<2 x i64>, metadata, metadata)
@@ -7356,8 +7330,8 @@
 declare <1 x float> @llvm.experimental.constrained.log2.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.rint.v1f32(<1 x float>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.nearbyint.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.maxnum.v1f32(<1 x float>, <1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.minnum.v1f32(<1 x float>, <1 x float>, metadata, metadata)
+declare <1 x float> @llvm.experimental.constrained.maxnum.v1f32(<1 x float>, <1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.minnum.v1f32(<1 x float>, <1 x float>, metadata)
 declare <1 x i32> @llvm.experimental.constrained.fptosi.v1i32.v1f32(<1 x float>, metadata)
 declare <1 x i64> @llvm.experimental.constrained.fptosi.v1i64.v1f32(<1 x float>, metadata)
 declare <1 x i32> @llvm.experimental.constrained.fptosi.v1i32.v1f64(<1 x double>, metadata)
@@ -7368,10 +7342,10 @@
 declare <1 x i64> @llvm.experimental.constrained.fptoui.v1i64.v1f64(<1 x double>, metadata)
 declare <1 x float> @llvm.experimental.constrained.fptrunc.v1f32.v1f64(<1 x double>, metadata, metadata)
 declare <1 x double> @llvm.experimental.constrained.fpext.v1f64.v1f32(<1 x float>, metadata)
-declare <1 x float> @llvm.experimental.constrained.ceil.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.floor.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.round.v1f32(<1 x float>, metadata, metadata)
-declare <1 x float> @llvm.experimental.constrained.trunc.v1f32(<1 x float>, metadata, metadata)
+declare <1 x float> @llvm.experimental.constrained.ceil.v1f32(<1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.floor.v1f32(<1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.round.v1f32(<1 x float>, metadata)
+declare <1 x float> @llvm.experimental.constrained.trunc.v1f32(<1 x float>, metadata)
 declare <1 x double> @llvm.experimental.constrained.sitofp.v1f64.v1i32(<1 x i32>, metadata, metadata)
 declare <1 x float> @llvm.experimental.constrained.sitofp.v1f32.v1i32(<1 x i32>, metadata, metadata)
 declare <1 x double> @llvm.experimental.constrained.sitofp.v1f64.v1i64(<1 x i64>, metadata, metadata)
@@ -7416,10 +7390,10 @@
 declare <3 x double> @llvm.experimental.constrained.rint.v3f64(<3 x double>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.nearbyint.v3f32(<3 x float>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.nearbyint.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.maxnum.v3f32(<3 x float>, <3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.maxnum.v3f64(<3 x double>, <3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.minnum.v3f32(<3 x float>, <3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.minnum.v3f64(<3 x double>, <3 x double>, metadata, metadata)
+declare <3 x float> @llvm.experimental.constrained.maxnum.v3f32(<3 x float>, <3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.maxnum.v3f64(<3 x double>, <3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.minnum.v3f32(<3 x float>, <3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.minnum.v3f64(<3 x double>, <3 x double>, metadata)
 declare <3 x i32> @llvm.experimental.constrained.fptosi.v3i32.v3f32(<3 x float>, metadata)
 declare <3 x i64> @llvm.experimental.constrained.fptosi.v3i64.v3f32(<3 x float>, metadata)
 declare <3 x i32> @llvm.experimental.constrained.fptosi.v3i32.v3f64(<3 x double>, metadata)
@@ -7430,14 +7404,14 @@
 declare <3 x i64> @llvm.experimental.constrained.fptoui.v3i64.v3f64(<3 x double>, metadata)
 declare <3 x float> @llvm.experimental.constrained.fptrunc.v3f32.v3f64(<3 x double>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.fpext.v3f64.v3f32(<3 x float>, metadata)
-declare <3 x float> @llvm.experimental.constrained.ceil.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.ceil.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.floor.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.floor.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.round.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.round.v3f64(<3 x double>, metadata, metadata)
-declare <3 x float> @llvm.experimental.constrained.trunc.v3f32(<3 x float>, metadata, metadata)
-declare <3 x double> @llvm.experimental.constrained.trunc.v3f64(<3 x double>, metadata, metadata)
+declare <3 x float> @llvm.experimental.constrained.ceil.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.ceil.v3f64(<3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.floor.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.floor.v3f64(<3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.round.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.round.v3f64(<3 x double>, metadata)
+declare <3 x float> @llvm.experimental.constrained.trunc.v3f32(<3 x float>, metadata)
+declare <3 x double> @llvm.experimental.constrained.trunc.v3f64(<3 x double>, metadata)
 declare <3 x double> @llvm.experimental.constrained.sitofp.v3f64.v3i32(<3 x i32>, metadata, metadata)
 declare <3 x float> @llvm.experimental.constrained.sitofp.v3f32.v3i32(<3 x i32>, metadata, metadata)
 declare <3 x double> @llvm.experimental.constrained.sitofp.v3f64.v3i64(<3 x i64>, metadata, metadata)
@@ -7465,8 +7439,8 @@
 declare <4 x double> @llvm.experimental.constrained.log2.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.rint.v4f64(<4 x double>, metadata, metadata)
 declare <4 x double> @llvm.experimental.constrained.nearbyint.v4f64(<4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.maxnum.v4f64(<4 x double>, <4 x double>, metadata, metadata)
-declare <4 x double> @llvm.experimental.constrained.minnum.v4f64(<4 x double>, <4 x double>, metadata, metadata)
+declare <4 x double> @llvm.experimental.constrained.maxnum.v4f64(<4 x double>, <4 x double>, metadata)
+declare <4 x double> @llvm.experimental.constrained.minnum.v4f64(<4 x double>, <4 x double>, metadata)
 declare <4 x i32> @llvm.experimental.constrained.fptosi.v4i32.v4f32(<4 x float>, metadata)
 declare <4 x i64> @llvm.experimental.constrained.fptosi.v4i64.v4f32(<4 x float>, metadata)
 declare <4 x i32> @llvm.experimental.constrained.fptosi.v4i32.v4f64(<4 x double>, metadata)
@@ -7477,10 +7451,10 @@
 declare <4 x 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)