2013-05-07 00:15:19 +08:00
|
|
|
//==- SystemZInstrFormats.td - SystemZ Instruction Formats --*- tablegen -*-==//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Basic SystemZ instruction definition
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
class InstSystemZ<int size, dag outs, dag ins, string asmstr,
|
|
|
|
list<dag> pattern> : Instruction {
|
|
|
|
let Namespace = "SystemZ";
|
|
|
|
|
|
|
|
dag OutOperandList = outs;
|
|
|
|
dag InOperandList = ins;
|
|
|
|
let Size = size;
|
|
|
|
let Pattern = pattern;
|
|
|
|
let AsmString = asmstr;
|
|
|
|
|
2013-07-03 17:19:58 +08:00
|
|
|
// Some instructions come in pairs, one having a 12-bit displacement
|
|
|
|
// and the other having a 20-bit displacement. Both instructions in
|
|
|
|
// the pair have the same DispKey and their DispSizes are "12" and "20"
|
|
|
|
// respectively.
|
|
|
|
string DispKey = "";
|
|
|
|
string DispSize = "none";
|
2013-05-07 00:15:19 +08:00
|
|
|
|
2013-07-03 18:10:02 +08:00
|
|
|
// Many register-based <INSN>R instructions have a memory-based <INSN>
|
|
|
|
// counterpart. OpKey uniquely identifies <INSN>, while OpType is
|
|
|
|
// "reg" for <INSN>R and "mem" for <INSN>.
|
|
|
|
string OpKey = "";
|
|
|
|
string OpType = "none";
|
|
|
|
|
2013-07-20 00:12:08 +08:00
|
|
|
// Many distinct-operands instructions have older 2-operand equivalents.
|
|
|
|
// NumOpsKey uniquely identifies one of these 2-operand and 3-operand pairs,
|
|
|
|
// with NumOpsValue being "2" or "3" as appropriate.
|
|
|
|
string NumOpsKey = "";
|
|
|
|
string NumOpsValue = "none";
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
// True if this instruction is a simple D(X,B) load of a register
|
|
|
|
// (with no sign or zero extension).
|
|
|
|
bit SimpleBDXLoad = 0;
|
|
|
|
|
|
|
|
// True if this instruction is a simple D(X,B) store of a register
|
|
|
|
// (with no truncation).
|
|
|
|
bit SimpleBDXStore = 0;
|
|
|
|
|
|
|
|
// True if this instruction has a 20-bit displacement field.
|
|
|
|
bit Has20BitOffset = 0;
|
|
|
|
|
|
|
|
// True if addresses in this instruction have an index register.
|
|
|
|
bit HasIndex = 0;
|
|
|
|
|
|
|
|
// True if this is a 128-bit pseudo instruction that combines two 64-bit
|
|
|
|
// operations.
|
|
|
|
bit Is128Bit = 0;
|
|
|
|
|
2013-07-03 18:10:02 +08:00
|
|
|
// The access size of all memory operands in bytes, or 0 if not known.
|
|
|
|
bits<5> AccessBytes = 0;
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
let TSFlags{0} = SimpleBDXLoad;
|
|
|
|
let TSFlags{1} = SimpleBDXStore;
|
|
|
|
let TSFlags{2} = Has20BitOffset;
|
|
|
|
let TSFlags{3} = HasIndex;
|
|
|
|
let TSFlags{4} = Is128Bit;
|
2013-07-03 18:10:02 +08:00
|
|
|
let TSFlags{9-5} = AccessBytes;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Mappings between instructions
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
// Return the version of an instruction that has an unsigned 12-bit
|
|
|
|
// displacement.
|
|
|
|
def getDisp12Opcode : InstrMapping {
|
|
|
|
let FilterClass = "InstSystemZ";
|
2013-07-03 17:19:58 +08:00
|
|
|
let RowFields = ["DispKey"];
|
|
|
|
let ColFields = ["DispSize"];
|
2013-05-07 00:15:19 +08:00
|
|
|
let KeyCol = ["20"];
|
|
|
|
let ValueCols = [["12"]];
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the version of an instruction that has a signed 20-bit displacement.
|
|
|
|
def getDisp20Opcode : InstrMapping {
|
|
|
|
let FilterClass = "InstSystemZ";
|
2013-07-03 17:19:58 +08:00
|
|
|
let RowFields = ["DispKey"];
|
|
|
|
let ColFields = ["DispSize"];
|
2013-05-07 00:15:19 +08:00
|
|
|
let KeyCol = ["12"];
|
|
|
|
let ValueCols = [["20"]];
|
|
|
|
}
|
|
|
|
|
2013-07-20 00:12:08 +08:00
|
|
|
// Return the memory form of a register instruction.
|
2013-07-03 18:10:02 +08:00
|
|
|
def getMemOpcode : InstrMapping {
|
|
|
|
let FilterClass = "InstSystemZ";
|
|
|
|
let RowFields = ["OpKey"];
|
|
|
|
let ColFields = ["OpType"];
|
|
|
|
let KeyCol = ["reg"];
|
|
|
|
let ValueCols = [["mem"]];
|
|
|
|
}
|
|
|
|
|
2013-07-20 00:12:08 +08:00
|
|
|
// Return the 3-operand form of a 2-operand instruction.
|
|
|
|
def getThreeOperandOpcode : InstrMapping {
|
|
|
|
let FilterClass = "InstSystemZ";
|
|
|
|
let RowFields = ["NumOpsKey"];
|
|
|
|
let ColFields = ["NumOpsValue"];
|
|
|
|
let KeyCol = ["2"];
|
|
|
|
let ValueCols = [["3"]];
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Instruction formats
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// Formats are specified using operand field declarations of the form:
|
|
|
|
//
|
2013-05-14 17:28:21 +08:00
|
|
|
// bits<4> Rn : register input or output for operand n
|
|
|
|
// bits<m> In : immediate value of width m for operand n
|
|
|
|
// bits<4> BDn : address operand n, which has a base and a displacement
|
|
|
|
// bits<m> XBDn : address operand n, which has an index, a base and a
|
|
|
|
// displacement
|
|
|
|
// bits<4> Xn : index register for address operand n
|
|
|
|
// bits<4> Mn : mode value for operand n
|
2013-05-07 00:15:19 +08:00
|
|
|
//
|
2013-05-14 17:28:21 +08:00
|
|
|
// The operand numbers ("n" in the list above) follow the architecture manual.
|
|
|
|
// Assembly operands sometimes have a different order; in particular, R3 often
|
|
|
|
// is often written between operands 1 and 2.
|
2013-05-07 00:15:19 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
class InstRI<bits<12> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<4, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<32> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<32> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
bits<4> R1;
|
|
|
|
bits<16> I2;
|
|
|
|
|
|
|
|
let Inst{31-24} = op{11-4};
|
|
|
|
let Inst{23-20} = R1;
|
|
|
|
let Inst{19-16} = op{3-0};
|
|
|
|
let Inst{15-0} = I2;
|
|
|
|
}
|
|
|
|
|
2013-05-28 18:41:11 +08:00
|
|
|
class InstRIEb<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<6, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<48> Inst;
|
|
|
|
field bits<48> SoftFail = 0;
|
|
|
|
|
|
|
|
bits<4> R1;
|
|
|
|
bits<4> R2;
|
|
|
|
bits<4> M3;
|
|
|
|
bits<16> RI4;
|
|
|
|
|
|
|
|
let Inst{47-40} = op{15-8};
|
|
|
|
let Inst{39-36} = R1;
|
|
|
|
let Inst{35-32} = R2;
|
|
|
|
let Inst{31-16} = RI4;
|
|
|
|
let Inst{15-12} = M3;
|
|
|
|
let Inst{11-8} = 0;
|
|
|
|
let Inst{7-0} = op{7-0};
|
|
|
|
}
|
|
|
|
|
2013-05-29 19:58:52 +08:00
|
|
|
class InstRIEc<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<6, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<48> Inst;
|
|
|
|
field bits<48> SoftFail = 0;
|
|
|
|
|
|
|
|
bits<4> R1;
|
|
|
|
bits<8> I2;
|
|
|
|
bits<4> M3;
|
|
|
|
bits<16> RI4;
|
|
|
|
|
|
|
|
let Inst{47-40} = op{15-8};
|
|
|
|
let Inst{39-36} = R1;
|
|
|
|
let Inst{35-32} = M3;
|
|
|
|
let Inst{31-16} = RI4;
|
|
|
|
let Inst{15-8} = I2;
|
|
|
|
let Inst{7-0} = op{7-0};
|
|
|
|
}
|
|
|
|
|
2013-07-20 00:32:12 +08:00
|
|
|
class InstRIEd<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<6, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<48> Inst;
|
|
|
|
field bits<48> SoftFail = 0;
|
|
|
|
|
|
|
|
bits<4> R1;
|
|
|
|
bits<4> R3;
|
|
|
|
bits<16> I2;
|
|
|
|
|
|
|
|
let Inst{47-40} = op{15-8};
|
|
|
|
let Inst{39-36} = R1;
|
|
|
|
let Inst{35-32} = R3;
|
|
|
|
let Inst{31-16} = I2;
|
|
|
|
let Inst{15-8} = 0;
|
|
|
|
let Inst{7-0} = op{7-0};
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
class InstRIEf<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<6, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<48> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<48> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
bits<4> R1;
|
|
|
|
bits<4> R2;
|
|
|
|
bits<8> I3;
|
|
|
|
bits<8> I4;
|
|
|
|
bits<8> I5;
|
|
|
|
|
|
|
|
let Inst{47-40} = op{15-8};
|
|
|
|
let Inst{39-36} = R1;
|
|
|
|
let Inst{35-32} = R2;
|
|
|
|
let Inst{31-24} = I3;
|
|
|
|
let Inst{23-16} = I4;
|
|
|
|
let Inst{15-8} = I5;
|
|
|
|
let Inst{7-0} = op{7-0};
|
|
|
|
}
|
|
|
|
|
|
|
|
class InstRIL<bits<12> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<6, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<48> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<48> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
bits<4> R1;
|
|
|
|
bits<32> I2;
|
|
|
|
|
|
|
|
let Inst{47-40} = op{11-4};
|
|
|
|
let Inst{39-36} = R1;
|
|
|
|
let Inst{35-32} = op{3-0};
|
|
|
|
let Inst{31-0} = I2;
|
|
|
|
}
|
|
|
|
|
|
|
|
class InstRR<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<2, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<16> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<16> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
bits<4> R1;
|
|
|
|
bits<4> R2;
|
|
|
|
|
|
|
|
let Inst{15-8} = op;
|
|
|
|
let Inst{7-4} = R1;
|
|
|
|
let Inst{3-0} = R2;
|
|
|
|
}
|
|
|
|
|
|
|
|
class InstRRD<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<4, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<32> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<32> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
bits<4> R1;
|
|
|
|
bits<4> R3;
|
|
|
|
bits<4> R2;
|
|
|
|
|
|
|
|
let Inst{31-16} = op;
|
|
|
|
let Inst{15-12} = R1;
|
|
|
|
let Inst{11-8} = 0;
|
|
|
|
let Inst{7-4} = R3;
|
|
|
|
let Inst{3-0} = R2;
|
|
|
|
}
|
|
|
|
|
|
|
|
class InstRRE<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<4, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<32> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<32> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
bits<4> R1;
|
|
|
|
bits<4> R2;
|
|
|
|
|
|
|
|
let Inst{31-16} = op;
|
|
|
|
let Inst{15-8} = 0;
|
|
|
|
let Inst{7-4} = R1;
|
|
|
|
let Inst{3-0} = R2;
|
|
|
|
}
|
|
|
|
|
|
|
|
class InstRRF<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<4, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<32> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<32> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
bits<4> R1;
|
|
|
|
bits<4> R2;
|
|
|
|
bits<4> R3;
|
|
|
|
|
|
|
|
let Inst{31-16} = op;
|
|
|
|
let Inst{15-12} = R3;
|
|
|
|
let Inst{11-8} = 0;
|
|
|
|
let Inst{7-4} = R1;
|
|
|
|
let Inst{3-0} = R2;
|
|
|
|
}
|
|
|
|
|
|
|
|
class InstRX<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<4, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<32> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<32> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
bits<4> R1;
|
2013-05-14 17:28:21 +08:00
|
|
|
bits<20> XBD2;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
let Inst{31-24} = op;
|
|
|
|
let Inst{23-20} = R1;
|
2013-05-14 17:28:21 +08:00
|
|
|
let Inst{19-0} = XBD2;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
let HasIndex = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
class InstRXE<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<6, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<48> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<48> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
bits<4> R1;
|
2013-05-14 17:28:21 +08:00
|
|
|
bits<20> XBD2;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
let Inst{47-40} = op{15-8};
|
|
|
|
let Inst{39-36} = R1;
|
2013-05-14 17:28:21 +08:00
|
|
|
let Inst{35-16} = XBD2;
|
2013-05-07 00:15:19 +08:00
|
|
|
let Inst{15-8} = 0;
|
|
|
|
let Inst{7-0} = op{7-0};
|
|
|
|
|
|
|
|
let HasIndex = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
class InstRXF<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<6, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<48> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<48> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
bits<4> R1;
|
|
|
|
bits<4> R3;
|
2013-05-14 17:28:21 +08:00
|
|
|
bits<20> XBD2;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
let Inst{47-40} = op{15-8};
|
|
|
|
let Inst{39-36} = R3;
|
2013-05-14 17:28:21 +08:00
|
|
|
let Inst{35-16} = XBD2;
|
2013-05-07 00:15:19 +08:00
|
|
|
let Inst{15-12} = R1;
|
|
|
|
let Inst{11-8} = 0;
|
|
|
|
let Inst{7-0} = op{7-0};
|
|
|
|
|
|
|
|
let HasIndex = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
class InstRXY<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<6, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<48> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<48> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
bits<4> R1;
|
2013-05-14 17:28:21 +08:00
|
|
|
bits<28> XBD2;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
let Inst{47-40} = op{15-8};
|
|
|
|
let Inst{39-36} = R1;
|
2013-05-14 17:28:21 +08:00
|
|
|
let Inst{35-8} = XBD2;
|
2013-05-07 00:15:19 +08:00
|
|
|
let Inst{7-0} = op{7-0};
|
|
|
|
|
|
|
|
let Has20BitOffset = 1;
|
|
|
|
let HasIndex = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
class InstRS<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<4, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<32> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<32> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
bits<4> R1;
|
|
|
|
bits<4> R3;
|
2013-05-14 17:28:21 +08:00
|
|
|
bits<16> BD2;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
let Inst{31-24} = op;
|
|
|
|
let Inst{23-20} = R1;
|
|
|
|
let Inst{19-16} = R3;
|
2013-05-14 17:28:21 +08:00
|
|
|
let Inst{15-0} = BD2;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class InstRSY<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<6, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<48> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<48> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
bits<4> R1;
|
|
|
|
bits<4> R3;
|
2013-05-14 17:28:21 +08:00
|
|
|
bits<24> BD2;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
let Inst{47-40} = op{15-8};
|
|
|
|
let Inst{39-36} = R1;
|
|
|
|
let Inst{35-32} = R3;
|
2013-05-14 17:28:21 +08:00
|
|
|
let Inst{31-8} = BD2;
|
2013-05-07 00:15:19 +08:00
|
|
|
let Inst{7-0} = op{7-0};
|
|
|
|
|
|
|
|
let Has20BitOffset = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
class InstSI<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<4, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<32> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<32> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
2013-05-14 17:28:21 +08:00
|
|
|
bits<16> BD1;
|
2013-05-07 00:15:19 +08:00
|
|
|
bits<8> I2;
|
|
|
|
|
|
|
|
let Inst{31-24} = op;
|
|
|
|
let Inst{23-16} = I2;
|
2013-05-14 17:28:21 +08:00
|
|
|
let Inst{15-0} = BD1;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class InstSIL<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<6, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<48> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<48> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
2013-05-14 17:28:21 +08:00
|
|
|
bits<16> BD1;
|
2013-05-07 00:15:19 +08:00
|
|
|
bits<16> I2;
|
|
|
|
|
|
|
|
let Inst{47-32} = op;
|
2013-05-14 17:28:21 +08:00
|
|
|
let Inst{31-16} = BD1;
|
2013-05-07 00:15:19 +08:00
|
|
|
let Inst{15-0} = I2;
|
|
|
|
}
|
|
|
|
|
|
|
|
class InstSIY<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<6, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<48> Inst;
|
2013-05-14 18:17:52 +08:00
|
|
|
field bits<48> SoftFail = 0;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
2013-05-14 17:28:21 +08:00
|
|
|
bits<24> BD1;
|
2013-05-07 00:15:19 +08:00
|
|
|
bits<8> I2;
|
|
|
|
|
|
|
|
let Inst{47-40} = op{15-8};
|
|
|
|
let Inst{39-32} = I2;
|
2013-05-14 17:28:21 +08:00
|
|
|
let Inst{31-8} = BD1;
|
2013-05-07 00:15:19 +08:00
|
|
|
let Inst{7-0} = op{7-0};
|
|
|
|
|
|
|
|
let Has20BitOffset = 1;
|
|
|
|
}
|
|
|
|
|
2013-07-02 22:56:45 +08:00
|
|
|
class InstSS<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
|
|
|
|
: InstSystemZ<6, outs, ins, asmstr, pattern> {
|
|
|
|
field bits<48> Inst;
|
|
|
|
field bits<48> SoftFail = 0;
|
|
|
|
|
|
|
|
bits<24> BDL1;
|
|
|
|
bits<16> BD2;
|
|
|
|
|
|
|
|
let Inst{47-40} = op;
|
|
|
|
let Inst{39-16} = BDL1;
|
|
|
|
let Inst{15-0} = BD2;
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Instruction definitions with semantics
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2013-07-25 16:57:02 +08:00
|
|
|
// These classes have the form [Cond]<Category><Format>, where <Format> is one
|
2013-05-07 00:15:19 +08:00
|
|
|
// of the formats defined above and where <Category> describes the inputs
|
2013-07-25 16:57:02 +08:00
|
|
|
// and outputs. "Cond" is used if the instruction is conditional,
|
|
|
|
// in which case the 4-bit condition-code mask is added as a final operand.
|
|
|
|
// <Category> can be one of:
|
2013-05-07 00:15:19 +08:00
|
|
|
//
|
|
|
|
// Inherent:
|
|
|
|
// One register output operand and no input operands.
|
|
|
|
//
|
|
|
|
// Store:
|
|
|
|
// One register or immediate input operand and one address input operand.
|
|
|
|
// The instruction stores the first operand to the address.
|
|
|
|
//
|
|
|
|
// This category is used for both pure and truncating stores.
|
|
|
|
//
|
|
|
|
// LoadMultiple:
|
|
|
|
// One address input operand and two explicit output operands.
|
|
|
|
// The instruction loads a range of registers from the address,
|
|
|
|
// with the explicit operands giving the first and last register
|
|
|
|
// to load. Other loaded registers are added as implicit definitions.
|
|
|
|
//
|
|
|
|
// StoreMultiple:
|
|
|
|
// Two explicit input register operands and an address operand.
|
|
|
|
// The instruction stores a range of registers to the address,
|
|
|
|
// with the explicit operands giving the first and last register
|
|
|
|
// to store. Other stored registers are added as implicit uses.
|
|
|
|
//
|
|
|
|
// Unary:
|
|
|
|
// One register output operand and one input operand. The input
|
|
|
|
// operand may be a register, immediate or memory.
|
|
|
|
//
|
|
|
|
// Binary:
|
|
|
|
// One register output operand and two input operands. The first
|
|
|
|
// input operand is always a register and he second may be a register,
|
|
|
|
// immediate or memory.
|
|
|
|
//
|
|
|
|
// Shift:
|
|
|
|
// One register output operand and two input operands. The first
|
|
|
|
// input operand is a register and the second has the same form as
|
|
|
|
// an address (although it isn't actually used to address memory).
|
|
|
|
//
|
|
|
|
// Compare:
|
|
|
|
// Two input operands. The first operand is always a register,
|
|
|
|
// the second may be a register, immediate or memory.
|
|
|
|
//
|
|
|
|
// Ternary:
|
|
|
|
// One register output operand and three register input operands.
|
|
|
|
//
|
|
|
|
// CmpSwap:
|
|
|
|
// One output operand and three input operands. The first two
|
|
|
|
// operands are registers and the third is an address. The instruction
|
|
|
|
// both reads from and writes to the address.
|
|
|
|
//
|
|
|
|
// RotateSelect:
|
|
|
|
// One output operand and five input operands. The first two operands
|
|
|
|
// are registers and the other three are immediates.
|
|
|
|
//
|
|
|
|
// The format determines which input operands are tied to output operands,
|
|
|
|
// and also determines the shape of any address operand.
|
|
|
|
//
|
|
|
|
// Multiclasses of the form <Category><Format>Pair define two instructions,
|
|
|
|
// one with <Category><Format> and one with <Category><Format>Y. The name
|
|
|
|
// of the first instruction has no suffix, the name of the second has
|
|
|
|
// an extra "y".
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
class InherentRRE<string mnemonic, bits<16> opcode, RegisterOperand cls,
|
|
|
|
dag src>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRRE<opcode, (outs cls:$R1), (ins),
|
2013-07-03 18:10:02 +08:00
|
|
|
mnemonic#"r\t$R1",
|
2013-05-14 17:28:21 +08:00
|
|
|
[(set cls:$R1, src)]> {
|
2013-05-07 00:15:19 +08:00
|
|
|
let R2 = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
class LoadMultipleRSY<string mnemonic, bits<16> opcode, RegisterOperand cls>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRSY<opcode, (outs cls:$R1, cls:$R3), (ins bdaddr20only:$BD2),
|
|
|
|
mnemonic#"\t$R1, $R3, $BD2", []> {
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
class StoreRILPC<string mnemonic, bits<12> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRIL<opcode, (outs), (ins cls:$R1, pcrel32:$I2),
|
|
|
|
mnemonic#"\t$R1, $I2",
|
|
|
|
[(operator cls:$R1, pcrel32:$I2)]> {
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayStore = 1;
|
|
|
|
// We want PC-relative addresses to be tried ahead of BD and BDX addresses.
|
|
|
|
// However, BDXs have two extra operands and are therefore 6 units more
|
|
|
|
// complex.
|
|
|
|
let AddedComplexity = 7;
|
|
|
|
}
|
|
|
|
|
|
|
|
class StoreRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
|
2013-07-03 18:10:02 +08:00
|
|
|
RegisterOperand cls, bits<5> bytes,
|
|
|
|
AddressingMode mode = bdxaddr12only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRX<opcode, (outs), (ins cls:$R1, mode:$XBD2),
|
|
|
|
mnemonic#"\t$R1, $XBD2",
|
|
|
|
[(operator cls:$R1, mode:$XBD2)]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls;
|
|
|
|
let OpType = "mem";
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayStore = 1;
|
2013-07-03 18:10:02 +08:00
|
|
|
let AccessBytes = bytes;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class StoreRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
2013-07-03 18:10:02 +08:00
|
|
|
RegisterOperand cls, bits<5> bytes,
|
|
|
|
AddressingMode mode = bdxaddr20only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRXY<opcode, (outs), (ins cls:$R1, mode:$XBD2),
|
|
|
|
mnemonic#"\t$R1, $XBD2",
|
|
|
|
[(operator cls:$R1, mode:$XBD2)]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls;
|
|
|
|
let OpType = "mem";
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayStore = 1;
|
2013-07-03 18:10:02 +08:00
|
|
|
let AccessBytes = bytes;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
multiclass StoreRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
|
2013-07-03 18:10:02 +08:00
|
|
|
SDPatternOperator operator, RegisterOperand cls,
|
|
|
|
bits<5> bytes> {
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispKey = mnemonic ## #cls in {
|
|
|
|
let DispSize = "12" in
|
2013-07-03 18:10:02 +08:00
|
|
|
def "" : StoreRX<mnemonic, rxOpcode, operator, cls, bytes, bdxaddr12pair>;
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispSize = "20" in
|
2013-07-03 18:10:02 +08:00
|
|
|
def Y : StoreRXY<mnemonic#"y", rxyOpcode, operator, cls, bytes,
|
|
|
|
bdxaddr20pair>;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class StoreMultipleRSY<string mnemonic, bits<16> opcode, RegisterOperand cls>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRSY<opcode, (outs), (ins cls:$R1, cls:$R3, bdaddr20only:$BD2),
|
|
|
|
mnemonic#"\t$R1, $R3, $BD2", []> {
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayStore = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
class StoreSI<string mnemonic, bits<8> opcode, SDPatternOperator operator,
|
|
|
|
Immediate imm, AddressingMode mode = bdaddr12only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstSI<opcode, (outs), (ins mode:$BD1, imm:$I2),
|
|
|
|
mnemonic#"\t$BD1, $I2",
|
|
|
|
[(operator imm:$I2, mode:$BD1)]> {
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayStore = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
class StoreSIY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
|
|
|
Immediate imm, AddressingMode mode = bdaddr20only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstSIY<opcode, (outs), (ins mode:$BD1, imm:$I2),
|
|
|
|
mnemonic#"\t$BD1, $I2",
|
|
|
|
[(operator imm:$I2, mode:$BD1)]> {
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayStore = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
class StoreSIL<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
|
|
|
Immediate imm>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstSIL<opcode, (outs), (ins bdaddr12only:$BD1, imm:$I2),
|
|
|
|
mnemonic#"\t$BD1, $I2",
|
|
|
|
[(operator imm:$I2, bdaddr12only:$BD1)]> {
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayStore = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass StoreSIPair<string mnemonic, bits<8> siOpcode, bits<16> siyOpcode,
|
|
|
|
SDPatternOperator operator, Immediate imm> {
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispKey = mnemonic in {
|
|
|
|
let DispSize = "12" in
|
2013-05-07 00:15:19 +08:00
|
|
|
def "" : StoreSI<mnemonic, siOpcode, operator, imm, bdaddr12pair>;
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispSize = "20" in
|
2013-05-07 00:15:19 +08:00
|
|
|
def Y : StoreSIY<mnemonic#"y", siyOpcode, operator, imm, bdaddr20pair>;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-25 16:57:02 +08:00
|
|
|
class CondStoreRSY<string mnemonic, bits<16> opcode,
|
|
|
|
RegisterOperand cls, bits<5> bytes,
|
|
|
|
AddressingMode mode = bdaddr20only>
|
|
|
|
: InstRSY<opcode, (outs), (ins cls:$R1, mode:$BD2, cond4:$R3),
|
|
|
|
mnemonic#"$R3\t$R1, $BD2", []>,
|
|
|
|
Requires<[FeatureLoadStoreOnCond]> {
|
|
|
|
let mayStore = 1;
|
|
|
|
let AccessBytes = bytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Like CondStoreRSY, but used for the raw assembly form. The condition-code
|
|
|
|
// mask is the third operand rather than being part of the mnemonic.
|
|
|
|
class AsmCondStoreRSY<string mnemonic, bits<16> opcode,
|
|
|
|
RegisterOperand cls, bits<5> bytes,
|
|
|
|
AddressingMode mode = bdaddr20only>
|
|
|
|
: InstRSY<opcode, (outs), (ins cls:$R1, mode:$BD2, uimm8zx4:$R3),
|
|
|
|
mnemonic#"\t$R1, $BD2, $R3", []>,
|
|
|
|
Requires<[FeatureLoadStoreOnCond]> {
|
|
|
|
let mayStore = 1;
|
|
|
|
let AccessBytes = bytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Like CondStoreRSY, but with a fixed CC mask.
|
|
|
|
class FixedCondStoreRSY<string mnemonic, bits<16> opcode,
|
|
|
|
RegisterOperand cls, bits<4> ccmask, bits<5> bytes,
|
|
|
|
AddressingMode mode = bdaddr20only>
|
|
|
|
: InstRSY<opcode, (outs), (ins cls:$R1, mode:$BD2),
|
|
|
|
mnemonic#"\t$R1, $BD2", []>,
|
|
|
|
Requires<[FeatureLoadStoreOnCond]> {
|
|
|
|
let mayStore = 1;
|
|
|
|
let AccessBytes = bytes;
|
|
|
|
let R3 = ccmask;
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
class UnaryRR<string mnemonic, bits<8> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls1, RegisterOperand cls2>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRR<opcode, (outs cls1:$R1), (ins cls2:$R2),
|
2013-07-03 18:10:02 +08:00
|
|
|
mnemonic#"r\t$R1, $R2",
|
|
|
|
[(set cls1:$R1, (operator cls2:$R2))]> {
|
|
|
|
let OpKey = mnemonic ## cls1;
|
|
|
|
let OpType = "reg";
|
|
|
|
}
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
class UnaryRRE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls1, RegisterOperand cls2>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRRE<opcode, (outs cls1:$R1), (ins cls2:$R2),
|
2013-07-03 18:10:02 +08:00
|
|
|
mnemonic#"r\t$R1, $R2",
|
|
|
|
[(set cls1:$R1, (operator cls2:$R2))]> {
|
|
|
|
let OpKey = mnemonic ## cls1;
|
|
|
|
let OpType = "reg";
|
|
|
|
}
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
class UnaryRRF<string mnemonic, bits<16> opcode, RegisterOperand cls1,
|
|
|
|
RegisterOperand cls2>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRRF<opcode, (outs cls1:$R1), (ins uimm8zx4:$R3, cls2:$R2),
|
2013-07-03 18:10:02 +08:00
|
|
|
mnemonic#"r\t$R1, $R3, $R2", []> {
|
|
|
|
let OpKey = mnemonic ## cls1;
|
|
|
|
let OpType = "reg";
|
|
|
|
}
|
2013-05-07 00:15:19 +08:00
|
|
|
|
2013-07-25 17:11:15 +08:00
|
|
|
// These instructions are generated by if conversion. The old value of R1
|
|
|
|
// is added as an implicit use.
|
|
|
|
class CondUnaryRRF<string mnemonic, bits<16> opcode, RegisterOperand cls1,
|
|
|
|
RegisterOperand cls2>
|
|
|
|
: InstRRF<opcode, (outs cls1:$R1), (ins cls2:$R2, cond4:$R3),
|
|
|
|
mnemonic#"r$R3\t$R1, $R2", []>,
|
|
|
|
Requires<[FeatureLoadStoreOnCond]>;
|
|
|
|
|
|
|
|
// Like CondUnaryRRF, but used for the raw assembly form. The condition-code
|
|
|
|
// mask is the third operand rather than being part of the mnemonic.
|
|
|
|
class AsmCondUnaryRRF<string mnemonic, bits<16> opcode, RegisterOperand cls1,
|
|
|
|
RegisterOperand cls2>
|
|
|
|
: InstRRF<opcode, (outs cls1:$R1), (ins cls1:$R1src, cls2:$R2, uimm8zx4:$R3),
|
|
|
|
mnemonic#"r\t$R1, $R2, $R3", []>,
|
|
|
|
Requires<[FeatureLoadStoreOnCond]> {
|
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
|
|
|
}
|
|
|
|
|
|
|
|
// Like CondUnaryRRF, but with a fixed CC mask.
|
|
|
|
class FixedCondUnaryRRF<string mnemonic, bits<16> opcode, RegisterOperand cls1,
|
|
|
|
RegisterOperand cls2, bits<4> ccmask>
|
|
|
|
: InstRRF<opcode, (outs cls1:$R1), (ins cls1:$R1src, cls2:$R2),
|
|
|
|
mnemonic#"\t$R1, $R2", []>,
|
|
|
|
Requires<[FeatureLoadStoreOnCond]> {
|
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
|
|
|
let R3 = ccmask;
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
class UnaryRI<string mnemonic, bits<12> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls, Immediate imm>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRI<opcode, (outs cls:$R1), (ins imm:$I2),
|
|
|
|
mnemonic#"\t$R1, $I2",
|
|
|
|
[(set cls:$R1, (operator imm:$I2))]>;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
class UnaryRIL<string mnemonic, bits<12> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls, Immediate imm>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRIL<opcode, (outs cls:$R1), (ins imm:$I2),
|
|
|
|
mnemonic#"\t$R1, $I2",
|
|
|
|
[(set cls:$R1, (operator imm:$I2))]>;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
class UnaryRILPC<string mnemonic, bits<12> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRIL<opcode, (outs cls:$R1), (ins pcrel32:$I2),
|
|
|
|
mnemonic#"\t$R1, $I2",
|
|
|
|
[(set cls:$R1, (operator pcrel32:$I2))]> {
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
|
|
|
// We want PC-relative addresses to be tried ahead of BD and BDX addresses.
|
|
|
|
// However, BDXs have two extra operands and are therefore 6 units more
|
|
|
|
// complex.
|
|
|
|
let AddedComplexity = 7;
|
|
|
|
}
|
|
|
|
|
2013-07-25 17:04:52 +08:00
|
|
|
class CondUnaryRSY<string mnemonic, bits<16> opcode,
|
|
|
|
RegisterOperand cls, bits<5> bytes,
|
|
|
|
AddressingMode mode = bdaddr20only>
|
|
|
|
: InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$BD2, cond4:$R3),
|
|
|
|
mnemonic#"$R3\t$R1, $BD2", []>,
|
|
|
|
Requires<[FeatureLoadStoreOnCond]> {
|
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
|
|
|
let mayLoad = 1;
|
|
|
|
let AccessBytes = bytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Like CondUnaryRSY, but used for the raw assembly form. The condition-code
|
|
|
|
// mask is the third operand rather than being part of the mnemonic.
|
|
|
|
class AsmCondUnaryRSY<string mnemonic, bits<16> opcode,
|
|
|
|
RegisterOperand cls, bits<5> bytes,
|
|
|
|
AddressingMode mode = bdaddr20only>
|
|
|
|
: InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$BD2, uimm8zx4:$R3),
|
|
|
|
mnemonic#"\t$R1, $BD2, $R3", []>,
|
|
|
|
Requires<[FeatureLoadStoreOnCond]> {
|
|
|
|
let mayLoad = 1;
|
|
|
|
let AccessBytes = bytes;
|
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
|
|
|
}
|
|
|
|
|
|
|
|
// Like CondUnaryRSY, but with a fixed CC mask.
|
|
|
|
class FixedCondUnaryRSY<string mnemonic, bits<16> opcode,
|
|
|
|
RegisterOperand cls, bits<4> ccmask, bits<5> bytes,
|
|
|
|
AddressingMode mode = bdaddr20only>
|
|
|
|
: InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$BD2),
|
|
|
|
mnemonic#"\t$R1, $BD2", []>,
|
|
|
|
Requires<[FeatureLoadStoreOnCond]> {
|
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
|
|
|
let R3 = ccmask;
|
|
|
|
let mayLoad = 1;
|
|
|
|
let AccessBytes = bytes;
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
class UnaryRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
|
2013-07-03 18:10:02 +08:00
|
|
|
RegisterOperand cls, bits<5> bytes,
|
|
|
|
AddressingMode mode = bdxaddr12only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRX<opcode, (outs cls:$R1), (ins mode:$XBD2),
|
|
|
|
mnemonic#"\t$R1, $XBD2",
|
|
|
|
[(set cls:$R1, (operator mode:$XBD2))]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls;
|
|
|
|
let OpType = "mem";
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
2013-07-03 18:10:02 +08:00
|
|
|
let AccessBytes = bytes;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class UnaryRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
2013-07-03 18:10:02 +08:00
|
|
|
RegisterOperand cls, bits<5> bytes>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRXE<opcode, (outs cls:$R1), (ins bdxaddr12only:$XBD2),
|
|
|
|
mnemonic#"\t$R1, $XBD2",
|
|
|
|
[(set cls:$R1, (operator bdxaddr12only:$XBD2))]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls;
|
|
|
|
let OpType = "mem";
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
2013-07-03 18:10:02 +08:00
|
|
|
let AccessBytes = bytes;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class UnaryRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
2013-07-03 18:10:02 +08:00
|
|
|
RegisterOperand cls, bits<5> bytes,
|
|
|
|
AddressingMode mode = bdxaddr20only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRXY<opcode, (outs cls:$R1), (ins mode:$XBD2),
|
|
|
|
mnemonic#"\t$R1, $XBD2",
|
|
|
|
[(set cls:$R1, (operator mode:$XBD2))]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls;
|
|
|
|
let OpType = "mem";
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
2013-07-03 18:10:02 +08:00
|
|
|
let AccessBytes = bytes;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
multiclass UnaryRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
|
2013-07-03 18:10:02 +08:00
|
|
|
SDPatternOperator operator, RegisterOperand cls,
|
|
|
|
bits<5> bytes> {
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispKey = mnemonic ## #cls in {
|
|
|
|
let DispSize = "12" in
|
2013-07-03 18:10:02 +08:00
|
|
|
def "" : UnaryRX<mnemonic, rxOpcode, operator, cls, bytes, bdxaddr12pair>;
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispSize = "20" in
|
2013-07-03 18:10:02 +08:00
|
|
|
def Y : UnaryRXY<mnemonic#"y", rxyOpcode, operator, cls, bytes,
|
|
|
|
bdxaddr20pair>;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class BinaryRR<string mnemonic, bits<8> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls1, RegisterOperand cls2>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRR<opcode, (outs cls1:$R1), (ins cls1:$R1src, cls2:$R2),
|
2013-07-03 18:10:02 +08:00
|
|
|
mnemonic#"r\t$R1, $R2",
|
2013-05-14 17:28:21 +08:00
|
|
|
[(set cls1:$R1, (operator cls1:$R1src, cls2:$R2))]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls1;
|
|
|
|
let OpType = "reg";
|
2013-05-14 17:28:21 +08:00
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class BinaryRRE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls1, RegisterOperand cls2>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRRE<opcode, (outs cls1:$R1), (ins cls1:$R1src, cls2:$R2),
|
2013-07-03 18:10:02 +08:00
|
|
|
mnemonic#"r\t$R1, $R2",
|
2013-05-14 17:28:21 +08:00
|
|
|
[(set cls1:$R1, (operator cls1:$R1src, cls2:$R2))]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls1;
|
|
|
|
let OpType = "reg";
|
2013-05-14 17:28:21 +08:00
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
2013-05-14 17:28:21 +08:00
|
|
|
class BinaryRRF<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls1, RegisterOperand cls2>
|
|
|
|
: InstRRF<opcode, (outs cls1:$R1), (ins cls1:$R3, cls2:$R2),
|
2013-07-03 18:10:02 +08:00
|
|
|
mnemonic#"r\t$R1, $R3, $R2",
|
|
|
|
[(set cls1:$R1, (operator cls1:$R3, cls2:$R2))]> {
|
|
|
|
let OpKey = mnemonic ## cls1;
|
|
|
|
let OpType = "reg";
|
|
|
|
}
|
2013-05-07 00:15:19 +08:00
|
|
|
|
2013-07-20 00:21:55 +08:00
|
|
|
class BinaryRRFK<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls1, RegisterOperand cls2>
|
|
|
|
: InstRRF<opcode, (outs cls1:$R1), (ins cls1:$R2, cls2:$R3),
|
|
|
|
mnemonic#"rk\t$R1, $R2, $R3",
|
|
|
|
[(set cls1:$R1, (operator cls1:$R2, cls2:$R3))]>;
|
|
|
|
|
|
|
|
multiclass BinaryRRAndK<string mnemonic, bits<8> opcode1, bits<16> opcode2,
|
|
|
|
SDPatternOperator operator, RegisterOperand cls1,
|
|
|
|
RegisterOperand cls2> {
|
|
|
|
let NumOpsKey = mnemonic in {
|
|
|
|
let NumOpsValue = "3" in
|
|
|
|
def K : BinaryRRFK<mnemonic, opcode2, null_frag, cls1, cls2>,
|
|
|
|
Requires<[FeatureDistinctOps]>;
|
|
|
|
let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
|
|
|
|
def "" : BinaryRR<mnemonic, opcode1, operator, cls1, cls2>;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-20 00:24:22 +08:00
|
|
|
multiclass BinaryRREAndK<string mnemonic, bits<16> opcode1, bits<16> opcode2,
|
|
|
|
SDPatternOperator operator, RegisterOperand cls1,
|
|
|
|
RegisterOperand cls2> {
|
|
|
|
let NumOpsKey = mnemonic in {
|
|
|
|
let NumOpsValue = "3" in
|
|
|
|
def K : BinaryRRFK<mnemonic, opcode2, null_frag, cls1, cls2>,
|
|
|
|
Requires<[FeatureDistinctOps]>;
|
|
|
|
let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
|
|
|
|
def "" : BinaryRRE<mnemonic, opcode1, operator, cls1, cls2>;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
class BinaryRI<string mnemonic, bits<12> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls, Immediate imm>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRI<opcode, (outs cls:$R1), (ins cls:$R1src, imm:$I2),
|
|
|
|
mnemonic#"\t$R1, $I2",
|
|
|
|
[(set cls:$R1, (operator cls:$R1src, imm:$I2))]> {
|
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
2013-07-20 00:32:12 +08:00
|
|
|
class BinaryRIE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls, Immediate imm>
|
|
|
|
: InstRIEd<opcode, (outs cls:$R1), (ins cls:$R3, imm:$I2),
|
|
|
|
mnemonic#"\t$R1, $R3, $I2",
|
|
|
|
[(set cls:$R1, (operator cls:$R3, imm:$I2))]>;
|
|
|
|
|
|
|
|
multiclass BinaryRIAndK<string mnemonic, bits<12> opcode1, bits<16> opcode2,
|
|
|
|
SDPatternOperator operator, RegisterOperand cls,
|
|
|
|
Immediate imm> {
|
|
|
|
let NumOpsKey = mnemonic in {
|
|
|
|
let NumOpsValue = "3" in
|
|
|
|
def K : BinaryRIE<mnemonic##"k", opcode2, null_frag, cls, imm>,
|
|
|
|
Requires<[FeatureDistinctOps]>;
|
|
|
|
let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
|
|
|
|
def "" : BinaryRI<mnemonic, opcode1, operator, cls, imm>;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
class BinaryRIL<string mnemonic, bits<12> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls, Immediate imm>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRIL<opcode, (outs cls:$R1), (ins cls:$R1src, imm:$I2),
|
|
|
|
mnemonic#"\t$R1, $I2",
|
|
|
|
[(set cls:$R1, (operator cls:$R1src, imm:$I2))]> {
|
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class BinaryRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
|
2013-07-03 18:10:02 +08:00
|
|
|
RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
|
2013-05-07 00:15:19 +08:00
|
|
|
AddressingMode mode = bdxaddr12only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRX<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$XBD2),
|
|
|
|
mnemonic#"\t$R1, $XBD2",
|
|
|
|
[(set cls:$R1, (operator cls:$R1src, (load mode:$XBD2)))]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls;
|
|
|
|
let OpType = "mem";
|
2013-05-14 17:28:21 +08:00
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
2013-07-03 18:10:02 +08:00
|
|
|
let AccessBytes = bytes;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class BinaryRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
2013-07-03 18:10:02 +08:00
|
|
|
RegisterOperand cls, SDPatternOperator load, bits<5> bytes>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRXE<opcode, (outs cls:$R1), (ins cls:$R1src, bdxaddr12only:$XBD2),
|
|
|
|
mnemonic#"\t$R1, $XBD2",
|
|
|
|
[(set cls:$R1, (operator cls:$R1src,
|
|
|
|
(load bdxaddr12only:$XBD2)))]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls;
|
|
|
|
let OpType = "mem";
|
2013-05-14 17:28:21 +08:00
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
2013-07-03 18:10:02 +08:00
|
|
|
let AccessBytes = bytes;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class BinaryRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
2013-07-03 18:10:02 +08:00
|
|
|
RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
|
2013-05-07 00:15:19 +08:00
|
|
|
AddressingMode mode = bdxaddr20only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRXY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$XBD2),
|
|
|
|
mnemonic#"\t$R1, $XBD2",
|
|
|
|
[(set cls:$R1, (operator cls:$R1src, (load mode:$XBD2)))]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls;
|
|
|
|
let OpType = "mem";
|
2013-05-14 17:28:21 +08:00
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
2013-07-03 18:10:02 +08:00
|
|
|
let AccessBytes = bytes;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
multiclass BinaryRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
|
|
|
|
SDPatternOperator operator, RegisterOperand cls,
|
2013-07-03 18:10:02 +08:00
|
|
|
SDPatternOperator load, bits<5> bytes> {
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispKey = mnemonic ## #cls in {
|
|
|
|
let DispSize = "12" in
|
2013-07-03 18:10:02 +08:00
|
|
|
def "" : BinaryRX<mnemonic, rxOpcode, operator, cls, load, bytes,
|
|
|
|
bdxaddr12pair>;
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispSize = "20" in
|
2013-07-03 18:10:02 +08:00
|
|
|
def Y : BinaryRXY<mnemonic#"y", rxyOpcode, operator, cls, load, bytes,
|
2013-05-07 00:15:19 +08:00
|
|
|
bdxaddr20pair>;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class BinarySI<string mnemonic, bits<8> opcode, SDPatternOperator operator,
|
|
|
|
Operand imm, AddressingMode mode = bdaddr12only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstSI<opcode, (outs), (ins mode:$BD1, imm:$I2),
|
|
|
|
mnemonic#"\t$BD1, $I2",
|
|
|
|
[(store (operator (load mode:$BD1), imm:$I2), mode:$BD1)]> {
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
|
|
|
let mayStore = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
class BinarySIY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
|
|
|
Operand imm, AddressingMode mode = bdaddr20only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstSIY<opcode, (outs), (ins mode:$BD1, imm:$I2),
|
|
|
|
mnemonic#"\t$BD1, $I2",
|
|
|
|
[(store (operator (load mode:$BD1), imm:$I2), mode:$BD1)]> {
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
|
|
|
let mayStore = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass BinarySIPair<string mnemonic, bits<8> siOpcode,
|
|
|
|
bits<16> siyOpcode, SDPatternOperator operator,
|
|
|
|
Operand imm> {
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispKey = mnemonic ## #cls in {
|
|
|
|
let DispSize = "12" in
|
2013-05-07 00:15:19 +08:00
|
|
|
def "" : BinarySI<mnemonic, siOpcode, operator, imm, bdaddr12pair>;
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispSize = "20" in
|
2013-05-07 00:15:19 +08:00
|
|
|
def Y : BinarySIY<mnemonic#"y", siyOpcode, operator, imm, bdaddr20pair>;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class ShiftRS<string mnemonic, bits<8> opcode, SDPatternOperator operator,
|
2013-07-20 00:09:03 +08:00
|
|
|
RegisterOperand cls>
|
|
|
|
: InstRS<opcode, (outs cls:$R1), (ins cls:$R1src, shift12only:$BD2),
|
2013-05-14 17:28:21 +08:00
|
|
|
mnemonic#"\t$R1, $BD2",
|
2013-07-20 00:09:03 +08:00
|
|
|
[(set cls:$R1, (operator cls:$R1src, shift12only:$BD2))]> {
|
2013-05-07 00:15:19 +08:00
|
|
|
let R3 = 0;
|
2013-05-14 17:28:21 +08:00
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class ShiftRSY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
2013-07-20 00:09:03 +08:00
|
|
|
RegisterOperand cls>
|
|
|
|
: InstRSY<opcode, (outs cls:$R1), (ins cls:$R3, shift20only:$BD2),
|
2013-05-14 17:28:21 +08:00
|
|
|
mnemonic#"\t$R1, $R3, $BD2",
|
2013-07-20 00:09:03 +08:00
|
|
|
[(set cls:$R1, (operator cls:$R3, shift20only:$BD2))]>;
|
|
|
|
|
|
|
|
multiclass ShiftRSAndK<string mnemonic, bits<8> opcode1, bits<16> opcode2,
|
|
|
|
SDPatternOperator operator, RegisterOperand cls> {
|
2013-07-20 00:12:08 +08:00
|
|
|
let NumOpsKey = mnemonic in {
|
|
|
|
let NumOpsValue = "3" in
|
|
|
|
def K : ShiftRSY<mnemonic##"k", opcode2, null_frag, cls>,
|
|
|
|
Requires<[FeatureDistinctOps]>;
|
|
|
|
let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
|
|
|
|
def "" : ShiftRS<mnemonic, opcode1, operator, cls>;
|
|
|
|
}
|
2013-07-20 00:09:03 +08:00
|
|
|
}
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
class CompareRR<string mnemonic, bits<8> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls1, RegisterOperand cls2>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRR<opcode, (outs), (ins cls1:$R1, cls2:$R2),
|
2013-07-03 18:10:02 +08:00
|
|
|
mnemonic#"r\t$R1, $R2",
|
|
|
|
[(operator cls1:$R1, cls2:$R2)]> {
|
|
|
|
let OpKey = mnemonic ## cls1;
|
|
|
|
let OpType = "reg";
|
2013-07-25 17:34:38 +08:00
|
|
|
let isCompare = 1;
|
2013-07-03 18:10:02 +08:00
|
|
|
}
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
class CompareRRE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls1, RegisterOperand cls2>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRRE<opcode, (outs), (ins cls1:$R1, cls2:$R2),
|
2013-07-03 18:10:02 +08:00
|
|
|
mnemonic#"r\t$R1, $R2",
|
|
|
|
[(operator cls1:$R1, cls2:$R2)]> {
|
|
|
|
let OpKey = mnemonic ## cls1;
|
|
|
|
let OpType = "reg";
|
2013-07-25 17:34:38 +08:00
|
|
|
let isCompare = 1;
|
2013-07-03 18:10:02 +08:00
|
|
|
}
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
class CompareRI<string mnemonic, bits<12> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls, Immediate imm>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRI<opcode, (outs), (ins cls:$R1, imm:$I2),
|
|
|
|
mnemonic#"\t$R1, $I2",
|
2013-07-25 17:34:38 +08:00
|
|
|
[(operator cls:$R1, imm:$I2)]> {
|
|
|
|
let isCompare = 1;
|
|
|
|
}
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
class CompareRIL<string mnemonic, bits<12> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls, Immediate imm>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRIL<opcode, (outs), (ins cls:$R1, imm:$I2),
|
|
|
|
mnemonic#"\t$R1, $I2",
|
2013-07-25 17:34:38 +08:00
|
|
|
[(operator cls:$R1, imm:$I2)]> {
|
|
|
|
let isCompare = 1;
|
|
|
|
}
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
class CompareRILPC<string mnemonic, bits<12> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls, SDPatternOperator load>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRIL<opcode, (outs), (ins cls:$R1, pcrel32:$I2),
|
|
|
|
mnemonic#"\t$R1, $I2",
|
|
|
|
[(operator cls:$R1, (load pcrel32:$I2))]> {
|
2013-07-25 17:34:38 +08:00
|
|
|
let isCompare = 1;
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
|
|
|
// We want PC-relative addresses to be tried ahead of BD and BDX addresses.
|
|
|
|
// However, BDXs have two extra operands and are therefore 6 units more
|
|
|
|
// complex.
|
|
|
|
let AddedComplexity = 7;
|
|
|
|
}
|
|
|
|
|
|
|
|
class CompareRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
|
2013-07-03 18:10:02 +08:00
|
|
|
RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
|
2013-05-07 00:15:19 +08:00
|
|
|
AddressingMode mode = bdxaddr12only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRX<opcode, (outs), (ins cls:$R1, mode:$XBD2),
|
|
|
|
mnemonic#"\t$R1, $XBD2",
|
|
|
|
[(operator cls:$R1, (load mode:$XBD2))]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls;
|
|
|
|
let OpType = "mem";
|
2013-07-25 17:34:38 +08:00
|
|
|
let isCompare = 1;
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
2013-07-03 18:10:02 +08:00
|
|
|
let AccessBytes = bytes;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class CompareRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
2013-07-03 18:10:02 +08:00
|
|
|
RegisterOperand cls, SDPatternOperator load, bits<5> bytes>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRXE<opcode, (outs), (ins cls:$R1, bdxaddr12only:$XBD2),
|
|
|
|
mnemonic#"\t$R1, $XBD2",
|
|
|
|
[(operator cls:$R1, (load bdxaddr12only:$XBD2))]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls;
|
|
|
|
let OpType = "mem";
|
2013-07-25 17:34:38 +08:00
|
|
|
let isCompare = 1;
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
2013-07-03 18:10:02 +08:00
|
|
|
let AccessBytes = bytes;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class CompareRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
2013-07-03 18:10:02 +08:00
|
|
|
RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
|
2013-05-07 00:15:19 +08:00
|
|
|
AddressingMode mode = bdxaddr20only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRXY<opcode, (outs), (ins cls:$R1, mode:$XBD2),
|
|
|
|
mnemonic#"\t$R1, $XBD2",
|
|
|
|
[(operator cls:$R1, (load mode:$XBD2))]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls;
|
|
|
|
let OpType = "mem";
|
2013-07-25 17:34:38 +08:00
|
|
|
let isCompare = 1;
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
2013-07-03 18:10:02 +08:00
|
|
|
let AccessBytes = bytes;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
multiclass CompareRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
|
|
|
|
SDPatternOperator operator, RegisterOperand cls,
|
2013-07-03 18:10:02 +08:00
|
|
|
SDPatternOperator load, bits<5> bytes> {
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispKey = mnemonic ## #cls in {
|
|
|
|
let DispSize = "12" in
|
2013-05-07 00:15:19 +08:00
|
|
|
def "" : CompareRX<mnemonic, rxOpcode, operator, cls,
|
2013-07-03 18:10:02 +08:00
|
|
|
load, bytes, bdxaddr12pair>;
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispSize = "20" in
|
2013-05-07 00:15:19 +08:00
|
|
|
def Y : CompareRXY<mnemonic#"y", rxyOpcode, operator, cls,
|
2013-07-03 18:10:02 +08:00
|
|
|
load, bytes, bdxaddr20pair>;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class CompareSI<string mnemonic, bits<8> opcode, SDPatternOperator operator,
|
|
|
|
SDPatternOperator load, Immediate imm,
|
|
|
|
AddressingMode mode = bdaddr12only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstSI<opcode, (outs), (ins mode:$BD1, imm:$I2),
|
|
|
|
mnemonic#"\t$BD1, $I2",
|
|
|
|
[(operator (load mode:$BD1), imm:$I2)]> {
|
2013-07-25 17:34:38 +08:00
|
|
|
let isCompare = 1;
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
class CompareSIL<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
|
|
|
SDPatternOperator load, Immediate imm>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstSIL<opcode, (outs), (ins bdaddr12only:$BD1, imm:$I2),
|
|
|
|
mnemonic#"\t$BD1, $I2",
|
|
|
|
[(operator (load bdaddr12only:$BD1), imm:$I2)]> {
|
2013-07-25 17:34:38 +08:00
|
|
|
let isCompare = 1;
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
class CompareSIY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
|
|
|
SDPatternOperator load, Immediate imm,
|
|
|
|
AddressingMode mode = bdaddr20only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstSIY<opcode, (outs), (ins mode:$BD1, imm:$I2),
|
|
|
|
mnemonic#"\t$BD1, $I2",
|
|
|
|
[(operator (load mode:$BD1), imm:$I2)]> {
|
2013-07-25 17:34:38 +08:00
|
|
|
let isCompare = 1;
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass CompareSIPair<string mnemonic, bits<8> siOpcode, bits<16> siyOpcode,
|
|
|
|
SDPatternOperator operator, SDPatternOperator load,
|
|
|
|
Immediate imm> {
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispKey = mnemonic in {
|
|
|
|
let DispSize = "12" in
|
2013-05-07 00:15:19 +08:00
|
|
|
def "" : CompareSI<mnemonic, siOpcode, operator, load, imm, bdaddr12pair>;
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispSize = "20" in
|
2013-05-07 00:15:19 +08:00
|
|
|
def Y : CompareSIY<mnemonic#"y", siyOpcode, operator, load, imm,
|
|
|
|
bdaddr20pair>;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class TernaryRRD<string mnemonic, bits<16> opcode,
|
|
|
|
SDPatternOperator operator, RegisterOperand cls>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRRD<opcode, (outs cls:$R1), (ins cls:$R1src, cls:$R3, cls:$R2),
|
2013-07-03 18:10:02 +08:00
|
|
|
mnemonic#"r\t$R1, $R3, $R2",
|
2013-05-14 17:28:21 +08:00
|
|
|
[(set cls:$R1, (operator cls:$R1src, cls:$R3, cls:$R2))]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls;
|
|
|
|
let OpType = "reg";
|
2013-05-14 17:28:21 +08:00
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class TernaryRXF<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
2013-07-03 18:10:02 +08:00
|
|
|
RegisterOperand cls, SDPatternOperator load, bits<5> bytes>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRXF<opcode, (outs cls:$R1),
|
|
|
|
(ins cls:$R1src, cls:$R3, bdxaddr12only:$XBD2),
|
|
|
|
mnemonic#"\t$R1, $R3, $XBD2",
|
|
|
|
[(set cls:$R1, (operator cls:$R1src, cls:$R3,
|
|
|
|
(load bdxaddr12only:$XBD2)))]> {
|
2013-07-03 18:10:02 +08:00
|
|
|
let OpKey = mnemonic ## cls;
|
|
|
|
let OpType = "mem";
|
2013-05-14 17:28:21 +08:00
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
2013-07-03 18:10:02 +08:00
|
|
|
let AccessBytes = bytes;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class CmpSwapRS<string mnemonic, bits<8> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls, AddressingMode mode = bdaddr12only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRS<opcode, (outs cls:$R1), (ins cls:$R1src, cls:$R3, mode:$BD2),
|
|
|
|
mnemonic#"\t$R1, $R3, $BD2",
|
|
|
|
[(set cls:$R1, (operator mode:$BD2, cls:$R1src, cls:$R3))]> {
|
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
|
|
|
let mayStore = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
class CmpSwapRSY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
|
|
|
|
RegisterOperand cls, AddressingMode mode = bdaddr20only>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, cls:$R3, mode:$BD2),
|
|
|
|
mnemonic#"\t$R1, $R3, $BD2",
|
|
|
|
[(set cls:$R1, (operator mode:$BD2, cls:$R1src, cls:$R3))]> {
|
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
2013-05-07 00:15:19 +08:00
|
|
|
let mayLoad = 1;
|
|
|
|
let mayStore = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass CmpSwapRSPair<string mnemonic, bits<8> rsOpcode, bits<16> rsyOpcode,
|
|
|
|
SDPatternOperator operator, RegisterOperand cls> {
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispKey = mnemonic ## #cls in {
|
|
|
|
let DispSize = "12" in
|
2013-05-07 00:15:19 +08:00
|
|
|
def "" : CmpSwapRS<mnemonic, rsOpcode, operator, cls, bdaddr12pair>;
|
2013-07-03 17:19:58 +08:00
|
|
|
let DispSize = "20" in
|
2013-05-07 00:15:19 +08:00
|
|
|
def Y : CmpSwapRSY<mnemonic#"y", rsyOpcode, operator, cls, bdaddr20pair>;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class RotateSelectRIEf<string mnemonic, bits<16> opcode, RegisterOperand cls1,
|
|
|
|
RegisterOperand cls2>
|
2013-05-14 17:28:21 +08:00
|
|
|
: InstRIEf<opcode, (outs cls1:$R1),
|
2013-07-11 16:37:13 +08:00
|
|
|
(ins cls1:$R1src, cls2:$R2, uimm8:$I3, uimm8:$I4, uimm8zx6:$I5),
|
2013-05-14 17:28:21 +08:00
|
|
|
mnemonic#"\t$R1, $R2, $I3, $I4, $I5", []> {
|
|
|
|
let Constraints = "$R1 = $R1src";
|
|
|
|
let DisableEncoding = "$R1src";
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Pseudo instructions
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// Convenience instructions that get lowered to real instructions
|
|
|
|
// by either SystemZTargetLowering::EmitInstrWithCustomInserter()
|
|
|
|
// or SystemZInstrInfo::expandPostRAPseudo().
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
class Pseudo<dag outs, dag ins, list<dag> pattern>
|
|
|
|
: InstSystemZ<0, outs, ins, "", pattern> {
|
|
|
|
let isPseudo = 1;
|
|
|
|
let isCodeGenOnly = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Implements "$dst = $cc & (8 >> CC) ? $src1 : $src2", where CC is
|
|
|
|
// the value of the PSW's 2-bit condition code field.
|
|
|
|
class SelectWrapper<RegisterOperand cls>
|
|
|
|
: Pseudo<(outs cls:$dst), (ins cls:$src1, cls:$src2, i8imm:$cc),
|
|
|
|
[(set cls:$dst, (z_select_ccmask cls:$src1, cls:$src2, imm:$cc))]> {
|
|
|
|
let usesCustomInserter = 1;
|
|
|
|
// Although the instructions used by these nodes do not in themselves
|
2013-05-22 21:38:45 +08:00
|
|
|
// change CC, the insertion requires new blocks, and CC cannot be live
|
|
|
|
// across them.
|
|
|
|
let Defs = [CC];
|
|
|
|
let Uses = [CC];
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
2013-06-27 17:27:40 +08:00
|
|
|
// Stores $new to $addr if $cc is true ("" case) or false (Inv case).
|
|
|
|
multiclass CondStores<RegisterOperand cls, SDPatternOperator store,
|
|
|
|
SDPatternOperator load, AddressingMode mode> {
|
|
|
|
let Defs = [CC], Uses = [CC], usesCustomInserter = 1 in {
|
2013-07-25 16:57:02 +08:00
|
|
|
def "" : Pseudo<(outs), (ins cls:$new, mode:$addr, uimm8zx4:$cc),
|
2013-06-27 17:27:40 +08:00
|
|
|
[(store (z_select_ccmask cls:$new, (load mode:$addr),
|
2013-07-25 16:57:02 +08:00
|
|
|
uimm8zx4:$cc), mode:$addr)]>;
|
|
|
|
def Inv : Pseudo<(outs), (ins cls:$new, mode:$addr, uimm8zx4:$cc),
|
2013-06-27 17:27:40 +08:00
|
|
|
[(store (z_select_ccmask (load mode:$addr), cls:$new,
|
2013-07-25 16:57:02 +08:00
|
|
|
uimm8zx4:$cc), mode:$addr)]>;
|
2013-06-27 17:27:40 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
// OPERATOR is ATOMIC_SWAP or an ATOMIC_LOAD_* operation. PAT and OPERAND
|
|
|
|
// describe the second (non-memory) operand.
|
|
|
|
class AtomicLoadBinary<SDPatternOperator operator, RegisterOperand cls,
|
|
|
|
dag pat, DAGOperand operand>
|
|
|
|
: Pseudo<(outs cls:$dst), (ins bdaddr20only:$ptr, operand:$src2),
|
|
|
|
[(set cls:$dst, (operator bdaddr20only:$ptr, pat))]> {
|
2013-05-22 21:38:45 +08:00
|
|
|
let Defs = [CC];
|
2013-05-07 00:15:19 +08:00
|
|
|
let Has20BitOffset = 1;
|
|
|
|
let mayLoad = 1;
|
|
|
|
let mayStore = 1;
|
|
|
|
let usesCustomInserter = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Specializations of AtomicLoadWBinary.
|
|
|
|
class AtomicLoadBinaryReg32<SDPatternOperator operator>
|
|
|
|
: AtomicLoadBinary<operator, GR32, (i32 GR32:$src2), GR32>;
|
|
|
|
class AtomicLoadBinaryImm32<SDPatternOperator operator, Immediate imm>
|
|
|
|
: AtomicLoadBinary<operator, GR32, (i32 imm:$src2), imm>;
|
|
|
|
class AtomicLoadBinaryReg64<SDPatternOperator operator>
|
|
|
|
: AtomicLoadBinary<operator, GR64, (i64 GR64:$src2), GR64>;
|
|
|
|
class AtomicLoadBinaryImm64<SDPatternOperator operator, Immediate imm>
|
|
|
|
: AtomicLoadBinary<operator, GR64, (i64 imm:$src2), imm>;
|
|
|
|
|
|
|
|
// OPERATOR is ATOMIC_SWAPW or an ATOMIC_LOADW_* operation. PAT and OPERAND
|
|
|
|
// describe the second (non-memory) operand.
|
|
|
|
class AtomicLoadWBinary<SDPatternOperator operator, dag pat,
|
|
|
|
DAGOperand operand>
|
|
|
|
: Pseudo<(outs GR32:$dst),
|
|
|
|
(ins bdaddr20only:$ptr, operand:$src2, ADDR32:$bitshift,
|
|
|
|
ADDR32:$negbitshift, uimm32:$bitsize),
|
|
|
|
[(set GR32:$dst, (operator bdaddr20only:$ptr, pat, ADDR32:$bitshift,
|
|
|
|
ADDR32:$negbitshift, uimm32:$bitsize))]> {
|
2013-05-22 21:38:45 +08:00
|
|
|
let Defs = [CC];
|
2013-05-07 00:15:19 +08:00
|
|
|
let Has20BitOffset = 1;
|
|
|
|
let mayLoad = 1;
|
|
|
|
let mayStore = 1;
|
|
|
|
let usesCustomInserter = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Specializations of AtomicLoadWBinary.
|
|
|
|
class AtomicLoadWBinaryReg<SDPatternOperator operator>
|
|
|
|
: AtomicLoadWBinary<operator, (i32 GR32:$src2), GR32>;
|
|
|
|
class AtomicLoadWBinaryImm<SDPatternOperator operator, Immediate imm>
|
|
|
|
: AtomicLoadWBinary<operator, (i32 imm:$src2), imm>;
|