[VE] Add vector float instructions

[kaz7]

Summary

Add VFAD/VFSB/VFMP/VFDV/VFSQRT/VFCP/VFCM/VFMAD/VFMSB/VFNMAD/VFNMSB/
VRCP/VRSQRT/VRSQRTNEX/VFIX/VFIXX/VFLT/VFLTX/VCVS/VCVD instructions.
Add regression tests too. Also add additional AsmParser for VFIX
and VFIXX instructions to parse their mnemonic.

llvm/lib/Target/VE/AsmParser/VEAsmParser.cpp

 //===-- VEAsmParser.cpp - Parse VE assembly to MCInst instructions --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "MCTargetDesc/VEMCExpr.h"
 #include "MCTargetDesc/VEMCTargetDesc.h"
 #include "TargetInfo/VETargetInfo.h"
 #include "VE.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/MC/MCContext.h"
Mnemonic = parseCC(Name, Start, Next, ICC, true, NameLoc, Operands);
              Name.startswith("cmov.d.") || Name.startswith("cmov.s.")) {
     bool ICC = Name[5] == 'l' || Name[5] == 'w';
     Mnemonic = parseCC(Name, 7, Name.size(), ICC, false, NameLoc, Operands);
   } else if (Name.startswith("cvt.w.d.sx") || Name.startswith("cvt.w.d.zx") ||
              Name.startswith("cvt.w.s.sx") || Name.startswith("cvt.w.s.zx")) {
     Mnemonic = parseRD(Name, 10, NameLoc, Operands);
   } else if (Name.startswith("cvt.l.d")) {
     Mnemonic = parseRD(Name, 7, NameLoc, Operands);
+  } else if (Name.startswith("vcvt.w.d.sx") || Name.startswith("vcvt.w.d.zx") ||
+             Name.startswith("vcvt.w.s.sx") || Name.startswith("vcvt.w.s.zx")) {
+    Mnemonic = parseRD(Name, 11, NameLoc, Operands);
+  } else if (Name.startswith("vcvt.l.d")) {
+    Mnemonic = parseRD(Name, 8, NameLoc, Operands);
+  } else if (Name.startswith("pvcvt.w.s.lo") ||
+             Name.startswith("pvcvt.w.s.up")) {
+    Mnemonic = parseRD(Name, 12, NameLoc, Operands);
+  } else if (Name.startswith("pvcvt.w.s")) {
+    Mnemonic = parseRD(Name, 9, NameLoc, Operands);
   } else {
     Operands->push_back(VEOperand::CreateToken(Mnemonic, NameLoc));
   }
 
   return Mnemonic;
 }
 
 static void applyMnemonicAliases(StringRef &Mnemonic,

llvm/lib/Target/VE/VEInstrVec.td

defm vrm : RVmm<opcStr, ", $vz, $sy, $sz", opc, RC, RCM,
                   (ins RC:$vz, I64:$sy, mimm:$sz)>;
   let cy = 0, cz = 1, sz = ?, vz = ? in
   defm vir : RVmm<opcStr, ", $vz, $sy, $sz", opc, RC, RCM,
                   (ins RC:$vz, uimm3:$sy, I64:$sz)>;
   let cy = 0, cz = 0, sz = ?, vz = ? in
   defm vim : RVmm<opcStr, ", $vz, $sy, $sz", opc, RC, RCM,
                   (ins RC:$vz, uimm3:$sy, mimm:$sz)>;
 }
