This is an archive of the discontinued LLVM Phabricator instance.

Show First 20 Lines • Show All 154 Lines • ▼ Show 20 Lines	def FeatureNoRVCHints
: SubtargetFeature<"no-rvc-hints", "EnableRVCHintInstrs", "false",		: SubtargetFeature<"no-rvc-hints", "EnableRVCHintInstrs", "false",
"Disable RVC Hint Instructions.">;		"Disable RVC Hint Instructions.">;
def HasRVCHints : Predicate<"Subtarget->enableRVCHintInstrs()">,		def HasRVCHints : Predicate<"Subtarget->enableRVCHintInstrs()">,
AssemblerPredicate<(all_of(not FeatureNoRVCHints)),		AssemblerPredicate<(all_of(not FeatureNoRVCHints)),
"RVC Hint Instructions">;		"RVC Hint Instructions">;

def FeatureStdExtV		def FeatureStdExtV
: SubtargetFeature<"experimental-v", "HasStdExtV", "true",		: SubtargetFeature<"experimental-v", "HasStdExtV", "true",
"'V' (Vector Instructions)",		"'V' (Vector Instructions)">;
[FeatureStdExtF]>;
def HasStdExtV : Predicate<"Subtarget->hasStdExtV()">,		def HasStdExtV : Predicate<"Subtarget->hasStdExtV()">,
AssemblerPredicate<(all_of FeatureStdExtV),		AssemblerPredicate<(all_of FeatureStdExtV),
"'V' (Vector Instructions)">;		"'V' (Vector Instructions)">;
		def HasStdExtVAndF
		: Predicate<"Subtarget->hasStdExtV() && Subtarget->hasStdExtF()">,
		AssemblerPredicate<(all_of FeatureStdExtV, FeatureStdExtF),
		"'V' and 'F' (Vector Floating-point Instructions)">;

def FeatureStdExtZvlsseg		def FeatureStdExtZvlsseg
: SubtargetFeature<"experimental-zvlsseg", "HasStdExtZvlsseg", "true",		: SubtargetFeature<"experimental-zvlsseg", "HasStdExtZvlsseg", "true",
"'Zvlsseg' (Vector segment load/store instructions)",		"'Zvlsseg' (Vector segment load/store instructions)",
[FeatureStdExtV]>;		[FeatureStdExtV]>;
def HasStdExtZvlsseg : Predicate<"Subtarget->hasStdExtZvlsseg()">,		def HasStdExtZvlsseg : Predicate<"Subtarget->hasStdExtZvlsseg()">,
AssemblerPredicate<(all_of FeatureStdExtZvlsseg),		AssemblerPredicate<(all_of FeatureStdExtZvlsseg),
"'Zvlsseg' (Vector segment load/store instructions)">;		"'Zvlsseg' (Vector segment load/store instructions)">;
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

Show First 20 Lines • Show All 118 Lines • ▼ Show 20 Lines	if (Subtarget.hasStdExtV()) {
addRegisterClass(RISCVVMVTs::vint32m4_t, &RISCV::VRM4RegClass);		addRegisterClass(RISCVVMVTs::vint32m4_t, &RISCV::VRM4RegClass);
addRegisterClass(RISCVVMVTs::vint32m8_t, &RISCV::VRM8RegClass);		addRegisterClass(RISCVVMVTs::vint32m8_t, &RISCV::VRM8RegClass);

addRegisterClass(RISCVVMVTs::vint64m1_t, &RISCV::VRRegClass);		addRegisterClass(RISCVVMVTs::vint64m1_t, &RISCV::VRRegClass);
addRegisterClass(RISCVVMVTs::vint64m2_t, &RISCV::VRM2RegClass);		addRegisterClass(RISCVVMVTs::vint64m2_t, &RISCV::VRM2RegClass);
addRegisterClass(RISCVVMVTs::vint64m4_t, &RISCV::VRM4RegClass);		addRegisterClass(RISCVVMVTs::vint64m4_t, &RISCV::VRM4RegClass);
addRegisterClass(RISCVVMVTs::vint64m8_t, &RISCV::VRM8RegClass);		addRegisterClass(RISCVVMVTs::vint64m8_t, &RISCV::VRM8RegClass);

		if (Subtarget.hasStdExtZfh()) {
addRegisterClass(RISCVVMVTs::vfloat16mf4_t, &RISCV::VRRegClass);		addRegisterClass(RISCVVMVTs::vfloat16mf4_t, &RISCV::VRRegClass);
addRegisterClass(RISCVVMVTs::vfloat16mf2_t, &RISCV::VRRegClass);		addRegisterClass(RISCVVMVTs::vfloat16mf2_t, &RISCV::VRRegClass);
addRegisterClass(RISCVVMVTs::vfloat16m1_t, &RISCV::VRRegClass);		addRegisterClass(RISCVVMVTs::vfloat16m1_t, &RISCV::VRRegClass);
addRegisterClass(RISCVVMVTs::vfloat16m2_t, &RISCV::VRM2RegClass);		addRegisterClass(RISCVVMVTs::vfloat16m2_t, &RISCV::VRM2RegClass);
addRegisterClass(RISCVVMVTs::vfloat16m4_t, &RISCV::VRM4RegClass);		addRegisterClass(RISCVVMVTs::vfloat16m4_t, &RISCV::VRM4RegClass);
addRegisterClass(RISCVVMVTs::vfloat16m8_t, &RISCV::VRM8RegClass);		addRegisterClass(RISCVVMVTs::vfloat16m8_t, &RISCV::VRM8RegClass);
		}

		if (Subtarget.hasStdExtF()) {
addRegisterClass(RISCVVMVTs::vfloat32mf2_t, &RISCV::VRRegClass);		addRegisterClass(RISCVVMVTs::vfloat32mf2_t, &RISCV::VRRegClass);
addRegisterClass(RISCVVMVTs::vfloat32m1_t, &RISCV::VRRegClass);		addRegisterClass(RISCVVMVTs::vfloat32m1_t, &RISCV::VRRegClass);
addRegisterClass(RISCVVMVTs::vfloat32m2_t, &RISCV::VRM2RegClass);		addRegisterClass(RISCVVMVTs::vfloat32m2_t, &RISCV::VRM2RegClass);
addRegisterClass(RISCVVMVTs::vfloat32m4_t, &RISCV::VRM4RegClass);		addRegisterClass(RISCVVMVTs::vfloat32m4_t, &RISCV::VRM4RegClass);
addRegisterClass(RISCVVMVTs::vfloat32m8_t, &RISCV::VRM8RegClass);		addRegisterClass(RISCVVMVTs::vfloat32m8_t, &RISCV::VRM8RegClass);
		}

		if (Subtarget.hasStdExtD()) {
addRegisterClass(RISCVVMVTs::vfloat64m1_t, &RISCV::VRRegClass);		addRegisterClass(RISCVVMVTs::vfloat64m1_t, &RISCV::VRRegClass);
addRegisterClass(RISCVVMVTs::vfloat64m2_t, &RISCV::VRM2RegClass);		addRegisterClass(RISCVVMVTs::vfloat64m2_t, &RISCV::VRM2RegClass);
addRegisterClass(RISCVVMVTs::vfloat64m4_t, &RISCV::VRM4RegClass);		addRegisterClass(RISCVVMVTs::vfloat64m4_t, &RISCV::VRM4RegClass);
addRegisterClass(RISCVVMVTs::vfloat64m8_t, &RISCV::VRM8RegClass);		addRegisterClass(RISCVVMVTs::vfloat64m8_t, &RISCV::VRM8RegClass);
}		}
		}

// Compute derived properties from the register classes.		// Compute derived properties from the register classes.
computeRegisterProperties(STI.getRegisterInfo());		computeRegisterProperties(STI.getRegisterInfo());

setStackPointerRegisterToSaveRestore(RISCV::X2);		setStackPointerRegisterToSaveRestore(RISCV::X2);

for (auto N : {ISD::EXTLOAD, ISD::SEXTLOAD, ISD::ZEXTLOAD})		for (auto N : {ISD::EXTLOAD, ISD::SEXTLOAD, ISD::ZEXTLOAD})
setLoadExtAction(N, XLenVT, MVT::i1, Promote);		setLoadExtAction(N, XLenVT, MVT::i1, Promote);
▲ Show 20 Lines • Show All 3,618 Lines • Show Last 20 Lines

