[llvm-branch-commits] [llvm] cbbdcfc - [RISCV] V does not imply F.

[Hsiangkai Wang via llvm-branch-commits]

Author: Hsiangkai Wang
Date: 2020-12-15T14:59:22+08:00
New Revision: cbbdcfc47c86ddafe4ebad49f93dd37b513db0ac

URL: 
https://github.com/llvm/llvm-project/commit/cbbdcfc47c86ddafe4ebad49f93dd37b513db0ac
DIFF: 
https://github.com/llvm/llvm-project/commit/cbbdcfc47c86ddafe4ebad49f93dd37b513db0ac.diff

LOG: [RISCV] V does not imply F.

If users want to use vector floating point instructions, they need to
specify 'F' extension additionally.

Added: 
    

Modified: 
    llvm/lib/Target/RISCV/RISCV.td
    llvm/lib/Target/RISCV/RISCVISelLowering.cpp
    llvm/lib/Target/RISCV/RISCVInstrInfoV.td
    llvm/lib/Target/RISCV/RISCVSchedRocket.td
    llvm/lib/Target/RISCV/RISCVSchedSiFive7.td
    llvm/test/MC/RISCV/rvv/convert.s
    llvm/test/MC/RISCV/rvv/fadd.s
    llvm/test/MC/RISCV/rvv/fcompare.s
    llvm/test/MC/RISCV/rvv/fdiv.s
    llvm/test/MC/RISCV/rvv/fmacc.s
    llvm/test/MC/RISCV/rvv/fminmax.s
    llvm/test/MC/RISCV/rvv/fmul.s
    llvm/test/MC/RISCV/rvv/fmv.s
    llvm/test/MC/RISCV/rvv/fothers.s
    llvm/test/MC/RISCV/rvv/freduction.s
    llvm/test/MC/RISCV/rvv/fsub.s
    llvm/test/MC/RISCV/rvv/sign-injection.s

Removed: 
    


################################################################################
diff  --git a/llvm/lib/Target/RISCV/RISCV.td b/llvm/lib/Target/RISCV/RISCV.td
index 7a7b3bb0ad32..b1f2658e76b8 100644
--- a/llvm/lib/Target/RISCV/RISCV.td
+++ b/llvm/lib/Target/RISCV/RISCV.td
@@ -160,11 +160,14 @@ def HasRVCHints : 
Predicate<"Subtarget->enableRVCHintInstrs()">,
 
 def FeatureStdExtV
     : SubtargetFeature<"experimental-v", "HasStdExtV", "true",
-                       "'V' (Vector Instructions)",
-                       [FeatureStdExtF]>;
+                       "'V' (Vector Instructions)">;
 def HasStdExtV : Predicate<"Subtarget->hasStdExtV()">,
                            AssemblerPredicate<(all_of FeatureStdExtV),
                            "'V' (Vector Instructions)">;
+def HasStdExtVAndF
+    : Predicate<"Subtarget->hasStdExtV() && Subtarget->hasStdExtF()">,
+                AssemblerPredicate<(all_of FeatureStdExtV, FeatureStdExtF),
+                "'V' and 'F' (Vector Floating-point Instructions)">;
 
 def FeatureStdExtZvlsseg
     : SubtargetFeature<"experimental-zvlsseg", "HasStdExtZvlsseg", "true",

diff  --git a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp 
b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
index 529a5bf784f4..f805a7dcc60c 100644
--- a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
+++ b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
@@ -124,23 +124,29 @@ RISCVTargetLowering::RISCVTargetLowering(const 
TargetMachine &TM,
     addRegisterClass(RISCVVMVTs::vint64m4_t, &RISCV::VRM4RegClass);
     addRegisterClass(RISCVVMVTs::vint64m8_t, &RISCV::VRM8RegClass);
 
-    addRegisterClass(RISCVVMVTs::vfloat16mf4_t, &RISCV::VRRegClass);
-    addRegisterClass(RISCVVMVTs::vfloat16mf2_t, &RISCV::VRRegClass);
-    addRegisterClass(RISCVVMVTs::vfloat16m1_t, &RISCV::VRRegClass);
-    addRegisterClass(RISCVVMVTs::vfloat16m2_t, &RISCV::VRM2RegClass);
-    addRegisterClass(RISCVVMVTs::vfloat16m4_t, &RISCV::VRM4RegClass);
-    addRegisterClass(RISCVVMVTs::vfloat16m8_t, &RISCV::VRM8RegClass);
-
-    addRegisterClass(RISCVVMVTs::vfloat32mf2_t, &RISCV::VRRegClass);
-    addRegisterClass(RISCVVMVTs::vfloat32m1_t, &RISCV::VRRegClass);
-    addRegisterClass(RISCVVMVTs::vfloat32m2_t, &RISCV::VRM2RegClass);
-    addRegisterClass(RISCVVMVTs::vfloat32m4_t, &RISCV::VRM4RegClass);
-    addRegisterClass(RISCVVMVTs::vfloat32m8_t, &RISCV::VRM8RegClass);
-
-    addRegisterClass(RISCVVMVTs::vfloat64m1_t, &RISCV::VRRegClass);
-    addRegisterClass(RISCVVMVTs::vfloat64m2_t, &RISCV::VRM2RegClass);
-    addRegisterClass(RISCVVMVTs::vfloat64m4_t, &RISCV::VRM4RegClass);
-    addRegisterClass(RISCVVMVTs::vfloat64m8_t, &RISCV::VRM8RegClass);
+    if (Subtarget.hasStdExtZfh()) {
+      addRegisterClass(RISCVVMVTs::vfloat16mf4_t, &RISCV::VRRegClass);
+      addRegisterClass(RISCVVMVTs::vfloat16mf2_t, &RISCV::VRRegClass);
+      addRegisterClass(RISCVVMVTs::vfloat16m1_t, &RISCV::VRRegClass);
+      addRegisterClass(RISCVVMVTs::vfloat16m2_t, &RISCV::VRM2RegClass);
+      addRegisterClass(RISCVVMVTs::vfloat16m4_t, &RISCV::VRM4RegClass);
+      addRegisterClass(RISCVVMVTs::vfloat16m8_t, &RISCV::VRM8RegClass);
+    }
+
+    if (Subtarget.hasStdExtF()) {
+      addRegisterClass(RISCVVMVTs::vfloat32mf2_t, &RISCV::VRRegClass);
+      addRegisterClass(RISCVVMVTs::vfloat32m1_t, &RISCV::VRRegClass);
+      addRegisterClass(RISCVVMVTs::vfloat32m2_t, &RISCV::VRM2RegClass);
+      addRegisterClass(RISCVVMVTs::vfloat32m4_t, &RISCV::VRM4RegClass);
+      addRegisterClass(RISCVVMVTs::vfloat32m8_t, &RISCV::VRM8RegClass);
+    }
+
+    if (Subtarget.hasStdExtD()) {
+      addRegisterClass(RISCVVMVTs::vfloat64m1_t, &RISCV::VRRegClass);
+      addRegisterClass(RISCVVMVTs::vfloat64m2_t, &RISCV::VRM2RegClass);
+      addRegisterClass(RISCVVMVTs::vfloat64m4_t, &RISCV::VRM4RegClass);
+      addRegisterClass(RISCVVMVTs::vfloat64m8_t, &RISCV::VRM8RegClass);
+    }
   }
 
   // Compute derived properties from the register classes.