+// Generic RV multiclass with 1 argument using vy field.
+//   e.g. VFSQRT, VRCP, and VRSQRT.
+let VE_VLIndex = 2 in
+multiclass RVF1m<string opcStr, bits<8>opc, RegisterClass RC,
+                 RegisterClass RCM> {
+  let cy = 0, sy = 0, vy = ? in
+  defm v : RVmm<opcStr, ", $vy", opc, RC, RCM, (ins RC:$vy)>;
+}
+// Special RV multiclass with 3 arguments using cs2.
+//   e.g. VFMAD, VFMSB, VFNMAD, and etc.
+let VE_VLIndex = 4 in
+multiclass RVMm<string opcStr, bits<8>opc, RegisterClass VRC, RegisterClass RC,
+                RegisterClass RCM, Operand SIMM = simm7> {
+  let cy = 0, sy = 0, vy = ?, vz = ?, vw = ? in
+  defm vvv : RVmm<opcStr, ", $vy, $vz, $vw", opc, VRC, RCM,
+                  (ins VRC:$vy, VRC:$vz, VRC:$vw)>;
+  let cs2 = 1, vy = ?, vw = ? in
+  defm vrv : RVmm<opcStr, ", $vy, $sy, $vw", opc, VRC, RCM,
+                  (ins VRC:$vy, RC:$sy, VRC:$vw)>;
+  let cs2 = 1, cy = 0, vy = ?, vw = ? in
+  defm viv : RVmm<opcStr, ", $vy, $sy, $vw", opc, VRC, RCM,
+                  (ins VRC:$vy, SIMM:$sy, VRC:$vw)>;
+  let cs = 1, vz = ?, vw = ? in
+  defm rvv : RVmm<opcStr, ", $sy, $vz, $vw", opc, VRC, RCM,
+                  (ins RC:$sy, VRC:$vz, VRC:$vw)>;
+  let cs = 1, cy = 0, vz = ?, vw = ? in
+  defm ivv : RVmm<opcStr, ", $sy, $vz, $vw", opc, VRC, RCM,
+                  (ins SIMM:$sy, VRC:$vz, VRC:$vw)>;
+}
+// Special RV multiclass with 2 arguments for floating point conversions.
+//   e.g. VFIX and VFIXX
+let hasSideEffects = 0, VE_VLIndex = 3 in
+multiclass RVFIXm<string opcStr, bits<8> opc, RegisterClass RC,
+                  RegisterClass RCM> {
+  let cy = 0, sy = 0, vy = ?, vz = ? in
+  defm v : RVmm<opcStr#"$vz", ", $vy", opc, RC, RCM, (ins RDOp:$vz, RC:$vy)>;
+}
 
 // Section 8.10.1 - VADD (Vector Add)
 let cx = 0, cx2 = 0 in
 defm VADDUL : RVm<"vaddu.l", 0xc8, V64, I64, VM>;
 let cx = 0, cx2 = 1 in {
   defm PVADDULO : RVm<"pvaddu.lo", 0xc8, V64, I32, VM>;
   let isCodeGenOnly = 1 in
   defm VADDUW : RVm<"vaddu.w", 0xc8, V64, I32, VM>;

 def : MnemonicAlias<"vsra.w", "pvsra.lo">;
 def : MnemonicAlias<"pvsra.lo.zx", "pvsra.lo">;
 
 // Section 8.12.8 - VSRAX (Vector Shift Right Arithmetic)
 defm VSRAL : RVSm<"vsra.l", 0xd5, I64, V64, VM>;
 
 // Section 8.12.9 - VSFA (Vector Shift Left and Add)
 defm VSFA : RVSAm<"vsfa", 0xd7, V64, VM>;
+
+//-----------------------------------------------------------------------------
+// Section 8.13 - Vector Floating-Point Arithmetic Instructions
+//-----------------------------------------------------------------------------
+
+// Section 8.13.1 - VFAD (Vector Floating Add)
+let cx = 0, cx2 = 0 in
+defm VFADDD : RVm<"vfadd.d", 0xcc, V64, I64, VM, simm7fp>;
+let cx = 0, cx2 = 1 in
+defm PVFADDLO : RVm<"pvfadd.lo", 0xcc, V64, I64, VM, simm7fp>;
+let cx = 1, cx2 = 0 in {
+  defm PVFADDUP : RVm<"pvfadd.up", 0xcc, V64, F32, VM, simm7fp>;
+  let isCodeGenOnly = 1 in
+  defm VFADDS : RVm<"vfadd.s", 0xcc, V64, F32, VM, simm7fp>;
+}
+let cx = 1, cx2 = 1 in
+defm PVFADD : RVm<"pvfadd", 0xcc, V64, I64, VM512, simm7fp>;
+def : MnemonicAlias<"vfadd.s", "pvfadd.up">;
+
+// Section 8.13.2 - VFSB (Vector Floating Subtract)
+let cx = 0, cx2 = 0 in
+defm VFSUBD : RVm<"vfsub.d", 0xdc, V64, I64, VM, simm7fp>;
+let cx = 0, cx2 = 1 in
+defm PVFSUBLO : RVm<"pvfsub.lo", 0xdc, V64, I64, VM, simm7fp>;
+let cx = 1, cx2 = 0 in {
+  defm PVFSUBUP : RVm<"pvfsub.up", 0xdc, V64, F32, VM, simm7fp>;
+  let isCodeGenOnly = 1 in
+  defm VFSUBS : RVm<"vfsub.s", 0xdc, V64, F32, VM, simm7fp>;
+}
+let cx = 1, cx2 = 1 in
+defm PVFSUB : RVm<"pvfsub", 0xdc, V64, I64, VM512, simm7fp>;
+def : MnemonicAlias<"vfsub.s", "pvfsub.up">;
+
+// Section 8.13.3 - VFMP (Vector Floating Multiply)
+let cx = 0, cx2 = 0 in
+defm VFMULD : RVm<"vfmul.d", 0xcd, V64, I64, VM, simm7fp>;
+let cx = 0, cx2 = 1 in
+defm PVFMULLO : RVm<"pvfmul.lo", 0xcd, V64, I64, VM, simm7fp>;
+let cx = 1, cx2 = 0 in {
+  defm PVFMULUP : RVm<"pvfmul.up", 0xcd, V64, F32, VM, simm7fp>;
+  let isCodeGenOnly = 1 in
+  defm VFMULS : RVm<"vfmul.s", 0xcd, V64, F32, VM, simm7fp>;
+}
+let cx = 1, cx2 = 1 in
+defm PVFMUL : RVm<"pvfmul", 0xcd, V64, I64, VM512, simm7fp>;
+def : MnemonicAlias<"vfmul.s", "pvfmul.up">;
+
+// Section 8.13.4 - VFDV (Vector Floating Divide)
+defm VFDIVD : RVDIVm<"vfdiv.d", 0xdd, V64, I64, VM, simm7fp>;
+let cx = 1 in
+defm VFDIVS : RVDIVm<"vfdiv.s", 0xdd, V64, F32, VM, simm7fp>;
+
+// Section 8.13.5 - VFSQRT (Vector Floating Square Root)
+defm VFSQRTD : RVF1m<"vfsqrt.d", 0xed, V64, VM>;
+let cx = 1 in
+defm VFSQRTS : RVF1m<"vfsqrt.s", 0xed, V64, VM>;
+
+// Section 8.13.6 - VFCP (Vector Floating Compare)
+let cx = 0, cx2 = 0 in
+defm VFCMPD : RVm<"vfcmp.d", 0xfc, V64, I64, VM, simm7fp>;
+let cx = 0, cx2 = 1 in
+defm PVFCMPLO : RVm<"pvfcmp.lo", 0xfc, V64, I64, VM, simm7fp>;
+let cx = 1, cx2 = 0 in {
+  defm PVFCMPUP : RVm<"pvfcmp.up", 0xfc, V64, F32, VM, simm7fp>;
+  let isCodeGenOnly = 1 in
+  defm VFCMPS : RVm<"vfcmp.s", 0xfc, V64, F32, VM, simm7fp>;
+}
+let cx = 1, cx2 = 1 in
+defm PVFCMP : RVm<"pvfcmp", 0xfc, V64, I64, VM512, simm7fp>;
+def : MnemonicAlias<"vfcmp.s", "pvfcmp.up">;
+
+// Section 8.13.7 - VFCM (Vector Floating Compare and Select Maximum/Minimum)
+let cx = 0, cx2 = 0 in
+defm VFMAXD : RVm<"vfmax.d", 0xbd, V64, I64, VM, simm7fp>;
+let cx = 0, cx2 = 1 in
+defm PVFMAXLO : RVm<"pvfmax.lo", 0xbd, V64, I64, VM, simm7fp>;
+let cx = 1, cx2 = 0 in {
+  defm PVFMAXUP : RVm<"pvfmax.up", 0xbd, V64, F32, VM, simm7fp>;
+  let isCodeGenOnly = 1 in
+  defm VFMAXS : RVm<"vfmax.s", 0xbd, V64, F32, VM, simm7fp>;
+}
+let cx = 1, cx2 = 1 in
+defm PVFMAX : RVm<"pvfmax", 0xbd, V64, I64, VM512, simm7fp>;
+let cs2 = 1 in {
+  let cx = 0, cx2 = 0 in
+  defm VFMIND : RVm<"vfmin.d", 0xbd, V64, I64, VM, simm7fp>;
+  let cx = 0, cx2 = 1 in
+  defm PVFMINLO : RVm<"pvfmin.lo", 0xbd, V64, I64, VM, simm7fp>;
+  let cx = 1, cx2 = 0 in {
+    defm PVFMINUP : RVm<"pvfmin.up", 0xbd, V64, F32, VM, simm7fp>;
+    let isCodeGenOnly = 1 in
+    defm VFMINS : RVm<"vfmin.s", 0xbd, V64, F32, VM, simm7fp>;
+  }
+  let cx = 1, cx2 = 1 in
+  defm PVFMIN : RVm<"pvfmin", 0xbd, V64, I64, VM512, simm7fp>;
+}
+def : MnemonicAlias<"vfmax.s", "pvfmax.up">;
+def : MnemonicAlias<"vfmin.s", "pvfmin.up">;
+
+// Section 8.13.8 - VFMAD (Vector Floating Fused Multiply Add)
+let cx = 0, cx2 = 0 in
+defm VFMADD : RVMm<"vfmad.d", 0xe2, V64, I64, VM, simm7fp>;
+let cx = 0, cx2 = 1 in
+defm PVFMADLO : RVMm<"pvfmad.lo", 0xe2, V64, I64, VM, simm7fp>;
+let cx = 1, cx2 = 0 in {
+  defm PVFMADUP : RVMm<"pvfmad.up", 0xe2, V64, F32, VM, simm7fp>;
+  let isCodeGenOnly = 1 in
+  defm VFMADS : RVMm<"vfmad.s", 0xe2, V64, F32, VM, simm7fp>;
+}
+let cx = 1, cx2 = 1 in
+defm PVFMAD : RVMm<"pvfmad", 0xe2, V64, I64, VM512, simm7fp>;
+def : MnemonicAlias<"vfmad.s", "pvfmad.up">;
+
+// Section 8.13.9 - VFMSB (Vector Floating Fused Multiply Subtract)
+let cx = 0, cx2 = 0 in
+defm VFMSBD : RVMm<"vfmsb.d", 0xf2, V64, I64, VM, simm7fp>;
+let cx = 0, cx2 = 1 in
+defm PVFMSBLO : RVMm<"pvfmsb.lo", 0xf2, V64, I64, VM, simm7fp>;
+let cx = 1, cx2 = 0 in {
+  defm PVFMSBUP : RVMm<"pvfmsb.up", 0xf2, V64, F32, VM, simm7fp>;
+  let isCodeGenOnly = 1 in
+  defm VFMSBS : RVMm<"vfmsb.s", 0xf2, V64, F32, VM, simm7fp>;
+}
+let cx = 1, cx2 = 1 in
+defm PVFMSB : RVMm<"pvfmsb", 0xf2, V64, I64, VM512, simm7fp>;
+def : MnemonicAlias<"vfmsb.s", "pvfmsb.up">;
+
+// Section 8.13.10 - VFNMAD (Vector Floating Fused Negative Multiply Add)
+let cx = 0, cx2 = 0 in
+defm VFNMADD : RVMm<"vfnmad.d", 0xe3, V64, I64, VM, simm7fp>;
+let cx = 0, cx2 = 1 in
+defm PVFNMADLO : RVMm<"pvfnmad.lo", 0xe3, V64, I64, VM, simm7fp>;
+let cx = 1, cx2 = 0 in {
+  defm PVFNMADUP : RVMm<"pvfnmad.up", 0xe3, V64, F32, VM, simm7fp>;
+  let isCodeGenOnly = 1 in
+  defm VFNMADS : RVMm<"vfnmad.s", 0xe3, V64, F32, VM, simm7fp>;
+}
+let cx = 1, cx2 = 1 in
+defm PVFNMAD : RVMm<"pvfnmad", 0xe3, V64, I64, VM512, simm7fp>;
+def : MnemonicAlias<"vfnmad.s", "pvfnmad.up">;
+
+// Section 8.13.11 - VFNMSB (Vector Floating Fused Negative Multiply Subtract)
+let cx = 0, cx2 = 0 in
+defm VFNMSBD : RVMm<"vfnmsb.d", 0xf3, V64, I64, VM, simm7fp>;
+let cx = 0, cx2 = 1 in
+defm PVFNMSBLO : RVMm<"pvfnmsb.lo", 0xf3, V64, I64, VM, simm7fp>;
+let cx = 1, cx2 = 0 in {
+  defm PVFNMSBUP : RVMm<"pvfnmsb.up", 0xf3, V64, F32, VM, simm7fp>;
+  let isCodeGenOnly = 1 in
+  defm VFNMSBS : RVMm<"vfnmsb.s", 0xf3, V64, F32, VM, simm7fp>;
+}
+let cx = 1, cx2 = 1 in
+defm PVFNMSB : RVMm<"pvfnmsb", 0xf3, V64, I64, VM512, simm7fp>;
+def : MnemonicAlias<"vfnmsb.s", "pvfnmsb.up">;
+
+// Section 8.13.12 - VRCP (Vector Floating Reciprocal)
+let cx = 0, cx2 = 0 in defm VRCPD : RVF1m<"vrcp.d", 0xe1, V64, VM>;
+let cx = 0, cx2 = 1 in defm PVRCPLO : RVF1m<"pvrcp.lo", 0xe1, V64, VM>;
+let cx = 1, cx2 = 0 in {
+  defm PVRCPUP : RVF1m<"pvrcp.up", 0xe1, V64, VM>;
+  let isCodeGenOnly = 1 in defm VRCPS : RVF1m<"vrcp.s", 0xe1, V64, VM>;
+}
+let cx = 1, cx2 = 1 in defm PVRCP : RVF1m<"pvrcp", 0xe1, V64, VM512>;
+def : MnemonicAlias<"vrcp.s", "pvrcp.up">;
+
+// Section 8.13.13 - VRSQRT (Vector Floating Reciprocal Square Root)
+let cx = 0, cx2 = 0 in defm VRSQRTD : RVF1m<"vrsqrt.d", 0xf1, V64, VM>;
+let cx = 0, cx2 = 1 in defm PVRSQRTLO : RVF1m<"pvrsqrt.lo", 0xf1, V64, VM>;
+let cx = 1, cx2 = 0 in {
+  defm PVRSQRTUP : RVF1m<"pvrsqrt.up", 0xf1, V64, VM>;
+  let isCodeGenOnly = 1 in
+  defm VRSQRTS : RVF1m<"vrsqrt.s", 0xf1, V64, VM>;
+}
+let cx = 1, cx2 = 1 in
+defm PVRSQRT : RVF1m<"pvrsqrt", 0xf1, V64, VM512>;
+let cs2 = 1 in {
+    let cx = 0, cx2 = 0 in
+    defm VRSQRTDNEX : RVF1m<"vrsqrt.d.nex", 0xf1, V64, VM>;
+    let cx = 0, cx2 = 1 in
+    defm PVRSQRTLONEX : RVF1m<"pvrsqrt.lo.nex", 0xf1, V64, VM>;
+    let cx = 1, cx2 = 0 in {
+      defm PVRSQRTUPNEX : RVF1m<"pvrsqrt.up.nex", 0xf1, V64, VM>;
+      let isCodeGenOnly = 1 in
+      defm VRSQRTSNEX : RVF1m<"vrsqrt.s.nex", 0xf1, V64, VM>;
+    }
+    let cx = 1, cx2 = 1 in
+    defm PVRSQRTNEX : RVF1m<"pvrsqrt.nex", 0xf1, V64, VM512>;
+}
+def : MnemonicAlias<"vrsqrt.s", "pvrsqrt.up">;
+def : MnemonicAlias<"vrsqrt.s.nex", "pvrsqrt.up.nex">;
+
+// Section 8.13.14 - VFIX (Vector Convert to Fixed Pointer)
+let cx = 0, cx2 = 0, cs2 = 0 in
+defm VCVTWDSX : RVFIXm<"vcvt.w.d.sx", 0xe8, V64, VM>;
+let cx = 0, cx2 = 1, cs2 = 0 in
+defm VCVTWDZX : RVFIXm<"vcvt.w.d.zx", 0xe8, V64, VM>;
+let cx = 1, cx2 = 0, cs2 = 0 in
+defm VCVTWSSX : RVFIXm<"vcvt.w.s.sx", 0xe8, V64, VM>;
+let cx = 1, cx2 = 1, cs2 = 0 in
+defm VCVTWSZX : RVFIXm<"vcvt.w.s.zx", 0xe8, V64, VM>;
+let cx = 0, cx2 = 1, cs2 = 1 in
+defm PVCVTWSLO : RVFIXm<"pvcvt.w.s.lo", 0xe8, V64, VM>;
+let cx = 1, cx2 = 0, cs2 = 1 in
+defm PVCVTWSUP : RVFIXm<"pvcvt.w.s.up", 0xe8, V64, VM>;
+let cx = 1, cx2 = 1, cs2 = 1 in
+defm PVCVTWS : RVFIXm<"pvcvt.w.s", 0xe8, V64, VM512>;
+
+// Section 8.13.15 - VFIXX (Vector Convert to Fixed Pointer)
+defm VCVTLD : RVFIXm<"vcvt.l.d", 0xa8, V64, VM>;
+
+// Section 8.13.16 - VFLT (Vector Convert to Floating Pointer)
+let cx = 0, cx2 = 0, cs2 = 0 in
+defm VCVTDW : RVF1m<"vcvt.d.w", 0xf8, V64, VM>;
+let cx = 1, cx2 = 0, cs2 = 0 in
+defm VCVTSW : RVF1m<"vcvt.s.w", 0xf8, V64, VM>;
+let cx = 0, cx2 = 1, cs2 = 1 in
+defm PVCVTSWLO : RVF1m<"pvcvt.s.w.lo", 0xf8, V64, VM>;
+let cx = 1, cx2 = 0, cs2 = 1 in
+defm PVCVTSWUP : RVF1m<"pvcvt.s.w.up", 0xf8, V64, VM>;
+let cx = 1, cx2 = 1, cs2 = 1 in
+defm PVCVTSW : RVF1m<"pvcvt.s.w", 0xf8, V64, VM512>;
+
+// Section 8.13.17 - VFLTX (Vector Convert to Floating Pointer)
+defm VCVTDL : RVF1m<"vcvt.d.l", 0xb8, V64, VM>;
+
+// Section 8.13.18 - VCVS (Vector Convert to Single-format)
+defm VCVTSD : RVF1m<"vcvt.s.d", 0x9f, V64, VM>;
+
+// Section 8.13.19 - VCVD (Vector Convert to Double-format)
+defm VCVTDS : RVF1m<"vcvt.d.s", 0x8f, V64, VM>;

llvm/test/MC/VE/VCVD.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vcvt.d.s %v11, %v12
+# CHECK-ENCODING: encoding: [0x00,0x00,0x0c,0x0b,0x00,0x00,0x00,0x8f]
+vcvt.d.s %v11, %v12
+
+# CHECK-INST: vcvt.d.s %v11, %vix, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0x0b,0x00,0x00,0x0b,0x8f]
+vcvt.d.s %v11, %vix, %vm11
+
+# CHECK-INST: vcvt.d.s %vix, %v22, %vm15
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0xff,0x00,0x00,0x0f,0x8f]
+vcvt.d.s %vix, %v22, %vm15
+
+# CHECK-INST: vcvt.d.s %v63, %v60, %vm2
+# CHECK-ENCODING: encoding: [0x00,0x00,0x3c,0x3f,0x00,0x00,0x02,0x8f]
+vcvt.d.s %v63, %v60, %vm2
+
+# CHECK-INST: vcvt.d.s %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0xff,0x00,0x00,0x00,0x8f]
+vcvt.d.s %vix, %vix, %vm0
+
+# CHECK-INST: vcvt.d.s %vix, %vix, %vm2
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0xff,0x00,0x00,0x02,0x8f]
+vcvt.d.s %vix, %vix, %vm2

