6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-11 09:29:20 +00:00
Code Issues Projects Releases Wiki Activity

Extensions of Hexagon V4 instructions.

Browse Source 
This adds new instructions for Hexagon V4 architecture.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@156071 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Sirish Pande 2012-05-03 16:18:50 +00:00
parent a199e01d8e
commit 71d56462a1
9 changed files with 4108 additions and 1340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp
View File

@ -375,7 +375,7 @@ SDNode *HexagonDAGToDAGISel::SelectIndexedLoadSignExtend64(LoadSDNode *LD,
}; };
ReplaceUses(Froms, Tos, 3); ReplaceUses(Froms, Tos, 3);
return Result_2; return Result_2;
} }
SDValue TargetConst0 = CurDAG->getTargetConstant(0, MVT::i32); SDValue TargetConst0 = CurDAG->getTargetConstant(0, MVT::i32);
SDValue TargetConstVal = CurDAG->getTargetConstant(Val, MVT::i32); SDValue TargetConstVal = CurDAG->getTargetConstant(Val, MVT::i32);
SDNode *Result_1 = CurDAG->getMachineNode(Opcode, dl, MVT::i32, SDNode *Result_1 = CurDAG->getMachineNode(Opcode, dl, MVT::i32,
@ -723,7 +723,7 @@ SDNode *HexagonDAGToDAGISel::SelectStore(SDNode *N) {
if (AM != ISD::UNINDEXED) { if (AM != ISD::UNINDEXED) {
return SelectIndexedStore(ST, dl); return SelectIndexedStore(ST, dl);
} }
return SelectBaseOffsetStore(ST, dl); return SelectBaseOffsetStore(ST, dl);
} }
@ -1215,7 +1215,7 @@ SDNode *HexagonDAGToDAGISel::SelectAdd(SDNode *N) {
// Build Rd = Rd' + asr(Rs, Rt). The machine constraints will ensure that // Build Rd = Rd' + asr(Rs, Rt). The machine constraints will ensure that
// Rd and Rd' are assigned to the same register // Rd and Rd' are assigned to the same register
SDNode* Result = CurDAG->getMachineNode(Hexagon::ASR_rr_acc, dl, MVT::i32, SDNode* Result = CurDAG->getMachineNode(Hexagon::ASR_ADD_rr, dl, MVT::i32,
N->getOperand(1), N->getOperand(1),
Src1->getOperand(0), Src1->getOperand(0),
Src1->getOperand(1)); Src1->getOperand(1));

134
lib/Target/Hexagon/HexagonInstrFormats.td
View File

@ -13,29 +13,48 @@
// *** Must match HexagonBaseInfo.h *** // *** Must match HexagonBaseInfo.h ***
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
class Type<bits<5> t> {
bits<5> Value = t;
}
def TypePSEUDO : Type<0>;
def TypeALU32 : Type<1>;
def TypeCR : Type<2>;
def TypeJR : Type<3>;
def TypeJ : Type<4>;
def TypeLD : Type<5>;
def TypeST : Type<6>;
def TypeSYSTEM : Type<7>;
def TypeXTYPE : Type<8>;
def TypeMARKER : Type<31>;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Intruction Class Declaration + // Intruction Class Declaration +
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
class InstHexagon<dag outs, dag ins, string asmstr, list<dag> pattern, class InstHexagon<dag outs, dag ins, string asmstr, list<dag> pattern,
string cstr, InstrItinClass itin> : Instruction { string cstr, InstrItinClass itin, Type type> : Instruction {
field bits<32> Inst; field bits<32> Inst;
let Namespace = "Hexagon"; let Namespace = "Hexagon";
dag OutOperandList = outs; dag OutOperandList = outs;
dag InOperandList = ins; dag InOperandList = ins;
let AsmString = asmstr; let AsmString = asmstr;
let Pattern = pattern; let Pattern = pattern;
let Constraints = cstr; let Constraints = cstr;
let Itinerary = itin; let Itinerary = itin;
let Size = 4;
// *** The code below must match HexagonBaseInfo.h ***
// *** Must match HexagonBaseInfo.h ***
// Instruction type according to the ISA.
Type HexagonType = type;
let TSFlags{4-0} = HexagonType.Value;
// Solo instructions, i.e., those that cannot be in a packet with others.
bits<1> isHexagonSolo = 0;
let TSFlags{5} = isHexagonSolo;
// Predicated instructions. // Predicated instructions.
bits<1> isPredicated = 0; bits<1> isPredicated = 0;
let TSFlags{1} = isPredicated; let TSFlags{6} = isPredicated;
// *** The code above must match HexagonBaseInfo.h *** // *** The code above must match HexagonBaseInfo.h ***
} }
@ -47,17 +66,25 @@ class InstHexagon<dag outs, dag ins, string asmstr, list<dag> pattern,
// LD Instruction Class in V2/V3/V4. // LD Instruction Class in V2/V3/V4.
// Definition of the instruction class NOT CHANGED. // Definition of the instruction class NOT CHANGED.
class LDInst<dag outs, dag ins, string asmstr, list<dag> pattern> class LDInst<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", LD> { : InstHexagon<outs, ins, asmstr, pattern, "", LD, TypeLD> {
bits<5> rd; bits<5> rd;
bits<5> rs; bits<5> rs;
bits<13> imm13; bits<13> imm13;
} }
class LDInst2<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", LD, TypeLD> {
bits<5> rd;
bits<5> rs;
bits<13> imm13;
let mayLoad = 1;
}
// LD Instruction Class in V2/V3/V4. // LD Instruction Class in V2/V3/V4.
// Definition of the instruction class NOT CHANGED. // Definition of the instruction class NOT CHANGED.
class LDInstPost<dag outs, dag ins, string asmstr, list<dag> pattern, class LDInstPost<dag outs, dag ins, string asmstr, list<dag> pattern,
string cstr> string cstr>
: InstHexagon<outs, ins, asmstr, pattern, cstr, LD> { : InstHexagon<outs, ins, asmstr, pattern, cstr, LD, TypeLD> {
bits<5> rd; bits<5> rd;
bits<5> rs; bits<5> rs;
bits<5> rt; bits<5> rt;
@ -68,7 +95,24 @@ class LDInstPost<dag outs, dag ins, string asmstr, list<dag> pattern,
// ST Instruction Class in V4 can take SLOT0 & SLOT1. // ST Instruction Class in V4 can take SLOT0 & SLOT1.
// Definition of the instruction class CHANGED from V2/V3 to V4. // Definition of the instruction class CHANGED from V2/V3 to V4.
class STInst<dag outs, dag ins, string asmstr, list<dag> pattern> class STInst<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", ST> { : InstHexagon<outs, ins, asmstr, pattern, "", ST, TypeST> {
bits<5> rd;
bits<5> rs;
bits<13> imm13;
}
class STInst2<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", ST, TypeST> {
bits<5> rd;
bits<5> rs;
bits<13> imm13;
let mayStore = 1;
}
// SYSTEM Instruction Class in V4 can take SLOT0 only
// In V2/V3 we used ST for this but in v4 ST can take SLOT0 or SLOT1.
class SYSInst<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", SYS, TypeSYSTEM> {
bits<5> rd; bits<5> rd;
bits<5> rs; bits<5> rs;
bits<13> imm13; bits<13> imm13;
@ -79,7 +123,7 @@ class STInst<dag outs, dag ins, string asmstr, list<dag> pattern>
// Definition of the instruction class CHANGED from V2/V3 to V4. // Definition of the instruction class CHANGED from V2/V3 to V4.
class STInstPost<dag outs, dag ins, string asmstr, list<dag> pattern, class STInstPost<dag outs, dag ins, string asmstr, list<dag> pattern,
string cstr> string cstr>
: InstHexagon<outs, ins, asmstr, pattern, cstr, ST> { : InstHexagon<outs, ins, asmstr, pattern, cstr, ST, TypeST> {
bits<5> rd; bits<5> rd;
bits<5> rs; bits<5> rs;
bits<5> rt; bits<5> rt;
@ -89,7 +133,7 @@ class STInstPost<dag outs, dag ins, string asmstr, list<dag> pattern,
// ALU32 Instruction Class in V2/V3/V4. // ALU32 Instruction Class in V2/V3/V4.
// Definition of the instruction class NOT CHANGED. // Definition of the instruction class NOT CHANGED.
class ALU32Type<dag outs, dag ins, string asmstr, list<dag> pattern> class ALU32Type<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", ALU32> { : InstHexagon<outs, ins, asmstr, pattern, "", ALU32, TypeALU32> {
bits<5> rd; bits<5> rd;
bits<5> rs; bits<5> rs;
bits<5> rt; bits<5> rt;
@ -102,7 +146,17 @@ class ALU32Type<dag outs, dag ins, string asmstr, list<dag> pattern>
// Definition of the instruction class NOT CHANGED. // Definition of the instruction class NOT CHANGED.
// Name of the Instruction Class changed from ALU64 to XTYPE from V2/V3 to V4. // Name of the Instruction Class changed from ALU64 to XTYPE from V2/V3 to V4.
class ALU64Type<dag outs, dag ins, string asmstr, list<dag> pattern> class ALU64Type<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", ALU64> { : InstHexagon<outs, ins, asmstr, pattern, "", ALU64, TypeXTYPE> {
bits<5> rd;
bits<5> rs;
bits<5> rt;
bits<16> imm16;
bits<16> imm16_2;
}
class ALU64_acc<dag outs, dag ins, string asmstr, list<dag> pattern,
string cstr>
: InstHexagon<outs, ins, asmstr, pattern, cstr, ALU64, TypeXTYPE> {
bits<5> rd; bits<5> rd;
bits<5> rs; bits<5> rs;
bits<5> rt; bits<5> rt;
@ -115,7 +169,7 @@ class ALU64Type<dag outs, dag ins, string asmstr, list<dag> pattern>
// Definition of the instruction class NOT CHANGED. // Definition of the instruction class NOT CHANGED.
// Name of the Instruction Class changed from M to XTYPE from V2/V3 to V4. // Name of the Instruction Class changed from M to XTYPE from V2/V3 to V4.
class MInst<dag outs, dag ins, string asmstr, list<dag> pattern> class MInst<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", M> { : InstHexagon<outs, ins, asmstr, pattern, "", M, TypeXTYPE> {
bits<5> rd; bits<5> rd;
bits<5> rs; bits<5> rs;
bits<5> rt; bits<5> rt;
@ -126,8 +180,8 @@ class MInst<dag outs, dag ins, string asmstr, list<dag> pattern>
// Definition of the instruction class NOT CHANGED. // Definition of the instruction class NOT CHANGED.
// Name of the Instruction Class changed from M to XTYPE from V2/V3 to V4. // Name of the Instruction Class changed from M to XTYPE from V2/V3 to V4.
class MInst_acc<dag outs, dag ins, string asmstr, list<dag> pattern, class MInst_acc<dag outs, dag ins, string asmstr, list<dag> pattern,
string cstr> string cstr>
: InstHexagon<outs, ins, asmstr, pattern, cstr, M> { : InstHexagon<outs, ins, asmstr, pattern, cstr, M, TypeXTYPE> {
bits<5> rd; bits<5> rd;
bits<5> rs; bits<5> rs;
bits<5> rt; bits<5> rt;
@ -138,9 +192,7 @@ class MInst_acc<dag outs, dag ins, string asmstr, list<dag> pattern,
// Definition of the instruction class NOT CHANGED. // Definition of the instruction class NOT CHANGED.
// Name of the Instruction Class changed from S to XTYPE from V2/V3 to V4. // Name of the Instruction Class changed from S to XTYPE from V2/V3 to V4.
class SInst<dag outs, dag ins, string asmstr, list<dag> pattern> class SInst<dag outs, dag ins, string asmstr, list<dag> pattern>
//: InstHexagon<outs, ins, asmstr, pattern, cstr, !if(V4T, XTYPE_V4, M)> { : InstHexagon<outs, ins, asmstr, pattern, "", S, TypeXTYPE> {
: InstHexagon<outs, ins, asmstr, pattern, "", S> {
// : InstHexagon<outs, ins, asmstr, pattern, "", S> {
bits<5> rd; bits<5> rd;
bits<5> rs; bits<5> rs;
bits<5> rt; bits<5> rt;
@ -151,8 +203,8 @@ class SInst<dag outs, dag ins, string asmstr, list<dag> pattern>
// Definition of the instruction class NOT CHANGED. // Definition of the instruction class NOT CHANGED.
// Name of the Instruction Class changed from S to XTYPE from V2/V3 to V4. // Name of the Instruction Class changed from S to XTYPE from V2/V3 to V4.
class SInst_acc<dag outs, dag ins, string asmstr, list<dag> pattern, class SInst_acc<dag outs, dag ins, string asmstr, list<dag> pattern,
string cstr> string cstr>
: InstHexagon<outs, ins, asmstr, pattern, cstr, S> { : InstHexagon<outs, ins, asmstr, pattern, cstr, S, TypeXTYPE> {
// : InstHexagon<outs, ins, asmstr, pattern, cstr, S> { // : InstHexagon<outs, ins, asmstr, pattern, cstr, S> {
// : InstHexagon<outs, ins, asmstr, pattern, cstr, !if(V4T, XTYPE_V4, S)> { // : InstHexagon<outs, ins, asmstr, pattern, cstr, !if(V4T, XTYPE_V4, S)> {
bits<5> rd; bits<5> rd;
@ -163,14 +215,14 @@ class SInst_acc<dag outs, dag ins, string asmstr, list<dag> pattern,
// J Instruction Class in V2/V3/V4. // J Instruction Class in V2/V3/V4.
// Definition of the instruction class NOT CHANGED. // Definition of the instruction class NOT CHANGED.
class JType<dag outs, dag ins, string asmstr, list<dag> pattern> class JType<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", J> { : InstHexagon<outs, ins, asmstr, pattern, "", J, TypeJ> {
bits<16> imm16; bits<16> imm16;
} }
// JR Instruction Class in V2/V3/V4. // JR Instruction Class in V2/V3/V4.
// Definition of the instruction class NOT CHANGED. // Definition of the instruction class NOT CHANGED.
class JRType<dag outs, dag ins, string asmstr, list<dag> pattern> class JRType<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", JR> { : InstHexagon<outs, ins, asmstr, pattern, "", JR, TypeJR> {
bits<5> rs; bits<5> rs;
bits<5> pu; // Predicate register bits<5> pu; // Predicate register
} }
@ -178,15 +230,22 @@ class JRType<dag outs, dag ins, string asmstr, list<dag> pattern>
// CR Instruction Class in V2/V3/V4. // CR Instruction Class in V2/V3/V4.
// Definition of the instruction class NOT CHANGED. // Definition of the instruction class NOT CHANGED.
class CRInst<dag outs, dag ins, string asmstr, list<dag> pattern> class CRInst<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", CR> { : InstHexagon<outs, ins, asmstr, pattern, "", CR, TypeCR> {
bits<5> rs; bits<5> rs;
bits<10> imm10; bits<10> imm10;
} }
class Marker<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", MARKER, TypeMARKER> {
let isCodeGenOnly = 1;
let isPseudo = 1;
}
class Pseudo<dag outs, dag ins, string asmstr, list<dag> pattern> class Pseudo<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", PSEUDO>; : InstHexagon<outs, ins, asmstr, pattern, "", PSEUDO, TypePSEUDO> {
let isCodeGenOnly = 1;
let isPseudo = 1;
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Intruction Classes Definitions - // Intruction Classes Definitions -
@ -222,6 +281,11 @@ class ALU64_rr<dag outs, dag ins, string asmstr, list<dag> pattern>
: ALU64Type<outs, ins, asmstr, pattern> { : ALU64Type<outs, ins, asmstr, pattern> {
} }
class ALU64_ri<dag outs, dag ins, string asmstr, list<dag> pattern>
: ALU64Type<outs, ins, asmstr, pattern> {
let rt{0-4} = 0;
}
// J Type Instructions. // J Type Instructions.
class JInst<dag outs, dag ins, string asmstr, list<dag> pattern> class JInst<dag outs, dag ins, string asmstr, list<dag> pattern>
: JType<outs, ins, asmstr, pattern> { : JType<outs, ins, asmstr, pattern> {
@ -234,17 +298,33 @@ class JRInst<dag outs, dag ins, string asmstr, list<dag> pattern>
// Post increment ST Instruction. // Post increment ST Instruction.
class STInstPI<dag outs, dag ins, string asmstr, list<dag> pattern, string cstr> class STInstPI<dag outs, dag ins, string asmstr, list<dag> pattern,
string cstr>
: STInstPost<outs, ins, asmstr, pattern, cstr> { : STInstPost<outs, ins, asmstr, pattern, cstr> {
let rt{0-4} = 0; let rt{0-4} = 0;
} }
class STInst2PI<dag outs, dag ins, string asmstr, list<dag> pattern,
string cstr>
: STInstPost<outs, ins, asmstr, pattern, cstr> {
let rt{0-4} = 0;
let mayStore = 1;
}
// Post increment LD Instruction. // Post increment LD Instruction.
class LDInstPI<dag outs, dag ins, string asmstr, list<dag> pattern, string cstr> class LDInstPI<dag outs, dag ins, string asmstr, list<dag> pattern,
string cstr>
: LDInstPost<outs, ins, asmstr, pattern, cstr> { : LDInstPost<outs, ins, asmstr, pattern, cstr> {
let rt{0-4} = 0; let rt{0-4} = 0;
} }
class LDInst2PI<dag outs, dag ins, string asmstr, list<dag> pattern,
string cstr>
: LDInstPost<outs, ins, asmstr, pattern, cstr> {
let rt{0-4} = 0;
let mayLoad = 1;
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// V4 Instruction Format Definitions + // V4 Instruction Format Definitions +
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//

27
lib/Target/Hexagon/HexagonInstrFormatsV4.td
View File

@ -11,11 +11,25 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//----------------------------------------------------------------------------//
// Hexagon Intruction Flags +
//
// *** Must match BaseInfo.h ***
//----------------------------------------------------------------------------//
def TypeMEMOP : Type<9>;
def TypeNV : Type<10>;
def TypePREFIX : Type<30>;
//----------------------------------------------------------------------------//
// Intruction Classes Definitions +
//----------------------------------------------------------------------------//
// //
// NV type instructions. // NV type instructions.
// //
class NVInst_V4<dag outs, dag ins, string asmstr, list<dag> pattern> class NVInst_V4<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", NV_V4> { : InstHexagon<outs, ins, asmstr, pattern, "", NV_V4, TypeNV> {
bits<5> rd; bits<5> rd;
bits<5> rs; bits<5> rs;
bits<13> imm13; bits<13> imm13;
@ -24,7 +38,7 @@ class NVInst_V4<dag outs, dag ins, string asmstr, list<dag> pattern>
// Definition of Post increment new value store. // Definition of Post increment new value store.
class NVInstPost_V4<dag outs, dag ins, string asmstr, list<dag> pattern, class NVInstPost_V4<dag outs, dag ins, string asmstr, list<dag> pattern,
string cstr> string cstr>
: InstHexagon<outs, ins, asmstr, pattern, cstr, NV_V4> { : InstHexagon<outs, ins, asmstr, pattern, cstr, NV_V4, TypeNV> {
bits<5> rd; bits<5> rd;
bits<5> rs; bits<5> rs;
bits<5> rt; bits<5> rt;
@ -39,8 +53,15 @@ class NVInstPI_V4<dag outs, dag ins, string asmstr, list<dag> pattern,
} }
class MEMInst_V4<dag outs, dag ins, string asmstr, list<dag> pattern> class MEMInst_V4<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", MEM_V4> { : InstHexagon<outs, ins, asmstr, pattern, "", MEM_V4, TypeMEMOP> {
bits<5> rd; bits<5> rd;
bits<5> rs; bits<5> rs;
bits<6> imm6; bits<6> imm6;
} }
class Immext<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstHexagon<outs, ins, asmstr, pattern, "", PREFIX, TypePREFIX> {
let isCodeGenOnly = 1;
bits<26> imm26;
}

7
lib/Target/Hexagon/HexagonInstrInfo.cpp
View File

@ -1200,9 +1200,6 @@ getMatchingCondBranchOpcode(int Opc, bool invertPredicate) const {
case Hexagon::LDriub: case Hexagon::LDriub:
return !invertPredicate ? Hexagon::LDriub_cPt : return !invertPredicate ? Hexagon::LDriub_cPt :
Hexagon::LDriub_cNotPt; Hexagon::LDriub_cNotPt;
case Hexagon::LDriubit:
return !invertPredicate ? Hexagon::LDriub_cPt :
Hexagon::LDriub_cNotPt;
// Load Indexed. // Load Indexed.
case Hexagon::LDrid_indexed: case Hexagon::LDrid_indexed:
return !invertPredicate ? Hexagon::LDrid_indexed_cPt : return !invertPredicate ? Hexagon::LDrid_indexed_cPt :
@ -1409,7 +1406,6 @@ isValidOffset(const int Opcode, const int Offset) const {
case Hexagon::LDrih: case Hexagon::LDrih:
case Hexagon::LDriuh: case Hexagon::LDriuh:
case Hexagon::STrih: case Hexagon::STrih:
case Hexagon::LDrih_ae:
assert((Offset % 2 == 0) && "Offset has incorrect alignment"); assert((Offset % 2 == 0) && "Offset has incorrect alignment");
return (Offset >= Hexagon_MEMH_OFFSET_MIN) && return (Offset >= Hexagon_MEMH_OFFSET_MIN) &&
(Offset <= Hexagon_MEMH_OFFSET_MAX); (Offset <= Hexagon_MEMH_OFFSET_MAX);
@ -1417,9 +1413,6 @@ isValidOffset(const int Opcode, const int Offset) const {
case Hexagon::LDrib: case Hexagon::LDrib:
case Hexagon::STrib: case Hexagon::STrib:
case Hexagon::LDriub: case Hexagon::LDriub:
case Hexagon::LDriubit:
case Hexagon::LDrib_ae:
case Hexagon::LDriub_ae:
return (Offset >= Hexagon_MEMB_OFFSET_MIN) && return (Offset >= Hexagon_MEMB_OFFSET_MIN) &&
(Offset <= Hexagon_MEMB_OFFSET_MAX); (Offset <= Hexagon_MEMB_OFFSET_MAX);

2195
lib/Target/Hexagon/HexagonInstrInfo.td
View File

File diff suppressed because it is too large Load Diff

51
lib/Target/Hexagon/HexagonInstrInfoV3.td
View File

@ -41,10 +41,11 @@ let isCall = 1, neverHasSideEffects = 1,
} }
// Jump to address from register
// if(p?.new) jumpr:t r? // if(p?.new) jumpr:t r?
let isReturn = 1, isTerminator = 1, isBarrier = 1, let isReturn = 1, isTerminator = 1, isBarrier = 1,
Defs = [PC], Uses = [R31] in { Defs = [PC], Uses = [R31] in {
def JMPR_cPnewt: JRInst<(outs), (ins PredRegs:$src1, IntRegs:$src2), def JMPR_cdnPt_V3: JRInst<(outs), (ins PredRegs:$src1, IntRegs:$src2),
"if ($src1.new) jumpr:t $src2", "if ($src1.new) jumpr:t $src2",
[]>, Requires<[HasV3T]>; []>, Requires<[HasV3T]>;
} }
@ -52,7 +53,7 @@ let isReturn = 1, isTerminator = 1, isBarrier = 1,
// if (!p?.new) jumpr:t r? // if (!p?.new) jumpr:t r?
let isReturn = 1, isTerminator = 1, isBarrier = 1, let isReturn = 1, isTerminator = 1, isBarrier = 1,
Defs = [PC], Uses = [R31] in { Defs = [PC], Uses = [R31] in {
def JMPR_cNotPnewt: JRInst<(outs), (ins PredRegs:$src1, IntRegs:$src2), def JMPR_cdnNotPt_V3: JRInst<(outs), (ins PredRegs:$src1, IntRegs:$src2),
"if (!$src1.new) jumpr:t $src2", "if (!$src1.new) jumpr:t $src2",
[]>, Requires<[HasV3T]>; []>, Requires<[HasV3T]>;
} }
@ -61,7 +62,7 @@ let isReturn = 1, isTerminator = 1, isBarrier = 1,
// if(p?.new) jumpr:nt r? // if(p?.new) jumpr:nt r?
let isReturn = 1, isTerminator = 1, isBarrier = 1, let isReturn = 1, isTerminator = 1, isBarrier = 1,
Defs = [PC], Uses = [R31] in { Defs = [PC], Uses = [R31] in {
def JMPR_cPnewNt: JRInst<(outs), (ins PredRegs:$src1, IntRegs:$src2), def JMPR_cdnPnt: JRInst<(outs), (ins PredRegs:$src1, IntRegs:$src2),
"if ($src1.new) jumpr:nt $src2", "if ($src1.new) jumpr:nt $src2",
[]>, Requires<[HasV3T]>; []>, Requires<[HasV3T]>;
} }
@ -69,7 +70,7 @@ let isReturn = 1, isTerminator = 1, isBarrier = 1,
// if (!p?.new) jumpr:nt r? // if (!p?.new) jumpr:nt r?
let isReturn = 1, isTerminator = 1, isBarrier = 1, let isReturn = 1, isTerminator = 1, isBarrier = 1,
Defs = [PC], Uses = [R31] in { Defs = [PC], Uses = [R31] in {
def JMPR_cNotPnewNt: JRInst<(outs), (ins PredRegs:$src1, IntRegs:$src2), def JMPR_cdnNotPnt: JRInst<(outs), (ins PredRegs:$src1, IntRegs:$src2),
"if (!$src1.new) jumpr:nt $src2", "if (!$src1.new) jumpr:nt $src2",
[]>, Requires<[HasV3T]>; []>, Requires<[HasV3T]>;
} }
@ -86,20 +87,22 @@ let AddedComplexity = 200 in
def MAXw_dd : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1, def MAXw_dd : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
DoubleRegs:$src2), DoubleRegs:$src2),
"$dst = max($src2, $src1)", "$dst = max($src2, $src1)",
[(set DoubleRegs:$dst, (select (i1 (setlt DoubleRegs:$src2, [(set (i64 DoubleRegs:$dst),
DoubleRegs:$src1)), (i64 (select (i1 (setlt (i64 DoubleRegs:$src2),
DoubleRegs:$src1, (i64 DoubleRegs:$src1))),
DoubleRegs:$src2))]>, (i64 DoubleRegs:$src1),
(i64 DoubleRegs:$src2))))]>,
Requires<[HasV3T]>; Requires<[HasV3T]>;
let AddedComplexity = 200 in let AddedComplexity = 200 in
def MINw_dd : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1, def MINw_dd : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
DoubleRegs:$src2), DoubleRegs:$src2),
"$dst = min($src2, $src1)", "$dst = min($src2, $src1)",
[(set DoubleRegs:$dst, (select (i1 (setgt DoubleRegs:$src2, [(set (i64 DoubleRegs:$dst),
DoubleRegs:$src1)), (i64 (select (i1 (setgt (i64 DoubleRegs:$src2),
DoubleRegs:$src1, (i64 DoubleRegs:$src1))),
DoubleRegs:$src2))]>, (i64 DoubleRegs:$src1),
(i64 DoubleRegs:$src2))))]>,
Requires<[HasV3T]>; Requires<[HasV3T]>;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
@ -109,25 +112,25 @@ Requires<[HasV3T]>;
//def : Pat <(brcond (i1 (seteq IntRegs:$src1, 0)), bb:$offset), //def : Pat <(brcond (i1 (seteq (i32 IntRegs:$src1), 0)), bb:$offset),
// (JMP_RegEzt IntRegs:$src1, bb:$offset)>, Requires<[HasV3T]>; // (JMP_RegEzt (i32 IntRegs:$src1), bb:$offset)>, Requires<[HasV3T]>;
//def : Pat <(brcond (i1 (setne IntRegs:$src1, 0)), bb:$offset), //def : Pat <(brcond (i1 (setne (i32 IntRegs:$src1), 0)), bb:$offset),
// (JMP_RegNzt IntRegs:$src1, bb:$offset)>, Requires<[HasV3T]>; // (JMP_RegNzt (i32 IntRegs:$src1), bb:$offset)>, Requires<[HasV3T]>;
//def : Pat <(brcond (i1 (setle IntRegs:$src1, 0)), bb:$offset), //def : Pat <(brcond (i1 (setle (i32 IntRegs:$src1), 0)), bb:$offset),
// (JMP_RegLezt IntRegs:$src1, bb:$offset)>, Requires<[HasV3T]>; // (JMP_RegLezt (i32 IntRegs:$src1), bb:$offset)>, Requires<[HasV3T]>;
//def : Pat <(brcond (i1 (setge IntRegs:$src1, 0)), bb:$offset), //def : Pat <(brcond (i1 (setge (i32 IntRegs:$src1), 0)), bb:$offset),
// (JMP_RegGezt IntRegs:$src1, bb:$offset)>, Requires<[HasV3T]>; // (JMP_RegGezt (i32 IntRegs:$src1), bb:$offset)>, Requires<[HasV3T]>;
//def : Pat <(brcond (i1 (setgt IntRegs:$src1, -1)), bb:$offset), //def : Pat <(brcond (i1 (setgt (i32 IntRegs:$src1), -1)), bb:$offset),
// (JMP_RegGezt IntRegs:$src1, bb:$offset)>, Requires<[HasV3T]>; // (JMP_RegGezt (i32 IntRegs:$src1), bb:$offset)>, Requires<[HasV3T]>;
// Map call instruction // Map call instruction
def : Pat<(call IntRegs:$dst), def : Pat<(call (i32 IntRegs:$dst)),
(CALLRv3 IntRegs:$dst)>, Requires<[HasV3T]>; (CALLRv3 (i32 IntRegs:$dst))>, Requires<[HasV3T]>;
def : Pat<(call tglobaladdr:$dst), def : Pat<(call tglobaladdr:$dst),
(CALLv3 tglobaladdr:$dst)>, Requires<[HasV3T]>; (CALLv3 tglobaladdr:$dst)>, Requires<[HasV3T]>;
def : Pat<(call texternalsym:$dst), def : Pat<(call texternalsym:$dst),