diff  --git a/llvm/lib/Target/RISCV/RISCVInstrInfoV.td 
b/llvm/lib/Target/RISCV/RISCVInstrInfoV.td
index 220aa9acc771..a0902e164f26 100644
--- a/llvm/lib/Target/RISCV/RISCVInstrInfoV.td
+++ b/llvm/lib/Target/RISCV/RISCVInstrInfoV.td
@@ -736,7 +736,9 @@ let Constraints = "@earlyclobber $vd", RVVConstraint = 
Narrow in {
 defm VNCLIPU_W : VALU_IV_V_X_I<"vnclipu", 0b101110, uimm5, "w">;
 defm VNCLIP_W : VALU_IV_V_X_I<"vnclip", 0b101111, uimm5, "w">;
 } // Constraints = "@earlyclobber $vd", RVVConstraint = Narrow
+} // Predicates = [HasStdExtV]
 
+let Predicates = [HasStdExtVAndF] in {
 // Vector Single-Width Floating-Point Add/Subtract Instructions
 defm VFADD_V : VALU_FV_V_F<"vfadd", 0b000000>;
 defm VFSUB_V : VALU_FV_V_F<"vfsub", 0b000010>;
@@ -862,7 +864,9 @@ defm VFNCVT_F_X_W : VALU_FV_VS2<"vfncvt.f.x.w", 0b010010, 
0b10011>;
 defm VFNCVT_F_F_W : VALU_FV_VS2<"vfncvt.f.f.w", 0b010010, 0b10100>;
 defm VFNCVT_ROD_F_F_W : VALU_FV_VS2<"vfncvt.rod.f.f.w", 0b010010, 0b10101>;
 } // Constraints = "@earlyclobber $vd", RVVConstraint = NarrowCvt
+} // Predicates = [HasStdExtVAndF]
 
+let Predicates = [HasStdExtV] in {
 // Vector Single-Width Integer Reduction Instructions
 let RVVConstraint = NoConstraint in {
 defm VREDSUM : VALU_MV_V<"vredsum", 0b000000>;
@@ -884,7 +888,9 @@ let Constraints = "@earlyclobber $vd", RVVConstraint = 
NoConstraint in {
 defm VWREDSUMU : VALU_IV_V<"vwredsumu", 0b110000>;
 defm VWREDSUM : VALU_IV_V<"vwredsum", 0b110001>;
 } // Constraints = "@earlyclobber $vd", RVVConstraint = NoConstraint
+} // Predicates = [HasStdExtV]
 
+let Predicates = [HasStdExtVAndF] in {
 // Vector Single-Width Floating-Point Reduction Instructions
 let RVVConstraint = NoConstraint in {
 defm VFREDOSUM : VALU_FV_V<"vfredosum", 0b000011>;
@@ -902,7 +908,9 @@ let Constraints = "@earlyclobber $vd", RVVConstraint = 
NoConstraint in {
 defm VFWREDOSUM : VALU_FV_V<"vfwredosum", 0b110011>;
 defm VFWREDSUM : VALU_FV_V<"vfwredsum", 0b110001>;
 } // Constraints = "@earlyclobber $vd", RVVConstraint = NoConstraint
+} // Predicates = [HasStdExtVAndF]
 
+let Predicates = [HasStdExtV] in {
 // Vector Mask-Register Logical Instructions
 defm VMAND_M : VALU_MV_Mask<"vmand", 0b011001, "m">;
 defm VMNAND_M : VALU_MV_Mask<"vmnand", 0b011101, "m">;
@@ -964,7 +972,9 @@ def VMV_S_X : RVInstV2<0b010000, 0b00000, OPMVX, (outs 
VR:$vd),
 
 }
 } // hasSideEffects = 0, mayLoad = 0, mayStore = 0
+} // Predicates = [HasStdExtV]
 
+let Predicates = [HasStdExtVAndF] in {
 let hasSideEffects = 0, mayLoad = 0, mayStore = 0, vm = 1 in {
 // Floating-Point Scalar Move Instructions
 def VFMV_F_S : RVInstV<0b010000, 0b00000, OPFVV, (outs FPR32:$vd),
@@ -973,7 +983,9 @@ def VFMV_S_F : RVInstV2<0b010000, 0b00000, OPFVF, (outs 
VR:$vd),
                       (ins FPR32:$rs1), "vfmv.s.f", "$vd, $rs1">;
 
 } // hasSideEffects = 0, mayLoad = 0, mayStore = 0, vm = 1
+} // Predicates = [HasStdExtVAndF]
 