llvm/test/MC/VE/VCVS.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vcvt.s.d %v11, %v12
+# CHECK-ENCODING: encoding: [0x00,0x00,0x0c,0x0b,0x00,0x00,0x00,0x9f]
+vcvt.s.d %v11, %v12
+
+# CHECK-INST: vcvt.s.d %v11, %vix, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0x0b,0x00,0x00,0x0b,0x9f]
+vcvt.s.d %v11, %vix, %vm11
+
+# CHECK-INST: vcvt.s.d %vix, %v22, %vm15
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0xff,0x00,0x00,0x0f,0x9f]
+vcvt.s.d %vix, %v22, %vm15
+
+# CHECK-INST: vcvt.s.d %v63, %v60, %vm2
+# CHECK-ENCODING: encoding: [0x00,0x00,0x3c,0x3f,0x00,0x00,0x02,0x9f]
+vcvt.s.d %v63, %v60, %vm2
+
+# CHECK-INST: vcvt.s.d %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0xff,0x00,0x00,0x00,0x9f]
+vcvt.s.d %vix, %vix, %vm0
+
+# CHECK-INST: vcvt.s.d %vix, %vix, %vm2
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0xff,0x00,0x00,0x02,0x9f]
+vcvt.s.d %vix, %vix, %vm2

