1511 lines
61 KiB
TableGen
1511 lines
61 KiB
TableGen
//===----------------------------------------------------------------------===//
|
|
// Vector Instructions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Pseudo instructions for VM512 modifications
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// LVM/SVM instructions using VM512
|
|
let hasSideEffects = 0, isCodeGenOnly = 1 in {
|
|
let Constraints = "$vx = $vd", DisableEncoding = "$vd" in {
|
|
def LVMyir_y : Pseudo<(outs VM512:$vx), (ins uimm3:$sy, I64:$sz, VM512:$vd),
|
|
"# pseudo LVM $vx, $sy, $sz, $vd">;
|
|
def LVMyim_y : Pseudo<(outs VM512:$vx),
|
|
(ins uimm3:$sy, mimm:$sz, VM512:$vd),
|
|
"# pseudo LVM $vx, $sy, $sz, $vd">;
|
|
}
|
|
def LVMyir : Pseudo<(outs VM512:$vx), (ins uimm3:$sy, I64:$sz),
|
|
"# pseudo LVM $vx, $sy, $sz">;
|
|
def LVMyim : Pseudo<(outs VM512:$vx), (ins uimm3:$sy, mimm:$sz),
|
|
"# pseudo LVM $vx, $sy, $sz">;
|
|
def SVMyi : Pseudo<(outs I64:$sx), (ins VM512:$vz, uimm3:$sy),
|
|
"# pseudo SVM $sx, $vz, $sy">;
|
|
}
|
|
|
|
// VFMK/VFMKW/VFMKS instructions using VM512
|
|
let hasSideEffects = 0, isCodeGenOnly = 1, DisableEncoding = "$vl" in {
|
|
def VFMKyal : Pseudo<(outs VM512:$vmx), (ins I32:$vl),
|
|
"# pseudo-vfmk.at $vmx">;
|
|
def VFMKynal : Pseudo<(outs VM512:$vmx), (ins I32:$vl),
|
|
"# pseudo-vfmk.af $vmx">;
|
|
def VFMKWyvl : Pseudo<(outs VM512:$vmx),
|
|
(ins CCOp:$cf, V64:$vz, I32:$vl),
|
|
"# pseudo-vfmk.w.$cf $vmx, $vz">;
|
|
def VFMKWyvyl : Pseudo<(outs VM512:$vmx),
|
|
(ins CCOp:$cf, V64:$vz, VM512:$vm, I32:$vl),
|
|
"# pseudo-vfmk.w.$cf $vmx, $vz, $vm">;
|
|
def VFMKSyvl : Pseudo<(outs VM512:$vmx),
|
|
(ins CCOp:$cf, V64:$vz, I32:$vl),
|
|
"# pseudo-vfmk.s.$cf $vmx, $vz">;
|
|
def VFMKSyvyl : Pseudo<(outs VM512:$vmx),
|
|
(ins CCOp:$cf, V64:$vz, VM512:$vm, I32:$vl),
|
|
"# pseudo-vfmk.s.$cf $vmx, $vz, $vm">;
|
|
}
|
|
|
|
// ANDM/ORM/XORM/EQVM/NNDM/NEGM instructions using VM512
|
|
let hasSideEffects = 0, isCodeGenOnly = 1 in {
|
|
def ANDMyy : Pseudo<(outs VM512:$vmx), (ins VM512:$vmy, VM512:$vmz),
|
|
"# andm $vmx, $vmy, $vmz">;
|
|
def ORMyy : Pseudo<(outs VM512:$vmx), (ins VM512:$vmy, VM512:$vmz),
|
|
"# orm $vmx, $vmy, $vmz">;
|
|
def XORMyy : Pseudo<(outs VM512:$vmx), (ins VM512:$vmy, VM512:$vmz),
|
|
"# xorm $vmx, $vmy, $vmz">;
|
|
def EQVMyy : Pseudo<(outs VM512:$vmx), (ins VM512:$vmy, VM512:$vmz),
|
|
"# eqvm $vmx, $vmy, $vmz">;
|
|
def NNDMyy : Pseudo<(outs VM512:$vmx), (ins VM512:$vmy, VM512:$vmz),
|
|
"# nndm $vmx, $vmy, $vmz">;
|
|
def NEGMy : Pseudo<(outs VM512:$vmx), (ins VM512:$vmy),
|
|
"# negm $vmx, $vmy">;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Instructions
|
|
//
|
|
// Define all vector instructions defined in SX-Aurora TSUBASA Architecture
|
|
// Guide here. As those mnemonics, we use mnemonics defined in Vector Engine
|
|
// Assembly Language Reference Manual.
|
|
//
|
|
// Some instructions can update existing data by following instructions
|
|
// sequence.
|
|
//
|
|
// lea %s0, 256
|
|
// lea %s1, 128
|
|
// lvl %s0
|
|
// vbrd %v0, 2 # v0 = { 2, 2, 2, ..., 2, 2, 2 }
|
|
// lvl %s1
|
|
// vbrd %v0, 3 # v0 = { 3, 3, 3, ..., 3, 2, 2, 2, ..., 2, 2, 2 }
|
|
//
|
|
// In order to represent above with a virtual register, we defines instructions
|
|
// with an additional base register and `_v` suffiex in mnemonic.
|
|
//
|
|
// lea t0, 256
|
|
// lea t1, 128
|
|
// lea t0
|
|
// vbrd tv0, 2
|
|
// lvl t1
|
|
// vbrd_v tv1, 2, tv0
|
|
//
|
|
// We also have some instructions uses VL register with an pseudo VL value
|
|
// with following suffixes in mnemonic.
|
|
//
|
|
// l: have an additional I32 register to represent the VL value.
|
|
// L: have an additional VL register to represent the VL value.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Section 8.9 - Vector Load/Store and Move Instructions
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Multiclass for VLD instructions
|
|
let mayLoad = 1, hasSideEffects = 0, Uses = [VL] in
|
|
multiclass VLDbm<string opcStr, bits<8>opc, RegisterClass RC, dag dag_in,
|
|
string disEnc = ""> {
|
|
let DisableEncoding = disEnc in
|
|
def "" : RVM<opc, (outs RC:$vx), dag_in,
|
|
!strconcat(opcStr, " $vx, $sy, $sz")>;
|
|
let Constraints = "$vx = $base", DisableEncoding = disEnc#"$base",
|
|
isCodeGenOnly = 1 in
|
|
def _v : RVM<opc, (outs RC:$vx), !con(dag_in, (ins RC:$base)),
|
|
!strconcat(opcStr, " $vx, $sy, $sz")>;
|
|
}
|
|
multiclass VLDlm<string opcStr, bits<8>opc, RegisterClass RC, dag dag_in> {
|
|
defm "" : VLDbm<opcStr, opc, RC, dag_in>;
|
|
let isCodeGenOnly = 1, VE_VLInUse = 1 in {
|
|
defm l : VLDbm<opcStr, opc, RC, !con(dag_in, (ins I32:$vl)), "$vl,">;
|
|
defm L : VLDbm<opcStr, opc, RC, !con(dag_in, (ins VLS:$vl)), "$vl,">;
|
|
}
|
|
}
|
|
let VE_VLIndex = 3 in
|
|
multiclass VLDtgm<string opcStr, bits<8>opc, RegisterClass RC> {
|
|
defm rr : VLDlm<opcStr, opc, RC, (ins I64:$sy, I64:$sz)>;
|
|
let cy = 0 in
|
|
defm ir : VLDlm<opcStr, opc, RC, (ins simm7:$sy, I64:$sz)>;
|
|
let cz = 0 in
|
|
defm rz : VLDlm<opcStr, opc, RC, (ins I64:$sy, zero:$sz)>;
|
|
let cy = 0, cz = 0 in
|
|
defm iz : VLDlm<opcStr, opc, RC, (ins simm7:$sy, zero:$sz)>;
|
|
}
|
|
multiclass VLDm<string opcStr, bits<8>opc, RegisterClass RC> {
|
|
let vc = 1 in defm "" : VLDtgm<opcStr, opc, RC>;
|
|
let vc = 0 in defm NC : VLDtgm<opcStr#".nc", opc, RC>;
|
|
}
|
|
|
|
// Section 8.9.1 - VLD (Vector Load)
|
|
defm VLD : VLDm<"vld", 0x81, V64>;
|
|
|
|
// Section 8.9.2 - VLDU (Vector Load Upper)
|
|
defm VLDU : VLDm<"vldu", 0x82, V64>;
|
|
|
|
// Section 8.9.3 - VLDL (Vector Load Lower)
|
|
defm VLDLSX : VLDm<"vldl.sx", 0x83, V64>;
|
|
let cx = 1 in defm VLDLZX : VLDm<"vldl.zx", 0x83, V64>;
|
|
|
|
// Section 8.9.4 - VLD2D (Vector Load 2D)
|
|
defm VLD2D : VLDm<"vld2d", 0xc1, V64>;
|
|
|
|
// Section 8.9.5 - VLDU2D (Vector Load Upper 2D)
|
|
defm VLDU2D : VLDm<"vldu2d", 0xc2, V64>;
|
|
|
|
// Section 8.9.6 - VLDL2D (Vector Load Lower 2D)
|
|
defm VLDL2DSX : VLDm<"vldl2d.sx", 0xc3, V64>;
|
|
let cx = 1 in defm VLDL2DZX : VLDm<"vldl2d.zx", 0xc3, V64>;
|
|
|
|
// Multiclass for VST instructions
|
|
let mayStore = 1, hasSideEffects = 0, Uses = [VL] in
|
|
multiclass VSTbm<string opcStr, string argStr, bits<8>opc, dag dag_in> {
|
|
def "" : RVM<opc, (outs), dag_in, !strconcat(opcStr, argStr)>;
|
|
let DisableEncoding = "$vl", isCodeGenOnly = 1, VE_VLInUse = 1 in {
|
|
def l : RVM<opc, (outs), !con(dag_in, (ins I32:$vl)),
|
|
!strconcat(opcStr, argStr)>;
|
|
def L : RVM<opc, (outs), !con(dag_in, (ins VLS:$vl)),
|
|
!strconcat(opcStr, argStr)>;
|
|
}
|
|
}
|
|
multiclass VSTmm<string opcStr, bits<8>opc, dag dag_in> {
|
|
defm "" : VSTbm<opcStr, " $vx, $sy, $sz", opc, dag_in>;
|
|
let m = ?, VE_VLWithMask = 1 in
|
|
defm m : VSTbm<opcStr, " $vx, $sy, $sz, $m", opc, !con(dag_in, (ins VM:$m))>;
|
|
}
|
|
let VE_VLIndex = 3 in
|
|
multiclass VSTtgm<string opcStr, bits<8>opc, RegisterClass RC> {
|
|
defm rrv : VSTmm<opcStr, opc, (ins I64:$sy, I64:$sz, RC:$vx)>;
|
|
let cy = 0 in
|
|
defm irv : VSTmm<opcStr, opc, (ins simm7:$sy, I64:$sz, RC:$vx)>;
|
|
let cz = 0 in
|
|
defm rzv : VSTmm<opcStr, opc, (ins I64:$sy, zero:$sz, RC:$vx)>;
|
|
let cy = 0, cz = 0 in
|
|
defm izv : VSTmm<opcStr, opc, (ins simm7:$sy, zero:$sz, RC:$vx)>;
|
|
}
|
|
multiclass VSTm<string opcStr, bits<8>opc, RegisterClass RC> {
|
|
let vc = 1, cx = 0 in defm "" : VSTtgm<opcStr, opc, RC>;
|
|
let vc = 0, cx = 0 in defm NC : VSTtgm<opcStr#".nc", opc, RC>;
|
|
let vc = 1, cx = 1 in defm OT : VSTtgm<opcStr#".ot", opc, RC>;
|
|
let vc = 0, cx = 1 in defm NCOT : VSTtgm<opcStr#".nc.ot", opc, RC>;
|
|
}
|
|
|
|
// Section 8.9.7 - VST (Vector Store)
|
|
defm VST : VSTm<"vst", 0x91, V64>;
|
|
|
|
// Section 8.9.8 - VST (Vector Store Upper)
|
|
defm VSTU : VSTm<"vstu", 0x92, V64>;
|
|
|
|
// Section 8.9.9 - VSTL (Vector Store Lower)
|
|
defm VSTL : VSTm<"vstl", 0x93, V64>;
|
|
|
|
// Section 8.9.10 - VST2D (Vector Store 2D)
|
|
defm VST2D : VSTm<"vst2d", 0xd1, V64>;
|
|
|
|
// Section 8.9.11 - VSTU2D (Vector Store Upper 2D)
|
|
defm VSTU2D : VSTm<"vstu2d", 0xd2, V64>;
|
|
|
|
// Section 8.9.12 - VSTL2D (Vector Store Lower 2D)
|
|
defm VSTL2D : VSTm<"vstl2d", 0xd3, V64>;
|
|
|
|
// Multiclass for VGT instructions
|
|
let mayLoad = 1, hasSideEffects = 0, Uses = [VL] in
|
|
multiclass VGTbm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
dag dag_in, string disEnc = ""> {
|
|
let DisableEncoding = disEnc in
|
|
def "" : RVM<opc, (outs RC:$vx), dag_in,
|
|
!strconcat(opcStr, " $vx, ", argStr)>;
|
|
let Constraints = "$vx = $base", DisableEncoding = disEnc#"$base",
|
|
isCodeGenOnly = 1 in
|
|
def _v : RVM<opc, (outs RC:$vx), !con(dag_in, (ins RC:$base)),
|
|
!strconcat(opcStr, " $vx, ", argStr)>;
|
|
}
|
|
multiclass VGTlm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
dag dag_in> {
|
|
defm "" : VGTbm<opcStr, argStr, opc, RC, dag_in>;
|
|
let isCodeGenOnly = 1, VE_VLInUse = 1 in {
|
|
defm l : VGTbm<opcStr, argStr, opc, RC, !con(dag_in, (ins I32:$vl)),
|
|
"$vl,">;
|
|
defm L : VGTbm<opcStr, argStr, opc, RC, !con(dag_in, (ins VLS:$vl)),
|
|
"$vl,">;
|
|
}
|
|
}
|
|
multiclass VGTmm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
dag dag_in> {
|
|
defm "" : VGTlm<opcStr, argStr, opc, RC, dag_in>;
|
|
let m = ?, VE_VLWithMask = 1 in
|
|
defm m : VGTlm<opcStr, argStr#", $m", opc, RC, !con(dag_in, (ins VM:$m))>;
|
|
}
|
|
let VE_VLIndex = 4 in
|
|
multiclass VGTlhm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
dag dag_in> {
|
|
defm rr : VGTmm<opcStr, argStr#", $sy, $sz", opc, RC,
|
|
!con(dag_in, (ins I64:$sy, I64:$sz))>;
|
|
let cy = 0 in
|
|
defm ir : VGTmm<opcStr, argStr#", $sy, $sz", opc, RC,
|
|
!con(dag_in, (ins simm7:$sy, I64:$sz))>;
|
|
let cz = 0 in
|
|
defm rz : VGTmm<opcStr, argStr#", $sy, $sz", opc, RC,
|
|
!con(dag_in, (ins I64:$sy, zero:$sz))>;
|
|
let cy = 0, cz = 0 in
|
|
defm iz : VGTmm<opcStr, argStr#", $sy, $sz", opc, RC,
|
|
!con(dag_in, (ins simm7:$sy, zero:$sz))>;
|
|
}
|
|
multiclass VGTtgm<string opcStr, bits<8>opc, RegisterClass RC> {
|
|
let vy = ? in defm v : VGTlhm<opcStr, "$vy", opc, RC, (ins V64:$vy)>;
|
|
let cs = 1, sw = ? in defm s : VGTlhm<opcStr, "$sw", opc, RC, (ins I64:$sw)>;
|
|
}
|
|
multiclass VGTm<string opcStr, bits<8>opc, RegisterClass RC> {
|
|
let vc = 1 in defm "" : VGTtgm<opcStr, opc, RC>;
|
|
let vc = 0 in defm NC : VGTtgm<opcStr#".nc", opc, RC>;
|
|
}
|
|
|
|
// Section 8.9.13 - VGT (Vector Gather)
|
|
defm VGT : VGTm<"vgt", 0xa1, V64>;
|
|
|
|
// Section 8.9.14 - VGTU (Vector Gather Upper)
|
|
defm VGTU : VGTm<"vgtu", 0xa2, V64>;
|
|
|
|
// Section 8.9.15 - VGTL (Vector Gather Lower)
|
|
defm VGTLSX : VGTm<"vgtl.sx", 0xa3, V64>;
|
|
let cx = 1 in defm VGTLZX : VGTm<"vgtl.zx", 0xa3, V64>;
|
|
def : MnemonicAlias<"vgtl", "vgtl.zx">;
|
|
def : MnemonicAlias<"vgtl.nc", "vgtl.zx.nc">;
|
|
|
|
// Multiclass for VSC instructions
|
|
let mayStore = 1, hasSideEffects = 0, Uses = [VL] in
|
|
multiclass VSCbm<string opcStr, string argStr, bits<8>opc, dag dag_in> {
|
|
def "" : RVM<opc, (outs), dag_in, !strconcat(opcStr, argStr)>;
|
|
let DisableEncoding = "$vl", isCodeGenOnly = 1, VE_VLInUse = 1 in {
|
|
def l : RVM<opc, (outs), !con(dag_in, (ins I32:$vl)),
|
|
!strconcat(opcStr, argStr)>;
|
|
def L : RVM<opc, (outs), !con(dag_in, (ins VLS:$vl)),
|
|
!strconcat(opcStr, argStr)>;
|
|
}
|
|
}
|
|
multiclass VSCmm<string opcStr, string argStr, bits<8>opc, dag dag_in> {
|
|
defm "" : VSCbm<opcStr, argStr, opc, dag_in>;
|
|
let m = ?, VE_VLWithMask = 1 in
|
|
defm m : VSCbm<opcStr, argStr#", $m", opc, !con(dag_in, (ins VM:$m))>;
|
|
}
|
|
let VE_VLIndex = 4 in
|
|
multiclass VSClhm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
dag dag_in> {
|
|
defm rrv : VSCmm<opcStr, " $vx, "#argStr#", $sy, $sz", opc,
|
|
!con(dag_in, (ins I64:$sy, I64:$sz, RC:$vx))>;
|
|
let cy = 0 in
|
|
defm irv : VSCmm<opcStr, " $vx, "#argStr#", $sy, $sz", opc,
|
|
!con(dag_in, (ins simm7:$sy, I64:$sz, RC:$vx))>;
|
|
let cz = 0 in
|
|
defm rzv : VSCmm<opcStr, " $vx, "#argStr#", $sy, $sz", opc,
|
|
!con(dag_in, (ins I64:$sy, zero:$sz, RC:$vx))>;
|
|
let cy = 0, cz = 0 in
|
|
defm izv : VSCmm<opcStr, " $vx, "#argStr#", $sy, $sz", opc,
|
|
!con(dag_in, (ins simm7:$sy, zero:$sz, RC:$vx))>;
|
|
}
|
|
multiclass VSCtgm<string opcStr, bits<8>opc, RegisterClass RC> {
|
|
let vy = ? in defm v : VSClhm<opcStr, "$vy", opc, RC, (ins V64:$vy)>;
|
|
let cs = 1, sw = ? in defm s : VSClhm<opcStr, "$sw", opc, RC, (ins I64:$sw)>;
|
|
}
|
|
multiclass VSCm<string opcStr, bits<8>opc, RegisterClass RC> {
|
|
let vc = 1, cx = 0 in defm "" : VSCtgm<opcStr, opc, RC>;
|
|
let vc = 0, cx = 0 in defm NC : VSCtgm<opcStr#".nc", opc, RC>;
|
|
let vc = 1, cx = 1 in defm OT : VSCtgm<opcStr#".ot", opc, RC>;
|
|
let vc = 0, cx = 1 in defm NCOT : VSCtgm<opcStr#".nc.ot", opc, RC>;
|
|
}
|
|
|
|
// Section 8.9.16 - VSC (Vector Scatter)
|
|
defm VSC : VSCm<"vsc", 0xb1, V64>;
|
|
|
|
// Section 8.9.17 - VSCU (Vector Scatter Upper)
|
|
defm VSCU : VSCm<"vscu", 0xb2, V64>;
|
|
|
|
// Section 8.9.18 - VSCL (Vector Scatter Lower)
|
|
defm VSCL : VSCm<"vscl", 0xb3, V64>;
|
|
|
|
// Section 8.9.19 - PFCHV (Prefetch Vector)
|
|
let Uses = [VL] in
|
|
multiclass PFCHVbm<string opcStr, string argStr, bits<8>opc, dag dag_in> {
|
|
def "" : RVM<opc, (outs), dag_in, !strconcat(opcStr, argStr)>;
|
|
let DisableEncoding = "$vl", isCodeGenOnly = 1, VE_VLInUse = 1 in {
|
|
def l : RVM<opc, (outs), !con(dag_in, (ins I32:$vl)),
|
|
!strconcat(opcStr, argStr)>;
|
|
def L : RVM<opc, (outs), !con(dag_in, (ins VLS:$vl)),
|
|
!strconcat(opcStr, argStr)>;
|
|
}
|
|
}
|
|
let VE_VLIndex = 2 in
|
|
multiclass PFCHVm<string opcStr, bits<8>opc> {
|
|
defm rr : PFCHVbm<opcStr, " $sy, $sz", opc, (ins I64:$sy, I64:$sz)>;
|
|
let cy = 0 in
|
|
defm ir : PFCHVbm<opcStr, " $sy, $sz", opc, (ins simm7:$sy, I64:$sz)>;
|
|
let cz = 0 in
|
|
defm rz : PFCHVbm<opcStr, " $sy, $sz", opc, (ins I64:$sy, zero:$sz)>;
|
|
let cy = 0, cz = 0 in
|
|
defm iz : PFCHVbm<opcStr, " $sy, $sz", opc, (ins simm7:$sy, zero:$sz)>;
|
|
}
|
|
let vc = 1, vx = 0 in defm PFCHV : PFCHVm<"pfchv", 0x80>;
|
|
let vc = 0, vx = 0 in defm PFCHVNC : PFCHVm<"pfchv.nc", 0x80>;
|
|
|
|
// Section 8.9.20 - LSV (Load S to V)
|
|
let sx = 0, vx = ?, hasSideEffects = 0 in
|
|
multiclass LSVbm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
dag dag_in> {
|
|
def "" : RR<opc, (outs RC:$vx), dag_in, !strconcat(opcStr, " ${vx}", argStr)>;
|
|
let Constraints = "$vx = $base", DisableEncoding = "$base",
|
|
isCodeGenOnly = 1 in
|
|
def _v : RR<opc, (outs RC:$vx), !con(dag_in, (ins RC:$base)),
|
|
!strconcat(opcStr, " ${vx}", argStr)>;
|
|
}
|
|
multiclass LSVm<string opcStr, bits<8>opc, RegisterClass RC> {
|
|
defm rr : LSVbm<opcStr, "(${sy}), $sz", opc, RC, (ins I64:$sy, I64:$sz)>;
|
|
let cy = 0 in
|
|
defm ir : LSVbm<opcStr, "(${sy}), $sz", opc, RC, (ins uimm7:$sy, I64:$sz)>;
|
|
let cz = 0 in
|
|
defm rm : LSVbm<opcStr, "(${sy}), $sz", opc, RC, (ins I64:$sy, mimm:$sz)>;
|
|
let cy = 0, cz = 0 in
|
|
defm im : LSVbm<opcStr, "(${sy}), $sz", opc, RC, (ins uimm7:$sy, mimm:$sz)>;
|
|
}
|
|
defm LSV : LSVm<"lsv", 0x8e, V64>;
|
|
|
|
// Section 8.9.21 - LVS (Load V to S)
|
|
let cz = 0, sz = 0, vx = ?, hasSideEffects = 0 in
|
|
multiclass LVSm<string opcStr, bits<8>opc, RegisterClass RC> {
|
|
def vr : RR<opc, (outs I64:$sx), (ins RC:$vx, I64:$sy),
|
|
opcStr#" $sx, ${vx}(${sy})">;
|
|
let cy = 0 in
|
|
def vi : RR<opc, (outs I64:$sx), (ins RC:$vx, uimm7:$sy),
|
|
opcStr#" $sx, ${vx}(${sy})">;
|
|
}
|
|
defm LVS : LVSm<"lvs", 0x9e, V64>;
|
|
|
|
// Section 8.9.22 - LVM (Load VM)
|
|
let sx = 0, vx = ?, hasSideEffects = 0 in
|
|
multiclass LVMbm<string opcStr, string argStr, bits<8>opc, RegisterClass RCM,
|
|
dag dag_in> {
|
|
def "" : RR<opc, (outs RCM:$vx), dag_in,
|
|
!strconcat(opcStr, " $vx, ", argStr)>;
|
|
let Constraints = "$vx = $base", DisableEncoding = "$base",
|
|
isCodeGenOnly = 1 in {
|
|
def _m : RR<opc, (outs RCM:$vx), !con(dag_in, (ins RCM:$base)),
|
|
!strconcat(opcStr, " $vx, ", argStr)>;
|
|
}
|
|
}
|
|
multiclass LVMom<string opcStr, bits<8>opc, RegisterClass RCM> {
|
|
defm rr : LVMbm<opcStr, "$sy, $sz", opc, RCM, (ins I64:$sy, I64:$sz)>;
|
|
let cy = 0 in
|
|
defm ir : LVMbm<opcStr, "$sy, $sz", opc, RCM, (ins uimm2:$sy, I64:$sz)>;
|
|
let cz = 0 in
|
|
defm rm : LVMbm<opcStr, "$sy, $sz", opc, RCM, (ins I64:$sy, mimm:$sz)>;
|
|
let cy = 0, cz = 0 in
|
|
defm im : LVMbm<opcStr, "$sy, $sz", opc, RCM, (ins uimm2:$sy, mimm:$sz)>;
|
|
}
|
|
multiclass LVMm<string opcStr, bits<8>opc, RegisterClass RCM> {
|
|
defm "" : LVMom<opcStr, opc, RCM>;
|
|
}
|
|
defm LVM : LVMm<"lvm", 0xb7, VM>;
|
|
|
|
// Section 8.9.23 - SVM (Save VM)
|
|
let cz = 0, sz = 0, vz = ?, hasSideEffects = 0 in
|
|
multiclass SVMm<string opcStr, bits<8>opc, RegisterClass RCM> {
|
|
def mr : RR<opc, (outs I64:$sx), (ins RCM:$vz, I64:$sy),
|
|
opcStr#" $sx, $vz, $sy">;
|
|
let cy = 0 in
|
|
def mi : RR<opc, (outs I64:$sx), (ins RCM:$vz, uimm2:$sy),
|
|
opcStr#" $sx, $vz, $sy">;
|
|
}
|
|
defm SVM : SVMm<"svm", 0xa7, VM>;
|
|
|
|
// Section 8.9.24 - VBRD (Vector Broadcast)
|
|
let vx = ?, hasSideEffects = 0, Uses = [VL] in
|
|
multiclass VBRDbm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
dag dag_in, string disEnc = ""> {
|
|
let DisableEncoding = disEnc in
|
|
def "" : RV<opc, (outs RC:$vx), dag_in,
|
|
!strconcat(opcStr, " $vx, ", argStr)>;
|
|
let Constraints = "$vx = $base", DisableEncoding = disEnc#"$base",
|
|
isCodeGenOnly = 1 in
|
|
def _v : RV<opc, (outs RC:$vx), !con(dag_in, (ins RC:$base)),
|
|
!strconcat(opcStr, " $vx, ", argStr)>;
|
|
}
|
|
multiclass VBRDlm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
dag dag_in> {
|
|
defm "" : VBRDbm<opcStr, argStr, opc, RC, dag_in>;
|
|
let isCodeGenOnly = 1, VE_VLInUse = 1 in {
|
|
defm l : VBRDbm<opcStr, argStr, opc, RC, !con(dag_in, (ins I32:$vl)),
|
|
"$vl,">;
|
|
defm L : VBRDbm<opcStr, argStr, opc, RC, !con(dag_in, (ins VLS:$vl)),
|
|
"$vl,">;
|
|
}
|
|
}
|
|
multiclass VBRDmm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
RegisterClass RCM, dag dag_in> {
|
|
defm "" : VBRDlm<opcStr, argStr, opc, RC, dag_in>;
|
|
let m = ?, VE_VLWithMask = 1 in
|
|
defm m : VBRDlm<opcStr, argStr#", $m", opc, RC, !con(dag_in, (ins RCM:$m))>;
|
|
}
|
|
let VE_VLIndex = 2 in
|
|
multiclass VBRDm<string opcStr, bits<8>opc, RegisterClass VRC, RegisterClass RC,
|
|
RegisterClass RCM> {
|
|
defm r : VBRDmm<opcStr, "$sy", opc, VRC, RCM, (ins RC:$sy)>;
|
|
let cy = 0 in
|
|
defm i : VBRDmm<opcStr, "$sy", opc, VRC, RCM, (ins simm7:$sy)>;
|
|
}
|
|
let cx = 0, cx2 = 0 in
|
|
defm VBRD : VBRDm<"vbrd", 0x8c, V64, I64, VM>;
|
|
let cx = 0, cx2 = 1 in
|
|
defm VBRDL : VBRDm<"vbrdl", 0x8c, V64, I32, VM>;
|
|
let cx = 1, cx2 = 0 in
|
|
defm VBRDU : VBRDm<"vbrdu", 0x8c, V64, F32, VM>;
|
|
let cx = 1, cx2 = 1 in
|
|
defm PVBRD : VBRDm<"pvbrd", 0x8c, V64, I64, VM512>;
|
|
|
|
// Section 8.9.25 - VMV (Vector Move)
|
|
let vx = ?, vz = ?, hasSideEffects = 0, Uses = [VL] in
|
|
multiclass VMVbm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
dag dag_in, string disEnc = ""> {
|
|
let DisableEncoding = disEnc in
|
|
def "" : RV<opc, (outs RC:$vx), dag_in,
|
|
!strconcat(opcStr, " $vx, ", argStr)>;
|
|
let Constraints = "$vx = $base", DisableEncoding = disEnc#"$base",
|
|
isCodeGenOnly = 1 in
|
|
def _v : RV<opc, (outs RC:$vx), !con(dag_in, (ins RC:$base)),
|
|
!strconcat(opcStr, " $vx, ", argStr)>;
|
|
}
|
|
multiclass VMVlm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
dag dag_in> {
|
|
defm "" : VMVbm<opcStr, argStr, opc, RC, dag_in>;
|
|
let isCodeGenOnly = 1, VE_VLInUse = 1 in {
|
|
defm l : VMVbm<opcStr, argStr, opc, RC, !con(dag_in, (ins I32:$vl)),
|
|
"$vl,">;
|
|
defm L : VMVbm<opcStr, argStr, opc, RC, !con(dag_in, (ins VLS:$vl)),
|
|
"$vl,">;
|
|
}
|
|
}
|
|
multiclass VMVmm<string opcStr, bits<8>opc, RegisterClass RC,
|
|
RegisterClass RCM, dag dag_in> {
|
|
defm "" : VMVlm<opcStr, "$sy, $vz", opc, RC, dag_in>;
|
|
let m = ?, VE_VLWithMask = 1 in
|
|
defm m : VMVlm<opcStr, "$sy, $vz, $m", opc, RC, !con(dag_in, (ins RCM:$m))>;
|
|
}
|
|
let VE_VLIndex = 3 in
|
|
multiclass VMVm<string opcStr, bits<8>opc, RegisterClass RC,
|
|
RegisterClass RCM> {
|
|
defm rv : VMVmm<opcStr, opc, RC, RCM, (ins I64:$sy, RC:$vz)>;
|
|
let cy = 0 in
|
|
defm iv : VMVmm<opcStr, opc, RC, RCM, (ins uimm7:$sy, RC:$vz)>;
|
|
}
|
|
defm VMV : VMVm<"vmv", 0x9c, V64, VM>;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Section 8.10 - Vector Fixed-Point Arithmetic Instructions
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Multiclass for generic vector calculation
|
|
let vx = ?, hasSideEffects = 0, Uses = [VL] in
|
|
multiclass RVbm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
dag dag_in, string disEnc = ""> {
|
|
let DisableEncoding = disEnc in
|
|
def "" : RV<opc, (outs RC:$vx), dag_in,
|
|
!strconcat(opcStr, " $vx", argStr)>;
|
|
let Constraints = "$vx = $base", DisableEncoding = disEnc#"$base",
|
|
isCodeGenOnly = 1 in
|
|
def _v : RV<opc, (outs RC:$vx), !con(dag_in, (ins RC:$base)),
|
|
!strconcat(opcStr, " $vx", argStr)>;
|
|
}
|
|
multiclass RVlm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
dag dag_in> {
|
|
defm "" : RVbm<opcStr, argStr, opc, RC, dag_in>;
|
|
let isCodeGenOnly = 1, VE_VLInUse = 1 in {
|
|
defm l : RVbm<opcStr, argStr, opc, RC, !con(dag_in, (ins I32:$vl)),
|
|
"$vl,">;
|
|
defm L : RVbm<opcStr, argStr, opc, RC, !con(dag_in, (ins VLS:$vl)),
|
|
"$vl,">;
|
|
}
|
|
}
|
|
multiclass RVmm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
RegisterClass RCM, dag dag_in> {
|
|
defm "" : RVlm<opcStr, argStr, opc, RC, dag_in>;
|
|
let m = ?, VE_VLWithMask = 1 in
|
|
defm m : RVlm<opcStr, argStr#", $m", opc, RC, !con(dag_in, (ins RCM:$m))>;
|
|
}
|
|
// Generic RV multiclass with 2 arguments.
|
|
// e.g. VADD, VSUB, VMPY, and etc.
|
|
let VE_VLIndex = 3 in
|
|
multiclass RVm<string opcStr, bits<8>opc, RegisterClass VRC, RegisterClass RC,
|
|
RegisterClass RCM, Operand SIMM = simm7> {
|
|
let cy = 0, sy = 0, vy = ?, vz = ? in
|
|
defm vv : RVmm<opcStr, ", $vy, $vz", opc, VRC, RCM, (ins VRC:$vy, VRC:$vz)>;
|
|
let cs = 1, vz = ? in
|
|
defm rv : RVmm<opcStr, ", $sy, $vz", opc, VRC, RCM, (ins RC:$sy, VRC:$vz)>;
|
|
let cs = 1, cy = 0, vz = ? in
|
|
defm iv : RVmm<opcStr, ", $sy, $vz", opc, VRC, RCM, (ins SIMM:$sy, VRC:$vz)>;
|
|
}
|
|
// Special RV multiclass with 2 arguments using cs2.
|
|
// e.g. VDIV, VDVS, and VDVX.
|
|
let VE_VLIndex = 3 in
|
|
multiclass RVDIVm<string opcStr, bits<8>opc, RegisterClass VRC,
|
|
RegisterClass RC, RegisterClass RCM, Operand SIMM = simm7> {
|
|
let cy = 0, sy = 0, vy = ?, vz = ? in
|
|
defm vv : RVmm<opcStr, ", $vy, $vz", opc, VRC, RCM, (ins VRC:$vy, VRC:$vz)>;
|
|
let cs2 = 1, vy = ? in
|
|
defm vr : RVmm<opcStr, ", $vy, $sy", opc, VRC, RCM, (ins VRC:$vy, RC:$sy)>;
|
|
let cs2 = 1, cy = 0, vy = ? in
|
|
defm vi : RVmm<opcStr, ", $vy, $sy", opc, VRC, RCM, (ins VRC:$vy, SIMM:$sy)>;
|
|
let cs = 1, vz = ? in
|
|
defm rv : RVmm<opcStr, ", $sy, $vz", opc, VRC, RCM, (ins RC:$sy, VRC:$vz)>;
|
|
let cs = 1, cy = 0, vz = ? in
|
|
defm iv : RVmm<opcStr, ", $sy, $vz", opc, VRC, RCM, (ins SIMM:$sy, VRC:$vz)>;
|
|
}
|
|
// Generic RV multiclass with 2 arguments for logical operations.
|
|
// e.g. VAND, VOR, VXOR, and etc.
|
|
let VE_VLIndex = 3 in
|
|
multiclass RVLm<string opcStr, bits<8>opc, RegisterClass ScaRC,
|
|
RegisterClass RC, RegisterClass RCM> {
|
|
let cy = 0, sy = 0, vy = ?, vz = ? in
|
|
defm vv : RVmm<opcStr, ", $vy, $vz", opc, RC, RCM, (ins RC:$vy, RC:$vz)>;
|
|
let cs = 1, vz = ? in
|
|
defm rv : RVmm<opcStr, ", $sy, $vz", opc, RC, RCM, (ins ScaRC:$sy, RC:$vz)>;
|
|
let cs = 1, cy = 0, vz = ? in
|
|
defm mv : RVmm<opcStr, ", $sy, $vz", opc, RC, RCM, (ins mimm:$sy, RC:$vz)>;
|
|
}
|
|
// Generic RV multiclass with 1 argument.
|
|
// e.g. VLDZ, VPCNT, and VBRV.
|
|
let VE_VLIndex = 2 in
|
|
multiclass RV1m<string opcStr, bits<8>opc, RegisterClass RC,
|
|
RegisterClass RCM> {
|
|
let cy = 0, sy = 0, vz = ? in
|
|
defm v : RVmm<opcStr, ", $vz", opc, RC, RCM, (ins RC:$vz)>;
|
|
}
|
|
// Generic RV multiclass with no argument.
|
|
// e.g. VSEQ.
|
|
let VE_VLIndex = 1 in
|
|
multiclass RV0m<string opcStr, bits<8>opc, RegisterClass RC,
|
|
RegisterClass RCM> {
|
|
let cy = 0, sy = 0 in
|
|
defm "" : RVmm<opcStr, "", opc, RC, RCM, (ins)>;
|
|
}
|
|
// Generic RV multiclass with 2 arguments for shift operations.
|
|
// e.g. VSLL, VSRL, VSLA, and etc.
|
|
let VE_VLIndex = 3 in
|
|
multiclass RVSm<string opcStr, bits<8>opc, RegisterClass ScaRC,
|
|
RegisterClass RC, RegisterClass RCM> {
|
|
let cy = 0, sy = 0, vy = ?, vz = ? in
|
|
defm vv : RVmm<opcStr, ", $vz, $vy", opc, RC, RCM, (ins RC:$vz, RC:$vy)>;
|
|
let cs = 1, vz = ? in
|
|
defm vr : RVmm<opcStr, ", $vz, $sy", opc, RC, RCM, (ins RC:$vz, ScaRC:$sy)>;
|
|
let cs = 1, cy = 0, vz = ? in
|
|
defm vi : RVmm<opcStr, ", $vz, $sy", opc, RC, RCM, (ins RC:$vz, uimm7:$sy)>;
|
|
}
|
|
// Generic RV multiclass with 3 arguments for shift operations.
|
|
// e.g. VSLD and VSRD.
|
|
let VE_VLIndex = 4 in
|
|
multiclass RVSDm<string opcStr, bits<8>opc, RegisterClass RC,
|
|
RegisterClass RCM> {
|
|
let vy = ?, vz = ? in
|
|
defm vvr : RVmm<opcStr, ", ($vy, ${vz}), $sy", opc, RC, RCM,
|
|
(ins RC:$vy, RC:$vz, I64:$sy)>;
|
|
let cy = 0, vy = ?, vz = ? in
|
|
defm vvi : RVmm<opcStr, ", ($vy, ${vz}), $sy", opc, RC, RCM,
|
|
(ins RC:$vy, RC:$vz, uimm7:$sy)>;
|
|
}
|
|
// Special RV multiclass with 3 arguments.
|
|
// e.g. VSFA
|
|
let VE_VLIndex = 4 in
|
|
multiclass RVSAm<string opcStr, bits<8>opc, RegisterClass RC,
|
|
RegisterClass RCM> {
|
|
let cz = 1, sz = ?, vz = ? in
|
|
defm vrr : RVmm<opcStr, ", $vz, $sy, $sz", opc, RC, RCM,
|
|
(ins RC:$vz, I64:$sy, I64:$sz)>;
|
|
let cz = 0, sz = ?, vz = ? in
|
|
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)>;
|
|
}
|
|
// Multiclass for generic iterative vector calculation
|
|
let vx = ?, hasSideEffects = 0, Uses = [VL] in
|
|
multiclass RVIbm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
dag dag_in, string disEnc = ""> {
|
|
let DisableEncoding = disEnc in
|
|
def "" : RV<opc, (outs RC:$vx), dag_in,
|
|
!strconcat(opcStr, " $vx", argStr)>;
|
|
let isCodeGenOnly = 1, Constraints = "$vx = $base", DisableEncoding = disEnc#"$base" in
|
|
def _v : RV<opc, (outs RC:$vx), !con(dag_in, (ins RC:$base)),
|
|
!strconcat(opcStr, " $vx", argStr)>;
|
|
}
|
|
multiclass RVIlm<string opcStr, string argStr, bits<8>opc, RegisterClass RC,
|
|
dag dag_in> {
|
|
defm "" : RVIbm<opcStr, argStr, opc, RC, dag_in>;
|
|
let isCodeGenOnly = 1, VE_VLInUse = 1 in {
|
|
defm l : RVIbm<opcStr, argStr, opc, RC, !con(dag_in, (ins I32:$vl)),
|
|
"$vl,">;
|
|
defm L : RVIbm<opcStr, argStr, opc, RC, !con(dag_in, (ins VLS:$vl)),
|
|
"$vl,">;
|
|
}
|
|
}
|
|
// Generic RV multiclass for iterative operation with 2 argument.
|
|
// e.g. VFIA, VFIS, and VFIM
|
|
let VE_VLIndex = 3 in
|
|
multiclass RVI2m<string opcStr, bits<8>opc, RegisterClass VRC,
|
|
RegisterClass RC> {
|
|
let vy = ? in
|
|
defm vr : RVIlm<opcStr, ", $vy, $sy", opc, VRC, (ins VRC:$vy, RC:$sy)>;
|
|
let cy = 0, vy = ? in
|
|
defm vi : RVIlm<opcStr, ", $vy, $sy", opc, VRC, (ins VRC:$vy, simm7fp:$sy)>;
|
|
}
|
|
// Generic RV multiclass for iterative operation with 3 argument.
|
|
// e.g. VFIAM, VFISM, VFIMA, and etc.
|
|
let VE_VLIndex = 4 in
|
|
multiclass RVI3m<string opcStr, bits<8>opc, RegisterClass VRC,
|
|
RegisterClass RC> {
|
|
let vy = ?, vz = ? in
|
|
defm vvr : RVIlm<opcStr, ", $vy, $vz, $sy", opc, VRC,
|
|
(ins VRC:$vy, VRC:$vz, RC:$sy)>;
|
|
let cy = 0, vy = ?, vz = ? in
|
|
defm vvi : RVIlm<opcStr, ", $vy, $vz, $sy", opc, VRC,
|
|
(ins VRC:$vy, VRC:$vz, simm7fp:$sy)>;
|
|
}
|
|
// special RV multiclass with 3 arguments for VSHF.
|
|
// e.g. VSHF
|
|
let vy = ?, vz = ?, VE_VLIndex = 4 in
|
|
multiclass RVSHFm<string opcStr, bits<8>opc, RegisterClass RC,
|
|
Operand SIMM = uimm4> {
|
|
defm vvr : RVlm<opcStr, ", $vy, $vz, $sy", opc, RC,
|
|
(ins RC:$vy, RC:$vz, I64:$sy)>;
|
|
let cy = 0 in defm vvi : RVlm<opcStr, ", $vy, $vz, $sy", opc, RC,
|
|
(ins RC:$vy, RC:$vz, SIMM:$sy)>;
|
|
}
|
|
// Multiclass for generic mask calculation
|
|
let vx = ?, hasSideEffects = 0, Uses = [VL] in
|
|
multiclass RVMKbm<string opcStr, string argStr, bits<8>opc, dag dag_out,
|
|
dag dag_in> {
|
|
def "" : RV<opc, dag_out, dag_in, !strconcat(opcStr, argStr)>;
|
|
let DisableEncoding = "$vl", isCodeGenOnly = 1, VE_VLInUse = 1 in {
|
|
def l : RV<opc, dag_out, !con(dag_in, (ins I32:$vl)),
|
|
!strconcat(opcStr, argStr)>;
|
|
def L : RV<opc, dag_out, !con(dag_in, (ins VLS:$vl)),
|
|
!strconcat(opcStr, argStr)>;
|
|
}
|
|
}
|
|
multiclass RVMKlm<string opcStr, string argStr, bits<8>opc, RegisterClass RCM,
|
|
dag dag_in> {
|
|
defm "" : RVMKbm<opcStr, " $vx"#argStr, opc, (outs RCM:$vx), dag_in>;
|
|
let m = ?, VE_VLWithMask = 1 in
|
|
defm m : RVMKbm<opcStr, " $vx"#argStr#", $m", opc, (outs RCM:$vx),
|
|
!con(dag_in, (ins RCM:$m))>;
|
|
}
|
|
// Generic RV multiclass for mask calculation with a condition.
|
|
// e.g. VFMK, VFMS, and VFMF
|
|
let cy = 0, sy = 0 in
|
|
multiclass RVMKom<string opcStr, bits<8> opc, RegisterClass RC,
|
|
RegisterClass RCM> {
|
|
let vy = ?, vz = ?, VE_VLIndex = 3 in
|
|
defm v : RVMKlm<opcStr#"$vy", ", $vz", opc, RCM, (ins CCOp:$vy, RC:$vz)>;
|
|
let vy = 15 /* AT */, VE_VLIndex = 1 in
|
|
defm a : RVMKlm<opcStr#"at", "", opc, RCM, (ins)>;
|
|
let vy = 0 /* AF */, VE_VLIndex = 1 in
|
|
defm na : RVMKlm<opcStr#"af", "", opc, RCM, (ins)>;
|
|
}
|
|
multiclass RVMKm<string opcStr, bits<8> opc, RegisterClass RC,
|
|
RegisterClass RCM> {
|
|
defm "" : RVMKom<opcStr, opc, RC, RCM>;
|
|
}
|
|
// Generic RV multiclass for mask calculation with 2 arguments.
|
|
// e.g. ANDM, ORM, XORM, and etc.
|
|
let cy = 0, sy = 0, vx = ?, vy = ?, vz = ?, hasSideEffects = 0 in
|
|
multiclass RVM2m<string opcStr, bits<8> opc, RegisterClass RCM> {
|
|
def mm : RV<opc, (outs RCM:$vx), (ins RCM:$vy, RCM:$vz),
|
|
!strconcat(opcStr, " $vx, $vy, $vz")>;
|
|
}
|
|
// Generic RV multiclass for mask calculation with 1 argument.
|
|
// e.g. NEGM
|
|
let cy = 0, sy = 0, vx = ?, vy = ?, hasSideEffects = 0 in
|
|
multiclass RVM1m<string opcStr, bits<8> opc, RegisterClass RCM> {
|
|
def m : RV<opc, (outs RCM:$vx), (ins RCM:$vy),
|
|
!strconcat(opcStr, " $vx, $vy")>;
|
|
}
|
|
// Generic RV multiclass for mask calculation with 1 argument.
|
|
// e.g. PCVM, LZVM, and TOVM
|
|
let cy = 0, sy = 0, vy = ?, hasSideEffects = 0, Uses = [VL] in
|
|
multiclass RVMSbm<string opcStr, string argStr, bits<8>opc, dag dag_in> {
|
|
def "" : RV<opc, (outs I64:$sx), dag_in,
|
|
!strconcat(opcStr, " $sx,", argStr)> {
|
|
bits<7> sx;
|
|
let Inst{54-48} = sx;
|
|
}
|
|
let DisableEncoding = "$vl", isCodeGenOnly = 1, VE_VLInUse = 1 in {
|
|
def l : RV<opc, (outs I64:$sx), !con(dag_in, (ins I32:$vl)),
|
|
!strconcat(opcStr, " $sx,", argStr)> {
|
|
bits<7> sx;
|
|
let Inst{54-48} = sx;
|
|
}
|
|
def L : RV<opc, (outs I64:$sx), !con(dag_in, (ins VLS:$vl)),
|
|
!strconcat(opcStr, " $sx,", argStr)> {
|
|
bits<7> sx;
|
|
let Inst{54-48} = sx;
|
|
}
|
|
}
|
|
}
|
|
let VE_VLIndex = 2 in
|
|
multiclass RVMSm<string opcStr, bits<8> opc, RegisterClass RCM> {
|
|
defm m : RVMSbm<opcStr, " $vy", opc, (ins RCM:$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>;
|
|
}
|
|
let cx = 1, cx2 = 0 in
|
|
defm PVADDUUP : RVm<"pvaddu.up", 0xc8, V64, I64, VM>;
|
|
let cx = 1, cx2 = 1 in
|
|
defm PVADDU : RVm<"pvaddu", 0xc8, V64, I64, VM512>;
|
|
def : MnemonicAlias<"vaddu.w", "pvaddu.lo">;
|
|
|
|
// Section 8.10.2 - VADS (Vector Add Single)
|
|
let cx = 0, cx2 = 0 in
|
|
defm VADDSWSX : RVm<"vadds.w.sx", 0xca, V64, I32, VM>;
|
|
let cx = 0, cx2 = 1 in {
|
|
defm PVADDSLO : RVm<"pvadds.lo", 0xca, V64, I32, VM>;
|
|
let isCodeGenOnly = 1 in
|
|
defm VADDSWZX : RVm<"vadds.w.zx", 0xca, V64, I32, VM>;
|
|
}
|
|
let cx = 1, cx2 = 0 in
|
|
defm PVADDSUP : RVm<"pvadds.up", 0xca, V64, I64, VM>;
|
|
let cx = 1, cx2 = 1 in
|
|
defm PVADDS : RVm<"pvadds", 0xca, V64, I64, VM512>;
|
|
def : MnemonicAlias<"pvadds.lo.sx", "vadds.w.sx">;
|
|
def : MnemonicAlias<"vadds.w.zx", "pvadds.lo">;
|
|
def : MnemonicAlias<"vadds.w", "pvadds.lo">;
|
|
def : MnemonicAlias<"pvadds.lo.zx", "pvadds.lo">;
|
|
|
|
// Section 8.10.3 - VADX (Vector Add)
|
|
defm VADDSL : RVm<"vadds.l", 0x8b, V64, I64, VM>;
|
|
|
|
// Section 8.10.4 - VSUB (Vector Subtract)
|
|
let cx = 0, cx2 = 0 in
|
|
defm VSUBUL : RVm<"vsubu.l", 0xd8, V64, I64, VM>;
|
|
let cx = 0, cx2 = 1 in {
|
|
defm PVSUBULO : RVm<"pvsubu.lo", 0xd8, V64, I32, VM>;
|
|
let isCodeGenOnly = 1 in
|
|
defm VSUBUW : RVm<"vsubu.w", 0xd8, V64, I32, VM>;
|
|
}
|
|
let cx = 1, cx2 = 0 in
|
|
defm PVSUBUUP : RVm<"pvsubu.up", 0xd8, V64, I64, VM>;
|
|
let cx = 1, cx2 = 1 in
|
|
defm PVSUBU : RVm<"pvsubu", 0xd8, V64, I64, VM512>;
|
|
def : MnemonicAlias<"vsubu.w", "pvsubu.lo">;
|
|
|
|
// Section 8.10.5 - VSBS (Vector Subtract Single)
|
|
let cx = 0, cx2 = 0 in
|
|
defm VSUBSWSX : RVm<"vsubs.w.sx", 0xda, V64, I32, VM>;
|
|
let cx = 0, cx2 = 1 in {
|
|
defm PVSUBSLO : RVm<"pvsubs.lo", 0xda, V64, I32, VM>;
|
|
let isCodeGenOnly = 1 in
|
|
defm VSUBSWZX : RVm<"vsubs.w.zx", 0xda, V64, I32, VM>;
|
|
}
|
|
let cx = 1, cx2 = 0 in
|
|
defm PVSUBSUP : RVm<"pvsubs.up", 0xda, V64, I64, VM>;
|
|
let cx = 1, cx2 = 1 in
|
|
defm PVSUBS : RVm<"pvsubs", 0xda, V64, I64, VM512>;
|
|
def : MnemonicAlias<"pvsubs.lo.sx", "vsubs.w.sx">;
|
|
def : MnemonicAlias<"vsubs.w.zx", "pvsubs.lo">;
|
|
def : MnemonicAlias<"vsubs.w", "pvsubs.lo">;
|
|
def : MnemonicAlias<"pvsubs.lo.zx", "pvsubs.lo">;
|
|
|
|
// Section 8.10.6 - VSBX (Vector Subtract)
|
|
defm VSUBSL : RVm<"vsubs.l", 0x9b, V64, I64, VM>;
|
|
|
|
// Section 8.10.7 - VMPY (Vector Multiply)
|
|
let cx2 = 0 in
|
|
defm VMULUL : RVm<"vmulu.l", 0xc9, V64, I64, VM>;
|
|
let cx2 = 1 in
|
|
defm VMULUW : RVm<"vmulu.w", 0xc9, V64, I32, VM>;
|
|
|
|
// Section 8.10.8 - VMPS (Vector Multiply Single)
|
|
let cx2 = 0 in
|
|
defm VMULSWSX : RVm<"vmuls.w.sx", 0xcb, V64, I32, VM>;
|
|
let cx2 = 1 in
|
|
defm VMULSWZX : RVm<"vmuls.w.zx", 0xcb, V64, I32, VM>;
|
|
def : MnemonicAlias<"vmuls.w", "vmuls.w.zx">;
|
|
|
|
// Section 8.10.9 - VMPX (Vector Multiply)
|
|
defm VMULSL : RVm<"vmuls.l", 0xdb, V64, I64, VM>;
|
|
|
|
// Section 8.10.10 - VMPD (Vector Multiply)
|
|
defm VMULSLW : RVm<"vmuls.l.w", 0xd9, V64, I32, VM>;
|
|
|
|
// Section 8.10.11 - VDIV (Vector Divide)
|
|
let cx2 = 0 in
|
|
defm VDIVUL : RVDIVm<"vdivu.l", 0xe9, V64, I64, VM>;
|
|
let cx2 = 1 in
|
|
defm VDIVUW : RVDIVm<"vdivu.w", 0xe9, V64, I32, VM>;
|
|
|
|
// Section 8.10.12 - VDVS (Vector Divide Single)
|
|
let cx2 = 0 in
|
|
defm VDIVSWSX : RVDIVm<"vdivs.w.sx", 0xeb, V64, I32, VM>;
|
|
let cx2 = 1 in
|
|
defm VDIVSWZX : RVDIVm<"vdivs.w.zx", 0xeb, V64, I32, VM>;
|
|
def : MnemonicAlias<"vdivs.w", "vdivs.w.zx">;
|
|
|
|
// Section 8.10.13 - VDVX (Vector Divide)
|
|
defm VDIVSL : RVDIVm<"vdivs.l", 0xfb, V64, I64, VM>;
|
|
|
|
// Section 8.10.14 - VCMP (Vector Compare)
|
|
let cx = 0, cx2 = 0 in
|
|
defm VCMPUL : RVm<"vcmpu.l", 0xb9, V64, I64, VM>;
|
|
let cx = 0, cx2 = 1 in {
|
|
defm PVCMPULO : RVm<"pvcmpu.lo", 0xb9, V64, I32, VM>;
|
|
let isCodeGenOnly = 1 in
|
|
defm VCMPUW : RVm<"vcmpu.w", 0xb9, V64, I32, VM>;
|
|
}
|
|
let cx = 1, cx2 = 0 in
|
|
defm PVCMPUUP : RVm<"pvcmpu.up", 0xb9, V64, I64, VM>;
|
|
let cx = 1, cx2 = 1 in
|
|
defm PVCMPU : RVm<"pvcmpu", 0xb9, V64, I64, VM512>;
|
|
def : MnemonicAlias<"vcmpu.w", "pvcmpu.lo">;
|
|
|
|
// Section 8.10.15 - VCPS (Vector Compare Single)
|
|
let cx = 0, cx2 = 0 in
|
|
defm VCMPSWSX : RVm<"vcmps.w.sx", 0xfa, V64, I32, VM>;
|
|
let cx = 0, cx2 = 1 in {
|
|
defm PVCMPSLO : RVm<"pvcmps.lo", 0xfa, V64, I32, VM>;
|
|
let isCodeGenOnly = 1 in
|
|
defm VCMPSWZX : RVm<"vcmps.w.zx", 0xfa, V64, I32, VM>;
|
|
}
|
|
let cx = 1, cx2 = 0 in
|
|
defm PVCMPSUP : RVm<"pvcmps.up", 0xfa, V64, I64, VM>;
|
|
let cx = 1, cx2 = 1 in
|
|
defm PVCMPS : RVm<"pvcmps", 0xfa, V64, I64, VM512>;
|
|
def : MnemonicAlias<"pvcmps.lo.sx", "vcmps.w.sx">;
|
|
def : MnemonicAlias<"vcmps.w.zx", "pvcmps.lo">;
|
|
def : MnemonicAlias<"vcmps.w", "pvcmps.lo">;
|
|
def : MnemonicAlias<"pvcmps.lo.zx", "pvcmps.lo">;
|
|
|
|
// Section 8.10.16 - VCPX (Vector Compare)
|
|
defm VCMPSL : RVm<"vcmps.l", 0xba, V64, I64, VM>;
|
|
|
|
// Section 8.10.17 - VCMS (Vector Compare and Select Maximum/Minimum Single)
|
|
let cx = 0, cx2 = 0 in
|
|
defm VMAXSWSX : RVm<"vmaxs.w.sx", 0x8a, V64, I32, VM>;
|
|
let cx = 0, cx2 = 1 in {
|
|
defm PVMAXSLO : RVm<"pvmaxs.lo", 0x8a, V64, I32, VM>;
|
|
let isCodeGenOnly = 1 in
|
|
defm VMAXSWZX : RVm<"vmaxs.w.zx", 0x8a, V64, I32, VM>;
|
|
}
|
|
let cx = 1, cx2 = 0 in
|
|
defm PVMAXSUP : RVm<"pvmaxs.up", 0x8a, V64, I64, VM>;
|
|
let cx = 1, cx2 = 1 in
|
|
defm PVMAXS : RVm<"pvmaxs", 0x8a, V64, I64, VM512>;
|
|
let cs2 = 1 in {
|
|
let cx = 0, cx2 = 0 in
|
|
defm VMINSWSX : RVm<"vmins.w.sx", 0x8a, V64, I32, VM>;
|
|
let cx = 0, cx2 = 1 in {
|
|
defm PVMINSLO : RVm<"pvmins.lo", 0x8a, V64, I32, VM>;
|
|
let isCodeGenOnly = 1 in
|
|
defm VMINSWZX : RVm<"vmins.w.zx", 0x8a, V64, I32, VM>;
|
|
}
|
|
let cx = 1, cx2 = 0 in
|
|
defm PVMINSUP : RVm<"pvmins.up", 0x8a, V64, I64, VM>;
|
|
let cx = 1, cx2 = 1 in
|
|
defm PVMINS : RVm<"pvmins", 0x8a, V64, I64, VM512>;
|
|
}
|
|
def : MnemonicAlias<"pvmaxs.lo.sx", "vmaxs.w.sx">;
|
|
def : MnemonicAlias<"vmaxs.w.zx", "pvmaxs.lo">;
|
|
def : MnemonicAlias<"vmaxs.w", "pvmaxs.lo">;
|
|
def : MnemonicAlias<"pvmaxs.lo.zx", "pvmaxs.lo">;
|
|
def : MnemonicAlias<"pvmins.lo.sx", "vmins.w.sx">;
|
|
def : MnemonicAlias<"vmins.w.zx", "pvmins.lo">;
|
|
def : MnemonicAlias<"vmins.w", "pvmins.lo">;
|
|
def : MnemonicAlias<"pvmins.lo.zx", "pvmins.lo">;
|
|
|
|
// Section 8.10.18 - VCMX (Vector Compare and Select Maximum/Minimum)
|
|
defm VMAXSL : RVm<"vmaxs.l", 0x9a, V64, I64, VM>;
|
|
let cs2 = 1 in
|
|
defm VMINSL : RVm<"vmins.l", 0x9a, V64, I64, VM>;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Section 8.11 - Vector Logical Operation Instructions
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Section 8.11.1 - VAND (Vector And)
|
|
let cx = 0, cx2 = 0 in defm VAND : RVLm<"vand", 0xc4, I64, V64, VM>;
|
|
let cx = 0, cx2 = 1 in defm PVANDLO : RVLm<"pvand.lo", 0xc4, I32, V64, VM>;
|
|
let cx = 1, cx2 = 0 in defm PVANDUP : RVLm<"pvand.up", 0xc4, F32, V64, VM>;
|
|
let cx = 1, cx2 = 1 in defm PVAND : RVLm<"pvand", 0xc4, I64, V64, VM512>;
|
|
|
|
// Section 8.11.2 - VOR (Vector Or)
|
|
let cx = 0, cx2 = 0 in defm VOR : RVLm<"vor", 0xc5, I64, V64, VM>;
|
|
let cx = 0, cx2 = 1 in defm PVORLO : RVLm<"pvor.lo", 0xc5, I32, V64, VM>;
|
|
let cx = 1, cx2 = 0 in defm PVORUP : RVLm<"pvor.up", 0xc5, F32, V64, VM>;
|
|
let cx = 1, cx2 = 1 in defm PVOR : RVLm<"pvor", 0xc5, I64, V64, VM512>;
|
|
|
|
// Section 8.11.3 - VXOR (Vector Exclusive Or)
|
|
let cx = 0, cx2 = 0 in defm VXOR : RVLm<"vxor", 0xc6, I64, V64, VM>;
|
|
let cx = 0, cx2 = 1 in defm PVXORLO : RVLm<"pvxor.lo", 0xc6, I32, V64, VM>;
|
|
let cx = 1, cx2 = 0 in defm PVXORUP : RVLm<"pvxor.up", 0xc6, F32, V64, VM>;
|
|
let cx = 1, cx2 = 1 in defm PVXOR : RVLm<"pvxor", 0xc6, I64, V64, VM512>;
|
|
|
|
// Section 8.11.4 - VEQV (Vector Equivalence)
|
|
let cx = 0, cx2 = 0 in defm VEQV : RVLm<"veqv", 0xc7, I64, V64, VM>;
|
|
let cx = 0, cx2 = 1 in defm PVEQVLO : RVLm<"pveqv.lo", 0xc7, I32, V64, VM>;
|
|
let cx = 1, cx2 = 0 in defm PVEQVUP : RVLm<"pveqv.up", 0xc7, F32, V64, VM>;
|
|
let cx = 1, cx2 = 1 in defm PVEQV : RVLm<"pveqv", 0xc7, I64, V64, VM512>;
|
|
|
|
// Section 8.11.5 - VLDZ (Vector Leading Zero Count)
|
|
let cx = 0, cx2 = 0 in defm VLDZ : RV1m<"vldz", 0xe7, V64, VM>;
|
|
let cx = 0, cx2 = 1 in defm PVLDZLO : RV1m<"pvldz.lo", 0xe7, V64, VM>;
|
|
let cx = 1, cx2 = 0 in defm PVLDZUP : RV1m<"pvldz.up", 0xe7, V64, VM>;
|
|
let cx = 1, cx2 = 1 in defm PVLDZ : RV1m<"pvldz", 0xe7, V64, VM512>;
|
|
|
|
// Section 8.11.6 - VPCNT (Vector Population Count)
|
|
let cx = 0, cx2 = 0 in defm VPCNT : RV1m<"vpcnt", 0xac, V64, VM>;
|
|
let cx = 0, cx2 = 1 in defm PVPCNTLO : RV1m<"pvpcnt.lo", 0xac, V64, VM>;
|
|
let cx = 1, cx2 = 0 in defm PVPCNTUP : RV1m<"pvpcnt.up", 0xac, V64, VM>;
|
|
let cx = 1, cx2 = 1 in defm PVPCNT : RV1m<"pvpcnt", 0xac, V64, VM512>;
|
|
|
|
// Section 8.11.7 - VBRV (Vector Bit Reverse)
|
|
let cx = 0, cx2 = 0 in defm VBRV : RV1m<"vbrv", 0xf7, V64, VM>;
|
|
let cx = 0, cx2 = 1 in defm PVBRVLO : RV1m<"pvbrv.lo", 0xf7, V64, VM>;
|
|
let cx = 1, cx2 = 0 in defm PVBRVUP : RV1m<"pvbrv.up", 0xf7, V64, VM>;
|
|
let cx = 1, cx2 = 1 in defm PVBRV : RV1m<"pvbrv", 0xf7, V64, VM512>;
|
|
|
|
// Section 8.11.8 - VSEQ (Vector Sequential Number)
|
|
let cx = 0, cx2 = 0 in defm VSEQ : RV0m<"vseq", 0x99, V64, VM>;
|
|
let cx = 0, cx2 = 1 in defm PVSEQLO : RV0m<"pvseq.lo", 0x99, V64, VM>;
|
|
let cx = 1, cx2 = 0 in defm PVSEQUP : RV0m<"pvseq.up", 0x99, V64, VM>;
|
|
let cx = 1, cx2 = 1 in defm PVSEQ : RV0m<"pvseq", 0x99, V64, VM512>;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Section 8.12 - Vector Shift Operation Instructions
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Section 8.12.1 - VSLL (Vector Shift Left Logical)
|
|
let cx = 0, cx2 = 0 in defm VSLL : RVSm<"vsll", 0xe5, I64, V64, VM>;
|
|
let cx = 0, cx2 = 1 in defm PVSLLLO : RVSm<"pvsll.lo", 0xe5, I32, V64, VM>;
|
|
let cx = 1, cx2 = 0 in defm PVSLLUP : RVSm<"pvsll.up", 0xe5, F32, V64, VM>;
|
|
let cx = 1, cx2 = 1 in defm PVSLL : RVSm<"pvsll", 0xe5, I64, V64, VM512>;
|
|
|
|
// Section 8.12.2 - VSLD (Vector Shift Left Double)
|
|
defm VSLD : RVSDm<"vsld", 0xe4, V64, VM>;
|
|
|
|
// Section 8.12.3 - VSRL (Vector Shift Right Logical)
|
|
let cx = 0, cx2 = 0 in defm VSRL : RVSm<"vsrl", 0xf5, I64, V64, VM>;
|
|
let cx = 0, cx2 = 1 in defm PVSRLLO : RVSm<"pvsrl.lo", 0xf5, I32, V64, VM>;
|
|
let cx = 1, cx2 = 0 in defm PVSRLUP : RVSm<"pvsrl.up", 0xf5, F32, V64, VM>;
|
|
let cx = 1, cx2 = 1 in defm PVSRL : RVSm<"pvsrl", 0xf5, I64, V64, VM512>;
|
|
|
|
// Section 8.12.4 - VSRD (Vector Shift Right Double)
|
|
defm VSRD : RVSDm<"vsrd", 0xf4, V64, VM>;
|
|
|
|
// Section 8.12.5 - VSLA (Vector Shift Left Arithmetic)
|
|
let cx = 0, cx2 = 0 in defm VSLAWSX : RVSm<"vsla.w.sx", 0xe6, I32, V64, VM>;
|
|
let cx = 0, cx2 = 1 in {
|
|
defm PVSLALO : RVSm<"pvsla.lo", 0xe6, I32, V64, VM>;
|
|
let isCodeGenOnly = 1 in defm VSLAWZX : RVSm<"vsla.w.zx", 0xe6, I32, V64, VM>;
|
|
}
|
|
let cx = 1, cx2 = 0 in defm PVSLAUP : RVSm<"pvsla.up", 0xe6, F32, V64, VM>;
|
|
let cx = 1, cx2 = 1 in defm PVSLA : RVSm<"pvsla", 0xe6, I64, V64, VM512>;
|
|
def : MnemonicAlias<"pvsla.lo.sx", "vsla.w.sx">;
|
|
def : MnemonicAlias<"vsla.w.zx", "pvsla.lo">;
|
|
def : MnemonicAlias<"vsla.w", "pvsla.lo">;
|
|
def : MnemonicAlias<"pvsla.lo.zx", "pvsla.lo">;
|
|
|
|
// Section 8.12.6 - VSLAX (Vector Shift Left Arithmetic)
|
|
defm VSLAL : RVSm<"vsla.l", 0xd4, I64, V64, VM>;
|
|
|
|
// Section 8.12.7 - VSRA (Vector Shift Right Arithmetic)
|
|
let cx = 0, cx2 = 0 in defm VSRAWSX : RVSm<"vsra.w.sx", 0xf6, I32, V64, VM>;
|
|
let cx = 0, cx2 = 1 in {
|
|
defm PVSRALO : RVSm<"pvsra.lo", 0xf6, I32, V64, VM>;
|
|
let isCodeGenOnly = 1 in defm VSRAWZX : RVSm<"vsra.w.zx", 0xf6, I32, V64, VM>;
|
|
}
|
|
let cx = 1, cx2 = 0 in defm PVSRAUP : RVSm<"pvsra.up", 0xf6, F32, V64, VM>;
|
|
let cx = 1, cx2 = 1 in defm PVSRA : RVSm<"pvsra", 0xf6, I64, V64, VM512>;
|
|
def : MnemonicAlias<"pvsra.lo.sx", "vsra.w.sx">;
|
|
def : MnemonicAlias<"vsra.w.zx", "pvsra.lo">;
|
|
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>;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Section 8.14 - Vector Reduction Instructions
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Section 8.14.1 - VSUMS (Vector Sum Single)
|
|
defm VSUMWSX : RVF1m<"vsum.w.sx", 0xea, V64, VM>;
|
|
let cx2 = 1 in defm VSUMWZX : RVF1m<"vsum.w.zx", 0xea, V64, VM>;
|
|
|
|
// Section 8.14.2 - VSUMX (Vector Sum)
|
|
defm VSUML : RVF1m<"vsum.l", 0xaa, V64, VM>;
|
|
|
|
// Section 8.14.3 - VFSUM (Vector Floating Sum)
|
|
defm VFSUMD : RVF1m<"vfsum.d", 0xec, V64, VM>;
|
|
let cx = 1 in defm VFSUMS : RVF1m<"vfsum.s", 0xec, V64, VM>;
|
|
|
|
// Section 8.14.4 - VMAXS (Vector Maximum/Minimum Single)
|
|
let cx2 = 0 in defm VRMAXSWFSTSX : RVF1m<"vrmaxs.w.fst.sx", 0xbb, V64, VM>;
|
|
let cx2 = 1 in defm VRMAXSWFSTZX : RVF1m<"vrmaxs.w.fst.zx", 0xbb, V64, VM>;
|
|
let cs = 1 in {
|
|
let cx2 = 0 in
|
|
defm VRMAXSWLSTSX : RVF1m<"vrmaxs.w.lst.sx", 0xbb, V64, VM>;
|
|
let cx2 = 1 in
|
|
defm VRMAXSWLSTZX : RVF1m<"vrmaxs.w.lst.zx", 0xbb, V64, VM>;
|
|
}
|
|
let cs2 = 1 in {
|
|
let cx2 = 0 in
|
|
defm VRMINSWFSTSX : RVF1m<"vrmins.w.fst.sx", 0xbb, V64, VM>;
|
|
let cx2 = 1 in
|
|
defm VRMINSWFSTZX : RVF1m<"vrmins.w.fst.zx", 0xbb, V64, VM>;
|
|
let cs = 1 in {
|
|
let cx2 = 0 in
|
|
defm VRMINSWLSTSX : RVF1m<"vrmins.w.lst.sx", 0xbb, V64, VM>;
|
|
let cx2 = 1 in
|
|
defm VRMINSWLSTZX : RVF1m<"vrmins.w.lst.zx", 0xbb, V64, VM>;
|
|
}
|
|
}
|
|
|
|
// Section 8.14.5 - VMAXX (Vector Maximum/Minimum)
|
|
let cs = 0 in defm VRMAXSLFST : RVF1m<"vrmaxs.l.fst", 0xab, V64, VM>;
|
|
let cs = 1 in defm VRMAXSLLST : RVF1m<"vrmaxs.l.lst", 0xab, V64, VM>;
|
|
let cs2 = 1 in {
|
|
let cs = 0 in defm VRMINSLFST : RVF1m<"vrmins.l.fst", 0xab, V64, VM>;
|
|
let cs = 1 in defm VRMINSLLST : RVF1m<"vrmins.l.lst", 0xab, V64, VM>;
|
|
}
|
|
|
|
// Section 8.14.6 - VFMAX (Vector Floating Maximum/Minimum)
|
|
let cs = 0 in defm VFRMAXDFST : RVF1m<"vfrmax.d.fst", 0xad, V64, VM>;
|
|
let cs = 1 in defm VFRMAXDLST : RVF1m<"vfrmax.d.lst", 0xad, V64, VM>;
|
|
let cs2 = 1 in {
|
|
let cs = 0 in defm VFRMINDFST : RVF1m<"vfrmin.d.fst", 0xad, V64, VM>;
|
|
let cs = 1 in defm VFRMINDLST : RVF1m<"vfrmin.d.lst", 0xad, V64, VM>;
|
|
}
|
|
let cx = 1 in {
|
|
let cs = 0 in defm VFRMAXSFST : RVF1m<"vfrmax.s.fst", 0xad, V64, VM>;
|
|
let cs = 1 in defm VFRMAXSLST : RVF1m<"vfrmax.s.lst", 0xad, V64, VM>;
|
|
let cs2 = 1 in {
|
|
let cs = 0 in defm VFRMINSFST : RVF1m<"vfrmin.s.fst", 0xad, V64, VM>;
|
|
let cs = 1 in defm VFRMINSLST : RVF1m<"vfrmin.s.lst", 0xad, V64, VM>;
|
|
}
|
|
}
|
|
|
|
// Section 8.14.7 - VRAND (Vector Reduction And)
|
|
defm VRAND : RVF1m<"vrand", 0x88, V64, VM>;
|
|
|
|
// Section 8.14.8 - VROR (Vector Reduction Or)
|
|
defm VROR : RVF1m<"vror", 0x98, V64, VM>;
|
|
|
|
// Section 8.14.9 - VRXOR (Vector Reduction Exclusive Or)
|
|
defm VRXOR : RVF1m<"vrxor", 0x89, V64, VM>;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Section 8.15 - Vector Iterative Operation Instructions
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Section 8.15.1 - VFIA (Vector Floating Iteration Add)
|
|
let cx = 0 in defm VFIAD : RVI2m<"vfia.d", 0xce, V64, I64>;
|
|
let cx = 1 in defm VFIAS : RVI2m<"vfia.s", 0xce, V64, F32>;
|
|
|
|
// Section 8.15.2 - VFIS (Vector Floating Iteration Subtract)
|
|
let cx = 0 in defm VFISD : RVI2m<"vfis.d", 0xde, V64, I64>;
|
|
let cx = 1 in defm VFISS : RVI2m<"vfis.s", 0xde, V64, F32>;
|
|
|
|
// Section 8.15.3 - VFIM (Vector Floating Iteration Multiply)
|
|
let cx = 0 in defm VFIMD : RVI2m<"vfim.d", 0xcf, V64, I64>;
|
|
let cx = 1 in defm VFIMS : RVI2m<"vfim.s", 0xcf, V64, F32>;
|
|
|
|
// Section 8.15.4 - VFIAM (Vector Floating Iteration Add and Multiply)
|
|
let cx = 0 in defm VFIAMD : RVI3m<"vfiam.d", 0xee, V64, I64>;
|
|
let cx = 1 in defm VFIAMS : RVI3m<"vfiam.s", 0xee, V64, F32>;
|
|
|
|
// Section 8.15.5 - VFISM (Vector Floating Iteration Subtract and Multiply)
|
|
let cx = 0 in defm VFISMD : RVI3m<"vfism.d", 0xfe, V64, I64>;
|
|
let cx = 1 in defm VFISMS : RVI3m<"vfism.s", 0xfe, V64, F32>;
|
|
|
|
// Section 8.15.6 - VFIMA (Vector Floating Iteration Multiply and Add)
|
|
let cx = 0 in defm VFIMAD : RVI3m<"vfima.d", 0xef, V64, I64>;
|
|
let cx = 1 in defm VFIMAS : RVI3m<"vfima.s", 0xef, V64, F32>;
|
|
|
|
// Section 8.15.7 - VFIMS (Vector Floating Iteration Multiply and Subtract)
|
|
let cx = 0 in defm VFIMSD : RVI3m<"vfims.d", 0xff, V64, I64>;
|
|
let cx = 1 in defm VFIMSS : RVI3m<"vfims.s", 0xff, V64, F32>;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Section 8.16 - Vector Merger Operation Instructions
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Section 8.16.1 - VMRG (Vector Merge)
|
|
let cx = 0 in defm VMRG : RVm<"vmrg", 0xd6, V64, I64, VM>;
|
|
// FIXME: vmrg.w should be called as pvmrg, but following assembly manual.
|
|
let cx = 1 in defm VMRGW : RVm<"vmrg.w", 0xd6, V64, I64, VM512>;
|
|
def : MnemonicAlias<"vmrg.l", "vmrg">;
|
|
|
|
// Section 8.16.2 - VSHF (Vector Shuffle)
|
|
defm VSHF : RVSHFm<"vshf", 0xbc, V64>;
|
|
|
|
// Section 8.16.3 - VCP (Vector Compress)
|
|
defm VCP : RV1m<"vcp", 0x8d, V64, VM>;
|
|
|
|
// Section 8.16.4 - VEX (Vector Expand)
|
|
defm VEX : RV1m<"vex", 0x9d, V64, VM>;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Section 8.17 - Vector Mask Operation Instructions
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Section 8.17.1 - VFMK (Vector Form Mask)
|
|
defm VFMKL : RVMKm<"vfmk.l.", 0xb4, V64, VM>;
|
|
def : MnemonicAlias<"vfmk.l", "vfmk.l.at">;
|
|
|
|
// Section 8.17.2 - VFMS (Vector Form Mask Single)
|
|
defm VFMKW : RVMKm<"vfmk.w.", 0xb5, V64, VM>;
|
|
let isCodeGenOnly = 1 in defm PVFMKWLO : RVMKm<"vfmk.w.", 0xb5, V64, VM>;
|
|
let cx = 1 in defm PVFMKWUP : RVMKm<"pvfmk.w.up.", 0xb5, V64, VM>;
|
|
def : MnemonicAlias<"vfmk.w", "vfmk.w.at">;
|
|
def : MnemonicAlias<"pvfmk.w.up", "pvfmk.w.up.at">;
|
|
def : MnemonicAlias<"pvfmk.w.lo", "vfmk.w.at">;
|
|
foreach CC = [ "af", "gt", "lt", "ne", "eq", "ge", "le", "at" ] in {
|
|
def : MnemonicAlias<"pvfmk.w.lo."#CC, "vfmk.w."#CC>;
|
|
}
|
|
|
|
// Section 8.17.3 - VFMF (Vector Form Mask Floating Point)
|
|
defm VFMKD : RVMKm<"vfmk.d.", 0xb6, V64, VM>;
|
|
let cx2 = 1 in defm PVFMKSLO : RVMKm<"pvfmk.s.lo.", 0xb6, V64, VM>;
|
|
let cx = 1 in {
|
|
defm PVFMKSUP : RVMKm<"pvfmk.s.up.", 0xb6, V64, VM>;
|
|
let isCodeGenOnly = 1 in defm VFMKS : RVMKm<"vfmk.s.", 0xb6, V64, VM>;
|
|
}
|
|
def : MnemonicAlias<"vfmk.d", "vfmk.d.at">;
|
|
def : MnemonicAlias<"pvfmk.s.lo", "pvfmk.s.lo.at">;
|
|
def : MnemonicAlias<"pvfmk.s.up", "pvfmk.s.up.at">;
|
|
def : MnemonicAlias<"vfmk.s", "pvfmk.s.up.at">;
|
|
foreach CC = [ "af", "gt", "lt", "ne", "eq", "ge", "le", "at", "num", "nan",
|
|
"gtnan", "ltnan", "nenan", "eqnan", "genan", "lenan" ] in {
|
|
def : MnemonicAlias<"vfmk.s."#CC, "pvfmk.s.up."#CC>;
|
|
}
|
|
|
|
// Section 8.17.4 - ANDM (And VM)
|
|
defm ANDM : RVM2m<"andm", 0x84, VM>;
|
|
|
|
// Section 8.17.5 - ORM (Or VM)
|
|
defm ORM : RVM2m<"orm", 0x85, VM>;
|
|
|
|
// Section 8.17.6 - XORM (Exclusive Or VM)
|
|
defm XORM : RVM2m<"xorm", 0x86, VM>;
|
|
|
|
// Section 8.17.7 - EQVM (Equivalence VM)
|
|
defm EQVM : RVM2m<"eqvm", 0x87, VM>;
|
|
|
|
// Section 8.17.8 - NNDM (Negate And VM)
|
|
defm NNDM : RVM2m<"nndm", 0x94, VM>;
|
|
|
|
// Section 8.17.9 - NEGM (Negate VM)
|
|
defm NEGM : RVM1m<"negm", 0x95, VM>;
|
|
|
|
// Section 8.17.10 - PCVM (Population Count of VM)
|
|
defm PCVM : RVMSm<"pcvm", 0xa4, VM>;
|
|
|
|
// Section 8.17.11 - LZVM (Leading Zero of VM)
|
|
defm LZVM : RVMSm<"lzvm", 0xa5, VM>;
|
|
|
|
// Section 8.17.12 - TOVM (Trailing One of VM)
|
|
defm TOVM : RVMSm<"tovm", 0xa6, VM>;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Section 8.18 - Vector Control Instructions
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Section 8.18.1 - LVL (Load VL)
|
|
let sx = 0, cz = 0, sz = 0, hasSideEffects = 0, Defs = [VL] in {
|
|
def LVLr : RR<0xbf, (outs), (ins I64:$sy), "lvl $sy">;
|
|
let cy = 0 in def LVLi : RR<0xbf, (outs), (ins simm7:$sy), "lvl $sy">;
|
|
}
|
|
|
|
// Section 8.18.2 - SVL (Save VL)
|
|
let cy = 0, sy = 0, cz = 0, sz = 0, hasSideEffects = 0, Uses = [VL] in
|
|
def SVL : RR<0x2f, (outs I64:$sx), (ins), "svl $sx">;
|
|
|
|
// Section 8.18.3 - SMVL (Save Maximum Vector Length)
|
|
let cy = 0, sy = 0, cz = 0, sz = 0, hasSideEffects = 0 in
|
|
def SMVL : RR<0x2e, (outs I64:$sx), (ins), "smvl $sx">;
|
|
|
|
// Section 8.18.4 - LVIX (Load Vector Data Index)
|
|
let sx = 0, cz = 0, sz = 0, hasSideEffects = 0, Defs = [VIX] in {
|
|
def LVIXr : RR<0xaf, (outs), (ins I64:$sy), "lvix $sy">;
|
|
let cy = 0 in def LVIXi : RR<0xaf, (outs), (ins uimm6:$sy), "lvix $sy">;
|
|
}
|