+let Predicates = [HasStdExtV] in {
 // Vector Slide Instructions
 let Constraints = "@earlyclobber $vd", RVVConstraint = SlideUp in {
 defm VSLIDEUP_V : VALU_IV_X_I<"vslideup", 0b001110, uimm5>;
@@ -982,11 +994,18 @@ defm VSLIDEDOWN_V : VALU_IV_X_I<"vslidedown", 0b001111, 
uimm5>;
 
 let Constraints = "@earlyclobber $vd", RVVConstraint = SlideUp in {
 defm VSLIDE1UP_V : VALU_MV_X<"vslide1up", 0b001110>;
-defm VFSLIDE1UP_V : VALU_FV_F<"vfslide1up", 0b001110>;
 } // Constraints = "@earlyclobber $vd", RVVConstraint = SlideUp
 defm VSLIDE1DOWN_V : VALU_MV_X<"vslide1down", 0b001111>;
+} // Predicates = [HasStdExtV]
+
+let Predicates = [HasStdExtVAndF] in {
+let Constraints = "@earlyclobber $vd", RVVConstraint = SlideUp in {
+defm VFSLIDE1UP_V : VALU_FV_F<"vfslide1up", 0b001110>;
+} // Constraints = "@earlyclobber $vd", RVVConstraint = SlideUp
 defm VFSLIDE1DOWN_V : VALU_FV_F<"vfslide1down", 0b001111>;
+} // Predicates = [HasStdExtVAndF]
 
+let Predicates = [HasStdExtV] in {
 // Vector Register Gather Instruction
 let Constraints = "@earlyclobber $vd", RVVConstraint = Vrgather in {
 defm VRGATHER_V : VALU_IV_V_X_I<"vrgather", 0b001100, uimm5>;

diff  --git a/llvm/lib/Target/RISCV/RISCVSchedRocket.td 
b/llvm/lib/Target/RISCV/RISCVSchedRocket.td
index de2cdf512e87..6ace8d561052 100644
--- a/llvm/lib/Target/RISCV/RISCVSchedRocket.td
+++ b/llvm/lib/Target/RISCV/RISCVSchedRocket.td
@@ -16,7 +16,8 @@ def RocketModel : SchedMachineModel {
   let IssueWidth = 1;        // 1 micro-op is dispatched per cycle.
   let LoadLatency = 3;
   let MispredictPenalty = 3;
-  let UnsupportedFeatures = [HasStdExtV, HasStdExtZvamo, HasStdExtZvlsseg];
+  let UnsupportedFeatures = [HasStdExtV, HasStdExtVAndF, HasStdExtZvamo,
+                             HasStdExtZvlsseg];
 }
 
 
//===----------------------------------------------------------------------===//

diff  --git a/llvm/lib/Target/RISCV/RISCVSchedSiFive7.td 
b/llvm/lib/Target/RISCV/RISCVSchedSiFive7.td
index e57ba4f61b98..51f4b3d988e3 100644
--- a/llvm/lib/Target/RISCV/RISCVSchedSiFive7.td
+++ b/llvm/lib/Target/RISCV/RISCVSchedSiFive7.td
@@ -15,7 +15,8 @@ def SiFive7Model : SchedMachineModel {
   let LoadLatency = 3;
   let MispredictPenalty = 3;
   let CompleteModel = 0;
-  let UnsupportedFeatures = [HasStdExtV, HasStdExtZvamo, HasStdExtZvlsseg];
+  let UnsupportedFeatures = [HasStdExtV, HasStdExtVAndF, HasStdExtZvamo,
+                             HasStdExtZvlsseg];
 }
 
 // The SiFive7 microarchitecure has two pipelines: A and B.

diff  --git a/llvm/test/MC/RISCV/rvv/convert.s 
b/llvm/test/MC/RISCV/rvv/convert.s
index bc818523e3e9..3be67c31ba29 100644
--- a/llvm/test/MC/RISCV/rvv/convert.s
+++ b/llvm/test/MC/RISCV/rvv/convert.s
@@ -1,261 +1,264 @@
 # RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
 # RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
 # RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
-# RUN:        | llvm-objdump -d --mattr=+experimental-v - \
+# RUN:         --mattr=+f \
+# RUN:        | llvm-objdump -d --mattr=+experimental-v --mattr=+f - \
 # RUN:        | FileCheck %s --check-prefix=CHECK-INST
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
 
 vfcvt.xu.f.v v8, v4, v0.t
 # CHECK-INST: vfcvt.xu.f.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x40,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 40 48 <unknown>
 
 vfcvt.xu.f.v v8, v4
 # CHECK-INST: vfcvt.xu.f.v v8, v4
 # CHECK-ENCODING: [0x57,0x14,0x40,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 40 4a <unknown>
 
 vfcvt.x.f.v v8, v4, v0.t
 # CHECK-INST: vfcvt.x.f.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x94,0x40,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 40 48 <unknown>
 
 vfcvt.x.f.v v8, v4
 # CHECK-INST: vfcvt.x.f.v v8, v4
 # CHECK-ENCODING: [0x57,0x94,0x40,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 40 4a <unknown>
 
 vfcvt.f.xu.v v8, v4, v0.t
 # CHECK-INST: vfcvt.f.xu.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x41,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 41 48 <unknown>
 
 vfcvt.f.xu.v v8, v4
 # CHECK-INST: vfcvt.f.xu.v v8, v4
 # CHECK-ENCODING: [0x57,0x14,0x41,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 41 4a <unknown>
 
 vfcvt.f.x.v v8, v4, v0.t
 # CHECK-INST: vfcvt.f.x.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x94,0x41,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 41 48 <unknown>
 
 vfcvt.f.x.v v8, v4
 # CHECK-INST: vfcvt.f.x.v v8, v4
 # CHECK-ENCODING: [0x57,0x94,0x41,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 41 4a <unknown>
 
 vfcvt.rtz.xu.f.v v8, v4, v0.t
 # CHECK-INST: vfcvt.rtz.xu.f.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x43,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 43 48 <unknown>
 
 vfcvt.rtz.xu.f.v v8, v4
 # CHECK-INST: vfcvt.rtz.xu.f.v v8, v4
 # CHECK-ENCODING: [0x57,0x14,0x43,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 43 4a <unknown>
 
 vfcvt.rtz.x.f.v v8, v4, v0.t
 # CHECK-INST: vfcvt.rtz.x.f.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x94,0x43,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 43 48 <unknown>
 
 vfcvt.rtz.x.f.v v8, v4
 # CHECK-INST: vfcvt.rtz.x.f.v v8, v4
 # CHECK-ENCODING: [0x57,0x94,0x43,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 43 4a <unknown>
 
 vfwcvt.xu.f.v v8, v4, v0.t
 # CHECK-INST: vfwcvt.xu.f.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x44,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 44 48 <unknown>
 
 vfwcvt.xu.f.v v8, v4
 # CHECK-INST: vfwcvt.xu.f.v v8, v4
 # CHECK-ENCODING: [0x57,0x14,0x44,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 44 4a <unknown>
 
 vfwcvt.x.f.v v8, v4, v0.t
 # CHECK-INST: vfwcvt.x.f.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x94,0x44,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 44 48 <unknown>
 
 vfwcvt.x.f.v v8, v4
 # CHECK-INST: vfwcvt.x.f.v v8, v4
 # CHECK-ENCODING: [0x57,0x94,0x44,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 44 4a <unknown>
 
 vfwcvt.f.xu.v v8, v4, v0.t
 # CHECK-INST: vfwcvt.f.xu.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x45,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 45 48 <unknown>
 
 vfwcvt.f.xu.v v8, v4
 # CHECK-INST: vfwcvt.f.xu.v v8, v4
 # CHECK-ENCODING: [0x57,0x14,0x45,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 45 4a <unknown>
 
 vfwcvt.f.x.v v8, v4, v0.t
 # CHECK-INST: vfwcvt.f.x.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x94,0x45,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 45 48 <unknown>
 
 vfwcvt.f.x.v v8, v4
 # CHECK-INST: vfwcvt.f.x.v v8, v4
 # CHECK-ENCODING: [0x57,0x94,0x45,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 45 4a <unknown>
 
 vfwcvt.f.f.v v8, v4, v0.t
 # CHECK-INST: vfwcvt.f.f.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x46,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 46 48 <unknown>
 
 vfwcvt.f.f.v v8, v4
 # CHECK-INST: vfwcvt.f.f.v v8, v4
 # CHECK-ENCODING: [0x57,0x14,0x46,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 46 4a <unknown>
 
 vfwcvt.rtz.xu.f.v v8, v4, v0.t
 # CHECK-INST: vfwcvt.rtz.xu.f.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x47,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 47 48 <unknown>
 
 vfwcvt.rtz.xu.f.v v8, v4
 # CHECK-INST: vfwcvt.rtz.xu.f.v v8, v4
 # CHECK-ENCODING: [0x57,0x14,0x47,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 47 4a <unknown>
 
 vfwcvt.rtz.x.f.v v8, v4, v0.t
 # CHECK-INST: vfwcvt.rtz.x.f.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x94,0x47,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 47 48 <unknown>
 
 vfwcvt.rtz.x.f.v v8, v4
 # CHECK-INST: vfwcvt.rtz.x.f.v v8, v4
 # CHECK-ENCODING: [0x57,0x94,0x47,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 47 4a <unknown>
 
 vfncvt.xu.f.w v8, v4, v0.t
 # CHECK-INST: vfncvt.xu.f.w v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x48,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 48 48 <unknown>
 
 vfncvt.xu.f.w v8, v4
 # CHECK-INST: vfncvt.xu.f.w v8, v4
 # CHECK-ENCODING: [0x57,0x14,0x48,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 48 4a <unknown>
 
 vfncvt.x.f.w v8, v4, v0.t
 # CHECK-INST: vfncvt.x.f.w v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x94,0x48,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 48 48 <unknown>
 
 vfncvt.x.f.w v8, v4
 # CHECK-INST: vfncvt.x.f.w v8, v4
 # CHECK-ENCODING: [0x57,0x94,0x48,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 48 4a <unknown>
 
 vfncvt.f.xu.w v8, v4, v0.t
 # CHECK-INST: vfncvt.f.xu.w v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x49,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 49 48 <unknown>
 
 vfncvt.f.xu.w v8, v4
 # CHECK-INST: vfncvt.f.xu.w v8, v4
 # CHECK-ENCODING: [0x57,0x14,0x49,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 49 4a <unknown>
 
 vfncvt.f.x.w v8, v4, v0.t
 # CHECK-INST: vfncvt.f.x.w v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x94,0x49,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 49 48 <unknown>
 
 vfncvt.f.x.w v8, v4
 # CHECK-INST: vfncvt.f.x.w v8, v4
 # CHECK-ENCODING: [0x57,0x94,0x49,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 49 4a <unknown>
 
 vfncvt.f.f.w v8, v4, v0.t
 # CHECK-INST: vfncvt.f.f.w v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 48 <unknown>
 
 vfncvt.f.f.w v8, v4
 # CHECK-INST: vfncvt.f.f.w v8, v4
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 4a <unknown>
 
 vfncvt.rod.f.f.w v8, v4, v0.t
 # CHECK-INST: vfncvt.rod.f.f.w v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x94,0x4a,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 4a 48 <unknown>
 
 vfncvt.rod.f.f.w v8, v4
 # CHECK-INST: vfncvt.rod.f.f.w v8, v4
 # CHECK-ENCODING: [0x57,0x94,0x4a,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 4a 4a <unknown>
 
 vfncvt.rtz.xu.f.w v8, v4, v0.t
 # CHECK-INST: vfncvt.rtz.xu.f.w v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4b,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4b 48 <unknown>
 
 vfncvt.rtz.xu.f.w v8, v4
 # CHECK-INST: vfncvt.rtz.xu.f.w v8, v4
 # CHECK-ENCODING: [0x57,0x14,0x4b,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4b 4a <unknown>
 
 vfncvt.rtz.x.f.w v8, v4, v0.t
 # CHECK-INST: vfncvt.rtz.x.f.w v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x94,0x4b,0x48]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 4b 48 <unknown>
 
 vfncvt.rtz.x.f.w v8, v4
 # CHECK-INST: vfncvt.rtz.x.f.w v8, v4
 # CHECK-ENCODING: [0x57,0x94,0x4b,0x4a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 94 4b 4a <unknown>

diff  --git a/llvm/test/MC/RISCV/rvv/fadd.s b/llvm/test/MC/RISCV/rvv/fadd.s
index 1c648c5a7634..bfc2d19c845b 100644
--- a/llvm/test/MC/RISCV/rvv/fadd.s
+++ b/llvm/test/MC/RISCV/rvv/fadd.s
@@ -1,81 +1,84 @@
 # RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
 # RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
 # RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
-# RUN:        | llvm-objdump -d --mattr=+experimental-v - \
+# RUN:         --mattr=+f \
+# RUN:        | llvm-objdump -d --mattr=+experimental-v --mattr=+f - \
 # RUN:        | FileCheck %s --check-prefix=CHECK-INST
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
 
 vfadd.vv v8, v4, v20, v0.t
 # CHECK-INST: vfadd.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x00]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 00 <unknown>
 
 vfadd.vv v8, v4, v20
 # CHECK-INST: vfadd.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x02]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 02 <unknown>
 
 vfadd.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfadd.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x00]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 00 <unknown>
 
 vfadd.vf v8, v4, fa0
 # CHECK-INST: vfadd.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x02]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 02 <unknown>
 
 vfwadd.vv v8, v4, v20, v0.t
 # CHECK-INST: vfwadd.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xc0]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a c0 <unknown>
 
 vfwadd.vv v8, v4, v20
 # CHECK-INST: vfwadd.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xc2]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a c2 <unknown>
 
 vfwadd.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfwadd.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xc0]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 c0 <unknown>
 
 vfwadd.vf v8, v4, fa0
 # CHECK-INST: vfwadd.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0xc2]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 c2 <unknown>
 
 vfwadd.wv v8, v4, v20, v0.t
 # CHECK-INST: vfwadd.wv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xd0]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a d0 <unknown>
 
 vfwadd.wv v8, v4, v20
 # CHECK-INST: vfwadd.wv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xd2]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a d2 <unknown>
 
 vfwadd.wf v8, v4, fa0, v0.t
 # CHECK-INST: vfwadd.wf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xd0]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 d0 <unknown>
 
 vfwadd.wf v8, v4, fa0
 # CHECK-INST: vfwadd.wf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0xd2]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 d2 <unknown>

diff  --git a/llvm/test/MC/RISCV/rvv/fcompare.s 
b/llvm/test/MC/RISCV/rvv/fcompare.s
index 4bb4e2d966f2..81781dfe9b20 100644
--- a/llvm/test/MC/RISCV/rvv/fcompare.s
+++ b/llvm/test/MC/RISCV/rvv/fcompare.s
@@ -1,159 +1,162 @@
 # RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
 # RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
 # RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
-# RUN:        | llvm-objdump -d --mattr=+experimental-v - \
+# RUN:         --mattr=+f \
+# RUN:        | llvm-objdump -d --mattr=+experimental-v --mattr=+f - \
 # RUN:        | FileCheck %s --check-prefix=CHECK-INST
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
 
 vmfeq.vv v8, v4, v20, v0.t
 # CHECK-INST: vmfeq.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x60]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 60 <unknown>
 
 vmfeq.vv v8, v4, v20
 # CHECK-INST: vmfeq.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x62]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 62 <unknown>
 
 vmfeq.vf v8, v4, fa0, v0.t
 # CHECK-INST: vmfeq.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x60]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 60 <unknown>
 
 vmfeq.vf v8, v4, fa0
 # CHECK-INST: vmfeq.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x62]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 62 <unknown>
 
 vmfne.vv v8, v4, v20, v0.t
 # CHECK-INST: vmfne.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x70]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 70 <unknown>
 
 vmfne.vv v8, v4, v20
 # CHECK-INST: vmfne.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x72]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 72 <unknown>
 
 vmfne.vf v8, v4, fa0, v0.t
 # CHECK-INST: vmfne.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x70]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 70 <unknown>
 
 vmfne.vf v8, v4, fa0
 # CHECK-INST: vmfne.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x72]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 72 <unknown>
 
 vmflt.vv v8, v4, v20, v0.t
 # CHECK-INST: vmflt.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x6c]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 6c <unknown>
 
 vmflt.vv v8, v4, v20
 # CHECK-INST: vmflt.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x6e]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 6e <unknown>
 
 vmflt.vf v8, v4, fa0, v0.t
 # CHECK-INST: vmflt.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x6c]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 6c <unknown>
 
 vmflt.vf v8, v4, fa0
 # CHECK-INST: vmflt.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x6e]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 6e <unknown>
 
 vmfle.vv v8, v4, v20, v0.t
 # CHECK-INST: vmfle.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x64]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 64 <unknown>
 
 vmfle.vv v8, v4, v20
 # CHECK-INST: vmfle.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x66]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 66 <unknown>
 
 vmfle.vf v8, v4, fa0, v0.t
 # CHECK-INST: vmfle.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x64]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 64 <unknown>
 
 vmfle.vf v8, v4, fa0
 # CHECK-INST: vmfle.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x66]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 66 <unknown>
 
 vmfgt.vf v8, v4, fa0, v0.t
 # CHECK-INST: vmfgt.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x74]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 74 <unknown>
 
 vmfgt.vf v8, v4, fa0
 # CHECK-INST: vmfgt.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x76]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 76 <unknown>
 
 vmfge.vf v8, v4, fa0, v0.t
 # CHECK-INST: vmfge.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x7c]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 7c <unknown>
 
 vmfge.vf v8, v4, fa0
 # CHECK-INST: vmfge.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x7e]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 7e <unknown>
 
 vmfgt.vv v8, v20, v4, v0.t
 # CHECK-INST: vmflt.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x6c]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 6c <unknown>
 
 vmfgt.vv v8, v20, v4
 # CHECK-INST: vmflt.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x6e]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 6e <unknown>
 
 vmfge.vv v8, v20, v4, v0.t
 # CHECK-INST: vmfle.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x64]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 64 <unknown>
 
 vmfge.vv v8, v20, v4
 # CHECK-INST: vmfle.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x66]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 66 <unknown>
 
 vmfeq.vv v0, v4, v20, v0.t
 # CHECK-INST: vmfeq.vv v0, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x10,0x4a,0x60]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 10 4a 60 <unknown>

diff  --git a/llvm/test/MC/RISCV/rvv/fdiv.s b/llvm/test/MC/RISCV/rvv/fdiv.s
index 28c067ec4fcd..12938b3f05be 100644
--- a/llvm/test/MC/RISCV/rvv/fdiv.s
+++ b/llvm/test/MC/RISCV/rvv/fdiv.s
@@ -1,45 +1,48 @@
 # RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
 # RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
 # RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
-# RUN:        | llvm-objdump -d --mattr=+experimental-v - \
+# RUN:         --mattr=+f \
+# RUN:        | llvm-objdump -d --mattr=+experimental-v --mattr=+f - \
 # RUN:        | FileCheck %s --check-prefix=CHECK-INST
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
 
 vfdiv.vv v8, v4, v20, v0.t
 # CHECK-INST: vfdiv.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x80]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 80 <unknown>
 
 vfdiv.vv v8, v4, v20
 # CHECK-INST: vfdiv.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x82]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 82 <unknown>
 
 vfdiv.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfdiv.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x80]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 80 <unknown>
 
 vfdiv.vf v8, v4, fa0
 # CHECK-INST: vfdiv.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x82]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 82 <unknown>
 
 vfrdiv.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfrdiv.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x84]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 84 <unknown>
 
 vfrdiv.vf v8, v4, fa0
 # CHECK-INST: vfrdiv.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x86]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 86 <unknown>