llvm/test/MC/VE/VFAD.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vfadd.d %v11, %s20, %v22
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0x0b,0x00,0x94,0x20,0xcc]
+vfadd.d %v11, %s20, %v22
+
+# CHECK-INST: vfadd.up %vix, %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0xff,0xff,0xff,0x00,0x00,0x80,0xcc]
+vfadd.s %vix, %vix, %vix
+
+# CHECK-INST: pvfadd.lo %vix, 22, %v22
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0xff,0x00,0x16,0x60,0xcc]
+pvfadd.lo %vix, 22, %v22
+
+# CHECK-INST: vfadd.up %v11, 63, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0x0b,0x00,0x3f,0xab,0xcc]
+pvfadd.up %v11, 63, %v22, %vm11
+
+# CHECK-INST: vfadd.up %v11, %vix, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x16,0xff,0x0b,0x00,0x00,0x8b,0xcc]
+pvfadd.up %v11, %vix, %v22, %vm11
+
+# CHECK-INST: pvfadd %v12, %v20, %v22, %vm12
+# CHECK-ENCODING: encoding: [0x00,0x16,0x14,0x0c,0x00,0x00,0xcc,0xcc]
+pvfadd %v12, %v20, %v22, %vm12

llvm/test/MC/VE/VFCM.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vfmax.d %v11, %s20, %v22
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0x0b,0x00,0x94,0x20,0xbd]
+vfmax.d %v11, %s20, %v22
+
+# CHECK-INST: pvfmax.up %vix, %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0xff,0xff,0xff,0x00,0x00,0x80,0xbd]
+vfmax.s %vix, %vix, %vix
+
+# CHECK-INST: pvfmax.lo %vix, 22, %v22
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0xff,0x00,0x16,0x60,0xbd]
+pvfmax.lo %vix, 22, %v22
+
+# CHECK-INST: pvfmax.up %v11, 63, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0x0b,0x00,0x3f,0xab,0xbd]
+pvfmax.up %v11, 63, %v22, %vm11
+
+# CHECK-INST: pvfmax.up %v11, %vix, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x16,0xff,0x0b,0x00,0x00,0x8b,0xbd]
+pvfmax.up %v11, %vix, %v22, %vm11
+
+# CHECK-INST: pvfmax %v12, %v20, %v22, %vm12
+# CHECK-ENCODING: encoding: [0x00,0x16,0x14,0x0c,0x00,0x00,0xcc,0xbd]
+pvfmax %v12, %v20, %v22, %vm12
+
+# CHECK-INST: vfmin.d %v11, %s20, %v22
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0x0b,0x00,0x94,0x30,0xbd]
+vfmin.d %v11, %s20, %v22
+
+# CHECK-INST: pvfmin.up %vix, %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0xff,0xff,0xff,0x00,0x00,0x90,0xbd]
+vfmin.s %vix, %vix, %vix
+
+# CHECK-INST: pvfmin.lo %vix, 22, %v22
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0xff,0x00,0x16,0x70,0xbd]
+pvfmin.lo %vix, 22, %v22
+
+# CHECK-INST: pvfmin.up %v11, 63, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0x0b,0x00,0x3f,0xbb,0xbd]
+pvfmin.up %v11, 63, %v22, %vm11
+
+# CHECK-INST: pvfmin.up %v11, %vix, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x16,0xff,0x0b,0x00,0x00,0x9b,0xbd]
+pvfmin.up %v11, %vix, %v22, %vm11
+
+# CHECK-INST: pvfmin %v12, %v20, %v22, %vm12
+# CHECK-ENCODING: encoding: [0x00,0x16,0x14,0x0c,0x00,0x00,0xdc,0xbd]
+pvfmin %v12, %v20, %v22, %vm12

