RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-12-14 15:39:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
3d39cb0a48
llvm/lib/Target/NVPTX/NVPTXVector.td
Matt Arsenault 0e0cc9459a Start replacing vector_extract/vector_insert with extractelt/insertelt 
These are redundant pairs of nodes defined for
INSERT_VECTOR_ELEMENT/EXTRACT_VECTOR_ELEMENT.
insertelement/extractelement are slightly closer to the corresponding
C++ node name, and has stricter type checking so prefer it.

Update targets to only use these nodes where it is trivial to do so.
AArch64, ARM, and Mips all have various type errors on simple replacement,
so they will need work to fix.

Example from AArch64:

def : Pat<(sext_inreg (vector_extract (v16i8 V128:$Rn), VectorIndexB:$idx), i8),
          (i32 (SMOVvi8to32 V128:$Rn, VectorIndexB:$idx))>;

Which is trying to do sext_inreg i8, i8.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@255359 91177308-0d34-0410-b5e6-96231b3b80d8
2015-12-11 19:20:16 +00:00

1480 lines
64 KiB
TableGen
Raw Blame History

//===- NVPTXVector.td - NVPTX Vector Specific Instruction defs -*- tblgen-*-==//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//-----------------------------------
// Vector Specific
//-----------------------------------
//
// All vector instructions derive from NVPTXVecInst
//
class NVPTXVecInst<dag outs, dag ins, string asmstr, list<dag> pattern,
NVPTXInst sInst=NOP>
: NVPTXInst<outs, ins, asmstr, pattern> {
NVPTXInst scalarInst=sInst;
}
let isAsCheapAsAMove=1, VecInstType=isVecExtract.Value in {
// Extract v2i16
def V2i16Extract : NVPTXVecInst<(outs Int16Regs:$dst),
(ins V2I16Regs:$src, i8imm:$c),
"mov.u16 \t$dst, $src${c:vecelem};",
[(set Int16Regs:$dst, (extractelt
(v2i16 V2I16Regs:$src), imm:$c))],
IMOV16rr>;
// Extract v4i16
def V4i16Extract : NVPTXVecInst<(outs Int16Regs:$dst),
(ins V4I16Regs:$src, i8imm:$c),
"mov.u16 \t$dst, $src${c:vecelem};",
[(set Int16Regs:$dst, (extractelt
(v4i16 V4I16Regs:$src), imm:$c))],
IMOV16rr>;
// Extract v2i8
def V2i8Extract : NVPTXVecInst<(outs Int8Regs:$dst),
(ins V2I8Regs:$src, i8imm:$c),
"mov.u16 \t$dst, $src${c:vecelem};",
[(set Int8Regs:$dst, (extractelt
(v2i8 V2I8Regs:$src), imm:$c))],
IMOV8rr>;
// Extract v4i8
def V4i8Extract : NVPTXVecInst<(outs Int8Regs:$dst),
(ins V4I8Regs:$src, i8imm:$c),
"mov.u16 \t$dst, $src${c:vecelem};",
[(set Int8Regs:$dst, (extractelt
(v4i8 V4I8Regs:$src), imm:$c))],
IMOV8rr>;
// Extract v2i32
def V2i32Extract : NVPTXVecInst<(outs Int32Regs:$dst),
(ins V2I32Regs:$src, i8imm:$c),
"mov.u32 \t$dst, $src${c:vecelem};",
[(set Int32Regs:$dst, (extractelt
(v2i32 V2I32Regs:$src), imm:$c))],
IMOV32rr>;
// Extract v2f32
def V2f32Extract : NVPTXVecInst<(outs Float32Regs:$dst),
(ins V2F32Regs:$src, i8imm:$c),
"mov.f32 \t$dst, $src${c:vecelem};",
[(set Float32Regs:$dst, (extractelt
(v2f32 V2F32Regs:$src), imm:$c))],
FMOV32rr>;
// Extract v2i64
def V2i64Extract : NVPTXVecInst<(outs Int64Regs:$dst),
(ins V2I64Regs:$src, i8imm:$c),
"mov.u64 \t$dst, $src${c:vecelem};",
[(set Int64Regs:$dst, (extractelt
(v2i64 V2I64Regs:$src), imm:$c))],
IMOV64rr>;
// Extract v2f64
def V2f64Extract : NVPTXVecInst<(outs Float64Regs:$dst),
(ins V2F64Regs:$src, i8imm:$c),
"mov.f64 \t$dst, $src${c:vecelem};",
[(set Float64Regs:$dst, (extractelt
(v2f64 V2F64Regs:$src), imm:$c))],
FMOV64rr>;
// Extract v4i32
def V4i32Extract : NVPTXVecInst<(outs Int32Regs:$dst),
(ins V4I32Regs:$src, i8imm:$c),
"mov.u32 \t$dst, $src${c:vecelem};",
[(set Int32Regs:$dst, (extractelt
(v4i32 V4I32Regs:$src), imm:$c))],
IMOV32rr>;
// Extract v4f32
def V4f32Extract : NVPTXVecInst<(outs Float32Regs:$dst),
(ins V4F32Regs:$src, i8imm:$c),
"mov.f32 \t$dst, $src${c:vecelem};",
[(set Float32Regs:$dst, (extractelt
(v4f32 V4F32Regs:$src), imm:$c))],
FMOV32rr>;
}
let isAsCheapAsAMove=1, VecInstType=isVecInsert.Value in {
// Insert v2i8
def V2i8Insert : NVPTXVecInst<(outs V2I8Regs:$dst),
(ins V2I8Regs:$src, Int8Regs:$val, i8imm:$c),
"mov.v2.u16 \t${dst:vecfull}, ${src:vecfull};"
"\n\tmov.u16 \t$dst${c:vecelem}, $val;",
[(set V2I8Regs:$dst,
(insertelt V2I8Regs:$src, Int8Regs:$val, imm:$c))], IMOV8rr>;
// Insert v4i8
def V4i8Insert : NVPTXVecInst<(outs V4I8Regs:$dst),
(ins V4I8Regs:$src, Int8Regs:$val, i8imm:$c),
"mov.v4.u16 \t${dst:vecfull}, ${src:vecfull};"
"\n\tmov.u16 \t$dst${c:vecelem}, $val;",
[(set V4I8Regs:$dst,
(insertelt V4I8Regs:$src, Int8Regs:$val, imm:$c))], IMOV8rr>;
// Insert v2i16
def V2i16Insert : NVPTXVecInst<(outs V2I16Regs:$dst),
(ins V2I16Regs:$src, Int16Regs:$val, i8imm:$c),
"mov.v2.u16 \t${dst:vecfull}, ${src:vecfull};"
"\n\tmov.u16 \t$dst${c:vecelem}, $val;",
[(set V2I16Regs:$dst,
(insertelt V2I16Regs:$src, Int16Regs:$val, imm:$c))],
IMOV16rr>;
// Insert v4i16
def V4i16Insert : NVPTXVecInst<(outs V4I16Regs:$dst),
(ins V4I16Regs:$src, Int16Regs:$val, i8imm:$c),
"mov.v4.u16 \t${dst:vecfull}, ${src:vecfull};"
"\n\tmov.u16 \t$dst${c:vecelem}, $val;",
[(set V4I16Regs:$dst,
(insertelt V4I16Regs:$src, Int16Regs:$val, imm:$c))],
IMOV16rr>;
// Insert v2i32
def V2i32Insert : NVPTXVecInst<(outs V2I32Regs:$dst),
(ins V2I32Regs:$src, Int32Regs:$val, i8imm:$c),
"mov.v2.u32 \t${dst:vecfull}, ${src:vecfull};"
"\n\tmov.u32 \t$dst${c:vecelem}, $val;",
[(set V2I32Regs:$dst,
(insertelt V2I32Regs:$src, Int32Regs:$val, imm:$c))],
IMOV32rr>;
// Insert v2f32
def V2f32Insert : NVPTXVecInst<(outs V2F32Regs:$dst),
(ins V2F32Regs:$src, Float32Regs:$val, i8imm:$c),
"mov.v2.f32 \t${dst:vecfull}, ${src:vecfull};"
"\n\tmov.f32 \t$dst${c:vecelem}, $val;",
[(set V2F32Regs:$dst,
(insertelt V2F32Regs:$src, Float32Regs:$val, imm:$c))],
FMOV32rr>;
// Insert v2i64
def V2i64Insert : NVPTXVecInst<(outs V2I64Regs:$dst),
(ins V2I64Regs:$src, Int64Regs:$val, i8imm:$c),
"mov.v2.u64 \t${dst:vecfull}, ${src:vecfull};"
"\n\tmov.u64 \t$dst${c:vecelem}, $val;",
[(set V2I64Regs:$dst,
(insertelt V2I64Regs:$src, Int64Regs:$val, imm:$c))],
IMOV64rr>;
// Insert v2f64
def V2f64Insert : NVPTXVecInst<(outs V2F64Regs:$dst),
(ins V2F64Regs:$src, Float64Regs:$val, i8imm:$c),
"mov.v2.f64 \t${dst:vecfull}, ${src:vecfull};"
"\n\tmov.f64 \t$dst${c:vecelem}, $val;",
[(set V2F64Regs:$dst,
(insertelt V2F64Regs:$src, Float64Regs:$val, imm:$c))],
FMOV64rr>;
// Insert v4i32
def V4i32Insert : NVPTXVecInst<(outs V4I32Regs:$dst),
(ins V4I32Regs:$src, Int32Regs:$val, i8imm:$c),
"mov.v4.u32 \t${dst:vecfull}, ${src:vecfull};"
"\n\tmov.u32 \t$dst${c:vecelem}, $val;",
[(set V4I32Regs:$dst,
(insertelt V4I32Regs:$src, Int32Regs:$val, imm:$c))],
IMOV32rr>;
// Insert v4f32
def V4f32Insert : NVPTXVecInst<(outs V4F32Regs:$dst),
(ins V4F32Regs:$src, Float32Regs:$val, i8imm:$c),
"mov.v4.f32 \t${dst:vecfull}, ${src:vecfull};"
"\n\tmov.f32 \t$dst${c:vecelem}, $val;",
[(set V4F32Regs:$dst,
(insertelt V4F32Regs:$src, Float32Regs:$val, imm:$c))],
FMOV32rr>;
}
class BinOpAsmString<string c> {
string s = c;
}
class V4AsmStr<string opcode> : BinOpAsmString<
!strconcat(!strconcat(!strconcat(!strconcat(
!strconcat(!strconcat(!strconcat(
opcode, " \t${dst}_0, ${a}_0, ${b}_0;\n\t"),
opcode), " \t${dst}_1, ${a}_1, ${b}_1;\n\t"),
opcode), " \t${dst}_2, ${a}_2, ${b}_2;\n\t"),
opcode), " \t${dst}_3, ${a}_3, ${b}_3;")>;
class V2AsmStr<string opcode> : BinOpAsmString<
!strconcat(!strconcat(!strconcat(
opcode, " \t${dst}_0, ${a}_0, ${b}_0;\n\t"),
opcode), " \t${dst}_1, ${a}_1, ${b}_1;")>;
class V4MADStr<string opcode> : BinOpAsmString<
!strconcat(!strconcat(!strconcat(!strconcat(
!strconcat(!strconcat(!strconcat(
opcode, " \t${dst}_0, ${a}_0, ${b}_0, ${c}_0;\n\t"),
opcode), " \t${dst}_1, ${a}_1, ${b}_1, ${c}_1;\n\t"),
opcode), " \t${dst}_2, ${a}_2, ${b}_2, ${c}_2;\n\t"),
opcode), " \t${dst}_3, ${a}_3, ${b}_3, ${c}_3;")>;
class V2MADStr<string opcode> : BinOpAsmString<
!strconcat(!strconcat(!strconcat(
opcode, " \t${dst}_0, ${a}_0, ${b}_0, ${c}_0;\n\t"),
opcode), " \t${dst}_1, ${a}_1, ${b}_1, ${c}_1;")>;
class V4UnaryStr<string opcode> : BinOpAsmString<
!strconcat(!strconcat(!strconcat(!strconcat(
!strconcat(!strconcat(!strconcat(
opcode, " \t${dst}_0, ${a}_0;\n\t"),
opcode), " \t${dst}_1, ${a}_1;\n\t"),
opcode), " \t${dst}_2, ${a}_2;\n\t"),
opcode), " \t${dst}_3, ${a}_3;")>;
class V2UnaryStr<string opcode> : BinOpAsmString<
!strconcat(!strconcat(!strconcat(
opcode, " \t${dst}_0, ${a}_0;\n\t"),
opcode), " \t${dst}_1, ${a}_1;")>;
class VecBinaryOp<BinOpAsmString asmstr, SDNode OpNode, NVPTXRegClass regclass,
NVPTXInst sInst=NOP> :
NVPTXVecInst<(outs regclass:$dst), (ins regclass:$a, regclass:$b),
asmstr.s,
[(set regclass:$dst, (OpNode regclass:$a, regclass:$b))],
sInst>;
class VecShiftOp<BinOpAsmString asmstr, SDNode OpNode, NVPTXRegClass regclass1,
NVPTXRegClass regclass2, NVPTXInst sInst=NOP> :
NVPTXVecInst<(outs regclass1:$dst), (ins regclass1:$a, regclass2:$b),
asmstr.s,
[(set regclass1:$dst, (OpNode regclass1:$a, regclass2:$b))],
sInst>;
class VecUnaryOp<BinOpAsmString asmstr, PatFrag OpNode, NVPTXRegClass regclass,
NVPTXInst sInst=NOP> :
NVPTXVecInst<(outs regclass:$dst), (ins regclass:$a),
asmstr.s,
[(set regclass:$dst, (OpNode regclass:$a))], sInst>;
multiclass IntBinVOp<string asmstr, SDNode OpNode,
NVPTXInst i64op=NOP, NVPTXInst i32op=NOP, NVPTXInst
i16op=NOP, NVPTXInst i8op=NOP> {
def V2I64 : VecBinaryOp<V2AsmStr<!strconcat(asmstr, "64")>, OpNode, V2I64Regs,
i64op>;
def V4I32 : VecBinaryOp<V4AsmStr<!strconcat(asmstr, "32")>, OpNode, V4I32Regs,
i32op>;
def V2I32 : VecBinaryOp<V2AsmStr<!strconcat(asmstr, "32")>, OpNode, V2I32Regs,
i32op>;
def V4I16 : VecBinaryOp<V4AsmStr<!strconcat(asmstr, "16")>, OpNode, V4I16Regs,
i16op>;
def V2I16 : VecBinaryOp<V2AsmStr<!strconcat(asmstr, "16")>, OpNode, V2I16Regs,
i16op>;
def V4I8 : VecBinaryOp<V4AsmStr<!strconcat(asmstr, "16")>, OpNode, V4I8Regs,
i8op>;
def V2I8 : VecBinaryOp<V2AsmStr<!strconcat(asmstr, "16")>, OpNode, V2I8Regs,
i8op>;
}
multiclass FloatBinVOp<string asmstr, SDNode OpNode,
NVPTXInst f64=NOP, NVPTXInst f32=NOP,
NVPTXInst f32_ftz=NOP> {
def V2F64 : VecBinaryOp<V2AsmStr<!strconcat(asmstr, "f64")>, OpNode,
V2F64Regs, f64>;
def V4F32_ftz : VecBinaryOp<V4AsmStr<!strconcat(asmstr, "ftz.f32")>, OpNode,
V4F32Regs, f32_ftz>, Requires<[doF32FTZ]>;
def V2F32_ftz : VecBinaryOp<V2AsmStr<!strconcat(asmstr, "ftz.f32")>, OpNode,
V2F32Regs, f32_ftz>, Requires<[doF32FTZ]>;
def V4F32 : VecBinaryOp<V4AsmStr<!strconcat(asmstr, "f32")>, OpNode,
V4F32Regs, f32>;
def V2F32 : VecBinaryOp<V2AsmStr<!strconcat(asmstr, "f32")>, OpNode,
V2F32Regs, f32>;
}
multiclass IntUnaryVOp<string asmstr, PatFrag OpNode,
NVPTXInst i64op=NOP, NVPTXInst i32op=NOP,
NVPTXInst i16op=NOP, NVPTXInst i8op=NOP> {
def V2I64 : VecUnaryOp<V2UnaryStr<!strconcat(asmstr, "64")>, OpNode,
V2I64Regs, i64op>;
def V4I32 : VecUnaryOp<V4UnaryStr<!strconcat(asmstr, "32")>, OpNode,
V4I32Regs, i32op>;
def V2I32 : VecUnaryOp<V2UnaryStr<!strconcat(asmstr, "32")>, OpNode,
V2I32Regs, i32op>;
def V4I16 : VecUnaryOp<V4UnaryStr<!strconcat(asmstr, "16")>, OpNode,
V4I16Regs, i16op>;
def V2I16 : VecUnaryOp<V2UnaryStr<!strconcat(asmstr, "16")>, OpNode,
V2I16Regs, i16op>;
def V4I8 : VecUnaryOp<V4UnaryStr<!strconcat(asmstr, "16")>, OpNode,
V4I8Regs, i8op>;
def V2I8 : VecUnaryOp<V2UnaryStr<!strconcat(asmstr, "16")>, OpNode,
V2I8Regs, i8op>;
}
// Integer Arithmetic
let VecInstType=isVecOther.Value in {
defm VAdd : IntBinVOp<"add.s", add, ADDi64rr, ADDi32rr, ADDi16rr, ADDi8rr>;
defm VSub : IntBinVOp<"sub.s", sub, SUBi64rr, SUBi32rr, SUBi16rr, SUBi8rr>;
def AddCCV4I32 : VecBinaryOp<V4AsmStr<"add.cc.s32">, addc, V4I32Regs,
ADDCCi32rr>;
def AddCCV2I32 : VecBinaryOp<V2AsmStr<"add.cc.s32">, addc, V2I32Regs,
ADDCCi32rr>;
def SubCCV4I32 : VecBinaryOp<V4AsmStr<"sub.cc.s32">, subc, V4I32Regs,
SUBCCi32rr>;
def SubCCV2I32 : VecBinaryOp<V2AsmStr<"sub.cc.s32">, subc, V2I32Regs,
SUBCCi32rr>;
def AddCCCV4I32 : VecBinaryOp<V4AsmStr<"addc.cc.s32">, adde, V4I32Regs,
ADDCCCi32rr>;
def AddCCCV2I32 : VecBinaryOp<V2AsmStr<"addc.cc.s32">, adde, V2I32Regs,
ADDCCCi32rr>;
def SubCCCV4I32 : VecBinaryOp<V4AsmStr<"subc.cc.s32">, sube, V4I32Regs,
SUBCCCi32rr>;
def SubCCCV2I32 : VecBinaryOp<V2AsmStr<"subc.cc.s32">, sube, V2I32Regs,
SUBCCCi32rr>;
def ShiftLV2I64 : VecShiftOp<V2AsmStr<"shl.b64">, shl, V2I64Regs, V2I32Regs,
SHLi64rr>;
def ShiftLV2I32 : VecShiftOp<V2AsmStr<"shl.b32">, shl, V2I32Regs, V2I32Regs,
SHLi32rr>;
def ShiftLV4I32 : VecShiftOp<V4AsmStr<"shl.b32">, shl, V4I32Regs, V4I32Regs,
SHLi32rr>;
def ShiftLV2I16 : VecShiftOp<V2AsmStr<"shl.b16">, shl, V2I16Regs, V2I32Regs,
SHLi16rr>;
def ShiftLV4I16 : VecShiftOp<V4AsmStr<"shl.b16">, shl, V4I16Regs, V4I32Regs,
SHLi16rr>;
def ShiftLV2I8 : VecShiftOp<V2AsmStr<"shl.b16">, shl, V2I8Regs, V2I32Regs,
SHLi8rr>;
def ShiftLV4I8 : VecShiftOp<V4AsmStr<"shl.b16">, shl, V4I8Regs, V4I32Regs,
SHLi8rr>;
}
// cvt to v*i32, helpers for shift
class CVTtoVeci32<NVPTXRegClass inclass, NVPTXRegClass outclass, string asmstr,
NVPTXInst sInst=NOP> :
NVPTXVecInst<(outs outclass:$d), (ins inclass:$s), asmstr, [], sInst>;
class VecCVTStrHelper<string op, string dest, string src> {
string s=!strconcat(op, !strconcat("\t",
!strconcat(dest, !strconcat(", ", !strconcat(src, ";")))));
}
class Vec2CVTStr<string op> {
string s=!strconcat(VecCVTStrHelper<op, "${d}_0", "${s}_0">.s,
!strconcat("\n\t", VecCVTStrHelper<op, "${d}_1", "${s}_1">.s));
}
class Vec4CVTStr<string op> {
string s=!strconcat(VecCVTStrHelper<op, "${d}_0", "${s}_0">.s,
!strconcat("\n\t",
!strconcat(VecCVTStrHelper<op, "${d}_1", "${s}_1">.s,
!strconcat("\n\t",
!strconcat(VecCVTStrHelper<op, "${d}_2", "${s}_2">.s,
!strconcat("\n\t", VecCVTStrHelper<op, "${d}_3", "${s}_3">.s))))));
}
let VecInstType=isVecOther.Value in {
def CVTv2i8tov2i32 : CVTtoVeci32<V2I8Regs, V2I32Regs,
Vec2CVTStr<"cvt.u32.u16">.s, Zint_extendext8to32>;
def CVTv2i16tov2i32 : CVTtoVeci32<V2I16Regs, V2I32Regs,
Vec2CVTStr<"cvt.u32.u16">.s, Zint_extendext16to32>;
def CVTv4i8tov4i32 : CVTtoVeci32<V4I8Regs, V4I32Regs,
Vec4CVTStr<"cvt.u32.u16">.s, Zint_extendext8to32>;
def CVTv4i16tov4i32 : CVTtoVeci32<V4I16Regs, V4I32Regs,
Vec4CVTStr<"cvt.u32.u16">.s, Zint_extendext16to32>;
def CVTv2i64tov2i32 : CVTtoVeci32<V2I64Regs, V2I32Regs,
Vec2CVTStr<"cvt.u32.u64">.s, TRUNC_64to32>;
}
def : Pat<(shl V2I16Regs:$src1, V2I16Regs:$src2),
(ShiftLV2I16 V2I16Regs:$src1, (CVTv2i16tov2i32 V2I16Regs:$src2))>;
def : Pat<(shl V2I8Regs:$src1, V2I8Regs:$src2),
(ShiftLV2I8 V2I8Regs:$src1, (CVTv2i8tov2i32 V2I8Regs:$src2))>;
def : Pat<(shl V2I64Regs:$src1, V2I64Regs:$src2),
(ShiftLV2I64 V2I64Regs:$src1, (CVTv2i64tov2i32 V2I64Regs:$src2))>;
def : Pat<(shl V4I16Regs:$src1, V4I16Regs:$src2),
(ShiftLV4I16 V4I16Regs:$src1, (CVTv4i16tov4i32 V4I16Regs:$src2))>;
def : Pat<(shl V4I8Regs:$src1, V4I8Regs:$src2),
(ShiftLV4I8 V4I8Regs:$src1, (CVTv4i8tov4i32 V4I8Regs:$src2))>;
let VecInstType=isVecOther.Value in {
def ShiftRAV2I64 : VecShiftOp<V2AsmStr<"shr.s64">, sra, V2I64Regs, V2I32Regs,
SRAi64rr>;
def ShiftRAV2I32 : VecShiftOp<V2AsmStr<"shr.s32">, sra, V2I32Regs, V2I32Regs,
SRAi32rr>;
def ShiftRAV4I32 : VecShiftOp<V4AsmStr<"shr.s32">, sra, V4I32Regs, V4I32Regs,
SRAi32rr>;
def ShiftRAV2I16 : VecShiftOp<V2AsmStr<"shr.s16">, sra, V2I16Regs, V2I32Regs,
SRAi16rr>;
def ShiftRAV4I16 : VecShiftOp<V4AsmStr<"shr.s16">, sra, V4I16Regs, V4I32Regs,
SRAi16rr>;
def ShiftRAV2I8 : VecShiftOp<V2AsmStr<"shr.s16">, sra, V2I8Regs, V2I32Regs,
SRAi8rr>;
def ShiftRAV4I8 : VecShiftOp<V4AsmStr<"shr.s16">, sra, V4I8Regs, V4I32Regs,
SRAi8rr>;
def ShiftRLV2I64 : VecShiftOp<V2AsmStr<"shr.u64">, srl, V2I64Regs, V2I32Regs,
SRLi64rr>;
def ShiftRLV2I32 : VecShiftOp<V2AsmStr<"shr.u32">, srl, V2I32Regs, V2I32Regs,
SRLi32rr>;
def ShiftRLV4I32 : VecShiftOp<V4AsmStr<"shr.u32">, srl, V4I32Regs, V4I32Regs,
SRLi32rr>;
def ShiftRLV2I16 : VecShiftOp<V2AsmStr<"shr.u16">, srl, V2I16Regs, V2I32Regs,
SRLi16rr>;
def ShiftRLV4I16 : VecShiftOp<V4AsmStr<"shr.u16">, srl, V4I16Regs, V4I32Regs,
SRLi16rr>;
def ShiftRLV2I8 : VecShiftOp<V2AsmStr<"shr.u16">, srl, V2I8Regs, V2I32Regs,
SRLi8rr>;
def ShiftRLV4I8 : VecShiftOp<V4AsmStr<"shr.u16">, srl, V4I8Regs, V4I32Regs,
SRLi8rr>;
defm VMult : IntBinVOp<"mul.lo.s", mul, MULTi64rr, MULTi32rr, MULTi16rr,
MULTi8rr>;
defm VMultHS : IntBinVOp<"mul.hi.s", mulhs, MULTHSi64rr, MULTHSi32rr,
MULTHSi16rr,
MULTHSi8rr>;
defm VMultHU : IntBinVOp<"mul.hi.u", mulhu, MULTHUi64rr, MULTHUi32rr,
MULTHUi16rr,
MULTHUi8rr>;
defm VSDiv : IntBinVOp<"div.s", sdiv, SDIVi64rr, SDIVi32rr, SDIVi16rr,
SDIVi8rr>;
defm VUDiv : IntBinVOp<"div.u", udiv, UDIVi64rr, UDIVi32rr, UDIVi16rr,
UDIVi8rr>;
defm VSRem : IntBinVOp<"rem.s", srem, SREMi64rr, SREMi32rr, SREMi16rr,
SREMi8rr>;
defm VURem : IntBinVOp<"rem.u", urem, UREMi64rr, UREMi32rr, UREMi16rr,
UREMi8rr>;
}
def : Pat<(sra V2I16Regs:$src1, V2I16Regs:$src2),
(ShiftRAV2I16 V2I16Regs:$src1, (CVTv2i16tov2i32 V2I16Regs:$src2))>;
def : Pat<(sra V2I8Regs:$src1, V2I8Regs:$src2),
(ShiftRAV2I8 V2I8Regs:$src1, (CVTv2i8tov2i32 V2I8Regs:$src2))>;
def : Pat<(sra V2I64Regs:$src1, V2I64Regs:$src2),
(ShiftRAV2I64 V2I64Regs:$src1, (CVTv2i64tov2i32 V2I64Regs:$src2))>;
def : Pat<(sra V4I16Regs:$src1, V4I16Regs:$src2),
(ShiftRAV4I16 V4I16Regs:$src1, (CVTv4i16tov4i32 V4I16Regs:$src2))>;
def : Pat<(sra V4I8Regs:$src1, V4I8Regs:$src2),
(ShiftRAV4I8 V4I8Regs:$src1, (CVTv4i8tov4i32 V4I8Regs:$src2))>;
def : Pat<(srl V2I16Regs:$src1, V2I16Regs:$src2),
(ShiftRLV2I16 V2I16Regs:$src1, (CVTv2i16tov2i32 V2I16Regs:$src2))>;
def : Pat<(srl V2I8Regs:$src1, V2I8Regs:$src2),
(ShiftRLV2I8 V2I8Regs:$src1, (CVTv2i8tov2i32 V2I8Regs:$src2))>;
def : Pat<(srl V2I64Regs:$src1, V2I64Regs:$src2),
(ShiftRLV2I64 V2I64Regs:$src1, (CVTv2i64tov2i32 V2I64Regs:$src2))>;
def : Pat<(srl V4I16Regs:$src1, V4I16Regs:$src2),
(ShiftRLV4I16 V4I16Regs:$src1, (CVTv4i16tov4i32 V4I16Regs:$src2))>;
def : Pat<(srl V4I8Regs:$src1, V4I8Regs:$src2),
(ShiftRLV4I8 V4I8Regs:$src1, (CVTv4i8tov4i32 V4I8Regs:$src2))>;
multiclass VMAD<string asmstr, NVPTXRegClass regclassv4,
NVPTXRegClass regclassv2,
SDNode an=add, SDNode mn=mul, NVPTXInst sop=NOP,
Predicate Pred> {
def V4 : NVPTXVecInst<(outs regclassv4:$dst),
(ins regclassv4:$a, regclassv4:$b, regclassv4:$c),
V4MADStr<asmstr>.s,
[(set regclassv4:$dst,
(an (mn regclassv4:$a, regclassv4:$b), regclassv4:$c))],
sop>,
Requires<[Pred]>;
def V2 : NVPTXVecInst<(outs regclassv2:$dst),
(ins regclassv2:$a, regclassv2:$b, regclassv2:$c),
V2MADStr<asmstr>.s,
[(set regclassv2:$dst,
(an (mn regclassv2:$a, regclassv2:$b), regclassv2:$c))],
sop>,
Requires<[Pred]>;
}
multiclass VMADV2Only<string asmstr, NVPTXRegClass regclass, NVPTXInst sop=NOP,
Predicate Pred> {
def V2 : NVPTXVecInst<(outs regclass:$dst),
(ins regclass:$a, regclass:$b, regclass:$c),
V2MADStr<asmstr>.s,
[(set regclass:$dst, (add
(mul regclass:$a, regclass:$b), regclass:$c))], sop>,
Requires<[Pred]>;
}
multiclass VFMADV2Only<string asmstr, NVPTXRegClass regclass, NVPTXInst sop=NOP,
Predicate Pred> {
def V2 : NVPTXVecInst<(outs regclass:$dst),
(ins regclass:$a, regclass:$b, regclass:$c),
V2MADStr<asmstr>.s,
[(set regclass:$dst, (fadd
(fmul regclass:$a, regclass:$b), regclass:$c))], sop>,
Requires<[Pred]>;
}
let VecInstType=isVecOther.Value in {
defm I8MAD : VMAD<"mad.lo.s16", V4I8Regs, V2I8Regs, add, mul, MAD8rrr, true>;
defm I16MAD : VMAD<"mad.lo.s16", V4I16Regs, V2I16Regs, add, mul, MAD16rrr,
true>;
defm I32MAD : VMAD<"mad.lo.s32", V4I32Regs, V2I32Regs, add, mul, MAD32rrr,
true>;
defm I64MAD : VMADV2Only<"mad.lo.s64", V2I64Regs, MAD64rrr, true>;
defm VNeg : IntUnaryVOp<"neg.s", ineg, INEG64, INEG32, INEG16, INEG8>;
defm VAddf : FloatBinVOp<"add.", fadd, FADDf64rr, FADDf32rr, FADDf32rr_ftz>;
defm VSubf : FloatBinVOp<"sub.", fsub, FSUBf64rr, FSUBf32rr, FSUBf32rr_ftz>;
defm VMulf : FloatBinVOp<"mul.", fmul, FMULf64rr, FMULf32rr, FMULf32rr_ftz>;
defm F32MAD_ftz : VMAD<"mad.ftz.f32", V4F32Regs, V2F32Regs, fadd, fmul,
FMAD32_ftzrrr, doFMADF32_ftz>;
defm F32FMA_ftz : VMAD<"fma.rn.ftz.f32", V4F32Regs, V2F32Regs, fadd, fmul,
FMA32_ftzrrr, doFMAF32_ftz>;
defm F32MAD : VMAD<"mad.f32", V4F32Regs, V2F32Regs, fadd, fmul, FMAD32rrr,
doFMADF32>;
defm F32FMA : VMAD<"fma.rn.f32", V4F32Regs, V2F32Regs, fadd, fmul, FMA32rrr,
doFMAF32>;
defm F64FMA : VFMADV2Only<"fma.rn.f64", V2F64Regs, FMA64rrr, doFMAF64>;
}
let VecInstType=isVecOther.Value in {
def V4F32Div_prec_ftz : VecBinaryOp<V4AsmStr<"div.rn.ftz.f32">, fdiv, V4F32Regs,
FDIV32rr_prec_ftz>, Requires<[doF32FTZ, reqPTX20]>;
def V2F32Div_prec_ftz : VecBinaryOp<V2AsmStr<"div.rn.ftz.f32">, fdiv, V2F32Regs,
FDIV32rr_prec_ftz>, Requires<[doF32FTZ, reqPTX20]>;
def V4F32Div_prec : VecBinaryOp<V4AsmStr<"div.rn.f32">, fdiv, V4F32Regs,
FDIV32rr_prec>, Requires<[reqPTX20]>;
def V2F32Div_prec : VecBinaryOp<V2AsmStr<"div.rn.f32">, fdiv, V2F32Regs,
FDIV32rr_prec>, Requires<[reqPTX20]>;
def V2F32Div_ftz : VecBinaryOp<V2AsmStr<"div.full.ftz.f32">, fdiv, V2F32Regs,
FDIV32rr_ftz>, Requires<[doF32FTZ]>;
def V4F32Div_ftz : VecBinaryOp<V4AsmStr<"div.full.ftz.f32">, fdiv, V4F32Regs,
FDIV32rr_ftz>, Requires<[doF32FTZ]>;
def V2F32Div : VecBinaryOp<V2AsmStr<"div.full.f32">, fdiv, V2F32Regs, FDIV32rr>;
def V4F32Div : VecBinaryOp<V4AsmStr<"div.full.f32">, fdiv, V4F32Regs, FDIV32rr>;
def V2F64Div : VecBinaryOp<V2AsmStr<"div.rn.f64">, fdiv, V2F64Regs, FDIV64rr>;
}
def fnegpat : PatFrag<(ops node:$in), (fneg node:$in)>;
let VecInstType=isVecOther.Value in {
def VNegv2f32_ftz : VecUnaryOp<V2UnaryStr<"neg.ftz.f32">, fnegpat, V2F32Regs,
FNEGf32_ftz>, Requires<[doF32FTZ]>;
def VNegv4f32_ftz : VecUnaryOp<V4UnaryStr<"neg.ftz.f32">, fnegpat, V4F32Regs,
FNEGf32_ftz>, Requires<[doF32FTZ]>;
def VNegv2f32 : VecUnaryOp<V2UnaryStr<"neg.f32">, fnegpat, V2F32Regs, FNEGf32>;
def VNegv4f32 : VecUnaryOp<V4UnaryStr<"neg.f32">, fnegpat, V4F32Regs, FNEGf32>;
def VNegv2f64 : VecUnaryOp<V2UnaryStr<"neg.f64">, fnegpat, V2F64Regs, FNEGf64>;
// Logical Arithmetic
defm VAnd : IntBinVOp<"and.b", and, ANDb64rr, ANDb32rr, ANDb16rr, ANDb8rr>;
defm VOr : IntBinVOp<"or.b", or, ORb64rr, ORb32rr, ORb16rr, ORb8rr>;
defm VXor : IntBinVOp<"xor.b", xor, XORb64rr, XORb32rr, XORb16rr, XORb8rr>;
defm VNot : IntUnaryVOp<"not.b", not, NOT64, NOT32, NOT16, NOT8>;
}
multiclass V2FPCONTRACT32_SUB_PAT<NVPTXInst Inst, Predicate Pred> {
def : Pat<(fsub V2F32Regs:$a, (fmul V2F32Regs:$b, V2F32Regs:$c)),
(Inst (VNegv2f32 V2F32Regs:$b), V2F32Regs:$c, V2F32Regs:$a)>,
Requires<[Pred]>;
def : Pat<(fsub (fmul V2F32Regs:$a, V2F32Regs:$b), V2F32Regs:$c),
(Inst V2F32Regs:$a, V2F32Regs:$b, (VNegv2f32 V2F32Regs:$c))>,
Requires<[Pred]>;
}
defm V2FMAF32ext_ftz : V2FPCONTRACT32_SUB_PAT<F32FMA_ftzV2, doFMAF32AGG_ftz>;
defm V2FMADF32ext_ftz : V2FPCONTRACT32_SUB_PAT<F32MAD_ftzV2, doFMADF32_ftz>;
defm V2FMAF32ext : V2FPCONTRACT32_SUB_PAT<F32FMAV2, doFMAF32AGG>;
defm V2FMADF32ext : V2FPCONTRACT32_SUB_PAT<F32MADV2, doFMADF32>;
multiclass V4FPCONTRACT32_SUB_PAT<NVPTXInst Inst, Predicate Pred> {
def : Pat<(fsub V4F32Regs:$a, (fmul V4F32Regs:$b, V4F32Regs:$c)),
(Inst (VNegv4f32 V4F32Regs:$b), V4F32Regs:$c, V4F32Regs:$a)>,
Requires<[Pred]>;
def : Pat<(fsub (fmul V4F32Regs:$a, V4F32Regs:$b), V4F32Regs:$c),
(Inst V4F32Regs:$a, V4F32Regs:$b, (VNegv4f32 V4F32Regs:$c))>,
Requires<[Pred]>;
}
defm V4FMAF32ext_ftz : V4FPCONTRACT32_SUB_PAT<F32FMA_ftzV4, doFMAF32AGG_ftz>;
defm V4FMADF32ext_ftz : V4FPCONTRACT32_SUB_PAT<F32MAD_ftzV4, doFMADF32_ftz>;
defm V4FMAF32ext : V4FPCONTRACT32_SUB_PAT<F32FMAV4, doFMAF32AGG>;
defm V4FMADF32ext : V4FPCONTRACT32_SUB_PAT<F32MADV4, doFMADF32>;
multiclass V2FPCONTRACT64_SUB_PAT<NVPTXInst Inst, Predicate Pred> {
def : Pat<(fsub V2F64Regs:$a, (fmul V2F64Regs:$b, V2F64Regs:$c)),
(Inst (VNegv2f64 V2F64Regs:$b), V2F64Regs:$c, V2F64Regs:$a)>,
Requires<[Pred]>;
def : Pat<(fsub (fmul V2F64Regs:$a, V2F64Regs:$b), V2F64Regs:$c),
(Inst V2F64Regs:$a, V2F64Regs:$b, (VNegv2f64 V2F64Regs:$c))>,
Requires<[Pred]>;
}
defm V2FMAF64ext : V2FPCONTRACT64_SUB_PAT<F64FMAV2, doFMAF64AGG>;
class VecModStr<string vecsize, string elem, string extra, string l="">
{
string t1 = !strconcat("${c", elem);
string t2 = !strconcat(t1, ":vecv");
string t3 = !strconcat(t2, vecsize);
string t4 = !strconcat(t3, extra);
string t5 = !strconcat(t4, l);
string s = !strconcat(t5, "}");
}
class ShuffleOneLine<string vecsize, string elem, string type>
{
string t1 = VecModStr<vecsize, elem, "comm", "1">.s;
string t2 = !strconcat(t1, "mov.");
string t3 = !strconcat(t2, type);
string t4 = !strconcat(t3, " \t${dst}_");
string t5 = !strconcat(t4, elem);
string t6 = !strconcat(t5, ", $src1");
string t7 = !strconcat(t6, VecModStr<vecsize, elem, "pos">.s);
string t8 = !strconcat(t7, ";\n\t");
string t9 = !strconcat(t8, VecModStr<vecsize, elem, "comm", "2">.s);
string t10 = !strconcat(t9, "mov.");
string t11 = !strconcat(t10, type);
string t12 = !strconcat(t11, " \t${dst}_");
string t13 = !strconcat(t12, elem);
string t14 = !strconcat(t13, ", $src2");
string t15 = !strconcat(t14, VecModStr<vecsize, elem, "pos">.s);
string s = !strconcat(t15, ";");
}
class ShuffleAsmStr2<string type>
{
string t1 = ShuffleOneLine<"2", "0", type>.s;
string t2 = !strconcat(t1, "\n\t");
string s = !strconcat(t2, ShuffleOneLine<"2", "1", type>.s);
}
class ShuffleAsmStr4<string type>
{
string t1 = ShuffleOneLine<"4", "0", type>.s;
string t2 = !strconcat(t1, "\n\t");
string t3 = !strconcat(t2, ShuffleOneLine<"4", "1", type>.s);
string t4 = !strconcat(t3, "\n\t");
string t5 = !strconcat(t4, ShuffleOneLine<"4", "2", type>.s);
string t6 = !strconcat(t5, "\n\t");
string s = !strconcat(t6, ShuffleOneLine<"4", "3", type>.s);
}
let hasSideEffects=0, VecInstType=isVecShuffle.Value in {
def VecShuffle_v4f32 : NVPTXVecInst<(outs V4F32Regs:$dst),
(ins V4F32Regs:$src1, V4F32Regs:$src2,
i8imm:$c0, i8imm:$c1, i8imm:$c2, i8imm:$c3),
!strconcat("//Mov $dst, $src1, $src2, $c0, $c1, $c2, $c3;\n\t",
ShuffleAsmStr4<"f32">.s),
[], FMOV32rr>;
def VecShuffle_v4i32 : NVPTXVecInst<(outs V4I32Regs:$dst),
(ins V4I32Regs:$src1, V4I32Regs:$src2,
i8imm:$c0, i8imm:$c1, i8imm:$c2, i8imm:$c3),
!strconcat("//Mov $dst, $src1, $src2, $c0, $c1, $c2, $c3;\n\t",
ShuffleAsmStr4<"u32">.s),
[], IMOV32rr>;
def VecShuffle_v4i16 : NVPTXVecInst<(outs V4I16Regs:$dst),
(ins V4I16Regs:$src1, V4I16Regs:$src2,
i8imm:$c0, i8imm:$c1, i8imm:$c2, i8imm:$c3),
!strconcat("//Mov $dst, $src1, $src2, $c0, $c1, $c2, $c3;\n\t",
ShuffleAsmStr4<"u16">.s),
[], IMOV16rr>;
def VecShuffle_v4i8 : NVPTXVecInst<(outs V4I8Regs:$dst),
(ins V4I8Regs:$src1, V4I8Regs:$src2,
i8imm:$c0, i8imm:$c1, i8imm:$c2, i8imm:$c3),
!strconcat("//Mov $dst, $src1, $src2, $c0, $c1, $c2, $c3;\n\t",
ShuffleAsmStr4<"u16">.s),
[], IMOV8rr>;
def VecShuffle_v2f32 : NVPTXVecInst<(outs V2F32Regs:$dst),
(ins V2F32Regs:$src1, V2F32Regs:$src2,
i8imm:$c0, i8imm:$c1),
!strconcat("//Mov $dst, $src1, $src2, $c0, $c1;\n\t",
ShuffleAsmStr2<"f32">.s),
[], FMOV32rr>;
def VecShuffle_v2i32 : NVPTXVecInst<(outs V2I32Regs:$dst),
(ins V2I32Regs:$src1, V2I32Regs:$src2,
i8imm:$c0, i8imm:$c1),
!strconcat("//Mov $dst, $src1, $src2, $c0, $c1;\n\t",
ShuffleAsmStr2<"u32">.s),
[], IMOV32rr>;
def VecShuffle_v2i8 : NVPTXVecInst<(outs V2I8Regs:$dst),
(ins V2I8Regs:$src1, V2I8Regs:$src2,
i8imm:$c0, i8imm:$c1),
!strconcat("//Mov $dst, $src1, $src2, $c0, $c1;\n\t",
ShuffleAsmStr2<"u16">.s),
[], IMOV8rr>;
def VecShuffle_v2i16 : NVPTXVecInst<(outs V2I16Regs:$dst),
(ins V2I16Regs:$src1, V2I16Regs:$src2,
i8imm:$c0, i8imm:$c1),
!strconcat("//Mov $dst, $src1, $src2, $c0, $c1;\n\t",
ShuffleAsmStr2<"u16">.s),
[], IMOV16rr>;
def VecShuffle_v2f64 : NVPTXVecInst<(outs V2F64Regs:$dst),
(ins V2F64Regs:$src1, V2F64Regs:$src2,
i8imm:$c0, i8imm:$c1),
!strconcat("//Mov $dst, $src1, $src2, $c0, $c1;\n\t",
ShuffleAsmStr2<"f64">.s),
[], FMOV64rr>;
def VecShuffle_v2i64 : NVPTXVecInst<(outs V2I64Regs:$dst),
(ins V2I64Regs:$src1, V2I64Regs:$src2,
i8imm:$c0, i8imm:$c1),
!strconcat("//Mov $dst, $src1, $src2, $c0, $c1;\n\t",
ShuffleAsmStr2<"u64">.s),
[], IMOV64rr>;
}
def ShuffleMask0 : SDNodeXForm<vector_shuffle, [{
ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
return CurDAG->getTargetConstant(SVOp->getMaskElt(0), SDLoc(N), MVT::i32);
}]>;
def ShuffleMask1 : SDNodeXForm<vector_shuffle, [{
ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
return CurDAG->getTargetConstant(SVOp->getMaskElt(1), SDLoc(N), MVT::i32);
}]>;
def ShuffleMask2 : SDNodeXForm<vector_shuffle, [{
ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
return CurDAG->getTargetConstant(SVOp->getMaskElt(2), SDLoc(N), MVT::i32);
}]>;
def ShuffleMask3 : SDNodeXForm<vector_shuffle, [{
ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
return CurDAG->getTargetConstant(SVOp->getMaskElt(3), SDLoc(N), MVT::i32);
}]>;
// The spurious call is here to silence a compiler warning about N being
// unused.
def vec_shuf : PatFrag<(ops node:$lhs, node:$rhs),
(vector_shuffle node:$lhs, node:$rhs),
[{ N->getGluedNode(); return true; }]>;
def : Pat<(v2f64 (vec_shuf:$op V2F64Regs:$src1, V2F64Regs:$src2)),
(VecShuffle_v2f64 V2F64Regs:$src1, V2F64Regs:$src2,
(ShuffleMask0 node:$op), (ShuffleMask1 node:$op))>;
def : Pat<(v4f32 (vec_shuf:$op V4F32Regs:$src1, V4F32Regs:$src2)),
(VecShuffle_v4f32 V4F32Regs:$src1, V4F32Regs:$src2,
(ShuffleMask0 node:$op), (ShuffleMask1 node:$op),
(ShuffleMask2 node:$op), (ShuffleMask3 node:$op))>;
def : Pat<(v2f32 (vec_shuf:$op V2F32Regs:$src1, V2F32Regs:$src2)),
(VecShuffle_v2f32 V2F32Regs:$src1, V2F32Regs:$src2,
(ShuffleMask0 node:$op), (ShuffleMask1 node:$op))>;
def : Pat<(v2i64 (vec_shuf:$op V2I64Regs:$src1, V2I64Regs:$src2)),
(VecShuffle_v2i64 V2I64Regs:$src1, V2I64Regs:$src2,
(ShuffleMask0 node:$op), (ShuffleMask1 node:$op))>;
def : Pat<(v4i32 (vec_shuf:$op V4I32Regs:$src1, V4I32Regs:$src2)),
(VecShuffle_v4i32 V4I32Regs:$src1, V4I32Regs:$src2,
(ShuffleMask0 node:$op), (ShuffleMask1 node:$op),
(ShuffleMask2 node:$op), (ShuffleMask3 node:$op))>;
def : Pat<(v2i32 (vec_shuf:$op V2I32Regs:$src1, V2I32Regs:$src2)),
(VecShuffle_v2i32 V2I32Regs:$src1, V2I32Regs:$src2,
(ShuffleMask0 node:$op), (ShuffleMask1 node:$op))>;
def : Pat<(v4i16 (vec_shuf:$op V4I16Regs:$src1, V4I16Regs:$src2)),
(VecShuffle_v4i16 V4I16Regs:$src1, V4I16Regs:$src2,
(ShuffleMask0 node:$op), (ShuffleMask1 node:$op),
(ShuffleMask2 node:$op), (ShuffleMask3 node:$op))>;
def : Pat<(v2i16 (vec_shuf:$op V2I16Regs:$src1, V2I16Regs:$src2)),
(VecShuffle_v2i16 V2I16Regs:$src1, V2I16Regs:$src2,
(ShuffleMask0 node:$op), (ShuffleMask1 node:$op))>;
def : Pat<(v4i8 (vec_shuf:$op V4I8Regs:$src1, V4I8Regs:$src2)),
(VecShuffle_v4i8 V4I8Regs:$src1, V4I8Regs:$src2,
(ShuffleMask0 node:$op), (ShuffleMask1 node:$op),
(ShuffleMask2 node:$op), (ShuffleMask3 node:$op))>;
def : Pat<(v2i8 (vec_shuf:$op V2I8Regs:$src1, V2I8Regs:$src2)),
(VecShuffle_v2i8 V2I8Regs:$src1, V2I8Regs:$src2,
(ShuffleMask0 node:$op), (ShuffleMask1 node:$op))>;
class Build_Vector2<string asmstr, NVPTXRegClass vclass, NVPTXRegClass sclass,
NVPTXInst si>
: NVPTXVecInst<(outs vclass:$dst),
(ins sclass:$a1, sclass:$a2),
!strconcat(asmstr, "\t${dst:vecfull}, {{$a1, $a2}};"),
[(set vclass:$dst, (build_vector sclass:$a1, sclass:$a2))],
si>;
class Build_Vector4<string asmstr, NVPTXRegClass vclass, NVPTXRegClass sclass,
NVPTXInst si>
: NVPTXVecInst<(outs vclass:$dst),
(ins sclass:$a1, sclass:$a2, sclass:$a3, sclass:$a4),
!strconcat(asmstr, "\t${dst:vecfull}, {{$a1, $a2, $a3, $a4}};"),
[(set vclass:$dst,
(build_vector sclass:$a1, sclass:$a2,
sclass:$a3, sclass:$a4))], si>;
let isAsCheapAsAMove=1, VecInstType=isVecBuild.Value in {
def Build_Vector2_f32 : Build_Vector2<"mov.v2.f32", V2F32Regs, Float32Regs,
FMOV32rr>;
def Build_Vector2_f64 : Build_Vector2<"mov.v2.f64", V2F64Regs, Float64Regs,
FMOV64rr>;
def Build_Vector2_i32 : Build_Vector2<"mov.v2.u32", V2I32Regs, Int32Regs,
IMOV32rr>;
def Build_Vector2_i64 : Build_Vector2<"mov.v2.u64", V2I64Regs, Int64Regs,
IMOV64rr>;
def Build_Vector2_i16 : Build_Vector2<"mov.v2.u16", V2I16Regs, Int16Regs,
IMOV16rr>;
def Build_Vector2_i8 : Build_Vector2<"mov.v2.u16", V2I8Regs, Int8Regs,
IMOV8rr>;
def Build_Vector4_f32 : Build_Vector4<"mov.v4.f32", V4F32Regs, Float32Regs,
FMOV32rr>;
def Build_Vector4_i32 : Build_Vector4<"mov.v4.u32", V4I32Regs, Int32Regs,
IMOV32rr>;
def Build_Vector4_i16 : Build_Vector4<"mov.v4.u16", V4I16Regs, Int16Regs,
IMOV16rr>;
def Build_Vector4_i8 : Build_Vector4<"mov.v4.u16", V4I8Regs, Int8Regs,
IMOV8rr>;
}
class Vec_Move<string asmstr, NVPTXRegClass vclass, NVPTXInst sop=NOP>
: NVPTXVecInst<(outs vclass:$dst), (ins vclass:$src),
!strconcat(asmstr, "\t${dst:vecfull}, ${src:vecfull};"),
[], sop>;
let isAsCheapAsAMove=1, hasSideEffects=0, IsSimpleMove=1,
VecInstType=isVecOther.Value in {
def V4f32Mov : Vec_Move<"mov.v4.f32", V4F32Regs, FMOV32rr>;
def V2f32Mov : Vec_Move<"mov.v2.f32", V2F32Regs, FMOV32rr>;
def V4i32Mov : Vec_Move<"mov.v4.u32", V4I32Regs, IMOV32rr>;
def V2i32Mov : Vec_Move<"mov.v2.u32", V2I32Regs, IMOV32rr>;
def V4i16Mov : Vec_Move<"mov.v4.u16", V4I16Regs, IMOV16rr>;
def V2i16Mov : Vec_Move<"mov.v2.u16", V2I16Regs, IMOV16rr>;
def V4i8Mov : Vec_Move<"mov.v4.u16", V4I8Regs, IMOV8rr>;
def V2i8Mov : Vec_Move<"mov.v2.u16", V2I8Regs, IMOV8rr>;
def V2f64Mov : Vec_Move<"mov.v2.f64", V2F64Regs, FMOV64rr>;
def V2i64Mov : Vec_Move<"mov.v2.u64", V2I64Regs, IMOV64rr>;
}
// extract subvector patterns
def extract_subvec : SDNode<"ISD::EXTRACT_SUBVECTOR",
SDTypeProfile<1, 2, [SDTCisPtrTy<2>]>>;
def : Pat<(v2f32 (extract_subvec V4F32Regs:$src, 0)),
(Build_Vector2_f32 (V4f32Extract V4F32Regs:$src, 0),
(V4f32Extract V4F32Regs:$src, 1))>;
def : Pat<(v2f32 (extract_subvec V4F32Regs:$src, 2)),
(Build_Vector2_f32 (V4f32Extract V4F32Regs:$src, 2),
(V4f32Extract V4F32Regs:$src, 3))>;
def : Pat<(v2i32 (extract_subvec V4I32Regs:$src, 0)),
(Build_Vector2_i32 (V4i32Extract V4I32Regs:$src, 0),
(V4i32Extract V4I32Regs:$src, 1))>;
def : Pat<(v2i32 (extract_subvec V4I32Regs:$src, 2)),
(Build_Vector2_i32 (V4i32Extract V4I32Regs:$src, 2),
(V4i32Extract V4I32Regs:$src, 3))>;
def : Pat<(v2i16 (extract_subvec V4I16Regs:$src, 0)),
(Build_Vector2_i16 (V4i16Extract V4I16Regs:$src, 0),
(V4i16Extract V4I16Regs:$src, 1))>;
def : Pat<(v2i16 (extract_subvec V4I16Regs:$src, 2)),
(Build_Vector2_i16 (V4i16Extract V4I16Regs:$src, 2),
(V4i16Extract V4I16Regs:$src, 3))>;
def : Pat<(v2i8 (extract_subvec V4I8Regs:$src, 0)),
(Build_Vector2_i8 (V4i8Extract V4I8Regs:$src, 0),
(V4i8Extract V4I8Regs:$src, 1))>;
def : Pat<(v2i8 (extract_subvec V4I8Regs:$src, 2)),
(Build_Vector2_i8 (V4i8Extract V4I8Regs:$src, 2),
(V4i8Extract V4I8Regs:$src, 3))>;
// Select instructions
class Select_OneLine<string type, string pos> {
string t1 = !strconcat("selp.", type);
string t2 = !strconcat(t1, " \t${dst}_");
string t3 = !strconcat(t2, pos);
string t4 = !strconcat(t3, ", ${src1}_");
string t5 = !strconcat(t4, pos);
string t6 = !strconcat(t5, ", ${src2}_");
string t7 = !strconcat(t6, pos);
string s = !strconcat(t7, ", $p;");
}
class Select_Str2<string type> {
string t1 = Select_OneLine<type, "0">.s;
string t2 = !strconcat(t1, "\n\t");
string s = !strconcat(t2, Select_OneLine<type, "1">.s);
}
class Select_Str4<string type> {
string t1 = Select_OneLine<type, "0">.s;
string t2 = !strconcat(t1, "\n\t");
string t3 = !strconcat(t2, Select_OneLine<type, "1">.s);
string t4 = !strconcat(t3, "\n\t");
string t5 = !strconcat(t4, Select_OneLine<type, "2">.s);
string t6 = !strconcat(t5, "\n\t");
string s = !strconcat(t6, Select_OneLine<type, "3">.s);
}
class Vec_Select<NVPTXRegClass vclass, string asmstr, NVPTXInst sop>
: NVPTXVecInst<(outs vclass:$dst),
(ins vclass:$src1, vclass:$src2, Int1Regs:$p),
asmstr,
[(set vclass:$dst, (select Int1Regs:$p, vclass:$src1,
vclass:$src2))],
sop>;
let VecInstType=isVecOther.Value in {
def V2I64_Select : Vec_Select<V2I64Regs, Select_Str2<"b64">.s, SELECTi64rr>;
def V4I32_Select : Vec_Select<V4I32Regs, Select_Str4<"b32">.s, SELECTi32rr>;
def V2I32_Select : Vec_Select<V2I32Regs, Select_Str2<"b32">.s, SELECTi32rr>;
def V4I16_Select : Vec_Select<V4I16Regs, Select_Str4<"b16">.s, SELECTi16rr>;
def V2I16_Select : Vec_Select<V2I16Regs, Select_Str2<"b16">.s, SELECTi16rr>;
def V4I8_Select : Vec_Select<V4I8Regs, Select_Str4<"b16">.s, SELECTi8rr>;
def V2I8_Select : Vec_Select<V2I8Regs, Select_Str2<"b16">.s, SELECTi8rr>;
def V2F64_Select : Vec_Select<V2F64Regs, Select_Str2<"f64">.s, SELECTf64rr>;
def V4F32_Select : Vec_Select<V4F32Regs, Select_Str4<"f32">.s, SELECTf32rr>;
def V2F32_Select : Vec_Select<V2F32Regs, Select_Str2<"f32">.s, SELECTf32rr>;
}
// Comparison instructions
// setcc convenience fragments.
def vsetoeq : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETOEQ)>;
def vsetogt : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETOGT)>;
def vsetoge : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETOGE)>;
def vsetolt : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETOLT)>;
def vsetole : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETOLE)>;
def vsetone : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETONE)>;
def vseto : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETO)>;
def vsetuo : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETUO)>;
def vsetueq : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETUEQ)>;
def vsetugt : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETUGT)>;
def vsetuge : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETUGE)>;
def vsetult : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETULT)>;
def vsetule : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETULE)>;
def vsetune : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETUNE)>;
def vseteq : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETEQ)>;
def vsetgt : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETGT)>;
def vsetge : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETGE)>;
def vsetlt : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETLT)>;
def vsetle : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETLE)>;
def vsetne : PatFrag<(ops node:$lhs, node:$rhs),
(setcc node:$lhs, node:$rhs, SETNE)>;
class Vec_Compare<PatFrag op, NVPTXRegClass outrclass, NVPTXRegClass inrclass,
NVPTXInst sop>
: NVPTXVecInst<(outs outrclass:$dst),
(ins inrclass:$a, inrclass:$b),
"Unsupported",
[(set outrclass:$dst, (op inrclass:$a, inrclass:$b))],
sop>;
multiclass Vec_Compare_All<PatFrag op,
NVPTXInst inst8,
NVPTXInst inst16,
NVPTXInst inst32,
NVPTXInst inst64>
{
def V2I8 : Vec_Compare<op, V2I8Regs, V2I8Regs, inst8>;
def V4I8 : Vec_Compare<op, V4I8Regs, V4I8Regs, inst8>;
def V2I16 : Vec_Compare<op, V2I16Regs, V2I16Regs, inst16>;
def V4I16 : Vec_Compare<op, V4I16Regs, V4I16Regs, inst16>;
def V2I32 : Vec_Compare<op, V2I32Regs, V2I32Regs, inst32>;
def V4I32 : Vec_Compare<op, V4I32Regs, V4I32Regs, inst32>;
def V2I64 : Vec_Compare<op, V2I64Regs, V2I64Regs, inst64>;
}
let VecInstType=isVecOther.Value in {
defm VecSGT : Vec_Compare_All<vsetgt, ISetSGTi8rr_toi8, ISetSGTi16rr_toi16,
ISetSGTi32rr_toi32, ISetSGTi64rr_toi64>;
defm VecUGT : Vec_Compare_All<vsetugt, ISetUGTi8rr_toi8, ISetUGTi16rr_toi16,
ISetUGTi32rr_toi32, ISetUGTi64rr_toi64>;
defm VecSLT : Vec_Compare_All<vsetlt, ISetSLTi8rr_toi8, ISetSLTi16rr_toi16,
ISetSLTi32rr_toi32, ISetSLTi64rr_toi64>;
defm VecULT : Vec_Compare_All<vsetult, ISetULTi8rr_toi8, ISetULTi16rr_toi16,
ISetULTi32rr_toi32, ISetULTi64rr_toi64>;
defm VecSGE : Vec_Compare_All<vsetge, ISetSGEi8rr_toi8, ISetSGEi16rr_toi16,
ISetSGEi32rr_toi32, ISetSGEi64rr_toi64>;
defm VecUGE : Vec_Compare_All<vsetuge, ISetUGEi8rr_toi8, ISetUGEi16rr_toi16,
ISetUGEi32rr_toi32, ISetUGEi64rr_toi64>;
defm VecSLE : Vec_Compare_All<vsetle, ISetSLEi8rr_toi8, ISetSLEi16rr_toi16,
ISetSLEi32rr_toi32, ISetSLEi64rr_toi64>;
defm VecULE : Vec_Compare_All<vsetule, ISetULEi8rr_toi8, ISetULEi16rr_toi16,
ISetULEi32rr_toi32, ISetULEi64rr_toi64>;
defm VecSEQ : Vec_Compare_All<vseteq, ISetSEQi8rr_toi8, ISetSEQi16rr_toi16,
ISetSEQi32rr_toi32, ISetSEQi64rr_toi64>;
defm VecUEQ : Vec_Compare_All<vsetueq, ISetUEQi8rr_toi8, ISetUEQi16rr_toi16,
ISetUEQi32rr_toi32, ISetUEQi64rr_toi64>;
defm VecSNE : Vec_Compare_All<vsetne, ISetSNEi8rr_toi8, ISetSNEi16rr_toi16,
ISetSNEi32rr_toi32, ISetSNEi64rr_toi64>;
defm VecUNE : Vec_Compare_All<vsetune, ISetUNEi8rr_toi8, ISetUNEi16rr_toi16,
ISetUNEi32rr_toi32, ISetUNEi64rr_toi64>;
}
multiclass FVec_Compare_All<PatFrag op,
NVPTXInst instf32,
NVPTXInst instf64>
{
def V2F32 : Vec_Compare<op, V2I32Regs, V2F32Regs, instf32>;
def V4F32 : Vec_Compare<op, V4I32Regs, V4F32Regs, instf32>;
def V2F64 : Vec_Compare<op, V2I64Regs, V2F64Regs, instf64>;
}
let VecInstType=isVecOther.Value in {
defm FVecGT : FVec_Compare_All<vsetogt, FSetGTf32rr_toi32,
FSetGTf64rr_toi64>;
defm FVecLT : FVec_Compare_All<vsetolt, FSetLTf32rr_toi32,
FSetLTf64rr_toi64>;
defm FVecGE : FVec_Compare_All<vsetoge, FSetGEf32rr_toi32,
FSetGEf64rr_toi64>;
defm FVecLE : FVec_Compare_All<vsetole, FSetLEf32rr_toi32,
FSetLEf64rr_toi64>;
defm FVecEQ : FVec_Compare_All<vsetoeq, FSetEQf32rr_toi32,
FSetEQf64rr_toi64>;
defm FVecNE : FVec_Compare_All<vsetone, FSetNEf32rr_toi32,
FSetNEf64rr_toi64>;
defm FVecUGT : FVec_Compare_All<vsetugt, FSetUGTf32rr_toi32,
FSetUGTf64rr_toi64>;
defm FVecULT : FVec_Compare_All<vsetult, FSetULTf32rr_toi32,
FSetULTf64rr_toi64>;
defm FVecUGE : FVec_Compare_All<vsetuge, FSetUGEf32rr_toi32,
FSetUGEf64rr_toi64>;
defm FVecULE : FVec_Compare_All<vsetule, FSetULEf32rr_toi32,
FSetULEf64rr_toi64>;
defm FVecUEQ : FVec_Compare_All<vsetueq, FSetUEQf32rr_toi32,
FSetUEQf64rr_toi64>;
defm FVecUNE : FVec_Compare_All<vsetune, FSetUNEf32rr_toi32,
FSetUNEf64rr_toi64>;
defm FVecNUM : FVec_Compare_All<vseto, FSetNUMf32rr_toi32,
FSetNUMf64rr_toi64>;
defm FVecNAN : FVec_Compare_All<vsetuo, FSetNANf32rr_toi32,
FSetNANf64rr_toi64>;
}
class LoadParamScalar4Inst<NVPTXRegClass regclass, string opstr> :
NVPTXInst<(outs regclass:$d1, regclass:$d2, regclass:$d3, regclass:$d4),
(ins i32imm:$a, i32imm:$b),
!strconcat(!strconcat("ld.param", opstr),
"\t{{$d1, $d2, $d3, $d4}}, [retval0+$b];"), []>;
class LoadParamScalar2Inst<NVPTXRegClass regclass, string opstr> :
NVPTXInst<(outs regclass:$d1, regclass:$d2),
(ins i32imm:$a, i32imm:$b),
!strconcat(!strconcat("ld.param", opstr),
"\t{{$d1, $d2}}, [retval0+$b];"), []>;
class StoreParamScalar4Inst<NVPTXRegClass regclass, string opstr> :
NVPTXInst<(outs),
(ins regclass:$s1, regclass:$s2, regclass:$s3, regclass:$s4,
i32imm:$a, i32imm:$b),
!strconcat(!strconcat("st.param", opstr),
"\t[param$a+$b], {{$s1, $s2, $s3, $s4}};"), []>;
class StoreParamScalar2Inst<NVPTXRegClass regclass, string opstr> :
NVPTXInst<(outs),
(ins regclass:$s1, regclass:$s2, i32imm:$a, i32imm:$b),
!strconcat(!strconcat("st.param", opstr),
"\t[param$a+$b], {{$s1, $s2}};"), []>;
class StoreRetvalScalar4Inst<NVPTXRegClass regclass, string opstr> :
NVPTXInst<(outs),
(ins regclass:$s1, regclass:$s2, regclass:$s3, regclass:$s4,
i32imm:$a),
!strconcat(!strconcat("st.param", opstr),
"\t[func_retval+$a], {{$s1, $s2, $s3, $s4}};"), []>;
class StoreRetvalScalar2Inst<NVPTXRegClass regclass, string opstr> :
NVPTXInst<(outs),
(ins regclass:$s1, regclass:$s2, i32imm:$a),
!strconcat(!strconcat("st.param", opstr),
"\t[func_retval+$a], {{$s1, $s2}};"), []>;
def LoadParamScalar4I32 : LoadParamScalar4Inst<Int32Regs, ".v4.b32">;
def LoadParamScalar4I16 : LoadParamScalar4Inst<Int16Regs, ".v4.b16">;
def LoadParamScalar4I8 : LoadParamScalar4Inst<Int8Regs, ".v4.b8">;
def LoadParamScalar2I64 : LoadParamScalar2Inst<Int32Regs, ".v2.b64">;
def LoadParamScalar2I32 : LoadParamScalar2Inst<Int32Regs, ".v2.b32">;
def LoadParamScalar2I16 : LoadParamScalar2Inst<Int32Regs, ".v2.b16">;
def LoadParamScalar2I8 : LoadParamScalar2Inst<Int32Regs, ".v2.b8">;
def LoadParamScalar4F32 : LoadParamScalar4Inst<Float32Regs, ".v4.f32">;
def LoadParamScalar2F32 : LoadParamScalar2Inst<Float32Regs, ".v2.f32">;
def LoadParamScalar2F64 : LoadParamScalar2Inst<Float64Regs, ".v2.f64">;
def StoreParamScalar4I32 : StoreParamScalar4Inst<Int32Regs, ".v4.b32">;
def StoreParamScalar4I16 : StoreParamScalar4Inst<Int16Regs, ".v4.b16">;
def StoreParamScalar4I8 : StoreParamScalar4Inst<Int8Regs, ".v4.b8">;
def StoreParamScalar2I64 : StoreParamScalar2Inst<Int64Regs, ".v2.b64">;
def StoreParamScalar2I32 : StoreParamScalar2Inst<Int32Regs, ".v2.b32">;
def StoreParamScalar2I16 : StoreParamScalar2Inst<Int16Regs, ".v2.b16">;
def StoreParamScalar2I8 : StoreParamScalar2Inst<Int8Regs, ".v2.b8">;
def StoreParamScalar4F32 : StoreParamScalar4Inst<Float32Regs, ".v4.f32">;
def StoreParamScalar2F32 : StoreParamScalar2Inst<Float32Regs, ".v2.f32">;
def StoreParamScalar2F64 : StoreParamScalar2Inst<Float64Regs, ".v2.f64">;
def StoreRetvalScalar4I32 : StoreRetvalScalar4Inst<Int32Regs, ".v4.b32">;
def StoreRetvalScalar4I16 : StoreRetvalScalar4Inst<Int16Regs, ".v4.b16">;
def StoreRetvalScalar4I8 : StoreRetvalScalar4Inst<Int8Regs, ".v4.b8">;
def StoreRetvalScalar2I64 : StoreRetvalScalar2Inst<Int64Regs, ".v2.b64">;
def StoreRetvalScalar2I32 : StoreRetvalScalar2Inst<Int32Regs, ".v2.b32">;
def StoreRetvalScalar2I16 : StoreRetvalScalar2Inst<Int16Regs, ".v2.b16">;
def StoreRetvalScalar2I8 : StoreRetvalScalar2Inst<Int8Regs, ".v2.b8">;
def StoreRetvalScalar4F32 : StoreRetvalScalar4Inst<Float32Regs, ".v4.f32">;
def StoreRetvalScalar2F32 : StoreRetvalScalar2Inst<Float32Regs, ".v2.f32">;
def StoreRetvalScalar2F64 : StoreRetvalScalar2Inst<Float64Regs, ".v2.f64">;
class LoadParamVecInst<NVPTXRegClass regclass, string opstr, NVPTXInst sop=NOP>:
NVPTXVecInst<(outs regclass:$dst), (ins i32imm:$a, i32imm:$b),
"loadparam : $dst <- [$a, $b]",
[(set regclass:$dst, (LoadParam (i32 imm:$a), (i32 imm:$b)))],
sop>;
class StoreParamVecInst<NVPTXRegClass regclass, string opstr, NVPTXInst sop=NOP>
: NVPTXVecInst<(outs), (ins regclass:$val, i32imm:$a, i32imm:$b),
"storeparam : [$a, $b] <- $val",
[(StoreParam (i32 imm:$a), (i32 imm:$b), regclass:$val)], sop>;
class StoreRetvalVecInst<NVPTXRegClass regclass, string opstr,
NVPTXInst sop=NOP>
: NVPTXVecInst<(outs), (ins regclass:$val, i32imm:$a),
"storeretval : retval[$a] <- $val",
[(StoreRetval (i32 imm:$a), regclass:$val)], sop>;
let VecInstType=isVecLD.Value in {
def LoadParamV4I32 : LoadParamVecInst<V4I32Regs, ".v4.b32",
LoadParamScalar4I32>;
def LoadParamV4I16 : LoadParamVecInst<V4I16Regs, ".v4.b16",
LoadParamScalar4I16>;
def LoadParamV4I8 : LoadParamVecInst<V4I8Regs, ".v4.b8",
LoadParamScalar4I8>;
def LoadParamV2I64 : LoadParamVecInst<V2I64Regs, ".v2.b64",
LoadParamScalar2I64>;
def LoadParamV2I32 : LoadParamVecInst<V2I32Regs, ".v2.b32",
LoadParamScalar2I32>;
def LoadParamV2I16 : LoadParamVecInst<V2I16Regs, ".v2.b16",
LoadParamScalar2I16>;
def LoadParamV2I8 : LoadParamVecInst<V2I8Regs, ".v2.b8",
LoadParamScalar2I8>;
def LoadParamV4F32 : LoadParamVecInst<V4F32Regs, ".v4.f32",
LoadParamScalar4F32>;
def LoadParamV2F32 : LoadParamVecInst<V2F32Regs, ".v2.f32",
LoadParamScalar2F32>;
def LoadParamV2F64 : LoadParamVecInst<V2F64Regs, ".v2.f64",
LoadParamScalar2F64>;
}
let VecInstType=isVecST.Value in {
def StoreParamV4I32 : StoreParamVecInst<V4I32Regs, ".v4.b32",
StoreParamScalar4I32>;
def StoreParamV4I16 : StoreParamVecInst<V4I16Regs, ".v4.b16",
StoreParamScalar4I16>;
def StoreParamV4I8 : StoreParamVecInst<V4I8Regs, ".v4.b8",
StoreParamScalar4I8>;
def StoreParamV2I64 : StoreParamVecInst<V2I64Regs, ".v2.b64",
StoreParamScalar2I64>;
def StoreParamV2I32 : StoreParamVecInst<V2I32Regs, ".v2.b32",
StoreParamScalar2I32>;
def StoreParamV2I16 : StoreParamVecInst<V2I16Regs, ".v2.b16",
StoreParamScalar2I16>;
def StoreParamV2I8 : StoreParamVecInst<V2I8Regs, ".v2.b8",
StoreParamScalar2I8>;
def StoreParamV4F32 : StoreParamVecInst<V4F32Regs, ".v4.f32",
StoreParamScalar4F32>;
def StoreParamV2F32 : StoreParamVecInst<V2F32Regs, ".v2.f32",
StoreParamScalar2F32>;
def StoreParamV2F64 : StoreParamVecInst<V2F64Regs, ".v2.f64",
StoreParamScalar2F64>;
def StoreRetvalV4I32 : StoreRetvalVecInst<V4I32Regs, ".v4.b32",
StoreRetvalScalar4I32>;
def StoreRetvalV4I16 : StoreRetvalVecInst<V4I16Regs, ".v4.b16",
StoreRetvalScalar4I16>;
def StoreRetvalV4I8 : StoreRetvalVecInst<V4I8Regs, ".v4.b8",
StoreRetvalScalar4I8>;
def StoreRetvalV2I64 : StoreRetvalVecInst<V2I64Regs, ".v2.b64",
StoreRetvalScalar2I64>;
def StoreRetvalV2I32 : StoreRetvalVecInst<V2I32Regs, ".v2.b32",
StoreRetvalScalar2I32>;
def StoreRetvalV2I16 : StoreRetvalVecInst<V2I16Regs, ".v2.b16",
StoreRetvalScalar2I16>;
def StoreRetvalV2I8 : StoreRetvalVecInst<V2I8Regs, ".v2.b8",
StoreRetvalScalar2I8>;
def StoreRetvalV4F32 : StoreRetvalVecInst<V4F32Regs, ".v4.f32",
StoreRetvalScalar4F32>;
def StoreRetvalV2F32 : StoreRetvalVecInst<V2F32Regs, ".v2.f32",
StoreRetvalScalar2F32>;
def StoreRetvalV2F64 : StoreRetvalVecInst<V2F64Regs, ".v2.f64",
StoreRetvalScalar2F64>;
}
// Int vector to int scalar bit convert
// v4i8 -> i32
def : Pat<(i32 (bitconvert V4I8Regs:$s)),
(V4I8toI32 (V4i8Extract V4I8Regs:$s,0), (V4i8Extract V4I8Regs:$s,1),
(V4i8Extract V4I8Regs:$s,2), (V4i8Extract V4I8Regs:$s,3))>;
// v4i16 -> i64
def : Pat<(i64 (bitconvert V4I16Regs:$s)),
(V4I16toI64 (V4i16Extract V4I16Regs:$s,0),
(V4i16Extract V4I16Regs:$s,1),
(V4i16Extract V4I16Regs:$s,2),
(V4i16Extract V4I16Regs:$s,3))>;
// v2i8 -> i16
def : Pat<(i16 (bitconvert V2I8Regs:$s)),
(V2I8toI16 (V2i8Extract V2I8Regs:$s,0), (V2i8Extract V2I8Regs:$s,1))>;
// v2i16 -> i32
def : Pat<(i32 (bitconvert V2I16Regs:$s)),
(V2I16toI32 (V2i16Extract V2I16Regs:$s,0),
(V2i16Extract V2I16Regs:$s,1))>;
// v2i32 -> i64
def : Pat<(i64 (bitconvert V2I32Regs:$s)),
(V2I32toI64 (V2i32Extract V2I32Regs:$s,0),
(V2i32Extract V2I32Regs:$s,1))>;
// Int scalar to int vector bit convert
let VecInstType=isVecDest.Value in {
// i32 -> v4i8
def VecI32toV4I8 : NVPTXVecInst<(outs V4I8Regs:$d), (ins Int32Regs:$s),
"Error!",
[(set V4I8Regs:$d, (bitconvert Int32Regs:$s))],
I32toV4I8>;
// i64 -> v4i16
def VecI64toV4I16 : NVPTXVecInst<(outs V4I16Regs:$d), (ins Int64Regs:$s),
"Error!",
[(set V4I16Regs:$d, (bitconvert Int64Regs:$s))],
I64toV4I16>;
// i16 -> v2i8
def VecI16toV2I8 : NVPTXVecInst<(outs V2I8Regs:$d), (ins Int16Regs:$s),
"Error!",
[(set V2I8Regs:$d, (bitconvert Int16Regs:$s))],
I16toV2I8>;
// i32 -> v2i16
def VecI32toV2I16 : NVPTXVecInst<(outs V2I16Regs:$d), (ins Int32Regs:$s),
"Error!",
[(set V2I16Regs:$d, (bitconvert Int32Regs:$s))],
I32toV2I16>;
// i64 -> v2i32
def VecI64toV2I32 : NVPTXVecInst<(outs V2I32Regs:$d), (ins Int64Regs:$s),
"Error!",
[(set V2I32Regs:$d, (bitconvert Int64Regs:$s))],
I64toV2I32>;
}
// Int vector to int vector bit convert
// v4i8 -> v2i16
def : Pat<(v2i16 (bitconvert V4I8Regs:$s)),
(VecI32toV2I16
(V4I8toI32 (V4i8Extract V4I8Regs:$s,0), (V4i8Extract V4I8Regs:$s,1),
(V4i8Extract V4I8Regs:$s,2), (V4i8Extract V4I8Regs:$s,3)))>;
// v4i16 -> v2i32
def : Pat<(v2i32 (bitconvert V4I16Regs:$s)),
(VecI64toV2I32
(V4I16toI64 (V4i16Extract V4I16Regs:$s,0), (V4i16Extract V4I16Regs:$s,1),
(V4i16Extract V4I16Regs:$s,2), (V4i16Extract V4I16Regs:$s,3)))>;
// v2i16 -> v4i8
def : Pat<(v4i8 (bitconvert V2I16Regs:$s)),
(VecI32toV4I8
(V2I16toI32 (V2i16Extract V2I16Regs:$s,0), (V2i16Extract V2I16Regs:$s,1)))>;
// v2i32 -> v4i16
def : Pat<(v4i16 (bitconvert V2I32Regs:$s)),
(VecI64toV4I16
(V2I32toI64 (V2i32Extract V2I32Regs:$s,0), (V2i32Extract V2I32Regs:$s,1)))>;
// v2i64 -> v4i32
def : Pat<(v4i32 (bitconvert V2I64Regs:$s)),
(Build_Vector4_i32
(V2i32Extract (VecI64toV2I32 (V2i64Extract V2I64Regs:$s, 0)), 0),
(V2i32Extract (VecI64toV2I32 (V2i64Extract V2I64Regs:$s, 0)), 1),
(V2i32Extract (VecI64toV2I32 (V2i64Extract V2I64Regs:$s, 1)), 0),
(V2i32Extract (VecI64toV2I32 (V2i64Extract V2I64Regs:$s, 1)), 1))>;
// v4i32 -> v2i64
def : Pat<(v2i64 (bitconvert V4I32Regs:$s)),
(Build_Vector2_i64
(V2I32toI64 (V4i32Extract V4I32Regs:$s,0), (V4i32Extract V4I32Regs:$s,1)),
(V2I32toI64 (V4i32Extract V4I32Regs:$s,2), (V4i32Extract V4I32Regs:$s,3)))>;
// Fp scalar to fp vector convert
// f64 -> v2f32
let VecInstType=isVecDest.Value in {
def VecF64toV2F32 : NVPTXVecInst<(outs V2F32Regs:$d), (ins Float64Regs:$s),
"Error!",
[(set V2F32Regs:$d, (bitconvert Float64Regs:$s))],
F64toV2F32>;
}
// Fp vector to fp scalar convert
// v2f32 -> f64
def : Pat<(f64 (bitconvert V2F32Regs:$s)),
(V2F32toF64 (V2f32Extract V2F32Regs:$s,0), (V2f32Extract V2F32Regs:$s,1))>;
// Fp scalar to int vector convert
// f32 -> v4i8
def : Pat<(v4i8 (bitconvert Float32Regs:$s)),
(VecI32toV4I8 (BITCONVERT_32_F2I Float32Regs:$s))>;
// f32 -> v2i16
def : Pat<(v2i16 (bitconvert Float32Regs:$s)),
(VecI32toV2I16 (BITCONVERT_32_F2I Float32Regs:$s))>;
// f64 -> v4i16
def : Pat<(v4i16 (bitconvert Float64Regs:$s)),
(VecI64toV4I16 (BITCONVERT_64_F2I Float64Regs:$s))>;
// f64 -> v2i32
def : Pat<(v2i32 (bitconvert Float64Regs:$s)),
(VecI64toV2I32 (BITCONVERT_64_F2I Float64Regs:$s))>;
// Int vector to fp scalar convert
// v4i8 -> f32
def : Pat<(f32 (bitconvert V4I8Regs:$s)),
(BITCONVERT_32_I2F
(V4I8toI32 (V4i8Extract V4I8Regs:$s,0), (V4i8Extract V4I8Regs:$s,1),
(V4i8Extract V4I8Regs:$s,2), (V4i8Extract V4I8Regs:$s,3)))>;
// v4i16 -> f64
def : Pat<(f64 (bitconvert V4I16Regs:$s)),
(BITCONVERT_64_I2F
(V4I16toI64 (V4i16Extract V4I16Regs:$s,0), (V4i16Extract V4I16Regs:$s,1),
(V4i16Extract V4I16Regs:$s,2), (V4i16Extract V4I16Regs:$s,3)))>;
// v2i16 -> f32
def : Pat<(f32 (bitconvert V2I16Regs:$s)),
(BITCONVERT_32_I2F
(V2I16toI32 (V2i16Extract V2I16Regs:$s,0), (V2i16Extract V2I16Regs:$s,1)))>;
// v2i32 -> f64
def : Pat<(f64 (bitconvert V2I32Regs:$s)),
(BITCONVERT_64_I2F
(V2I32toI64 (V2i32Extract V2I32Regs:$s,0), (V2i32Extract V2I32Regs:$s,1)))>;
// Int scalar to fp vector convert
// i64 -> v2f32
def : Pat<(v2f32 (bitconvert Int64Regs:$s)),
(VecF64toV2F32 (BITCONVERT_64_I2F Int64Regs:$s))>;
// Fp vector to int scalar convert
// v2f32 -> i64
def : Pat<(i64 (bitconvert V2F32Regs:$s)),
(BITCONVERT_64_F2I
(V2F32toF64 (V2f32Extract V2F32Regs:$s,0), (V2f32Extract V2F32Regs:$s,1)))>;
// Int vector to fp vector convert
// v2i64 -> v4f32
def : Pat<(v4f32 (bitconvert V2I64Regs:$s)),
(Build_Vector4_f32
(BITCONVERT_32_I2F (V2i32Extract (VecI64toV2I32
(V2i64Extract V2I64Regs:$s, 0)), 0)),
(BITCONVERT_32_I2F (V2i32Extract (VecI64toV2I32
(V2i64Extract V2I64Regs:$s, 0)), 1)),
(BITCONVERT_32_I2F (V2i32Extract (VecI64toV2I32
(V2i64Extract V2I64Regs:$s, 1)), 0)),
(BITCONVERT_32_I2F (V2i32Extract (VecI64toV2I32
(V2i64Extract V2I64Regs:$s, 1)), 1)))>;
// v2i64 -> v2f64
def : Pat<(v2f64 (bitconvert V2I64Regs:$s)),
(Build_Vector2_f64
(BITCONVERT_64_I2F (V2i64Extract V2I64Regs:$s,0)),
(BITCONVERT_64_I2F (V2i64Extract V2I64Regs:$s,1)))>;
// v2i32 -> v2f32
def : Pat<(v2f32 (bitconvert V2I32Regs:$s)),
(Build_Vector2_f32
(BITCONVERT_32_I2F (V2i32Extract V2I32Regs:$s,0)),
(BITCONVERT_32_I2F (V2i32Extract V2I32Regs:$s,1)))>;
// v4i32 -> v2f64
def : Pat<(v2f64 (bitconvert V4I32Regs:$s)),
(Build_Vector2_f64
(BITCONVERT_64_I2F (V2I32toI64 (V4i32Extract V4I32Regs:$s,0),
(V4i32Extract V4I32Regs:$s,1))),
(BITCONVERT_64_I2F (V2I32toI64 (V4i32Extract V4I32Regs:$s,2),
(V4i32Extract V4I32Regs:$s,3))))>;
// v4i32 -> v4f32
def : Pat<(v4f32 (bitconvert V4I32Regs:$s)),
(Build_Vector4_f32
(BITCONVERT_32_I2F (V4i32Extract V4I32Regs:$s,0)),
(BITCONVERT_32_I2F (V4i32Extract V4I32Regs:$s,1)),
(BITCONVERT_32_I2F (V4i32Extract V4I32Regs:$s,2)),
(BITCONVERT_32_I2F (V4i32Extract V4I32Regs:$s,3)))>;
// v4i16 -> v2f32
def : Pat<(v2f32 (bitconvert V4I16Regs:$s)),
(VecF64toV2F32 (BITCONVERT_64_I2F
(V4I16toI64 (V4i16Extract V4I16Regs:$s,0),
(V4i16Extract V4I16Regs:$s,1),
(V4i16Extract V4I16Regs:$s,2),
(V4i16Extract V4I16Regs:$s,3))))>;
// Fp vector to int vector convert
// v2i64 <- v4f32
def : Pat<(v2i64 (bitconvert V4F32Regs:$s)),
(Build_Vector2_i64
(BITCONVERT_64_F2I (V2F32toF64 (V4f32Extract V4F32Regs:$s,0),
(V4f32Extract V4F32Regs:$s,1))),
(BITCONVERT_64_F2I (V2F32toF64 (V4f32Extract V4F32Regs:$s,2),
(V4f32Extract V4F32Regs:$s,3))))>;
// v2i64 <- v2f64
def : Pat<(v2i64 (bitconvert V2F64Regs:$s)),
(Build_Vector2_i64
(BITCONVERT_64_F2I (V2f64Extract V2F64Regs:$s,0)),
(BITCONVERT_64_F2I (V2f64Extract V2F64Regs:$s,1)))>;
// v2i32 <- v2f32
def : Pat<(v2i32 (bitconvert V2F32Regs:$s)),
(Build_Vector2_i32
(BITCONVERT_32_F2I (V2f32Extract V2F32Regs:$s,0)),
(BITCONVERT_32_F2I (V2f32Extract V2F32Regs:$s,1)))>;
// v4i32 <- v2f64
def : Pat<(v4i32 (bitconvert V2F64Regs:$s)),
(Build_Vector4_i32
(BITCONVERT_32_F2I (V2f32Extract (VecF64toV2F32
(V2f64Extract V2F64Regs:$s, 0)), 0)),
(BITCONVERT_32_F2I (V2f32Extract (VecF64toV2F32
(V2f64Extract V2F64Regs:$s, 0)), 1)),
(BITCONVERT_32_F2I (V2f32Extract (VecF64toV2F32
(V2f64Extract V2F64Regs:$s, 1)), 0)),
(BITCONVERT_32_F2I (V2f32Extract (VecF64toV2F32
(V2f64Extract V2F64Regs:$s, 1)), 1)))>;
// v4i32 <- v4f32
def : Pat<(v4i32 (bitconvert V4F32Regs:$s)),
(Build_Vector4_i32
(BITCONVERT_32_F2I (V4f32Extract V4F32Regs:$s,0)),
(BITCONVERT_32_F2I (V4f32Extract V4F32Regs:$s,1)),
(BITCONVERT_32_F2I (V4f32Extract V4F32Regs:$s,2)),
(BITCONVERT_32_F2I (V4f32Extract V4F32Regs:$s,3)))>;
// v4i16 <- v2f32
def : Pat<(v4i16 (bitconvert V2F32Regs:$s)),
(VecI64toV4I16 (BITCONVERT_64_F2I
(V2F32toF64 (V2f32Extract V2F32Regs:$s,0),
(V2f32Extract V2F32Regs:$s,1))))>;
Reference in New Issue View Git Blame Copy Permalink