diff  --git a/llvm/test/MC/RISCV/rvv/fmacc.s b/llvm/test/MC/RISCV/rvv/fmacc.s
index 4dc39e4d57b3..cc97ec9fc07a 100644
--- a/llvm/test/MC/RISCV/rvv/fmacc.s
+++ b/llvm/test/MC/RISCV/rvv/fmacc.s
@@ -1,297 +1,300 @@
 # RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
 # RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
 # RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
-# RUN:        | llvm-objdump -d --mattr=+experimental-v - \
+# RUN:         --mattr=+f \
+# RUN:        | llvm-objdump -d --mattr=+experimental-v --mattr=+f - \
 # RUN:        | FileCheck %s --check-prefix=CHECK-INST
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
 
 vfmacc.vv v8, v20, v4, v0.t
 # CHECK-INST: vfmacc.vv v8, v20, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xb0]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a b0 <unknown>
 
 vfmacc.vv v8, v20, v4
 # CHECK-INST: vfmacc.vv v8, v20, v4
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xb2]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a b2 <unknown>
 
 vfmacc.vf v8, fa0, v4, v0.t
 # CHECK-INST: vfmacc.vf v8, fa0, v4, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xb0]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 b0 <unknown>
 
 vfmacc.vf v8, fa0, v4
 # CHECK-INST: vfmacc.vf v8, fa0, v4
 # CHECK-ENCODING: [0x57,0x54,0x45,0xb2]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 b2 <unknown>
 
 vfnmacc.vv v8, v20, v4, v0.t
 # CHECK-INST: vfnmacc.vv v8, v20, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xb4]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a b4 <unknown>
 
 vfnmacc.vv v8, v20, v4
 # CHECK-INST: vfnmacc.vv v8, v20, v4
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xb6]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a b6 <unknown>
 
 vfnmacc.vf v8, fa0, v4, v0.t
 # CHECK-INST: vfnmacc.vf v8, fa0, v4, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xb4]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 b4 <unknown>
 
 vfnmacc.vf v8, fa0, v4
 # CHECK-INST: vfnmacc.vf v8, fa0, v4
 # CHECK-ENCODING: [0x57,0x54,0x45,0xb6]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 b6 <unknown>
 
 vfmsac.vv v8, v20, v4, v0.t
 # CHECK-INST: vfmsac.vv v8, v20, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xb8]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a b8 <unknown>
 
 vfmsac.vv v8, v20, v4
 # CHECK-INST: vfmsac.vv v8, v20, v4
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xba]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a ba <unknown>
 
 vfmsac.vf v8, fa0, v4, v0.t
 # CHECK-INST: vfmsac.vf v8, fa0, v4, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xb8]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 b8 <unknown>
 
 vfmsac.vf v8, fa0, v4
 # CHECK-INST: vfmsac.vf v8, fa0, v4
 # CHECK-ENCODING: [0x57,0x54,0x45,0xba]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 ba <unknown>
 
 vfnmsac.vv v8, v20, v4, v0.t
 # CHECK-INST: vfnmsac.vv v8, v20, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xbc]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a bc <unknown>
 
 vfnmsac.vv v8, v20, v4
 # CHECK-INST: vfnmsac.vv v8, v20, v4
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xbe]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a be <unknown>
 
 vfnmsac.vf v8, fa0, v4, v0.t
 # CHECK-INST: vfnmsac.vf v8, fa0, v4, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xbc]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 bc <unknown>
 
 vfnmsac.vf v8, fa0, v4
 # CHECK-INST: vfnmsac.vf v8, fa0, v4
 # CHECK-ENCODING: [0x57,0x54,0x45,0xbe]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 be <unknown>
 
 vfmadd.vv v8, v20, v4, v0.t
 # CHECK-INST: vfmadd.vv v8, v20, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xa0]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a a0 <unknown>
 
 vfmadd.vv v8, v20, v4
 # CHECK-INST: vfmadd.vv v8, v20, v4
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xa2]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a a2 <unknown>
 
 vfmadd.vf v8, fa0, v4, v0.t
 # CHECK-INST: vfmadd.vf v8, fa0, v4, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xa0]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 a0 <unknown>
 
 vfmadd.vf v8, fa0, v4
 # CHECK-INST: vfmadd.vf v8, fa0, v4
 # CHECK-ENCODING: [0x57,0x54,0x45,0xa2]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 a2 <unknown>
 
 vfnmadd.vv v8, v20, v4, v0.t
 # CHECK-INST: vfnmadd.vv v8, v20, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xa4]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a a4 <unknown>
 
 vfnmadd.vv v8, v20, v4
 # CHECK-INST: vfnmadd.vv v8, v20, v4
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xa6]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a a6 <unknown>
 
 vfnmadd.vf v8, fa0, v4, v0.t
 # CHECK-INST: vfnmadd.vf v8, fa0, v4, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xa4]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 a4 <unknown>
 
 vfnmadd.vf v8, fa0, v4
 # CHECK-INST: vfnmadd.vf v8, fa0, v4
 # CHECK-ENCODING: [0x57,0x54,0x45,0xa6]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 a6 <unknown>
 
 vfmsub.vv v8, v20, v4, v0.t
 # CHECK-INST: vfmsub.vv v8, v20, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xa8]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a a8 <unknown>
 
 vfmsub.vv v8, v20, v4
 # CHECK-INST: vfmsub.vv v8, v20, v4
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xaa]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a aa <unknown>
 
 vfmsub.vf v8, fa0, v4, v0.t
 # CHECK-INST: vfmsub.vf v8, fa0, v4, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xa8]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 a8 <unknown>
 
 vfmsub.vf v8, fa0, v4
 # CHECK-INST: vfmsub.vf v8, fa0, v4
 # CHECK-ENCODING: [0x57,0x54,0x45,0xaa]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 aa <unknown>
 
 vfnmsub.vv v8, v20, v4, v0.t
 # CHECK-INST: vfnmsub.vv v8, v20, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xac]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a ac <unknown>
 
 vfnmsub.vv v8, v20, v4
 # CHECK-INST: vfnmsub.vv v8, v20, v4
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xae]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a ae <unknown>
 
 vfnmsub.vf v8, fa0, v4, v0.t
 # CHECK-INST: vfnmsub.vf v8, fa0, v4, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xac]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 ac <unknown>
 
 vfnmsub.vf v8, fa0, v4
 # CHECK-INST: vfnmsub.vf v8, fa0, v4
 # CHECK-ENCODING: [0x57,0x54,0x45,0xae]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 ae <unknown>
 
 vfwmacc.vv v8, v20, v4, v0.t
 # CHECK-INST: vfwmacc.vv v8, v20, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xf0]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a f0 <unknown>
 
 vfwmacc.vv v8, v20, v4
 # CHECK-INST: vfwmacc.vv v8, v20, v4
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xf2]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a f2 <unknown>
 
 vfwmacc.vf v8, fa0, v4, v0.t
 # CHECK-INST: vfwmacc.vf v8, fa0, v4, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xf0]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 f0 <unknown>
 
 vfwmacc.vf v8, fa0, v4
 # CHECK-INST: vfwmacc.vf v8, fa0, v4
 # CHECK-ENCODING: [0x57,0x54,0x45,0xf2]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 f2 <unknown>
 
 vfwnmacc.vv v8, v20, v4, v0.t
 # CHECK-INST: vfwnmacc.vv v8, v20, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xf4]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a f4 <unknown>
 
 vfwnmacc.vv v8, v20, v4
 # CHECK-INST: vfwnmacc.vv v8, v20, v4
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xf6]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a f6 <unknown>
 
 vfwnmacc.vf v8, fa0, v4, v0.t
 # CHECK-INST: vfwnmacc.vf v8, fa0, v4, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xf4]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 f4 <unknown>
 
 vfwnmacc.vf v8, fa0, v4
 # CHECK-INST: vfwnmacc.vf v8, fa0, v4
 # CHECK-ENCODING: [0x57,0x54,0x45,0xf6]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 f6 <unknown>
 
 vfwmsac.vv v8, v20, v4, v0.t
 # CHECK-INST: vfwmsac.vv v8, v20, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xf8]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a f8 <unknown>
 
 vfwmsac.vv v8, v20, v4
 # CHECK-INST: vfwmsac.vv v8, v20, v4
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xfa]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a fa <unknown>
 
 vfwmsac.vf v8, fa0, v4, v0.t
 # CHECK-INST: vfwmsac.vf v8, fa0, v4, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xf8]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 f8 <unknown>
 
 vfwmsac.vf v8, fa0, v4
 # CHECK-INST: vfwmsac.vf v8, fa0, v4
 # CHECK-ENCODING: [0x57,0x54,0x45,0xfa]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 fa <unknown>
 
 vfwnmsac.vv v8, v20, v4, v0.t
 # CHECK-INST: vfwnmsac.vv v8, v20, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xfc]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a fc <unknown>
 
 vfwnmsac.vv v8, v20, v4
 # CHECK-INST: vfwnmsac.vv v8, v20, v4
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xfe]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a fe <unknown>
 
 vfwnmsac.vf v8, fa0, v4, v0.t
 # CHECK-INST: vfwnmsac.vf v8, fa0, v4, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xfc]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 fc <unknown>
 
 vfwnmsac.vf v8, fa0, v4
 # CHECK-INST: vfwnmsac.vf v8, fa0, v4
 # CHECK-ENCODING: [0x57,0x54,0x45,0xfe]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 fe <unknown>