llvm/test/MC/VE/VFCP.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vfcmp.d %v11, %s20, %v22
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0x0b,0x00,0x94,0x20,0xfc]
+vfcmp.d %v11, %s20, %v22
+
+# CHECK-INST: pvfcmp.up %vix, %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0xff,0xff,0xff,0x00,0x00,0x80,0xfc]
+vfcmp.s %vix, %vix, %vix
+
+# CHECK-INST: pvfcmp.lo %vix, 22, %v22
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0xff,0x00,0x16,0x60,0xfc]
+pvfcmp.lo %vix, 22, %v22
+
+# CHECK-INST: pvfcmp.up %v11, 63, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0x0b,0x00,0x3f,0xab,0xfc]
+pvfcmp.up %v11, 63, %v22, %vm11
+
+# CHECK-INST: pvfcmp.up %v11, %vix, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x16,0xff,0x0b,0x00,0x00,0x8b,0xfc]
+pvfcmp.up %v11, %vix, %v22, %vm11
+
+# CHECK-INST: pvfcmp %v12, %v20, %v22, %vm12
+# CHECK-ENCODING: encoding: [0x00,0x16,0x14,0x0c,0x00,0x00,0xcc,0xfc]
+pvfcmp %v12, %v20, %v22, %vm12

llvm/test/MC/VE/VFDV.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vfdiv.d %v11, %s20, %v22
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0x0b,0x00,0x94,0x20,0xdd]
+vfdiv.d %v11, %s20, %v22
+
+# CHECK-INST: vfdiv.d %vix, %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0xff,0xff,0xff,0x00,0x00,0x00,0xdd]
+vfdiv.d %vix, %vix, %vix
+
+# CHECK-INST: vfdiv.s %vix, 22, %v22
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0xff,0x00,0x16,0xa0,0xdd]
+vfdiv.s %vix, 22, %v22
+
+# CHECK-INST: vfdiv.s %vix, %v22, 22
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0xff,0x00,0x16,0x90,0xdd]
+vfdiv.s %vix, %v22, 22
+
+# CHECK-INST: vfdiv.s %v11, %v22, 63, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0x0b,0x00,0x3f,0x9b,0xdd]
+vfdiv.s %v11, %v22, 63, %vm11

