2005-10-14 23:40:39 +00:00
|
|
|
//===- PPCInstrInfo.td - The PowerPC Instruction Set -------*- tablegen -*-===//
|
2004-06-21 16:55:25 +00:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2004-06-21 16:55:25 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2004-08-09 17:24:04 +00:00
|
|
|
// This file describes the subset of the 32-bit PowerPC instruction set, as used
|
|
|
|
// by the PowerPC instruction selector.
|
2004-06-21 16:55:25 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2005-10-14 23:40:39 +00:00
|
|
|
include "PPCInstrFormats.td"
|
2004-06-21 16:55:25 +00:00
|
|
|
|
2006-03-01 05:50:56 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC specific type constraints.
|
|
|
|
//
|
|
|
|
def SDT_PPCstfiwx : SDTypeProfile<0, 2, [ // stfiwx
|
|
|
|
SDTCisVT<0, f64>, SDTCisPtrTy<1>
|
|
|
|
]>;
|
2007-11-13 09:19:02 +00:00
|
|
|
def SDT_PPCCallSeqStart : SDCallSeqStart<[ SDTCisVT<0, i32> ]>;
|
|
|
|
def SDT_PPCCallSeqEnd : SDCallSeqEnd<[ SDTCisVT<0, i32>,
|
|
|
|
SDTCisVT<1, i32> ]>;
|
2006-03-20 01:53:53 +00:00
|
|
|
def SDT_PPCvperm : SDTypeProfile<1, 3, [
|
|
|
|
SDTCisVT<3, v16i8>, SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>
|
|
|
|
]>;
|
|
|
|
|
2006-03-31 05:13:27 +00:00
|
|
|
def SDT_PPCvcmp : SDTypeProfile<1, 3, [
|
2006-03-26 10:06:40 +00:00
|
|
|
SDTCisSameAs<0, 1>, SDTCisSameAs<1, 2>, SDTCisVT<3, i32>
|
|
|
|
]>;
|
|
|
|
|
Implement an important entry from README_ALTIVEC:
If an altivec predicate compare is used immediately by a branch, don't
use a (serializing) MFCR instruction to read the CR6 register, which requires
a compare to get it back to CR's. Instead, just branch on CR6 directly. :)
For example, for:
void foo2(vector float *A, vector float *B) {
if (!vec_any_eq(*A, *B))
*B = (vector float){0,0,0,0};
}
We now generate:
_foo2:
mfspr r2, 256
oris r5, r2, 12288
mtspr 256, r5
lvx v2, 0, r4
lvx v3, 0, r3
vcmpeqfp. v2, v3, v2
bne cr6, LBB1_2 ; UnifiedReturnBlock
LBB1_1: ; cond_true
vxor v2, v2, v2
stvx v2, 0, r4
mtspr 256, r2
blr
LBB1_2: ; UnifiedReturnBlock
mtspr 256, r2
blr
instead of:
_foo2:
mfspr r2, 256
oris r5, r2, 12288
mtspr 256, r5
lvx v2, 0, r4
lvx v3, 0, r3
vcmpeqfp. v2, v3, v2
mfcr r3, 2
rlwinm r3, r3, 27, 31, 31
cmpwi cr0, r3, 0
beq cr0, LBB1_2 ; UnifiedReturnBlock
LBB1_1: ; cond_true
vxor v2, v2, v2
stvx v2, 0, r4
mtspr 256, r2
blr
LBB1_2: ; UnifiedReturnBlock
mtspr 256, r2
blr
This implements CodeGen/PowerPC/vec_br_cmp.ll.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@27804 91177308-0d34-0410-b5e6-96231b3b80d8
2006-04-18 17:59:36 +00:00
|
|
|
def SDT_PPCcondbr : SDTypeProfile<0, 3, [
|
2006-11-17 22:37:34 +00:00
|
|
|
SDTCisVT<0, i32>, SDTCisVT<2, OtherVT>
|
Implement an important entry from README_ALTIVEC:
If an altivec predicate compare is used immediately by a branch, don't
use a (serializing) MFCR instruction to read the CR6 register, which requires
a compare to get it back to CR's. Instead, just branch on CR6 directly. :)
For example, for:
void foo2(vector float *A, vector float *B) {
if (!vec_any_eq(*A, *B))
*B = (vector float){0,0,0,0};
}
We now generate:
_foo2:
mfspr r2, 256
oris r5, r2, 12288
mtspr 256, r5
lvx v2, 0, r4
lvx v3, 0, r3
vcmpeqfp. v2, v3, v2
bne cr6, LBB1_2 ; UnifiedReturnBlock
LBB1_1: ; cond_true
vxor v2, v2, v2
stvx v2, 0, r4
mtspr 256, r2
blr
LBB1_2: ; UnifiedReturnBlock
mtspr 256, r2
blr
instead of:
_foo2:
mfspr r2, 256
oris r5, r2, 12288
mtspr 256, r5
lvx v2, 0, r4
lvx v3, 0, r3
vcmpeqfp. v2, v3, v2
mfcr r3, 2
rlwinm r3, r3, 27, 31, 31
cmpwi cr0, r3, 0
beq cr0, LBB1_2 ; UnifiedReturnBlock
LBB1_1: ; cond_true
vxor v2, v2, v2
stvx v2, 0, r4
mtspr 256, r2
blr
LBB1_2: ; UnifiedReturnBlock
mtspr 256, r2
blr
This implements CodeGen/PowerPC/vec_br_cmp.ll.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@27804 91177308-0d34-0410-b5e6-96231b3b80d8
2006-04-18 17:59:36 +00:00
|
|
|
]>;
|
|
|
|
|
2006-07-10 20:56:58 +00:00
|
|
|
def SDT_PPClbrx : SDTypeProfile<1, 3, [
|
|
|
|
SDTCisVT<0, i32>, SDTCisPtrTy<1>, SDTCisVT<2, OtherVT>, SDTCisVT<3, OtherVT>
|
|
|
|
]>;
|
|
|
|
def SDT_PPCstbrx : SDTypeProfile<0, 4, [
|
|
|
|
SDTCisVT<0, i32>, SDTCisPtrTy<1>, SDTCisVT<2, OtherVT>, SDTCisVT<3, OtherVT>
|
|
|
|
]>;
|
|
|
|
|
2008-07-12 02:23:19 +00:00
|
|
|
def SDT_PPCatomic_load_add : SDTypeProfile<1, 2, [
|
|
|
|
SDTCisInt<0>, SDTCisPtrTy<1>, SDTCisInt<2>
|
|
|
|
]>;
|
|
|
|
def SDT_PPCatomic_cmp_swap : SDTypeProfile<1, 3, [
|
|
|
|
SDTCisInt<0>, SDTCisPtrTy<1>, SDTCisInt<2>, SDTCisInt<3>
|
|
|
|
]>;
|
|
|
|
def SDT_PPCatomic_swap : SDTypeProfile<1, 2, [
|
|
|
|
SDTCisInt<0>, SDTCisPtrTy<1>, SDTCisInt<2>
|
2008-04-19 01:30:48 +00:00
|
|
|
]>;
|
2008-07-12 02:23:19 +00:00
|
|
|
|
|
|
|
def SDT_PPClarx : SDTypeProfile<1, 1, [
|
|
|
|
SDTCisInt<0>, SDTCisPtrTy<1>
|
2008-04-19 01:30:48 +00:00
|
|
|
]>;
|
2008-07-12 02:23:19 +00:00
|
|
|
def SDT_PPCstcx : SDTypeProfile<0, 2, [
|
|
|
|
SDTCisInt<0>, SDTCisPtrTy<1>
|
2008-04-19 01:30:48 +00:00
|
|
|
]>;
|
|
|
|
|
2008-04-30 09:16:33 +00:00
|
|
|
def SDT_PPCTC_ret : SDTypeProfile<0, 2, [
|
|
|
|
SDTCisPtrTy<0>, SDTCisVT<1, i32>
|
|
|
|
]>;
|
|
|
|
|
2005-10-25 20:41:46 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC specific DAG Nodes.
|
|
|
|
//
|
|
|
|
|
|
|
|
def PPCfcfid : SDNode<"PPCISD::FCFID" , SDTFPUnaryOp, []>;
|
|
|
|
def PPCfctidz : SDNode<"PPCISD::FCTIDZ", SDTFPUnaryOp, []>;
|
|
|
|
def PPCfctiwz : SDNode<"PPCISD::FCTIWZ", SDTFPUnaryOp, []>;
|
2008-01-06 06:44:58 +00:00
|
|
|
def PPCstfiwx : SDNode<"PPCISD::STFIWX", SDT_PPCstfiwx,
|
|
|
|
[SDNPHasChain, SDNPMayStore]>;
|
2005-10-25 20:41:46 +00:00
|
|
|
|
2007-10-10 01:01:31 +00:00
|
|
|
// This sequence is used for long double->int conversions. It changes the
|
|
|
|
// bits in the FPSCR which is not modelled.
|
|
|
|
def PPCmffs : SDNode<"PPCISD::MFFS", SDTypeProfile<1, 0, [SDTCisVT<0, f64>]>,
|
|
|
|
[SDNPOutFlag]>;
|
|
|
|
def PPCmtfsb0 : SDNode<"PPCISD::MTFSB0", SDTypeProfile<0, 1, [SDTCisInt<0>]>,
|
|
|
|
[SDNPInFlag, SDNPOutFlag]>;
|
|
|
|
def PPCmtfsb1 : SDNode<"PPCISD::MTFSB1", SDTypeProfile<0, 1, [SDTCisInt<0>]>,
|
|
|
|
[SDNPInFlag, SDNPOutFlag]>;
|
|
|
|
def PPCfaddrtz: SDNode<"PPCISD::FADDRTZ", SDTFPBinOp,
|
|
|
|
[SDNPInFlag, SDNPOutFlag]>;
|
|
|
|
def PPCmtfsf : SDNode<"PPCISD::MTFSF", SDTypeProfile<1, 3,
|
|
|
|
[SDTCisVT<0, f64>, SDTCisInt<1>, SDTCisVT<2, f64>,
|
|
|
|
SDTCisVT<3, f64>]>,
|
|
|
|
[SDNPInFlag]>;
|
|
|
|
|
2005-10-25 20:55:47 +00:00
|
|
|
def PPCfsel : SDNode<"PPCISD::FSEL",
|
|
|
|
// Type constraint for fsel.
|
|
|
|
SDTypeProfile<1, 3, [SDTCisSameAs<0, 2>, SDTCisSameAs<0, 3>,
|
|
|
|
SDTCisFP<0>, SDTCisVT<1, f64>]>, []>;
|
2005-09-08 19:50:41 +00:00
|
|
|
|
2005-12-13 22:55:22 +00:00
|
|
|
def PPChi : SDNode<"PPCISD::Hi", SDTIntBinOp, []>;
|
|
|
|
def PPClo : SDNode<"PPCISD::Lo", SDTIntBinOp, []>;
|
|
|
|
def PPCvmaddfp : SDNode<"PPCISD::VMADDFP", SDTFPTernaryOp, []>;
|
|
|
|
def PPCvnmsubfp : SDNode<"PPCISD::VNMSUBFP", SDTFPTernaryOp, []>;
|
2005-11-17 07:30:41 +00:00
|
|
|
|
2006-03-20 01:53:53 +00:00
|
|
|
def PPCvperm : SDNode<"PPCISD::VPERM", SDT_PPCvperm, []>;
|
2006-03-19 06:55:52 +00:00
|
|
|
|
2005-12-06 02:10:38 +00:00
|
|
|
// These nodes represent the 32-bit PPC shifts that operate on 6-bit shift
|
|
|
|
// amounts. These nodes are generated by the multi-precision shift code.
|
2008-03-07 20:18:24 +00:00
|
|
|
def PPCsrl : SDNode<"PPCISD::SRL" , SDTIntShiftOp>;
|
|
|
|
def PPCsra : SDNode<"PPCISD::SRA" , SDTIntShiftOp>;
|
|
|
|
def PPCshl : SDNode<"PPCISD::SHL" , SDTIntShiftOp>;
|
2005-12-06 02:10:38 +00:00
|
|
|
|
When possible, custom lower 32-bit SINT_TO_FP to this:
_foo2:
extsw r2, r3
std r2, -8(r1)
lfd f0, -8(r1)
fcfid f0, f0
frsp f1, f0
blr
instead of this:
_foo2:
lis r2, ha16(LCPI2_0)
lis r4, 17200
xoris r3, r3, 32768
stw r3, -4(r1)
stw r4, -8(r1)
lfs f0, lo16(LCPI2_0)(r2)
lfd f1, -8(r1)
fsub f0, f1, f0
frsp f1, f0
blr
This speeds up Misc/pi from 2.44s->2.09s with LLC and from 3.01->2.18s
with llcbeta (16.7% and 38.1% respectively).
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26943 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-22 05:30:33 +00:00
|
|
|
def PPCextsw_32 : SDNode<"PPCISD::EXTSW_32" , SDTIntUnaryOp>;
|
2008-01-06 06:44:58 +00:00
|
|
|
def PPCstd_32 : SDNode<"PPCISD::STD_32" , SDTStore,
|
|
|
|
[SDNPHasChain, SDNPMayStore]>;
|
When possible, custom lower 32-bit SINT_TO_FP to this:
_foo2:
extsw r2, r3
std r2, -8(r1)
lfd f0, -8(r1)
fcfid f0, f0
frsp f1, f0
blr
instead of this:
_foo2:
lis r2, ha16(LCPI2_0)
lis r4, 17200
xoris r3, r3, 32768
stw r3, -4(r1)
stw r4, -8(r1)
lfs f0, lo16(LCPI2_0)(r2)
lfd f1, -8(r1)
fsub f0, f1, f0
frsp f1, f0
blr
This speeds up Misc/pi from 2.44s->2.09s with LLC and from 3.01->2.18s
with llcbeta (16.7% and 38.1% respectively).
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26943 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-22 05:30:33 +00:00
|
|
|
|
2005-12-04 19:01:59 +00:00
|
|
|
// These are target-independent nodes, but have target-specific formats.
|
2007-11-13 09:19:02 +00:00
|
|
|
def callseq_start : SDNode<"ISD::CALLSEQ_START", SDT_PPCCallSeqStart,
|
2006-08-11 09:03:33 +00:00
|
|
|
[SDNPHasChain, SDNPOutFlag]>;
|
2007-11-13 09:19:02 +00:00
|
|
|
def callseq_end : SDNode<"ISD::CALLSEQ_END", SDT_PPCCallSeqEnd,
|
2007-11-13 00:44:25 +00:00
|
|
|
[SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
|
2005-12-04 19:01:59 +00:00
|
|
|
|
2006-06-27 18:36:44 +00:00
|
|
|
def SDT_PPCCall : SDTypeProfile<0, -1, [SDTCisInt<0>]>;
|
2007-02-27 13:01:19 +00:00
|
|
|
def PPCcall_Macho : SDNode<"PPCISD::CALL_Macho", SDT_PPCCall,
|
2007-02-25 05:34:32 +00:00
|
|
|
[SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
|
2007-02-27 13:01:19 +00:00
|
|
|
def PPCcall_ELF : SDNode<"PPCISD::CALL_ELF", SDT_PPCCall,
|
2006-05-17 06:01:33 +00:00
|
|
|
[SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
|
2006-05-17 19:00:46 +00:00
|
|
|
def PPCmtctr : SDNode<"PPCISD::MTCTR", SDT_PPCCall,
|
|
|
|
[SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
|
2008-01-15 22:02:54 +00:00
|
|
|
def PPCbctrl_Macho : SDNode<"PPCISD::BCTRL_Macho", SDTNone,
|
2008-02-27 06:33:05 +00:00
|
|
|
[SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
|
2007-02-25 05:34:32 +00:00
|
|
|
|
2008-01-15 22:02:54 +00:00
|
|
|
def PPCbctrl_ELF : SDNode<"PPCISD::BCTRL_ELF", SDTNone,
|
2008-02-27 06:33:05 +00:00
|
|
|
[SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
|
2006-05-17 06:01:33 +00:00
|
|
|
|
2008-01-15 22:02:54 +00:00
|
|
|
def retflag : SDNode<"PPCISD::RET_FLAG", SDTNone,
|
2008-02-27 06:33:05 +00:00
|
|
|
[SDNPHasChain, SDNPOptInFlag]>;
|
2005-12-20 00:26:01 +00:00
|
|
|
|
2008-04-30 09:16:33 +00:00
|
|
|
def PPCtc_return : SDNode<"PPCISD::TC_RETURN", SDT_PPCTC_ret,
|
|
|
|
[SDNPHasChain, SDNPOptInFlag]>;
|
|
|
|
|
|
|
|
def PPCtailcall : SDNode<"PPCISD::TAILCALL", SDT_PPCCall,
|
|
|
|
[SDNPHasChain, SDNPOutFlag, SDNPOptInFlag]>;
|
|
|
|
|
2006-03-31 05:13:27 +00:00
|
|
|
def PPCvcmp : SDNode<"PPCISD::VCMP" , SDT_PPCvcmp, []>;
|
|
|
|
def PPCvcmp_o : SDNode<"PPCISD::VCMPo", SDT_PPCvcmp, [SDNPOutFlag]>;
|
2006-03-26 10:06:40 +00:00
|
|
|
|
Implement an important entry from README_ALTIVEC:
If an altivec predicate compare is used immediately by a branch, don't
use a (serializing) MFCR instruction to read the CR6 register, which requires
a compare to get it back to CR's. Instead, just branch on CR6 directly. :)
For example, for:
void foo2(vector float *A, vector float *B) {
if (!vec_any_eq(*A, *B))
*B = (vector float){0,0,0,0};
}
We now generate:
_foo2:
mfspr r2, 256
oris r5, r2, 12288
mtspr 256, r5
lvx v2, 0, r4
lvx v3, 0, r3
vcmpeqfp. v2, v3, v2
bne cr6, LBB1_2 ; UnifiedReturnBlock
LBB1_1: ; cond_true
vxor v2, v2, v2
stvx v2, 0, r4
mtspr 256, r2
blr
LBB1_2: ; UnifiedReturnBlock
mtspr 256, r2
blr
instead of:
_foo2:
mfspr r2, 256
oris r5, r2, 12288
mtspr 256, r5
lvx v2, 0, r4
lvx v3, 0, r3
vcmpeqfp. v2, v3, v2
mfcr r3, 2
rlwinm r3, r3, 27, 31, 31
cmpwi cr0, r3, 0
beq cr0, LBB1_2 ; UnifiedReturnBlock
LBB1_1: ; cond_true
vxor v2, v2, v2
stvx v2, 0, r4
mtspr 256, r2
blr
LBB1_2: ; UnifiedReturnBlock
mtspr 256, r2
blr
This implements CodeGen/PowerPC/vec_br_cmp.ll.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@27804 91177308-0d34-0410-b5e6-96231b3b80d8
2006-04-18 17:59:36 +00:00
|
|
|
def PPCcondbranch : SDNode<"PPCISD::COND_BRANCH", SDT_PPCcondbr,
|
|
|
|
[SDNPHasChain, SDNPOptInFlag]>;
|
|
|
|
|
2008-01-10 05:12:37 +00:00
|
|
|
def PPClbrx : SDNode<"PPCISD::LBRX", SDT_PPClbrx,
|
|
|
|
[SDNPHasChain, SDNPMayLoad]>;
|
2008-01-06 06:44:58 +00:00
|
|
|
def PPCstbrx : SDNode<"PPCISD::STBRX", SDT_PPCstbrx,
|
|
|
|
[SDNPHasChain, SDNPMayStore]>;
|
2006-07-10 20:56:58 +00:00
|
|
|
|
2008-07-12 02:23:19 +00:00
|
|
|
// Atomic operations
|
|
|
|
def PPCatomic_load_add : SDNode<"PPCISD::ATOMIC_LOAD_ADD",
|
|
|
|
SDT_PPCatomic_load_add,
|
|
|
|
[SDNPHasChain, SDNPMayLoad, SDNPMayStore]>;
|
|
|
|
def PPCatomic_cmp_swap : SDNode<"PPCISD::ATOMIC_CMP_SWAP",
|
|
|
|
SDT_PPCatomic_cmp_swap,
|
|
|
|
[SDNPHasChain, SDNPMayLoad, SDNPMayStore]>;
|
|
|
|
def PPCatomic_swap : SDNode<"PPCISD::ATOMIC_SWAP",
|
|
|
|
SDT_PPCatomic_swap,
|
|
|
|
[SDNPHasChain, SDNPMayLoad, SDNPMayStore]>;
|
|
|
|
|
|
|
|
// Instructions to support atomic operations
|
2008-04-19 02:30:38 +00:00
|
|
|
def PPClarx : SDNode<"PPCISD::LARX", SDT_PPClarx,
|
|
|
|
[SDNPHasChain, SDNPMayLoad]>;
|
|
|
|
def PPCstcx : SDNode<"PPCISD::STCX", SDT_PPCstcx,
|
|
|
|
[SDNPHasChain, SDNPMayStore]>;
|
2008-04-19 01:30:48 +00:00
|
|
|
|
2006-11-16 22:43:37 +00:00
|
|
|
// Instructions to support dynamic alloca.
|
|
|
|
def SDTDynOp : SDTypeProfile<1, 2, []>;
|
|
|
|
def PPCdynalloc : SDNode<"PPCISD::DYNALLOC", SDTDynOp, [SDNPHasChain]>;
|
|
|
|
|
2005-09-08 19:50:41 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2005-09-09 00:39:56 +00: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
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23809 91177308-0d34-0410-b5e6-96231b3b80d8
2005-10-19 01:12:32 +00:00
|
|
|
|
2005-10-19 18:42:01 +00:00
|
|
|
def SHL32 : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: 31 - imm
|
|
|
|
return getI32Imm(31 - N->getValue());
|
|
|
|
}]>;
|
|
|
|
|
|
|
|
def SRL32 : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: 32 - imm
|
|
|
|
return N->getValue() ? getI32Imm(32 - N->getValue()) : getI32Imm(0);
|
|
|
|
}]>;
|
|
|
|
|
2005-09-09 00:39:56 +00: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-08 17:33:10 +00:00
|
|
|
|
2005-09-28 23:07:13 +00: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);
|
|
|
|
}]>;
|
2006-09-22 05:01:56 +00:00
|
|
|
def MB : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: get the start bit of a mask
|
|
|
|
unsigned mb, me;
|
|
|
|
(void)isRunOfOnes((unsigned)N->getValue(), mb, me);
|
|
|
|
return getI32Imm(mb);
|
|
|
|
}]>;
|
2005-09-28 23:07:13 +00:00
|
|
|
|
2006-09-22 05:01:56 +00:00
|
|
|
def ME : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: get the end bit of a mask
|
|
|
|
unsigned mb, me;
|
|
|
|
(void)isRunOfOnes((unsigned)N->getValue(), mb, me);
|
|
|
|
return getI32Imm(me);
|
|
|
|
}]>;
|
|
|
|
def maskimm32 : PatLeaf<(imm), [{
|
|
|
|
// maskImm predicate - True if immediate is a run of ones.
|
|
|
|
unsigned mb, me;
|
|
|
|
if (N->getValueType(0) == MVT::i32)
|
|
|
|
return isRunOfOnes((unsigned)N->getValue(), mb, me);
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}]>;
|
2005-09-28 23:07:13 +00:00
|
|
|
|
2005-09-08 17:33:10 +00:00
|
|
|
def immSExt16 : PatLeaf<(imm), [{
|
|
|
|
// immSExt16 predicate - True if the immediate fits in a 16-bit sign extended
|
|
|
|
// field. Used by instructions like 'addi'.
|
2006-06-20 23:21:20 +00:00
|
|
|
if (N->getValueType(0) == MVT::i32)
|
|
|
|
return (int32_t)N->getValue() == (short)N->getValue();
|
|
|
|
else
|
|
|
|
return (int64_t)N->getValue() == (short)N->getValue();
|
2005-09-08 17:33:10 +00:00
|
|
|
}]>;
|
2005-09-08 17:40:49 +00:00
|
|
|
def immZExt16 : PatLeaf<(imm), [{
|
|
|
|
// immZExt16 predicate - True if the immediate fits in a 16-bit zero extended
|
|
|
|
// field. Used by instructions like 'ori'.
|
2006-06-20 23:21:20 +00:00
|
|
|
return (uint64_t)N->getValue() == (unsigned short)N->getValue();
|
2005-09-09 00:39:56 +00:00
|
|
|
}], LO16>;
|
|
|
|
|
Add some 64-bit logical ops.
Split imm16Shifted into a sext/zext form for 64-bit support.
Add some patterns for immediate formation. For example, we now compile this:
static unsigned long long Y;
void test3() {
Y = 0xF0F00F00;
}
into:
_test3:
li r2, 3840
lis r3, ha16(_Y)
xoris r2, r2, 61680
std r2, lo16(_Y)(r3)
blr
GCC produces:
_test3:
li r0,0
lis r2,ha16(_Y)
ori r0,r0,61680
sldi r0,r0,16
ori r0,r0,3840
std r0,lo16(_Y)(r2)
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@28883 91177308-0d34-0410-b5e6-96231b3b80d8
2006-06-20 22:34:10 +00:00
|
|
|
// imm16Shifted* - These match immediates where the low 16-bits are zero. There
|
|
|
|
// are two forms: imm16ShiftedSExt and imm16ShiftedZExt. These two forms are
|
|
|
|
// identical in 32-bit mode, but in 64-bit mode, they return true if the
|
|
|
|
// immediate fits into a sign/zero extended 32-bit immediate (with the low bits
|
|
|
|
// clear).
|
|
|
|
def imm16ShiftedZExt : PatLeaf<(imm), [{
|
|
|
|
// imm16ShiftedZExt predicate - True if only bits in the top 16-bits of the
|
|
|
|
// immediate are set. Used by instructions like 'xoris'.
|
|
|
|
return (N->getValue() & ~uint64_t(0xFFFF0000)) == 0;
|
|
|
|
}], HI16>;
|
|
|
|
|
|
|
|
def imm16ShiftedSExt : PatLeaf<(imm), [{
|
|
|
|
// imm16ShiftedSExt predicate - True if only bits in the top 16-bits of the
|
|
|
|
// immediate are set. Used by instructions like 'addis'. Identical to
|
|
|
|
// imm16ShiftedZExt in 32-bit mode.
|
2006-06-20 21:39:30 +00:00
|
|
|
if (N->getValue() & 0xFFFF) return false;
|
|
|
|
if (N->getValueType(0) == MVT::i32)
|
|
|
|
return true;
|
|
|
|
// For 64-bit, make sure it is sext right.
|
|
|
|
return N->getValue() == (uint64_t)(int)N->getValue();
|
2005-09-09 00:39:56 +00:00
|
|
|
}], HI16>;
|
2005-09-08 17:33:10 +00:00
|
|
|
|
2006-03-25 06:12:06 +00:00
|
|
|
|
2005-09-08 19:50:41 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Flag Definitions.
|
|
|
|
|
2005-04-19 04:32:54 +00:00
|
|
|
class isPPC64 { bit PPC64 = 1; }
|
2005-04-19 05:15:18 +00:00
|
|
|
class isDOT {
|
|
|
|
list<Register> Defs = [CR0];
|
|
|
|
bit RC = 1;
|
|
|
|
}
|
2005-04-19 04:32:54 +00:00
|
|
|
|
2006-11-08 02:13:12 +00:00
|
|
|
class RegConstraint<string C> {
|
|
|
|
string Constraints = C;
|
|
|
|
}
|
2006-11-15 23:24:18 +00:00
|
|
|
class NoEncode<string E> {
|
|
|
|
string DisableEncoding = E;
|
|
|
|
}
|
2005-09-08 19:50:41 +00:00
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Operand Definitions.
|
2004-08-14 23:27:29 +00:00
|
|
|
|
2006-03-25 06:12:06 +00:00
|
|
|
def s5imm : Operand<i32> {
|
|
|
|
let PrintMethod = "printS5ImmOperand";
|
|
|
|
}
|
2005-09-14 20:53:05 +00:00
|
|
|
def u5imm : Operand<i32> {
|
2004-08-21 05:56:39 +00:00
|
|
|
let PrintMethod = "printU5ImmOperand";
|
|
|
|
}
|
2005-09-14 20:53:05 +00:00
|
|
|
def u6imm : Operand<i32> {
|
2004-08-30 02:28:06 +00:00
|
|
|
let PrintMethod = "printU6ImmOperand";
|
|
|
|
}
|
2005-09-14 20:53:05 +00:00
|
|
|
def s16imm : Operand<i32> {
|
2004-09-04 05:00:00 +00:00
|
|
|
let PrintMethod = "printS16ImmOperand";
|
|
|
|
}
|
2005-09-14 20:53:05 +00:00
|
|
|
def u16imm : Operand<i32> {
|
2004-08-15 05:20:16 +00:00
|
|
|
let PrintMethod = "printU16ImmOperand";
|
|
|
|
}
|
2005-10-18 16:51:22 +00:00
|
|
|
def s16immX4 : Operand<i32> { // Multiply imm by 4 before printing.
|
|
|
|
let PrintMethod = "printS16X4ImmOperand";
|
|
|
|
}
|
2005-12-04 18:42:54 +00:00
|
|
|
def target : Operand<OtherVT> {
|
2004-09-02 08:13:00 +00:00
|
|
|
let PrintMethod = "printBranchOperand";
|
|
|
|
}
|
2006-06-16 21:01:35 +00:00
|
|
|
def calltarget : Operand<iPTR> {
|
2005-11-17 19:16:08 +00:00
|
|
|
let PrintMethod = "printCallOperand";
|
|
|
|
}
|
2006-06-16 21:01:35 +00:00
|
|
|
def aaddr : Operand<iPTR> {
|
2005-11-16 00:48:01 +00:00
|
|
|
let PrintMethod = "printAbsAddrOperand";
|
|
|
|
}
|
2006-06-16 21:01:35 +00:00
|
|
|
def piclabel: Operand<iPTR> {
|
2004-09-02 08:13:00 +00:00
|
|
|
let PrintMethod = "printPICLabel";
|
|
|
|
}
|
2004-09-04 05:00:00 +00:00
|
|
|
def symbolHi: Operand<i32> {
|
|
|
|
let PrintMethod = "printSymbolHi";
|
|
|
|
}
|
|
|
|
def symbolLo: Operand<i32> {
|
|
|
|
let PrintMethod = "printSymbolLo";
|
|
|
|
}
|
2005-07-20 22:42:00 +00:00
|
|
|
def crbitm: Operand<i8> {
|
|
|
|
let PrintMethod = "printcrbitm";
|
|
|
|
}
|
2005-12-19 23:25:09 +00:00
|
|
|
// Address operands
|
2006-06-16 21:01:35 +00:00
|
|
|
def memri : Operand<iPTR> {
|
2005-12-19 23:25:09 +00:00
|
|
|
let PrintMethod = "printMemRegImm";
|
2006-11-15 02:43:19 +00:00
|
|
|
let MIOperandInfo = (ops i32imm:$imm, ptr_rc:$reg);
|
2005-12-19 23:25:09 +00:00
|
|
|
}
|
2006-06-16 21:01:35 +00:00
|
|
|
def memrr : Operand<iPTR> {
|
2005-12-19 23:25:09 +00:00
|
|
|
let PrintMethod = "printMemRegReg";
|
2006-06-16 21:29:03 +00:00
|
|
|
let MIOperandInfo = (ops ptr_rc, ptr_rc);
|
2005-12-19 23:25:09 +00:00
|
|
|
}
|
2006-06-16 21:01:35 +00:00
|
|
|
def memrix : Operand<iPTR> { // memri where the imm is shifted 2 bits.
|
When possible, custom lower 32-bit SINT_TO_FP to this:
_foo2:
extsw r2, r3
std r2, -8(r1)
lfd f0, -8(r1)
fcfid f0, f0
frsp f1, f0
blr
instead of this:
_foo2:
lis r2, ha16(LCPI2_0)
lis r4, 17200
xoris r3, r3, 32768
stw r3, -4(r1)
stw r4, -8(r1)
lfs f0, lo16(LCPI2_0)(r2)
lfd f1, -8(r1)
fsub f0, f1, f0
frsp f1, f0
blr
This speeds up Misc/pi from 2.44s->2.09s with LLC and from 3.01->2.18s
with llcbeta (16.7% and 38.1% respectively).
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26943 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-22 05:30:33 +00:00
|
|
|
let PrintMethod = "printMemRegImmShifted";
|
2006-11-15 19:55:13 +00:00
|
|
|
let MIOperandInfo = (ops i32imm:$imm, ptr_rc:$reg);
|
When possible, custom lower 32-bit SINT_TO_FP to this:
_foo2:
extsw r2, r3
std r2, -8(r1)
lfd f0, -8(r1)
fcfid f0, f0
frsp f1, f0
blr
instead of this:
_foo2:
lis r2, ha16(LCPI2_0)
lis r4, 17200
xoris r3, r3, 32768
stw r3, -4(r1)
stw r4, -8(r1)
lfs f0, lo16(LCPI2_0)(r2)
lfd f1, -8(r1)
fsub f0, f1, f0
frsp f1, f0
blr
This speeds up Misc/pi from 2.44s->2.09s with LLC and from 3.01->2.18s
with llcbeta (16.7% and 38.1% respectively).
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26943 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-22 05:30:33 +00:00
|
|
|
}
|
2005-12-19 23:25:09 +00:00
|
|
|
|
2006-11-04 05:42:48 +00:00
|
|
|
// PowerPC Predicate operand. 20 = (0<<5)|20 = always, CR0 is a dummy reg
|
2006-11-04 05:27:39 +00:00
|
|
|
// that doesn't matter.
|
2007-07-06 23:22:46 +00:00
|
|
|
def pred : PredicateOperand<OtherVT, (ops imm, CRRC),
|
2008-02-13 02:58:33 +00:00
|
|
|
(ops (i32 20), (i32 zero_reg))> {
|
2006-11-04 05:27:39 +00:00
|
|
|
let PrintMethod = "printPredicateOperand";
|
|
|
|
}
|
2006-11-03 23:53:25 +00:00
|
|
|
|
2006-01-12 02:05:36 +00:00
|
|
|
// Define PowerPC specific addressing mode.
|
2006-10-11 21:03:53 +00:00
|
|
|
def iaddr : ComplexPattern<iPTR, 2, "SelectAddrImm", [], []>;
|
|
|
|
def xaddr : ComplexPattern<iPTR, 2, "SelectAddrIdx", [], []>;
|
|
|
|
def xoaddr : ComplexPattern<iPTR, 2, "SelectAddrIdxOnly",[], []>;
|
|
|
|
def ixaddr : ComplexPattern<iPTR, 2, "SelectAddrImmShift", [], []>; // "std"
|
2004-08-15 05:20:16 +00:00
|
|
|
|
2006-11-16 00:41:37 +00:00
|
|
|
/// This is just the offset part of iaddr, used for preinc.
|
|
|
|
def iaddroff : ComplexPattern<iPTR, 1, "SelectAddrImmOffs", [], []>;
|
2006-11-15 02:43:19 +00:00
|
|
|
|
2005-12-14 22:07:12 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Instruction Predicate Definitions.
|
2005-12-20 20:08:53 +00:00
|
|
|
def FPContractions : Predicate<"!NoExcessFPPrecision">;
|
2007-10-23 06:42:42 +00:00
|
|
|
def In32BitMode : Predicate<"!PPCSubTarget.isPPC64()">;
|
|
|
|
def In64BitMode : Predicate<"PPCSubTarget.isPPC64()">;
|
2005-09-08 19:50:41 +00:00
|
|
|
|
2006-11-14 18:44:47 +00:00
|
|
|
|
2005-09-08 19:50:41 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Instruction Definitions.
|
|
|
|
|
2004-06-21 16:55:25 +00:00
|
|
|
// Pseudo-instructions:
|
2005-09-08 19:50:41 +00:00
|
|
|
|
2006-03-12 09:13:49 +00:00
|
|
|
let hasCtrlDep = 1 in {
|
2007-09-11 19:55:27 +00:00
|
|
|
let Defs = [R1], Uses = [R1] in {
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ADJCALLSTACKDOWN : Pseudo<(outs), (ins u16imm:$amt),
|
2006-09-27 02:55:21 +00:00
|
|
|
"${:comment} ADJCALLSTACKDOWN",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(callseq_start imm:$amt)]>;
|
2007-11-13 00:44:25 +00:00
|
|
|
def ADJCALLSTACKUP : Pseudo<(outs), (ins u16imm:$amt1, u16imm:$amt2),
|
2006-09-27 02:55:21 +00:00
|
|
|
"${:comment} ADJCALLSTACKUP",
|
2007-11-13 00:44:25 +00:00
|
|
|
[(callseq_end imm:$amt1, imm:$amt2)]>;
|
2007-09-11 19:55:27 +00:00
|
|
|
}
|
For functions that use vector registers, save VRSAVE, mark used
registers, and update it on entry to each function, then restore it on exit.
This compiles:
void func(vfloat *a, vfloat *b, vfloat *c) {
*a = *b * *c + *c;
}
to this:
_func:
mfspr r2, 256
oris r6, r2, 49152
mtspr 256, r6
lvx v0, 0, r5
lvx v1, 0, r4
vmaddfp v0, v1, v0, v0
stvx v0, 0, r3
mtspr 256, r2
blr
GCC produces this (which has additional stack accesses):
_func:
mfspr r0,256
stw r0,-4(r1)
oris r0,r0,0xc000
mtspr 256,r0
lvx v0,0,r5
lvx v1,0,r4
lwz r12,-4(r1)
vmaddfp v0,v0,v1,v0
stvx v0,0,r3
mtspr 256,r12
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26733 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-13 21:52:10 +00:00
|
|
|
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def UPDATE_VRSAVE : Pseudo<(outs GPRC:$rD), (ins GPRC:$rS),
|
For functions that use vector registers, save VRSAVE, mark used
registers, and update it on entry to each function, then restore it on exit.
This compiles:
void func(vfloat *a, vfloat *b, vfloat *c) {
*a = *b * *c + *c;
}
to this:
_func:
mfspr r2, 256
oris r6, r2, 49152
mtspr 256, r6
lvx v0, 0, r5
lvx v1, 0, r4
vmaddfp v0, v1, v0, v0
stvx v0, 0, r3
mtspr 256, r2
blr
GCC produces this (which has additional stack accesses):
_func:
mfspr r0,256
stw r0,-4(r1)
oris r0,r0,0xc000
mtspr 256,r0
lvx v0,0,r5
lvx v1,0,r4
lwz r12,-4(r1)
vmaddfp v0,v0,v1,v0
stvx v0,0,r3
mtspr 256,r12
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26733 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-13 21:52:10 +00:00
|
|
|
"UPDATE_VRSAVE $rD, $rS", []>;
|
2004-10-07 22:30:03 +00:00
|
|
|
}
|
2006-11-16 22:43:37 +00:00
|
|
|
|
2007-09-11 19:55:27 +00:00
|
|
|
let Defs = [R1], Uses = [R1] in
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def DYNALLOC : Pseudo<(outs GPRC:$result), (ins GPRC:$negsize, memri:$fpsi),
|
2006-11-16 22:43:37 +00:00
|
|
|
"${:comment} DYNALLOC $result, $negsize, $fpsi",
|
|
|
|
[(set GPRC:$result,
|
2007-09-11 19:55:27 +00:00
|
|
|
(PPCdynalloc GPRC:$negsize, iaddr:$fpsi))]>;
|
2006-11-16 22:43:37 +00:00
|
|
|
|
2005-08-26 21:23:58 +00:00
|
|
|
// SELECT_CC_* - Used to implement the SELECT_CC DAG operation. Expanded by the
|
|
|
|
// scheduler into a branch sequence.
|
2006-03-12 09:13:49 +00:00
|
|
|
let usesCustomDAGSchedInserter = 1, // Expanded by the scheduler.
|
|
|
|
PPC970_Single = 1 in {
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SELECT_CC_I4 : Pseudo<(outs GPRC:$dst), (ins CRRC:$cond, GPRC:$T, GPRC:$F,
|
2006-09-27 02:55:21 +00:00
|
|
|
i32imm:$BROPC), "${:comment} SELECT_CC PSEUDO!",
|
|
|
|
[]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SELECT_CC_I8 : Pseudo<(outs G8RC:$dst), (ins CRRC:$cond, G8RC:$T, G8RC:$F,
|
2006-09-27 02:55:21 +00:00
|
|
|
i32imm:$BROPC), "${:comment} SELECT_CC PSEUDO!",
|
|
|
|
[]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SELECT_CC_F4 : Pseudo<(outs F4RC:$dst), (ins CRRC:$cond, F4RC:$T, F4RC:$F,
|
2006-09-27 02:55:21 +00:00
|
|
|
i32imm:$BROPC), "${:comment} SELECT_CC PSEUDO!",
|
|
|
|
[]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SELECT_CC_F8 : Pseudo<(outs F8RC:$dst), (ins CRRC:$cond, F8RC:$T, F8RC:$F,
|
2006-09-27 02:55:21 +00:00
|
|
|
i32imm:$BROPC), "${:comment} SELECT_CC PSEUDO!",
|
|
|
|
[]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SELECT_CC_VRRC: Pseudo<(outs VRRC:$dst), (ins CRRC:$cond, VRRC:$T, VRRC:$F,
|
2006-09-27 02:55:21 +00:00
|
|
|
i32imm:$BROPC), "${:comment} SELECT_CC PSEUDO!",
|
|
|
|
[]>;
|
2005-08-26 21:23:58 +00:00
|
|
|
}
|
|
|
|
|
2008-03-03 22:19:16 +00:00
|
|
|
// SPILL_CR - Indicate that we're dumping the CR register, so we'll need to
|
|
|
|
// scavenge a register for it.
|
|
|
|
def SPILL_CR : Pseudo<(outs), (ins GPRC:$cond, memri:$F),
|
|
|
|
"${:comment} SPILL_CR $cond $F", []>;
|
|
|
|
|
2007-07-21 00:34:19 +00:00
|
|
|
let isTerminator = 1, isBarrier = 1, PPC970_Unit = 7 in {
|
2006-01-09 18:28:21 +00:00
|
|
|
let isReturn = 1 in
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def BLR : XLForm_2_br<19, 16, 0, (outs), (ins pred:$p),
|
2006-11-04 05:42:48 +00:00
|
|
|
"b${p:cc}lr ${p:reg}", BrB,
|
|
|
|
[(retflag)]>;
|
2007-11-12 07:39:39 +00:00
|
|
|
let isBranch = 1, isIndirectBranch = 1 in
|
|
|
|
def BCTR : XLForm_2_ext<19, 528, 20, 0, 0, (outs), (ins), "bctr", BrB, []>;
|
2005-09-08 19:50:41 +00:00
|
|
|
}
|
|
|
|
|
2005-02-15 20:26:49 +00:00
|
|
|
let Defs = [LR] in
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MovePCtoLR : Pseudo<(outs), (ins piclabel:$label), "bl $label", []>,
|
2006-03-12 09:13:49 +00:00
|
|
|
PPC970_Unit_BRU;
|
2004-06-21 16:55:25 +00:00
|
|
|
|
2007-07-21 00:34:19 +00:00
|
|
|
let isBranch = 1, isTerminator = 1, hasCtrlDep = 1, PPC970_Unit = 7 in {
|
2006-10-13 19:10:34 +00:00
|
|
|
let isBarrier = 1 in {
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def B : IForm<18, 0, 0, (outs), (ins target:$dst),
|
2005-12-04 18:42:54 +00:00
|
|
|
"b $dst", BrB,
|
|
|
|
[(br bb:$dst)]>;
|
2006-10-13 19:10:34 +00:00
|
|
|
}
|
2004-11-22 23:07:01 +00:00
|
|
|
|
2006-11-17 22:37:34 +00:00
|
|
|
// BCC represents an arbitrary conditional branch on a predicate.
|
|
|
|
// FIXME: should be able to write a pattern for PPCcondbranch, but can't use
|
|
|
|
// a two-value operand where a dag node expects two operands. :(
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def BCC : BForm<16, 0, 0, (outs), (ins pred:$cond, target:$dst),
|
2006-11-18 00:32:03 +00:00
|
|
|
"b${cond:cc} ${cond:reg}, $dst"
|
|
|
|
/*[(PPCcondbranch CRRC:$crS, imm:$opc, bb:$dst)]*/>;
|
2004-06-28 18:23:35 +00:00
|
|
|
}
|
|
|
|
|
2007-02-25 05:34:32 +00:00
|
|
|
// Macho ABI Calls.
|
2007-07-21 00:34:19 +00:00
|
|
|
let isCall = 1, PPC970_Unit = 7,
|
2004-06-29 23:37:36 +00:00
|
|
|
// All calls clobber the non-callee saved registers...
|
2004-06-30 22:00:45 +00: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,
|
2006-03-16 22:35:59 +00:00
|
|
|
V0,V1,V2,V3,V4,V5,V6,V7,V8,V9,V10,V11,V12,V13,V14,V15,V16,V17,V18,V19,
|
2005-08-22 22:32:13 +00:00
|
|
|
LR,CTR,
|
2008-03-10 14:12:10 +00:00
|
|
|
CR0,CR1,CR5,CR6,CR7,
|
|
|
|
CR0LT,CR0GT,CR0EQ,CR0UN,CR1LT,CR1GT,CR1EQ,CR1UN,CR5LT,CR5GT,CR5EQ,
|
|
|
|
CR5UN,CR6LT,CR6GT,CR6EQ,CR6UN,CR7LT,CR7GT,CR7EQ,CR7UN] in {
|
2004-06-30 22:00:45 +00:00
|
|
|
// Convenient aliases for call instructions
|
2007-02-25 05:34:32 +00:00
|
|
|
def BL_Macho : IForm<18, 0, 1,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs), (ins calltarget:$func, variable_ops),
|
2007-02-25 05:34:32 +00:00
|
|
|
"bl $func", BrB, []>; // See Pat patterns below.
|
|
|
|
def BLA_Macho : IForm<18, 1, 1,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs), (ins aaddr:$func, variable_ops),
|
2007-02-25 05:34:32 +00:00
|
|
|
"bla $func", BrB, [(PPCcall_Macho (i32 imm:$func))]>;
|
|
|
|
def BCTRL_Macho : XLForm_2_ext<19, 528, 20, 0, 1,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs), (ins variable_ops),
|
2007-02-25 05:34:32 +00:00
|
|
|
"bctrl", BrB,
|
2007-10-23 06:42:42 +00:00
|
|
|
[(PPCbctrl_Macho)]>, Requires<[In32BitMode]>;
|
2007-02-25 05:34:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ELF ABI Calls.
|
2007-07-21 00:34:19 +00:00
|
|
|
let isCall = 1, PPC970_Unit = 7,
|
2007-02-25 05:34:32 +00:00
|
|
|
// All calls clobber the non-callee saved registers...
|
|
|
|
Defs = [R0,R2,R3,R4,R5,R6,R7,R8,R9,R10,R11,R12,
|
2007-04-03 10:27:07 +00:00
|
|
|
F0,F1,F2,F3,F4,F5,F6,F7,F8,
|
2007-02-25 05:34:32 +00:00
|
|
|
V0,V1,V2,V3,V4,V5,V6,V7,V8,V9,V10,V11,V12,V13,V14,V15,V16,V17,V18,V19,
|
|
|
|
LR,CTR,
|
2008-03-10 14:12:10 +00:00
|
|
|
CR0,CR1,CR5,CR6,CR7,
|
|
|
|
CR0LT,CR0GT,CR0EQ,CR0UN,CR1LT,CR1GT,CR1EQ,CR1UN,CR5LT,CR5GT,CR5EQ,
|
|
|
|
CR5UN,CR6LT,CR6GT,CR6EQ,CR6UN,CR7LT,CR7GT,CR7EQ,CR7UN] in {
|
2007-02-25 05:34:32 +00:00
|
|
|
// Convenient aliases for call instructions
|
|
|
|
def BL_ELF : IForm<18, 0, 1,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs), (ins calltarget:$func, variable_ops),
|
2007-02-25 05:34:32 +00:00
|
|
|
"bl $func", BrB, []>; // See Pat patterns below.
|
|
|
|
def BLA_ELF : IForm<18, 1, 1,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs), (ins aaddr:$func, variable_ops),
|
2007-02-25 05:34:32 +00:00
|
|
|
"bla $func", BrB,
|
2007-02-27 13:01:19 +00:00
|
|
|
[(PPCcall_ELF (i32 imm:$func))]>;
|
2007-02-25 05:34:32 +00:00
|
|
|
def BCTRL_ELF : XLForm_2_ext<19, 528, 20, 0, 1,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs), (ins variable_ops),
|
2007-02-25 05:34:32 +00:00
|
|
|
"bctrl", BrB,
|
2007-10-23 06:42:42 +00:00
|
|
|
[(PPCbctrl_ELF)]>, Requires<[In32BitMode]>;
|
2004-06-29 23:37:36 +00:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:16:33 +00:00
|
|
|
|
|
|
|
let isCall = 1, isTerminator = 1, isReturn = 1, isBarrier = 1 in
|
|
|
|
def TCRETURNdi :Pseudo< (outs),
|
|
|
|
(ins calltarget:$dst, i32imm:$offset, variable_ops),
|
|
|
|
"#TC_RETURNd $dst $offset",
|
|
|
|
[]>;
|
|
|
|
|
|
|
|
|
|
|
|
let isCall = 1, isTerminator = 1, isReturn = 1, isBarrier = 1 in
|
|
|
|
def TCRETURNai :Pseudo<(outs), (ins aaddr:$func, i32imm:$offset, variable_ops),
|
|
|
|
"#TC_RETURNa $func $offset",
|
|
|
|
[(PPCtc_return (i32 imm:$func), imm:$offset)]>;
|
|
|
|
|
|
|
|
let isCall = 1, isTerminator = 1, isReturn = 1, isBarrier = 1 in
|
|
|
|
def TCRETURNri : Pseudo<(outs), (ins CTRRC:$dst, i32imm:$offset, variable_ops),
|
|
|
|
"#TC_RETURNr $dst $offset",
|
|
|
|
[]>;
|
|
|
|
|
|
|
|
|
|
|
|
let isTerminator = 1, isBarrier = 1, PPC970_Unit = 7, isBranch = 1,
|
|
|
|
isIndirectBranch = 1, isCall = 1, isReturn = 1 in
|
|
|
|
def TAILBCTR : XLForm_2_ext<19, 528, 20, 0, 0, (outs), (ins), "bctr", BrB, []>,
|
|
|
|
Requires<[In32BitMode]>;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
let isBranch = 1, isTerminator = 1, hasCtrlDep = 1, PPC970_Unit = 7,
|
|
|
|
isBarrier = 1, isCall = 1, isReturn = 1 in
|
|
|
|
def TAILB : IForm<18, 0, 0, (outs), (ins calltarget:$dst),
|
|
|
|
"b $dst", BrB,
|
|
|
|
[]>;
|
|
|
|
|
|
|
|
|
|
|
|
let isBranch = 1, isTerminator = 1, hasCtrlDep = 1, PPC970_Unit = 7,
|
|
|
|
isBarrier = 1, isCall = 1, isReturn = 1 in
|
|
|
|
def TAILBA : IForm<18, 0, 0, (outs), (ins aaddr:$dst),
|
|
|
|
"ba $dst", BrB,
|
|
|
|
[]>;
|
|
|
|
|
|
|
|
|
2006-06-06 21:29:23 +00:00
|
|
|
// DCB* instructions.
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def DCBA : DCB_Form<758, 0, (outs), (ins memrr:$dst),
|
2006-10-24 01:08:42 +00:00
|
|
|
"dcba $dst", LdStDCBF, [(int_ppc_dcba xoaddr:$dst)]>,
|
|
|
|
PPC970_DGroup_Single;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def DCBF : DCB_Form<86, 0, (outs), (ins memrr:$dst),
|
2006-10-24 01:08:42 +00:00
|
|
|
"dcbf $dst", LdStDCBF, [(int_ppc_dcbf xoaddr:$dst)]>,
|
|
|
|
PPC970_DGroup_Single;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def DCBI : DCB_Form<470, 0, (outs), (ins memrr:$dst),
|
2006-10-24 01:08:42 +00:00
|
|
|
"dcbi $dst", LdStDCBF, [(int_ppc_dcbi xoaddr:$dst)]>,
|
|
|
|
PPC970_DGroup_Single;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def DCBST : DCB_Form<54, 0, (outs), (ins memrr:$dst),
|
2006-10-24 01:08:42 +00:00
|
|
|
"dcbst $dst", LdStDCBF, [(int_ppc_dcbst xoaddr:$dst)]>,
|
|
|
|
PPC970_DGroup_Single;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def DCBT : DCB_Form<278, 0, (outs), (ins memrr:$dst),
|
2006-10-24 01:08:42 +00:00
|
|
|
"dcbt $dst", LdStDCBF, [(int_ppc_dcbt xoaddr:$dst)]>,
|
|
|
|
PPC970_DGroup_Single;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def DCBTST : DCB_Form<246, 0, (outs), (ins memrr:$dst),
|
2006-10-24 01:08:42 +00:00
|
|
|
"dcbtst $dst", LdStDCBF, [(int_ppc_dcbtst xoaddr:$dst)]>,
|
|
|
|
PPC970_DGroup_Single;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def DCBZ : DCB_Form<1014, 0, (outs), (ins memrr:$dst),
|
2006-10-24 01:08:42 +00:00
|
|
|
"dcbz $dst", LdStDCBF, [(int_ppc_dcbz xoaddr:$dst)]>,
|
|
|
|
PPC970_DGroup_Single;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def DCBZL : DCB_Form<1014, 1, (outs), (ins memrr:$dst),
|
2006-10-24 01:08:42 +00:00
|
|
|
"dcbzl $dst", LdStDCBF, [(int_ppc_dcbzl xoaddr:$dst)]>,
|
|
|
|
PPC970_DGroup_Single;
|
2006-11-14 19:19:53 +00:00
|
|
|
|
2008-07-12 02:23:19 +00:00
|
|
|
// Atomic operations
|
|
|
|
let usesCustomDAGSchedInserter = 1 in {
|
|
|
|
let Uses = [CR0] in {
|
|
|
|
def ATOMIC_LOAD_ADD_I32 : Pseudo<
|
|
|
|
(outs GPRC:$dst), (ins memrr:$ptr, GPRC:$incr),
|
|
|
|
"${:comment} ATOMIC_LOAD_ADD_I32 PSEUDO!",
|
|
|
|
[(set GPRC:$dst, (PPCatomic_load_add xoaddr:$ptr, GPRC:$incr))]>;
|
|
|
|
def ATOMIC_CMP_SWAP_I32 : Pseudo<
|
|
|
|
(outs GPRC:$dst), (ins memrr:$ptr, GPRC:$old, GPRC:$new),
|
|
|
|
"${:comment} ATOMIC_CMP_SWAP_I32 PSEUDO!",
|
|
|
|
[(set GPRC:$dst, (PPCatomic_cmp_swap xoaddr:$ptr, GPRC:$old, GPRC:$new))]>;
|
|
|
|
def ATOMIC_SWAP_I32 : Pseudo<
|
|
|
|
(outs GPRC:$dst), (ins memrr:$ptr, GPRC:$new),
|
|
|
|
"${:comment} ATOMIC_SWAP_I32 PSEUDO!",
|
|
|
|
[(set GPRC:$dst, (PPCatomic_swap xoaddr:$ptr, GPRC:$new))]>;
|
|
|
|
}
|
2008-04-19 01:30:48 +00:00
|
|
|
}
|
|
|
|
|
2008-07-12 02:23:19 +00:00
|
|
|
// Instructions to support atomic operations
|
|
|
|
def LWARX : XForm_1<31, 20, (outs GPRC:$rD), (ins memrr:$src),
|
|
|
|
"lwarx $rD, $src", LdStLWARX,
|
|
|
|
[(set GPRC:$rD, (PPClarx xoaddr:$src))]>;
|
|
|
|
|
|
|
|
let Defs = [CR0] in
|
|
|
|
def STWCX : XForm_1<31, 150, (outs), (ins GPRC:$rS, memrr:$dst),
|
|
|
|
"stwcx. $rS, $dst", LdStSTWCX,
|
|
|
|
[(PPCstcx GPRC:$rS, xoaddr:$dst)]>,
|
|
|
|
isDOT;
|
|
|
|
|
2006-11-14 19:19:53 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PPC32 Load Instructions.
|
2004-08-30 02:28:06 +00:00
|
|
|
//
|
2006-11-14 19:19:53 +00:00
|
|
|
|
2006-11-15 02:43:19 +00:00
|
|
|
// Unindexed (r+i) Loads.
|
2008-01-06 23:38:27 +00:00
|
|
|
let isSimpleLoad = 1, PPC970_Unit = 2 in {
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LBZ : DForm_1<34, (outs GPRC:$rD), (ins memri:$src),
|
2005-12-19 23:25:09 +00:00
|
|
|
"lbz $rD, $src", LdStGeneral,
|
2006-10-09 20:57:25 +00:00
|
|
|
[(set GPRC:$rD, (zextloadi8 iaddr:$src))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LHA : DForm_1<42, (outs GPRC:$rD), (ins memri:$src),
|
2005-12-19 23:25:09 +00:00
|
|
|
"lha $rD, $src", LdStLHA,
|
2006-10-09 20:57:25 +00:00
|
|
|
[(set GPRC:$rD, (sextloadi16 iaddr:$src))]>,
|
2006-03-13 05:15:10 +00:00
|
|
|
PPC970_DGroup_Cracked;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LHZ : DForm_1<40, (outs GPRC:$rD), (ins memri:$src),
|
2005-12-19 23:25:09 +00:00
|
|
|
"lhz $rD, $src", LdStGeneral,
|
2006-10-09 20:57:25 +00:00
|
|
|
[(set GPRC:$rD, (zextloadi16 iaddr:$src))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LWZ : DForm_1<32, (outs GPRC:$rD), (ins memri:$src),
|
2005-12-19 23:25:09 +00:00
|
|
|
"lwz $rD, $src", LdStGeneral,
|
|
|
|
[(set GPRC:$rD, (load iaddr:$src))]>;
|
2006-11-08 02:13:12 +00:00
|
|
|
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LFS : DForm_1<48, (outs F4RC:$rD), (ins memri:$src),
|
2006-11-10 02:08:47 +00:00
|
|
|
"lfs $rD, $src", LdStLFDU,
|
|
|
|
[(set F4RC:$rD, (load iaddr:$src))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LFD : DForm_1<50, (outs F8RC:$rD), (ins memri:$src),
|
2006-11-10 02:08:47 +00:00
|
|
|
"lfd $rD, $src", LdStLFD,
|
|
|
|
[(set F8RC:$rD, (load iaddr:$src))]>;
|
|
|
|
|
|
|
|
|
2006-11-15 02:43:19 +00:00
|
|
|
// Unindexed (r+i) Loads with Update (preinc).
|
2007-08-01 23:07:38 +00:00
|
|
|
def LBZU : DForm_1<35, (outs GPRC:$rD, ptr_rc:$ea_result), (ins memri:$addr),
|
2006-11-15 02:43:19 +00:00
|
|
|
"lbzu $rD, $addr", LdStGeneral,
|
2006-11-15 23:24:18 +00:00
|
|
|
[]>, RegConstraint<"$addr.reg = $ea_result">,
|
|
|
|
NoEncode<"$ea_result">;
|
2006-11-15 02:43:19 +00:00
|
|
|
|
2007-08-01 23:07:38 +00:00
|
|
|
def LHAU : DForm_1<43, (outs GPRC:$rD, ptr_rc:$ea_result), (ins memri:$addr),
|
2006-11-15 02:43:19 +00:00
|
|
|
"lhau $rD, $addr", LdStGeneral,
|
2006-11-15 23:24:18 +00:00
|
|
|
[]>, RegConstraint<"$addr.reg = $ea_result">,
|
|
|
|
NoEncode<"$ea_result">;
|
2006-11-15 02:43:19 +00:00
|
|
|
|
2007-08-01 23:07:38 +00:00
|
|
|
def LHZU : DForm_1<41, (outs GPRC:$rD, ptr_rc:$ea_result), (ins memri:$addr),
|
2006-11-15 02:43:19 +00:00
|
|
|
"lhzu $rD, $addr", LdStGeneral,
|
2006-11-15 23:24:18 +00:00
|
|
|
[]>, RegConstraint<"$addr.reg = $ea_result">,
|
|
|
|
NoEncode<"$ea_result">;
|
2006-11-15 02:43:19 +00:00
|
|
|
|
2007-08-01 23:07:38 +00:00
|
|
|
def LWZU : DForm_1<33, (outs GPRC:$rD, ptr_rc:$ea_result), (ins memri:$addr),
|
2006-11-15 02:43:19 +00:00
|
|
|
"lwzu $rD, $addr", LdStGeneral,
|
2006-11-15 23:24:18 +00:00
|
|
|
[]>, RegConstraint<"$addr.reg = $ea_result">,
|
|
|
|
NoEncode<"$ea_result">;
|
2006-11-15 02:43:19 +00:00
|
|
|
|
2007-08-01 23:07:38 +00:00
|
|
|
def LFSU : DForm_1<49, (outs F4RC:$rD, ptr_rc:$ea_result), (ins memri:$addr),
|
2006-11-15 02:43:19 +00:00
|
|
|
"lfs $rD, $addr", LdStLFDU,
|
2006-11-15 23:24:18 +00:00
|
|
|
[]>, RegConstraint<"$addr.reg = $ea_result">,
|
|
|
|
NoEncode<"$ea_result">;
|
|
|
|
|
2007-08-01 23:07:38 +00:00
|
|
|
def LFDU : DForm_1<51, (outs F8RC:$rD, ptr_rc:$ea_result), (ins memri:$addr),
|
2006-11-15 02:43:19 +00:00
|
|
|
"lfd $rD, $addr", LdStLFD,
|
2006-11-15 23:24:18 +00:00
|
|
|
[]>, RegConstraint<"$addr.reg = $ea_result">,
|
|
|
|
NoEncode<"$ea_result">;
|
2004-10-07 22:30:03 +00:00
|
|
|
}
|
2006-11-08 02:13:12 +00:00
|
|
|
|
2006-11-15 02:43:19 +00:00
|
|
|
// Indexed (r+r) Loads.
|
2006-11-14 19:19:53 +00:00
|
|
|
//
|
2008-01-06 23:38:27 +00:00
|
|
|
let isSimpleLoad = 1, PPC970_Unit = 2 in {
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LBZX : XForm_1<31, 87, (outs GPRC:$rD), (ins memrr:$src),
|
2006-11-14 19:19:53 +00:00
|
|
|
"lbzx $rD, $src", LdStGeneral,
|
|
|
|
[(set GPRC:$rD, (zextloadi8 xaddr:$src))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LHAX : XForm_1<31, 343, (outs GPRC:$rD), (ins memrr:$src),
|
2006-11-14 19:19:53 +00:00
|
|
|
"lhax $rD, $src", LdStLHA,
|
|
|
|
[(set GPRC:$rD, (sextloadi16 xaddr:$src))]>,
|
|
|
|
PPC970_DGroup_Cracked;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LHZX : XForm_1<31, 279, (outs GPRC:$rD), (ins memrr:$src),
|
2006-11-14 19:19:53 +00:00
|
|
|
"lhzx $rD, $src", LdStGeneral,
|
|
|
|
[(set GPRC:$rD, (zextloadi16 xaddr:$src))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LWZX : XForm_1<31, 23, (outs GPRC:$rD), (ins memrr:$src),
|
2006-11-14 19:19:53 +00:00
|
|
|
"lwzx $rD, $src", LdStGeneral,
|
|
|
|
[(set GPRC:$rD, (load xaddr:$src))]>;
|
|
|
|
|
|
|
|
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LHBRX : XForm_1<31, 790, (outs GPRC:$rD), (ins memrr:$src),
|
2006-11-14 19:19:53 +00:00
|
|
|
"lhbrx $rD, $src", LdStGeneral,
|
|
|
|
[(set GPRC:$rD, (PPClbrx xoaddr:$src, srcvalue:$sv, i16))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LWBRX : XForm_1<31, 534, (outs GPRC:$rD), (ins memrr:$src),
|
2006-11-14 19:19:53 +00:00
|
|
|
"lwbrx $rD, $src", LdStGeneral,
|
|
|
|
[(set GPRC:$rD, (PPClbrx xoaddr:$src, srcvalue:$sv, i32))]>;
|
|
|
|
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LFSX : XForm_25<31, 535, (outs F4RC:$frD), (ins memrr:$src),
|
2006-11-14 19:19:53 +00:00
|
|
|
"lfsx $frD, $src", LdStLFDU,
|
|
|
|
[(set F4RC:$frD, (load xaddr:$src))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LFDX : XForm_25<31, 599, (outs F8RC:$frD), (ins memrr:$src),
|
2006-11-14 19:19:53 +00:00
|
|
|
"lfdx $frD, $src", LdStLFDU,
|
|
|
|
[(set F8RC:$frD, (load xaddr:$src))]>;
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PPC32 Store Instructions.
|
|
|
|
//
|
|
|
|
|
2006-11-15 02:43:19 +00:00
|
|
|
// Unindexed (r+i) Stores.
|
2008-01-06 05:53:26 +00:00
|
|
|
let PPC970_Unit = 2 in {
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def STB : DForm_1<38, (outs), (ins GPRC:$rS, memri:$src),
|
2006-11-14 19:19:53 +00:00
|
|
|
"stb $rS, $src", LdStGeneral,
|
|
|
|
[(truncstorei8 GPRC:$rS, iaddr:$src)]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def STH : DForm_1<44, (outs), (ins GPRC:$rS, memri:$src),
|
2006-11-14 19:19:53 +00:00
|
|
|
"sth $rS, $src", LdStGeneral,
|
|
|
|
[(truncstorei16 GPRC:$rS, iaddr:$src)]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def STW : DForm_1<36, (outs), (ins GPRC:$rS, memri:$src),
|
2006-11-14 19:19:53 +00:00
|
|
|
"stw $rS, $src", LdStGeneral,
|
|
|
|
[(store GPRC:$rS, iaddr:$src)]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def STFS : DForm_1<52, (outs), (ins F4RC:$rS, memri:$dst),
|
2006-11-14 19:19:53 +00:00
|
|
|
"stfs $rS, $dst", LdStUX,
|
|
|
|
[(store F4RC:$rS, iaddr:$dst)]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def STFD : DForm_1<54, (outs), (ins F8RC:$rS, memri:$dst),
|
2006-11-14 19:19:53 +00:00
|
|
|
"stfd $rS, $dst", LdStUX,
|
|
|
|
[(store F8RC:$rS, iaddr:$dst)]>;
|
|
|
|
}
|
|
|
|
|
2006-11-15 02:43:19 +00:00
|
|
|
// Unindexed (r+i) Stores with Update (preinc).
|
2008-01-06 05:53:26 +00:00
|
|
|
let PPC970_Unit = 2 in {
|
2007-07-20 00:20:46 +00:00
|
|
|
def STBU : DForm_1<39, (outs ptr_rc:$ea_res), (ins GPRC:$rS,
|
2006-11-16 00:33:34 +00:00
|
|
|
symbolLo:$ptroff, ptr_rc:$ptrreg),
|
|
|
|
"stbu $rS, $ptroff($ptrreg)", LdStGeneral,
|
2006-11-16 00:41:37 +00:00
|
|
|
[(set ptr_rc:$ea_res,
|
|
|
|
(pre_truncsti8 GPRC:$rS, ptr_rc:$ptrreg,
|
|
|
|
iaddroff:$ptroff))]>,
|
2006-11-16 00:33:34 +00:00
|
|
|
RegConstraint<"$ptrreg = $ea_res">, NoEncode<"$ea_res">;
|
2007-07-20 00:20:46 +00:00
|
|
|
def STHU : DForm_1<45, (outs ptr_rc:$ea_res), (ins GPRC:$rS,
|
2006-11-16 00:33:34 +00:00
|
|
|
symbolLo:$ptroff, ptr_rc:$ptrreg),
|
|
|
|
"sthu $rS, $ptroff($ptrreg)", LdStGeneral,
|
2006-11-16 00:41:37 +00:00
|
|
|
[(set ptr_rc:$ea_res,
|
|
|
|
(pre_truncsti16 GPRC:$rS, ptr_rc:$ptrreg,
|
|
|
|
iaddroff:$ptroff))]>,
|
2006-11-16 00:33:34 +00:00
|
|
|
RegConstraint<"$ptrreg = $ea_res">, NoEncode<"$ea_res">;
|
2007-07-20 00:20:46 +00:00
|
|
|
def STWU : DForm_1<37, (outs ptr_rc:$ea_res), (ins GPRC:$rS,
|
2006-11-16 00:33:34 +00:00
|
|
|
symbolLo:$ptroff, ptr_rc:$ptrreg),
|
|
|
|
"stwu $rS, $ptroff($ptrreg)", LdStGeneral,
|
2006-11-16 00:41:37 +00:00
|
|
|
[(set ptr_rc:$ea_res, (pre_store GPRC:$rS, ptr_rc:$ptrreg,
|
|
|
|
iaddroff:$ptroff))]>,
|
2006-11-16 00:33:34 +00:00
|
|
|
RegConstraint<"$ptrreg = $ea_res">, NoEncode<"$ea_res">;
|
2007-07-20 00:20:46 +00:00
|
|
|
def STFSU : DForm_1<37, (outs ptr_rc:$ea_res), (ins F4RC:$rS,
|
2006-11-16 00:33:34 +00:00
|
|
|
symbolLo:$ptroff, ptr_rc:$ptrreg),
|
|
|
|
"stfsu $rS, $ptroff($ptrreg)", LdStGeneral,
|
2006-11-16 00:41:37 +00:00
|
|
|
[(set ptr_rc:$ea_res, (pre_store F4RC:$rS, ptr_rc:$ptrreg,
|
|
|
|
iaddroff:$ptroff))]>,
|
2006-11-16 00:33:34 +00:00
|
|
|
RegConstraint<"$ptrreg = $ea_res">, NoEncode<"$ea_res">;
|
2007-07-20 00:20:46 +00:00
|
|
|
def STFDU : DForm_1<37, (outs ptr_rc:$ea_res), (ins F8RC:$rS,
|
2006-11-16 00:33:34 +00:00
|
|
|
symbolLo:$ptroff, ptr_rc:$ptrreg),
|
|
|
|
"stfdu $rS, $ptroff($ptrreg)", LdStGeneral,
|
2006-11-16 00:41:37 +00:00
|
|
|
[(set ptr_rc:$ea_res, (pre_store F8RC:$rS, ptr_rc:$ptrreg,
|
|
|
|
iaddroff:$ptroff))]>,
|
2006-11-16 00:33:34 +00:00
|
|
|
RegConstraint<"$ptrreg = $ea_res">, NoEncode<"$ea_res">;
|
2006-11-15 02:43:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-11-14 19:19:53 +00:00
|
|
|
// Indexed (r+r) Stores.
|
|
|
|
//
|
2008-01-06 05:53:26 +00:00
|
|
|
let PPC970_Unit = 2 in {
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def STBX : XForm_8<31, 215, (outs), (ins GPRC:$rS, memrr:$dst),
|
2006-11-14 19:19:53 +00:00
|
|
|
"stbx $rS, $dst", LdStGeneral,
|
|
|
|
[(truncstorei8 GPRC:$rS, xaddr:$dst)]>,
|
|
|
|
PPC970_DGroup_Cracked;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def STHX : XForm_8<31, 407, (outs), (ins GPRC:$rS, memrr:$dst),
|
2006-11-14 19:19:53 +00:00
|
|
|
"sthx $rS, $dst", LdStGeneral,
|
|
|
|
[(truncstorei16 GPRC:$rS, xaddr:$dst)]>,
|
|
|
|
PPC970_DGroup_Cracked;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def STWX : XForm_8<31, 151, (outs), (ins GPRC:$rS, memrr:$dst),
|
2006-11-14 19:19:53 +00:00
|
|
|
"stwx $rS, $dst", LdStGeneral,
|
|
|
|
[(store GPRC:$rS, xaddr:$dst)]>,
|
|
|
|
PPC970_DGroup_Cracked;
|
2008-01-06 05:53:26 +00:00
|
|
|
|
2008-01-06 08:36:04 +00:00
|
|
|
let mayStore = 1 in {
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def STWUX : XForm_8<31, 183, (outs), (ins GPRC:$rS, GPRC:$rA, GPRC:$rB),
|
2006-11-14 19:19:53 +00:00
|
|
|
"stwux $rS, $rA, $rB", LdStGeneral,
|
|
|
|
[]>;
|
2008-01-06 06:44:58 +00:00
|
|
|
}
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def STHBRX: XForm_8<31, 918, (outs), (ins GPRC:$rS, memrr:$dst),
|
2006-11-14 19:19:53 +00:00
|
|
|
"sthbrx $rS, $dst", LdStGeneral,
|
|
|
|
[(PPCstbrx GPRC:$rS, xoaddr:$dst, srcvalue:$dummy, i16)]>,
|
|
|
|
PPC970_DGroup_Cracked;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def STWBRX: XForm_8<31, 662, (outs), (ins GPRC:$rS, memrr:$dst),
|
2006-11-14 19:19:53 +00:00
|
|
|
"stwbrx $rS, $dst", LdStGeneral,
|
|
|
|
[(PPCstbrx GPRC:$rS, xoaddr:$dst, srcvalue:$dummy, i32)]>,
|
|
|
|
PPC970_DGroup_Cracked;
|
|
|
|
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def STFIWX: XForm_28<31, 983, (outs), (ins F8RC:$frS, memrr:$dst),
|
2006-11-14 19:19:53 +00:00
|
|
|
"stfiwx $frS, $dst", LdStUX,
|
|
|
|
[(PPCstfiwx F8RC:$frS, xoaddr:$dst)]>;
|
2008-01-06 06:44:58 +00:00
|
|
|
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def STFSX : XForm_28<31, 663, (outs), (ins F4RC:$frS, memrr:$dst),
|
2006-11-14 19:19:53 +00:00
|
|
|
"stfsx $frS, $dst", LdStUX,
|
|
|
|
[(store F4RC:$frS, xaddr:$dst)]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def STFDX : XForm_28<31, 727, (outs), (ins F8RC:$frS, memrr:$dst),
|
2006-11-14 19:19:53 +00:00
|
|
|
"stfdx $frS, $dst", LdStUX,
|
|
|
|
[(store F8RC:$frS, xaddr:$dst)]>;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PPC32 Arithmetic Instructions.
|
|
|
|
//
|
2006-11-08 02:13:12 +00:00
|
|
|
|
2006-03-12 09:13:49 +00:00
|
|
|
let PPC970_Unit = 1 in { // FXU Operations.
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ADDI : DForm_2<14, (outs GPRC:$rD), (ins GPRC:$rA, s16imm:$imm),
|
2005-10-19 19:51:16 +00:00
|
|
|
"addi $rD, $rA, $imm", IntGeneral,
|
2005-09-08 17:33:10 +00:00
|
|
|
[(set GPRC:$rD, (add GPRC:$rA, immSExt16:$imm))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ADDIC : DForm_2<12, (outs GPRC:$rD), (ins GPRC:$rA, s16imm:$imm),
|
2005-10-19 19:51:16 +00:00
|
|
|
"addic $rD, $rA, $imm", IntGeneral,
|
2006-03-13 05:15:10 +00:00
|
|
|
[(set GPRC:$rD, (addc GPRC:$rA, immSExt16:$imm))]>,
|
|
|
|
PPC970_DGroup_Cracked;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ADDICo : DForm_2<13, (outs GPRC:$rD), (ins GPRC:$rA, s16imm:$imm),
|
2005-10-19 19:51:16 +00:00
|
|
|
"addic. $rD, $rA, $imm", IntGeneral,
|
2005-09-08 17:33:10 +00:00
|
|
|
[]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ADDIS : DForm_2<15, (outs GPRC:$rD), (ins GPRC:$rA, symbolHi:$imm),
|
2005-10-19 19:51:16 +00:00
|
|
|
"addis $rD, $rA, $imm", IntGeneral,
|
Add some 64-bit logical ops.
Split imm16Shifted into a sext/zext form for 64-bit support.
Add some patterns for immediate formation. For example, we now compile this:
static unsigned long long Y;
void test3() {
Y = 0xF0F00F00;
}
into:
_test3:
li r2, 3840
lis r3, ha16(_Y)
xoris r2, r2, 61680
std r2, lo16(_Y)(r3)
blr
GCC produces:
_test3:
li r0,0
lis r2,ha16(_Y)
ori r0,r0,61680
sldi r0,r0,16
ori r0,r0,3840
std r0,lo16(_Y)(r2)
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@28883 91177308-0d34-0410-b5e6-96231b3b80d8
2006-06-20 22:34:10 +00:00
|
|
|
[(set GPRC:$rD, (add GPRC:$rA, imm16ShiftedSExt:$imm))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def LA : DForm_2<14, (outs GPRC:$rD), (ins GPRC:$rA, symbolLo:$sym),
|
2005-10-19 19:51:16 +00:00
|
|
|
"la $rD, $sym($rA)", IntGeneral,
|
2005-11-17 17:52:01 +00:00
|
|
|
[(set GPRC:$rD, (add GPRC:$rA,
|
|
|
|
(PPClo tglobaladdr:$sym, 0)))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MULLI : DForm_2< 7, (outs GPRC:$rD), (ins GPRC:$rA, s16imm:$imm),
|
2005-10-19 19:51:16 +00:00
|
|
|
"mulli $rD, $rA, $imm", IntMulLI,
|
2005-09-08 17:33:10 +00:00
|
|
|
[(set GPRC:$rD, (mul GPRC:$rA, immSExt16:$imm))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SUBFIC : DForm_2< 8, (outs GPRC:$rD), (ins GPRC:$rA, s16imm:$imm),
|
2005-10-19 19:51:16 +00:00
|
|
|
"subfic $rD, $rA, $imm", IntGeneral,
|
2006-03-17 22:41:37 +00:00
|
|
|
[(set GPRC:$rD, (subc immSExt16:$imm, GPRC:$rA))]>;
|
Initial commit of the machine code LICM pass. It successfully hoists this:
_foo:
li r2, 0
LBB1_1: ; bb
li r5, 0
stw r5, 0(r3)
addi r2, r2, 1
addi r3, r3, 4
cmplw cr0, r2, r4
bne cr0, LBB1_1 ; bb
LBB1_2: ; return
blr
to:
_foo:
li r2, 0
li r5, 0
LBB1_1: ; bb
stw r5, 0(r3)
addi r2, r2, 1
addi r3, r3, 4
cmplw cr0, r2, r4
bne cr0, LBB1_1 ; bb
LBB1_2: ; return
blr
ZOMG!! :-)
Moar to come...
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@44687 91177308-0d34-0410-b5e6-96231b3b80d8
2007-12-07 21:42:31 +00:00
|
|
|
|
2008-01-10 05:45:39 +00:00
|
|
|
let isReMaterializable = 1 in {
|
Initial commit of the machine code LICM pass. It successfully hoists this:
_foo:
li r2, 0
LBB1_1: ; bb
li r5, 0
stw r5, 0(r3)
addi r2, r2, 1
addi r3, r3, 4
cmplw cr0, r2, r4
bne cr0, LBB1_1 ; bb
LBB1_2: ; return
blr
to:
_foo:
li r2, 0
li r5, 0
LBB1_1: ; bb
stw r5, 0(r3)
addi r2, r2, 1
addi r3, r3, 4
cmplw cr0, r2, r4
bne cr0, LBB1_1 ; bb
LBB1_2: ; return
blr
ZOMG!! :-)
Moar to come...
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@44687 91177308-0d34-0410-b5e6-96231b3b80d8
2007-12-07 21:42:31 +00:00
|
|
|
def LI : DForm_2_r0<14, (outs GPRC:$rD), (ins symbolLo:$imm),
|
|
|
|
"li $rD, $imm", IntGeneral,
|
|
|
|
[(set GPRC:$rD, immSExt16:$imm)]>;
|
|
|
|
def LIS : DForm_2_r0<15, (outs GPRC:$rD), (ins symbolHi:$imm),
|
|
|
|
"lis $rD, $imm", IntGeneral,
|
|
|
|
[(set GPRC:$rD, imm16ShiftedSExt:$imm)]>;
|
|
|
|
}
|
2006-03-12 09:13:49 +00:00
|
|
|
}
|
2006-11-14 19:19:53 +00:00
|
|
|
|
2006-03-12 09:13:49 +00:00
|
|
|
let PPC970_Unit = 1 in { // FXU Operations.
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ANDIo : DForm_4<28, (outs GPRC:$dst), (ins GPRC:$src1, u16imm:$src2),
|
2005-10-19 19:51:16 +00:00
|
|
|
"andi. $dst, $src1, $src2", IntGeneral,
|
2006-02-12 09:09:52 +00:00
|
|
|
[(set GPRC:$dst, (and GPRC:$src1, immZExt16:$src2))]>,
|
|
|
|
isDOT;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ANDISo : DForm_4<29, (outs GPRC:$dst), (ins GPRC:$src1, u16imm:$src2),
|
2005-10-19 19:51:16 +00:00
|
|
|
"andis. $dst, $src1, $src2", IntGeneral,
|
Add some 64-bit logical ops.
Split imm16Shifted into a sext/zext form for 64-bit support.
Add some patterns for immediate formation. For example, we now compile this:
static unsigned long long Y;
void test3() {
Y = 0xF0F00F00;
}
into:
_test3:
li r2, 3840
lis r3, ha16(_Y)
xoris r2, r2, 61680
std r2, lo16(_Y)(r3)
blr
GCC produces:
_test3:
li r0,0
lis r2,ha16(_Y)
ori r0,r0,61680
sldi r0,r0,16
ori r0,r0,3840
std r0,lo16(_Y)(r2)
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@28883 91177308-0d34-0410-b5e6-96231b3b80d8
2006-06-20 22:34:10 +00:00
|
|
|
[(set GPRC:$dst, (and GPRC:$src1,imm16ShiftedZExt:$src2))]>,
|
2006-02-12 09:09:52 +00:00
|
|
|
isDOT;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ORI : DForm_4<24, (outs GPRC:$dst), (ins GPRC:$src1, u16imm:$src2),
|
2005-10-19 19:51:16 +00:00
|
|
|
"ori $dst, $src1, $src2", IntGeneral,
|
2005-09-14 18:18:39 +00:00
|
|
|
[(set GPRC:$dst, (or GPRC:$src1, immZExt16:$src2))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ORIS : DForm_4<25, (outs GPRC:$dst), (ins GPRC:$src1, u16imm:$src2),
|
2005-10-19 19:51:16 +00:00
|
|
|
"oris $dst, $src1, $src2", IntGeneral,
|
Add some 64-bit logical ops.
Split imm16Shifted into a sext/zext form for 64-bit support.
Add some patterns for immediate formation. For example, we now compile this:
static unsigned long long Y;
void test3() {
Y = 0xF0F00F00;
}
into:
_test3:
li r2, 3840
lis r3, ha16(_Y)
xoris r2, r2, 61680
std r2, lo16(_Y)(r3)
blr
GCC produces:
_test3:
li r0,0
lis r2,ha16(_Y)
ori r0,r0,61680
sldi r0,r0,16
ori r0,r0,3840
std r0,lo16(_Y)(r2)
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@28883 91177308-0d34-0410-b5e6-96231b3b80d8
2006-06-20 22:34:10 +00:00
|
|
|
[(set GPRC:$dst, (or GPRC:$src1, imm16ShiftedZExt:$src2))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def XORI : DForm_4<26, (outs GPRC:$dst), (ins GPRC:$src1, u16imm:$src2),
|
2005-10-19 19:51:16 +00:00
|
|
|
"xori $dst, $src1, $src2", IntGeneral,
|
2005-09-14 18:18:39 +00:00
|
|
|
[(set GPRC:$dst, (xor GPRC:$src1, immZExt16:$src2))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def XORIS : DForm_4<27, (outs GPRC:$dst), (ins GPRC:$src1, u16imm:$src2),
|
2005-10-19 19:51:16 +00:00
|
|
|
"xoris $dst, $src1, $src2", IntGeneral,
|
Add some 64-bit logical ops.
Split imm16Shifted into a sext/zext form for 64-bit support.
Add some patterns for immediate formation. For example, we now compile this:
static unsigned long long Y;
void test3() {
Y = 0xF0F00F00;
}
into:
_test3:
li r2, 3840
lis r3, ha16(_Y)
xoris r2, r2, 61680
std r2, lo16(_Y)(r3)
blr
GCC produces:
_test3:
li r0,0
lis r2,ha16(_Y)
ori r0,r0,61680
sldi r0,r0,16
ori r0,r0,3840
std r0,lo16(_Y)(r2)
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@28883 91177308-0d34-0410-b5e6-96231b3b80d8
2006-06-20 22:34:10 +00:00
|
|
|
[(set GPRC:$dst, (xor GPRC:$src1,imm16ShiftedZExt:$src2))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def NOP : DForm_4_zero<24, (outs), (ins), "nop", IntGeneral,
|
2005-12-09 23:54:18 +00:00
|
|
|
[]>;
|
2007-08-01 23:07:38 +00:00
|
|
|
def CMPWI : DForm_5_ext<11, (outs CRRC:$crD), (ins GPRC:$rA, s16imm:$imm),
|
2005-10-19 19:51:16 +00:00
|
|
|
"cmpwi $crD, $rA, $imm", IntCompare>;
|
2007-08-01 23:07:38 +00:00
|
|
|
def CMPLWI : DForm_6_ext<10, (outs CRRC:$dst), (ins GPRC:$src1, u16imm:$src2),
|
2005-10-19 19:51:16 +00:00
|
|
|
"cmplwi $dst, $src1, $src2", IntCompare>;
|
2006-03-12 09:13:49 +00:00
|
|
|
}
|
2006-07-10 20:56:58 +00:00
|
|
|
|
2006-03-25 07:51:43 +00:00
|
|
|
|
2006-03-12 09:13:49 +00:00
|
|
|
let PPC970_Unit = 1 in { // FXU Operations.
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def NAND : XForm_6<31, 476, (outs GPRC:$rA), (ins GPRC:$rS, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"nand $rA, $rS, $rB", IntGeneral,
|
2005-09-03 00:21:51 +00:00
|
|
|
[(set GPRC:$rA, (not (and GPRC:$rS, GPRC:$rB)))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def AND : XForm_6<31, 28, (outs GPRC:$rA), (ins GPRC:$rS, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"and $rA, $rS, $rB", IntGeneral,
|
2005-09-14 18:18:39 +00:00
|
|
|
[(set GPRC:$rA, (and GPRC:$rS, GPRC:$rB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ANDC : XForm_6<31, 60, (outs GPRC:$rA), (ins GPRC:$rS, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"andc $rA, $rS, $rB", IntGeneral,
|
2005-09-03 00:21:51 +00:00
|
|
|
[(set GPRC:$rA, (and GPRC:$rS, (not GPRC:$rB)))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def OR : XForm_6<31, 444, (outs GPRC:$rA), (ins GPRC:$rS, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"or $rA, $rS, $rB", IntGeneral,
|
2005-09-14 18:18:39 +00:00
|
|
|
[(set GPRC:$rA, (or GPRC:$rS, GPRC:$rB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def NOR : XForm_6<31, 124, (outs GPRC:$rA), (ins GPRC:$rS, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"nor $rA, $rS, $rB", IntGeneral,
|
2005-09-03 00:21:51 +00:00
|
|
|
[(set GPRC:$rA, (not (or GPRC:$rS, GPRC:$rB)))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ORC : XForm_6<31, 412, (outs GPRC:$rA), (ins GPRC:$rS, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"orc $rA, $rS, $rB", IntGeneral,
|
2005-09-03 00:21:51 +00:00
|
|
|
[(set GPRC:$rA, (or GPRC:$rS, (not GPRC:$rB)))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def EQV : XForm_6<31, 284, (outs GPRC:$rA), (ins GPRC:$rS, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"eqv $rA, $rS, $rB", IntGeneral,
|
2005-09-14 18:18:39 +00:00
|
|
|
[(set GPRC:$rA, (not (xor GPRC:$rS, GPRC:$rB)))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def XOR : XForm_6<31, 316, (outs GPRC:$rA), (ins GPRC:$rS, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"xor $rA, $rS, $rB", IntGeneral,
|
2006-06-20 00:39:56 +00:00
|
|
|
[(set GPRC:$rA, (xor GPRC:$rS, GPRC:$rB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SLW : XForm_6<31, 24, (outs GPRC:$rA), (ins GPRC:$rS, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"slw $rA, $rS, $rB", IntGeneral,
|
2005-12-06 02:10:38 +00:00
|
|
|
[(set GPRC:$rA, (PPCshl GPRC:$rS, GPRC:$rB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SRW : XForm_6<31, 536, (outs GPRC:$rA), (ins GPRC:$rS, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"srw $rA, $rS, $rB", IntGeneral,
|
2005-12-06 02:10:38 +00:00
|
|
|
[(set GPRC:$rA, (PPCsrl GPRC:$rS, GPRC:$rB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SRAW : XForm_6<31, 792, (outs GPRC:$rA), (ins GPRC:$rS, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"sraw $rA, $rS, $rB", IntShift,
|
2005-12-06 02:10:38 +00:00
|
|
|
[(set GPRC:$rA, (PPCsra GPRC:$rS, GPRC:$rB))]>;
|
2006-03-12 09:13:49 +00:00
|
|
|
}
|
2006-11-14 19:19:53 +00:00
|
|
|
|
2006-03-12 09:13:49 +00:00
|
|
|
let PPC970_Unit = 1 in { // FXU Operations.
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SRAWI : XForm_10<31, 824, (outs GPRC:$rA), (ins GPRC:$rS, u5imm:$SH),
|
2005-10-19 19:51:16 +00:00
|
|
|
"srawi $rA, $rS, $SH", IntShift,
|
2005-12-05 02:34:05 +00:00
|
|
|
[(set GPRC:$rA, (sra GPRC:$rS, (i32 imm:$SH)))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def CNTLZW : XForm_11<31, 26, (outs GPRC:$rA), (ins GPRC:$rS),
|
2005-10-19 19:51:16 +00:00
|
|
|
"cntlzw $rA, $rS", IntGeneral,
|
2005-09-02 22:35:53 +00:00
|
|
|
[(set GPRC:$rA, (ctlz GPRC:$rS))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def EXTSB : XForm_11<31, 954, (outs GPRC:$rA), (ins GPRC:$rS),
|
2005-10-19 19:51:16 +00:00
|
|
|
"extsb $rA, $rS", IntGeneral,
|
2005-09-02 22:35:53 +00:00
|
|
|
[(set GPRC:$rA, (sext_inreg GPRC:$rS, i8))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def EXTSH : XForm_11<31, 922, (outs GPRC:$rA), (ins GPRC:$rS),
|
2005-10-19 19:51:16 +00:00
|
|
|
"extsh $rA, $rS", IntGeneral,
|
2005-09-02 22:35:53 +00:00
|
|
|
[(set GPRC:$rA, (sext_inreg GPRC:$rS, i16))]>;
|
When possible, custom lower 32-bit SINT_TO_FP to this:
_foo2:
extsw r2, r3
std r2, -8(r1)
lfd f0, -8(r1)
fcfid f0, f0
frsp f1, f0
blr
instead of this:
_foo2:
lis r2, ha16(LCPI2_0)
lis r4, 17200
xoris r3, r3, 32768
stw r3, -4(r1)
stw r4, -8(r1)
lfs f0, lo16(LCPI2_0)(r2)
lfd f1, -8(r1)
fsub f0, f1, f0
frsp f1, f0
blr
This speeds up Misc/pi from 2.44s->2.09s with LLC and from 3.01->2.18s
with llcbeta (16.7% and 38.1% respectively).
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26943 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-22 05:30:33 +00:00
|
|
|
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def CMPW : XForm_16_ext<31, 0, (outs CRRC:$crD), (ins GPRC:$rA, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"cmpw $crD, $rA, $rB", IntCompare>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def CMPLW : XForm_16_ext<31, 32, (outs CRRC:$crD), (ins GPRC:$rA, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"cmplw $crD, $rA, $rB", IntCompare>;
|
2006-03-12 09:13:49 +00:00
|
|
|
}
|
|
|
|
let PPC970_Unit = 3 in { // FPU Operations.
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
//def FCMPO : XForm_17<63, 32, (outs CRRC:$crD), (ins FPRC:$fA, FPRC:$fB),
|
2005-10-19 19:51:16 +00:00
|
|
|
// "fcmpo $crD, $fA, $fB", FPCompare>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FCMPUS : XForm_17<63, 0, (outs CRRC:$crD), (ins F4RC:$fA, F4RC:$fB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fcmpu $crD, $fA, $fB", FPCompare>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FCMPUD : XForm_17<63, 0, (outs CRRC:$crD), (ins F8RC:$fA, F8RC:$fB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fcmpu $crD, $fA, $fB", FPCompare>;
|
2006-11-14 19:19:53 +00:00
|
|
|
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FCTIWZ : XForm_26<63, 15, (outs F8RC:$frD), (ins F8RC:$frB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fctiwz $frD, $frB", FPGeneral,
|
2005-10-25 20:41:46 +00:00
|
|
|
[(set F8RC:$frD, (PPCfctiwz F8RC:$frB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FRSP : XForm_26<63, 12, (outs F4RC:$frD), (ins F8RC:$frB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"frsp $frD, $frB", FPGeneral,
|
2005-10-14 04:55:50 +00:00
|
|
|
[(set F4RC:$frD, (fround F8RC:$frB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FSQRT : XForm_26<63, 22, (outs F8RC:$frD), (ins F8RC:$frB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fsqrt $frD, $frB", FPSqrt,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F8RC:$frD, (fsqrt F8RC:$frB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FSQRTS : XForm_26<59, 22, (outs F4RC:$frD), (ins F4RC:$frB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fsqrts $frD, $frB", FPSqrt,
|
2005-10-15 21:44:15 +00:00
|
|
|
[(set F4RC:$frD, (fsqrt F4RC:$frB))]>;
|
2006-03-12 09:13:49 +00:00
|
|
|
}
|
2005-10-01 01:35:02 +00:00
|
|
|
|
|
|
|
/// FMR is split into 3 versions, one for 4/8 byte FP, and one for extending.
|
2006-03-12 09:13:49 +00:00
|
|
|
///
|
|
|
|
/// Note that these are defined as pseudo-ops on the PPC970 because they are
|
2006-03-24 07:12:19 +00:00
|
|
|
/// often coalesced away and we don't want the dispatch group builder to think
|
2006-03-12 09:13:49 +00:00
|
|
|
/// that they will fill slots (which could cause the load of a LSU reject to
|
|
|
|
/// sneak into a d-group with a store).
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FMRS : XForm_26<63, 72, (outs F4RC:$frD), (ins F4RC:$frB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fmr $frD, $frB", FPGeneral,
|
2006-03-12 09:13:49 +00:00
|
|
|
[]>, // (set F4RC:$frD, F4RC:$frB)
|
|
|
|
PPC970_Unit_Pseudo;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FMRD : XForm_26<63, 72, (outs F8RC:$frD), (ins F8RC:$frB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fmr $frD, $frB", FPGeneral,
|
2006-03-12 09:13:49 +00:00
|
|
|
[]>, // (set F8RC:$frD, F8RC:$frB)
|
|
|
|
PPC970_Unit_Pseudo;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FMRSD : XForm_26<63, 72, (outs F8RC:$frD), (ins F4RC:$frB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fmr $frD, $frB", FPGeneral,
|
2006-03-12 09:13:49 +00:00
|
|
|
[(set F8RC:$frD, (fextend F4RC:$frB))]>,
|
|
|
|
PPC970_Unit_Pseudo;
|
2005-10-01 01:35:02 +00:00
|
|
|
|
2006-03-12 09:13:49 +00:00
|
|
|
let PPC970_Unit = 3 in { // FPU Operations.
|
2005-10-01 01:35:02 +00:00
|
|
|
// These are artificially split into two different forms, for 4/8 byte FP.
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FABSS : XForm_26<63, 264, (outs F4RC:$frD), (ins F4RC:$frB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fabs $frD, $frB", FPGeneral,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F4RC:$frD, (fabs F4RC:$frB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FABSD : XForm_26<63, 264, (outs F8RC:$frD), (ins F8RC:$frB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fabs $frD, $frB", FPGeneral,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F8RC:$frD, (fabs F8RC:$frB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FNABSS : XForm_26<63, 136, (outs F4RC:$frD), (ins F4RC:$frB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fnabs $frD, $frB", FPGeneral,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F4RC:$frD, (fneg (fabs F4RC:$frB)))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FNABSD : XForm_26<63, 136, (outs F8RC:$frD), (ins F8RC:$frB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fnabs $frD, $frB", FPGeneral,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F8RC:$frD, (fneg (fabs F8RC:$frB)))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FNEGS : XForm_26<63, 40, (outs F4RC:$frD), (ins F4RC:$frB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fneg $frD, $frB", FPGeneral,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F4RC:$frD, (fneg F4RC:$frB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def FNEGD : XForm_26<63, 40, (outs F8RC:$frD), (ins F8RC:$frB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fneg $frD, $frB", FPGeneral,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F8RC:$frD, (fneg F8RC:$frB))]>;
|
2006-03-12 09:13:49 +00:00
|
|
|
}
|
2005-10-01 01:35:02 +00:00
|
|
|
|
2004-08-29 22:45:13 +00:00
|
|
|
|
2004-08-30 02:28:06 +00:00
|
|
|
// XL-Form instructions. condition register logical ops.
|
|
|
|
//
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MCRF : XLForm_3<19, 0, (outs CRRC:$BF), (ins CRRC:$BFA),
|
2006-03-12 09:13:49 +00:00
|
|
|
"mcrf $BF, $BFA", BrMCR>,
|
|
|
|
PPC970_DGroup_First, PPC970_Unit_CRU;
|
2004-08-30 02:28:06 +00:00
|
|
|
|
2008-03-10 14:12:10 +00:00
|
|
|
def CREQV : XLForm_1<19, 289, (outs CRBITRC:$CRD),
|
|
|
|
(ins CRBITRC:$CRA, CRBITRC:$CRB),
|
2007-02-25 05:34:32 +00:00
|
|
|
"creqv $CRD, $CRA, $CRB", BrCR,
|
|
|
|
[]>;
|
|
|
|
|
2008-03-10 14:12:10 +00:00
|
|
|
def CROR : XLForm_1<19, 449, (outs CRBITRC:$CRD),
|
|
|
|
(ins CRBITRC:$CRA, CRBITRC:$CRB),
|
|
|
|
"cror $CRD, $CRA, $CRB", BrCR,
|
|
|
|
[]>;
|
|
|
|
|
|
|
|
def CRSET : XLForm_1_ext<19, 289, (outs CRBITRC:$dst), (ins),
|
2007-02-25 05:34:32 +00:00
|
|
|
"creqv $dst, $dst, $dst", BrCR,
|
|
|
|
[]>;
|
|
|
|
|
2006-03-12 09:13:49 +00:00
|
|
|
// XFX-Form instructions. Instructions that deal with SPRs.
|
2004-08-30 02:28:06 +00:00
|
|
|
//
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MFCTR : XFXForm_1_ext<31, 339, 9, (outs GPRC:$rT), (ins),
|
|
|
|
"mfctr $rT", SprMFSPR>,
|
2006-03-12 09:13:49 +00:00
|
|
|
PPC970_DGroup_First, PPC970_Unit_FXU;
|
2006-05-17 19:00:46 +00:00
|
|
|
let Pattern = [(PPCmtctr GPRC:$rS)] in {
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MTCTR : XFXForm_7_ext<31, 467, 9, (outs), (ins GPRC:$rS),
|
|
|
|
"mtctr $rS", SprMTSPR>,
|
For functions that use vector registers, save VRSAVE, mark used
registers, and update it on entry to each function, then restore it on exit.
This compiles:
void func(vfloat *a, vfloat *b, vfloat *c) {
*a = *b * *c + *c;
}
to this:
_func:
mfspr r2, 256
oris r6, r2, 49152
mtspr 256, r6
lvx v0, 0, r5
lvx v1, 0, r4
vmaddfp v0, v1, v0, v0
stvx v0, 0, r3
mtspr 256, r2
blr
GCC produces this (which has additional stack accesses):
_func:
mfspr r0,256
stw r0,-4(r1)
oris r0,r0,0xc000
mtspr 256,r0
lvx v0,0,r5
lvx v1,0,r4
lwz r12,-4(r1)
vmaddfp v0,v0,v1,v0
stvx v0,0,r3
mtspr 256,r12
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26733 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-13 21:52:10 +00:00
|
|
|
PPC970_DGroup_First, PPC970_Unit_FXU;
|
2006-05-17 19:00:46 +00:00
|
|
|
}
|
For functions that use vector registers, save VRSAVE, mark used
registers, and update it on entry to each function, then restore it on exit.
This compiles:
void func(vfloat *a, vfloat *b, vfloat *c) {
*a = *b * *c + *c;
}
to this:
_func:
mfspr r2, 256
oris r6, r2, 49152
mtspr 256, r6
lvx v0, 0, r5
lvx v1, 0, r4
vmaddfp v0, v1, v0, v0
stvx v0, 0, r3
mtspr 256, r2
blr
GCC produces this (which has additional stack accesses):
_func:
mfspr r0,256
stw r0,-4(r1)
oris r0,r0,0xc000
mtspr 256,r0
lvx v0,0,r5
lvx v1,0,r4
lwz r12,-4(r1)
vmaddfp v0,v0,v1,v0
stvx v0,0,r3
mtspr 256,r12
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26733 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-13 21:52:10 +00:00
|
|
|
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MTLR : XFXForm_7_ext<31, 467, 8, (outs), (ins GPRC:$rS),
|
|
|
|
"mtlr $rS", SprMTSPR>,
|
For functions that use vector registers, save VRSAVE, mark used
registers, and update it on entry to each function, then restore it on exit.
This compiles:
void func(vfloat *a, vfloat *b, vfloat *c) {
*a = *b * *c + *c;
}
to this:
_func:
mfspr r2, 256
oris r6, r2, 49152
mtspr 256, r6
lvx v0, 0, r5
lvx v1, 0, r4
vmaddfp v0, v1, v0, v0
stvx v0, 0, r3
mtspr 256, r2
blr
GCC produces this (which has additional stack accesses):
_func:
mfspr r0,256
stw r0,-4(r1)
oris r0,r0,0xc000
mtspr 256,r0
lvx v0,0,r5
lvx v1,0,r4
lwz r12,-4(r1)
vmaddfp v0,v0,v1,v0
stvx v0,0,r3
mtspr 256,r12
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26733 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-13 21:52:10 +00:00
|
|
|
PPC970_DGroup_First, PPC970_Unit_FXU;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MFLR : XFXForm_1_ext<31, 339, 8, (outs GPRC:$rT), (ins),
|
|
|
|
"mflr $rT", SprMFSPR>,
|
2006-03-12 09:13:49 +00:00
|
|
|
PPC970_DGroup_First, PPC970_Unit_FXU;
|
For functions that use vector registers, save VRSAVE, mark used
registers, and update it on entry to each function, then restore it on exit.
This compiles:
void func(vfloat *a, vfloat *b, vfloat *c) {
*a = *b * *c + *c;
}
to this:
_func:
mfspr r2, 256
oris r6, r2, 49152
mtspr 256, r6
lvx v0, 0, r5
lvx v1, 0, r4
vmaddfp v0, v1, v0, v0
stvx v0, 0, r3
mtspr 256, r2
blr
GCC produces this (which has additional stack accesses):
_func:
mfspr r0,256
stw r0,-4(r1)
oris r0,r0,0xc000
mtspr 256,r0
lvx v0,0,r5
lvx v1,0,r4
lwz r12,-4(r1)
vmaddfp v0,v0,v1,v0
stvx v0,0,r3
mtspr 256,r12
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26733 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-13 21:52:10 +00:00
|
|
|
|
|
|
|
// Move to/from VRSAVE: despite being a SPR, the VRSAVE register is renamed like
|
|
|
|
// a GPR on the PPC970. As such, copies in and out have the same performance
|
|
|
|
// characteristics as an OR instruction.
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MTVRSAVE : XFXForm_7_ext<31, 467, 256, (outs), (ins GPRC:$rS),
|
For functions that use vector registers, save VRSAVE, mark used
registers, and update it on entry to each function, then restore it on exit.
This compiles:
void func(vfloat *a, vfloat *b, vfloat *c) {
*a = *b * *c + *c;
}
to this:
_func:
mfspr r2, 256
oris r6, r2, 49152
mtspr 256, r6
lvx v0, 0, r5
lvx v1, 0, r4
vmaddfp v0, v1, v0, v0
stvx v0, 0, r3
mtspr 256, r2
blr
GCC produces this (which has additional stack accesses):
_func:
mfspr r0,256
stw r0,-4(r1)
oris r0,r0,0xc000
mtspr 256,r0
lvx v0,0,r5
lvx v1,0,r4
lwz r12,-4(r1)
vmaddfp v0,v0,v1,v0
stvx v0,0,r3
mtspr 256,r12
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26733 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-13 21:52:10 +00:00
|
|
|
"mtspr 256, $rS", IntGeneral>,
|
2006-03-15 05:25:05 +00:00
|
|
|
PPC970_DGroup_Single, PPC970_Unit_FXU;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MFVRSAVE : XFXForm_1_ext<31, 339, 256, (outs GPRC:$rT), (ins),
|
For functions that use vector registers, save VRSAVE, mark used
registers, and update it on entry to each function, then restore it on exit.
This compiles:
void func(vfloat *a, vfloat *b, vfloat *c) {
*a = *b * *c + *c;
}
to this:
_func:
mfspr r2, 256
oris r6, r2, 49152
mtspr 256, r6
lvx v0, 0, r5
lvx v1, 0, r4
vmaddfp v0, v1, v0, v0
stvx v0, 0, r3
mtspr 256, r2
blr
GCC produces this (which has additional stack accesses):
_func:
mfspr r0,256
stw r0,-4(r1)
oris r0,r0,0xc000
mtspr 256,r0
lvx v0,0,r5
lvx v1,0,r4
lwz r12,-4(r1)
vmaddfp v0,v0,v1,v0
stvx v0,0,r3
mtspr 256,r12
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26733 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-13 21:52:10 +00:00
|
|
|
"mfspr $rT, 256", IntGeneral>,
|
2006-03-15 05:25:05 +00:00
|
|
|
PPC970_DGroup_First, PPC970_Unit_FXU;
|
For functions that use vector registers, save VRSAVE, mark used
registers, and update it on entry to each function, then restore it on exit.
This compiles:
void func(vfloat *a, vfloat *b, vfloat *c) {
*a = *b * *c + *c;
}
to this:
_func:
mfspr r2, 256
oris r6, r2, 49152
mtspr 256, r6
lvx v0, 0, r5
lvx v1, 0, r4
vmaddfp v0, v1, v0, v0
stvx v0, 0, r3
mtspr 256, r2
blr
GCC produces this (which has additional stack accesses):
_func:
mfspr r0,256
stw r0,-4(r1)
oris r0,r0,0xc000
mtspr 256,r0
lvx v0,0,r5
lvx v1,0,r4
lwz r12,-4(r1)
vmaddfp v0,v0,v1,v0
stvx v0,0,r3
mtspr 256,r12
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26733 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-13 21:52:10 +00:00
|
|
|
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MTCRF : XFXForm_5<31, 144, (outs), (ins crbitm:$FXM, GPRC:$rS),
|
2006-03-12 09:13:49 +00:00
|
|
|
"mtcrf $FXM, $rS", BrMCRX>,
|
|
|
|
PPC970_MicroCode, PPC970_Unit_CRU;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MFCR : XFXForm_3<31, 19, (outs GPRC:$rT), (ins), "mfcr $rT", SprMFCR>,
|
2006-03-26 10:06:40 +00:00
|
|
|
PPC970_MicroCode, PPC970_Unit_CRU;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MFOCRF: XFXForm_5a<31, 19, (outs GPRC:$rT), (ins crbitm:$FXM),
|
2006-03-12 09:13:49 +00:00
|
|
|
"mfcr $rT, $FXM", SprMFCR>,
|
|
|
|
PPC970_DGroup_First, PPC970_Unit_CRU;
|
2004-08-30 02:28:06 +00:00
|
|
|
|
2007-10-10 01:01:31 +00:00
|
|
|
// Instructions to manipulate FPSCR. Only long double handling uses these.
|
|
|
|
// FPSCR is not modelled; we use the SDNode Flag to keep things in order.
|
|
|
|
|
|
|
|
def MFFS : XForm_42<63, 583, (outs F8RC:$rT), (ins),
|
|
|
|
"mffs $rT", IntMFFS,
|
|
|
|
[(set F8RC:$rT, (PPCmffs))]>,
|
|
|
|
PPC970_DGroup_Single, PPC970_Unit_FPU;
|
|
|
|
def MTFSB0 : XForm_43<63, 70, (outs), (ins u5imm:$FM),
|
|
|
|
"mtfsb0 $FM", IntMTFSB0,
|
|
|
|
[(PPCmtfsb0 (i32 imm:$FM))]>,
|
|
|
|
PPC970_DGroup_Single, PPC970_Unit_FPU;
|
|
|
|
def MTFSB1 : XForm_43<63, 38, (outs), (ins u5imm:$FM),
|
|
|
|
"mtfsb1 $FM", IntMTFSB0,
|
|
|
|
[(PPCmtfsb1 (i32 imm:$FM))]>,
|
|
|
|
PPC970_DGroup_Single, PPC970_Unit_FPU;
|
|
|
|
def FADDrtz: AForm_2<63, 21,
|
|
|
|
(outs F8RC:$FRT), (ins F8RC:$FRA, F8RC:$FRB),
|
|
|
|
"fadd $FRT, $FRA, $FRB", FPGeneral,
|
|
|
|
[(set F8RC:$FRT, (PPCfaddrtz F8RC:$FRA, F8RC:$FRB))]>,
|
|
|
|
PPC970_DGroup_Single, PPC970_Unit_FPU;
|
|
|
|
// MTFSF does not actually produce an FP result. We pretend it copies
|
|
|
|
// input reg B to the output. If we didn't do this it would look like the
|
|
|
|
// instruction had no outputs (because we aren't modelling the FPSCR) and
|
|
|
|
// it would be deleted.
|
|
|
|
def MTFSF : XFLForm<63, 711, (outs F8RC:$FRA),
|
|
|
|
(ins i32imm:$FM, F8RC:$rT, F8RC:$FRB),
|
|
|
|
"mtfsf $FM, $rT", "$FRB = $FRA", IntMTFSB0,
|
|
|
|
[(set F8RC:$FRA, (PPCmtfsf (i32 imm:$FM),
|
|
|
|
F8RC:$rT, F8RC:$FRB))]>,
|
|
|
|
PPC970_DGroup_Single, PPC970_Unit_FPU;
|
|
|
|
|
2006-03-12 09:13:49 +00:00
|
|
|
let PPC970_Unit = 1 in { // FXU Operations.
|
2004-08-30 02:28:06 +00:00
|
|
|
|
|
|
|
// XO-Form instructions. Arithmetic instructions that can set overflow bit
|
|
|
|
//
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ADD4 : XOForm_1<31, 266, 0, (outs GPRC:$rT), (ins GPRC:$rA, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"add $rT, $rA, $rB", IntGeneral,
|
2005-09-02 21:18:00 +00:00
|
|
|
[(set GPRC:$rT, (add GPRC:$rA, GPRC:$rB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ADDC : XOForm_1<31, 10, 0, (outs GPRC:$rT), (ins GPRC:$rA, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"addc $rT, $rA, $rB", IntGeneral,
|
2006-03-13 05:15:10 +00:00
|
|
|
[(set GPRC:$rT, (addc GPRC:$rA, GPRC:$rB))]>,
|
|
|
|
PPC970_DGroup_Cracked;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ADDE : XOForm_1<31, 138, 0, (outs GPRC:$rT), (ins GPRC:$rA, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"adde $rT, $rA, $rB", IntGeneral,
|
2006-02-17 05:43:56 +00:00
|
|
|
[(set GPRC:$rT, (adde GPRC:$rA, GPRC:$rB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def DIVW : XOForm_1<31, 491, 0, (outs GPRC:$rT), (ins GPRC:$rA, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"divw $rT, $rA, $rB", IntDivW,
|
2006-03-12 09:13:49 +00:00
|
|
|
[(set GPRC:$rT, (sdiv GPRC:$rA, GPRC:$rB))]>,
|
2006-03-13 05:15:10 +00:00
|
|
|
PPC970_DGroup_First, PPC970_DGroup_Cracked;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def DIVWU : XOForm_1<31, 459, 0, (outs GPRC:$rT), (ins GPRC:$rA, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"divwu $rT, $rA, $rB", IntDivW,
|
2006-03-12 09:13:49 +00:00
|
|
|
[(set GPRC:$rT, (udiv GPRC:$rA, GPRC:$rB))]>,
|
2006-03-13 05:15:10 +00:00
|
|
|
PPC970_DGroup_First, PPC970_DGroup_Cracked;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MULHW : XOForm_1<31, 75, 0, (outs GPRC:$rT), (ins GPRC:$rA, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"mulhw $rT, $rA, $rB", IntMulHW,
|
2005-09-02 21:18:00 +00:00
|
|
|
[(set GPRC:$rT, (mulhs GPRC:$rA, GPRC:$rB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MULHWU : XOForm_1<31, 11, 0, (outs GPRC:$rT), (ins GPRC:$rA, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"mulhwu $rT, $rA, $rB", IntMulHWU,
|
2005-09-02 21:18:00 +00:00
|
|
|
[(set GPRC:$rT, (mulhu GPRC:$rA, GPRC:$rB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MULLW : XOForm_1<31, 235, 0, (outs GPRC:$rT), (ins GPRC:$rA, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"mullw $rT, $rA, $rB", IntMulHW,
|
2005-09-02 21:18:00 +00:00
|
|
|
[(set GPRC:$rT, (mul GPRC:$rA, GPRC:$rB))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SUBF : XOForm_1<31, 40, 0, (outs GPRC:$rT), (ins GPRC:$rA, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"subf $rT, $rA, $rB", IntGeneral,
|
2005-09-02 21:18:00 +00:00
|
|
|
[(set GPRC:$rT, (sub GPRC:$rB, GPRC:$rA))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SUBFC : XOForm_1<31, 8, 0, (outs GPRC:$rT), (ins GPRC:$rA, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"subfc $rT, $rA, $rB", IntGeneral,
|
2006-03-13 05:15:10 +00:00
|
|
|
[(set GPRC:$rT, (subc GPRC:$rB, GPRC:$rA))]>,
|
|
|
|
PPC970_DGroup_Cracked;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SUBFE : XOForm_1<31, 136, 0, (outs GPRC:$rT), (ins GPRC:$rA, GPRC:$rB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"subfe $rT, $rA, $rB", IntGeneral,
|
2006-02-17 05:43:56 +00:00
|
|
|
[(set GPRC:$rT, (sube GPRC:$rB, GPRC:$rA))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ADDME : XOForm_3<31, 234, 0, (outs GPRC:$rT), (ins GPRC:$rA),
|
2005-10-19 19:51:16 +00:00
|
|
|
"addme $rT, $rA", IntGeneral,
|
2006-02-17 05:43:56 +00:00
|
|
|
[(set GPRC:$rT, (adde GPRC:$rA, immAllOnes))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def ADDZE : XOForm_3<31, 202, 0, (outs GPRC:$rT), (ins GPRC:$rA),
|
2005-10-19 19:51:16 +00:00
|
|
|
"addze $rT, $rA", IntGeneral,
|
2006-02-17 05:43:56 +00:00
|
|
|
[(set GPRC:$rT, (adde GPRC:$rA, 0))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def NEG : XOForm_3<31, 104, 0, (outs GPRC:$rT), (ins GPRC:$rA),
|
2005-10-19 19:51:16 +00:00
|
|
|
"neg $rT, $rA", IntGeneral,
|
2005-09-08 17:01:54 +00:00
|
|
|
[(set GPRC:$rT, (ineg GPRC:$rA))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SUBFME : XOForm_3<31, 232, 0, (outs GPRC:$rT), (ins GPRC:$rA),
|
2006-02-17 05:43:56 +00:00
|
|
|
"subfme $rT, $rA", IntGeneral,
|
|
|
|
[(set GPRC:$rT, (sube immAllOnes, GPRC:$rA))]>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def SUBFZE : XOForm_3<31, 200, 0, (outs GPRC:$rT), (ins GPRC:$rA),
|
2005-10-19 19:51:16 +00:00
|
|
|
"subfze $rT, $rA", IntGeneral,
|
2006-02-17 05:43:56 +00:00
|
|
|
[(set GPRC:$rT, (sube 0, GPRC:$rA))]>;
|
2006-03-12 09:13:49 +00:00
|
|
|
}
|
2004-08-30 02:28:06 +00:00
|
|
|
|
|
|
|
// A-Form instructions. Most of the instructions executed in the FPU are of
|
|
|
|
// this type.
|
|
|
|
//
|
2006-03-12 09:13:49 +00:00
|
|
|
let PPC970_Unit = 3 in { // FPU Operations.
|
2005-04-19 05:21:30 +00:00
|
|
|
def FMADD : AForm_1<63, 29,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F8RC:$FRT), (ins F8RC:$FRA, F8RC:$FRC, F8RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fmadd $FRT, $FRA, $FRC, $FRB", FPFused,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F8RC:$FRT, (fadd (fmul F8RC:$FRA, F8RC:$FRC),
|
2005-12-14 22:07:12 +00:00
|
|
|
F8RC:$FRB))]>,
|
|
|
|
Requires<[FPContractions]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FMADDS : AForm_1<59, 29,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F4RC:$FRT), (ins F4RC:$FRA, F4RC:$FRC, F4RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fmadds $FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2005-10-02 07:46:28 +00:00
|
|
|
[(set F4RC:$FRT, (fadd (fmul F4RC:$FRA, F4RC:$FRC),
|
2005-12-14 22:07:12 +00:00
|
|
|
F4RC:$FRB))]>,
|
|
|
|
Requires<[FPContractions]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FMSUB : AForm_1<63, 28,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F8RC:$FRT), (ins F8RC:$FRA, F8RC:$FRC, F8RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fmsub $FRT, $FRA, $FRC, $FRB", FPFused,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F8RC:$FRT, (fsub (fmul F8RC:$FRA, F8RC:$FRC),
|
2005-12-14 22:07:12 +00:00
|
|
|
F8RC:$FRB))]>,
|
|
|
|
Requires<[FPContractions]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FMSUBS : AForm_1<59, 28,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F4RC:$FRT), (ins F4RC:$FRA, F4RC:$FRC, F4RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fmsubs $FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2005-10-02 07:46:28 +00:00
|
|
|
[(set F4RC:$FRT, (fsub (fmul F4RC:$FRA, F4RC:$FRC),
|
2005-12-14 22:07:12 +00:00
|
|
|
F4RC:$FRB))]>,
|
|
|
|
Requires<[FPContractions]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FNMADD : AForm_1<63, 31,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F8RC:$FRT), (ins F8RC:$FRA, F8RC:$FRC, F8RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fnmadd $FRT, $FRA, $FRC, $FRB", FPFused,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F8RC:$FRT, (fneg (fadd (fmul F8RC:$FRA, F8RC:$FRC),
|
Use the new predicate support that Evan Cheng added to remove some code
from the DAGToDAG cpp file. This adds pattern support for vector and
scalar fma, which passes test/Regression/CodeGen/PowerPC/fma.ll, and
does the right thing in the presence of -disable-excess-fp-precision.
Allows us to match:
void %foo(<4 x float> * %a) {
entry:
%tmp1 = load <4 x float> * %a;
%tmp2 = mul <4 x float> %tmp1, %tmp1
%tmp3 = add <4 x float> %tmp2, %tmp1
store <4 x float> %tmp3, <4 x float> *%a
ret void
}
As:
_foo:
li r2, 0
lvx v0, r2, r3
vmaddfp v0, v0, v0, v0
stvx v0, r2, r3
blr
Or, with llc -disable-excess-fp-precision,
_foo:
li r2, 0
lvx v0, r2, r3
vxor v1, v1, v1
vmaddfp v1, v0, v0, v1
vaddfp v0, v1, v0
stvx v0, r2, r3
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24719 91177308-0d34-0410-b5e6-96231b3b80d8
2005-12-14 22:54:33 +00:00
|
|
|
F8RC:$FRB)))]>,
|
|
|
|
Requires<[FPContractions]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FNMADDS : AForm_1<59, 31,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F4RC:$FRT), (ins F4RC:$FRA, F4RC:$FRC, F4RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fnmadds $FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2005-10-02 07:46:28 +00:00
|
|
|
[(set F4RC:$FRT, (fneg (fadd (fmul F4RC:$FRA, F4RC:$FRC),
|
Use the new predicate support that Evan Cheng added to remove some code
from the DAGToDAG cpp file. This adds pattern support for vector and
scalar fma, which passes test/Regression/CodeGen/PowerPC/fma.ll, and
does the right thing in the presence of -disable-excess-fp-precision.
Allows us to match:
void %foo(<4 x float> * %a) {
entry:
%tmp1 = load <4 x float> * %a;
%tmp2 = mul <4 x float> %tmp1, %tmp1
%tmp3 = add <4 x float> %tmp2, %tmp1
store <4 x float> %tmp3, <4 x float> *%a
ret void
}
As:
_foo:
li r2, 0
lvx v0, r2, r3
vmaddfp v0, v0, v0, v0
stvx v0, r2, r3
blr
Or, with llc -disable-excess-fp-precision,
_foo:
li r2, 0
lvx v0, r2, r3
vxor v1, v1, v1
vmaddfp v1, v0, v0, v1
vaddfp v0, v1, v0
stvx v0, r2, r3
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24719 91177308-0d34-0410-b5e6-96231b3b80d8
2005-12-14 22:54:33 +00:00
|
|
|
F4RC:$FRB)))]>,
|
|
|
|
Requires<[FPContractions]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FNMSUB : AForm_1<63, 30,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F8RC:$FRT), (ins F8RC:$FRA, F8RC:$FRC, F8RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fnmsub $FRT, $FRA, $FRC, $FRB", FPFused,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F8RC:$FRT, (fneg (fsub (fmul F8RC:$FRA, F8RC:$FRC),
|
Use the new predicate support that Evan Cheng added to remove some code
from the DAGToDAG cpp file. This adds pattern support for vector and
scalar fma, which passes test/Regression/CodeGen/PowerPC/fma.ll, and
does the right thing in the presence of -disable-excess-fp-precision.
Allows us to match:
void %foo(<4 x float> * %a) {
entry:
%tmp1 = load <4 x float> * %a;
%tmp2 = mul <4 x float> %tmp1, %tmp1
%tmp3 = add <4 x float> %tmp2, %tmp1
store <4 x float> %tmp3, <4 x float> *%a
ret void
}
As:
_foo:
li r2, 0
lvx v0, r2, r3
vmaddfp v0, v0, v0, v0
stvx v0, r2, r3
blr
Or, with llc -disable-excess-fp-precision,
_foo:
li r2, 0
lvx v0, r2, r3
vxor v1, v1, v1
vmaddfp v1, v0, v0, v1
vaddfp v0, v1, v0
stvx v0, r2, r3
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24719 91177308-0d34-0410-b5e6-96231b3b80d8
2005-12-14 22:54:33 +00:00
|
|
|
F8RC:$FRB)))]>,
|
|
|
|
Requires<[FPContractions]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FNMSUBS : AForm_1<59, 30,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F4RC:$FRT), (ins F4RC:$FRA, F4RC:$FRC, F4RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fnmsubs $FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2005-10-02 07:46:28 +00:00
|
|
|
[(set F4RC:$FRT, (fneg (fsub (fmul F4RC:$FRA, F4RC:$FRC),
|
Use the new predicate support that Evan Cheng added to remove some code
from the DAGToDAG cpp file. This adds pattern support for vector and
scalar fma, which passes test/Regression/CodeGen/PowerPC/fma.ll, and
does the right thing in the presence of -disable-excess-fp-precision.
Allows us to match:
void %foo(<4 x float> * %a) {
entry:
%tmp1 = load <4 x float> * %a;
%tmp2 = mul <4 x float> %tmp1, %tmp1
%tmp3 = add <4 x float> %tmp2, %tmp1
store <4 x float> %tmp3, <4 x float> *%a
ret void
}
As:
_foo:
li r2, 0
lvx v0, r2, r3
vmaddfp v0, v0, v0, v0
stvx v0, r2, r3
blr
Or, with llc -disable-excess-fp-precision,
_foo:
li r2, 0
lvx v0, r2, r3
vxor v1, v1, v1
vmaddfp v1, v0, v0, v1
vaddfp v0, v1, v0
stvx v0, r2, r3
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24719 91177308-0d34-0410-b5e6-96231b3b80d8
2005-12-14 22:54:33 +00:00
|
|
|
F4RC:$FRB)))]>,
|
|
|
|
Requires<[FPContractions]>;
|
2005-10-02 07:07:49 +00: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 06:58:23 +00:00
|
|
|
// and 4/8 byte forms for the result and operand type..
|
2005-10-02 07:07:49 +00:00
|
|
|
def FSELD : AForm_1<63, 23,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F8RC:$FRT), (ins F8RC:$FRA, F8RC:$FRC, F8RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fsel $FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2005-10-25 20:55:47 +00:00
|
|
|
[(set F8RC:$FRT, (PPCfsel F8RC:$FRA,F8RC:$FRC,F8RC:$FRB))]>;
|
2005-10-02 07:07:49 +00:00
|
|
|
def FSELS : AForm_1<63, 23,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F4RC:$FRT), (ins F8RC:$FRA, F4RC:$FRC, F4RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fsel $FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2005-10-25 20:55:47 +00:00
|
|
|
[(set F4RC:$FRT, (PPCfsel F8RC:$FRA,F4RC:$FRC,F4RC:$FRB))]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FADD : AForm_2<63, 21,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F8RC:$FRT), (ins F8RC:$FRA, F8RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fadd $FRT, $FRA, $FRB", FPGeneral,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F8RC:$FRT, (fadd F8RC:$FRA, F8RC:$FRB))]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FADDS : AForm_2<59, 21,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F4RC:$FRT), (ins F4RC:$FRA, F4RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fadds $FRT, $FRA, $FRB", FPGeneral,
|
2005-10-02 07:46:28 +00:00
|
|
|
[(set F4RC:$FRT, (fadd F4RC:$FRA, F4RC:$FRB))]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FDIV : AForm_2<63, 18,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F8RC:$FRT), (ins F8RC:$FRA, F8RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fdiv $FRT, $FRA, $FRB", FPDivD,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F8RC:$FRT, (fdiv F8RC:$FRA, F8RC:$FRB))]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FDIVS : AForm_2<59, 18,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F4RC:$FRT), (ins F4RC:$FRA, F4RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fdivs $FRT, $FRA, $FRB", FPDivS,
|
2005-10-02 07:46:28 +00:00
|
|
|
[(set F4RC:$FRT, (fdiv F4RC:$FRA, F4RC:$FRB))]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FMUL : AForm_3<63, 25,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F8RC:$FRT), (ins F8RC:$FRA, F8RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fmul $FRT, $FRA, $FRB", FPFused,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F8RC:$FRT, (fmul F8RC:$FRA, F8RC:$FRB))]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FMULS : AForm_3<59, 25,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F4RC:$FRT), (ins F4RC:$FRA, F4RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fmuls $FRT, $FRA, $FRB", FPGeneral,
|
2005-10-02 07:46:28 +00:00
|
|
|
[(set F4RC:$FRT, (fmul F4RC:$FRA, F4RC:$FRB))]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FSUB : AForm_2<63, 20,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F8RC:$FRT), (ins F8RC:$FRA, F8RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fsub $FRT, $FRA, $FRB", FPGeneral,
|
2005-10-01 01:35:02 +00:00
|
|
|
[(set F8RC:$FRT, (fsub F8RC:$FRA, F8RC:$FRB))]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def FSUBS : AForm_2<59, 20,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs F4RC:$FRT), (ins F4RC:$FRA, F4RC:$FRB),
|
2005-10-19 19:51:16 +00:00
|
|
|
"fsubs $FRT, $FRA, $FRB", FPGeneral,
|
2005-10-02 07:46:28 +00:00
|
|
|
[(set F4RC:$FRT, (fsub F4RC:$FRA, F4RC:$FRB))]>;
|
2006-03-12 09:13:49 +00:00
|
|
|
}
|
2004-08-30 02:28:06 +00:00
|
|
|
|
2006-03-12 09:13:49 +00:00
|
|
|
let PPC970_Unit = 1 in { // FXU Operations.
|
2004-08-31 02:28:08 +00:00
|
|
|
// M-Form instructions. rotate and mask instructions.
|
|
|
|
//
|
2006-11-15 23:24:18 +00:00
|
|
|
let isCommutable = 1 in {
|
2005-09-09 18:17:41 +00:00
|
|
|
// RLWIMI can be commuted if the rotate amount is zero.
|
2005-04-19 05:21:30 +00:00
|
|
|
def RLWIMI : MForm_2<20,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs GPRC:$rA), (ins GPRC:$rSi, GPRC:$rS, u5imm:$SH, u5imm:$MB,
|
2005-10-19 19:51:16 +00:00
|
|
|
u5imm:$ME), "rlwimi $rA, $rS, $SH, $MB, $ME", IntRotate,
|
2006-11-15 23:24:18 +00:00
|
|
|
[]>, PPC970_DGroup_Cracked, RegConstraint<"$rSi = $rA">,
|
|
|
|
NoEncode<"$rSi">;
|
2004-10-16 20:43:38 +00:00
|
|
|
}
|
2005-04-19 05:21:30 +00:00
|
|
|
def RLWINM : MForm_2<21,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs GPRC:$rA), (ins GPRC:$rS, u5imm:$SH, u5imm:$MB, u5imm:$ME),
|
2005-10-19 19:51:16 +00:00
|
|
|
"rlwinm $rA, $rS, $SH, $MB, $ME", IntGeneral,
|
2005-10-19 18:42:01 +00:00
|
|
|
[]>;
|
2005-04-19 05:21:30 +00:00
|
|
|
def RLWINMo : MForm_2<21,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs GPRC:$rA), (ins GPRC:$rS, u5imm:$SH, u5imm:$MB, u5imm:$ME),
|
2005-10-19 19:51:16 +00:00
|
|
|
"rlwinm. $rA, $rS, $SH, $MB, $ME", IntGeneral,
|
2006-03-13 05:15:10 +00:00
|
|
|
[]>, isDOT, PPC970_DGroup_Cracked;
|
2005-04-19 05:21:30 +00:00
|
|
|
def RLWNM : MForm_2<23,
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
(outs GPRC:$rA), (ins GPRC:$rS, GPRC:$rB, u5imm:$MB, u5imm:$ME),
|
2005-10-19 19:51:16 +00:00
|
|
|
"rlwnm $rA, $rS, $rB, $MB, $ME", IntGeneral,
|
2005-10-19 18:42:01 +00:00
|
|
|
[]>;
|
2006-03-12 09:13:49 +00:00
|
|
|
}
|
2004-08-31 02:28:08 +00:00
|
|
|
|
2006-03-20 06:15:45 +00:00
|
|
|
|
2005-12-16 22:45:29 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// DWARF Pseudo Instructions
|
|
|
|
//
|
|
|
|
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def DWARF_LOC : Pseudo<(outs), (ins i32imm:$line, i32imm:$col, i32imm:$file),
|
2006-09-27 02:55:21 +00:00
|
|
|
"${:comment} .loc $file, $line, $col",
|
2005-12-16 22:45:29 +00:00
|
|
|
[(dwarf_loc (i32 imm:$line), (i32 imm:$col),
|
2006-01-05 01:25:28 +00:00
|
|
|
(i32 imm:$file))]>;
|
|
|
|
|
2005-09-09 00:39:56 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Instruction Patterns
|
|
|
|
//
|
|
|
|
|
2005-09-26 22:20:16 +00: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-28 17:13:15 +00:00
|
|
|
|
|
|
|
// Implement the 'not' operation with the NOR instruction.
|
|
|
|
def NOT : Pat<(not GPRC:$in),
|
|
|
|
(NOR GPRC:$in, GPRC:$in)>;
|
|
|
|
|
2005-09-28 23:07:13 +00: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 00:39:56 +00:00
|
|
|
def : Pat<(or GPRC:$in, imm:$imm),
|
|
|
|
(ORIS (ORI GPRC:$in, (LO16 imm:$imm)), (HI16 imm:$imm))>;
|
2005-09-28 23:07:13 +00:00
|
|
|
// XOR an arbitrary immediate.
|
2005-09-09 00:39:56 +00:00
|
|
|
def : Pat<(xor GPRC:$in, imm:$imm),
|
|
|
|
(XORIS (XORI GPRC:$in, (LO16 imm:$imm)), (HI16 imm:$imm))>;
|
2006-02-17 05:43:56 +00:00
|
|
|
// SUBFIC
|
2006-03-17 22:41:37 +00:00
|
|
|
def : Pat<(sub immSExt16:$imm, GPRC:$in),
|
2006-02-17 05:43:56 +00:00
|
|
|
(SUBFIC GPRC:$in, imm:$imm)>;
|
2005-10-19 01:38:02 +00:00
|
|
|
|
2006-06-16 20:22:01 +00:00
|
|
|
// SHL/SRL
|
2005-12-05 02:34:05 +00:00
|
|
|
def : Pat<(shl GPRC:$in, (i32 imm:$imm)),
|
2005-10-19 18:42:01 +00:00
|
|
|
(RLWINM GPRC:$in, imm:$imm, 0, (SHL32 imm:$imm))>;
|
2005-12-05 02:34:05 +00:00
|
|
|
def : Pat<(srl GPRC:$in, (i32 imm:$imm)),
|
2005-10-19 18:42:01 +00:00
|
|
|
(RLWINM GPRC:$in, (SRL32 imm:$imm), imm:$imm, 31)>;
|
|
|
|
|
2006-01-11 21:21:00 +00:00
|
|
|
// ROTL
|
|
|
|
def : Pat<(rotl GPRC:$in, GPRC:$sh),
|
|
|
|
(RLWNM GPRC:$in, GPRC:$sh, 0, 31)>;
|
|
|
|
def : Pat<(rotl GPRC:$in, (i32 imm:$imm)),
|
|
|
|
(RLWINM GPRC:$in, imm:$imm, 0, 31)>;
|
2006-05-17 19:00:46 +00:00
|
|
|
|
2006-09-22 05:01:56 +00:00
|
|
|
// RLWNM
|
|
|
|
def : Pat<(and (rotl GPRC:$in, GPRC:$sh), maskimm32:$imm),
|
|
|
|
(RLWNM GPRC:$in, GPRC:$sh, (MB maskimm32:$imm), (ME maskimm32:$imm))>;
|
|
|
|
|
2006-05-17 19:00:46 +00:00
|
|
|
// Calls
|
2007-02-25 05:34:32 +00:00
|
|
|
def : Pat<(PPCcall_Macho (i32 tglobaladdr:$dst)),
|
|
|
|
(BL_Macho tglobaladdr:$dst)>;
|
2007-02-25 19:20:53 +00:00
|
|
|
def : Pat<(PPCcall_Macho (i32 texternalsym:$dst)),
|
|
|
|
(BL_Macho texternalsym:$dst)>;
|
2007-02-27 13:01:19 +00:00
|
|
|
def : Pat<(PPCcall_ELF (i32 tglobaladdr:$dst)),
|
2007-02-25 19:20:53 +00:00
|
|
|
(BL_ELF tglobaladdr:$dst)>;
|
2007-02-25 05:34:32 +00:00
|
|
|
def : Pat<(PPCcall_ELF (i32 texternalsym:$dst)),
|
2007-02-27 13:01:19 +00:00
|
|
|
(BL_ELF texternalsym:$dst)>;
|
2006-05-17 19:00:46 +00:00
|
|
|
|
2008-04-30 09:16:33 +00:00
|
|
|
|
|
|
|
def : Pat<(PPCtc_return (i32 tglobaladdr:$dst), imm:$imm),
|
|
|
|
(TCRETURNdi tglobaladdr:$dst, imm:$imm)>;
|
|
|
|
|
|
|
|
def : Pat<(PPCtc_return (i32 texternalsym:$dst), imm:$imm),
|
|
|
|
(TCRETURNdi texternalsym:$dst, imm:$imm)>;
|
|
|
|
|
|
|
|
def : Pat<(PPCtc_return CTRRC:$dst, imm:$imm),
|
|
|
|
(TCRETURNri CTRRC:$dst, imm:$imm)>;
|
|
|
|
|
|
|
|
|
|
|
|
|
2005-11-17 07:30:41 +00:00
|
|
|
// Hi and Lo for Darwin Global Addresses.
|
2005-12-11 07:45:47 +00:00
|
|
|
def : Pat<(PPChi tglobaladdr:$in, 0), (LIS tglobaladdr:$in)>;
|
|
|
|
def : Pat<(PPClo tglobaladdr:$in, 0), (LI tglobaladdr:$in)>;
|
|
|
|
def : Pat<(PPChi tconstpool:$in, 0), (LIS tconstpool:$in)>;
|
|
|
|
def : Pat<(PPClo tconstpool:$in, 0), (LI tconstpool:$in)>;
|
2006-04-22 18:53:45 +00:00
|
|
|
def : Pat<(PPChi tjumptable:$in, 0), (LIS tjumptable:$in)>;
|
|
|
|
def : Pat<(PPClo tjumptable:$in, 0), (LI tjumptable:$in)>;
|
2005-11-17 17:52:01 +00:00
|
|
|
def : Pat<(add GPRC:$in, (PPChi tglobaladdr:$g, 0)),
|
|
|
|
(ADDIS GPRC:$in, tglobaladdr:$g)>;
|
2005-12-10 02:36:00 +00:00
|
|
|
def : Pat<(add GPRC:$in, (PPChi tconstpool:$g, 0)),
|
|
|
|
(ADDIS GPRC:$in, tconstpool:$g)>;
|
2006-04-22 18:53:45 +00:00
|
|
|
def : Pat<(add GPRC:$in, (PPChi tjumptable:$g, 0)),
|
|
|
|
(ADDIS GPRC:$in, tjumptable:$g)>;
|
2005-11-17 07:30:41 +00:00
|
|
|
|
Use the new predicate support that Evan Cheng added to remove some code
from the DAGToDAG cpp file. This adds pattern support for vector and
scalar fma, which passes test/Regression/CodeGen/PowerPC/fma.ll, and
does the right thing in the presence of -disable-excess-fp-precision.
Allows us to match:
void %foo(<4 x float> * %a) {
entry:
%tmp1 = load <4 x float> * %a;
%tmp2 = mul <4 x float> %tmp1, %tmp1
%tmp3 = add <4 x float> %tmp2, %tmp1
store <4 x float> %tmp3, <4 x float> *%a
ret void
}
As:
_foo:
li r2, 0
lvx v0, r2, r3
vmaddfp v0, v0, v0, v0
stvx v0, r2, r3
blr
Or, with llc -disable-excess-fp-precision,
_foo:
li r2, 0
lvx v0, r2, r3
vxor v1, v1, v1
vmaddfp v1, v0, v0, v1
vaddfp v0, v1, v0
stvx v0, r2, r3
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24719 91177308-0d34-0410-b5e6-96231b3b80d8
2005-12-14 22:54:33 +00:00
|
|
|
// Fused negative multiply subtract, alternate pattern
|
|
|
|
def : Pat<(fsub F8RC:$B, (fmul F8RC:$A, F8RC:$C)),
|
|
|
|
(FNMSUB F8RC:$A, F8RC:$C, F8RC:$B)>,
|
|
|
|
Requires<[FPContractions]>;
|
|
|
|
def : Pat<(fsub F4RC:$B, (fmul F4RC:$A, F4RC:$C)),
|
|
|
|
(FNMSUBS F4RC:$A, F4RC:$C, F4RC:$B)>,
|
|
|
|
Requires<[FPContractions]>;
|
|
|
|
|
2005-12-06 02:10:38 +00:00
|
|
|
// Standard shifts. These are represented separately from the real shifts above
|
|
|
|
// so that we can distinguish between shifts that allow 5-bit and 6-bit shift
|
|
|
|
// amounts.
|
|
|
|
def : Pat<(sra GPRC:$rS, GPRC:$rB),
|
|
|
|
(SRAW GPRC:$rS, GPRC:$rB)>;
|
|
|
|
def : Pat<(srl GPRC:$rS, GPRC:$rB),
|
|
|
|
(SRW GPRC:$rS, GPRC:$rB)>;
|
|
|
|
def : Pat<(shl GPRC:$rS, GPRC:$rB),
|
|
|
|
(SLW GPRC:$rS, GPRC:$rB)>;
|
|
|
|
|
2006-10-09 20:57:25 +00:00
|
|
|
def : Pat<(zextloadi1 iaddr:$src),
|
2005-12-19 23:25:09 +00:00
|
|
|
(LBZ iaddr:$src)>;
|
2006-10-09 20:57:25 +00:00
|
|
|
def : Pat<(zextloadi1 xaddr:$src),
|
2005-12-19 23:25:09 +00:00
|
|
|
(LBZX xaddr:$src)>;
|
2006-10-09 20:57:25 +00:00
|
|
|
def : Pat<(extloadi1 iaddr:$src),
|
2005-12-19 23:25:09 +00:00
|
|
|
(LBZ iaddr:$src)>;
|
2006-10-09 20:57:25 +00:00
|
|
|
def : Pat<(extloadi1 xaddr:$src),
|
2005-12-19 23:25:09 +00:00
|
|
|
(LBZX xaddr:$src)>;
|
2006-10-09 20:57:25 +00:00
|
|
|
def : Pat<(extloadi8 iaddr:$src),
|
2005-12-19 23:25:09 +00:00
|
|
|
(LBZ iaddr:$src)>;
|
2006-10-09 20:57:25 +00:00
|
|
|
def : Pat<(extloadi8 xaddr:$src),
|
2005-12-19 23:25:09 +00:00
|
|
|
(LBZX xaddr:$src)>;
|
2006-10-09 20:57:25 +00:00
|
|
|
def : Pat<(extloadi16 iaddr:$src),
|
2005-12-19 23:25:09 +00:00
|
|
|
(LHZ iaddr:$src)>;
|
2006-10-09 20:57:25 +00:00
|
|
|
def : Pat<(extloadi16 xaddr:$src),
|
2005-12-19 23:25:09 +00:00
|
|
|
(LHZX xaddr:$src)>;
|
2006-10-09 20:57:25 +00:00
|
|
|
def : Pat<(extloadf32 iaddr:$src),
|
2005-12-19 23:25:09 +00:00
|
|
|
(FMRSD (LFS iaddr:$src))>;
|
2006-10-09 20:57:25 +00:00
|
|
|
def : Pat<(extloadf32 xaddr:$src),
|
2005-12-19 23:25:09 +00:00
|
|
|
(FMRSD (LFSX xaddr:$src))>;
|
|
|
|
|
2006-03-25 07:51:43 +00:00
|
|
|
include "PPCInstrAltivec.td"
|
2006-06-16 20:22:01 +00:00
|
|
|
include "PPCInstr64Bit.td"
|