llvm/lib/Target/RISCV/RISCVInstrInfoV.td

	Show First 20 Lines • Show All 730 Lines • ▼ Show 20 Lines
	defm VSSRL_V : VALU_IV_V_X_I<"vssrl", 0b101010, uimm5>;			defm VSSRL_V : VALU_IV_V_X_I<"vssrl", 0b101010, uimm5>;
	defm VSSRA_V : VALU_IV_V_X_I<"vssra", 0b101011, uimm5>;			defm VSSRA_V : VALU_IV_V_X_I<"vssra", 0b101011, uimm5>;

	// Vector Narrowing Fixed-Point Clip Instructions			// Vector Narrowing Fixed-Point Clip Instructions
	let Constraints = "@earlyclobber $vd", RVVConstraint = Narrow in {			let Constraints = "@earlyclobber $vd", RVVConstraint = Narrow in {
	defm VNCLIPU_W : VALU_IV_V_X_I<"vnclipu", 0b101110, uimm5, "w">;			defm VNCLIPU_W : VALU_IV_V_X_I<"vnclipu", 0b101110, uimm5, "w">;
	defm VNCLIP_W : VALU_IV_V_X_I<"vnclip", 0b101111, uimm5, "w">;			defm VNCLIP_W : VALU_IV_V_X_I<"vnclip", 0b101111, uimm5, "w">;
	} // Constraints = "@earlyclobber $vd", RVVConstraint = Narrow			} // Constraints = "@earlyclobber $vd", RVVConstraint = Narrow
				} // Predicates = [HasStdExtV]

				let Predicates = [HasStdExtVAndF] in {
				craig.topperUnsubmitted Not Done Reply Inline Actions Can't this just be [HasStdExtV, HasStdExtF]? craig.topper: Can't this just be [HasStdExtV, HasStdExtF]?
				frasercrmckUnsubmitted Not Done Reply Inline Actions I'd vote for separating them too frasercrmck: I'd vote for separating them too
	// Vector Single-Width Floating-Point Add/Subtract Instructions			// Vector Single-Width Floating-Point Add/Subtract Instructions
	defm VFADD_V : VALU_FV_V_F<"vfadd", 0b000000>;			defm VFADD_V : VALU_FV_V_F<"vfadd", 0b000000>;
	defm VFSUB_V : VALU_FV_V_F<"vfsub", 0b000010>;			defm VFSUB_V : VALU_FV_V_F<"vfsub", 0b000010>;
	defm VFRSUB_V : VALU_FV_F<"vfrsub", 0b100111>;			defm VFRSUB_V : VALU_FV_F<"vfrsub", 0b100111>;

	// Vector Widening Floating-Point Add/Subtract Instructions			// Vector Widening Floating-Point Add/Subtract Instructions
	let Constraints = "@earlyclobber $vd" in {			let Constraints = "@earlyclobber $vd" in {
	let RVVConstraint = WidenV in {			let RVVConstraint = WidenV in {
	▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Lines
	defm VFNCVT_X_F_W : VALU_FV_VS2<"vfncvt.x.f.w", 0b010010, 0b10001>;			defm VFNCVT_X_F_W : VALU_FV_VS2<"vfncvt.x.f.w", 0b010010, 0b10001>;
	defm VFNCVT_RTZ_XU_F_W : VALU_FV_VS2<"vfncvt.rtz.xu.f.w", 0b010010, 0b10110>;			defm VFNCVT_RTZ_XU_F_W : VALU_FV_VS2<"vfncvt.rtz.xu.f.w", 0b010010, 0b10110>;
	defm VFNCVT_RTZ_X_F_W : VALU_FV_VS2<"vfncvt.rtz.x.f.w", 0b010010, 0b10111>;			defm VFNCVT_RTZ_X_F_W : VALU_FV_VS2<"vfncvt.rtz.x.f.w", 0b010010, 0b10111>;
	defm VFNCVT_F_XU_W : VALU_FV_VS2<"vfncvt.f.xu.w", 0b010010, 0b10010>;			defm VFNCVT_F_XU_W : VALU_FV_VS2<"vfncvt.f.xu.w", 0b010010, 0b10010>;
	defm VFNCVT_F_X_W : VALU_FV_VS2<"vfncvt.f.x.w", 0b010010, 0b10011>;			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_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>;			defm VFNCVT_ROD_F_F_W : VALU_FV_VS2<"vfncvt.rod.f.f.w", 0b010010, 0b10101>;
	} // Constraints = "@earlyclobber $vd", RVVConstraint = NarrowCvt			} // Constraints = "@earlyclobber $vd", RVVConstraint = NarrowCvt
				} // Predicates = [HasStdExtVAndF]

				let Predicates = [HasStdExtV] in {
	// Vector Single-Width Integer Reduction Instructions			// Vector Single-Width Integer Reduction Instructions
	let RVVConstraint = NoConstraint in {			let RVVConstraint = NoConstraint in {
	defm VREDSUM : VALU_MV_V<"vredsum", 0b000000>;			defm VREDSUM : VALU_MV_V<"vredsum", 0b000000>;
	defm VREDMAXU : VALU_MV_V<"vredmaxu", 0b000110>;			defm VREDMAXU : VALU_MV_V<"vredmaxu", 0b000110>;
	defm VREDMAX : VALU_MV_V<"vredmax", 0b000111>;			defm VREDMAX : VALU_MV_V<"vredmax", 0b000111>;
	defm VREDMINU : VALU_MV_V<"vredminu", 0b000100>;			defm VREDMINU : VALU_MV_V<"vredminu", 0b000100>;
	defm VREDMIN : VALU_MV_V<"vredmin", 0b000101>;			defm VREDMIN : VALU_MV_V<"vredmin", 0b000101>;
	defm VREDAND : VALU_MV_V<"vredand", 0b000001>;			defm VREDAND : VALU_MV_V<"vredand", 0b000001>;
	defm VREDOR : VALU_MV_V<"vredor", 0b000010>;			defm VREDOR : VALU_MV_V<"vredor", 0b000010>;
	defm VREDXOR : VALU_MV_V<"vredxor", 0b000011>;			defm VREDXOR : VALU_MV_V<"vredxor", 0b000011>;
	} // RVVConstraint = NoConstraint			} // RVVConstraint = NoConstraint

	// Vector Widening Integer Reduction Instructions			// Vector Widening Integer Reduction Instructions
	let Constraints = "@earlyclobber $vd", RVVConstraint = NoConstraint in {			let Constraints = "@earlyclobber $vd", RVVConstraint = NoConstraint in {
	// Set earlyclobber for following instructions for second and mask operands.			// Set earlyclobber for following instructions for second and mask operands.
	// This has the downside that the earlyclobber constraint is too coarse and			// This has the downside that the earlyclobber constraint is too coarse and
	// will impose unnecessary restrictions by not allowing the destination to			// will impose unnecessary restrictions by not allowing the destination to
	// overlap with the first (wide) operand.			// overlap with the first (wide) operand.
	defm VWREDSUMU : VALU_IV_V<"vwredsumu", 0b110000>;			defm VWREDSUMU : VALU_IV_V<"vwredsumu", 0b110000>;
	defm VWREDSUM : VALU_IV_V<"vwredsum", 0b110001>;			defm VWREDSUM : VALU_IV_V<"vwredsum", 0b110001>;
	} // Constraints = "@earlyclobber $vd", RVVConstraint = NoConstraint			} // Constraints = "@earlyclobber $vd", RVVConstraint = NoConstraint
				} // Predicates = [HasStdExtV]

				let Predicates = [HasStdExtVAndF] in {
				craig.topperUnsubmitted Not Done Reply Inline Actions Same here craig.topper: Same here
	// Vector Single-Width Floating-Point Reduction Instructions			// Vector Single-Width Floating-Point Reduction Instructions
	let RVVConstraint = NoConstraint in {			let RVVConstraint = NoConstraint in {
	defm VFREDOSUM : VALU_FV_V<"vfredosum", 0b000011>;			defm VFREDOSUM : VALU_FV_V<"vfredosum", 0b000011>;
	defm VFREDSUM : VALU_FV_V<"vfredsum", 0b000001>;			defm VFREDSUM : VALU_FV_V<"vfredsum", 0b000001>;
	defm VFREDMAX : VALU_FV_V<"vfredmax", 0b000111>;			defm VFREDMAX : VALU_FV_V<"vfredmax", 0b000111>;
	defm VFREDMIN : VALU_FV_V<"vfredmin", 0b000101>;			defm VFREDMIN : VALU_FV_V<"vfredmin", 0b000101>;
	} // RVVConstraint = NoConstraint			} // RVVConstraint = NoConstraint

	// Vector Widening Floating-Point Reduction Instructions			// Vector Widening Floating-Point Reduction Instructions
	let Constraints = "@earlyclobber $vd", RVVConstraint = NoConstraint in {			let Constraints = "@earlyclobber $vd", RVVConstraint = NoConstraint in {
	// Set earlyclobber for following instructions for second and mask operands.			// Set earlyclobber for following instructions for second and mask operands.
	// This has the downside that the earlyclobber constraint is too coarse and			// This has the downside that the earlyclobber constraint is too coarse and
	// will impose unnecessary restrictions by not allowing the destination to			// will impose unnecessary restrictions by not allowing the destination to
	// overlap with the first (wide) operand.			// overlap with the first (wide) operand.
	defm VFWREDOSUM : VALU_FV_V<"vfwredosum", 0b110011>;			defm VFWREDOSUM : VALU_FV_V<"vfwredosum", 0b110011>;
	defm VFWREDSUM : VALU_FV_V<"vfwredsum", 0b110001>;			defm VFWREDSUM : VALU_FV_V<"vfwredsum", 0b110001>;
	} // Constraints = "@earlyclobber $vd", RVVConstraint = NoConstraint			} // Constraints = "@earlyclobber $vd", RVVConstraint = NoConstraint
				} // Predicates = [HasStdExtVAndF]

				let Predicates = [HasStdExtV] in {
	// Vector Mask-Register Logical Instructions			// Vector Mask-Register Logical Instructions
	defm VMAND_M : VALU_MV_Mask<"vmand", 0b011001, "m">;			defm VMAND_M : VALU_MV_Mask<"vmand", 0b011001, "m">;
	defm VMNAND_M : VALU_MV_Mask<"vmnand", 0b011101, "m">;			defm VMNAND_M : VALU_MV_Mask<"vmnand", 0b011101, "m">;
	defm VMANDNOT_M : VALU_MV_Mask<"vmandnot", 0b011000, "m">;			defm VMANDNOT_M : VALU_MV_Mask<"vmandnot", 0b011000, "m">;
	defm VMXOR_M : VALU_MV_Mask<"vmxor", 0b011011, "m">;			defm VMXOR_M : VALU_MV_Mask<"vmxor", 0b011011, "m">;
	defm VMOR_M : VALU_MV_Mask<"vmor", 0b011010, "m">;			defm VMOR_M : VALU_MV_Mask<"vmor", 0b011010, "m">;
	defm VMNOR_M : VALU_MV_Mask<"vmnor", 0b011110, "m">;			defm VMNOR_M : VALU_MV_Mask<"vmnor", 0b011110, "m">;
	defm VMORNOT_M : VALU_MV_Mask<"vmornot", 0b011100, "m">;			defm VMORNOT_M : VALU_MV_Mask<"vmornot", 0b011100, "m">;
	▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
	let vm = 1 in {			let vm = 1 in {
	def VMV_X_S : RVInstV<0b010000, 0b00000, OPMVV, (outs GPR:$vd),			def VMV_X_S : RVInstV<0b010000, 0b00000, OPMVV, (outs GPR:$vd),
	(ins VR:$vs2), "vmv.x.s", "$vd, $vs2">;			(ins VR:$vs2), "vmv.x.s", "$vd, $vs2">;
	def VMV_S_X : RVInstV2<0b010000, 0b00000, OPMVX, (outs VR:$vd),			def VMV_S_X : RVInstV2<0b010000, 0b00000, OPMVX, (outs VR:$vd),
	(ins GPR:$rs1), "vmv.s.x", "$vd, $rs1">;			(ins GPR:$rs1), "vmv.s.x", "$vd, $rs1">;

	}			}
	} // hasSideEffects = 0, mayLoad = 0, mayStore = 0			} // hasSideEffects = 0, mayLoad = 0, mayStore = 0
				} // Predicates = [HasStdExtV]

				let Predicates = [HasStdExtVAndF] in {
	let hasSideEffects = 0, mayLoad = 0, mayStore = 0, vm = 1 in {			let hasSideEffects = 0, mayLoad = 0, mayStore = 0, vm = 1 in {
	// Floating-Point Scalar Move Instructions			// Floating-Point Scalar Move Instructions
	def VFMV_F_S : RVInstV<0b010000, 0b00000, OPFVV, (outs FPR32:$vd),			def VFMV_F_S : RVInstV<0b010000, 0b00000, OPFVV, (outs FPR32:$vd),
	(ins VR:$vs2), "vfmv.f.s", "$vd, $vs2">;			(ins VR:$vs2), "vfmv.f.s", "$vd, $vs2">;
	def VFMV_S_F : RVInstV2<0b010000, 0b00000, OPFVF, (outs VR:$vd),			def VFMV_S_F : RVInstV2<0b010000, 0b00000, OPFVF, (outs VR:$vd),
	(ins FPR32:$rs1), "vfmv.s.f", "$vd, $rs1">;			(ins FPR32:$rs1), "vfmv.s.f", "$vd, $rs1">;

	} // hasSideEffects = 0, mayLoad = 0, mayStore = 0, vm = 1			} // hasSideEffects = 0, mayLoad = 0, mayStore = 0, vm = 1
				} // Predicates = [HasStdExtVAndF]

				let Predicates = [HasStdExtV] in {
	// Vector Slide Instructions			// Vector Slide Instructions
	let Constraints = "@earlyclobber $vd", RVVConstraint = SlideUp in {			let Constraints = "@earlyclobber $vd", RVVConstraint = SlideUp in {
	defm VSLIDEUP_V : VALU_IV_X_I<"vslideup", 0b001110, uimm5>;			defm VSLIDEUP_V : VALU_IV_X_I<"vslideup", 0b001110, uimm5>;
	} // Constraints = "@earlyclobber $vd", RVVConstraint = SlideUp			} // Constraints = "@earlyclobber $vd", RVVConstraint = SlideUp
	defm VSLIDEDOWN_V : VALU_IV_X_I<"vslidedown", 0b001111, uimm5>;			defm VSLIDEDOWN_V : VALU_IV_X_I<"vslidedown", 0b001111, uimm5>;

	let Constraints = "@earlyclobber $vd", RVVConstraint = SlideUp in {			let Constraints = "@earlyclobber $vd", RVVConstraint = SlideUp in {
	defm VSLIDE1UP_V : VALU_MV_X<"vslide1up", 0b001110>;			defm VSLIDE1UP_V : VALU_MV_X<"vslide1up", 0b001110>;
	defm VFSLIDE1UP_V : VALU_FV_F<"vfslide1up", 0b001110>;
	} // Constraints = "@earlyclobber $vd", RVVConstraint = SlideUp			} // Constraints = "@earlyclobber $vd", RVVConstraint = SlideUp
	defm VSLIDE1DOWN_V : VALU_MV_X<"vslide1down", 0b001111>;			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>;			defm VFSLIDE1DOWN_V : VALU_FV_F<"vfslide1down", 0b001111>;
				} // Predicates = [HasStdExtVAndF]

				let Predicates = [HasStdExtV] in {
	// Vector Register Gather Instruction			// Vector Register Gather Instruction
	let Constraints = "@earlyclobber $vd", RVVConstraint = Vrgather in {			let Constraints = "@earlyclobber $vd", RVVConstraint = Vrgather in {
	defm VRGATHER_V : VALU_IV_V_X_I<"vrgather", 0b001100, uimm5>;			defm VRGATHER_V : VALU_IV_V_X_I<"vrgather", 0b001100, uimm5>;
	} // Constraints = "@earlyclobber $vd", RVVConstraint = Vrgather			} // Constraints = "@earlyclobber $vd", RVVConstraint = Vrgather

	// Vector Compress Instruction			// Vector Compress Instruction
	let Constraints = "@earlyclobber $vd", RVVConstraint = Vcompress in {			let Constraints = "@earlyclobber $vd", RVVConstraint = Vcompress in {
	defm VCOMPRESS_V : VALU_MV_Mask<"vcompress", 0b010111>;			defm VCOMPRESS_V : VALU_MV_Mask<"vcompress", 0b010111>;
	▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

llvm/lib/Target/RISCV/RISCVSchedRocket.td

	Show All 10 Lines
	// This works with MachineScheduler. See MCSchedule.h for details.			// This works with MachineScheduler. See MCSchedule.h for details.

	// Rocket machine model for scheduling and other instruction cost heuristics.			// Rocket machine model for scheduling and other instruction cost heuristics.
	def RocketModel : SchedMachineModel {			def RocketModel : SchedMachineModel {
	let MicroOpBufferSize = 0; // Rocket is in-order.			let MicroOpBufferSize = 0; // Rocket is in-order.
	let IssueWidth = 1; // 1 micro-op is dispatched per cycle.			let IssueWidth = 1; // 1 micro-op is dispatched per cycle.
	let LoadLatency = 3;			let LoadLatency = 3;
	let MispredictPenalty = 3;			let MispredictPenalty = 3;
	let UnsupportedFeatures = [HasStdExtV, HasStdExtZvamo, HasStdExtZvlsseg];			let UnsupportedFeatures = [HasStdExtV, HasStdExtVAndF, HasStdExtZvamo,
				HasStdExtZvlsseg];
	}			}

	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//
	// Define each kind of processor resource and number available.			// Define each kind of processor resource and number available.

	// Modeling each pipeline as a ProcResource using the BufferSize = 0 since			// Modeling each pipeline as a ProcResource using the BufferSize = 0 since
	// Rocket is in-order.			// Rocket is in-order.

	▲ Show 20 Lines • Show All 206 Lines • Show Last 20 Lines

llvm/lib/Target/RISCV/RISCVSchedSiFive7.td

	Show All 9 Lines

	// SiFive7 machine model for scheduling and other instruction cost heuristics.			// SiFive7 machine model for scheduling and other instruction cost heuristics.
	def SiFive7Model : SchedMachineModel {			def SiFive7Model : SchedMachineModel {
	let MicroOpBufferSize = 0; // Explicitly set to zero since SiFive7 is in-order.			let MicroOpBufferSize = 0; // Explicitly set to zero since SiFive7 is in-order.
	let IssueWidth = 2; // 2 micro-ops are dispatched per cycle.			let IssueWidth = 2; // 2 micro-ops are dispatched per cycle.
	let LoadLatency = 3;			let LoadLatency = 3;
	let MispredictPenalty = 3;			let MispredictPenalty = 3;
	let CompleteModel = 0;			let CompleteModel = 0;
	let UnsupportedFeatures = [HasStdExtV, HasStdExtZvamo, HasStdExtZvlsseg];			let UnsupportedFeatures = [HasStdExtV, HasStdExtVAndF, HasStdExtZvamo,
				HasStdExtZvlsseg];
	}			}

	// The SiFive7 microarchitecure has two pipelines: A and B.			// The SiFive7 microarchitecure has two pipelines: A and B.
	// Pipe A can handle memory, integer alu and vector operations.			// Pipe A can handle memory, integer alu and vector operations.
	// Pipe B can handle integer alu, control flow, integer multiply and divide,			// Pipe B can handle integer alu, control flow, integer multiply and divide,
	// and floating point computation.			// and floating point computation.
	let SchedModel = SiFive7Model in {			let SchedModel = SiFive7Model in {
	let BufferSize = 0 in {			let BufferSize = 0 in {
	▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

llvm/test/MC/RISCV/rvv/convert.s

	# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST			# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
	# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \			# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
	# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR			# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# 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: \| FileCheck %s --check-prefix=CHECK-INST
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN			# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN

	vfcvt.xu.f.v v8, v4, v0.t			vfcvt.xu.f.v v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 14 40 48 <unknown>

	vfcvt.xu.f.v v8, v4			vfcvt.xu.f.v v8, v4
	# CHECK-INST: vfcvt.xu.f.v v8, v4			# CHECK-INST: vfcvt.xu.f.v v8, v4
	# CHECK-ENCODING: [0x57,0x14,0x40,0x4a]			# 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>			# CHECK-UNKNOWN: 57 14 40 4a <unknown>

	vfcvt.x.f.v v8, v4, v0.t			vfcvt.x.f.v v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 94 40 48 <unknown>

	vfcvt.x.f.v v8, v4			vfcvt.x.f.v v8, v4
	# CHECK-INST: vfcvt.x.f.v v8, v4			# CHECK-INST: vfcvt.x.f.v v8, v4
	# CHECK-ENCODING: [0x57,0x94,0x40,0x4a]			# 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>			# CHECK-UNKNOWN: 57 94 40 4a <unknown>

	vfcvt.f.xu.v v8, v4, v0.t			vfcvt.f.xu.v v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 14 41 48 <unknown>

	vfcvt.f.xu.v v8, v4			vfcvt.f.xu.v v8, v4
	# CHECK-INST: vfcvt.f.xu.v v8, v4			# CHECK-INST: vfcvt.f.xu.v v8, v4
	# CHECK-ENCODING: [0x57,0x14,0x41,0x4a]			# 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>			# CHECK-UNKNOWN: 57 14 41 4a <unknown>

	vfcvt.f.x.v v8, v4, v0.t			vfcvt.f.x.v v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 94 41 48 <unknown>

	vfcvt.f.x.v v8, v4			vfcvt.f.x.v v8, v4
	# CHECK-INST: vfcvt.f.x.v v8, v4			# CHECK-INST: vfcvt.f.x.v v8, v4
	# CHECK-ENCODING: [0x57,0x94,0x41,0x4a]			# 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>			# CHECK-UNKNOWN: 57 94 41 4a <unknown>

	vfcvt.rtz.xu.f.v v8, v4, v0.t			vfcvt.rtz.xu.f.v v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 14 43 48 <unknown>

	vfcvt.rtz.xu.f.v v8, v4			vfcvt.rtz.xu.f.v v8, v4
	# CHECK-INST: vfcvt.rtz.xu.f.v v8, v4			# CHECK-INST: vfcvt.rtz.xu.f.v v8, v4
	# CHECK-ENCODING: [0x57,0x14,0x43,0x4a]			# 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>			# CHECK-UNKNOWN: 57 14 43 4a <unknown>

	vfcvt.rtz.x.f.v v8, v4, v0.t			vfcvt.rtz.x.f.v v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 94 43 48 <unknown>

	vfcvt.rtz.x.f.v v8, v4			vfcvt.rtz.x.f.v v8, v4
	# CHECK-INST: vfcvt.rtz.x.f.v v8, v4			# CHECK-INST: vfcvt.rtz.x.f.v v8, v4
	# CHECK-ENCODING: [0x57,0x94,0x43,0x4a]			# 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>			# CHECK-UNKNOWN: 57 94 43 4a <unknown>

	vfwcvt.xu.f.v v8, v4, v0.t			vfwcvt.xu.f.v v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 14 44 48 <unknown>

	vfwcvt.xu.f.v v8, v4			vfwcvt.xu.f.v v8, v4
	# CHECK-INST: vfwcvt.xu.f.v v8, v4			# CHECK-INST: vfwcvt.xu.f.v v8, v4
	# CHECK-ENCODING: [0x57,0x14,0x44,0x4a]			# 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>			# CHECK-UNKNOWN: 57 14 44 4a <unknown>

	vfwcvt.x.f.v v8, v4, v0.t			vfwcvt.x.f.v v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 94 44 48 <unknown>

	vfwcvt.x.f.v v8, v4			vfwcvt.x.f.v v8, v4
	# CHECK-INST: vfwcvt.x.f.v v8, v4			# CHECK-INST: vfwcvt.x.f.v v8, v4
	# CHECK-ENCODING: [0x57,0x94,0x44,0x4a]			# 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>			# CHECK-UNKNOWN: 57 94 44 4a <unknown>

	vfwcvt.f.xu.v v8, v4, v0.t			vfwcvt.f.xu.v v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 14 45 48 <unknown>

	vfwcvt.f.xu.v v8, v4			vfwcvt.f.xu.v v8, v4
	# CHECK-INST: vfwcvt.f.xu.v v8, v4			# CHECK-INST: vfwcvt.f.xu.v v8, v4
	# CHECK-ENCODING: [0x57,0x14,0x45,0x4a]			# 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>			# CHECK-UNKNOWN: 57 14 45 4a <unknown>

	vfwcvt.f.x.v v8, v4, v0.t			vfwcvt.f.x.v v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 94 45 48 <unknown>

	vfwcvt.f.x.v v8, v4			vfwcvt.f.x.v v8, v4
	# CHECK-INST: vfwcvt.f.x.v v8, v4			# CHECK-INST: vfwcvt.f.x.v v8, v4
	# CHECK-ENCODING: [0x57,0x94,0x45,0x4a]			# 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>			# CHECK-UNKNOWN: 57 94 45 4a <unknown>

	vfwcvt.f.f.v v8, v4, v0.t			vfwcvt.f.f.v v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 14 46 48 <unknown>

	vfwcvt.f.f.v v8, v4			vfwcvt.f.f.v v8, v4
	# CHECK-INST: vfwcvt.f.f.v v8, v4			# CHECK-INST: vfwcvt.f.f.v v8, v4
	# CHECK-ENCODING: [0x57,0x14,0x46,0x4a]			# 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>			# CHECK-UNKNOWN: 57 14 46 4a <unknown>

	vfwcvt.rtz.xu.f.v v8, v4, v0.t			vfwcvt.rtz.xu.f.v v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 14 47 48 <unknown>

	vfwcvt.rtz.xu.f.v v8, v4			vfwcvt.rtz.xu.f.v v8, v4
	# CHECK-INST: vfwcvt.rtz.xu.f.v v8, v4			# CHECK-INST: vfwcvt.rtz.xu.f.v v8, v4
	# CHECK-ENCODING: [0x57,0x14,0x47,0x4a]			# 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>			# CHECK-UNKNOWN: 57 14 47 4a <unknown>

	vfwcvt.rtz.x.f.v v8, v4, v0.t			vfwcvt.rtz.x.f.v v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 94 47 48 <unknown>

	vfwcvt.rtz.x.f.v v8, v4			vfwcvt.rtz.x.f.v v8, v4
	# CHECK-INST: vfwcvt.rtz.x.f.v v8, v4			# CHECK-INST: vfwcvt.rtz.x.f.v v8, v4
	# CHECK-ENCODING: [0x57,0x94,0x47,0x4a]			# 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>			# CHECK-UNKNOWN: 57 94 47 4a <unknown>

	vfncvt.xu.f.w v8, v4, v0.t			vfncvt.xu.f.w v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 14 48 48 <unknown>

	vfncvt.xu.f.w v8, v4			vfncvt.xu.f.w v8, v4
	# CHECK-INST: vfncvt.xu.f.w v8, v4			# CHECK-INST: vfncvt.xu.f.w v8, v4
	# CHECK-ENCODING: [0x57,0x14,0x48,0x4a]			# 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>			# CHECK-UNKNOWN: 57 14 48 4a <unknown>

	vfncvt.x.f.w v8, v4, v0.t			vfncvt.x.f.w v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 94 48 48 <unknown>

	vfncvt.x.f.w v8, v4			vfncvt.x.f.w v8, v4
	# CHECK-INST: vfncvt.x.f.w v8, v4			# CHECK-INST: vfncvt.x.f.w v8, v4
	# CHECK-ENCODING: [0x57,0x94,0x48,0x4a]			# 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>			# CHECK-UNKNOWN: 57 94 48 4a <unknown>

	vfncvt.f.xu.w v8, v4, v0.t			vfncvt.f.xu.w v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 14 49 48 <unknown>

	vfncvt.f.xu.w v8, v4			vfncvt.f.xu.w v8, v4
	# CHECK-INST: vfncvt.f.xu.w v8, v4			# CHECK-INST: vfncvt.f.xu.w v8, v4
	# CHECK-ENCODING: [0x57,0x14,0x49,0x4a]			# 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>			# CHECK-UNKNOWN: 57 14 49 4a <unknown>

	vfncvt.f.x.w v8, v4, v0.t			vfncvt.f.x.w v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 94 49 48 <unknown>

	vfncvt.f.x.w v8, v4			vfncvt.f.x.w v8, v4
	# CHECK-INST: vfncvt.f.x.w v8, v4			# CHECK-INST: vfncvt.f.x.w v8, v4
	# CHECK-ENCODING: [0x57,0x94,0x49,0x4a]			# 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>			# CHECK-UNKNOWN: 57 94 49 4a <unknown>

	vfncvt.f.f.w v8, v4, v0.t			vfncvt.f.f.w v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 14 4a 48 <unknown>

	vfncvt.f.f.w v8, v4			vfncvt.f.f.w v8, v4
	# CHECK-INST: vfncvt.f.f.w v8, v4			# CHECK-INST: vfncvt.f.f.w v8, v4
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x4a]			# 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>			# CHECK-UNKNOWN: 57 14 4a 4a <unknown>

	vfncvt.rod.f.f.w v8, v4, v0.t			vfncvt.rod.f.f.w v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 94 4a 48 <unknown>

	vfncvt.rod.f.f.w v8, v4			vfncvt.rod.f.f.w v8, v4
	# CHECK-INST: vfncvt.rod.f.f.w v8, v4			# CHECK-INST: vfncvt.rod.f.f.w v8, v4
	# CHECK-ENCODING: [0x57,0x94,0x4a,0x4a]			# 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>			# CHECK-UNKNOWN: 57 94 4a 4a <unknown>

	vfncvt.rtz.xu.f.w v8, v4, v0.t			vfncvt.rtz.xu.f.w v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 14 4b 48 <unknown>

	vfncvt.rtz.xu.f.w v8, v4			vfncvt.rtz.xu.f.w v8, v4
	# CHECK-INST: vfncvt.rtz.xu.f.w v8, v4			# CHECK-INST: vfncvt.rtz.xu.f.w v8, v4
	# CHECK-ENCODING: [0x57,0x14,0x4b,0x4a]			# 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>			# CHECK-UNKNOWN: 57 14 4b 4a <unknown>

	vfncvt.rtz.x.f.w v8, v4, v0.t			vfncvt.rtz.x.f.w v8, v4, v0.t
	# CHECK-INST: 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-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>			# CHECK-UNKNOWN: 57 94 4b 48 <unknown>

	vfncvt.rtz.x.f.w v8, v4			vfncvt.rtz.x.f.w v8, v4
	# CHECK-INST: vfncvt.rtz.x.f.w v8, v4			# CHECK-INST: vfncvt.rtz.x.f.w v8, v4
	# CHECK-ENCODING: [0x57,0x94,0x4b,0x4a]			# 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>			# CHECK-UNKNOWN: 57 94 4b 4a <unknown>

llvm/test/MC/RISCV/rvv/fadd.s

	# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST			# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
	# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \			# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
	# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR			# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# 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: \| FileCheck %s --check-prefix=CHECK-INST
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN			# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN

	vfadd.vv v8, v4, v20, v0.t			vfadd.vv v8, v4, v20, v0.t
	# CHECK-INST: vfadd.vv v8, v4, v20, v0.t			# CHECK-INST: vfadd.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x00]			# 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>			# CHECK-UNKNOWN: 57 14 4a 00 <unknown>

	vfadd.vv v8, v4, v20			vfadd.vv v8, v4, v20
	# CHECK-INST: vfadd.vv v8, v4, v20			# CHECK-INST: vfadd.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x02]			# 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>			# CHECK-UNKNOWN: 57 14 4a 02 <unknown>

	vfadd.vf v8, v4, fa0, v0.t			vfadd.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfadd.vf v8, v4, fa0, v0.t			# CHECK-INST: vfadd.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x00]			# 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>			# CHECK-UNKNOWN: 57 54 45 00 <unknown>

	vfadd.vf v8, v4, fa0			vfadd.vf v8, v4, fa0
	# CHECK-INST: vfadd.vf v8, v4, fa0			# CHECK-INST: vfadd.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x02]			# 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>			# CHECK-UNKNOWN: 57 54 45 02 <unknown>

	vfwadd.vv v8, v4, v20, v0.t			vfwadd.vv v8, v4, v20, v0.t
	# CHECK-INST: vfwadd.vv v8, v4, v20, v0.t			# CHECK-INST: vfwadd.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xc0]			# 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>			# CHECK-UNKNOWN: 57 14 4a c0 <unknown>

	vfwadd.vv v8, v4, v20			vfwadd.vv v8, v4, v20
	# CHECK-INST: vfwadd.vv v8, v4, v20			# CHECK-INST: vfwadd.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xc2]			# 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>			# CHECK-UNKNOWN: 57 14 4a c2 <unknown>

	vfwadd.vf v8, v4, fa0, v0.t			vfwadd.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfwadd.vf v8, v4, fa0, v0.t			# CHECK-INST: vfwadd.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xc0]			# 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>			# CHECK-UNKNOWN: 57 54 45 c0 <unknown>

	vfwadd.vf v8, v4, fa0			vfwadd.vf v8, v4, fa0
	# CHECK-INST: vfwadd.vf v8, v4, fa0			# CHECK-INST: vfwadd.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0xc2]			# 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>			# CHECK-UNKNOWN: 57 54 45 c2 <unknown>

	vfwadd.wv v8, v4, v20, v0.t			vfwadd.wv v8, v4, v20, v0.t
	# CHECK-INST: vfwadd.wv v8, v4, v20, v0.t			# CHECK-INST: vfwadd.wv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xd0]			# 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>			# CHECK-UNKNOWN: 57 14 4a d0 <unknown>

	vfwadd.wv v8, v4, v20			vfwadd.wv v8, v4, v20
	# CHECK-INST: vfwadd.wv v8, v4, v20			# CHECK-INST: vfwadd.wv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xd2]			# 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>			# CHECK-UNKNOWN: 57 14 4a d2 <unknown>

	vfwadd.wf v8, v4, fa0, v0.t			vfwadd.wf v8, v4, fa0, v0.t
	# CHECK-INST: vfwadd.wf v8, v4, fa0, v0.t			# CHECK-INST: vfwadd.wf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xd0]			# 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>			# CHECK-UNKNOWN: 57 54 45 d0 <unknown>

	vfwadd.wf v8, v4, fa0			vfwadd.wf v8, v4, fa0
	# CHECK-INST: vfwadd.wf v8, v4, fa0			# CHECK-INST: vfwadd.wf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0xd2]			# 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>			# CHECK-UNKNOWN: 57 54 45 d2 <unknown>

llvm/test/MC/RISCV/rvv/fcompare.s

	# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST			# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
	# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \			# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
	# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR			# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# 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: \| FileCheck %s --check-prefix=CHECK-INST
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN			# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN

	vmfeq.vv v8, v4, v20, v0.t			vmfeq.vv v8, v4, v20, v0.t
	# CHECK-INST: vmfeq.vv v8, v4, v20, v0.t			# CHECK-INST: vmfeq.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x60]			# 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>			# CHECK-UNKNOWN: 57 14 4a 60 <unknown>

	vmfeq.vv v8, v4, v20			vmfeq.vv v8, v4, v20
	# CHECK-INST: vmfeq.vv v8, v4, v20			# CHECK-INST: vmfeq.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x62]			# 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>			# CHECK-UNKNOWN: 57 14 4a 62 <unknown>

	vmfeq.vf v8, v4, fa0, v0.t			vmfeq.vf v8, v4, fa0, v0.t
	# CHECK-INST: vmfeq.vf v8, v4, fa0, v0.t			# CHECK-INST: vmfeq.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x60]			# 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>			# CHECK-UNKNOWN: 57 54 45 60 <unknown>

	vmfeq.vf v8, v4, fa0			vmfeq.vf v8, v4, fa0
	# CHECK-INST: vmfeq.vf v8, v4, fa0			# CHECK-INST: vmfeq.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x62]			# 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>			# CHECK-UNKNOWN: 57 54 45 62 <unknown>

	vmfne.vv v8, v4, v20, v0.t			vmfne.vv v8, v4, v20, v0.t
	# CHECK-INST: vmfne.vv v8, v4, v20, v0.t			# CHECK-INST: vmfne.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x70]			# 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>			# CHECK-UNKNOWN: 57 14 4a 70 <unknown>

	vmfne.vv v8, v4, v20			vmfne.vv v8, v4, v20
	# CHECK-INST: vmfne.vv v8, v4, v20			# CHECK-INST: vmfne.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x72]			# 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>			# CHECK-UNKNOWN: 57 14 4a 72 <unknown>

	vmfne.vf v8, v4, fa0, v0.t			vmfne.vf v8, v4, fa0, v0.t
	# CHECK-INST: vmfne.vf v8, v4, fa0, v0.t			# CHECK-INST: vmfne.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x70]			# 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>			# CHECK-UNKNOWN: 57 54 45 70 <unknown>

	vmfne.vf v8, v4, fa0			vmfne.vf v8, v4, fa0
	# CHECK-INST: vmfne.vf v8, v4, fa0			# CHECK-INST: vmfne.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x72]			# 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>			# CHECK-UNKNOWN: 57 54 45 72 <unknown>

	vmflt.vv v8, v4, v20, v0.t			vmflt.vv v8, v4, v20, v0.t
	# CHECK-INST: vmflt.vv v8, v4, v20, v0.t			# CHECK-INST: vmflt.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x6c]			# 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>			# CHECK-UNKNOWN: 57 14 4a 6c <unknown>

	vmflt.vv v8, v4, v20			vmflt.vv v8, v4, v20
	# CHECK-INST: vmflt.vv v8, v4, v20			# CHECK-INST: vmflt.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x6e]			# 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>			# CHECK-UNKNOWN: 57 14 4a 6e <unknown>

	vmflt.vf v8, v4, fa0, v0.t			vmflt.vf v8, v4, fa0, v0.t
	# CHECK-INST: vmflt.vf v8, v4, fa0, v0.t			# CHECK-INST: vmflt.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x6c]			# 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>			# CHECK-UNKNOWN: 57 54 45 6c <unknown>

	vmflt.vf v8, v4, fa0			vmflt.vf v8, v4, fa0
	# CHECK-INST: vmflt.vf v8, v4, fa0			# CHECK-INST: vmflt.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x6e]			# 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>			# CHECK-UNKNOWN: 57 54 45 6e <unknown>

	vmfle.vv v8, v4, v20, v0.t			vmfle.vv v8, v4, v20, v0.t
	# CHECK-INST: vmfle.vv v8, v4, v20, v0.t			# CHECK-INST: vmfle.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x64]			# 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>			# CHECK-UNKNOWN: 57 14 4a 64 <unknown>

	vmfle.vv v8, v4, v20			vmfle.vv v8, v4, v20
	# CHECK-INST: vmfle.vv v8, v4, v20			# CHECK-INST: vmfle.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x66]			# 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>			# CHECK-UNKNOWN: 57 14 4a 66 <unknown>

	vmfle.vf v8, v4, fa0, v0.t			vmfle.vf v8, v4, fa0, v0.t
	# CHECK-INST: vmfle.vf v8, v4, fa0, v0.t			# CHECK-INST: vmfle.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x64]			# 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>			# CHECK-UNKNOWN: 57 54 45 64 <unknown>

	vmfle.vf v8, v4, fa0			vmfle.vf v8, v4, fa0
	# CHECK-INST: vmfle.vf v8, v4, fa0			# CHECK-INST: vmfle.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x66]			# 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>			# CHECK-UNKNOWN: 57 54 45 66 <unknown>

	vmfgt.vf v8, v4, fa0, v0.t			vmfgt.vf v8, v4, fa0, v0.t
	# CHECK-INST: vmfgt.vf v8, v4, fa0, v0.t			# CHECK-INST: vmfgt.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x74]			# 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>			# CHECK-UNKNOWN: 57 54 45 74 <unknown>

	vmfgt.vf v8, v4, fa0			vmfgt.vf v8, v4, fa0
	# CHECK-INST: vmfgt.vf v8, v4, fa0			# CHECK-INST: vmfgt.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x76]			# 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>			# CHECK-UNKNOWN: 57 54 45 76 <unknown>

	vmfge.vf v8, v4, fa0, v0.t			vmfge.vf v8, v4, fa0, v0.t
	# CHECK-INST: vmfge.vf v8, v4, fa0, v0.t			# CHECK-INST: vmfge.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x7c]			# 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>			# CHECK-UNKNOWN: 57 54 45 7c <unknown>

	vmfge.vf v8, v4, fa0			vmfge.vf v8, v4, fa0
	# CHECK-INST: vmfge.vf v8, v4, fa0			# CHECK-INST: vmfge.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x7e]			# 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>			# CHECK-UNKNOWN: 57 54 45 7e <unknown>

	vmfgt.vv v8, v20, v4, v0.t			vmfgt.vv v8, v20, v4, v0.t
	# CHECK-INST: vmflt.vv v8, v4, v20, v0.t			# CHECK-INST: vmflt.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x6c]			# 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>			# CHECK-UNKNOWN: 57 14 4a 6c <unknown>

	vmfgt.vv v8, v20, v4			vmfgt.vv v8, v20, v4
	# CHECK-INST: vmflt.vv v8, v4, v20			# CHECK-INST: vmflt.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x6e]			# 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>			# CHECK-UNKNOWN: 57 14 4a 6e <unknown>

	vmfge.vv v8, v20, v4, v0.t			vmfge.vv v8, v20, v4, v0.t
	# CHECK-INST: vmfle.vv v8, v4, v20, v0.t			# CHECK-INST: vmfle.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x64]			# 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>			# CHECK-UNKNOWN: 57 14 4a 64 <unknown>

	vmfge.vv v8, v20, v4			vmfge.vv v8, v20, v4
	# CHECK-INST: vmfle.vv v8, v4, v20			# CHECK-INST: vmfle.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x66]			# 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>			# CHECK-UNKNOWN: 57 14 4a 66 <unknown>

	vmfeq.vv v0, v4, v20, v0.t			vmfeq.vv v0, v4, v20, v0.t
	# CHECK-INST: vmfeq.vv v0, v4, v20, v0.t			# CHECK-INST: vmfeq.vv v0, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x10,0x4a,0x60]			# 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>			# CHECK-UNKNOWN: 57 10 4a 60 <unknown>

llvm/test/MC/RISCV/rvv/fdiv.s

	# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST			# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
	# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \			# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
	# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR			# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# 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: \| FileCheck %s --check-prefix=CHECK-INST
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN			# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN

	vfdiv.vv v8, v4, v20, v0.t			vfdiv.vv v8, v4, v20, v0.t
	# CHECK-INST: vfdiv.vv v8, v4, v20, v0.t			# CHECK-INST: vfdiv.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x80]			# 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>			# CHECK-UNKNOWN: 57 14 4a 80 <unknown>

	vfdiv.vv v8, v4, v20			vfdiv.vv v8, v4, v20
	# CHECK-INST: vfdiv.vv v8, v4, v20			# CHECK-INST: vfdiv.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x82]			# 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>			# CHECK-UNKNOWN: 57 14 4a 82 <unknown>

	vfdiv.vf v8, v4, fa0, v0.t			vfdiv.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfdiv.vf v8, v4, fa0, v0.t			# CHECK-INST: vfdiv.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x80]			# 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>			# CHECK-UNKNOWN: 57 54 45 80 <unknown>

	vfdiv.vf v8, v4, fa0			vfdiv.vf v8, v4, fa0
	# CHECK-INST: vfdiv.vf v8, v4, fa0			# CHECK-INST: vfdiv.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x82]			# 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>			# CHECK-UNKNOWN: 57 54 45 82 <unknown>

	vfrdiv.vf v8, v4, fa0, v0.t			vfrdiv.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfrdiv.vf v8, v4, fa0, v0.t			# CHECK-INST: vfrdiv.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x84]			# 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>			# CHECK-UNKNOWN: 57 54 45 84 <unknown>

	vfrdiv.vf v8, v4, fa0			vfrdiv.vf v8, v4, fa0
	# CHECK-INST: vfrdiv.vf v8, v4, fa0			# CHECK-INST: vfrdiv.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x86]			# 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>			# CHECK-UNKNOWN: 57 54 45 86 <unknown>

llvm/test/MC/RISCV/rvv/fmacc.s

	# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST			# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
	# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \			# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
	# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR			# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# 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: \| FileCheck %s --check-prefix=CHECK-INST
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN			# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN

	vfmacc.vv v8, v20, v4, v0.t			vfmacc.vv v8, v20, v4, v0.t
	# CHECK-INST: vfmacc.vv v8, v20, v4, v0.t			# CHECK-INST: vfmacc.vv v8, v20, v4, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xb0]			# 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>			# CHECK-UNKNOWN: 57 14 4a b0 <unknown>

	vfmacc.vv v8, v20, v4			vfmacc.vv v8, v20, v4
	# CHECK-INST: vfmacc.vv v8, v20, v4			# CHECK-INST: vfmacc.vv v8, v20, v4
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xb2]			# 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>			# CHECK-UNKNOWN: 57 14 4a b2 <unknown>

	vfmacc.vf v8, fa0, v4, v0.t			vfmacc.vf v8, fa0, v4, v0.t
	# CHECK-INST: vfmacc.vf v8, fa0, v4, v0.t			# CHECK-INST: vfmacc.vf v8, fa0, v4, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xb0]			# 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>			# CHECK-UNKNOWN: 57 54 45 b0 <unknown>

	vfmacc.vf v8, fa0, v4			vfmacc.vf v8, fa0, v4
	# CHECK-INST: vfmacc.vf v8, fa0, v4			# CHECK-INST: vfmacc.vf v8, fa0, v4
	# CHECK-ENCODING: [0x57,0x54,0x45,0xb2]			# 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>			# CHECK-UNKNOWN: 57 54 45 b2 <unknown>

	vfnmacc.vv v8, v20, v4, v0.t			vfnmacc.vv v8, v20, v4, v0.t
	# CHECK-INST: vfnmacc.vv v8, v20, v4, v0.t			# CHECK-INST: vfnmacc.vv v8, v20, v4, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xb4]			# 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>			# CHECK-UNKNOWN: 57 14 4a b4 <unknown>

	vfnmacc.vv v8, v20, v4			vfnmacc.vv v8, v20, v4
	# CHECK-INST: vfnmacc.vv v8, v20, v4			# CHECK-INST: vfnmacc.vv v8, v20, v4
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xb6]			# 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>			# CHECK-UNKNOWN: 57 14 4a b6 <unknown>

	vfnmacc.vf v8, fa0, v4, v0.t			vfnmacc.vf v8, fa0, v4, v0.t
	# CHECK-INST: vfnmacc.vf v8, fa0, v4, v0.t			# CHECK-INST: vfnmacc.vf v8, fa0, v4, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xb4]			# 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>			# CHECK-UNKNOWN: 57 54 45 b4 <unknown>

	vfnmacc.vf v8, fa0, v4			vfnmacc.vf v8, fa0, v4
	# CHECK-INST: vfnmacc.vf v8, fa0, v4			# CHECK-INST: vfnmacc.vf v8, fa0, v4
	# CHECK-ENCODING: [0x57,0x54,0x45,0xb6]			# 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>			# CHECK-UNKNOWN: 57 54 45 b6 <unknown>

	vfmsac.vv v8, v20, v4, v0.t			vfmsac.vv v8, v20, v4, v0.t
	# CHECK-INST: vfmsac.vv v8, v20, v4, v0.t			# CHECK-INST: vfmsac.vv v8, v20, v4, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xb8]			# 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>			# CHECK-UNKNOWN: 57 14 4a b8 <unknown>

	vfmsac.vv v8, v20, v4			vfmsac.vv v8, v20, v4
	# CHECK-INST: vfmsac.vv v8, v20, v4			# CHECK-INST: vfmsac.vv v8, v20, v4
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xba]			# 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>			# CHECK-UNKNOWN: 57 14 4a ba <unknown>

	vfmsac.vf v8, fa0, v4, v0.t			vfmsac.vf v8, fa0, v4, v0.t
	# CHECK-INST: vfmsac.vf v8, fa0, v4, v0.t			# CHECK-INST: vfmsac.vf v8, fa0, v4, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xb8]			# 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>			# CHECK-UNKNOWN: 57 54 45 b8 <unknown>

	vfmsac.vf v8, fa0, v4			vfmsac.vf v8, fa0, v4
	# CHECK-INST: vfmsac.vf v8, fa0, v4			# CHECK-INST: vfmsac.vf v8, fa0, v4
	# CHECK-ENCODING: [0x57,0x54,0x45,0xba]			# 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>			# CHECK-UNKNOWN: 57 54 45 ba <unknown>

	vfnmsac.vv v8, v20, v4, v0.t			vfnmsac.vv v8, v20, v4, v0.t
	# CHECK-INST: vfnmsac.vv v8, v20, v4, v0.t			# CHECK-INST: vfnmsac.vv v8, v20, v4, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xbc]			# 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>			# CHECK-UNKNOWN: 57 14 4a bc <unknown>

	vfnmsac.vv v8, v20, v4			vfnmsac.vv v8, v20, v4
	# CHECK-INST: vfnmsac.vv v8, v20, v4			# CHECK-INST: vfnmsac.vv v8, v20, v4
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xbe]			# 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>			# CHECK-UNKNOWN: 57 14 4a be <unknown>

	vfnmsac.vf v8, fa0, v4, v0.t			vfnmsac.vf v8, fa0, v4, v0.t
	# CHECK-INST: vfnmsac.vf v8, fa0, v4, v0.t			# CHECK-INST: vfnmsac.vf v8, fa0, v4, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xbc]			# 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>			# CHECK-UNKNOWN: 57 54 45 bc <unknown>

	vfnmsac.vf v8, fa0, v4			vfnmsac.vf v8, fa0, v4
	# CHECK-INST: vfnmsac.vf v8, fa0, v4			# CHECK-INST: vfnmsac.vf v8, fa0, v4
	# CHECK-ENCODING: [0x57,0x54,0x45,0xbe]			# 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>			# CHECK-UNKNOWN: 57 54 45 be <unknown>

	vfmadd.vv v8, v20, v4, v0.t			vfmadd.vv v8, v20, v4, v0.t
	# CHECK-INST: vfmadd.vv v8, v20, v4, v0.t			# CHECK-INST: vfmadd.vv v8, v20, v4, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xa0]			# 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>			# CHECK-UNKNOWN: 57 14 4a a0 <unknown>

	vfmadd.vv v8, v20, v4			vfmadd.vv v8, v20, v4
	# CHECK-INST: vfmadd.vv v8, v20, v4			# CHECK-INST: vfmadd.vv v8, v20, v4
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xa2]			# 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>			# CHECK-UNKNOWN: 57 14 4a a2 <unknown>

	vfmadd.vf v8, fa0, v4, v0.t			vfmadd.vf v8, fa0, v4, v0.t
	# CHECK-INST: vfmadd.vf v8, fa0, v4, v0.t			# CHECK-INST: vfmadd.vf v8, fa0, v4, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xa0]			# 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>			# CHECK-UNKNOWN: 57 54 45 a0 <unknown>

	vfmadd.vf v8, fa0, v4			vfmadd.vf v8, fa0, v4
	# CHECK-INST: vfmadd.vf v8, fa0, v4			# CHECK-INST: vfmadd.vf v8, fa0, v4
	# CHECK-ENCODING: [0x57,0x54,0x45,0xa2]			# 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>			# CHECK-UNKNOWN: 57 54 45 a2 <unknown>

	vfnmadd.vv v8, v20, v4, v0.t			vfnmadd.vv v8, v20, v4, v0.t
	# CHECK-INST: vfnmadd.vv v8, v20, v4, v0.t			# CHECK-INST: vfnmadd.vv v8, v20, v4, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xa4]			# 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>			# CHECK-UNKNOWN: 57 14 4a a4 <unknown>

	vfnmadd.vv v8, v20, v4			vfnmadd.vv v8, v20, v4
	# CHECK-INST: vfnmadd.vv v8, v20, v4			# CHECK-INST: vfnmadd.vv v8, v20, v4
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xa6]			# 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>			# CHECK-UNKNOWN: 57 14 4a a6 <unknown>

	vfnmadd.vf v8, fa0, v4, v0.t			vfnmadd.vf v8, fa0, v4, v0.t
	# CHECK-INST: vfnmadd.vf v8, fa0, v4, v0.t			# CHECK-INST: vfnmadd.vf v8, fa0, v4, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xa4]			# 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>			# CHECK-UNKNOWN: 57 54 45 a4 <unknown>

	vfnmadd.vf v8, fa0, v4			vfnmadd.vf v8, fa0, v4
	# CHECK-INST: vfnmadd.vf v8, fa0, v4			# CHECK-INST: vfnmadd.vf v8, fa0, v4
	# CHECK-ENCODING: [0x57,0x54,0x45,0xa6]			# 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>			# CHECK-UNKNOWN: 57 54 45 a6 <unknown>

	vfmsub.vv v8, v20, v4, v0.t			vfmsub.vv v8, v20, v4, v0.t
	# CHECK-INST: vfmsub.vv v8, v20, v4, v0.t			# CHECK-INST: vfmsub.vv v8, v20, v4, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xa8]			# 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>			# CHECK-UNKNOWN: 57 14 4a a8 <unknown>

	vfmsub.vv v8, v20, v4			vfmsub.vv v8, v20, v4
	# CHECK-INST: vfmsub.vv v8, v20, v4			# CHECK-INST: vfmsub.vv v8, v20, v4
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xaa]			# 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>			# CHECK-UNKNOWN: 57 14 4a aa <unknown>

	vfmsub.vf v8, fa0, v4, v0.t			vfmsub.vf v8, fa0, v4, v0.t
	# CHECK-INST: vfmsub.vf v8, fa0, v4, v0.t			# CHECK-INST: vfmsub.vf v8, fa0, v4, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xa8]			# 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>			# CHECK-UNKNOWN: 57 54 45 a8 <unknown>

	vfmsub.vf v8, fa0, v4			vfmsub.vf v8, fa0, v4
	# CHECK-INST: vfmsub.vf v8, fa0, v4			# CHECK-INST: vfmsub.vf v8, fa0, v4
	# CHECK-ENCODING: [0x57,0x54,0x45,0xaa]			# 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>			# CHECK-UNKNOWN: 57 54 45 aa <unknown>

	vfnmsub.vv v8, v20, v4, v0.t			vfnmsub.vv v8, v20, v4, v0.t
	# CHECK-INST: vfnmsub.vv v8, v20, v4, v0.t			# CHECK-INST: vfnmsub.vv v8, v20, v4, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xac]			# 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>			# CHECK-UNKNOWN: 57 14 4a ac <unknown>

	vfnmsub.vv v8, v20, v4			vfnmsub.vv v8, v20, v4
	# CHECK-INST: vfnmsub.vv v8, v20, v4			# CHECK-INST: vfnmsub.vv v8, v20, v4
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xae]			# 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>			# CHECK-UNKNOWN: 57 14 4a ae <unknown>

	vfnmsub.vf v8, fa0, v4, v0.t			vfnmsub.vf v8, fa0, v4, v0.t
	# CHECK-INST: vfnmsub.vf v8, fa0, v4, v0.t			# CHECK-INST: vfnmsub.vf v8, fa0, v4, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xac]			# 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>			# CHECK-UNKNOWN: 57 54 45 ac <unknown>

	vfnmsub.vf v8, fa0, v4			vfnmsub.vf v8, fa0, v4
	# CHECK-INST: vfnmsub.vf v8, fa0, v4			# CHECK-INST: vfnmsub.vf v8, fa0, v4
	# CHECK-ENCODING: [0x57,0x54,0x45,0xae]			# 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>			# CHECK-UNKNOWN: 57 54 45 ae <unknown>

	vfwmacc.vv v8, v20, v4, v0.t			vfwmacc.vv v8, v20, v4, v0.t
	# CHECK-INST: vfwmacc.vv v8, v20, v4, v0.t			# CHECK-INST: vfwmacc.vv v8, v20, v4, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xf0]			# 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>			# CHECK-UNKNOWN: 57 14 4a f0 <unknown>

	vfwmacc.vv v8, v20, v4			vfwmacc.vv v8, v20, v4
	# CHECK-INST: vfwmacc.vv v8, v20, v4			# CHECK-INST: vfwmacc.vv v8, v20, v4
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xf2]			# 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>			# CHECK-UNKNOWN: 57 14 4a f2 <unknown>

	vfwmacc.vf v8, fa0, v4, v0.t			vfwmacc.vf v8, fa0, v4, v0.t
	# CHECK-INST: vfwmacc.vf v8, fa0, v4, v0.t			# CHECK-INST: vfwmacc.vf v8, fa0, v4, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xf0]			# 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>			# CHECK-UNKNOWN: 57 54 45 f0 <unknown>

	vfwmacc.vf v8, fa0, v4			vfwmacc.vf v8, fa0, v4
	# CHECK-INST: vfwmacc.vf v8, fa0, v4			# CHECK-INST: vfwmacc.vf v8, fa0, v4
	# CHECK-ENCODING: [0x57,0x54,0x45,0xf2]			# 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>			# CHECK-UNKNOWN: 57 54 45 f2 <unknown>

	vfwnmacc.vv v8, v20, v4, v0.t			vfwnmacc.vv v8, v20, v4, v0.t
	# CHECK-INST: vfwnmacc.vv v8, v20, v4, v0.t			# CHECK-INST: vfwnmacc.vv v8, v20, v4, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xf4]			# 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>			# CHECK-UNKNOWN: 57 14 4a f4 <unknown>

	vfwnmacc.vv v8, v20, v4			vfwnmacc.vv v8, v20, v4
	# CHECK-INST: vfwnmacc.vv v8, v20, v4			# CHECK-INST: vfwnmacc.vv v8, v20, v4
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xf6]			# 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>			# CHECK-UNKNOWN: 57 14 4a f6 <unknown>

	vfwnmacc.vf v8, fa0, v4, v0.t			vfwnmacc.vf v8, fa0, v4, v0.t
	# CHECK-INST: vfwnmacc.vf v8, fa0, v4, v0.t			# CHECK-INST: vfwnmacc.vf v8, fa0, v4, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xf4]			# 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>			# CHECK-UNKNOWN: 57 54 45 f4 <unknown>

	vfwnmacc.vf v8, fa0, v4			vfwnmacc.vf v8, fa0, v4
	# CHECK-INST: vfwnmacc.vf v8, fa0, v4			# CHECK-INST: vfwnmacc.vf v8, fa0, v4
	# CHECK-ENCODING: [0x57,0x54,0x45,0xf6]			# 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>			# CHECK-UNKNOWN: 57 54 45 f6 <unknown>

	vfwmsac.vv v8, v20, v4, v0.t			vfwmsac.vv v8, v20, v4, v0.t
	# CHECK-INST: vfwmsac.vv v8, v20, v4, v0.t			# CHECK-INST: vfwmsac.vv v8, v20, v4, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xf8]			# 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>			# CHECK-UNKNOWN: 57 14 4a f8 <unknown>

	vfwmsac.vv v8, v20, v4			vfwmsac.vv v8, v20, v4
	# CHECK-INST: vfwmsac.vv v8, v20, v4			# CHECK-INST: vfwmsac.vv v8, v20, v4
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xfa]			# 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>			# CHECK-UNKNOWN: 57 14 4a fa <unknown>

	vfwmsac.vf v8, fa0, v4, v0.t			vfwmsac.vf v8, fa0, v4, v0.t
	# CHECK-INST: vfwmsac.vf v8, fa0, v4, v0.t			# CHECK-INST: vfwmsac.vf v8, fa0, v4, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xf8]			# 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>			# CHECK-UNKNOWN: 57 54 45 f8 <unknown>

	vfwmsac.vf v8, fa0, v4			vfwmsac.vf v8, fa0, v4
	# CHECK-INST: vfwmsac.vf v8, fa0, v4			# CHECK-INST: vfwmsac.vf v8, fa0, v4
	# CHECK-ENCODING: [0x57,0x54,0x45,0xfa]			# 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>			# CHECK-UNKNOWN: 57 54 45 fa <unknown>

	vfwnmsac.vv v8, v20, v4, v0.t			vfwnmsac.vv v8, v20, v4, v0.t
	# CHECK-INST: vfwnmsac.vv v8, v20, v4, v0.t			# CHECK-INST: vfwnmsac.vv v8, v20, v4, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xfc]			# 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>			# CHECK-UNKNOWN: 57 14 4a fc <unknown>

	vfwnmsac.vv v8, v20, v4			vfwnmsac.vv v8, v20, v4
	# CHECK-INST: vfwnmsac.vv v8, v20, v4			# CHECK-INST: vfwnmsac.vv v8, v20, v4
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xfe]			# 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>			# CHECK-UNKNOWN: 57 14 4a fe <unknown>

	vfwnmsac.vf v8, fa0, v4, v0.t			vfwnmsac.vf v8, fa0, v4, v0.t
	# CHECK-INST: vfwnmsac.vf v8, fa0, v4, v0.t			# CHECK-INST: vfwnmsac.vf v8, fa0, v4, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xfc]			# 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>			# CHECK-UNKNOWN: 57 54 45 fc <unknown>

	vfwnmsac.vf v8, fa0, v4			vfwnmsac.vf v8, fa0, v4
	# CHECK-INST: vfwnmsac.vf v8, fa0, v4			# CHECK-INST: vfwnmsac.vf v8, fa0, v4
	# CHECK-ENCODING: [0x57,0x54,0x45,0xfe]			# 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>			# CHECK-UNKNOWN: 57 54 45 fe <unknown>

llvm/test/MC/RISCV/rvv/fminmax.s

	# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST			# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
	# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \			# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
	# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR			# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# 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: \| FileCheck %s --check-prefix=CHECK-INST
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN			# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN

	vfmin.vv v8, v4, v20, v0.t			vfmin.vv v8, v4, v20, v0.t
	# CHECK-INST: vfmin.vv v8, v4, v20, v0.t			# CHECK-INST: vfmin.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x10]			# 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>			# CHECK-UNKNOWN: 57 14 4a 10 <unknown>

	vfmin.vv v8, v4, v20			vfmin.vv v8, v4, v20
	# CHECK-INST: vfmin.vv v8, v4, v20			# CHECK-INST: vfmin.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x12]			# 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>			# CHECK-UNKNOWN: 57 14 4a 12 <unknown>

	vfmin.vf v8, v4, fa0, v0.t			vfmin.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfmin.vf v8, v4, fa0, v0.t			# CHECK-INST: vfmin.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x10]			# 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>			# CHECK-UNKNOWN: 57 54 45 10 <unknown>

	vfmin.vf v8, v4, fa0			vfmin.vf v8, v4, fa0
	# CHECK-INST: vfmin.vf v8, v4, fa0			# CHECK-INST: vfmin.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x12]			# 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>			# CHECK-UNKNOWN: 57 54 45 12 <unknown>

	vfmax.vv v8, v4, v20, v0.t			vfmax.vv v8, v4, v20, v0.t
	# CHECK-INST: vfmax.vv v8, v4, v20, v0.t			# CHECK-INST: vfmax.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x18]			# 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>			# CHECK-UNKNOWN: 57 14 4a 18 <unknown>

	vfmax.vv v8, v4, v20			vfmax.vv v8, v4, v20
	# CHECK-INST: vfmax.vv v8, v4, v20			# CHECK-INST: vfmax.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x1a]			# 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>			# CHECK-UNKNOWN: 57 14 4a 1a <unknown>

	vfmax.vf v8, v4, fa0, v0.t			vfmax.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfmax.vf v8, v4, fa0, v0.t			# CHECK-INST: vfmax.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x18]			# 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>			# CHECK-UNKNOWN: 57 54 45 18 <unknown>

	vfmax.vf v8, v4, fa0			vfmax.vf v8, v4, fa0
	# CHECK-INST: vfmax.vf v8, v4, fa0			# CHECK-INST: vfmax.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x1a]			# 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>			# CHECK-UNKNOWN: 57 54 45 1a <unknown>

llvm/test/MC/RISCV/rvv/fmul.s

	# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST			# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
	# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \			# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
	# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR			# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# 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: \| FileCheck %s --check-prefix=CHECK-INST
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN			# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN

	vfmul.vv v8, v4, v20, v0.t			vfmul.vv v8, v4, v20, v0.t
	# CHECK-INST: vfmul.vv v8, v4, v20, v0.t			# CHECK-INST: vfmul.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x90]			# 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>			# CHECK-UNKNOWN: 57 14 4a 90 <unknown>

	vfmul.vv v8, v4, v20			vfmul.vv v8, v4, v20
	# CHECK-INST: vfmul.vv v8, v4, v20			# CHECK-INST: vfmul.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x92]			# 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>			# CHECK-UNKNOWN: 57 14 4a 92 <unknown>

	vfmul.vf v8, v4, fa0, v0.t			vfmul.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfmul.vf v8, v4, fa0, v0.t			# CHECK-INST: vfmul.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x90]			# 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>			# CHECK-UNKNOWN: 57 54 45 90 <unknown>

	vfmul.vf v8, v4, fa0			vfmul.vf v8, v4, fa0
	# CHECK-INST: vfmul.vf v8, v4, fa0			# CHECK-INST: vfmul.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x92]			# 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>			# CHECK-UNKNOWN: 57 54 45 92 <unknown>

	vfwmul.vv v8, v4, v20, v0.t			vfwmul.vv v8, v4, v20, v0.t
	# CHECK-INST: vfwmul.vv v8, v4, v20, v0.t			# CHECK-INST: vfwmul.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xe0]			# 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>			# CHECK-UNKNOWN: 57 14 4a e0 <unknown>

	vfwmul.vv v8, v4, v20			vfwmul.vv v8, v4, v20
	# CHECK-INST: vfwmul.vv v8, v4, v20			# CHECK-INST: vfwmul.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xe2]			# 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>			# CHECK-UNKNOWN: 57 14 4a e2 <unknown>

	vfwmul.vf v8, v4, fa0, v0.t			vfwmul.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfwmul.vf v8, v4, fa0, v0.t			# CHECK-INST: vfwmul.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xe0]			# 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>			# CHECK-UNKNOWN: 57 54 45 e0 <unknown>

	vfwmul.vf v8, v4, fa0			vfwmul.vf v8, v4, fa0
	# CHECK-INST: vfwmul.vf v8, v4, fa0			# CHECK-INST: vfwmul.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0xe2]			# 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>			# CHECK-UNKNOWN: 57 54 45 e2 <unknown>

llvm/test/MC/RISCV/rvv/fmv.s

	# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST			# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
	# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \			# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
	# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR			# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# 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: \| FileCheck %s --check-prefix=CHECK-INST
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN			# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN

	vfmv.v.f v8, fa0			vfmv.v.f v8, fa0
	# CHECK-INST: vfmv.v.f v8, fa0			# CHECK-INST: vfmv.v.f v8, fa0
	# CHECK-ENCODING: [0x57,0x54,0x05,0x5e]			# 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>			# CHECK-UNKNOWN: 57 54 05 5e <unknown>

	vfmv.f.s fa0, v4			vfmv.f.s fa0, v4
	# CHECK-INST: vfmv.f.s fa0, v4			# CHECK-INST: vfmv.f.s fa0, v4
	# CHECK-ENCODING: [0x57,0x15,0x40,0x42]			# 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>			# CHECK-UNKNOWN: 57 15 40 42 <unknown>

	vfmv.s.f v8, fa0			vfmv.s.f v8, fa0
	# CHECK-INST: vfmv.s.f v8, fa0			# CHECK-INST: vfmv.s.f v8, fa0
	# CHECK-ENCODING: [0x57,0x54,0x05,0x42]			# 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>			# CHECK-UNKNOWN: 57 54 05 42 <unknown>

llvm/test/MC/RISCV/rvv/fothers.s

	# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST			# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
	# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \			# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
	# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR			# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# 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: \| FileCheck %s --check-prefix=CHECK-INST
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN			# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN

	vfsqrt.v v8, v4, v0.t			vfsqrt.v v8, v4, v0.t
	# CHECK-INST: vfsqrt.v v8, v4, v0.t			# CHECK-INST: vfsqrt.v v8, v4, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x40,0x4c]			# 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>			# CHECK-UNKNOWN: 57 14 40 4c <unknown>

	vfsqrt.v v8, v4			vfsqrt.v v8, v4
	# CHECK-INST: vfsqrt.v v8, v4			# CHECK-INST: vfsqrt.v v8, v4
	# CHECK-ENCODING: [0x57,0x14,0x40,0x4e]			# 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>			# CHECK-UNKNOWN: 57 14 40 4e <unknown>

	vfclass.v v8, v4, v0.t			vfclass.v v8, v4, v0.t
	# CHECK-INST: vfclass.v v8, v4, v0.t			# CHECK-INST: vfclass.v v8, v4, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x48,0x4c]			# 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>			# CHECK-UNKNOWN: 57 14 48 4c <unknown>

	vfclass.v v8, v4			vfclass.v v8, v4
	# CHECK-INST: vfclass.v v8, v4			# CHECK-INST: vfclass.v v8, v4
	# CHECK-ENCODING: [0x57,0x14,0x48,0x4e]			# 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>			# CHECK-UNKNOWN: 57 14 48 4e <unknown>

	vfmerge.vfm v8, v4, fa0, v0			vfmerge.vfm v8, v4, fa0, v0
	# CHECK-INST: vfmerge.vfm v8, v4, fa0, v0			# CHECK-INST: vfmerge.vfm v8, v4, fa0, v0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x5c]			# 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>			# CHECK-UNKNOWN: 57 54 45 5c <unknown>

	vfslide1up.vf v8, v4, fa0, v0.t			vfslide1up.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfslide1up.vf v8, v4, fa0, v0.t			# CHECK-INST: vfslide1up.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x38]			# 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>			# CHECK-UNKNOWN: 57 54 45 38 <unknown>

	vfslide1up.vf v8, v4, fa0			vfslide1up.vf v8, v4, fa0
	# CHECK-INST: vfslide1up.vf v8, v4, fa0			# CHECK-INST: vfslide1up.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x3a]			# 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>			# CHECK-UNKNOWN: 57 54 45 3a <unknown>

	vfslide1down.vf v8, v4, fa0, v0.t			vfslide1down.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfslide1down.vf v8, v4, fa0, v0.t			# CHECK-INST: vfslide1down.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x3c]			# 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>			# CHECK-UNKNOWN: 57 54 45 3c <unknown>

	vfslide1down.vf v8, v4, fa0			vfslide1down.vf v8, v4, fa0
	# CHECK-INST: vfslide1down.vf v8, v4, fa0			# CHECK-INST: vfslide1down.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x3e]			# 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>			# CHECK-UNKNOWN: 57 54 45 3e <unknown>

llvm/test/MC/RISCV/rvv/freduction.s

	# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST			# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
	# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \			# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
	# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR			# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# 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: \| FileCheck %s --check-prefix=CHECK-INST
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN			# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN

	vfredosum.vs v8, v4, v20, v0.t			vfredosum.vs v8, v4, v20, v0.t
	# CHECK-INST: vfredosum.vs v8, v4, v20, v0.t			# CHECK-INST: vfredosum.vs v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x0c]			# 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>			# CHECK-UNKNOWN: 57 14 4a 0c <unknown>

	vfredosum.vs v8, v4, v20			vfredosum.vs v8, v4, v20
	# CHECK-INST: vfredosum.vs v8, v4, v20			# CHECK-INST: vfredosum.vs v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x0e]			# 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>			# CHECK-UNKNOWN: 57 14 4a 0e <unknown>

	vfredsum.vs v8, v4, v20, v0.t			vfredsum.vs v8, v4, v20, v0.t
	# CHECK-INST: vfredsum.vs v8, v4, v20, v0.t			# CHECK-INST: vfredsum.vs v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x04]			# 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>			# CHECK-UNKNOWN: 57 14 4a 04 <unknown>

	vfredsum.vs v8, v4, v20			vfredsum.vs v8, v4, v20
	# CHECK-INST: vfredsum.vs v8, v4, v20			# CHECK-INST: vfredsum.vs v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x06]			# 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>			# CHECK-UNKNOWN: 57 14 4a 06 <unknown>

	vfredmax.vs v8, v4, v20, v0.t			vfredmax.vs v8, v4, v20, v0.t
	# CHECK-INST: vfredmax.vs v8, v4, v20, v0.t			# CHECK-INST: vfredmax.vs v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x1c]			# 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>			# CHECK-UNKNOWN: 57 14 4a 1c <unknown>

	vfredmax.vs v8, v4, v20			vfredmax.vs v8, v4, v20
	# CHECK-INST: vfredmax.vs v8, v4, v20			# CHECK-INST: vfredmax.vs v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x1e]			# 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>			# CHECK-UNKNOWN: 57 14 4a 1e <unknown>

	vfredmin.vs v8, v4, v20, v0.t			vfredmin.vs v8, v4, v20, v0.t
	# CHECK-INST: vfredmin.vs v8, v4, v20, v0.t			# CHECK-INST: vfredmin.vs v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x14]			# 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>			# CHECK-UNKNOWN: 57 14 4a 14 <unknown>

	vfredmin.vs v8, v4, v20			vfredmin.vs v8, v4, v20
	# CHECK-INST: vfredmin.vs v8, v4, v20			# CHECK-INST: vfredmin.vs v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x16]			# 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>			# CHECK-UNKNOWN: 57 14 4a 16 <unknown>

	vfwredosum.vs v8, v4, v20, v0.t			vfwredosum.vs v8, v4, v20, v0.t
	# CHECK-INST: vfwredosum.vs v8, v4, v20, v0.t			# CHECK-INST: vfwredosum.vs v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xcc]			# 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>			# CHECK-UNKNOWN: 57 14 4a cc <unknown>

	vfwredosum.vs v8, v4, v20			vfwredosum.vs v8, v4, v20
	# CHECK-INST: vfwredosum.vs v8, v4, v20			# CHECK-INST: vfwredosum.vs v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xce]			# 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>			# CHECK-UNKNOWN: 57 14 4a ce <unknown>

	vfwredsum.vs v8, v4, v20, v0.t			vfwredsum.vs v8, v4, v20, v0.t
	# CHECK-INST: vfwredsum.vs v8, v4, v20, v0.t			# CHECK-INST: vfwredsum.vs v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xc4]			# 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>			# CHECK-UNKNOWN: 57 14 4a c4 <unknown>

	vfwredsum.vs v8, v4, v20			vfwredsum.vs v8, v4, v20
	# CHECK-INST: vfwredsum.vs v8, v4, v20			# CHECK-INST: vfwredsum.vs v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xc6]			# 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>			# CHECK-UNKNOWN: 57 14 4a c6 <unknown>

	vfredosum.vs v0, v4, v20, v0.t			vfredosum.vs v0, v4, v20, v0.t
	# CHECK-INST: vfredosum.vs v0, v4, v20, v0.t			# CHECK-INST: vfredosum.vs v0, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x10,0x4a,0x0c]			# 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>			# CHECK-UNKNOWN: 57 10 4a 0c <unknown>

llvm/test/MC/RISCV/rvv/fsub.s

	# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST			# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
	# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \			# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
	# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR			# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# 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: \| FileCheck %s --check-prefix=CHECK-INST
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN			# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN

	vfsub.vv v8, v4, v20, v0.t			vfsub.vv v8, v4, v20, v0.t
	# CHECK-INST: vfsub.vv v8, v4, v20, v0.t			# CHECK-INST: vfsub.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x08]			# 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>			# CHECK-UNKNOWN: 57 14 4a 08 <unknown>

	vfsub.vv v8, v4, v20			vfsub.vv v8, v4, v20
	# CHECK-INST: vfsub.vv v8, v4, v20			# CHECK-INST: vfsub.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x0a]			# 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>			# CHECK-UNKNOWN: 57 14 4a 0a <unknown>

	vfsub.vf v8, v4, fa0, v0.t			vfsub.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfsub.vf v8, v4, fa0, v0.t			# CHECK-INST: vfsub.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x08]			# 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>			# CHECK-UNKNOWN: 57 54 45 08 <unknown>

	vfsub.vf v8, v4, fa0			vfsub.vf v8, v4, fa0
	# CHECK-INST: vfsub.vf v8, v4, fa0			# CHECK-INST: vfsub.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x0a]			# 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>			# CHECK-UNKNOWN: 57 54 45 0a <unknown>

	vfrsub.vf v8, v4, fa0, v0.t			vfrsub.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfrsub.vf v8, v4, fa0, v0.t			# CHECK-INST: vfrsub.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x9c]			# 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>			# CHECK-UNKNOWN: 57 54 45 9c <unknown>

	vfrsub.vf v8, v4, fa0			vfrsub.vf v8, v4, fa0
	# CHECK-INST: vfrsub.vf v8, v4, fa0			# CHECK-INST: vfrsub.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x9e]			# 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>			# CHECK-UNKNOWN: 57 54 45 9e <unknown>

	vfwsub.vv v8, v4, v20, v0.t			vfwsub.vv v8, v4, v20, v0.t
	# CHECK-INST: vfwsub.vv v8, v4, v20, v0.t			# CHECK-INST: vfwsub.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xc8]			# 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>			# CHECK-UNKNOWN: 57 14 4a c8 <unknown>

	vfwsub.vv v8, v4, v20			vfwsub.vv v8, v4, v20
	# CHECK-INST: vfwsub.vv v8, v4, v20			# CHECK-INST: vfwsub.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xca]			# 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>			# CHECK-UNKNOWN: 57 14 4a ca <unknown>

	vfwsub.vf v8, v4, fa0, v0.t			vfwsub.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfwsub.vf v8, v4, fa0, v0.t			# CHECK-INST: vfwsub.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xc8]			# 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>			# CHECK-UNKNOWN: 57 54 45 c8 <unknown>

	vfwsub.vf v8, v4, fa0			vfwsub.vf v8, v4, fa0
	# CHECK-INST: vfwsub.vf v8, v4, fa0			# CHECK-INST: vfwsub.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0xca]			# 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>			# CHECK-UNKNOWN: 57 54 45 ca <unknown>

	vfwsub.wv v8, v4, v20, v0.t			vfwsub.wv v8, v4, v20, v0.t
	# CHECK-INST: vfwsub.wv v8, v4, v20, v0.t			# CHECK-INST: vfwsub.wv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xd8]			# 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>			# CHECK-UNKNOWN: 57 14 4a d8 <unknown>

	vfwsub.wv v8, v4, v20			vfwsub.wv v8, v4, v20
	# CHECK-INST: vfwsub.wv v8, v4, v20			# CHECK-INST: vfwsub.wv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0xda]			# 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>			# CHECK-UNKNOWN: 57 14 4a da <unknown>

	vfwsub.wf v8, v4, fa0, v0.t			vfwsub.wf v8, v4, fa0, v0.t
	# CHECK-INST: vfwsub.wf v8, v4, fa0, v0.t			# CHECK-INST: vfwsub.wf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0xd8]			# 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>			# CHECK-UNKNOWN: 57 54 45 d8 <unknown>

	vfwsub.wf v8, v4, fa0			vfwsub.wf v8, v4, fa0
	# CHECK-INST: vfwsub.wf v8, v4, fa0			# CHECK-INST: vfwsub.wf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0xda]			# 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>			# CHECK-UNKNOWN: 57 54 45 da <unknown>

llvm/test/MC/RISCV/rvv/sign-injection.s

	# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST			# RUN: \| FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
	# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \			# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
	# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR			# RUN: \| FileCheck %s --check-prefix=CHECK-ERROR
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# 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: \| FileCheck %s --check-prefix=CHECK-INST
	# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \			# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-v %s \
				# RUN: --mattr=+f \
	# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN			# RUN: \| llvm-objdump -d - \| FileCheck %s --check-prefix=CHECK-UNKNOWN

	vfsgnj.vv v8, v4, v20, v0.t			vfsgnj.vv v8, v4, v20, v0.t
	# CHECK-INST: vfsgnj.vv v8, v4, v20, v0.t			# CHECK-INST: vfsgnj.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x20]			# 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>			# CHECK-UNKNOWN: 57 14 4a 20 <unknown>

	vfsgnj.vv v8, v4, v20			vfsgnj.vv v8, v4, v20
	# CHECK-INST: vfsgnj.vv v8, v4, v20			# CHECK-INST: vfsgnj.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x22]			# 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>			# CHECK-UNKNOWN: 57 14 4a 22 <unknown>

	vfsgnj.vf v8, v4, fa0, v0.t			vfsgnj.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfsgnj.vf v8, v4, fa0, v0.t			# CHECK-INST: vfsgnj.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x20]			# 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>			# CHECK-UNKNOWN: 57 54 45 20 <unknown>

	vfsgnj.vf v8, v4, fa0			vfsgnj.vf v8, v4, fa0
	# CHECK-INST: vfsgnj.vf v8, v4, fa0			# CHECK-INST: vfsgnj.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x22]			# 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>			# CHECK-UNKNOWN: 57 54 45 22 <unknown>

	vfsgnjn.vv v8, v4, v20, v0.t			vfsgnjn.vv v8, v4, v20, v0.t
	# CHECK-INST: vfsgnjn.vv v8, v4, v20, v0.t			# CHECK-INST: vfsgnjn.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x24]			# 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>			# CHECK-UNKNOWN: 57 14 4a 24 <unknown>

	vfsgnjn.vv v8, v4, v20			vfsgnjn.vv v8, v4, v20
	# CHECK-INST: vfsgnjn.vv v8, v4, v20			# CHECK-INST: vfsgnjn.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x26]			# 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>			# CHECK-UNKNOWN: 57 14 4a 26 <unknown>

	vfsgnjn.vf v8, v4, fa0, v0.t			vfsgnjn.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfsgnjn.vf v8, v4, fa0, v0.t			# CHECK-INST: vfsgnjn.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x24]			# 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>			# CHECK-UNKNOWN: 57 54 45 24 <unknown>

	vfsgnjn.vf v8, v4, fa0			vfsgnjn.vf v8, v4, fa0
	# CHECK-INST: vfsgnjn.vf v8, v4, fa0			# CHECK-INST: vfsgnjn.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x26]			# 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>			# CHECK-UNKNOWN: 57 54 45 26 <unknown>

	vfsgnjx.vv v8, v4, v20, v0.t			vfsgnjx.vv v8, v4, v20, v0.t
	# CHECK-INST: vfsgnjx.vv v8, v4, v20, v0.t			# CHECK-INST: vfsgnjx.vv v8, v4, v20, v0.t
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x28]			# 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>			# CHECK-UNKNOWN: 57 14 4a 28 <unknown>

	vfsgnjx.vv v8, v4, v20			vfsgnjx.vv v8, v4, v20
	# CHECK-INST: vfsgnjx.vv v8, v4, v20			# CHECK-INST: vfsgnjx.vv v8, v4, v20
	# CHECK-ENCODING: [0x57,0x14,0x4a,0x2a]			# 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>			# CHECK-UNKNOWN: 57 14 4a 2a <unknown>

	vfsgnjx.vf v8, v4, fa0, v0.t			vfsgnjx.vf v8, v4, fa0, v0.t
	# CHECK-INST: vfsgnjx.vf v8, v4, fa0, v0.t			# CHECK-INST: vfsgnjx.vf v8, v4, fa0, v0.t
	# CHECK-ENCODING: [0x57,0x54,0x45,0x28]			# 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>			# CHECK-UNKNOWN: 57 54 45 28 <unknown>

	vfsgnjx.vf v8, v4, fa0			vfsgnjx.vf v8, v4, fa0
	# CHECK-INST: vfsgnjx.vf v8, v4, fa0			# CHECK-INST: vfsgnjx.vf v8, v4, fa0
	# CHECK-ENCODING: [0x57,0x54,0x45,0x2a]			# 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>			# CHECK-UNKNOWN: 57 54 45 2a <unknown>

This is an archive of the discontinued LLVM Phabricator instance.

[RISCV] V does not imply F.ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 311800

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

[RISCV] V does not imply F.
ClosedPublic