llvm/test/MC/VE/VFIX.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vcvt.w.d.sx %v11, %v12
+# CHECK-ENCODING: encoding: [0x00,0x00,0x0c,0x0b,0x00,0x00,0x00,0xe8]
+vcvt.w.d.sx %v11, %v12
+
+# CHECK-INST: vcvt.w.d.zx.rz %v11, %vix, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x08,0xff,0x0b,0x00,0x00,0x4b,0xe8]
+vcvt.w.d.zx.rz %v11, %vix, %vm11
+
+# CHECK-INST: vcvt.w.s.sx.rp %vix, %v22, %vm15
+# CHECK-ENCODING: encoding: [0x00,0x09,0x16,0xff,0x00,0x00,0x8f,0xe8]
+vcvt.w.s.sx.rp %vix, %v22, %vm15
+
+# CHECK-INST: vcvt.w.s.zx.rm %v63, %v60, %vm2
+# CHECK-ENCODING: encoding: [0x00,0x0a,0x3c,0x3f,0x00,0x00,0xc2,0xe8]
+vcvt.w.s.zx.rm %v63, %v60, %vm2
+
+# CHECK-INST: pvcvt.w.s.lo.rn %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0x0b,0xff,0xff,0x00,0x00,0x50,0xe8]
+pvcvt.w.s.lo.rn %vix, %vix, %vm0
+
+# CHECK-INST: pvcvt.w.s.up.ra %vix, %vix, %vm2
+# CHECK-ENCODING: encoding: [0x00,0x0c,0xff,0xff,0x00,0x00,0x92,0xe8]
+pvcvt.w.s.up.ra %vix, %vix, %vm2
+
+# CHECK-INST: pvcvt.w.s %vix, %vix, %vm2
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0xff,0x00,0x00,0xd2,0xe8]
+pvcvt.w.s %vix, %vix, %vm2

llvm/test/MC/VE/VFIXX.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vcvt.l.d %v11, %v12
+# CHECK-ENCODING: encoding: [0x00,0x00,0x0c,0x0b,0x00,0x00,0x00,0xa8]
+vcvt.l.d %v11, %v12
+
+# CHECK-INST: vcvt.l.d.rz %v11, %vix, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x08,0xff,0x0b,0x00,0x00,0x0b,0xa8]
+vcvt.l.d.rz %v11, %vix, %vm11
+
+# CHECK-INST: vcvt.l.d.rp %vix, %v22, %vm15
+# CHECK-ENCODING: encoding: [0x00,0x09,0x16,0xff,0x00,0x00,0x0f,0xa8]
+vcvt.l.d.rp %vix, %v22, %vm15
+
+# CHECK-INST: vcvt.l.d.rm %v63, %v60, %vm2
+# CHECK-ENCODING: encoding: [0x00,0x0a,0x3c,0x3f,0x00,0x00,0x02,0xa8]
+vcvt.l.d.rm %v63, %v60, %vm2
+
+# CHECK-INST: vcvt.l.d.rn %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0x0b,0xff,0xff,0x00,0x00,0x00,0xa8]
+vcvt.l.d.rn %vix, %vix, %vm0
+
+# CHECK-INST: vcvt.l.d.ra %vix, %vix, %vm2
+# CHECK-ENCODING: encoding: [0x00,0x0c,0xff,0xff,0x00,0x00,0x02,0xa8]
+vcvt.l.d.ra %vix, %vix, %vm2

llvm/test/MC/VE/VFLT.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vcvt.d.w %v11, %v12
+# CHECK-ENCODING: encoding: [0x00,0x00,0x0c,0x0b,0x00,0x00,0x00,0xf8]
+vcvt.d.w %v11, %v12
+
+# CHECK-INST: vcvt.s.w %v11, %vix, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0x0b,0x00,0x00,0x8b,0xf8]
+vcvt.s.w %v11, %vix, %vm11
+
+# CHECK-INST: pvcvt.s.w.lo %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0xff,0x00,0x00,0x50,0xf8]
+pvcvt.s.w.lo %vix, %vix, %vm0
+
+# CHECK-INST: pvcvt.s.w.up %vix, %vix, %vm2
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0xff,0x00,0x00,0x92,0xf8]
+pvcvt.s.w.up %vix, %vix, %vm2
+
+# CHECK-INST: pvcvt.s.w %vix, %vix, %vm2
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0xff,0x00,0x00,0xd2,0xf8]
+pvcvt.s.w %vix, %vix, %vm2

llvm/test/MC/VE/VFLTX.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vcvt.d.l %v11, %v12
+# CHECK-ENCODING: encoding: [0x00,0x00,0x0c,0x0b,0x00,0x00,0x00,0xb8]
+vcvt.d.l %v11, %v12
+
+# CHECK-INST: vcvt.d.l %v11, %vix, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0x0b,0x00,0x00,0x0b,0xb8]
+vcvt.d.l %v11, %vix, %vm11
+
+# CHECK-INST: vcvt.d.l %vix, %v22, %vm15
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0xff,0x00,0x00,0x0f,0xb8]
+vcvt.d.l %vix, %v22, %vm15
+
+# CHECK-INST: vcvt.d.l %v63, %v60, %vm2
+# CHECK-ENCODING: encoding: [0x00,0x00,0x3c,0x3f,0x00,0x00,0x02,0xb8]
+vcvt.d.l %v63, %v60, %vm2
+
+# CHECK-INST: vcvt.d.l %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0xff,0x00,0x00,0x00,0xb8]
+vcvt.d.l %vix, %vix, %vm0
+
+# CHECK-INST: vcvt.d.l %vix, %vix, %vm2
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0xff,0x00,0x00,0x02,0xb8]
+vcvt.d.l %vix, %vix, %vm2

