2005-10-15 07:40:39 +08:00
|
|
|
//===- PPCInstrInfo.td - The PowerPC Instruction Set -------*- tablegen -*-===//
|
2004-06-22 00:55:25 +08:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2004-08-10 01:24:04 +08:00
|
|
|
// This file describes the subset of the 32-bit PowerPC instruction set, as used
|
|
|
|
// by the PowerPC instruction selector.
|
2004-06-22 00:55:25 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2005-10-15 07:40:39 +08:00
|
|
|
include "PPCInstrFormats.td"
|
2004-06-22 00:55:25 +08:00
|
|
|
|
2005-09-09 03:50:41 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2005-09-09 08:39:56 +08:00
|
|
|
// PowerPC specific transformation functions and pattern fragments.
|
|
|
|
//
|
Woo, it kinda works. We now generate this atrociously bad, but correct,
code for long long foo(long long a, long long b) { return a + b; }
_foo:
or r2, r3, r3
or r3, r4, r4
or r4, r5, r5
or r5, r6, r6
rldicr r2, r2, 32, 31
rldicl r3, r3, 0, 32
rldicr r4, r4, 32, 31
rldicl r5, r5, 0, 32
or r2, r3, r2
or r3, r5, r4
add r4, r3, r2
rldicl r2, r4, 32, 32
or r4, r4, r4
or r3, r2, r2
blr
llvm-svn: 23809
2005-10-19 09:12:32 +08:00
|
|
|
|
2005-10-20 02:42:01 +08:00
|
|
|
def SHL32 : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: 31 - imm
|
|
|
|
return getI32Imm(31 - N->getValue());
|
|
|
|
}]>;
|
|
|
|
|
|
|
|
def SHL64 : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: 63 - imm
|
|
|
|
return getI32Imm(63 - N->getValue());
|
|
|
|
}]>;
|
|
|
|
|
|
|
|
def SRL32 : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: 32 - imm
|
|
|
|
return N->getValue() ? getI32Imm(32 - N->getValue()) : getI32Imm(0);
|
|
|
|
}]>;
|
|
|
|
|
|
|
|
def SRL64 : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: 64 - imm
|
|
|
|
return N->getValue() ? getI32Imm(64 - N->getValue()) : getI32Imm(0);
|
|
|
|
}]>;
|
|
|
|
|
2005-09-09 08:39:56 +08:00
|
|
|
def LO16 : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: get the low 16 bits.
|
|
|
|
return getI32Imm((unsigned short)N->getValue());
|
|
|
|
}]>;
|
|
|
|
|
|
|
|
def HI16 : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: shift the immediate value down into the low bits.
|
|
|
|
return getI32Imm((unsigned)N->getValue() >> 16);
|
|
|
|
}]>;
|
2005-09-09 01:33:10 +08:00
|
|
|
|
2005-09-29 07:07:13 +08:00
|
|
|
def HA16 : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: shift the immediate value down into the low bits.
|
|
|
|
signed int Val = N->getValue();
|
|
|
|
return getI32Imm((Val - (signed short)Val) >> 16);
|
|
|
|
}]>;
|
|
|
|
|
|
|
|
|
2005-09-09 01:33:10 +08:00
|
|
|
def immSExt16 : PatLeaf<(imm), [{
|
|
|
|
// immSExt16 predicate - True if the immediate fits in a 16-bit sign extended
|
|
|
|
// field. Used by instructions like 'addi'.
|
|
|
|
return (int)N->getValue() == (short)N->getValue();
|
|
|
|
}]>;
|
2005-09-09 01:40:49 +08:00
|
|
|
def immZExt16 : PatLeaf<(imm), [{
|
|
|
|
// immZExt16 predicate - True if the immediate fits in a 16-bit zero extended
|
|
|
|
// field. Used by instructions like 'ori'.
|
|
|
|
return (unsigned)N->getValue() == (unsigned short)N->getValue();
|
2005-09-09 08:39:56 +08:00
|
|
|
}], LO16>;
|
|
|
|
|
2005-09-09 01:33:10 +08:00
|
|
|
def imm16Shifted : PatLeaf<(imm), [{
|
|
|
|
// imm16Shifted predicate - True if only bits in the top 16-bits of the
|
|
|
|
// immediate are set. Used by instructions like 'addis'.
|
|
|
|
return ((unsigned)N->getValue() & 0xFFFF0000U) == (unsigned)N->getValue();
|
2005-09-09 08:39:56 +08:00
|
|
|
}], HI16>;
|
2005-09-09 01:33:10 +08:00
|
|
|
|
2005-09-09 01:40:49 +08:00
|
|
|
/*
|
|
|
|
// Example of a legalize expander: Only for PPC64.
|
|
|
|
def : Expander<(set i64:$dst, (fp_to_sint f64:$src)),
|
|
|
|
[(set f64:$tmp , (FCTIDZ f64:$src)),
|
|
|
|
(set i32:$tmpFI, (CreateNewFrameIndex 8, 8)),
|
|
|
|
(store f64:$tmp, i32:$tmpFI),
|
|
|
|
(set i64:$dst, (load i32:$tmpFI))],
|
|
|
|
Subtarget_PPC64>;
|
|
|
|
*/
|
2005-09-09 01:33:10 +08:00
|
|
|
|
2005-09-09 03:50:41 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Flag Definitions.
|
|
|
|
|
2005-04-19 12:32:54 +08:00
|
|
|
class isPPC64 { bit PPC64 = 1; }
|
|
|
|
class isVMX { bit VMX = 1; }
|
2005-04-19 13:15:18 +08:00
|
|
|
class isDOT {
|
|
|
|
list<Register> Defs = [CR0];
|
|
|
|
bit RC = 1;
|
|
|
|
}
|
2005-04-19 12:32:54 +08:00
|
|
|
|
2005-09-09 03:50:41 +08:00
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Operand Definitions.
|
2004-08-15 07:27:29 +08:00
|
|
|
|
2005-09-15 04:53:05 +08:00
|
|
|
def u5imm : Operand<i32> {
|
2004-08-21 13:56:39 +08:00
|
|
|
let PrintMethod = "printU5ImmOperand";
|
|
|
|
}
|
2005-09-15 04:53:05 +08:00
|
|
|
def u6imm : Operand<i32> {
|
2004-08-30 10:28:06 +08:00
|
|
|
let PrintMethod = "printU6ImmOperand";
|
|
|
|
}
|
2005-09-15 04:53:05 +08:00
|
|
|
def s16imm : Operand<i32> {
|
2004-09-04 13:00:00 +08:00
|
|
|
let PrintMethod = "printS16ImmOperand";
|
|
|
|
}
|
2005-09-15 04:53:05 +08:00
|
|
|
def u16imm : Operand<i32> {
|
2004-08-15 13:20:16 +08:00
|
|
|
let PrintMethod = "printU16ImmOperand";
|
|
|
|
}
|
2005-10-19 00:51:22 +08:00
|
|
|
def s16immX4 : Operand<i32> { // Multiply imm by 4 before printing.
|
|
|
|
let PrintMethod = "printS16X4ImmOperand";
|
|
|
|
}
|
2004-09-02 16:13:00 +08:00
|
|
|
def target : Operand<i32> {
|
|
|
|
let PrintMethod = "printBranchOperand";
|
|
|
|
}
|
|
|
|
def piclabel: Operand<i32> {
|
|
|
|
let PrintMethod = "printPICLabel";
|
|
|
|
}
|
2004-09-04 13:00:00 +08:00
|
|
|
def symbolHi: Operand<i32> {
|
|
|
|
let PrintMethod = "printSymbolHi";
|
|
|
|
}
|
|
|
|
def symbolLo: Operand<i32> {
|
|
|
|
let PrintMethod = "printSymbolLo";
|
|
|
|
}
|
2005-07-21 06:42:00 +08:00
|
|
|
def crbitm: Operand<i8> {
|
|
|
|
let PrintMethod = "printcrbitm";
|
|
|
|
}
|
2004-08-15 13:20:16 +08:00
|
|
|
|
2005-09-09 03:50:41 +08:00
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Instruction Definitions.
|
|
|
|
|
2004-06-22 00:55:25 +08:00
|
|
|
// Pseudo-instructions:
|
2005-08-19 07:25:33 +08:00
|
|
|
def PHI : Pseudo<(ops variable_ops), "; PHI">;
|
2005-09-09 03:50:41 +08:00
|
|
|
|
2004-10-08 06:30:03 +08:00
|
|
|
let isLoad = 1 in {
|
2005-09-15 05:10:24 +08:00
|
|
|
def ADJCALLSTACKDOWN : Pseudo<(ops u16imm:$amt), "; ADJCALLSTACKDOWN">;
|
|
|
|
def ADJCALLSTACKUP : Pseudo<(ops u16imm:$amt), "; ADJCALLSTACKUP">;
|
2004-10-08 06:30:03 +08:00
|
|
|
}
|
2005-08-25 07:08:16 +08:00
|
|
|
def IMPLICIT_DEF_GPR : Pseudo<(ops GPRC:$rD), "; $rD = IMPLICIT_DEF_GPRC">;
|
2005-10-01 09:35:02 +08:00
|
|
|
def IMPLICIT_DEF_F8 : Pseudo<(ops F8RC:$rD), "; %rD = IMPLICIT_DEF_F8">;
|
|
|
|
def IMPLICIT_DEF_F4 : Pseudo<(ops F4RC:$rD), "; %rD = IMPLICIT_DEF_F4">;
|
2005-02-16 04:26:49 +08:00
|
|
|
|
2005-08-27 05:23:58 +08:00
|
|
|
// SELECT_CC_* - Used to implement the SELECT_CC DAG operation. Expanded by the
|
|
|
|
// scheduler into a branch sequence.
|
|
|
|
let usesCustomDAGSchedInserter = 1 in { // Expanded by the scheduler.
|
|
|
|
def SELECT_CC_Int : Pseudo<(ops GPRC:$dst, CRRC:$cond, GPRC:$T, GPRC:$F,
|
|
|
|
i32imm:$BROPC), "; SELECT_CC PSEUDO!">;
|
2005-10-01 09:35:02 +08:00
|
|
|
def SELECT_CC_F4 : Pseudo<(ops F4RC:$dst, CRRC:$cond, F4RC:$T, F4RC:$F,
|
|
|
|
i32imm:$BROPC), "; SELECT_CC PSEUDO!">;
|
|
|
|
def SELECT_CC_F8 : Pseudo<(ops F8RC:$dst, CRRC:$cond, F8RC:$T, F8RC:$F,
|
2005-09-03 05:18:00 +08:00
|
|
|
i32imm:$BROPC), "; SELECT_CC PSEUDO!">;
|
2005-08-27 05:23:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-09-09 03:50:41 +08:00
|
|
|
let isTerminator = 1 in {
|
|
|
|
let isReturn = 1 in
|
2005-10-20 03:51:16 +08:00
|
|
|
def BLR : XLForm_2_ext<19, 16, 20, 0, 0, (ops), "blr", BrB>;
|
|
|
|
def BCTR : XLForm_2_ext<19, 528, 20, 0, 0, (ops), "bctr", BrB>;
|
2005-09-09 03:50:41 +08:00
|
|
|
}
|
|
|
|
|
2005-02-16 04:26:49 +08:00
|
|
|
let Defs = [LR] in
|
|
|
|
def MovePCtoLR : Pseudo<(ops piclabel:$label), "bl $label">;
|
2004-06-22 00:55:25 +08:00
|
|
|
|
2004-06-29 02:23:35 +08:00
|
|
|
let isBranch = 1, isTerminator = 1 in {
|
2005-09-15 05:10:24 +08:00
|
|
|
def COND_BRANCH : Pseudo<(ops CRRC:$crS, u16imm:$opc,
|
|
|
|
target:$true, target:$false),
|
2005-08-19 07:25:33 +08:00
|
|
|
"; COND_BRANCH">;
|
2005-10-20 03:51:16 +08:00
|
|
|
def B : IForm<18, 0, 0, (ops target:$func), "b $func", BrB>;
|
|
|
|
//def BA : IForm<18, 1, 0, (ops target:$func), "ba $func", BrB>;
|
|
|
|
def BL : IForm<18, 0, 1, (ops target:$func), "bl $func", BrB>;
|
|
|
|
//def BLA : IForm<18, 1, 1, (ops target:$func), "bla $func", BrB>;
|
2004-11-23 07:07:01 +08:00
|
|
|
|
2004-08-10 01:24:04 +08:00
|
|
|
// FIXME: 4*CR# needs to be added to the BI field!
|
|
|
|
// This will only work for CR0 as it stands now
|
2005-08-26 12:11:42 +08:00
|
|
|
def BLT : BForm<16, 0, 0, 12, 0, (ops CRRC:$crS, target:$block),
|
2005-10-20 03:51:16 +08:00
|
|
|
"blt $crS, $block", BrB>;
|
2005-08-26 12:11:42 +08:00
|
|
|
def BLE : BForm<16, 0, 0, 4, 1, (ops CRRC:$crS, target:$block),
|
2005-10-20 03:51:16 +08:00
|
|
|
"ble $crS, $block", BrB>;
|
2005-08-26 12:11:42 +08:00
|
|
|
def BEQ : BForm<16, 0, 0, 12, 2, (ops CRRC:$crS, target:$block),
|
2005-10-20 03:51:16 +08:00
|
|
|
"beq $crS, $block", BrB>;
|
2005-08-26 12:11:42 +08:00
|
|
|
def BGE : BForm<16, 0, 0, 4, 0, (ops CRRC:$crS, target:$block),
|
2005-10-20 03:51:16 +08:00
|
|
|
"bge $crS, $block", BrB>;
|
2005-08-26 12:11:42 +08:00
|
|
|
def BGT : BForm<16, 0, 0, 12, 1, (ops CRRC:$crS, target:$block),
|
2005-10-20 03:51:16 +08:00
|
|
|
"bgt $crS, $block", BrB>;
|
2005-08-26 12:11:42 +08:00
|
|
|
def BNE : BForm<16, 0, 0, 4, 2, (ops CRRC:$crS, target:$block),
|
2005-10-20 03:51:16 +08:00
|
|
|
"bne $crS, $block", BrB>;
|
2004-06-29 02:23:35 +08:00
|
|
|
}
|
|
|
|
|
2005-05-16 04:11:44 +08:00
|
|
|
let isCall = 1,
|
2004-06-30 07:37:36 +08:00
|
|
|
// All calls clobber the non-callee saved registers...
|
2004-07-01 06:00:45 +08:00
|
|
|
Defs = [R0,R2,R3,R4,R5,R6,R7,R8,R9,R10,R11,R12,
|
|
|
|
F0,F1,F2,F3,F4,F5,F6,F7,F8,F9,F10,F11,F12,F13,
|
2005-08-23 06:32:13 +08:00
|
|
|
LR,CTR,
|
2004-07-01 06:00:45 +08:00
|
|
|
CR0,CR1,CR5,CR6,CR7] in {
|
|
|
|
// Convenient aliases for call instructions
|
2005-10-20 03:51:16 +08:00
|
|
|
def CALLpcrel : IForm<18, 0, 1, (ops target:$func, variable_ops),
|
|
|
|
"bl $func", BrB>;
|
2005-08-19 07:25:33 +08:00
|
|
|
def CALLindirect : XLForm_2_ext<19, 528, 20, 0, 1,
|
2005-10-20 03:51:16 +08:00
|
|
|
(ops variable_ops), "bctrl", BrB>;
|
2004-06-30 07:37:36 +08:00
|
|
|
}
|
|
|
|
|
2004-08-30 10:28:06 +08:00
|
|
|
// D-Form instructions. Most instructions that perform an operation on a
|
|
|
|
// register and an immediate are of this type.
|
|
|
|
//
|
2004-10-08 06:30:03 +08:00
|
|
|
let isLoad = 1 in {
|
2005-07-22 04:44:43 +08:00
|
|
|
def LBZ : DForm_1<34, (ops GPRC:$rD, symbolLo:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lbz $rD, $disp($rA)", LdStGeneral>;
|
2005-07-22 04:44:43 +08:00
|
|
|
def LHA : DForm_1<42, (ops GPRC:$rD, symbolLo:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lha $rD, $disp($rA)", LdStLHA>;
|
2005-07-22 04:44:43 +08:00
|
|
|
def LHZ : DForm_1<40, (ops GPRC:$rD, symbolLo:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lhz $rD, $disp($rA)", LdStGeneral>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def LMW : DForm_1<46, (ops GPRC:$rD, s16imm:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lmw $rD, $disp($rA)", LdStLMW>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def LWZ : DForm_1<32, (ops GPRC:$rD, symbolLo:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lwz $rD, $disp($rA)", LdStGeneral>;
|
2005-07-22 04:44:43 +08:00
|
|
|
def LWZU : DForm_1<35, (ops GPRC:$rD, s16imm:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lwzu $rD, $disp($rA)", LdStGeneral>;
|
2004-10-08 06:30:03 +08:00
|
|
|
}
|
2005-04-19 12:59:28 +08:00
|
|
|
def ADDI : DForm_2<14, (ops GPRC:$rD, GPRC:$rA, s16imm:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"addi $rD, $rA, $imm", IntGeneral,
|
2005-09-09 01:33:10 +08:00
|
|
|
[(set GPRC:$rD, (add GPRC:$rA, immSExt16:$imm))]>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def ADDIC : DForm_2<12, (ops GPRC:$rD, GPRC:$rA, s16imm:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"addic $rD, $rA, $imm", IntGeneral,
|
2005-09-09 01:33:10 +08:00
|
|
|
[]>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def ADDICo : DForm_2<13, (ops GPRC:$rD, GPRC:$rA, s16imm:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"addic. $rD, $rA, $imm", IntGeneral,
|
2005-09-09 01:33:10 +08:00
|
|
|
[]>;
|
2005-07-22 04:44:43 +08:00
|
|
|
def ADDIS : DForm_2<15, (ops GPRC:$rD, GPRC:$rA, symbolHi:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"addis $rD, $rA, $imm", IntGeneral,
|
2005-09-09 01:33:10 +08:00
|
|
|
[(set GPRC:$rD, (add GPRC:$rA, imm16Shifted:$imm))]>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def LA : DForm_2<14, (ops GPRC:$rD, GPRC:$rA, symbolLo:$sym),
|
2005-10-20 03:51:16 +08:00
|
|
|
"la $rD, $sym($rA)", IntGeneral,
|
2005-09-09 01:33:10 +08:00
|
|
|
[]>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def MULLI : DForm_2< 7, (ops GPRC:$rD, GPRC:$rA, s16imm:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"mulli $rD, $rA, $imm", IntMulLI,
|
2005-09-09 01:33:10 +08:00
|
|
|
[(set GPRC:$rD, (mul GPRC:$rA, immSExt16:$imm))]>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def SUBFIC : DForm_2< 8, (ops GPRC:$rD, GPRC:$rA, s16imm:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"subfic $rD, $rA, $imm", IntGeneral,
|
2005-09-29 06:47:06 +08:00
|
|
|
[(set GPRC:$rD, (sub immSExt16:$imm, GPRC:$rA))]>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def LI : DForm_2_r0<14, (ops GPRC:$rD, s16imm:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"li $rD, $imm", IntGeneral,
|
2005-09-09 01:33:10 +08:00
|
|
|
[(set GPRC:$rD, immSExt16:$imm)]>;
|
2005-07-22 04:44:43 +08:00
|
|
|
def LIS : DForm_2_r0<15, (ops GPRC:$rD, symbolHi:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lis $rD, $imm", IntGeneral,
|
2005-09-09 01:33:10 +08:00
|
|
|
[(set GPRC:$rD, imm16Shifted:$imm)]>;
|
2004-10-08 06:30:03 +08:00
|
|
|
let isStore = 1 in {
|
2005-04-19 12:59:28 +08:00
|
|
|
def STMW : DForm_3<47, (ops GPRC:$rS, s16imm:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"stmw $rS, $disp($rA)", LdStLMW>;
|
2005-07-22 04:44:43 +08:00
|
|
|
def STB : DForm_3<38, (ops GPRC:$rS, symbolLo:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"stb $rS, $disp($rA)", LdStGeneral>;
|
2005-07-22 04:44:43 +08:00
|
|
|
def STH : DForm_3<44, (ops GPRC:$rS, symbolLo:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"sth $rS, $disp($rA)", LdStGeneral>;
|
2005-07-22 04:44:43 +08:00
|
|
|
def STW : DForm_3<36, (ops GPRC:$rS, symbolLo:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"stw $rS, $disp($rA)", LdStGeneral>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def STWU : DForm_3<37, (ops GPRC:$rS, s16imm:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"stwu $rS, $disp($rA)", LdStGeneral>;
|
2004-10-08 06:30:03 +08:00
|
|
|
}
|
2005-04-19 12:59:28 +08:00
|
|
|
def ANDIo : DForm_4<28, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
|
2005-10-20 03:51:16 +08:00
|
|
|
"andi. $dst, $src1, $src2", IntGeneral,
|
2005-09-09 01:40:49 +08:00
|
|
|
[]>, isDOT;
|
2005-04-19 12:59:28 +08:00
|
|
|
def ANDISo : DForm_4<29, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
|
2005-10-20 03:51:16 +08:00
|
|
|
"andis. $dst, $src1, $src2", IntGeneral,
|
2005-09-09 01:40:49 +08:00
|
|
|
[]>, isDOT;
|
2005-04-19 12:59:28 +08:00
|
|
|
def ORI : DForm_4<24, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
|
2005-10-20 03:51:16 +08:00
|
|
|
"ori $dst, $src1, $src2", IntGeneral,
|
2005-09-15 02:18:39 +08:00
|
|
|
[(set GPRC:$dst, (or GPRC:$src1, immZExt16:$src2))]>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def ORIS : DForm_4<25, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
|
2005-10-20 03:51:16 +08:00
|
|
|
"oris $dst, $src1, $src2", IntGeneral,
|
2005-09-15 02:18:39 +08:00
|
|
|
[(set GPRC:$dst, (or GPRC:$src1, imm16Shifted:$src2))]>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def XORI : DForm_4<26, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
|
2005-10-20 03:51:16 +08:00
|
|
|
"xori $dst, $src1, $src2", IntGeneral,
|
2005-09-15 02:18:39 +08:00
|
|
|
[(set GPRC:$dst, (xor GPRC:$src1, immZExt16:$src2))]>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def XORIS : DForm_4<27, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
|
2005-10-20 03:51:16 +08:00
|
|
|
"xoris $dst, $src1, $src2", IntGeneral,
|
2005-09-15 04:53:05 +08:00
|
|
|
[(set GPRC:$dst, (xor GPRC:$src1, imm16Shifted:$src2))]>;
|
2005-10-20 03:51:16 +08:00
|
|
|
def NOP : DForm_4_zero<24, (ops), "nop", IntGeneral>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def CMPI : DForm_5<11, (ops CRRC:$crD, i1imm:$L, GPRC:$rA, s16imm:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"cmpi $crD, $L, $rA, $imm", IntCompare>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def CMPWI : DForm_5_ext<11, (ops CRRC:$crD, GPRC:$rA, s16imm:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"cmpwi $crD, $rA, $imm", IntCompare>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def CMPDI : DForm_5_ext<11, (ops CRRC:$crD, GPRC:$rA, s16imm:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"cmpdi $crD, $rA, $imm", IntCompare>, isPPC64;
|
2005-04-19 12:59:28 +08:00
|
|
|
def CMPLI : DForm_6<10, (ops CRRC:$dst, i1imm:$size, GPRC:$src1, u16imm:$src2),
|
2005-10-20 03:51:16 +08:00
|
|
|
"cmpli $dst, $size, $src1, $src2", IntCompare>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def CMPLWI : DForm_6_ext<10, (ops CRRC:$dst, GPRC:$src1, u16imm:$src2),
|
2005-10-20 03:51:16 +08:00
|
|
|
"cmplwi $dst, $src1, $src2", IntCompare>;
|
2005-04-19 12:59:28 +08:00
|
|
|
def CMPLDI : DForm_6_ext<10, (ops CRRC:$dst, GPRC:$src1, u16imm:$src2),
|
2005-10-20 03:51:16 +08:00
|
|
|
"cmpldi $dst, $src1, $src2", IntCompare>, isPPC64;
|
2004-10-08 06:30:03 +08:00
|
|
|
let isLoad = 1 in {
|
2005-10-01 09:35:02 +08:00
|
|
|
def LFS : DForm_8<48, (ops F4RC:$rD, symbolLo:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lfs $rD, $disp($rA)", LdStLFDU>;
|
2005-10-01 09:35:02 +08:00
|
|
|
def LFD : DForm_8<50, (ops F8RC:$rD, symbolLo:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lfd $rD, $disp($rA)", LdStLFD>;
|
2004-10-08 06:30:03 +08:00
|
|
|
}
|
|
|
|
let isStore = 1 in {
|
2005-10-01 09:35:02 +08:00
|
|
|
def STFS : DForm_9<52, (ops F4RC:$rS, symbolLo:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"stfs $rS, $disp($rA)", LdStUX>;
|
2005-10-01 09:35:02 +08:00
|
|
|
def STFD : DForm_9<54, (ops F8RC:$rS, symbolLo:$disp, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"stfd $rS, $disp($rA)", LdStUX>;
|
2004-10-08 06:30:03 +08:00
|
|
|
}
|
2004-09-04 13:00:00 +08:00
|
|
|
|
|
|
|
// DS-Form instructions. Load/Store instructions available in PPC-64
|
|
|
|
//
|
2004-10-08 06:30:03 +08:00
|
|
|
let isLoad = 1 in {
|
2005-10-19 00:51:22 +08:00
|
|
|
def LWA : DSForm_1<58, 2, (ops GPRC:$rT, s16immX4:$DS, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lwa $rT, $DS($rA)", LdStLWA>, isPPC64;
|
2005-10-19 00:51:22 +08:00
|
|
|
def LD : DSForm_2<58, 0, (ops GPRC:$rT, s16immX4:$DS, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"ld $rT, $DS($rA)", LdStLD>, isPPC64;
|
2004-10-08 06:30:03 +08:00
|
|
|
}
|
|
|
|
let isStore = 1 in {
|
2005-10-19 00:51:22 +08:00
|
|
|
def STD : DSForm_2<62, 0, (ops GPRC:$rT, s16immX4:$DS, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"std $rT, $DS($rA)", LdStSTD>, isPPC64;
|
2005-10-19 00:51:22 +08:00
|
|
|
def STDU : DSForm_2<62, 1, (ops GPRC:$rT, s16immX4:$DS, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"stdu $rT, $DS($rA)", LdStSTD>, isPPC64;
|
2004-10-08 06:30:03 +08:00
|
|
|
}
|
2004-08-21 13:56:39 +08:00
|
|
|
|
2004-08-30 10:28:06 +08:00
|
|
|
// X-Form instructions. Most instructions that perform an operation on a
|
|
|
|
// register and another register are of this type.
|
|
|
|
//
|
2004-10-08 06:30:03 +08:00
|
|
|
let isLoad = 1 in {
|
2005-04-19 12:51:30 +08:00
|
|
|
def LBZX : XForm_1<31, 87, (ops GPRC:$dst, GPRC:$base, GPRC:$index),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lbzx $dst, $base, $index", LdStGeneral>;
|
2005-04-19 12:51:30 +08:00
|
|
|
def LHAX : XForm_1<31, 343, (ops GPRC:$dst, GPRC:$base, GPRC:$index),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lhax $dst, $base, $index", LdStLHA>;
|
2005-04-19 12:51:30 +08:00
|
|
|
def LHZX : XForm_1<31, 279, (ops GPRC:$dst, GPRC:$base, GPRC:$index),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lhzx $dst, $base, $index", LdStGeneral>;
|
2005-04-19 12:51:30 +08:00
|
|
|
def LWAX : XForm_1<31, 341, (ops GPRC:$dst, GPRC:$base, GPRC:$index),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lwax $dst, $base, $index", LdStLHA>, isPPC64;
|
2005-04-19 12:51:30 +08:00
|
|
|
def LWZX : XForm_1<31, 23, (ops GPRC:$dst, GPRC:$base, GPRC:$index),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lwzx $dst, $base, $index", LdStGeneral>;
|
2005-04-19 12:51:30 +08:00
|
|
|
def LDX : XForm_1<31, 21, (ops GPRC:$dst, GPRC:$base, GPRC:$index),
|
2005-10-20 03:51:16 +08:00
|
|
|
"ldx $dst, $base, $index", LdStLD>, isPPC64;
|
2004-10-08 06:30:03 +08:00
|
|
|
}
|
2005-09-03 08:21:51 +08:00
|
|
|
def NAND : XForm_6<31, 476, (ops GPRC:$rA, GPRC:$rS, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"nand $rA, $rS, $rB", IntGeneral,
|
2005-09-03 08:21:51 +08:00
|
|
|
[(set GPRC:$rA, (not (and GPRC:$rS, GPRC:$rB)))]>;
|
2005-04-19 13:15:18 +08:00
|
|
|
def AND : XForm_6<31, 28, (ops GPRC:$rA, GPRC:$rS, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"and $rA, $rS, $rB", IntGeneral,
|
2005-09-15 02:18:39 +08:00
|
|
|
[(set GPRC:$rA, (and GPRC:$rS, GPRC:$rB))]>;
|
2005-04-19 13:15:18 +08:00
|
|
|
def ANDo : XForm_6<31, 28, (ops GPRC:$rA, GPRC:$rS, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"and. $rA, $rS, $rB", IntGeneral,
|
2005-09-03 06:35:53 +08:00
|
|
|
[]>, isDOT;
|
2005-04-19 13:15:18 +08:00
|
|
|
def ANDC : XForm_6<31, 60, (ops GPRC:$rA, GPRC:$rS, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"andc $rA, $rS, $rB", IntGeneral,
|
2005-09-03 08:21:51 +08:00
|
|
|
[(set GPRC:$rA, (and GPRC:$rS, (not GPRC:$rB)))]>;
|
2005-10-18 08:28:58 +08:00
|
|
|
def OR4 : XForm_6<31, 444, (ops GPRC:$rA, GPRC:$rS, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"or $rA, $rS, $rB", IntGeneral,
|
2005-09-15 02:18:39 +08:00
|
|
|
[(set GPRC:$rA, (or GPRC:$rS, GPRC:$rB))]>;
|
2005-10-18 08:28:58 +08:00
|
|
|
def OR8 : XForm_6<31, 444, (ops G8RC:$rA, G8RC:$rS, G8RC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"or $rA, $rS, $rB", IntGeneral,
|
2005-10-18 08:28:58 +08:00
|
|
|
[(set G8RC:$rA, (or G8RC:$rS, G8RC:$rB))]>;
|
Woo, it kinda works. We now generate this atrociously bad, but correct,
code for long long foo(long long a, long long b) { return a + b; }
_foo:
or r2, r3, r3
or r3, r4, r4
or r4, r5, r5
or r5, r6, r6
rldicr r2, r2, 32, 31
rldicl r3, r3, 0, 32
rldicr r4, r4, 32, 31
rldicl r5, r5, 0, 32
or r2, r3, r2
or r3, r5, r4
add r4, r3, r2
rldicl r2, r4, 32, 32
or r4, r4, r4
or r3, r2, r2
blr
llvm-svn: 23809
2005-10-19 09:12:32 +08:00
|
|
|
def OR4To8 : XForm_6<31, 444, (ops G8RC:$rA, GPRC:$rS, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"or $rA, $rS, $rB", IntGeneral,
|
Woo, it kinda works. We now generate this atrociously bad, but correct,
code for long long foo(long long a, long long b) { return a + b; }
_foo:
or r2, r3, r3
or r3, r4, r4
or r4, r5, r5
or r5, r6, r6
rldicr r2, r2, 32, 31
rldicl r3, r3, 0, 32
rldicr r4, r4, 32, 31
rldicl r5, r5, 0, 32
or r2, r3, r2
or r3, r5, r4
add r4, r3, r2
rldicl r2, r4, 32, 32
or r4, r4, r4
or r3, r2, r2
blr
llvm-svn: 23809
2005-10-19 09:12:32 +08:00
|
|
|
[]>;
|
|
|
|
def OR8To4 : XForm_6<31, 444, (ops GPRC:$rA, G8RC:$rS, G8RC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"or $rA, $rS, $rB", IntGeneral,
|
Woo, it kinda works. We now generate this atrociously bad, but correct,
code for long long foo(long long a, long long b) { return a + b; }
_foo:
or r2, r3, r3
or r3, r4, r4
or r4, r5, r5
or r5, r6, r6
rldicr r2, r2, 32, 31
rldicl r3, r3, 0, 32
rldicr r4, r4, 32, 31
rldicl r5, r5, 0, 32
or r2, r3, r2
or r3, r5, r4
add r4, r3, r2
rldicl r2, r4, 32, 32
or r4, r4, r4
or r3, r2, r2
blr
llvm-svn: 23809
2005-10-19 09:12:32 +08:00
|
|
|
[]>;
|
2005-09-03 08:21:51 +08:00
|
|
|
def NOR : XForm_6<31, 124, (ops GPRC:$rA, GPRC:$rS, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"nor $rA, $rS, $rB", IntGeneral,
|
2005-09-03 08:21:51 +08:00
|
|
|
[(set GPRC:$rA, (not (or GPRC:$rS, GPRC:$rB)))]>;
|
2005-04-19 13:15:18 +08:00
|
|
|
def ORo : XForm_6<31, 444, (ops GPRC:$rA, GPRC:$rS, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"or. $rA, $rS, $rB", IntGeneral,
|
2005-09-03 06:35:53 +08:00
|
|
|
[]>, isDOT;
|
2005-04-19 13:15:18 +08:00
|
|
|
def ORC : XForm_6<31, 412, (ops GPRC:$rA, GPRC:$rS, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"orc $rA, $rS, $rB", IntGeneral,
|
2005-09-03 08:21:51 +08:00
|
|
|
[(set GPRC:$rA, (or GPRC:$rS, (not GPRC:$rB)))]>;
|
|
|
|
def EQV : XForm_6<31, 284, (ops GPRC:$rA, GPRC:$rS, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"eqv $rA, $rS, $rB", IntGeneral,
|
2005-09-15 02:18:39 +08:00
|
|
|
[(set GPRC:$rA, (not (xor GPRC:$rS, GPRC:$rB)))]>;
|
2005-09-03 08:21:51 +08:00
|
|
|
def XOR : XForm_6<31, 316, (ops GPRC:$rA, GPRC:$rS, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"xor $rA, $rS, $rB", IntGeneral,
|
2005-09-15 02:18:39 +08:00
|
|
|
[(set GPRC:$rA, (xor GPRC:$rS, GPRC:$rB))]>;
|
2005-10-20 02:42:01 +08:00
|
|
|
def SLD : XForm_6<31, 27, (ops G8RC:$rA, G8RC:$rS, G8RC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"sld $rA, $rS, $rB", IntRotateD,
|
2005-10-20 02:42:01 +08:00
|
|
|
[(set G8RC:$rA, (shl G8RC:$rS, G8RC:$rB))]>, isPPC64;
|
2005-04-19 13:15:18 +08:00
|
|
|
def SLW : XForm_6<31, 24, (ops GPRC:$rA, GPRC:$rS, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"slw $rA, $rS, $rB", IntGeneral,
|
2005-09-30 07:34:24 +08:00
|
|
|
[(set GPRC:$rA, (shl GPRC:$rS, GPRC:$rB))]>;
|
2005-10-20 02:42:01 +08:00
|
|
|
def SRD : XForm_6<31, 539, (ops G8RC:$rA, G8RC:$rS, G8RC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"srd $rA, $rS, $rB", IntRotateD,
|
2005-10-20 02:42:01 +08:00
|
|
|
[(set G8RC:$rA, (srl G8RC:$rS, G8RC:$rB))]>, isPPC64;
|
2005-04-19 13:15:18 +08:00
|
|
|
def SRW : XForm_6<31, 536, (ops GPRC:$rA, GPRC:$rS, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"srw $rA, $rS, $rB", IntGeneral,
|
2005-09-30 07:34:24 +08:00
|
|
|
[(set GPRC:$rA, (srl GPRC:$rS, GPRC:$rB))]>;
|
2005-10-20 02:42:01 +08:00
|
|
|
def SRAD : XForm_6<31, 794, (ops G8RC:$rA, G8RC:$rS, G8RC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"srad $rA, $rS, $rB", IntRotateD,
|
2005-10-20 02:42:01 +08:00
|
|
|
[(set G8RC:$rA, (sra G8RC:$rS, G8RC:$rB))]>, isPPC64;
|
2005-04-19 13:15:18 +08:00
|
|
|
def SRAW : XForm_6<31, 792, (ops GPRC:$rA, GPRC:$rS, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"sraw $rA, $rS, $rB", IntShift,
|
2005-09-30 07:34:24 +08:00
|
|
|
[(set GPRC:$rA, (sra GPRC:$rS, GPRC:$rB))]>;
|
2004-10-08 06:30:03 +08:00
|
|
|
let isStore = 1 in {
|
2005-04-19 12:51:30 +08:00
|
|
|
def STBX : XForm_8<31, 215, (ops GPRC:$rS, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"stbx $rS, $rA, $rB", LdStGeneral>;
|
2005-04-19 12:51:30 +08:00
|
|
|
def STHX : XForm_8<31, 407, (ops GPRC:$rS, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"sthx $rS, $rA, $rB", LdStGeneral>;
|
2005-04-19 12:51:30 +08:00
|
|
|
def STWX : XForm_8<31, 151, (ops GPRC:$rS, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"stwx $rS, $rA, $rB", LdStGeneral>;
|
2005-04-19 12:51:30 +08:00
|
|
|
def STWUX : XForm_8<31, 183, (ops GPRC:$rS, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"stwux $rS, $rA, $rB", LdStGeneral>;
|
2005-04-19 12:51:30 +08:00
|
|
|
def STDX : XForm_8<31, 149, (ops GPRC:$rS, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"stdx $rS, $rA, $rB", LdStSTD>, isPPC64;
|
2005-04-19 12:51:30 +08:00
|
|
|
def STDUX : XForm_8<31, 181, (ops GPRC:$rS, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"stdux $rS, $rA, $rB", LdStSTD>, isPPC64;
|
2004-10-08 06:30:03 +08:00
|
|
|
}
|
2005-04-19 13:15:18 +08:00
|
|
|
def SRAWI : XForm_10<31, 824, (ops GPRC:$rA, GPRC:$rS, u5imm:$SH),
|
2005-10-20 03:51:16 +08:00
|
|
|
"srawi $rA, $rS, $SH", IntShift,
|
2005-09-30 07:34:24 +08:00
|
|
|
[(set GPRC:$rA, (sra GPRC:$rS, imm:$SH))]>;
|
2005-04-19 13:15:18 +08:00
|
|
|
def CNTLZW : XForm_11<31, 26, (ops GPRC:$rA, GPRC:$rS),
|
2005-10-20 03:51:16 +08:00
|
|
|
"cntlzw $rA, $rS", IntGeneral,
|
2005-09-03 06:35:53 +08:00
|
|
|
[(set GPRC:$rA, (ctlz GPRC:$rS))]>;
|
2005-04-19 13:15:18 +08:00
|
|
|
def EXTSB : XForm_11<31, 954, (ops GPRC:$rA, GPRC:$rS),
|
2005-10-20 03:51:16 +08:00
|
|
|
"extsb $rA, $rS", IntGeneral,
|
2005-09-03 06:35:53 +08:00
|
|
|
[(set GPRC:$rA, (sext_inreg GPRC:$rS, i8))]>;
|
2005-04-19 13:15:18 +08:00
|
|
|
def EXTSH : XForm_11<31, 922, (ops GPRC:$rA, GPRC:$rS),
|
2005-10-20 03:51:16 +08:00
|
|
|
"extsh $rA, $rS", IntGeneral,
|
2005-09-03 06:35:53 +08:00
|
|
|
[(set GPRC:$rA, (sext_inreg GPRC:$rS, i16))]>;
|
2005-04-19 13:15:18 +08:00
|
|
|
def EXTSW : XForm_11<31, 986, (ops GPRC:$rA, GPRC:$rS),
|
2005-10-20 03:51:16 +08:00
|
|
|
"extsw $rA, $rS", IntRotateD,
|
2005-09-03 06:35:53 +08:00
|
|
|
[]>, isPPC64;
|
2005-04-19 12:51:30 +08:00
|
|
|
def CMP : XForm_16<31, 0, (ops CRRC:$crD, i1imm:$long, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"cmp $crD, $long, $rA, $rB", IntCompare>;
|
2005-04-19 12:51:30 +08:00
|
|
|
def CMPL : XForm_16<31, 32, (ops CRRC:$crD, i1imm:$long, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"cmpl $crD, $long, $rA, $rB", IntCompare>;
|
2005-04-19 12:51:30 +08:00
|
|
|
def CMPW : XForm_16_ext<31, 0, (ops CRRC:$crD, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"cmpw $crD, $rA, $rB", IntCompare>;
|
2005-04-19 12:51:30 +08:00
|
|
|
def CMPD : XForm_16_ext<31, 0, (ops CRRC:$crD, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"cmpd $crD, $rA, $rB", IntCompare>, isPPC64;
|
2005-04-19 12:51:30 +08:00
|
|
|
def CMPLW : XForm_16_ext<31, 32, (ops CRRC:$crD, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"cmplw $crD, $rA, $rB", IntCompare>;
|
2005-04-19 12:51:30 +08:00
|
|
|
def CMPLD : XForm_16_ext<31, 32, (ops CRRC:$crD, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"cmpld $crD, $rA, $rB", IntCompare>, isPPC64;
|
2005-10-01 09:35:02 +08:00
|
|
|
//def FCMPO : XForm_17<63, 32, (ops CRRC:$crD, FPRC:$fA, FPRC:$fB),
|
2005-10-20 03:51:16 +08:00
|
|
|
// "fcmpo $crD, $fA, $fB", FPCompare>;
|
2005-10-01 09:35:02 +08:00
|
|
|
def FCMPUS : XForm_17<63, 0, (ops CRRC:$crD, F4RC:$fA, F4RC:$fB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fcmpu $crD, $fA, $fB", FPCompare>;
|
2005-10-01 09:35:02 +08:00
|
|
|
def FCMPUD : XForm_17<63, 0, (ops CRRC:$crD, F8RC:$fA, F8RC:$fB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fcmpu $crD, $fA, $fB", FPCompare>;
|
2005-10-01 09:35:02 +08:00
|
|
|
|
2004-10-08 06:30:03 +08:00
|
|
|
let isLoad = 1 in {
|
2005-10-01 09:35:02 +08:00
|
|
|
def LFSX : XForm_25<31, 535, (ops F4RC:$dst, GPRC:$base, GPRC:$index),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lfsx $dst, $base, $index", LdStLFDU>;
|
2005-10-01 09:35:02 +08:00
|
|
|
def LFDX : XForm_25<31, 599, (ops F8RC:$dst, GPRC:$base, GPRC:$index),
|
2005-10-20 03:51:16 +08:00
|
|
|
"lfdx $dst, $base, $index", LdStLFDU>;
|
2004-10-08 06:30:03 +08:00
|
|
|
}
|
2005-10-01 09:35:02 +08:00
|
|
|
def FCFID : XForm_26<63, 846, (ops F8RC:$frD, F8RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fcfid $frD, $frB", FPGeneral,
|
2005-09-30 07:34:24 +08:00
|
|
|
[]>, isPPC64;
|
2005-10-01 09:35:02 +08:00
|
|
|
def FCTIDZ : XForm_26<63, 815, (ops F8RC:$frD, F8RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fctidz $frD, $frB", FPGeneral,
|
2005-09-30 07:34:24 +08:00
|
|
|
[]>, isPPC64;
|
2005-10-01 09:35:02 +08:00
|
|
|
def FCTIWZ : XForm_26<63, 15, (ops F8RC:$frD, F8RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fctiwz $frD, $frB", FPGeneral,
|
2005-09-30 07:34:24 +08:00
|
|
|
[]>;
|
2005-10-01 09:35:02 +08:00
|
|
|
def FRSP : XForm_26<63, 12, (ops F4RC:$frD, F8RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"frsp $frD, $frB", FPGeneral,
|
2005-10-14 12:55:50 +08:00
|
|
|
[(set F4RC:$frD, (fround F8RC:$frB))]>;
|
2005-10-01 09:35:02 +08:00
|
|
|
def FSQRT : XForm_26<63, 22, (ops F8RC:$frD, F8RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fsqrt $frD, $frB", FPSqrt,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F8RC:$frD, (fsqrt F8RC:$frB))]>;
|
|
|
|
def FSQRTS : XForm_26<59, 22, (ops F4RC:$frD, F4RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fsqrts $frD, $frB", FPSqrt,
|
2005-10-16 05:44:15 +08:00
|
|
|
[(set F4RC:$frD, (fsqrt F4RC:$frB))]>;
|
2005-10-01 09:35:02 +08:00
|
|
|
|
|
|
|
/// FMR is split into 3 versions, one for 4/8 byte FP, and one for extending.
|
|
|
|
def FMRS : XForm_26<63, 72, (ops F4RC:$frD, F4RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fmr $frD, $frB", FPGeneral,
|
2005-10-01 09:35:02 +08:00
|
|
|
[]>; // (set F4RC:$frD, F4RC:$frB)
|
|
|
|
def FMRD : XForm_26<63, 72, (ops F8RC:$frD, F8RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fmr $frD, $frB", FPGeneral,
|
2005-10-01 09:35:02 +08:00
|
|
|
[]>; // (set F8RC:$frD, F8RC:$frB)
|
|
|
|
def FMRSD : XForm_26<63, 72, (ops F8RC:$frD, F4RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fmr $frD, $frB", FPGeneral,
|
2005-10-14 12:55:50 +08:00
|
|
|
[(set F8RC:$frD, (fextend F4RC:$frB))]>;
|
2005-10-01 09:35:02 +08:00
|
|
|
|
|
|
|
// These are artificially split into two different forms, for 4/8 byte FP.
|
|
|
|
def FABSS : XForm_26<63, 264, (ops F4RC:$frD, F4RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fabs $frD, $frB", FPGeneral,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F4RC:$frD, (fabs F4RC:$frB))]>;
|
|
|
|
def FABSD : XForm_26<63, 264, (ops F8RC:$frD, F8RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fabs $frD, $frB", FPGeneral,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F8RC:$frD, (fabs F8RC:$frB))]>;
|
|
|
|
def FNABSS : XForm_26<63, 136, (ops F4RC:$frD, F4RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fnabs $frD, $frB", FPGeneral,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F4RC:$frD, (fneg (fabs F4RC:$frB)))]>;
|
|
|
|
def FNABSD : XForm_26<63, 136, (ops F8RC:$frD, F8RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fnabs $frD, $frB", FPGeneral,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F8RC:$frD, (fneg (fabs F8RC:$frB)))]>;
|
|
|
|
def FNEGS : XForm_26<63, 40, (ops F4RC:$frD, F4RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fneg $frD, $frB", FPGeneral,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F4RC:$frD, (fneg F4RC:$frB))]>;
|
|
|
|
def FNEGD : XForm_26<63, 40, (ops F8RC:$frD, F8RC:$frB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fneg $frD, $frB", FPGeneral,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F8RC:$frD, (fneg F8RC:$frB))]>;
|
|
|
|
|
2005-07-21 06:42:00 +08:00
|
|
|
|
2004-10-08 06:30:03 +08:00
|
|
|
let isStore = 1 in {
|
2005-10-01 09:35:02 +08:00
|
|
|
def STFSX : XForm_28<31, 663, (ops F4RC:$frS, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"stfsx $frS, $rA, $rB", LdStUX>;
|
2005-10-01 09:35:02 +08:00
|
|
|
def STFDX : XForm_28<31, 727, (ops F8RC:$frS, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"stfdx $frS, $rA, $rB", LdStUX>;
|
2004-10-08 06:30:03 +08:00
|
|
|
}
|
2004-08-30 06:45:13 +08:00
|
|
|
|
2004-08-30 10:28:06 +08:00
|
|
|
// XL-Form instructions. condition register logical ops.
|
|
|
|
//
|
2005-04-19 12:51:30 +08:00
|
|
|
def MCRF : XLForm_3<19, 0, (ops CRRC:$BF, CRRC:$BFA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"mcrf $BF, $BFA", BrMCR>;
|
2004-08-30 10:28:06 +08:00
|
|
|
|
|
|
|
// XFX-Form instructions. Instructions that deal with SPRs
|
|
|
|
//
|
2004-10-23 14:05:49 +08:00
|
|
|
// Note that although LR should be listed as `8' and CTR as `9' in the SPR
|
|
|
|
// field, the manual lists the groups of bits as [5-9] = 0, [0-4] = 8 or 9
|
|
|
|
// which means the SPR value needs to be multiplied by a factor of 32.
|
2005-10-20 03:51:16 +08:00
|
|
|
def MFCTR : XFXForm_1_ext<31, 339, 288, (ops GPRC:$rT), "mfctr $rT", SprMFSPR>;
|
|
|
|
def MFLR : XFXForm_1_ext<31, 339, 256, (ops GPRC:$rT), "mflr $rT", SprMFSPR>;
|
|
|
|
def MFCR : XFXForm_3<31, 19, (ops GPRC:$rT), "mfcr $rT", SprMFCR>;
|
2005-08-27 06:05:54 +08:00
|
|
|
def MTCRF : XFXForm_5<31, 144, (ops crbitm:$FXM, GPRC:$rS),
|
2005-10-20 03:51:16 +08:00
|
|
|
"mtcrf $FXM, $rS", BrMCRX>;
|
2005-08-09 04:04:52 +08:00
|
|
|
def MFOCRF : XFXForm_5a<31, 19, (ops GPRC:$rT, crbitm:$FXM),
|
2005-10-20 03:51:16 +08:00
|
|
|
"mfcr $rT, $FXM", SprMFCR>;
|
|
|
|
def MTCTR : XFXForm_7_ext<31, 467, 288, (ops GPRC:$rS), "mtctr $rS", SprMTSPR>;
|
|
|
|
def MTLR : XFXForm_7_ext<31, 467, 256, (ops GPRC:$rS), "mtlr $rS", SprMTSPR>;
|
2004-08-30 10:28:06 +08:00
|
|
|
|
|
|
|
// XS-Form instructions. Just 'sradi'
|
|
|
|
//
|
2005-04-19 13:15:18 +08:00
|
|
|
def SRADI : XSForm_1<31, 413, (ops GPRC:$rA, GPRC:$rS, u6imm:$SH),
|
2005-10-20 03:51:16 +08:00
|
|
|
"sradi $rA, $rS, $SH", IntRotateD>, isPPC64;
|
2004-08-30 10:28:06 +08:00
|
|
|
|
|
|
|
// XO-Form instructions. Arithmetic instructions that can set overflow bit
|
|
|
|
//
|
2005-10-18 08:28:58 +08:00
|
|
|
def ADD4 : XOForm_1<31, 266, 0, (ops GPRC:$rT, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"add $rT, $rA, $rB", IntGeneral,
|
2005-09-03 05:18:00 +08:00
|
|
|
[(set GPRC:$rT, (add GPRC:$rA, GPRC:$rB))]>;
|
2005-10-18 08:28:58 +08:00
|
|
|
def ADD8 : XOForm_1<31, 266, 0, (ops G8RC:$rT, G8RC:$rA, G8RC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"add $rT, $rA, $rB", IntGeneral,
|
2005-10-18 08:28:58 +08:00
|
|
|
[(set G8RC:$rT, (add G8RC:$rA, G8RC:$rB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def ADDC : XOForm_1<31, 10, 0, (ops GPRC:$rT, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"addc $rT, $rA, $rB", IntGeneral,
|
2005-09-03 05:18:00 +08:00
|
|
|
[]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def ADDE : XOForm_1<31, 138, 0, (ops GPRC:$rT, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"adde $rT, $rA, $rB", IntGeneral,
|
2005-09-03 05:18:00 +08:00
|
|
|
[]>;
|
2005-10-20 15:51:08 +08:00
|
|
|
def DIVD : XOForm_1<31, 489, 0, (ops G8RC:$rT, G8RC:$rA, G8RC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"divd $rT, $rA, $rB", IntDivD,
|
2005-10-20 15:51:08 +08:00
|
|
|
[(set G8RC:$rT, (sdiv G8RC:$rA, G8RC:$rB))]>, isPPC64;
|
|
|
|
def DIVDU : XOForm_1<31, 457, 0, (ops G8RC:$rT, G8RC:$rA, G8RC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"divdu $rT, $rA, $rB", IntDivD,
|
2005-10-20 15:51:08 +08:00
|
|
|
[(set G8RC:$rT, (udiv G8RC:$rA, G8RC:$rB))]>, isPPC64;
|
2005-04-19 13:21:30 +08:00
|
|
|
def DIVW : XOForm_1<31, 491, 0, (ops GPRC:$rT, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"divw $rT, $rA, $rB", IntDivW,
|
2005-09-03 05:18:00 +08:00
|
|
|
[(set GPRC:$rT, (sdiv GPRC:$rA, GPRC:$rB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def DIVWU : XOForm_1<31, 459, 0, (ops GPRC:$rT, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"divwu $rT, $rA, $rB", IntDivW,
|
2005-09-03 05:18:00 +08:00
|
|
|
[(set GPRC:$rT, (udiv GPRC:$rA, GPRC:$rB))]>;
|
2005-10-20 15:51:08 +08:00
|
|
|
def MULHD : XOForm_1<31, 73, 0, (ops G8RC:$rT, G8RC:$rA, G8RC:$rB),
|
|
|
|
"mulhd $rT, $rA, $rB", IntMulHW,
|
|
|
|
[(set G8RC:$rT, (mulhs G8RC:$rA, G8RC:$rB))]>;
|
|
|
|
def MULHDU : XOForm_1<31, 9, 0, (ops G8RC:$rT, G8RC:$rA, G8RC:$rB),
|
|
|
|
"mulhdu $rT, $rA, $rB", IntMulHWU,
|
|
|
|
[(set G8RC:$rT, (mulhu G8RC:$rA, G8RC:$rB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def MULHW : XOForm_1<31, 75, 0, (ops GPRC:$rT, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"mulhw $rT, $rA, $rB", IntMulHW,
|
2005-09-03 05:18:00 +08:00
|
|
|
[(set GPRC:$rT, (mulhs GPRC:$rA, GPRC:$rB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def MULHWU : XOForm_1<31, 11, 0, (ops GPRC:$rT, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"mulhwu $rT, $rA, $rB", IntMulHWU,
|
2005-09-03 05:18:00 +08:00
|
|
|
[(set GPRC:$rT, (mulhu GPRC:$rA, GPRC:$rB))]>;
|
2005-10-20 15:51:08 +08:00
|
|
|
def MULLD : XOForm_1<31, 233, 0, (ops G8RC:$rT, G8RC:$rA, G8RC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"mulld $rT, $rA, $rB", IntMulHD,
|
2005-10-20 15:51:08 +08:00
|
|
|
[(set G8RC:$rT, (mul G8RC:$rA, G8RC:$rB))]>, isPPC64;
|
2005-04-19 13:21:30 +08:00
|
|
|
def MULLW : XOForm_1<31, 235, 0, (ops GPRC:$rT, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"mullw $rT, $rA, $rB", IntMulHW,
|
2005-09-03 05:18:00 +08:00
|
|
|
[(set GPRC:$rT, (mul GPRC:$rA, GPRC:$rB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def SUBF : XOForm_1<31, 40, 0, (ops GPRC:$rT, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"subf $rT, $rA, $rB", IntGeneral,
|
2005-09-03 05:18:00 +08:00
|
|
|
[(set GPRC:$rT, (sub GPRC:$rB, GPRC:$rA))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def SUBFC : XOForm_1<31, 8, 0, (ops GPRC:$rT, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"subfc $rT, $rA, $rB", IntGeneral,
|
2005-09-03 05:18:00 +08:00
|
|
|
[]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def SUBFE : XOForm_1<31, 136, 0, (ops GPRC:$rT, GPRC:$rA, GPRC:$rB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"subfe $rT, $rA, $rB", IntGeneral,
|
2005-09-03 05:18:00 +08:00
|
|
|
[]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def ADDME : XOForm_3<31, 234, 0, (ops GPRC:$rT, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"addme $rT, $rA", IntGeneral,
|
2005-09-09 01:01:54 +08:00
|
|
|
[]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def ADDZE : XOForm_3<31, 202, 0, (ops GPRC:$rT, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"addze $rT, $rA", IntGeneral,
|
2005-09-09 01:01:54 +08:00
|
|
|
[]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def NEG : XOForm_3<31, 104, 0, (ops GPRC:$rT, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"neg $rT, $rA", IntGeneral,
|
2005-09-09 01:01:54 +08:00
|
|
|
[(set GPRC:$rT, (ineg GPRC:$rA))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def SUBFZE : XOForm_3<31, 200, 0, (ops GPRC:$rT, GPRC:$rA),
|
2005-10-20 03:51:16 +08:00
|
|
|
"subfze $rT, $rA", IntGeneral,
|
2005-09-09 01:01:54 +08:00
|
|
|
[]>;
|
2004-08-30 10:28:06 +08:00
|
|
|
|
|
|
|
// A-Form instructions. Most of the instructions executed in the FPU are of
|
|
|
|
// this type.
|
|
|
|
//
|
2005-04-19 13:21:30 +08:00
|
|
|
def FMADD : AForm_1<63, 29,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F8RC:$FRT, F8RC:$FRA, F8RC:$FRC, F8RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fmadd $FRT, $FRA, $FRC, $FRB", FPFused,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F8RC:$FRT, (fadd (fmul F8RC:$FRA, F8RC:$FRC),
|
|
|
|
F8RC:$FRB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FMADDS : AForm_1<59, 29,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F4RC:$FRT, F4RC:$FRA, F4RC:$FRC, F4RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fmadds $FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2005-10-02 15:46:28 +08:00
|
|
|
[(set F4RC:$FRT, (fadd (fmul F4RC:$FRA, F4RC:$FRC),
|
|
|
|
F4RC:$FRB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FMSUB : AForm_1<63, 28,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F8RC:$FRT, F8RC:$FRA, F8RC:$FRC, F8RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fmsub $FRT, $FRA, $FRC, $FRB", FPFused,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F8RC:$FRT, (fsub (fmul F8RC:$FRA, F8RC:$FRC),
|
|
|
|
F8RC:$FRB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FMSUBS : AForm_1<59, 28,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F4RC:$FRT, F4RC:$FRA, F4RC:$FRC, F4RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fmsubs $FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2005-10-02 15:46:28 +08:00
|
|
|
[(set F4RC:$FRT, (fsub (fmul F4RC:$FRA, F4RC:$FRC),
|
|
|
|
F4RC:$FRB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FNMADD : AForm_1<63, 31,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F8RC:$FRT, F8RC:$FRA, F8RC:$FRC, F8RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fnmadd $FRT, $FRA, $FRC, $FRB", FPFused,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F8RC:$FRT, (fneg (fadd (fmul F8RC:$FRA, F8RC:$FRC),
|
|
|
|
F8RC:$FRB)))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FNMADDS : AForm_1<59, 31,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F4RC:$FRT, F4RC:$FRA, F4RC:$FRC, F4RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fnmadds $FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2005-10-02 15:46:28 +08:00
|
|
|
[(set F4RC:$FRT, (fneg (fadd (fmul F4RC:$FRA, F4RC:$FRC),
|
|
|
|
F4RC:$FRB)))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FNMSUB : AForm_1<63, 30,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F8RC:$FRT, F8RC:$FRA, F8RC:$FRC, F8RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fnmsub $FRT, $FRA, $FRC, $FRB", FPFused,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F8RC:$FRT, (fneg (fsub (fmul F8RC:$FRA, F8RC:$FRC),
|
|
|
|
F8RC:$FRB)))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FNMSUBS : AForm_1<59, 30,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F4RC:$FRT, F4RC:$FRA, F4RC:$FRC, F4RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fnmsubs $FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2005-10-02 15:46:28 +08:00
|
|
|
[(set F4RC:$FRT, (fneg (fsub (fmul F4RC:$FRA, F4RC:$FRC),
|
|
|
|
F4RC:$FRB)))]>;
|
2005-10-02 15:07:49 +08:00
|
|
|
// FSEL is artificially split into 4 and 8-byte forms for the result. To avoid
|
|
|
|
// having 4 of these, force the comparison to always be an 8-byte double (code
|
|
|
|
// should use an FMRSD if the input comparison value really wants to be a float)
|
2005-10-02 14:58:23 +08:00
|
|
|
// and 4/8 byte forms for the result and operand type..
|
2005-10-02 15:07:49 +08:00
|
|
|
def FSELD : AForm_1<63, 23,
|
|
|
|
(ops F8RC:$FRT, F8RC:$FRA, F8RC:$FRC, F8RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fsel $FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2005-10-02 15:07:49 +08:00
|
|
|
[]>;
|
|
|
|
def FSELS : AForm_1<63, 23,
|
2005-10-02 14:58:23 +08:00
|
|
|
(ops F4RC:$FRT, F8RC:$FRA, F4RC:$FRC, F4RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fsel $FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2005-10-02 14:58:23 +08:00
|
|
|
[]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FADD : AForm_2<63, 21,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F8RC:$FRT, F8RC:$FRA, F8RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fadd $FRT, $FRA, $FRB", FPGeneral,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F8RC:$FRT, (fadd F8RC:$FRA, F8RC:$FRB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FADDS : AForm_2<59, 21,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F4RC:$FRT, F4RC:$FRA, F4RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fadds $FRT, $FRA, $FRB", FPGeneral,
|
2005-10-02 15:46:28 +08:00
|
|
|
[(set F4RC:$FRT, (fadd F4RC:$FRA, F4RC:$FRB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FDIV : AForm_2<63, 18,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F8RC:$FRT, F8RC:$FRA, F8RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fdiv $FRT, $FRA, $FRB", FPDivD,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F8RC:$FRT, (fdiv F8RC:$FRA, F8RC:$FRB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FDIVS : AForm_2<59, 18,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F4RC:$FRT, F4RC:$FRA, F4RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fdivs $FRT, $FRA, $FRB", FPDivS,
|
2005-10-02 15:46:28 +08:00
|
|
|
[(set F4RC:$FRT, (fdiv F4RC:$FRA, F4RC:$FRB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FMUL : AForm_3<63, 25,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F8RC:$FRT, F8RC:$FRA, F8RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fmul $FRT, $FRA, $FRB", FPFused,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F8RC:$FRT, (fmul F8RC:$FRA, F8RC:$FRB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FMULS : AForm_3<59, 25,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F4RC:$FRT, F4RC:$FRA, F4RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fmuls $FRT, $FRA, $FRB", FPGeneral,
|
2005-10-02 15:46:28 +08:00
|
|
|
[(set F4RC:$FRT, (fmul F4RC:$FRA, F4RC:$FRB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FSUB : AForm_2<63, 20,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F8RC:$FRT, F8RC:$FRA, F8RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fsub $FRT, $FRA, $FRB", FPGeneral,
|
2005-10-01 09:35:02 +08:00
|
|
|
[(set F8RC:$FRT, (fsub F8RC:$FRA, F8RC:$FRB))]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def FSUBS : AForm_2<59, 20,
|
2005-10-01 09:35:02 +08:00
|
|
|
(ops F4RC:$FRT, F4RC:$FRA, F4RC:$FRB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"fsubs $FRT, $FRA, $FRB", FPGeneral,
|
2005-10-02 15:46:28 +08:00
|
|
|
[(set F4RC:$FRT, (fsub F4RC:$FRA, F4RC:$FRB))]>;
|
2004-08-30 10:28:06 +08:00
|
|
|
|
2004-08-31 10:28:08 +08:00
|
|
|
// M-Form instructions. rotate and mask instructions.
|
|
|
|
//
|
2005-09-10 02:17:41 +08:00
|
|
|
let isTwoAddress = 1, isCommutable = 1 in {
|
|
|
|
// RLWIMI can be commuted if the rotate amount is zero.
|
2005-04-19 13:21:30 +08:00
|
|
|
def RLWIMI : MForm_2<20,
|
2004-10-17 04:43:38 +08:00
|
|
|
(ops GPRC:$rA, GPRC:$rSi, GPRC:$rS, u5imm:$SH, u5imm:$MB,
|
2005-10-20 03:51:16 +08:00
|
|
|
u5imm:$ME), "rlwimi $rA, $rS, $SH, $MB, $ME", IntRotate,
|
2005-10-20 02:42:01 +08:00
|
|
|
[]>;
|
2005-10-18 08:28:58 +08:00
|
|
|
def RLDIMI : MDForm_1<30, 3,
|
|
|
|
(ops G8RC:$rA, G8RC:$rSi, G8RC:$rS, u6imm:$SH, u6imm:$MB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"rldimi $rA, $rS, $SH, $MB", IntRotateD,
|
2005-10-20 02:42:01 +08:00
|
|
|
[]>, isPPC64;
|
2004-10-17 04:43:38 +08:00
|
|
|
}
|
2005-04-19 13:21:30 +08:00
|
|
|
def RLWINM : MForm_2<21,
|
2004-08-31 10:28:08 +08:00
|
|
|
(ops GPRC:$rA, GPRC:$rS, u5imm:$SH, u5imm:$MB, u5imm:$ME),
|
2005-10-20 03:51:16 +08:00
|
|
|
"rlwinm $rA, $rS, $SH, $MB, $ME", IntGeneral,
|
2005-10-20 02:42:01 +08:00
|
|
|
[]>;
|
2005-04-19 13:21:30 +08:00
|
|
|
def RLWINMo : MForm_2<21,
|
2005-04-12 08:10:02 +08:00
|
|
|
(ops GPRC:$rA, GPRC:$rS, u5imm:$SH, u5imm:$MB, u5imm:$ME),
|
2005-10-20 03:51:16 +08:00
|
|
|
"rlwinm. $rA, $rS, $SH, $MB, $ME", IntGeneral,
|
2005-10-20 02:42:01 +08:00
|
|
|
[]>, isDOT;
|
2005-04-19 13:21:30 +08:00
|
|
|
def RLWNM : MForm_2<23,
|
2005-04-10 04:09:12 +08:00
|
|
|
(ops GPRC:$rA, GPRC:$rS, GPRC:$rB, u5imm:$MB, u5imm:$ME),
|
2005-10-20 03:51:16 +08:00
|
|
|
"rlwnm $rA, $rS, $rB, $MB, $ME", IntGeneral,
|
2005-10-20 02:42:01 +08:00
|
|
|
[]>;
|
2004-08-31 10:28:08 +08:00
|
|
|
|
|
|
|
// MD-Form instructions. 64 bit rotate instructions.
|
|
|
|
//
|
2005-04-19 13:21:30 +08:00
|
|
|
def RLDICL : MDForm_1<30, 0,
|
2005-10-18 08:28:58 +08:00
|
|
|
(ops G8RC:$rA, G8RC:$rS, u6imm:$SH, u6imm:$MB),
|
2005-10-20 03:51:16 +08:00
|
|
|
"rldicl $rA, $rS, $SH, $MB", IntRotateD,
|
2005-10-20 02:42:01 +08:00
|
|
|
[]>, isPPC64;
|
2005-04-19 13:21:30 +08:00
|
|
|
def RLDICR : MDForm_1<30, 1,
|
2005-10-18 08:28:58 +08:00
|
|
|
(ops G8RC:$rA, G8RC:$rS, u6imm:$SH, u6imm:$ME),
|
2005-10-20 03:51:16 +08:00
|
|
|
"rldicr $rA, $rS, $SH, $ME", IntRotateD,
|
2005-10-20 02:42:01 +08:00
|
|
|
[]>, isPPC64;
|
2004-08-31 10:28:08 +08:00
|
|
|
|
2005-09-09 08:39:56 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Instruction Patterns
|
|
|
|
//
|
|
|
|
|
2005-09-27 06:20:16 +08:00
|
|
|
// Arbitrary immediate support. Implement in terms of LIS/ORI.
|
|
|
|
def : Pat<(i32 imm:$imm),
|
|
|
|
(ORI (LIS (HI16 imm:$imm)), (LO16 imm:$imm))>;
|
2005-09-29 01:13:15 +08:00
|
|
|
|
|
|
|
// Implement the 'not' operation with the NOR instruction.
|
|
|
|
def NOT : Pat<(not GPRC:$in),
|
|
|
|
(NOR GPRC:$in, GPRC:$in)>;
|
|
|
|
|
2005-09-29 07:07:13 +08:00
|
|
|
// ADD an arbitrary immediate.
|
|
|
|
def : Pat<(add GPRC:$in, imm:$imm),
|
|
|
|
(ADDIS (ADDI GPRC:$in, (LO16 imm:$imm)), (HA16 imm:$imm))>;
|
|
|
|
// OR an arbitrary immediate.
|
2005-09-09 08:39:56 +08:00
|
|
|
def : Pat<(or GPRC:$in, imm:$imm),
|
|
|
|
(ORIS (ORI GPRC:$in, (LO16 imm:$imm)), (HI16 imm:$imm))>;
|
2005-09-29 07:07:13 +08:00
|
|
|
// XOR an arbitrary immediate.
|
2005-09-09 08:39:56 +08:00
|
|
|
def : Pat<(xor GPRC:$in, imm:$imm),
|
|
|
|
(XORIS (XORI GPRC:$in, (LO16 imm:$imm)), (HI16 imm:$imm))>;
|
2005-10-21 14:36:18 +08:00
|
|
|
def : Pat<(or (shl GPRC:$rS, GPRC:$rB),
|
|
|
|
(srl GPRC:$rS, (sub 32, GPRC:$rB))),
|
|
|
|
(RLWNM GPRC:$rS, GPRC:$rB, 0, 31)>;
|
2005-10-19 09:38:02 +08:00
|
|
|
|
|
|
|
def : Pat<(zext GPRC:$in),
|
2005-10-19 12:32:04 +08:00
|
|
|
(RLDICL (OR4To8 GPRC:$in, GPRC:$in), 0, 32)>;
|
2005-10-19 09:38:02 +08:00
|
|
|
def : Pat<(anyext GPRC:$in),
|
|
|
|
(OR4To8 GPRC:$in, GPRC:$in)>;
|
|
|
|
def : Pat<(trunc G8RC:$in),
|
|
|
|
(OR8To4 G8RC:$in, G8RC:$in)>;
|
|
|
|
|
2005-10-20 02:42:01 +08:00
|
|
|
// SHL
|
|
|
|
def : Pat<(shl GPRC:$in, imm:$imm),
|
|
|
|
(RLWINM GPRC:$in, imm:$imm, 0, (SHL32 imm:$imm))>;
|
|
|
|
def : Pat<(shl G8RC:$in, imm:$imm),
|
|
|
|
(RLDICR G8RC:$in, imm:$imm, (SHL64 imm:$imm))>;
|
|
|
|
// SRL
|
|
|
|
def : Pat<(srl GPRC:$in, imm:$imm),
|
|
|
|
(RLWINM GPRC:$in, (SRL32 imm:$imm), imm:$imm, 31)>;
|
|
|
|
def : Pat<(srl G8RC:$in, imm:$imm),
|
|
|
|
(RLDICL G8RC:$in, (SRL64 imm:$imm), imm:$imm)>;
|
|
|
|
|
2005-09-24 08:41:58 +08:00
|
|
|
// Same as above, but using a temporary. FIXME: implement temporaries :)
|
2005-09-16 05:44:00 +08:00
|
|
|
/*
|
2005-09-15 02:18:39 +08:00
|
|
|
def : Pattern<(xor GPRC:$in, imm:$imm),
|
|
|
|
[(set GPRC:$tmp, (XORI GPRC:$in, (LO16 imm:$imm))),
|
|
|
|
(XORIS GPRC:$tmp, (HI16 imm:$imm))]>;
|
2005-09-16 05:44:00 +08:00
|
|
|
*/
|
2005-09-15 02:18:39 +08:00
|
|
|
|
2005-09-09 08:39:56 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPCInstrInfo Definition
|
|
|
|
//
|
2004-12-17 00:31:57 +08:00
|
|
|
def PowerPCInstrInfo : InstrInfo {
|
|
|
|
let PHIInst = PHI;
|
|
|
|
|
|
|
|
let TSFlagsFields = [ "VMX", "PPC64" ];
|
|
|
|
let TSFlagsShifts = [ 0, 1 ];
|
|
|
|
|
|
|
|
let isLittleEndianEncoding = 1;
|
|
|
|
}
|
2005-09-09 08:39:56 +08:00
|
|
|
|