diff  --git a/llvm/test/MC/RISCV/rvv/fminmax.s 
b/llvm/test/MC/RISCV/rvv/fminmax.s
index 8ce3db16b3ea..20ec857ceda4 100644
--- a/llvm/test/MC/RISCV/rvv/fminmax.s
+++ b/llvm/test/MC/RISCV/rvv/fminmax.s
@@ -1,57 +1,60 @@
 # RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
 # RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
 # RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
-# RUN:        | llvm-objdump -d --mattr=+experimental-v - \
+# RUN:         --mattr=+f \
+# RUN:        | llvm-objdump -d --mattr=+experimental-v --mattr=+f - \
 # RUN:        | FileCheck %s --check-prefix=CHECK-INST
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
 
 vfmin.vv v8, v4, v20, v0.t
 # CHECK-INST: vfmin.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x10]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 10 <unknown>
 
 vfmin.vv v8, v4, v20
 # CHECK-INST: vfmin.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x12]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 12 <unknown>
 
 vfmin.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfmin.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x10]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 10 <unknown>
 
 vfmin.vf v8, v4, fa0
 # CHECK-INST: vfmin.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x12]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 12 <unknown>
 
 vfmax.vv v8, v4, v20, v0.t
 # CHECK-INST: vfmax.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x18]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 18 <unknown>
 
 vfmax.vv v8, v4, v20
 # CHECK-INST: vfmax.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x1a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 1a <unknown>
 
 vfmax.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfmax.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x18]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 18 <unknown>
 
 vfmax.vf v8, v4, fa0
 # CHECK-INST: vfmax.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x1a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 1a <unknown>