llvm/test/MC/VE/VFMAD.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vfmad.d %v11, %s20, %v22, %v21
+# CHECK-ENCODING: encoding: [0x15,0x16,0x00,0x0b,0x00,0x94,0x20,0xe2]
+vfmad.d %v11, %s20, %v22, %v21
+
+# CHECK-INST: pvfmad.up %vix, %vix, %vix, %v21
+# CHECK-ENCODING: encoding: [0x15,0xff,0xff,0xff,0x00,0x00,0x80,0xe2]
+vfmad.s %vix, %vix, %vix, %v21
+
+# CHECK-INST: pvfmad.lo %vix, 22, %v22, %vix
+# CHECK-ENCODING: encoding: [0xff,0x16,0x00,0xff,0x00,0x16,0x60,0xe2]
+pvfmad.lo %vix, 22, %v22, %vix
+
+# CHECK-INST: pvfmad.up %vix, %v22, 22, %vix
+# CHECK-ENCODING: encoding: [0xff,0x00,0x16,0xff,0x00,0x16,0x90,0xe2]
+pvfmad.up %vix, %v22, 22, %vix
+
+# CHECK-INST: pvfmad %v11, %v22, 63, %v20, %vm12
+# CHECK-ENCODING: encoding: [0x14,0x00,0x16,0x0b,0x00,0x3f,0xdc,0xe2]
+pvfmad %v11, %v22, 63, %v20, %vm12

llvm/test/MC/VE/VFMP.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vfmul.d %v11, %s20, %v22
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0x0b,0x00,0x94,0x20,0xcd]
+vfmul.d %v11, %s20, %v22
+
+# CHECK-INST: pvfmul.up %vix, %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0xff,0xff,0xff,0x00,0x00,0x80,0xcd]
+vfmul.s %vix, %vix, %vix
+
+# CHECK-INST: pvfmul.lo %vix, 22, %v22
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0xff,0x00,0x16,0x60,0xcd]
+pvfmul.lo %vix, 22, %v22
+
+# CHECK-INST: pvfmul.up %v11, 63, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0x0b,0x00,0x3f,0xab,0xcd]
+pvfmul.up %v11, 63, %v22, %vm11
+
+# CHECK-INST: pvfmul.up %v11, %vix, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x16,0xff,0x0b,0x00,0x00,0x8b,0xcd]
+pvfmul.up %v11, %vix, %v22, %vm11
+
+# CHECK-INST: pvfmul %v12, %v20, %v22, %vm12
+# CHECK-ENCODING: encoding: [0x00,0x16,0x14,0x0c,0x00,0x00,0xcc,0xcd]
+pvfmul %v12, %v20, %v22, %vm12

llvm/test/MC/VE/VFMSB.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vfmsb.d %v11, %s20, %v22, %v21
+# CHECK-ENCODING: encoding: [0x15,0x16,0x00,0x0b,0x00,0x94,0x20,0xf2]
+vfmsb.d %v11, %s20, %v22, %v21
+
+# CHECK-INST: pvfmsb.up %vix, %vix, %vix, %v21
+# CHECK-ENCODING: encoding: [0x15,0xff,0xff,0xff,0x00,0x00,0x80,0xf2]
+vfmsb.s %vix, %vix, %vix, %v21
+
+# CHECK-INST: pvfmsb.lo %vix, 22, %v22, %vix
+# CHECK-ENCODING: encoding: [0xff,0x16,0x00,0xff,0x00,0x16,0x60,0xf2]
+pvfmsb.lo %vix, 22, %v22, %vix
+
+# CHECK-INST: pvfmsb.up %vix, %v22, 22, %vix
+# CHECK-ENCODING: encoding: [0xff,0x00,0x16,0xff,0x00,0x16,0x90,0xf2]
+pvfmsb.up %vix, %v22, 22, %vix
+
+# CHECK-INST: pvfmsb %v11, %v22, 63, %v20, %vm12
+# CHECK-ENCODING: encoding: [0x14,0x00,0x16,0x0b,0x00,0x3f,0xdc,0xf2]
+pvfmsb %v11, %v22, 63, %v20, %vm12

llvm/test/MC/VE/VFNMAD.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vfnmad.d %v11, %s20, %v22, %v21
+# CHECK-ENCODING: encoding: [0x15,0x16,0x00,0x0b,0x00,0x94,0x20,0xe3]
+vfnmad.d %v11, %s20, %v22, %v21
+
+# CHECK-INST: pvfnmad.up %vix, %vix, %vix, %v21
+# CHECK-ENCODING: encoding: [0x15,0xff,0xff,0xff,0x00,0x00,0x80,0xe3]
+vfnmad.s %vix, %vix, %vix, %v21
+
+# CHECK-INST: pvfnmad.lo %vix, 22, %v22, %vix
+# CHECK-ENCODING: encoding: [0xff,0x16,0x00,0xff,0x00,0x16,0x60,0xe3]
+pvfnmad.lo %vix, 22, %v22, %vix
+
+# CHECK-INST: pvfnmad.up %vix, %v22, 22, %vix
+# CHECK-ENCODING: encoding: [0xff,0x00,0x16,0xff,0x00,0x16,0x90,0xe3]
+pvfnmad.up %vix, %v22, 22, %vix
+
+# CHECK-INST: pvfnmad %v11, %v22, 63, %v20, %vm12
+# CHECK-ENCODING: encoding: [0x14,0x00,0x16,0x0b,0x00,0x3f,0xdc,0xe3]
+pvfnmad %v11, %v22, 63, %v20, %vm12

llvm/test/MC/VE/VFNMSB.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vfnmsb.d %v11, %s20, %v22, %v21
+# CHECK-ENCODING: encoding: [0x15,0x16,0x00,0x0b,0x00,0x94,0x20,0xf3]
+vfnmsb.d %v11, %s20, %v22, %v21
+
+# CHECK-INST: pvfnmsb.up %vix, %vix, %vix, %v21
+# CHECK-ENCODING: encoding: [0x15,0xff,0xff,0xff,0x00,0x00,0x80,0xf3]
+vfnmsb.s %vix, %vix, %vix, %v21
+
+# CHECK-INST: pvfnmsb.lo %vix, 22, %v22, %vix
+# CHECK-ENCODING: encoding: [0xff,0x16,0x00,0xff,0x00,0x16,0x60,0xf3]
+pvfnmsb.lo %vix, 22, %v22, %vix
+
+# CHECK-INST: pvfnmsb.up %vix, %v22, 22, %vix
+# CHECK-ENCODING: encoding: [0xff,0x00,0x16,0xff,0x00,0x16,0x90,0xf3]
+pvfnmsb.up %vix, %v22, 22, %vix
+
+# CHECK-INST: pvfnmsb %v11, %v22, 63, %v20, %vm12
+# CHECK-ENCODING: encoding: [0x14,0x00,0x16,0x0b,0x00,0x3f,0xdc,0xf3]
+pvfnmsb %v11, %v22, 63, %v20, %vm12