2962
lib/Target/Hexagon/HexagonInstrInfoV4.td
View File

File diff suppressed because it is too large Load Diff

31
lib/Target/Hexagon/HexagonSchedule.td
View File

@ -13,7 +13,6 @@ def LSUNIT : FuncUnit;
def MUNIT : FuncUnit; def MUNIT : FuncUnit;
def SUNIT : FuncUnit; def SUNIT : FuncUnit;
// Itinerary classes // Itinerary classes
def ALU32 : InstrItinClass; def ALU32 : InstrItinClass;
def ALU64 : InstrItinClass; def ALU64 : InstrItinClass;
@ -24,23 +23,25 @@ def LD : InstrItinClass;
def M : InstrItinClass; def M : InstrItinClass;
def ST : InstrItinClass; def ST : InstrItinClass;
def S : InstrItinClass; def S : InstrItinClass;
def SYS : InstrItinClass;
def MARKER : InstrItinClass;
def PSEUDO : InstrItinClass; def PSEUDO : InstrItinClass;
def HexagonItineraries : def HexagonItineraries :
ProcessorItineraries<[LUNIT, LSUNIT, MUNIT, SUNIT], [], [ ProcessorItineraries<[LUNIT, LSUNIT, MUNIT, SUNIT], [], [
InstrItinData<ALU32 , [InstrStage<1, [LUNIT, LSUNIT, MUNIT, SUNIT]>]>, InstrItinData<ALU32 , [InstrStage<1, [LUNIT, LSUNIT, MUNIT, SUNIT]>]>,
InstrItinData<ALU64 , [InstrStage<1, [MUNIT, SUNIT]>]>, InstrItinData<ALU64 , [InstrStage<1, [MUNIT, SUNIT]>]>,
InstrItinData<CR , [InstrStage<1, [SUNIT]>]>, InstrItinData<CR , [InstrStage<1, [SUNIT]>]>,
InstrItinData<J , [InstrStage<1, [SUNIT, MUNIT]>]>, InstrItinData<J , [InstrStage<1, [SUNIT, MUNIT]>]>,
InstrItinData<JR , [InstrStage<1, [MUNIT]>]>, InstrItinData<JR , [InstrStage<1, [MUNIT]>]>,
InstrItinData<LD , [InstrStage<1, [LUNIT, LSUNIT]>]>, InstrItinData<LD , [InstrStage<1, [LUNIT, LSUNIT]>]>,
InstrItinData<M , [InstrStage<1, [MUNIT, SUNIT]>]>, InstrItinData<M , [InstrStage<1, [MUNIT, SUNIT]>]>,
InstrItinData<ST , [InstrStage<1, [LSUNIT]>]>, InstrItinData<ST , [InstrStage<1, [LSUNIT]>]>,
InstrItinData<S , [InstrStage<1, [SUNIT, MUNIT]>]>, InstrItinData<S , [InstrStage<1, [SUNIT, MUNIT]>]>,
InstrItinData<PSEUDO , [InstrStage<1, [LUNIT, LSUNIT, MUNIT, SUNIT]>]> InstrItinData<SYS , [InstrStage<1, [LSUNIT]>]>,
]>; InstrItinData<MARKER , [InstrStage<1, [LUNIT, LSUNIT, MUNIT, SUNIT]>]>,
InstrItinData<PSEUDO , [InstrStage<1, [LUNIT, LSUNIT, MUNIT, SUNIT]>]>
]>;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// V4 Machine Info + // V4 Machine Info +