diff  --git a/llvm/test/MC/RISCV/rvv/fmul.s b/llvm/test/MC/RISCV/rvv/fmul.s
index 82f3bd3a4bf6..0fb91b4cc11c 100644
--- a/llvm/test/MC/RISCV/rvv/fmul.s
+++ b/llvm/test/MC/RISCV/rvv/fmul.s
@@ -1,57 +1,60 @@
 # RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
 # RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
 # RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
-# RUN:        | llvm-objdump -d --mattr=+experimental-v - \
+# RUN:         --mattr=+f \
+# RUN:        | llvm-objdump -d --mattr=+experimental-v --mattr=+f - \
 # RUN:        | FileCheck %s --check-prefix=CHECK-INST
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
 
 vfmul.vv v8, v4, v20, v0.t
 # CHECK-INST: vfmul.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x90]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 90 <unknown>
 
 vfmul.vv v8, v4, v20
 # CHECK-INST: vfmul.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x92]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 92 <unknown>
 
 vfmul.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfmul.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x90]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 90 <unknown>
 
 vfmul.vf v8, v4, fa0
 # CHECK-INST: vfmul.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x92]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 92 <unknown>
 
 vfwmul.vv v8, v4, v20, v0.t
 # CHECK-INST: vfwmul.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xe0]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a e0 <unknown>
 
 vfwmul.vv v8, v4, v20
 # CHECK-INST: vfwmul.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xe2]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a e2 <unknown>
 
 vfwmul.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfwmul.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xe0]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 e0 <unknown>
 
 vfwmul.vf v8, v4, fa0
 # CHECK-INST: vfwmul.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0xe2]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 e2 <unknown>