llvm/test/MC/VE/VFSB.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vfsub.d %v11, %s20, %v22
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0x0b,0x00,0x94,0x20,0xdc]
+vfsub.d %v11, %s20, %v22
+
+# CHECK-INST: pvfsub.up %vix, %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0xff,0xff,0xff,0x00,0x00,0x80,0xdc]
+vfsub.s %vix, %vix, %vix
+
+# CHECK-INST: pvfsub.lo %vix, 22, %v22
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0xff,0x00,0x16,0x60,0xdc]
+pvfsub.lo %vix, 22, %v22
+
+# CHECK-INST: pvfsub.up %v11, 63, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x16,0x00,0x0b,0x00,0x3f,0xab,0xdc]
+pvfsub.up %v11, 63, %v22, %vm11
+
+# CHECK-INST: pvfsub.up %v11, %vix, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x16,0xff,0x0b,0x00,0x00,0x8b,0xdc]
+pvfsub.up %v11, %vix, %v22, %vm11
+
+# CHECK-INST: pvfsub %v12, %v20, %v22, %vm12
+# CHECK-ENCODING: encoding: [0x00,0x16,0x14,0x0c,0x00,0x00,0xcc,0xdc]
+pvfsub %v12, %v20, %v22, %vm12

llvm/test/MC/VE/VFSQRT.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vfsqrt.d %v11, %v22
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0x0b,0x00,0x00,0x00,0xed]
+vfsqrt.d %v11, %v22
+
+# CHECK-INST: vfsqrt.d %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0xff,0x00,0x00,0x00,0xed]
+vfsqrt.d %vix, %vix
+
+# CHECK-INST: vfsqrt.s %vix, %v22
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0xff,0x00,0x00,0x80,0xed]
+vfsqrt.s %vix, %v22
+
+# CHECK-INST: vfsqrt.s %v11, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0x0b,0x00,0x00,0x8b,0xed]
+vfsqrt.s %v11, %v22, %vm11
+
+# CHECK-INST: vfsqrt.s %v11, %vix, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0x0b,0x00,0x00,0x8b,0xed]
+vfsqrt.s %v11, %vix, %vm11
+
+# CHECK-INST: vfsqrt.s %v12, %v20, %vm12
+# CHECK-ENCODING: encoding: [0x00,0x00,0x14,0x0c,0x00,0x00,0x8c,0xed]
+vfsqrt.s %v12, %v20, %vm12

llvm/test/MC/VE/VRCP.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vrcp.d %v11, %v22
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0x0b,0x00,0x00,0x00,0xe1]
+vrcp.d %v11, %v22
+
+# CHECK-INST: pvrcp.up %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0xff,0x00,0x00,0x80,0xe1]
+vrcp.s %vix, %vix
+
+# CHECK-INST: pvrcp.lo %vix, %v22
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0xff,0x00,0x00,0x40,0xe1]
+pvrcp.lo %vix, %v22
+
+# CHECK-INST: pvrcp.up %v11, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0x0b,0x00,0x00,0x8b,0xe1]
+pvrcp.up %v11, %v22, %vm11
+
+# CHECK-INST: pvrcp.up %v11, %vix, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0x0b,0x00,0x00,0x8b,0xe1]
+pvrcp.up %v11, %vix, %vm11
+
+# CHECK-INST: pvrcp %v12, %v20, %vm12
+# CHECK-ENCODING: encoding: [0x00,0x00,0x14,0x0c,0x00,0x00,0xcc,0xe1]
+pvrcp %v12, %v20, %vm12

llvm/test/MC/VE/VRSQRT.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vrsqrt.d %v11, %v22
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0x0b,0x00,0x00,0x00,0xf1]
+vrsqrt.d %v11, %v22
+
+# CHECK-INST: pvrsqrt.up %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0xff,0x00,0x00,0x80,0xf1]
+vrsqrt.s %vix, %vix
+
+# CHECK-INST: pvrsqrt.lo %vix, %v22
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0xff,0x00,0x00,0x40,0xf1]
+pvrsqrt.lo %vix, %v22
+
+# CHECK-INST: pvrsqrt.up %v11, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0x0b,0x00,0x00,0x8b,0xf1]
+pvrsqrt.up %v11, %v22, %vm11
+
+# CHECK-INST: pvrsqrt.up %v11, %vix, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0x0b,0x00,0x00,0x8b,0xf1]
+pvrsqrt.up %v11, %vix, %vm11
+
+# CHECK-INST: pvrsqrt %v12, %v20, %vm12
+# CHECK-ENCODING: encoding: [0x00,0x00,0x14,0x0c,0x00,0x00,0xcc,0xf1]
+pvrsqrt %v12, %v20, %vm12

llvm/test/MC/VE/VRSQRTNEX.s

+# RUN: llvm-mc -triple=ve --show-encoding < %s \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=ve -filetype=obj < %s | llvm-objdump -d - \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-INST
+
+# CHECK-INST: vrsqrt.d.nex %v11, %v22
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0x0b,0x00,0x00,0x10,0xf1]
+vrsqrt.d.nex %v11, %v22
+
+# CHECK-INST: pvrsqrt.up.nex %vix, %vix
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0xff,0x00,0x00,0x90,0xf1]
+vrsqrt.s.nex %vix, %vix
+
+# CHECK-INST: pvrsqrt.lo.nex %vix, %v22
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0xff,0x00,0x00,0x50,0xf1]
+pvrsqrt.lo.nex %vix, %v22
+
+# CHECK-INST: pvrsqrt.up.nex %v11, %v22, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x00,0x16,0x0b,0x00,0x00,0x9b,0xf1]
+pvrsqrt.up.nex %v11, %v22, %vm11
+
+# CHECK-INST: pvrsqrt.up.nex %v11, %vix, %vm11
+# CHECK-ENCODING: encoding: [0x00,0x00,0xff,0x0b,0x00,0x00,0x9b,0xf1]
+pvrsqrt.up.nex %v11, %vix, %vm11
+
+# CHECK-INST: pvrsqrt.nex %v12, %v20, %vm12
+# CHECK-ENCODING: encoding: [0x00,0x00,0x14,0x0c,0x00,0x00,0xdc,0xf1]
+pvrsqrt.nex %v12, %v20, %vm12