35
lib/Target/Hexagon/HexagonScheduleV4.td
View File

@ -23,7 +23,6 @@
// | SLOT3 | XTYPE ALU32 J CR | // | SLOT3 | XTYPE ALU32 J CR |
// |===========|==================================================| // |===========|==================================================|
// Functional Units. // Functional Units.
def SLOT0 : FuncUnit; def SLOT0 : FuncUnit;
def SLOT1 : FuncUnit; def SLOT1 : FuncUnit;
@ -34,22 +33,26 @@ def SLOT3 : FuncUnit;
def NV_V4 : InstrItinClass; def NV_V4 : InstrItinClass;
def MEM_V4 : InstrItinClass; def MEM_V4 : InstrItinClass;
// ALU64/M/S Instruction classes of V2 are collectively knownn as XTYPE in V4. // ALU64/M/S Instruction classes of V2 are collectively knownn as XTYPE in V4.
def PREFIX : InstrItinClass;
def HexagonItinerariesV4 : ProcessorItineraries< def HexagonItinerariesV4 :
[SLOT0, SLOT1, SLOT2, SLOT3], [], [ ProcessorItineraries<[SLOT0, SLOT1, SLOT2, SLOT3], [], [
InstrItinData<LD , [InstrStage<1, [SLOT0, SLOT1]>]>, InstrItinData<ALU32 , [InstrStage<1, [SLOT0, SLOT1, SLOT2, SLOT3]>]>,
InstrItinData<ST , [InstrStage<1, [SLOT0, SLOT1]>]>, InstrItinData<ALU64 , [InstrStage<1, [SLOT2, SLOT3]>]>,
InstrItinData<ALU32 , [InstrStage<1, [SLOT0, SLOT1, SLOT2, SLOT3]>]>, InstrItinData<CR , [InstrStage<1, [SLOT3]>]>,
InstrItinData<NV_V4 , [InstrStage<1, [SLOT0]>]>, InstrItinData<J , [InstrStage<1, [SLOT2, SLOT3]>]>,
InstrItinData<MEM_V4 , [InstrStage<1, [SLOT0]>]>, InstrItinData<JR , [InstrStage<1, [SLOT2]>]>,
InstrItinData<J , [InstrStage<1, [SLOT2, SLOT3]>]>, InstrItinData<LD , [InstrStage<1, [SLOT0, SLOT1]>]>,
InstrItinData<JR , [InstrStage<1, [SLOT2]>]>, InstrItinData<M , [InstrStage<1, [SLOT2, SLOT3]>]>,
InstrItinData<CR , [InstrStage<1, [SLOT3]>]>, InstrItinData<ST , [InstrStage<1, [SLOT0, SLOT1]>]>,
InstrItinData<PSEUDO , [InstrStage<1, [SLOT0, SLOT1, SLOT2, SLOT3]>]>, InstrItinData<S , [InstrStage<1, [SLOT2, SLOT3]>]>,
InstrItinData<ALU64 , [InstrStage<1, [SLOT2, SLOT3]>]>, InstrItinData<SYS , [InstrStage<1, [SLOT0]>]>,
InstrItinData<M , [InstrStage<1, [SLOT2, SLOT3]>]>, InstrItinData<NV_V4 , [InstrStage<1, [SLOT0]>]>,
InstrItinData<S , [InstrStage<1, [SLOT2, SLOT3]>]> InstrItinData<MEM_V4 , [InstrStage<1, [SLOT0]>]>,
]>; InstrItinData<MARKER , [InstrStage<1, [SLOT0, SLOT1, SLOT2, SLOT3]>]>,
InstrItinData<PREFIX , [InstrStage<1, [SLOT0, SLOT1, SLOT2, SLOT3]>]>,
InstrItinData<PSEUDO , [InstrStage<1, [SLOT0, SLOT1, SLOT2, SLOT3]>]>
]>;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Hexagon V4 Resource Definitions - // Hexagon V4 Resource Definitions -