diff  --git a/llvm/test/MC/RISCV/rvv/fmv.s b/llvm/test/MC/RISCV/rvv/fmv.s
index 74e3f0268bda..194cae0a4273 100644
--- a/llvm/test/MC/RISCV/rvv/fmv.s
+++ b/llvm/test/MC/RISCV/rvv/fmv.s
@@ -1,27 +1,30 @@
 # RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
 # RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
 # RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
-# RUN:        | llvm-objdump -d --mattr=+experimental-v - \
+# RUN:         --mattr=+f \
+# RUN:        | llvm-objdump -d --mattr=+experimental-v --mattr=+f - \
 # RUN:        | FileCheck %s --check-prefix=CHECK-INST
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
 
 vfmv.v.f v8, fa0
 # CHECK-INST: vfmv.v.f v8, fa0
 # CHECK-ENCODING: [0x57,0x54,0x05,0x5e]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 05 5e <unknown>
 
 vfmv.f.s fa0, v4
 # CHECK-INST: vfmv.f.s fa0, v4
 # CHECK-ENCODING: [0x57,0x15,0x40,0x42]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 15 40 42 <unknown>
 
 vfmv.s.f v8, fa0
 # CHECK-INST: vfmv.s.f v8, fa0
 # CHECK-ENCODING: [0x57,0x54,0x05,0x42]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 05 42 <unknown>

diff  --git a/llvm/test/MC/RISCV/rvv/fothers.s 
b/llvm/test/MC/RISCV/rvv/fothers.s
index b9e03842fa2d..b46e4bcb3489 100644
--- a/llvm/test/MC/RISCV/rvv/fothers.s
+++ b/llvm/test/MC/RISCV/rvv/fothers.s
@@ -1,63 +1,66 @@
 # RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
 # RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
 # RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
-# RUN:        | llvm-objdump -d --mattr=+experimental-v - \
+# RUN:         --mattr=+f \
+# RUN:        | llvm-objdump -d --mattr=+experimental-v --mattr=+f - \
 # RUN:        | FileCheck %s --check-prefix=CHECK-INST
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
 
 vfsqrt.v v8, v4, v0.t
 # CHECK-INST: vfsqrt.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x40,0x4c]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 40 4c <unknown>
 
 vfsqrt.v v8, v4
 # CHECK-INST: vfsqrt.v v8, v4
 # CHECK-ENCODING: [0x57,0x14,0x40,0x4e]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 40 4e <unknown>
 
 vfclass.v v8, v4, v0.t
 # CHECK-INST: vfclass.v v8, v4, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x48,0x4c]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 48 4c <unknown>
 
 vfclass.v v8, v4
 # CHECK-INST: vfclass.v v8, v4
 # CHECK-ENCODING: [0x57,0x14,0x48,0x4e]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 48 4e <unknown>
 
 vfmerge.vfm v8, v4, fa0, v0
 # CHECK-INST: vfmerge.vfm v8, v4, fa0, v0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x5c]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 5c <unknown>
 
 vfslide1up.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfslide1up.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x38]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 38 <unknown>
 
 vfslide1up.vf v8, v4, fa0
 # CHECK-INST: vfslide1up.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x3a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 3a <unknown>
 
 vfslide1down.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfslide1down.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x3c]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 3c <unknown>
 
 vfslide1down.vf v8, v4, fa0
 # CHECK-INST: vfslide1down.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x3e]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 3e <unknown>

diff  --git a/llvm/test/MC/RISCV/rvv/freduction.s 
b/llvm/test/MC/RISCV/rvv/freduction.s
index a85e676f9a8c..847366a3fd22 100644
--- a/llvm/test/MC/RISCV/rvv/freduction.s
+++ b/llvm/test/MC/RISCV/rvv/freduction.s
@@ -1,87 +1,90 @@
 # RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
 # RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
 # RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
-# RUN:        | llvm-objdump -d --mattr=+experimental-v - \
+# RUN:         --mattr=+f \
+# RUN:        | llvm-objdump -d --mattr=+experimental-v --mattr=+f - \
 # RUN:        | FileCheck %s --check-prefix=CHECK-INST
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
 
 vfredosum.vs v8, v4, v20, v0.t
 # CHECK-INST: vfredosum.vs v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x0c]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 0c <unknown>
 
 vfredosum.vs v8, v4, v20
 # CHECK-INST: vfredosum.vs v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x0e]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 0e <unknown>
 
 vfredsum.vs v8, v4, v20, v0.t
 # CHECK-INST: vfredsum.vs v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x04]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 04 <unknown>
 
 vfredsum.vs v8, v4, v20
 # CHECK-INST: vfredsum.vs v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x06]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 06 <unknown>
 
 vfredmax.vs v8, v4, v20, v0.t
 # CHECK-INST: vfredmax.vs v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x1c]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 1c <unknown>
 
 vfredmax.vs v8, v4, v20
 # CHECK-INST: vfredmax.vs v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x1e]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 1e <unknown>
 
 vfredmin.vs v8, v4, v20, v0.t
 # CHECK-INST: vfredmin.vs v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x14]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 14 <unknown>
 
 vfredmin.vs v8, v4, v20
 # CHECK-INST: vfredmin.vs v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x16]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 16 <unknown>
 
 vfwredosum.vs v8, v4, v20, v0.t
 # CHECK-INST: vfwredosum.vs v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xcc]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a cc <unknown>
 
 vfwredosum.vs v8, v4, v20
 # CHECK-INST: vfwredosum.vs v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xce]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a ce <unknown>
 
 vfwredsum.vs v8, v4, v20, v0.t
 # CHECK-INST: vfwredsum.vs v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xc4]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a c4 <unknown>
 
 vfwredsum.vs v8, v4, v20
 # CHECK-INST: vfwredsum.vs v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xc6]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a c6 <unknown>
 
 vfredosum.vs v0, v4, v20, v0.t
 # CHECK-INST: vfredosum.vs v0, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x10,0x4a,0x0c]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 10 4a 0c <unknown>

diff  --git a/llvm/test/MC/RISCV/rvv/fsub.s b/llvm/test/MC/RISCV/rvv/fsub.s
index 753da9a202b1..70e8796e58d4 100644
--- a/llvm/test/MC/RISCV/rvv/fsub.s
+++ b/llvm/test/MC/RISCV/rvv/fsub.s
@@ -1,93 +1,96 @@
 # RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
 # RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
 # RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
-# RUN:        | llvm-objdump -d --mattr=+experimental-v - \
+# RUN:         --mattr=+f \
+# RUN:        | llvm-objdump -d --mattr=+experimental-v --mattr=+f - \
 # RUN:        | FileCheck %s --check-prefix=CHECK-INST
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
 
 vfsub.vv v8, v4, v20, v0.t
 # CHECK-INST: vfsub.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x08]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 08 <unknown>
 
 vfsub.vv v8, v4, v20
 # CHECK-INST: vfsub.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x0a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 0a <unknown>
 
 vfsub.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfsub.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x08]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 08 <unknown>
 
 vfsub.vf v8, v4, fa0
 # CHECK-INST: vfsub.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x0a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 0a <unknown>
 
 vfrsub.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfrsub.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x9c]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 9c <unknown>
 
 vfrsub.vf v8, v4, fa0
 # CHECK-INST: vfrsub.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x9e]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 9e <unknown>
 
 vfwsub.vv v8, v4, v20, v0.t
 # CHECK-INST: vfwsub.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xc8]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a c8 <unknown>
 
 vfwsub.vv v8, v4, v20
 # CHECK-INST: vfwsub.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xca]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a ca <unknown>
 
 vfwsub.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfwsub.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xc8]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 c8 <unknown>
 
 vfwsub.vf v8, v4, fa0
 # CHECK-INST: vfwsub.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0xca]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 ca <unknown>
 
 vfwsub.wv v8, v4, v20, v0.t
 # CHECK-INST: vfwsub.wv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xd8]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a d8 <unknown>
 
 vfwsub.wv v8, v4, v20
 # CHECK-INST: vfwsub.wv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0xda]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a da <unknown>
 
 vfwsub.wf v8, v4, fa0, v0.t
 # CHECK-INST: vfwsub.wf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0xd8]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 d8 <unknown>
 
 vfwsub.wf v8, v4, fa0
 # CHECK-INST: vfwsub.wf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0xda]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 da <unknown>

diff  --git a/llvm/test/MC/RISCV/rvv/sign-injection.s 
b/llvm/test/MC/RISCV/rvv/sign-injection.s
index 0831f923be3f..d8efea7f2762 100644
--- a/llvm/test/MC/RISCV/rvv/sign-injection.s
+++ b/llvm/test/MC/RISCV/rvv/sign-injection.s
@@ -1,81 +1,84 @@
 # RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
 # RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
 # RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
-# RUN:        | llvm-objdump -d --mattr=+experimental-v - \
+# RUN:         --mattr=+f \
+# RUN:        | llvm-objdump -d --mattr=+experimental-v --mattr=+f - \
 # RUN:        | FileCheck %s --check-prefix=CHECK-INST
 # RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
+# RUN:         --mattr=+f \
 # RUN:        | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
 
 vfsgnj.vv v8, v4, v20, v0.t
 # CHECK-INST: vfsgnj.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x20]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 20 <unknown>
 
 vfsgnj.vv v8, v4, v20
 # CHECK-INST: vfsgnj.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x22]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 22 <unknown>
 
 vfsgnj.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfsgnj.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x20]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 20 <unknown>
 
 vfsgnj.vf v8, v4, fa0
 # CHECK-INST: vfsgnj.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x22]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 22 <unknown>
 
 vfsgnjn.vv v8, v4, v20, v0.t
 # CHECK-INST: vfsgnjn.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x24]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 24 <unknown>
 
 vfsgnjn.vv v8, v4, v20
 # CHECK-INST: vfsgnjn.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x26]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 26 <unknown>
 
 vfsgnjn.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfsgnjn.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x24]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 24 <unknown>
 
 vfsgnjn.vf v8, v4, fa0
 # CHECK-INST: vfsgnjn.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x26]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 26 <unknown>
 
 vfsgnjx.vv v8, v4, v20, v0.t
 # CHECK-INST: vfsgnjx.vv v8, v4, v20, v0.t
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x28]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 28 <unknown>
 
 vfsgnjx.vv v8, v4, v20
 # CHECK-INST: vfsgnjx.vv v8, v4, v20
 # CHECK-ENCODING: [0x57,0x14,0x4a,0x2a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 14 4a 2a <unknown>
 
 vfsgnjx.vf v8, v4, fa0, v0.t
 # CHECK-INST: vfsgnjx.vf v8, v4, fa0, v0.t
 # CHECK-ENCODING: [0x57,0x54,0x45,0x28]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 28 <unknown>
 
 vfsgnjx.vf v8, v4, fa0
 # CHECK-INST: vfsgnjx.vf v8, v4, fa0
 # CHECK-ENCODING: [0x57,0x54,0x45,0x2a]
-# CHECK-ERROR: instruction requires the following: 'V' (Vector Instructions)
+# CHECK-ERROR: instruction requires the following: 'V' and 'F' (Vector 
Floating-point Instructions)
 # CHECK-UNKNOWN: 57 54 45 2a <unknown>


        
_______________________________________________
llvm-branch-commits mailing list
llvm-branch-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits