2012-02-18 20:03:15 +08:00
|
|
|
//===-- PPCInstrInfo.td - The PowerPC Instruction Set ------*- tablegen -*-===//
|
|
|
|
//
|
2004-06-22 00:55:25 +08:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 04:36:04 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2012-02-18 20:03:15 +08:00
|
|
|
//
|
2004-06-22 00:55:25 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2004-08-10 01:24:04 +08:00
|
|
|
// This file describes the subset of the 32-bit PowerPC instruction set, as used
|
|
|
|
// by the PowerPC instruction selector.
|
2004-06-22 00:55:25 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2005-10-15 07:40:39 +08:00
|
|
|
include "PPCInstrFormats.td"
|
2004-06-22 00:55:25 +08:00
|
|
|
|
2006-03-01 13:50:56 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC specific type constraints.
|
|
|
|
//
|
|
|
|
def SDT_PPCstfiwx : SDTypeProfile<0, 2, [ // stfiwx
|
|
|
|
SDTCisVT<0, f64>, SDTCisPtrTy<1>
|
|
|
|
]>;
|
2013-04-02 01:52:07 +08:00
|
|
|
def SDT_PPClfiwx : SDTypeProfile<1, 1, [ // lfiw[az]x
|
2013-03-31 18:12:51 +08:00
|
|
|
SDTCisVT<0, f64>, SDTCisPtrTy<1>
|
|
|
|
]>;
|
|
|
|
|
2007-11-13 17:19:02 +08:00
|
|
|
def SDT_PPCCallSeqStart : SDCallSeqStart<[ SDTCisVT<0, i32> ]>;
|
|
|
|
def SDT_PPCCallSeqEnd : SDCallSeqEnd<[ SDTCisVT<0, i32>,
|
|
|
|
SDTCisVT<1, i32> ]>;
|
2006-03-20 09:53:53 +08:00
|
|
|
def SDT_PPCvperm : SDTypeProfile<1, 3, [
|
|
|
|
SDTCisVT<3, v16i8>, SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>
|
|
|
|
]>;
|
|
|
|
|
2006-03-31 13:13:27 +08:00
|
|
|
def SDT_PPCvcmp : SDTypeProfile<1, 3, [
|
2006-03-26 18:06:40 +08: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.
llvm-svn: 27804
2006-04-19 01:59:36 +08:00
|
|
|
def SDT_PPCcondbr : SDTypeProfile<0, 3, [
|
2006-11-18 06:37:34 +08: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.
llvm-svn: 27804
2006-04-19 01:59:36 +08:00
|
|
|
]>;
|
|
|
|
|
2009-09-26 04:36:54 +08:00
|
|
|
def SDT_PPClbrx : SDTypeProfile<1, 2, [
|
2013-03-29 03:25:55 +08:00
|
|
|
SDTCisInt<0>, SDTCisPtrTy<1>, SDTCisVT<2, OtherVT>
|
2006-07-11 04:56:58 +08:00
|
|
|
]>;
|
2009-09-26 04:36:54 +08:00
|
|
|
def SDT_PPCstbrx : SDTypeProfile<0, 3, [
|
2013-03-29 03:25:55 +08:00
|
|
|
SDTCisInt<0>, SDTCisPtrTy<1>, SDTCisVT<2, OtherVT>
|
2006-07-11 04:56:58 +08:00
|
|
|
]>;
|
|
|
|
|
2008-07-12 10:23:19 +08:00
|
|
|
def SDT_PPClarx : SDTypeProfile<1, 1, [
|
|
|
|
SDTCisInt<0>, SDTCisPtrTy<1>
|
2008-04-19 09:30:48 +08:00
|
|
|
]>;
|
2008-07-12 10:23:19 +08:00
|
|
|
def SDT_PPCstcx : SDTypeProfile<0, 2, [
|
|
|
|
SDTCisInt<0>, SDTCisPtrTy<1>
|
2008-04-19 09:30:48 +08:00
|
|
|
]>;
|
|
|
|
|
2008-04-30 17:16:33 +08:00
|
|
|
def SDT_PPCTC_ret : SDTypeProfile<0, 2, [
|
|
|
|
SDTCisPtrTy<0>, SDTCisVT<1, i32>
|
|
|
|
]>;
|
|
|
|
|
2009-08-15 19:54:46 +08:00
|
|
|
|
2005-10-26 04:41:46 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC specific DAG Nodes.
|
|
|
|
//
|
|
|
|
|
2013-04-03 12:01:11 +08:00
|
|
|
def PPCfre : SDNode<"PPCISD::FRE", SDTFPUnaryOp, []>;
|
|
|
|
def PPCfrsqrte: SDNode<"PPCISD::FRSQRTE", SDTFPUnaryOp, []>;
|
|
|
|
|
2013-04-02 01:52:07 +08:00
|
|
|
def PPCfcfid : SDNode<"PPCISD::FCFID", SDTFPUnaryOp, []>;
|
|
|
|
def PPCfcfidu : SDNode<"PPCISD::FCFIDU", SDTFPUnaryOp, []>;
|
|
|
|
def PPCfcfids : SDNode<"PPCISD::FCFIDS", SDTFPRoundOp, []>;
|
|
|
|
def PPCfcfidus: SDNode<"PPCISD::FCFIDUS", SDTFPRoundOp, []>;
|
2005-10-26 04:41:46 +08:00
|
|
|
def PPCfctidz : SDNode<"PPCISD::FCTIDZ", SDTFPUnaryOp, []>;
|
|
|
|
def PPCfctiwz : SDNode<"PPCISD::FCTIWZ", SDTFPUnaryOp, []>;
|
2013-04-02 01:52:07 +08:00
|
|
|
def PPCfctiduz: SDNode<"PPCISD::FCTIDUZ",SDTFPUnaryOp, []>;
|
|
|
|
def PPCfctiwuz: SDNode<"PPCISD::FCTIWUZ",SDTFPUnaryOp, []>;
|
2008-01-06 14:44:58 +08:00
|
|
|
def PPCstfiwx : SDNode<"PPCISD::STFIWX", SDT_PPCstfiwx,
|
|
|
|
[SDNPHasChain, SDNPMayStore]>;
|
2013-04-02 01:52:07 +08:00
|
|
|
def PPClfiwax : SDNode<"PPCISD::LFIWAX", SDT_PPClfiwx,
|
|
|
|
[SDNPHasChain, SDNPMayLoad]>;
|
|
|
|
def PPClfiwzx : SDNode<"PPCISD::LFIWZX", SDT_PPClfiwx,
|
2013-03-31 18:12:51 +08:00
|
|
|
[SDNPHasChain, SDNPMayLoad]>;
|
2005-10-26 04:41:46 +08:00
|
|
|
|
2013-03-26 18:56:22 +08:00
|
|
|
// Extract FPSCR (not modeled at the DAG level).
|
|
|
|
def PPCmffs : SDNode<"PPCISD::MFFS",
|
|
|
|
SDTypeProfile<1, 0, [SDTCisVT<0, f64>]>, []>;
|
|
|
|
|
|
|
|
// Perform FADD in round-to-zero mode.
|
|
|
|
def PPCfaddrtz: SDNode<"PPCISD::FADDRTZ", SDTFPBinOp, []>;
|
|
|
|
|
2007-10-10 09:01:31 +08:00
|
|
|
|
2005-10-26 04:55:47 +08: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-09 03:50:41 +08:00
|
|
|
|
2005-12-14 06:55:22 +08:00
|
|
|
def PPChi : SDNode<"PPCISD::Hi", SDTIntBinOp, []>;
|
|
|
|
def PPClo : SDNode<"PPCISD::Lo", SDTIntBinOp, []>;
|
2009-08-15 19:54:46 +08:00
|
|
|
def PPCtoc_entry: SDNode<"PPCISD::TOC_ENTRY", SDTIntBinOp, [SDNPMayLoad]>;
|
2005-12-14 06:55:22 +08:00
|
|
|
def PPCvmaddfp : SDNode<"PPCISD::VMADDFP", SDTFPTernaryOp, []>;
|
|
|
|
def PPCvnmsubfp : SDNode<"PPCISD::VNMSUBFP", SDTFPTernaryOp, []>;
|
2005-11-17 15:30:41 +08:00
|
|
|
|
This patch improves the 64-bit PowerPC InitialExec TLS support by providing
for a wider range of GOT entries that can hold thread-relative offsets.
This matches the behavior of GCC, which was not documented in the PPC64 TLS
ABI. The ABI will be updated with the new code sequence.
Former sequence:
ld 9,x@got@tprel(2)
add 9,9,x@tls
New sequence:
addis 9,2,x@got@tprel@ha
ld 9,x@got@tprel@l(9)
add 9,9,x@tls
Note that a linker optimization exists to transform the new sequence into
the shorter sequence when appropriate, by replacing the addis with a nop
and modifying the base register and relocation type of the ld.
llvm-svn: 170209
2012-12-15 01:02:38 +08:00
|
|
|
def PPCaddisGotTprelHA : SDNode<"PPCISD::ADDIS_GOT_TPREL_HA", SDTIntBinOp>;
|
|
|
|
def PPCldGotTprelL : SDNode<"PPCISD::LD_GOT_TPREL_L", SDTIntBinOp,
|
|
|
|
[SDNPMayLoad]>;
|
2012-12-05 00:18:08 +08:00
|
|
|
def PPCaddTls : SDNode<"PPCISD::ADD_TLS", SDTIntBinOp, []>;
|
This patch implements the general dynamic TLS model for 64-bit PowerPC.
Given a thread-local symbol x with global-dynamic access, the generated
code to obtain x's address is:
Instruction Relocation Symbol
addis ra,r2,x@got@tlsgd@ha R_PPC64_GOT_TLSGD16_HA x
addi r3,ra,x@got@tlsgd@l R_PPC64_GOT_TLSGD16_L x
bl __tls_get_addr(x@tlsgd) R_PPC64_TLSGD x
R_PPC64_REL24 __tls_get_addr
nop
<use address in r3>
The implementation borrows from the medium code model work for introducing
special forms of ADDIS and ADDI into the DAG representation. This is made
slightly more complicated by having to introduce a call to the external
function __tls_get_addr. Using the full call machinery is overkill and,
more importantly, makes it difficult to add a special relocation. So I've
introduced another opcode GET_TLS_ADDR to represent the function call, and
surrounded it with register copies to set up the parameter and return value.
Most of the code is pretty straightforward. I ran into one peculiarity
when I introduced a new PPC opcode BL8_NOP_ELF_TLSGD, which is just like
BL8_NOP_ELF except that it takes another parameter to represent the symbol
("x" above) that requires a relocation on the call. Something in the
TblGen machinery causes BL8_NOP_ELF and BL8_NOP_ELF_TLSGD to be treated
identically during the emit phase, so this second operand was never
visited to generate relocations. This is the reason for the slightly
messy workaround in PPCMCCodeEmitter.cpp:getDirectBrEncoding().
Two new tests are included to demonstrate correct external assembly and
correct generation of relocations using the integrated assembler.
Comments welcome!
Thanks,
Bill
llvm-svn: 169910
2012-12-12 04:30:11 +08:00
|
|
|
def PPCaddisTlsgdHA : SDNode<"PPCISD::ADDIS_TLSGD_HA", SDTIntBinOp>;
|
|
|
|
def PPCaddiTlsgdL : SDNode<"PPCISD::ADDI_TLSGD_L", SDTIntBinOp>;
|
|
|
|
def PPCgetTlsAddr : SDNode<"PPCISD::GET_TLS_ADDR", SDTIntBinOp>;
|
2012-12-13 03:29:35 +08:00
|
|
|
def PPCaddisTlsldHA : SDNode<"PPCISD::ADDIS_TLSLD_HA", SDTIntBinOp>;
|
|
|
|
def PPCaddiTlsldL : SDNode<"PPCISD::ADDI_TLSLD_L", SDTIntBinOp>;
|
|
|
|
def PPCgetTlsldAddr : SDNode<"PPCISD::GET_TLSLD_ADDR", SDTIntBinOp>;
|
|
|
|
def PPCaddisDtprelHA : SDNode<"PPCISD::ADDIS_DTPREL_HA", SDTIntBinOp,
|
|
|
|
[SDNPHasChain]>;
|
|
|
|
def PPCaddiDtprelL : SDNode<"PPCISD::ADDI_DTPREL_L", SDTIntBinOp>;
|
2012-12-05 00:18:08 +08:00
|
|
|
|
2006-03-20 09:53:53 +08:00
|
|
|
def PPCvperm : SDNode<"PPCISD::VPERM", SDT_PPCvperm, []>;
|
2006-03-19 14:55:52 +08:00
|
|
|
|
2005-12-06 10:10:38 +08: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-08 04:18:24 +08:00
|
|
|
def PPCsrl : SDNode<"PPCISD::SRL" , SDTIntShiftOp>;
|
|
|
|
def PPCsra : SDNode<"PPCISD::SRA" , SDTIntShiftOp>;
|
|
|
|
def PPCshl : SDNode<"PPCISD::SHL" , SDTIntShiftOp>;
|
2005-12-06 10:10:38 +08:00
|
|
|
|
2005-12-05 03:01:59 +08:00
|
|
|
// These are target-independent nodes, but have target-specific formats.
|
2007-11-13 17:19:02 +08:00
|
|
|
def callseq_start : SDNode<"ISD::CALLSEQ_START", SDT_PPCCallSeqStart,
|
2010-12-24 02:28:41 +08:00
|
|
|
[SDNPHasChain, SDNPOutGlue]>;
|
2007-11-13 17:19:02 +08:00
|
|
|
def callseq_end : SDNode<"ISD::CALLSEQ_END", SDT_PPCCallSeqEnd,
|
2010-12-24 02:28:41 +08:00
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
|
2005-12-05 03:01:59 +08:00
|
|
|
|
2006-06-28 02:36:44 +08:00
|
|
|
def SDT_PPCCall : SDTypeProfile<0, -1, [SDTCisInt<0>]>;
|
2013-03-22 23:24:13 +08:00
|
|
|
def PPCcall : SDNode<"PPCISD::CALL", SDT_PPCCall,
|
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPOutGlue,
|
|
|
|
SDNPVariadic]>;
|
|
|
|
def PPCcall_nop : SDNode<"PPCISD::CALL_NOP", SDT_PPCCall,
|
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPOutGlue,
|
|
|
|
SDNPVariadic]>;
|
2009-12-18 21:00:15 +08:00
|
|
|
def PPCload : SDNode<"PPCISD::LOAD", SDTypeProfile<1, 1, []>,
|
2010-12-24 02:28:41 +08:00
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
|
2009-12-18 21:00:15 +08:00
|
|
|
def PPCload_toc : SDNode<"PPCISD::LOAD_TOC", SDTypeProfile<0, 1, []>,
|
2012-08-24 22:43:27 +08:00
|
|
|
[SDNPHasChain, SDNPSideEffect,
|
|
|
|
SDNPInGlue, SDNPOutGlue]>;
|
2009-12-18 21:00:15 +08:00
|
|
|
def PPCtoc_restore : SDNode<"PPCISD::TOC_RESTORE", SDTypeProfile<0, 0, []>,
|
2012-08-24 22:43:27 +08:00
|
|
|
[SDNPHasChain, SDNPSideEffect,
|
|
|
|
SDNPInGlue, SDNPOutGlue]>;
|
2006-05-18 03:00:46 +08:00
|
|
|
def PPCmtctr : SDNode<"PPCISD::MTCTR", SDT_PPCCall,
|
2010-12-24 02:28:41 +08:00
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
|
2013-03-22 23:24:13 +08:00
|
|
|
def PPCbctrl : SDNode<"PPCISD::BCTRL", SDTNone,
|
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPOutGlue,
|
|
|
|
SDNPVariadic]>;
|
2006-05-17 14:01:33 +08:00
|
|
|
|
2008-01-16 06:02:54 +08:00
|
|
|
def retflag : SDNode<"PPCISD::RET_FLAG", SDTNone,
|
2010-12-24 02:28:41 +08:00
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>;
|
2005-12-20 08:26:01 +08:00
|
|
|
|
2008-04-30 17:16:33 +08:00
|
|
|
def PPCtc_return : SDNode<"PPCISD::TC_RETURN", SDT_PPCTC_ret,
|
2010-12-24 02:28:41 +08:00
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>;
|
2008-04-30 17:16:33 +08:00
|
|
|
|
2013-03-22 05:37:52 +08:00
|
|
|
def PPCeh_sjlj_setjmp : SDNode<"PPCISD::EH_SJLJ_SETJMP",
|
|
|
|
SDTypeProfile<1, 1, [SDTCisInt<0>,
|
|
|
|
SDTCisPtrTy<1>]>,
|
|
|
|
[SDNPHasChain, SDNPSideEffect]>;
|
|
|
|
def PPCeh_sjlj_longjmp : SDNode<"PPCISD::EH_SJLJ_LONGJMP",
|
|
|
|
SDTypeProfile<0, 1, [SDTCisPtrTy<0>]>,
|
|
|
|
[SDNPHasChain, SDNPSideEffect]>;
|
|
|
|
|
2013-05-15 03:35:45 +08:00
|
|
|
def SDT_PPCsc : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
|
|
|
|
def PPCsc : SDNode<"PPCISD::SC", SDT_PPCsc,
|
|
|
|
[SDNPHasChain, SDNPSideEffect]>;
|
|
|
|
|
2006-03-31 13:13:27 +08:00
|
|
|
def PPCvcmp : SDNode<"PPCISD::VCMP" , SDT_PPCvcmp, []>;
|
2010-12-24 02:28:41 +08:00
|
|
|
def PPCvcmp_o : SDNode<"PPCISD::VCMPo", SDT_PPCvcmp, [SDNPOutGlue]>;
|
2006-03-26 18:06:40 +08: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.
llvm-svn: 27804
2006-04-19 01:59:36 +08:00
|
|
|
def PPCcondbranch : SDNode<"PPCISD::COND_BRANCH", SDT_PPCcondbr,
|
2010-12-24 02:28:41 +08:00
|
|
|
[SDNPHasChain, SDNPOptInGlue]>;
|
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.
llvm-svn: 27804
2006-04-19 01:59:36 +08:00
|
|
|
|
2008-01-10 13:12:37 +08:00
|
|
|
def PPClbrx : SDNode<"PPCISD::LBRX", SDT_PPClbrx,
|
|
|
|
[SDNPHasChain, SDNPMayLoad]>;
|
2008-01-06 14:44:58 +08:00
|
|
|
def PPCstbrx : SDNode<"PPCISD::STBRX", SDT_PPCstbrx,
|
|
|
|
[SDNPHasChain, SDNPMayStore]>;
|
2006-07-11 04:56:58 +08:00
|
|
|
|
2012-08-28 10:10:27 +08:00
|
|
|
// Instructions to set/unset CR bit 6 for SVR4 vararg calls
|
|
|
|
def PPCcr6set : SDNode<"PPCISD::CR6SET", SDTNone,
|
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
|
|
|
|
def PPCcr6unset : SDNode<"PPCISD::CR6UNSET", SDTNone,
|
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
|
|
|
|
|
2008-07-12 10:23:19 +08:00
|
|
|
// Instructions to support atomic operations
|
2008-04-19 10:30:38 +08:00
|
|
|
def PPClarx : SDNode<"PPCISD::LARX", SDT_PPClarx,
|
|
|
|
[SDNPHasChain, SDNPMayLoad]>;
|
|
|
|
def PPCstcx : SDNode<"PPCISD::STCX", SDT_PPCstcx,
|
|
|
|
[SDNPHasChain, SDNPMayStore]>;
|
2008-04-19 09:30:48 +08:00
|
|
|
|
2013-02-22 01:12:27 +08:00
|
|
|
// Instructions to support medium and large code model
|
This patch implements medium code model support for 64-bit PowerPC.
The default for 64-bit PowerPC is small code model, in which TOC entries
must be addressable using a 16-bit offset from the TOC pointer. Additionally,
only TOC entries are addressed via the TOC pointer.
With medium code model, TOC entries and data sections can all be addressed
via the TOC pointer using a 32-bit offset. Cooperation with the linker
allows 16-bit offsets to be used when these are sufficient, reducing the
number of extra instructions that need to be executed. Medium code model
also does not generate explicit TOC entries in ".section toc" for variables
that are wholly internal to the compilation unit.
Consider a load of an external 4-byte integer. With small code model, the
compiler generates:
ld 3, .LC1@toc(2)
lwz 4, 0(3)
.section .toc,"aw",@progbits
.LC1:
.tc ei[TC],ei
With medium model, it instead generates:
addis 3, 2, .LC1@toc@ha
ld 3, .LC1@toc@l(3)
lwz 4, 0(3)
.section .toc,"aw",@progbits
.LC1:
.tc ei[TC],ei
Here .LC1@toc@ha is a relocation requesting the upper 16 bits of the
32-bit offset of ei's TOC entry from the TOC base pointer. Similarly,
.LC1@toc@l is a relocation requesting the lower 16 bits. Note that if
the linker determines that ei's TOC entry is within a 16-bit offset of
the TOC base pointer, it will replace the "addis" with a "nop", and
replace the "ld" with the identical "ld" instruction from the small
code model example.
Consider next a load of a function-scope static integer. For small code
model, the compiler generates:
ld 3, .LC1@toc(2)
lwz 4, 0(3)
.section .toc,"aw",@progbits
.LC1:
.tc test_fn_static.si[TC],test_fn_static.si
.type test_fn_static.si,@object
.local test_fn_static.si
.comm test_fn_static.si,4,4
For medium code model, the compiler generates:
addis 3, 2, test_fn_static.si@toc@ha
addi 3, 3, test_fn_static.si@toc@l
lwz 4, 0(3)
.type test_fn_static.si,@object
.local test_fn_static.si
.comm test_fn_static.si,4,4
Again, the linker may replace the "addis" with a "nop", calculating only
a 16-bit offset when this is sufficient.
Note that it would be more efficient for the compiler to generate:
addis 3, 2, test_fn_static.si@toc@ha
lwz 4, test_fn_static.si@toc@l(3)
The current patch does not perform this optimization yet. This will be
addressed as a peephole optimization in a later patch.
For the moment, the default code model for 64-bit PowerPC will remain the
small code model. We plan to eventually change the default to medium code
model, which matches current upstream GCC behavior. Note that the different
code models are ABI-compatible, so code compiled with different models will
be linked and execute correctly.
I've tested the regression suite and the application/benchmark test suite in
two ways: Once with the patch as submitted here, and once with additional
logic to force medium code model as the default. The tests all compile
cleanly, with one exception. The mandel-2 application test fails due to an
unrelated ABI compatibility with passing complex numbers. It just so happens
that small code model was incredibly lucky, in that temporary values in
floating-point registers held the expected values needed by the external
library routine that was called incorrectly. My current thought is to correct
the ABI problems with _Complex before making medium code model the default,
to avoid introducing this "regression."
Here are a few comments on how the patch works, since the selection code
can be difficult to follow:
The existing logic for small code model defines three pseudo-instructions:
LDtoc for most uses, LDtocJTI for jump table addresses, and LDtocCPT for
constant pool addresses. These are expanded by SelectCodeCommon(). The
pseudo-instruction approach doesn't work for medium code model, because
we need to generate two instructions when we match the same pattern.
Instead, new logic in PPCDAGToDAGISel::Select() intercepts the TOC_ENTRY
node for medium code model, and generates an ADDIStocHA followed by either
a LDtocL or an ADDItocL. These new node types correspond naturally to
the sequences described above.
The addis/ld sequence is generated for the following cases:
* Jump table addresses
* Function addresses
* External global variables
* Tentative definitions of global variables (common linkage)
The addis/addi sequence is generated for the following cases:
* Constant pool entries
* File-scope static global variables
* Function-scope static variables
Expanding to the two-instruction sequences at select time exposes the
instructions to subsequent optimization, particularly scheduling.
The rest of the processing occurs at assembly time, in
PPCAsmPrinter::EmitInstruction. Each of the instructions is converted to
a "real" PowerPC instruction. When a TOC entry needs to be created, this
is done here in the same manner as for the existing LDtoc, LDtocJTI, and
LDtocCPT pseudo-instructions (I factored out a new routine to handle this).
I had originally thought that if a TOC entry was needed for LDtocL or
ADDItocL, it would already have been generated for the previous ADDIStocHA.
However, at higher optimization levels, the ADDIStocHA may appear in a
different block, which may be assembled textually following the block
containing the LDtocL or ADDItocL. So it is necessary to include the
possibility of creating a new TOC entry for those two instructions.
Note that for LDtocL, we generate a new form of LD called LDrs. This
allows specifying the @toc@l relocation for the offset field of the LD
instruction (i.e., the offset is replaced by a SymbolLo relocation).
When the peephole optimization described above is added, we will need
to do similar things for all immediate-form load and store operations.
The seven "mcm-n.ll" test cases are kept separate because otherwise the
intermingling of various TOC entries and so forth makes the tests fragile
and hard to understand.
The above assumes use of an external assembler. For use of the
integrated assembler, new relocations are added and used by
PPCELFObjectWriter. Testing is done with "mcm-obj.ll", which tests for
proper generation of the various relocations for the same sequences
tested with the external assembler.
llvm-svn: 168708
2012-11-28 01:35:46 +08:00
|
|
|
def PPCaddisTocHA : SDNode<"PPCISD::ADDIS_TOC_HA", SDTIntBinOp, []>;
|
|
|
|
def PPCldTocL : SDNode<"PPCISD::LD_TOC_L", SDTIntBinOp, [SDNPMayLoad]>;
|
|
|
|
def PPCaddiTocL : SDNode<"PPCISD::ADDI_TOC_L", SDTIntBinOp, []>;
|
|
|
|
|
|
|
|
|
2006-11-17 06:43:37 +08:00
|
|
|
// Instructions to support dynamic alloca.
|
|
|
|
def SDTDynOp : SDTypeProfile<1, 2, []>;
|
|
|
|
def PPCdynalloc : SDNode<"PPCISD::DYNALLOC", SDTDynOp, [SDNPHasChain]>;
|
|
|
|
|
2005-09-09 03:50:41 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2005-09-09 08:39:56 +08:00
|
|
|
// PowerPC specific transformation functions and pattern fragments.
|
|
|
|
//
|
Woo, it kinda works. We now generate this atrociously bad, but correct,
code for long long foo(long long a, long long b) { return a + b; }
_foo:
or r2, r3, r3
or r3, r4, r4
or r4, r5, r5
or r5, r6, r6
rldicr r2, r2, 32, 31
rldicl r3, r3, 0, 32
rldicr r4, r4, 32, 31
rldicl r5, r5, 0, 32
or r2, r3, r2
or r3, r5, r4
add r4, r3, r2
rldicl r2, r4, 32, 32
or r4, r4, r4
or r3, r2, r2
blr
llvm-svn: 23809
2005-10-19 09:12:32 +08:00
|
|
|
|
2005-10-20 02:42:01 +08:00
|
|
|
def SHL32 : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: 31 - imm
|
2008-09-13 00:56:44 +08:00
|
|
|
return getI32Imm(31 - N->getZExtValue());
|
2005-10-20 02:42:01 +08:00
|
|
|
}]>;
|
|
|
|
|
|
|
|
def SRL32 : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: 32 - imm
|
2008-09-13 00:56:44 +08:00
|
|
|
return N->getZExtValue() ? getI32Imm(32 - N->getZExtValue()) : getI32Imm(0);
|
2005-10-20 02:42:01 +08:00
|
|
|
}]>;
|
|
|
|
|
2005-09-09 08:39:56 +08:00
|
|
|
def LO16 : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: get the low 16 bits.
|
2008-09-13 00:56:44 +08:00
|
|
|
return getI32Imm((unsigned short)N->getZExtValue());
|
2005-09-09 08:39:56 +08:00
|
|
|
}]>;
|
|
|
|
|
|
|
|
def HI16 : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: shift the immediate value down into the low bits.
|
2008-09-13 00:56:44 +08:00
|
|
|
return getI32Imm((unsigned)N->getZExtValue() >> 16);
|
2005-09-09 08:39:56 +08:00
|
|
|
}]>;
|
2005-09-09 01:33:10 +08:00
|
|
|
|
2005-09-29 07:07:13 +08:00
|
|
|
def HA16 : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: shift the immediate value down into the low bits.
|
2008-09-13 00:56:44 +08:00
|
|
|
signed int Val = N->getZExtValue();
|
2005-09-29 07:07:13 +08:00
|
|
|
return getI32Imm((Val - (signed short)Val) >> 16);
|
|
|
|
}]>;
|
2006-09-22 13:01:56 +08:00
|
|
|
def MB : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: get the start bit of a mask
|
2008-10-16 21:02:33 +08:00
|
|
|
unsigned mb = 0, me;
|
2008-09-13 00:56:44 +08:00
|
|
|
(void)isRunOfOnes((unsigned)N->getZExtValue(), mb, me);
|
2006-09-22 13:01:56 +08:00
|
|
|
return getI32Imm(mb);
|
|
|
|
}]>;
|
2005-09-29 07:07:13 +08:00
|
|
|
|
2006-09-22 13:01:56 +08:00
|
|
|
def ME : SDNodeXForm<imm, [{
|
|
|
|
// Transformation function: get the end bit of a mask
|
2008-10-16 21:02:33 +08:00
|
|
|
unsigned mb, me = 0;
|
2008-09-13 00:56:44 +08:00
|
|
|
(void)isRunOfOnes((unsigned)N->getZExtValue(), mb, me);
|
2006-09-22 13:01:56 +08:00
|
|
|
return getI32Imm(me);
|
|
|
|
}]>;
|
|
|
|
def maskimm32 : PatLeaf<(imm), [{
|
|
|
|
// maskImm predicate - True if immediate is a run of ones.
|
|
|
|
unsigned mb, me;
|
2009-08-12 04:47:22 +08:00
|
|
|
if (N->getValueType(0) == MVT::i32)
|
2008-09-13 00:56:44 +08:00
|
|
|
return isRunOfOnes((unsigned)N->getZExtValue(), mb, me);
|
2006-09-22 13:01:56 +08:00
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}]>;
|
2005-09-29 07:07:13 +08:00
|
|
|
|
Change some PowerPC PatLeaf definitions to ImmLeaf for fast-isel.
Using PatLeaf rather than ImmLeaf when defining immediate predicates
prevents simple patterns using those predicates from being recognized
for fast instruction selection. This patch replaces the immSExt16
PatLeaf predicate with two ImmLeaf predicates, imm32SExt16 and
imm64SExt16, allowing a few more patterns to be recognized (ADDI,
ADDIC, MULLI, ADDI8, and ADDIC8). Using the new predicates does not
help for LI, LI8, SUBFIC, and SUBFIC8 because these are rejected for
other reasons, but I see no reason to retain the PatLeaf predicate.
No functional change intended, and thus no test cases yet. This is
preliminary work for enabling fast-isel support for PowerPC. When
that support is ready, we'll be able to test this function.
llvm-svn: 182510
2013-05-23 04:09:24 +08:00
|
|
|
def imm32SExt16 : Operand<i32>, ImmLeaf<i32, [{
|
|
|
|
// imm32SExt16 predicate - True if the i32 immediate fits in a 16-bit
|
|
|
|
// sign extended field. Used by instructions like 'addi'.
|
|
|
|
return (int32_t)Imm == (short)Imm;
|
|
|
|
}]>;
|
|
|
|
def imm64SExt16 : Operand<i64>, ImmLeaf<i64, [{
|
|
|
|
// imm64SExt16 predicate - True if the i64 immediate fits in a 16-bit
|
|
|
|
// sign extended field. Used by instructions like 'addi'.
|
|
|
|
return (int64_t)Imm == (short)Imm;
|
2005-09-09 01:33:10 +08:00
|
|
|
}]>;
|
2005-09-09 01:40:49 +08:00
|
|
|
def immZExt16 : PatLeaf<(imm), [{
|
|
|
|
// immZExt16 predicate - True if the immediate fits in a 16-bit zero extended
|
|
|
|
// field. Used by instructions like 'ori'.
|
2008-09-13 00:56:44 +08:00
|
|
|
return (uint64_t)N->getZExtValue() == (unsigned short)N->getZExtValue();
|
2005-09-09 08:39:56 +08: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
llvm-svn: 28883
2006-06-21 06:34:10 +08: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'.
|
2008-09-13 00:56:44 +08:00
|
|
|
return (N->getZExtValue() & ~uint64_t(0xFFFF0000)) == 0;
|
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
llvm-svn: 28883
2006-06-21 06:34:10 +08:00
|
|
|
}], 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.
|
2008-09-13 00:56:44 +08:00
|
|
|
if (N->getZExtValue() & 0xFFFF) return false;
|
2009-08-12 04:47:22 +08:00
|
|
|
if (N->getValueType(0) == MVT::i32)
|
2006-06-21 05:39:30 +08:00
|
|
|
return true;
|
|
|
|
// For 64-bit, make sure it is sext right.
|
2008-09-13 00:56:44 +08:00
|
|
|
return N->getZExtValue() == (uint64_t)(int)N->getZExtValue();
|
2005-09-09 08:39:56 +08:00
|
|
|
}], HI16>;
|
2005-09-09 01:33:10 +08:00
|
|
|
|
2013-03-19 07:00:58 +08:00
|
|
|
// Some r+i load/store instructions (such as LD, STD, LDU, etc.) that require
|
2013-05-17 01:58:02 +08:00
|
|
|
// restricted memrix (4-aligned) constants are alignment sensitive. If these
|
2013-03-19 07:00:58 +08:00
|
|
|
// offsets are hidden behind TOC entries than the values of the lower-order
|
|
|
|
// bits cannot be checked directly. As a result, we need to also incorporate
|
|
|
|
// an alignment check into the relevant patterns.
|
|
|
|
|
|
|
|
def aligned4load : PatFrag<(ops node:$ptr), (load node:$ptr), [{
|
|
|
|
return cast<LoadSDNode>(N)->getAlignment() >= 4;
|
|
|
|
}]>;
|
|
|
|
def aligned4store : PatFrag<(ops node:$val, node:$ptr),
|
|
|
|
(store node:$val, node:$ptr), [{
|
|
|
|
return cast<StoreSDNode>(N)->getAlignment() >= 4;
|
|
|
|
}]>;
|
|
|
|
def aligned4sextloadi32 : PatFrag<(ops node:$ptr), (sextloadi32 node:$ptr), [{
|
|
|
|
return cast<LoadSDNode>(N)->getAlignment() >= 4;
|
|
|
|
}]>;
|
|
|
|
def aligned4pre_store : PatFrag<
|
|
|
|
(ops node:$val, node:$base, node:$offset),
|
|
|
|
(pre_store node:$val, node:$base, node:$offset), [{
|
|
|
|
return cast<StoreSDNode>(N)->getAlignment() >= 4;
|
|
|
|
}]>;
|
|
|
|
|
|
|
|
def unaligned4load : PatFrag<(ops node:$ptr), (load node:$ptr), [{
|
|
|
|
return cast<LoadSDNode>(N)->getAlignment() < 4;
|
|
|
|
}]>;
|
|
|
|
def unaligned4store : PatFrag<(ops node:$val, node:$ptr),
|
|
|
|
(store node:$val, node:$ptr), [{
|
|
|
|
return cast<StoreSDNode>(N)->getAlignment() < 4;
|
|
|
|
}]>;
|
|
|
|
def unaligned4sextloadi32 : PatFrag<(ops node:$ptr), (sextloadi32 node:$ptr), [{
|
|
|
|
return cast<LoadSDNode>(N)->getAlignment() < 4;
|
|
|
|
}]>;
|
2006-03-25 14:12:06 +08:00
|
|
|
|
2005-09-09 03:50:41 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Flag Definitions.
|
|
|
|
|
2005-04-19 12:32:54 +08:00
|
|
|
class isPPC64 { bit PPC64 = 1; }
|
2013-04-13 02:17:57 +08:00
|
|
|
class isDOT { bit RC = 1; }
|
2005-04-19 12:32:54 +08:00
|
|
|
|
2006-11-08 10:13:12 +08:00
|
|
|
class RegConstraint<string C> {
|
|
|
|
string Constraints = C;
|
|
|
|
}
|
2006-11-16 07:24:18 +08:00
|
|
|
class NoEncode<string E> {
|
|
|
|
string DisableEncoding = E;
|
|
|
|
}
|
2005-09-09 03:50:41 +08:00
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Operand Definitions.
|
2004-08-15 07:27:29 +08:00
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
// In the default PowerPC assembler syntax, registers are specified simply
|
|
|
|
// by number, so they cannot be distinguished from immediate values (without
|
|
|
|
// looking at the opcode). This means that the default operand matching logic
|
|
|
|
// for the asm parser does not work, and we need to specify custom matchers.
|
|
|
|
// Since those can only be specified with RegisterOperand classes and not
|
|
|
|
// directly on the RegisterClass, all instructions patterns used by the asm
|
|
|
|
// parser need to use a RegisterOperand (instead of a RegisterClass) for
|
|
|
|
// all their register operands.
|
|
|
|
// For this purpose, we define one RegisterOperand for each RegisterClass,
|
|
|
|
// using the same name as the class, just in lower case.
|
|
|
|
|
2013-05-04 03:49:39 +08:00
|
|
|
def PPCRegGPRCAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "RegGPRC"; let PredicateMethod = "isRegNumber";
|
|
|
|
}
|
|
|
|
def gprc : RegisterOperand<GPRC> {
|
|
|
|
let ParserMatchClass = PPCRegGPRCAsmOperand;
|
|
|
|
}
|
|
|
|
def PPCRegG8RCAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "RegG8RC"; let PredicateMethod = "isRegNumber";
|
|
|
|
}
|
|
|
|
def g8rc : RegisterOperand<G8RC> {
|
|
|
|
let ParserMatchClass = PPCRegG8RCAsmOperand;
|
|
|
|
}
|
|
|
|
def PPCRegGPRCNoR0AsmOperand : AsmOperandClass {
|
|
|
|
let Name = "RegGPRCNoR0"; let PredicateMethod = "isRegNumber";
|
|
|
|
}
|
|
|
|
def gprc_nor0 : RegisterOperand<GPRC_NOR0> {
|
|
|
|
let ParserMatchClass = PPCRegGPRCNoR0AsmOperand;
|
|
|
|
}
|
|
|
|
def PPCRegG8RCNoX0AsmOperand : AsmOperandClass {
|
|
|
|
let Name = "RegG8RCNoX0"; let PredicateMethod = "isRegNumber";
|
|
|
|
}
|
|
|
|
def g8rc_nox0 : RegisterOperand<G8RC_NOX0> {
|
|
|
|
let ParserMatchClass = PPCRegG8RCNoX0AsmOperand;
|
|
|
|
}
|
|
|
|
def PPCRegF8RCAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "RegF8RC"; let PredicateMethod = "isRegNumber";
|
|
|
|
}
|
|
|
|
def f8rc : RegisterOperand<F8RC> {
|
|
|
|
let ParserMatchClass = PPCRegF8RCAsmOperand;
|
|
|
|
}
|
|
|
|
def PPCRegF4RCAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "RegF4RC"; let PredicateMethod = "isRegNumber";
|
|
|
|
}
|
|
|
|
def f4rc : RegisterOperand<F4RC> {
|
|
|
|
let ParserMatchClass = PPCRegF4RCAsmOperand;
|
|
|
|
}
|
|
|
|
def PPCRegVRRCAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "RegVRRC"; let PredicateMethod = "isRegNumber";
|
|
|
|
}
|
|
|
|
def vrrc : RegisterOperand<VRRC> {
|
|
|
|
let ParserMatchClass = PPCRegVRRCAsmOperand;
|
|
|
|
}
|
|
|
|
def PPCRegCRBITRCAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "RegCRBITRC"; let PredicateMethod = "isRegNumber";
|
|
|
|
}
|
|
|
|
def crbitrc : RegisterOperand<CRBITRC> {
|
|
|
|
let ParserMatchClass = PPCRegCRBITRCAsmOperand;
|
|
|
|
}
|
|
|
|
def PPCRegCRRCAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "RegCRRC"; let PredicateMethod = "isCCRegNumber";
|
|
|
|
}
|
|
|
|
def crrc : RegisterOperand<CRRC> {
|
|
|
|
let ParserMatchClass = PPCRegCRRCAsmOperand;
|
|
|
|
}
|
|
|
|
|
|
|
|
def PPCS5ImmAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "S5Imm"; let PredicateMethod = "isS5Imm";
|
|
|
|
let RenderMethod = "addImmOperands";
|
|
|
|
}
|
2006-03-25 14:12:06 +08:00
|
|
|
def s5imm : Operand<i32> {
|
|
|
|
let PrintMethod = "printS5ImmOperand";
|
2013-05-04 03:49:39 +08:00
|
|
|
let ParserMatchClass = PPCS5ImmAsmOperand;
|
|
|
|
}
|
|
|
|
def PPCU5ImmAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "U5Imm"; let PredicateMethod = "isU5Imm";
|
|
|
|
let RenderMethod = "addImmOperands";
|
2006-03-25 14:12:06 +08:00
|
|
|
}
|
2005-09-15 04:53:05 +08:00
|
|
|
def u5imm : Operand<i32> {
|
2004-08-21 13:56:39 +08:00
|
|
|
let PrintMethod = "printU5ImmOperand";
|
2013-05-04 03:49:39 +08:00
|
|
|
let ParserMatchClass = PPCU5ImmAsmOperand;
|
|
|
|
}
|
|
|
|
def PPCU6ImmAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "U6Imm"; let PredicateMethod = "isU6Imm";
|
|
|
|
let RenderMethod = "addImmOperands";
|
2004-08-21 13:56:39 +08:00
|
|
|
}
|
2005-09-15 04:53:05 +08:00
|
|
|
def u6imm : Operand<i32> {
|
2004-08-30 10:28:06 +08:00
|
|
|
let PrintMethod = "printU6ImmOperand";
|
2013-05-04 03:49:39 +08:00
|
|
|
let ParserMatchClass = PPCU6ImmAsmOperand;
|
|
|
|
}
|
|
|
|
def PPCS16ImmAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "S16Imm"; let PredicateMethod = "isS16Imm";
|
|
|
|
let RenderMethod = "addImmOperands";
|
2004-08-30 10:28:06 +08:00
|
|
|
}
|
2005-09-15 04:53:05 +08:00
|
|
|
def s16imm : Operand<i32> {
|
2004-09-04 13:00:00 +08:00
|
|
|
let PrintMethod = "printS16ImmOperand";
|
2013-05-04 03:49:39 +08:00
|
|
|
let ParserMatchClass = PPCS16ImmAsmOperand;
|
|
|
|
}
|
|
|
|
def PPCU16ImmAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "U16Imm"; let PredicateMethod = "isU16Imm";
|
|
|
|
let RenderMethod = "addImmOperands";
|
2004-09-04 13:00:00 +08:00
|
|
|
}
|
2005-09-15 04:53:05 +08:00
|
|
|
def u16imm : Operand<i32> {
|
2004-08-15 13:20:16 +08:00
|
|
|
let PrintMethod = "printU16ImmOperand";
|
2013-05-04 03:49:39 +08:00
|
|
|
let ParserMatchClass = PPCU16ImmAsmOperand;
|
2004-08-15 13:20:16 +08:00
|
|
|
}
|
2010-11-15 14:09:35 +08:00
|
|
|
def directbrtarget : Operand<OtherVT> {
|
2004-09-02 16:13:00 +08:00
|
|
|
let PrintMethod = "printBranchOperand";
|
2010-11-15 14:09:35 +08:00
|
|
|
let EncoderMethod = "getDirectBrEncoding";
|
|
|
|
}
|
|
|
|
def condbrtarget : Operand<OtherVT> {
|
2010-11-16 09:45:05 +08:00
|
|
|
let PrintMethod = "printBranchOperand";
|
2010-11-15 14:09:35 +08:00
|
|
|
let EncoderMethod = "getCondBrEncoding";
|
2004-09-02 16:13:00 +08:00
|
|
|
}
|
2006-06-17 05:01:35 +08:00
|
|
|
def calltarget : Operand<iPTR> {
|
2010-11-15 14:09:35 +08:00
|
|
|
let EncoderMethod = "getDirectBrEncoding";
|
2005-11-18 03:16:08 +08:00
|
|
|
}
|
2006-06-17 05:01:35 +08:00
|
|
|
def aaddr : Operand<iPTR> {
|
2005-11-16 08:48:01 +08:00
|
|
|
let PrintMethod = "printAbsAddrOperand";
|
|
|
|
}
|
2004-09-04 13:00:00 +08:00
|
|
|
def symbolHi: Operand<i32> {
|
2013-05-24 06:26:41 +08:00
|
|
|
let PrintMethod = "printS16ImmOperand";
|
2013-05-17 22:14:12 +08:00
|
|
|
let EncoderMethod = "getS16ImmEncoding";
|
2013-05-04 03:49:39 +08:00
|
|
|
let ParserMatchClass = PPCS16ImmAsmOperand;
|
2004-09-04 13:00:00 +08:00
|
|
|
}
|
|
|
|
def symbolLo: Operand<i32> {
|
2013-05-24 06:26:41 +08:00
|
|
|
let PrintMethod = "printS16ImmOperand";
|
2013-05-17 22:14:12 +08:00
|
|
|
let EncoderMethod = "getS16ImmEncoding";
|
2013-05-04 03:49:39 +08:00
|
|
|
let ParserMatchClass = PPCS16ImmAsmOperand;
|
|
|
|
}
|
|
|
|
def PPCCRBitMaskOperand : AsmOperandClass {
|
|
|
|
let Name = "CRBitMask"; let PredicateMethod = "isCRBitMask";
|
2004-09-04 13:00:00 +08:00
|
|
|
}
|
2005-07-21 06:42:00 +08:00
|
|
|
def crbitm: Operand<i8> {
|
|
|
|
let PrintMethod = "printcrbitm";
|
2010-11-15 13:19:25 +08:00
|
|
|
let EncoderMethod = "get_crbitm_encoding";
|
2013-05-04 03:49:39 +08:00
|
|
|
let ParserMatchClass = PPCCRBitMaskOperand;
|
2005-07-21 06:42:00 +08:00
|
|
|
}
|
2005-12-20 07:25:09 +08:00
|
|
|
// Address operands
|
Prepare to make r0 an allocatable register on PPC
Currently the PPC r0 register is unconditionally reserved. There are two reasons
for this:
1. r0 is treated specially (as the constant 0) by certain instructions, and so
cannot be used with those instructions as a regular register.
2. r0 is used as a temporary register in the CR-register spilling process
(where, under some circumstances, we require two GPRs).
This change addresses the first reason by introducing a restricted register
class (without r0) for use by those instructions that treat r0 specially. These
register classes have a new pseudo-register, ZERO, which represents the r0-as-0
use. This has the side benefit of making the existing target code simpler (and
easier to understand), and will make it clear to the register allocator that
uses of r0 as 0 don't conflict will real uses of the r0 register.
Once the CR spilling code is improved, we'll be able to allocate r0.
Adding these extra register classes, for some reason unclear to me, causes
requests to the target to copy 32-bit registers to 64-bit registers. The
resulting code seems correct (and causes no test-suite failures), and the new
test case covers this new kind of asymmetric copy.
As r0 is still reserved, no functionality change intended.
llvm-svn: 177423
2013-03-20 02:51:05 +08:00
|
|
|
// A version of ptr_rc which excludes R0 (or X0 in 64-bit mode).
|
2013-05-04 03:49:39 +08:00
|
|
|
def PPCRegGxRCNoR0Operand : AsmOperandClass {
|
|
|
|
let Name = "RegGxRCNoR0"; let PredicateMethod = "isRegNumber";
|
|
|
|
}
|
|
|
|
def ptr_rc_nor0 : Operand<iPTR>, PointerLikeRegClass<1> {
|
|
|
|
let ParserMatchClass = PPCRegGxRCNoR0Operand;
|
|
|
|
}
|
|
|
|
// A version of ptr_rc usable with the asm parser.
|
|
|
|
def PPCRegGxRCOperand : AsmOperandClass {
|
|
|
|
let Name = "RegGxRC"; let PredicateMethod = "isRegNumber";
|
|
|
|
}
|
|
|
|
def ptr_rc_idx : Operand<iPTR>, PointerLikeRegClass<0> {
|
|
|
|
let ParserMatchClass = PPCRegGxRCOperand;
|
|
|
|
}
|
Prepare to make r0 an allocatable register on PPC
Currently the PPC r0 register is unconditionally reserved. There are two reasons
for this:
1. r0 is treated specially (as the constant 0) by certain instructions, and so
cannot be used with those instructions as a regular register.
2. r0 is used as a temporary register in the CR-register spilling process
(where, under some circumstances, we require two GPRs).
This change addresses the first reason by introducing a restricted register
class (without r0) for use by those instructions that treat r0 specially. These
register classes have a new pseudo-register, ZERO, which represents the r0-as-0
use. This has the side benefit of making the existing target code simpler (and
easier to understand), and will make it clear to the register allocator that
uses of r0 as 0 don't conflict will real uses of the r0 register.
Once the CR spilling code is improved, we'll be able to allocate r0.
Adding these extra register classes, for some reason unclear to me, causes
requests to the target to copy 32-bit registers to 64-bit registers. The
resulting code seems correct (and causes no test-suite failures), and the new
test case covers this new kind of asymmetric copy.
As r0 is still reserved, no functionality change intended.
llvm-svn: 177423
2013-03-20 02:51:05 +08:00
|
|
|
|
2013-05-04 03:49:39 +08:00
|
|
|
def PPCDispRIOperand : AsmOperandClass {
|
|
|
|
let Name = "DispRI"; let PredicateMethod = "isS16Imm";
|
2013-05-17 01:58:02 +08:00
|
|
|
let RenderMethod = "addImmOperands";
|
2013-05-04 03:49:39 +08:00
|
|
|
}
|
|
|
|
def dispRI : Operand<iPTR> {
|
|
|
|
let ParserMatchClass = PPCDispRIOperand;
|
|
|
|
}
|
|
|
|
def PPCDispRIXOperand : AsmOperandClass {
|
|
|
|
let Name = "DispRIX"; let PredicateMethod = "isS16ImmX4";
|
2013-05-17 01:58:02 +08:00
|
|
|
let RenderMethod = "addImmOperands";
|
2013-05-04 03:49:39 +08:00
|
|
|
}
|
|
|
|
def dispRIX : Operand<iPTR> {
|
|
|
|
let ParserMatchClass = PPCDispRIXOperand;
|
|
|
|
}
|
2013-03-26 18:55:45 +08:00
|
|
|
|
2006-06-17 05:01:35 +08:00
|
|
|
def memri : Operand<iPTR> {
|
2005-12-20 07:25:09 +08:00
|
|
|
let PrintMethod = "printMemRegImm";
|
2013-03-26 18:55:45 +08:00
|
|
|
let MIOperandInfo = (ops dispRI:$imm, ptr_rc_nor0:$reg);
|
split out an encoder for memri operands, allowing a relocation to be plopped
into the immediate field. This allows us to encode stuff like this:
lbz r3, lo16(__ZL4init)(r4) ; globalopt.cpp:5
; encoding: [0x88,0x64,A,A]
; fixup A - offset: 0, value: lo16(__ZL4init), kind: fixup_ppc_lo16
stw r3, lo16(__ZL1s)(r5) ; globalopt.cpp:6
; encoding: [0x90,0x65,A,A]
; fixup A - offset: 0, value: lo16(__ZL1s), kind: fixup_ppc_lo16
With this, we should have a completely function MCCodeEmitter for PPC, wewt.
llvm-svn: 119134
2010-11-15 16:22:03 +08:00
|
|
|
let EncoderMethod = "getMemRIEncoding";
|
2005-12-20 07:25:09 +08:00
|
|
|
}
|
2006-06-17 05:01:35 +08:00
|
|
|
def memrr : Operand<iPTR> {
|
2005-12-20 07:25:09 +08:00
|
|
|
let PrintMethod = "printMemRegReg";
|
2013-05-04 03:49:39 +08:00
|
|
|
let MIOperandInfo = (ops ptr_rc_nor0:$ptrreg, ptr_rc_idx:$offreg);
|
2005-12-20 07:25:09 +08:00
|
|
|
}
|
2013-05-17 01:58:02 +08:00
|
|
|
def memrix : Operand<iPTR> { // memri where the imm is 4-aligned.
|
|
|
|
let PrintMethod = "printMemRegImm";
|
2013-03-26 18:55:45 +08:00
|
|
|
let MIOperandInfo = (ops dispRIX:$imm, ptr_rc_nor0:$reg);
|
2010-11-15 16:02:41 +08:00
|
|
|
let EncoderMethod = "getMemRIXEncoding";
|
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).
llvm-svn: 26943
2006-03-22 13:30:33 +08:00
|
|
|
}
|
2005-12-20 07:25:09 +08:00
|
|
|
|
2013-03-22 05:37:52 +08:00
|
|
|
// A single-register address. This is used with the SjLj
|
|
|
|
// pseudo-instructions.
|
|
|
|
def memr : Operand<iPTR> {
|
|
|
|
let MIOperandInfo = (ops ptr_rc:$ptrreg);
|
|
|
|
}
|
|
|
|
|
2013-03-26 18:53:27 +08:00
|
|
|
// PowerPC Predicate operand.
|
|
|
|
def pred : Operand<OtherVT> {
|
2006-11-04 13:27:39 +08:00
|
|
|
let PrintMethod = "printPredicateOperand";
|
2013-04-27 00:53:15 +08:00
|
|
|
let MIOperandInfo = (ops i32imm:$bibo, crrc:$reg);
|
2006-11-04 13:27:39 +08:00
|
|
|
}
|
2006-11-04 07:53:25 +08:00
|
|
|
|
2006-01-12 10:05:36 +08:00
|
|
|
// Define PowerPC specific addressing mode.
|
2006-10-12 05:03:53 +08:00
|
|
|
def iaddr : ComplexPattern<iPTR, 2, "SelectAddrImm", [], []>;
|
|
|
|
def xaddr : ComplexPattern<iPTR, 2, "SelectAddrIdx", [], []>;
|
|
|
|
def xoaddr : ComplexPattern<iPTR, 2, "SelectAddrIdxOnly",[], []>;
|
2013-05-17 01:58:02 +08:00
|
|
|
def ixaddr : ComplexPattern<iPTR, 2, "SelectAddrImmX4", [], []>; // "std"
|
2004-08-15 13:20:16 +08:00
|
|
|
|
2013-03-22 05:37:52 +08:00
|
|
|
// The address in a single register. This is used with the SjLj
|
|
|
|
// pseudo-instructions.
|
|
|
|
def addr : ComplexPattern<iPTR, 1, "SelectAddr",[], []>;
|
|
|
|
|
2006-11-16 08:41:37 +08:00
|
|
|
/// This is just the offset part of iaddr, used for preinc.
|
|
|
|
def iaddroff : ComplexPattern<iPTR, 1, "SelectAddrImmOffs", [], []>;
|
2006-11-15 10:43:19 +08:00
|
|
|
|
2005-12-15 06:07:12 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Instruction Predicate Definitions.
|
2007-10-23 14:42:42 +08:00
|
|
|
def In32BitMode : Predicate<"!PPCSubTarget.isPPC64()">;
|
|
|
|
def In64BitMode : Predicate<"PPCSubTarget.isPPC64()">;
|
2011-10-17 12:03:49 +08:00
|
|
|
def IsBookE : Predicate<"PPCSubTarget.isBookE()">;
|
2006-11-15 02:44:47 +08:00
|
|
|
|
2013-04-12 10:18:09 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Multiclass Definitions.
|
|
|
|
|
|
|
|
multiclass XForm_6r<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
def NAME : XForm_6<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CR0] in
|
|
|
|
def o : XForm_6<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
|
|
|
[]>, isDOT, RecFormRel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass XForm_6rc<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
let Defs = [CARRY] in
|
|
|
|
def NAME : XForm_6<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
|
|
|
let Defs = [CARRY, CR0] in
|
2013-04-12 10:18:09 +08:00
|
|
|
def o : XForm_6<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
|
|
|
[]>, isDOT, RecFormRel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass XForm_10r<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
def NAME : XForm_10<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CR0] in
|
|
|
|
def o : XForm_10<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
|
|
|
[]>, isDOT, RecFormRel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass XForm_10rc<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
let Defs = [CARRY] in
|
|
|
|
def NAME : XForm_10<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
|
|
|
let Defs = [CARRY, CR0] in
|
2013-04-12 10:18:09 +08:00
|
|
|
def o : XForm_10<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
|
|
|
[]>, isDOT, RecFormRel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass XForm_11r<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
def NAME : XForm_11<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CR0] in
|
2013-04-12 10:18:09 +08:00
|
|
|
def o : XForm_11<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
|
|
|
[]>, isDOT, RecFormRel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass XOForm_1r<bits<6> opcode, bits<9> xo, bit oe, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
def NAME : XOForm_1<opcode, xo, oe, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CR0] in
|
|
|
|
def o : XOForm_1<opcode, xo, oe, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
|
|
|
[]>, isDOT, RecFormRel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass XOForm_1rc<bits<6> opcode, bits<9> xo, bit oe, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
let Defs = [CARRY] in
|
|
|
|
def NAME : XOForm_1<opcode, xo, oe, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
|
|
|
let Defs = [CARRY, CR0] in
|
2013-04-12 10:18:09 +08:00
|
|
|
def o : XOForm_1<opcode, xo, oe, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
|
|
|
[]>, isDOT, RecFormRel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass XOForm_3r<bits<6> opcode, bits<9> xo, bit oe, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
def NAME : XOForm_3<opcode, xo, oe, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CR0] in
|
|
|
|
def o : XOForm_3<opcode, xo, oe, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
|
|
|
[]>, isDOT, RecFormRel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass XOForm_3rc<bits<6> opcode, bits<9> xo, bit oe, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
let Defs = [CARRY] in
|
|
|
|
def NAME : XOForm_3<opcode, xo, oe, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
|
|
|
let Defs = [CARRY, CR0] in
|
2013-04-12 10:18:09 +08:00
|
|
|
def o : XOForm_3<opcode, xo, oe, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
|
|
|
[]>, isDOT, RecFormRel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass MForm_2r<bits<6> opcode, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
def NAME : MForm_2<opcode, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CR0] in
|
2013-04-12 10:18:09 +08:00
|
|
|
def o : MForm_2<opcode, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
|
|
|
[]>, isDOT, RecFormRel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass MDForm_1r<bits<6> opcode, bits<3> xo, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
def NAME : MDForm_1<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CR0] in
|
2013-04-12 10:18:09 +08:00
|
|
|
def o : MDForm_1<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
|
|
|
[]>, isDOT, RecFormRel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-26 23:39:12 +08:00
|
|
|
multiclass MDSForm_1r<bits<6> opcode, bits<4> xo, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
def NAME : MDSForm_1<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
|
|
|
let Defs = [CR0] in
|
|
|
|
def o : MDSForm_1<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
|
|
|
[]>, isDOT, RecFormRel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-13 02:17:57 +08:00
|
|
|
multiclass XSForm_1rc<bits<6> opcode, bits<9> xo, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
2013-04-12 10:18:09 +08:00
|
|
|
let BaseName = asmbase in {
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CARRY] in
|
2013-04-12 10:18:09 +08:00
|
|
|
def NAME : XSForm_1<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CARRY, CR0] in
|
2013-04-12 10:18:09 +08:00
|
|
|
def o : XSForm_1<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
|
|
|
[]>, isDOT, RecFormRel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass XForm_26r<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
def NAME : XForm_26<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CR1] in
|
2013-04-12 10:18:09 +08:00
|
|
|
def o : XForm_26<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
2013-04-13 02:17:57 +08:00
|
|
|
[]>, isDOT, RecFormRel;
|
2013-04-12 10:18:09 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass AForm_1r<bits<6> opcode, bits<5> xo, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
def NAME : AForm_1<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CR1] in
|
2013-04-12 10:18:09 +08:00
|
|
|
def o : AForm_1<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
2013-04-13 02:17:57 +08:00
|
|
|
[]>, isDOT, RecFormRel;
|
2013-04-12 10:18:09 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass AForm_2r<bits<6> opcode, bits<5> xo, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
def NAME : AForm_2<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CR1] in
|
2013-04-12 10:18:09 +08:00
|
|
|
def o : AForm_2<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
2013-04-13 02:17:57 +08:00
|
|
|
[]>, isDOT, RecFormRel;
|
2013-04-12 10:18:09 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass AForm_3r<bits<6> opcode, bits<5> xo, dag OOL, dag IOL,
|
|
|
|
string asmbase, string asmstr, InstrItinClass itin,
|
|
|
|
list<dag> pattern> {
|
|
|
|
let BaseName = asmbase in {
|
|
|
|
def NAME : AForm_3<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(" ", asmstr)), itin,
|
|
|
|
pattern>, RecFormRel;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CR1] in
|
2013-04-12 10:18:09 +08:00
|
|
|
def o : AForm_3<opcode, xo, OOL, IOL,
|
|
|
|
!strconcat(asmbase, !strconcat(". ", asmstr)), itin,
|
2013-04-13 02:17:57 +08:00
|
|
|
[]>, isDOT, RecFormRel;
|
2013-04-12 10:18:09 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-09 03:50:41 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Instruction Definitions.
|
|
|
|
|
2004-06-22 00:55:25 +08:00
|
|
|
// Pseudo-instructions:
|
2005-09-09 03:50:41 +08:00
|
|
|
|
2006-03-12 17:13:49 +08:00
|
|
|
let hasCtrlDep = 1 in {
|
2007-09-12 03:55:27 +08:00
|
|
|
let Defs = [R1], Uses = [R1] in {
|
2012-10-05 02:14:28 +08:00
|
|
|
def ADJCALLSTACKDOWN : Pseudo<(outs), (ins u16imm:$amt), "#ADJCALLSTACKDOWN $amt",
|
2008-10-12 06:08:30 +08:00
|
|
|
[(callseq_start timm:$amt)]>;
|
2012-10-05 02:14:28 +08:00
|
|
|
def ADJCALLSTACKUP : Pseudo<(outs), (ins u16imm:$amt1, u16imm:$amt2), "#ADJCALLSTACKUP $amt1 $amt2",
|
2008-10-12 06:08:30 +08:00
|
|
|
[(callseq_end timm:$amt1, timm:$amt2)]>;
|
2007-09-12 03:55:27 +08: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
llvm-svn: 26733
2006-03-14 05:52:10 +08:00
|
|
|
|
2013-04-27 00:53:15 +08: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
llvm-svn: 26733
2006-03-14 05:52:10 +08:00
|
|
|
"UPDATE_VRSAVE $rD, $rS", []>;
|
2004-10-08 06:30:03 +08:00
|
|
|
}
|
2006-11-17 06:43:37 +08:00
|
|
|
|
2007-09-12 03:55:27 +08:00
|
|
|
let Defs = [R1], Uses = [R1] in
|
2013-04-27 00:53:15 +08:00
|
|
|
def DYNALLOC : Pseudo<(outs gprc:$result), (ins gprc:$negsize, memri:$fpsi), "#DYNALLOC",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$result,
|
|
|
|
(PPCdynalloc i32:$negsize, iaddr:$fpsi))]>;
|
2006-11-17 06:43:37 +08:00
|
|
|
|
2009-10-30 02:10:34 +08:00
|
|
|
// SELECT_CC_* - Used to implement the SELECT_CC DAG operation. Expanded after
|
|
|
|
// instruction selection into a branch sequence.
|
|
|
|
let usesCustomInserter = 1, // Expanded after instruction selection.
|
2006-03-12 17:13:49 +08:00
|
|
|
PPC970_Single = 1 in {
|
2013-03-27 13:57:58 +08:00
|
|
|
// Note that SELECT_CC_I4 and SELECT_CC_I8 use the no-r0 register classes
|
|
|
|
// because either operand might become the first operand in an isel, and
|
|
|
|
// that operand cannot be r0.
|
2013-04-27 00:53:15 +08:00
|
|
|
def SELECT_CC_I4 : Pseudo<(outs gprc:$dst), (ins crrc:$cond,
|
|
|
|
gprc_nor0:$T, gprc_nor0:$F,
|
2012-10-05 02:14:28 +08:00
|
|
|
i32imm:$BROPC), "#SELECT_CC_I4",
|
2006-09-27 10:55:21 +08:00
|
|
|
[]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def SELECT_CC_I8 : Pseudo<(outs g8rc:$dst), (ins crrc:$cond,
|
|
|
|
g8rc_nox0:$T, g8rc_nox0:$F,
|
2012-10-05 02:14:28 +08:00
|
|
|
i32imm:$BROPC), "#SELECT_CC_I8",
|
2006-09-27 10:55:21 +08:00
|
|
|
[]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def SELECT_CC_F4 : Pseudo<(outs f4rc:$dst), (ins crrc:$cond, f4rc:$T, f4rc:$F,
|
2012-10-05 02:14:28 +08:00
|
|
|
i32imm:$BROPC), "#SELECT_CC_F4",
|
2006-09-27 10:55:21 +08:00
|
|
|
[]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def SELECT_CC_F8 : Pseudo<(outs f8rc:$dst), (ins crrc:$cond, f8rc:$T, f8rc:$F,
|
2012-10-05 02:14:28 +08:00
|
|
|
i32imm:$BROPC), "#SELECT_CC_F8",
|
2006-09-27 10:55:21 +08:00
|
|
|
[]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def SELECT_CC_VRRC: Pseudo<(outs vrrc:$dst), (ins crrc:$cond, vrrc:$T, vrrc:$F,
|
2012-10-05 02:14:28 +08:00
|
|
|
i32imm:$BROPC), "#SELECT_CC_VRRC",
|
2006-09-27 10:55:21 +08:00
|
|
|
[]>;
|
2005-08-27 05:23:58 +08:00
|
|
|
}
|
|
|
|
|
2008-03-04 06:19:16 +08:00
|
|
|
// SPILL_CR - Indicate that we're dumping the CR register, so we'll need to
|
|
|
|
// scavenge a register for it.
|
2011-12-07 14:33:57 +08:00
|
|
|
let mayStore = 1 in
|
2013-04-27 00:53:15 +08:00
|
|
|
def SPILL_CR : Pseudo<(outs), (ins crrc:$cond, memri:$F),
|
2012-10-05 02:14:28 +08:00
|
|
|
"#SPILL_CR", []>;
|
2008-03-04 06:19:16 +08:00
|
|
|
|
2011-12-07 04:55:36 +08:00
|
|
|
// RESTORE_CR - Indicate that we're restoring the CR register (previously
|
|
|
|
// spilled), so we'll need to scavenge a register for it.
|
2011-12-07 14:33:57 +08:00
|
|
|
let mayLoad = 1 in
|
2013-04-27 00:53:15 +08:00
|
|
|
def RESTORE_CR : Pseudo<(outs crrc:$cond), (ins memri:$F),
|
2012-10-05 02:14:28 +08:00
|
|
|
"#RESTORE_CR", []>;
|
2011-12-07 04:55:36 +08:00
|
|
|
|
2007-07-21 08:34:19 +08:00
|
|
|
let isTerminator = 1, isBarrier = 1, PPC970_Unit = 7 in {
|
2013-03-26 18:53:27 +08:00
|
|
|
let isReturn = 1, Uses = [LR, RM] in
|
|
|
|
def BLR : XLForm_2_ext<19, 16, 20, 0, 0, (outs), (ins), "blr", BrB,
|
|
|
|
[(retflag)]>;
|
PPC: Prep for if conversion of bctr[l]
This adds in-principle support for if-converting the bctr[l] instructions.
These instructions are used for indirect branching. It seems, however, that the
current if converter will never actually predicate these. To do so, it would
need the ability to hoist a few setup insts. out of the conditionally-executed
block. For example, code like this:
void foo(int a, int (*bar)()) { if (a != 0) bar(); }
becomes:
...
beq 0, .LBB0_2
std 2, 40(1)
mr 12, 4
ld 3, 0(4)
ld 11, 16(4)
ld 2, 8(4)
mtctr 3
bctrl
ld 2, 40(1)
.LBB0_2:
...
and it would be safe to do all of this unconditionally with a predicated
beqctrl instruction.
llvm-svn: 179156
2013-04-10 14:42:34 +08:00
|
|
|
let isBranch = 1, isIndirectBranch = 1, Uses = [CTR] in {
|
2007-11-12 15:39:39 +08:00
|
|
|
def BCTR : XLForm_2_ext<19, 528, 20, 0, 0, (outs), (ins), "bctr", BrB, []>;
|
PPC: Prep for if conversion of bctr[l]
This adds in-principle support for if-converting the bctr[l] instructions.
These instructions are used for indirect branching. It seems, however, that the
current if converter will never actually predicate these. To do so, it would
need the ability to hoist a few setup insts. out of the conditionally-executed
block. For example, code like this:
void foo(int a, int (*bar)()) { if (a != 0) bar(); }
becomes:
...
beq 0, .LBB0_2
std 2, 40(1)
mr 12, 4
ld 3, 0(4)
ld 11, 16(4)
ld 2, 8(4)
mtctr 3
bctrl
ld 2, 40(1)
.LBB0_2:
...
and it would be safe to do all of this unconditionally with a predicated
beqctrl instruction.
llvm-svn: 179156
2013-04-10 14:42:34 +08:00
|
|
|
|
2013-04-18 01:19:05 +08:00
|
|
|
let isCodeGenOnly = 1 in
|
PPC: Prep for if conversion of bctr[l]
This adds in-principle support for if-converting the bctr[l] instructions.
These instructions are used for indirect branching. It seems, however, that the
current if converter will never actually predicate these. To do so, it would
need the ability to hoist a few setup insts. out of the conditionally-executed
block. For example, code like this:
void foo(int a, int (*bar)()) { if (a != 0) bar(); }
becomes:
...
beq 0, .LBB0_2
std 2, 40(1)
mr 12, 4
ld 3, 0(4)
ld 11, 16(4)
ld 2, 8(4)
mtctr 3
bctrl
ld 2, 40(1)
.LBB0_2:
...
and it would be safe to do all of this unconditionally with a predicated
beqctrl instruction.
llvm-svn: 179156
2013-04-10 14:42:34 +08:00
|
|
|
def BCCTR : XLForm_2_br<19, 528, 0, (outs), (ins pred:$cond),
|
|
|
|
"b${cond:cc}ctr ${cond:reg}", BrB, []>;
|
|
|
|
}
|
2005-09-09 03:50:41 +08:00
|
|
|
}
|
|
|
|
|
2005-02-16 04:26:49 +08:00
|
|
|
let Defs = [LR] in
|
2012-10-05 02:14:28 +08:00
|
|
|
def MovePCtoLR : Pseudo<(outs), (ins), "#MovePCtoLR", []>,
|
2006-03-12 17:13:49 +08:00
|
|
|
PPC970_Unit_BRU;
|
2004-06-22 00:55:25 +08:00
|
|
|
|
2007-07-21 08:34:19 +08:00
|
|
|
let isBranch = 1, isTerminator = 1, hasCtrlDep = 1, PPC970_Unit = 7 in {
|
2006-10-14 03:10:34 +08:00
|
|
|
let isBarrier = 1 in {
|
2010-11-15 14:09:35 +08:00
|
|
|
def B : IForm<18, 0, 0, (outs), (ins directbrtarget:$dst),
|
2005-12-05 02:42:54 +08:00
|
|
|
"b $dst", BrB,
|
|
|
|
[(br bb:$dst)]>;
|
2006-10-14 03:10:34 +08:00
|
|
|
}
|
2004-11-23 07:07:01 +08:00
|
|
|
|
2006-11-18 06:37:34 +08:00
|
|
|
// BCC represents an arbitrary conditional branch on a predicate.
|
|
|
|
// FIXME: should be able to write a pattern for PPCcondbranch, but can't use
|
2012-10-05 23:16:11 +08:00
|
|
|
// a two-value operand where a dag node expects two operands. :(
|
2013-04-09 00:24:03 +08:00
|
|
|
let isCodeGenOnly = 1 in {
|
2012-10-05 23:16:11 +08:00
|
|
|
def BCC : BForm<16, 0, 0, (outs), (ins pred:$cond, condbrtarget:$dst),
|
|
|
|
"b${cond:cc} ${cond:reg}, $dst"
|
2013-04-27 00:53:15 +08:00
|
|
|
/*[(PPCcondbranch crrc:$crS, imm:$opc, bb:$dst)]*/>;
|
2013-04-09 00:24:03 +08:00
|
|
|
let isReturn = 1, Uses = [LR, RM] in
|
|
|
|
def BCLR : XLForm_2_br<19, 16, 0, (outs), (ins pred:$cond),
|
|
|
|
"b${cond:cc}lr ${cond:reg}", BrB, []>;
|
2013-04-10 06:58:37 +08:00
|
|
|
|
|
|
|
let isReturn = 1, Defs = [CTR], Uses = [CTR, LR, RM] in {
|
|
|
|
def BDZLR : XLForm_2_ext<19, 16, 18, 0, 0, (outs), (ins),
|
|
|
|
"bdzlr", BrB, []>;
|
|
|
|
def BDNZLR : XLForm_2_ext<19, 16, 16, 0, 0, (outs), (ins),
|
|
|
|
"bdnzlr", BrB, []>;
|
|
|
|
}
|
2013-04-09 00:24:03 +08:00
|
|
|
}
|
2012-06-08 23:38:21 +08:00
|
|
|
|
|
|
|
let Defs = [CTR], Uses = [CTR] in {
|
2012-11-14 03:15:52 +08:00
|
|
|
def BDZ : BForm_1<16, 18, 0, 0, (outs), (ins condbrtarget:$dst),
|
|
|
|
"bdz $dst">;
|
|
|
|
def BDNZ : BForm_1<16, 16, 0, 0, (outs), (ins condbrtarget:$dst),
|
|
|
|
"bdnz $dst">;
|
2012-06-08 23:38:21 +08:00
|
|
|
}
|
2004-06-29 02:23:35 +08:00
|
|
|
}
|
|
|
|
|
2013-04-05 06:55:54 +08:00
|
|
|
// The unconditional BCL used by the SjLj setjmp code.
|
2013-03-26 18:57:16 +08:00
|
|
|
let isCall = 1, hasCtrlDep = 1, isCodeGenOnly = 1, PPC970_Unit = 7 in {
|
2013-03-22 05:37:52 +08:00
|
|
|
let Defs = [LR], Uses = [RM] in {
|
2013-04-05 06:55:54 +08:00
|
|
|
def BCLalways : BForm_2<16, 20, 31, 0, 1, (outs), (ins condbrtarget:$dst),
|
|
|
|
"bcl 20, 31, $dst">;
|
2013-03-22 05:37:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-07 00:41:49 +08:00
|
|
|
let isCall = 1, PPC970_Unit = 7, Defs = [LR] in {
|
2007-02-25 13:34:32 +08:00
|
|
|
// Convenient aliases for call instructions
|
2008-10-30 02:26:45 +08:00
|
|
|
let Uses = [RM] in {
|
2013-03-22 23:24:13 +08:00
|
|
|
def BL : IForm<18, 0, 1, (outs), (ins calltarget:$func),
|
|
|
|
"bl $func", BrB, []>; // See Pat patterns below.
|
|
|
|
def BLA : IForm<18, 1, 1, (outs), (ins aaddr:$func),
|
|
|
|
"bla $func", BrB, [(PPCcall (i32 imm:$func))]>;
|
2008-10-30 02:26:45 +08:00
|
|
|
}
|
|
|
|
let Uses = [CTR, RM] in {
|
2013-03-22 23:24:13 +08:00
|
|
|
def BCTRL : XLForm_2_ext<19, 528, 20, 0, 1, (outs), (ins),
|
|
|
|
"bctrl", BrB, [(PPCbctrl)]>,
|
|
|
|
Requires<[In32BitMode]>;
|
2013-04-18 01:19:05 +08:00
|
|
|
|
|
|
|
let isCodeGenOnly = 1 in
|
PPC: Prep for if conversion of bctr[l]
This adds in-principle support for if-converting the bctr[l] instructions.
These instructions are used for indirect branching. It seems, however, that the
current if converter will never actually predicate these. To do so, it would
need the ability to hoist a few setup insts. out of the conditionally-executed
block. For example, code like this:
void foo(int a, int (*bar)()) { if (a != 0) bar(); }
becomes:
...
beq 0, .LBB0_2
std 2, 40(1)
mr 12, 4
ld 3, 0(4)
ld 11, 16(4)
ld 2, 8(4)
mtctr 3
bctrl
ld 2, 40(1)
.LBB0_2:
...
and it would be safe to do all of this unconditionally with a predicated
beqctrl instruction.
llvm-svn: 179156
2013-04-10 14:42:34 +08:00
|
|
|
def BCCTRL : XLForm_2_br<19, 528, 1, (outs), (ins pred:$cond),
|
|
|
|
"b${cond:cc}ctrl ${cond:reg}", BrB, []>;
|
2008-10-24 04:41:28 +08:00
|
|
|
}
|
2004-06-30 07:37:36 +08:00
|
|
|
}
|
|
|
|
|
2008-10-30 02:26:45 +08:00
|
|
|
let isCall = 1, isTerminator = 1, isReturn = 1, isBarrier = 1, Uses = [RM] in
|
2008-04-30 17:16:33 +08:00
|
|
|
def TCRETURNdi :Pseudo< (outs),
|
2012-07-14 04:44:29 +08:00
|
|
|
(ins calltarget:$dst, i32imm:$offset),
|
2008-04-30 17:16:33 +08:00
|
|
|
"#TC_RETURNd $dst $offset",
|
|
|
|
[]>;
|
|
|
|
|
|
|
|
|
2008-10-30 02:26:45 +08:00
|
|
|
let isCall = 1, isTerminator = 1, isReturn = 1, isBarrier = 1, Uses = [RM] in
|
2012-07-14 04:44:29 +08:00
|
|
|
def TCRETURNai :Pseudo<(outs), (ins aaddr:$func, i32imm:$offset),
|
2008-04-30 17:16:33 +08:00
|
|
|
"#TC_RETURNa $func $offset",
|
|
|
|
[(PPCtc_return (i32 imm:$func), imm:$offset)]>;
|
|
|
|
|
2008-10-30 02:26:45 +08:00
|
|
|
let isCall = 1, isTerminator = 1, isReturn = 1, isBarrier = 1, Uses = [RM] in
|
2012-07-14 04:44:29 +08:00
|
|
|
def TCRETURNri : Pseudo<(outs), (ins CTRRC:$dst, i32imm:$offset),
|
2008-04-30 17:16:33 +08:00
|
|
|
"#TC_RETURNr $dst $offset",
|
|
|
|
[]>;
|
|
|
|
|
|
|
|
|
2013-03-26 18:57:16 +08:00
|
|
|
let isCodeGenOnly = 1 in {
|
|
|
|
|
2008-04-30 17:16:33 +08:00
|
|
|
let isTerminator = 1, isBarrier = 1, PPC970_Unit = 7, isBranch = 1,
|
2008-10-30 02:26:45 +08:00
|
|
|
isIndirectBranch = 1, isCall = 1, isReturn = 1, Uses = [CTR, RM] in
|
2008-04-30 17:16:33 +08:00
|
|
|
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,
|
2008-10-30 02:26:45 +08:00
|
|
|
isBarrier = 1, isCall = 1, isReturn = 1, Uses = [RM] in
|
2008-04-30 17:16:33 +08:00
|
|
|
def TAILB : IForm<18, 0, 0, (outs), (ins calltarget:$dst),
|
|
|
|
"b $dst", BrB,
|
|
|
|
[]>;
|
|
|
|
|
2013-03-26 18:57:16 +08:00
|
|
|
}
|
2008-04-30 17:16:33 +08:00
|
|
|
|
|
|
|
let isBranch = 1, isTerminator = 1, hasCtrlDep = 1, PPC970_Unit = 7,
|
2008-10-30 02:26:45 +08:00
|
|
|
isBarrier = 1, isCall = 1, isReturn = 1, Uses = [RM] in
|
2008-04-30 17:16:33 +08:00
|
|
|
def TAILBA : IForm<18, 0, 0, (outs), (ins aaddr:$dst),
|
|
|
|
"ba $dst", BrB,
|
|
|
|
[]>;
|
|
|
|
|
2013-03-26 18:57:16 +08:00
|
|
|
let hasSideEffects = 1, isBarrier = 1, usesCustomInserter = 1 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def EH_SjLj_SetJmp32 : Pseudo<(outs gprc:$dst), (ins memr:$buf),
|
2013-03-22 05:37:52 +08:00
|
|
|
"#EH_SJLJ_SETJMP32",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (PPCeh_sjlj_setjmp addr:$buf))]>,
|
2013-03-22 05:37:52 +08:00
|
|
|
Requires<[In32BitMode]>;
|
|
|
|
let isTerminator = 1 in
|
|
|
|
def EH_SjLj_LongJmp32 : Pseudo<(outs), (ins memr:$buf),
|
|
|
|
"#EH_SJLJ_LONGJMP32",
|
|
|
|
[(PPCeh_sjlj_longjmp addr:$buf)]>,
|
|
|
|
Requires<[In32BitMode]>;
|
|
|
|
}
|
|
|
|
|
2013-03-26 18:57:16 +08:00
|
|
|
let isBranch = 1, isTerminator = 1 in {
|
2013-03-22 05:37:52 +08:00
|
|
|
def EH_SjLj_Setup : Pseudo<(outs), (ins directbrtarget:$dst),
|
|
|
|
"#EH_SjLj_Setup\t$dst", []>;
|
|
|
|
}
|
2008-04-30 17:16:33 +08:00
|
|
|
|
2013-05-15 03:35:45 +08:00
|
|
|
// System call.
|
|
|
|
let PPC970_Unit = 7 in {
|
|
|
|
def SC : SCForm<17, 1, (outs), (ins i32imm:$lev),
|
|
|
|
"sc $lev", BrB, [(PPCsc (i32 imm:$lev))]>;
|
|
|
|
}
|
|
|
|
|
2006-06-07 05:29:23 +08: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))]>;
llvm-svn: 40033
2007-07-19 09:14:50 +08:00
|
|
|
def DCBA : DCB_Form<758, 0, (outs), (ins memrr:$dst),
|
2006-10-24 09:08:42 +08: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))]>;
llvm-svn: 40033
2007-07-19 09:14:50 +08:00
|
|
|
def DCBF : DCB_Form<86, 0, (outs), (ins memrr:$dst),
|
2006-10-24 09:08:42 +08: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))]>;
llvm-svn: 40033
2007-07-19 09:14:50 +08:00
|
|
|
def DCBI : DCB_Form<470, 0, (outs), (ins memrr:$dst),
|
2006-10-24 09:08:42 +08: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))]>;
llvm-svn: 40033
2007-07-19 09:14:50 +08:00
|
|
|
def DCBST : DCB_Form<54, 0, (outs), (ins memrr:$dst),
|
2006-10-24 09:08:42 +08: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))]>;
llvm-svn: 40033
2007-07-19 09:14:50 +08:00
|
|
|
def DCBT : DCB_Form<278, 0, (outs), (ins memrr:$dst),
|
2006-10-24 09:08:42 +08: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))]>;
llvm-svn: 40033
2007-07-19 09:14:50 +08:00
|
|
|
def DCBTST : DCB_Form<246, 0, (outs), (ins memrr:$dst),
|
2006-10-24 09:08:42 +08: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))]>;
llvm-svn: 40033
2007-07-19 09:14:50 +08:00
|
|
|
def DCBZ : DCB_Form<1014, 0, (outs), (ins memrr:$dst),
|
2006-10-24 09:08:42 +08: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))]>;
llvm-svn: 40033
2007-07-19 09:14:50 +08:00
|
|
|
def DCBZL : DCB_Form<1014, 1, (outs), (ins memrr:$dst),
|
2006-10-24 09:08:42 +08:00
|
|
|
"dcbzl $dst", LdStDCBF, [(int_ppc_dcbzl xoaddr:$dst)]>,
|
|
|
|
PPC970_DGroup_Single;
|
2006-11-15 03:19:53 +08:00
|
|
|
|
2012-04-02 04:08:17 +08:00
|
|
|
def : Pat<(prefetch xoaddr:$dst, (i32 0), imm, (i32 1)),
|
|
|
|
(DCBT xoaddr:$dst)>;
|
|
|
|
|
2008-07-12 10:23:19 +08:00
|
|
|
// Atomic operations
|
2009-10-30 02:10:34 +08:00
|
|
|
let usesCustomInserter = 1 in {
|
2011-04-05 01:07:09 +08:00
|
|
|
let Defs = [CR0] in {
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_LOAD_ADD_I8 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_ADD_I8",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_add_8 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_LOAD_SUB_I8 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_SUB_I8",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_sub_8 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_LOAD_AND_I8 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_AND_I8",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_and_8 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_LOAD_OR_I8 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_OR_I8",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_or_8 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_LOAD_XOR_I8 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "ATOMIC_LOAD_XOR_I8",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_xor_8 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_LOAD_NAND_I8 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_NAND_I8",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_nand_8 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_LOAD_ADD_I16 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_ADD_I16",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_add_16 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_LOAD_SUB_I16 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_SUB_I16",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_sub_16 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_LOAD_AND_I16 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_AND_I16",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_and_16 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_LOAD_OR_I16 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_OR_I16",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_or_16 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_LOAD_XOR_I16 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_XOR_I16",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_xor_16 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_LOAD_NAND_I16 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_NAND_I16",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_nand_16 xoaddr:$ptr, i32:$incr))]>;
|
2008-07-12 10:23:19 +08:00
|
|
|
def ATOMIC_LOAD_ADD_I32 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_ADD_I32",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_add_32 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-26 06:34:37 +08:00
|
|
|
def ATOMIC_LOAD_SUB_I32 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_SUB_I32",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_sub_32 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-26 06:34:37 +08:00
|
|
|
def ATOMIC_LOAD_AND_I32 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_AND_I32",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_and_32 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-26 06:34:37 +08:00
|
|
|
def ATOMIC_LOAD_OR_I32 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_OR_I32",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_or_32 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-26 06:34:37 +08:00
|
|
|
def ATOMIC_LOAD_XOR_I32 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_XOR_I32",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_xor_32 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-26 06:34:37 +08:00
|
|
|
def ATOMIC_LOAD_NAND_I32 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_NAND_I32",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_load_nand_32 xoaddr:$ptr, i32:$incr))]>;
|
2008-08-26 06:34:37 +08:00
|
|
|
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_CMP_SWAP_I8 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$old, gprc:$new), "#ATOMIC_CMP_SWAP_I8",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_cmp_swap_8 xoaddr:$ptr, i32:$old, i32:$new))]>;
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_CMP_SWAP_I16 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$old, gprc:$new), "#ATOMIC_CMP_SWAP_I16 $dst $ptr $old $new",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_cmp_swap_16 xoaddr:$ptr, i32:$old, i32:$new))]>;
|
2008-08-22 11:49:10 +08:00
|
|
|
def ATOMIC_CMP_SWAP_I32 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$old, gprc:$new), "#ATOMIC_CMP_SWAP_I32 $dst $ptr $old $new",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_cmp_swap_32 xoaddr:$ptr, i32:$old, i32:$new))]>;
|
2008-08-26 06:34:37 +08:00
|
|
|
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_SWAP_I8 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$new), "#ATOMIC_SWAP_i8",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_swap_8 xoaddr:$ptr, i32:$new))]>;
|
2008-08-29 01:53:09 +08:00
|
|
|
def ATOMIC_SWAP_I16 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$new), "#ATOMIC_SWAP_I16",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_swap_16 xoaddr:$ptr, i32:$new))]>;
|
2008-08-26 05:09:52 +08:00
|
|
|
def ATOMIC_SWAP_I32 : Pseudo<
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$dst), (ins memrr:$ptr, gprc:$new), "#ATOMIC_SWAP_I32",
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (atomic_swap_32 xoaddr:$ptr, i32:$new))]>;
|
2008-08-22 11:49:10 +08:00
|
|
|
}
|
2008-04-19 09:30:48 +08:00
|
|
|
}
|
|
|
|
|
2008-07-12 10:23:19 +08:00
|
|
|
// Instructions to support atomic operations
|
2013-04-27 00:53:15 +08:00
|
|
|
def LWARX : XForm_1<31, 20, (outs gprc:$rD), (ins memrr:$src),
|
2008-07-12 10:23:19 +08:00
|
|
|
"lwarx $rD, $src", LdStLWARX,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$rD, (PPClarx xoaddr:$src))]>;
|
2008-07-12 10:23:19 +08:00
|
|
|
|
|
|
|
let Defs = [CR0] in
|
2013-04-27 00:53:15 +08:00
|
|
|
def STWCX : XForm_1<31, 150, (outs), (ins gprc:$rS, memrr:$dst),
|
2008-07-12 10:23:19 +08:00
|
|
|
"stwcx. $rS, $dst", LdStSTWCX,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(PPCstcx i32:$rS, xoaddr:$dst)]>,
|
2008-07-12 10:23:19 +08:00
|
|
|
isDOT;
|
|
|
|
|
2010-05-15 00:46:02 +08:00
|
|
|
let isTerminator = 1, isBarrier = 1, hasCtrlDep = 1 in
|
2012-04-01 12:44:16 +08:00
|
|
|
def TRAP : XForm_24<31, 4, (outs), (ins), "trap", LdStLoad, [(trap)]>;
|
2008-08-12 01:36:31 +08:00
|
|
|
|
2006-11-15 03:19:53 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PPC32 Load Instructions.
|
2004-08-30 10:28:06 +08:00
|
|
|
//
|
2006-11-15 03:19:53 +08:00
|
|
|
|
2006-11-15 10:43:19 +08:00
|
|
|
// Unindexed (r+i) Loads.
|
2008-12-04 02:15:48 +08:00
|
|
|
let canFoldAsLoad = 1, PPC970_Unit = 2 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def LBZ : DForm_1<34, (outs gprc:$rD), (ins memri:$src),
|
2012-04-01 12:44:16 +08:00
|
|
|
"lbz $rD, $src", LdStLoad,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$rD, (zextloadi8 iaddr:$src))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def LHA : DForm_1<42, (outs gprc:$rD), (ins memri:$src),
|
2005-12-20 07:25:09 +08:00
|
|
|
"lha $rD, $src", LdStLHA,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$rD, (sextloadi16 iaddr:$src))]>,
|
2006-03-13 13:15:10 +08:00
|
|
|
PPC970_DGroup_Cracked;
|
2013-04-27 00:53:15 +08:00
|
|
|
def LHZ : DForm_1<40, (outs gprc:$rD), (ins memri:$src),
|
2012-04-01 12:44:16 +08:00
|
|
|
"lhz $rD, $src", LdStLoad,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$rD, (zextloadi16 iaddr:$src))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def LWZ : DForm_1<32, (outs gprc:$rD), (ins memri:$src),
|
2012-04-01 12:44:16 +08:00
|
|
|
"lwz $rD, $src", LdStLoad,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$rD, (load iaddr:$src))]>;
|
2006-11-08 10:13:12 +08:00
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def LFS : DForm_1<48, (outs f4rc:$rD), (ins memri:$src),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lfs $rD, $src", LdStLFD,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set f32:$rD, (load iaddr:$src))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def LFD : DForm_1<50, (outs f8rc:$rD), (ins memri:$src),
|
2006-11-10 10:08:47 +08:00
|
|
|
"lfd $rD, $src", LdStLFD,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set f64:$rD, (load iaddr:$src))]>;
|
2006-11-10 10:08:47 +08:00
|
|
|
|
|
|
|
|
2006-11-15 10:43:19 +08:00
|
|
|
// Unindexed (r+i) Loads with Update (preinc).
|
2013-04-07 13:46:58 +08:00
|
|
|
let mayLoad = 1, neverHasSideEffects = 1 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def LBZU : DForm_1<35, (outs gprc:$rD, ptr_rc_nor0:$ea_result), (ins memri:$addr),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lbzu $rD, $addr", LdStLoadUpd,
|
2006-11-16 07:24:18 +08:00
|
|
|
[]>, RegConstraint<"$addr.reg = $ea_result">,
|
|
|
|
NoEncode<"$ea_result">;
|
2006-11-15 10:43:19 +08:00
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def LHAU : DForm_1<43, (outs gprc:$rD, ptr_rc_nor0:$ea_result), (ins memri:$addr),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lhau $rD, $addr", LdStLHAU,
|
2006-11-16 07:24:18 +08:00
|
|
|
[]>, RegConstraint<"$addr.reg = $ea_result">,
|
|
|
|
NoEncode<"$ea_result">;
|
2006-11-15 10:43:19 +08:00
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def LHZU : DForm_1<41, (outs gprc:$rD, ptr_rc_nor0:$ea_result), (ins memri:$addr),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lhzu $rD, $addr", LdStLoadUpd,
|
2006-11-16 07:24:18 +08:00
|
|
|
[]>, RegConstraint<"$addr.reg = $ea_result">,
|
|
|
|
NoEncode<"$ea_result">;
|
2006-11-15 10:43:19 +08:00
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def LWZU : DForm_1<33, (outs gprc:$rD, ptr_rc_nor0:$ea_result), (ins memri:$addr),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lwzu $rD, $addr", LdStLoadUpd,
|
2006-11-16 07:24:18 +08:00
|
|
|
[]>, RegConstraint<"$addr.reg = $ea_result">,
|
|
|
|
NoEncode<"$ea_result">;
|
2006-11-15 10:43:19 +08:00
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def LFSU : DForm_1<49, (outs f4rc:$rD, ptr_rc_nor0:$ea_result), (ins memri:$addr),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lfsu $rD, $addr", LdStLFDU,
|
2006-11-16 07:24:18 +08:00
|
|
|
[]>, RegConstraint<"$addr.reg = $ea_result">,
|
|
|
|
NoEncode<"$ea_result">;
|
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def LFDU : DForm_1<51, (outs f8rc:$rD, ptr_rc_nor0:$ea_result), (ins memri:$addr),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lfdu $rD, $addr", LdStLFDU,
|
2006-11-16 07:24:18 +08:00
|
|
|
[]>, RegConstraint<"$addr.reg = $ea_result">,
|
|
|
|
NoEncode<"$ea_result">;
|
2012-06-20 23:43:03 +08:00
|
|
|
|
|
|
|
|
|
|
|
// Indexed (r+r) Loads with Update (preinc).
|
2013-04-27 00:53:15 +08:00
|
|
|
def LBZUX : XForm_1<31, 119, (outs gprc:$rD, ptr_rc_nor0:$ea_result),
|
2012-06-20 23:43:03 +08:00
|
|
|
(ins memrr:$addr),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lbzux $rD, $addr", LdStLoadUpd,
|
2013-03-22 22:59:13 +08:00
|
|
|
[]>, RegConstraint<"$addr.ptrreg = $ea_result">,
|
2012-06-20 23:43:03 +08:00
|
|
|
NoEncode<"$ea_result">;
|
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def LHAUX : XForm_1<31, 375, (outs gprc:$rD, ptr_rc_nor0:$ea_result),
|
2012-06-20 23:43:03 +08:00
|
|
|
(ins memrr:$addr),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lhaux $rD, $addr", LdStLHAU,
|
2013-03-22 22:59:13 +08:00
|
|
|
[]>, RegConstraint<"$addr.ptrreg = $ea_result">,
|
2012-06-20 23:43:03 +08:00
|
|
|
NoEncode<"$ea_result">;
|
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def LHZUX : XForm_1<31, 311, (outs gprc:$rD, ptr_rc_nor0:$ea_result),
|
2012-06-20 23:43:03 +08:00
|
|
|
(ins memrr:$addr),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lhzux $rD, $addr", LdStLoadUpd,
|
2013-03-22 22:59:13 +08:00
|
|
|
[]>, RegConstraint<"$addr.ptrreg = $ea_result">,
|
2012-06-20 23:43:03 +08:00
|
|
|
NoEncode<"$ea_result">;
|
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def LWZUX : XForm_1<31, 55, (outs gprc:$rD, ptr_rc_nor0:$ea_result),
|
2012-06-20 23:43:03 +08:00
|
|
|
(ins memrr:$addr),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lwzux $rD, $addr", LdStLoadUpd,
|
2013-03-22 22:59:13 +08:00
|
|
|
[]>, RegConstraint<"$addr.ptrreg = $ea_result">,
|
2012-06-20 23:43:03 +08:00
|
|
|
NoEncode<"$ea_result">;
|
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def LFSUX : XForm_1<31, 567, (outs f4rc:$rD, ptr_rc_nor0:$ea_result),
|
2012-06-20 23:43:03 +08:00
|
|
|
(ins memrr:$addr),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lfsux $rD, $addr", LdStLFDU,
|
2013-03-22 22:59:13 +08:00
|
|
|
[]>, RegConstraint<"$addr.ptrreg = $ea_result">,
|
2012-06-20 23:43:03 +08:00
|
|
|
NoEncode<"$ea_result">;
|
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def LFDUX : XForm_1<31, 631, (outs f8rc:$rD, ptr_rc_nor0:$ea_result),
|
2012-06-20 23:43:03 +08:00
|
|
|
(ins memrr:$addr),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lfdux $rD, $addr", LdStLFDU,
|
2013-03-22 22:59:13 +08:00
|
|
|
[]>, RegConstraint<"$addr.ptrreg = $ea_result">,
|
2012-06-20 23:43:03 +08:00
|
|
|
NoEncode<"$ea_result">;
|
2004-10-08 06:30:03 +08:00
|
|
|
}
|
2008-12-03 10:30:17 +08:00
|
|
|
}
|
2006-11-08 10:13:12 +08:00
|
|
|
|
2006-11-15 10:43:19 +08:00
|
|
|
// Indexed (r+r) Loads.
|
2006-11-15 03:19:53 +08:00
|
|
|
//
|
2008-12-04 02:15:48 +08:00
|
|
|
let canFoldAsLoad = 1, PPC970_Unit = 2 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def LBZX : XForm_1<31, 87, (outs gprc:$rD), (ins memrr:$src),
|
2012-04-01 12:44:16 +08:00
|
|
|
"lbzx $rD, $src", LdStLoad,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$rD, (zextloadi8 xaddr:$src))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def LHAX : XForm_1<31, 343, (outs gprc:$rD), (ins memrr:$src),
|
2006-11-15 03:19:53 +08:00
|
|
|
"lhax $rD, $src", LdStLHA,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$rD, (sextloadi16 xaddr:$src))]>,
|
2006-11-15 03:19:53 +08:00
|
|
|
PPC970_DGroup_Cracked;
|
2013-04-27 00:53:15 +08:00
|
|
|
def LHZX : XForm_1<31, 279, (outs gprc:$rD), (ins memrr:$src),
|
2012-04-01 12:44:16 +08:00
|
|
|
"lhzx $rD, $src", LdStLoad,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$rD, (zextloadi16 xaddr:$src))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def LWZX : XForm_1<31, 23, (outs gprc:$rD), (ins memrr:$src),
|
2012-04-01 12:44:16 +08:00
|
|
|
"lwzx $rD, $src", LdStLoad,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$rD, (load xaddr:$src))]>;
|
2006-11-15 03:19:53 +08:00
|
|
|
|
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def LHBRX : XForm_1<31, 790, (outs gprc:$rD), (ins memrr:$src),
|
2012-04-01 12:44:16 +08:00
|
|
|
"lhbrx $rD, $src", LdStLoad,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$rD, (PPClbrx xoaddr:$src, i16))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def LWBRX : XForm_1<31, 534, (outs gprc:$rD), (ins memrr:$src),
|
2012-04-01 12:44:16 +08:00
|
|
|
"lwbrx $rD, $src", LdStLoad,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$rD, (PPClbrx xoaddr:$src, i32))]>;
|
2006-11-15 03:19:53 +08:00
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def LFSX : XForm_25<31, 535, (outs f4rc:$frD), (ins memrr:$src),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lfsx $frD, $src", LdStLFD,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set f32:$frD, (load xaddr:$src))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def LFDX : XForm_25<31, 599, (outs f8rc:$frD), (ins memrr:$src),
|
2012-08-28 10:49:14 +08:00
|
|
|
"lfdx $frD, $src", LdStLFD,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set f64:$frD, (load xaddr:$src))]>;
|
2013-03-31 18:12:51 +08:00
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def LFIWAX : XForm_25<31, 855, (outs f8rc:$frD), (ins memrr:$src),
|
2013-03-31 18:12:51 +08:00
|
|
|
"lfiwax $frD, $src", LdStLFD,
|
|
|
|
[(set f64:$frD, (PPClfiwax xoaddr:$src))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def LFIWZX : XForm_25<31, 887, (outs f8rc:$frD), (ins memrr:$src),
|
2013-04-02 01:52:07 +08:00
|
|
|
"lfiwzx $frD, $src", LdStLFD,
|
|
|
|
[(set f64:$frD, (PPClfiwzx xoaddr:$src))]>;
|
2006-11-15 03:19:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PPC32 Store Instructions.
|
|
|
|
//
|
|
|
|
|
2006-11-15 10:43:19 +08:00
|
|
|
// Unindexed (r+i) Stores.
|
2008-01-06 13:53:26 +08:00
|
|
|
let PPC970_Unit = 2 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def STB : DForm_1<38, (outs), (ins gprc:$rS, memri:$src),
|
2012-04-01 12:44:16 +08:00
|
|
|
"stb $rS, $src", LdStStore,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(truncstorei8 i32:$rS, iaddr:$src)]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STH : DForm_1<44, (outs), (ins gprc:$rS, memri:$src),
|
2012-04-01 12:44:16 +08:00
|
|
|
"sth $rS, $src", LdStStore,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(truncstorei16 i32:$rS, iaddr:$src)]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STW : DForm_1<36, (outs), (ins gprc:$rS, memri:$src),
|
2012-04-01 12:44:16 +08:00
|
|
|
"stw $rS, $src", LdStStore,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(store i32:$rS, iaddr:$src)]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STFS : DForm_1<52, (outs), (ins f4rc:$rS, memri:$dst),
|
2012-08-28 10:49:14 +08:00
|
|
|
"stfs $rS, $dst", LdStSTFD,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(store f32:$rS, iaddr:$dst)]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STFD : DForm_1<54, (outs), (ins f8rc:$rS, memri:$dst),
|
2012-08-28 10:49:14 +08:00
|
|
|
"stfd $rS, $dst", LdStSTFD,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(store f64:$rS, iaddr:$dst)]>;
|
2006-11-15 03:19:53 +08:00
|
|
|
}
|
|
|
|
|
2006-11-15 10:43:19 +08:00
|
|
|
// Unindexed (r+i) Stores with Update (preinc).
|
2013-03-20 03:52:04 +08:00
|
|
|
let PPC970_Unit = 2, mayStore = 1 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def STBU : DForm_1<39, (outs ptr_rc_nor0:$ea_res), (ins gprc:$rS, memri:$dst),
|
2013-03-20 03:52:04 +08:00
|
|
|
"stbu $rS, $dst", LdStStoreUpd, []>,
|
|
|
|
RegConstraint<"$dst.reg = $ea_res">, NoEncode<"$ea_res">;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STHU : DForm_1<45, (outs ptr_rc_nor0:$ea_res), (ins gprc:$rS, memri:$dst),
|
2013-03-20 03:52:04 +08:00
|
|
|
"sthu $rS, $dst", LdStStoreUpd, []>,
|
|
|
|
RegConstraint<"$dst.reg = $ea_res">, NoEncode<"$ea_res">;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STWU : DForm_1<37, (outs ptr_rc_nor0:$ea_res), (ins gprc:$rS, memri:$dst),
|
2013-03-20 03:52:04 +08:00
|
|
|
"stwu $rS, $dst", LdStStoreUpd, []>,
|
|
|
|
RegConstraint<"$dst.reg = $ea_res">, NoEncode<"$ea_res">;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STFSU : DForm_1<53, (outs ptr_rc_nor0:$ea_res), (ins f4rc:$rS, memri:$dst),
|
2013-03-20 03:52:04 +08:00
|
|
|
"stfsu $rS, $dst", LdStSTFDU, []>,
|
|
|
|
RegConstraint<"$dst.reg = $ea_res">, NoEncode<"$ea_res">;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STFDU : DForm_1<55, (outs ptr_rc_nor0:$ea_res), (ins f8rc:$rS, memri:$dst),
|
2013-03-20 03:52:04 +08:00
|
|
|
"stfdu $rS, $dst", LdStSTFDU, []>,
|
|
|
|
RegConstraint<"$dst.reg = $ea_res">, NoEncode<"$ea_res">;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Patterns to match the pre-inc stores. We can't put the patterns on
|
|
|
|
// the instruction definitions directly as ISel wants the address base
|
|
|
|
// and offset to be separate operands, not a single complex operand.
|
2013-03-26 03:04:58 +08:00
|
|
|
def : Pat<(pre_truncsti8 i32:$rS, iPTR:$ptrreg, iaddroff:$ptroff),
|
|
|
|
(STBU $rS, iaddroff:$ptroff, $ptrreg)>;
|
|
|
|
def : Pat<(pre_truncsti16 i32:$rS, iPTR:$ptrreg, iaddroff:$ptroff),
|
|
|
|
(STHU $rS, iaddroff:$ptroff, $ptrreg)>;
|
|
|
|
def : Pat<(pre_store i32:$rS, iPTR:$ptrreg, iaddroff:$ptroff),
|
|
|
|
(STWU $rS, iaddroff:$ptroff, $ptrreg)>;
|
|
|
|
def : Pat<(pre_store f32:$rS, iPTR:$ptrreg, iaddroff:$ptroff),
|
|
|
|
(STFSU $rS, iaddroff:$ptroff, $ptrreg)>;
|
|
|
|
def : Pat<(pre_store f64:$rS, iPTR:$ptrreg, iaddroff:$ptroff),
|
|
|
|
(STFDU $rS, iaddroff:$ptroff, $ptrreg)>;
|
2006-11-15 10:43:19 +08:00
|
|
|
|
2006-11-15 03:19:53 +08:00
|
|
|
// Indexed (r+r) Stores.
|
2008-01-06 13:53:26 +08:00
|
|
|
let PPC970_Unit = 2 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def STBX : XForm_8<31, 215, (outs), (ins gprc:$rS, memrr:$dst),
|
2012-04-01 12:44:16 +08:00
|
|
|
"stbx $rS, $dst", LdStStore,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(truncstorei8 i32:$rS, xaddr:$dst)]>,
|
2006-11-15 03:19:53 +08:00
|
|
|
PPC970_DGroup_Cracked;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STHX : XForm_8<31, 407, (outs), (ins gprc:$rS, memrr:$dst),
|
2012-04-01 12:44:16 +08:00
|
|
|
"sthx $rS, $dst", LdStStore,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(truncstorei16 i32:$rS, xaddr:$dst)]>,
|
2006-11-15 03:19:53 +08:00
|
|
|
PPC970_DGroup_Cracked;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STWX : XForm_8<31, 151, (outs), (ins gprc:$rS, memrr:$dst),
|
2012-04-01 12:44:16 +08:00
|
|
|
"stwx $rS, $dst", LdStStore,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(store i32:$rS, xaddr:$dst)]>,
|
2006-11-15 03:19:53 +08:00
|
|
|
PPC970_DGroup_Cracked;
|
2012-06-19 10:34:32 +08:00
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def STHBRX: XForm_8<31, 918, (outs), (ins gprc:$rS, memrr:$dst),
|
2012-04-01 12:44:16 +08:00
|
|
|
"sthbrx $rS, $dst", LdStStore,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(PPCstbrx i32:$rS, xoaddr:$dst, i16)]>,
|
2006-11-15 03:19:53 +08:00
|
|
|
PPC970_DGroup_Cracked;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STWBRX: XForm_8<31, 662, (outs), (ins gprc:$rS, memrr:$dst),
|
2012-04-01 12:44:16 +08:00
|
|
|
"stwbrx $rS, $dst", LdStStore,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(PPCstbrx i32:$rS, xoaddr:$dst, i32)]>,
|
2006-11-15 03:19:53 +08:00
|
|
|
PPC970_DGroup_Cracked;
|
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def STFIWX: XForm_28<31, 983, (outs), (ins f8rc:$frS, memrr:$dst),
|
2012-08-28 10:49:14 +08:00
|
|
|
"stfiwx $frS, $dst", LdStSTFD,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(PPCstfiwx f64:$frS, xoaddr:$dst)]>;
|
2008-01-06 14:44:58 +08:00
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def STFSX : XForm_28<31, 663, (outs), (ins f4rc:$frS, memrr:$dst),
|
2012-08-28 10:49:14 +08:00
|
|
|
"stfsx $frS, $dst", LdStSTFD,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(store f32:$frS, xaddr:$dst)]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STFDX : XForm_28<31, 727, (outs), (ins f8rc:$frS, memrr:$dst),
|
2012-08-28 10:49:14 +08:00
|
|
|
"stfdx $frS, $dst", LdStSTFD,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(store f64:$frS, xaddr:$dst)]>;
|
2006-11-15 03:19:53 +08:00
|
|
|
}
|
|
|
|
|
2013-03-20 03:52:04 +08:00
|
|
|
// Indexed (r+r) Stores with Update (preinc).
|
|
|
|
let PPC970_Unit = 2, mayStore = 1 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def STBUX : XForm_8<31, 247, (outs ptr_rc_nor0:$ea_res), (ins gprc:$rS, memrr:$dst),
|
2013-03-20 03:52:04 +08:00
|
|
|
"stbux $rS, $dst", LdStStoreUpd, []>,
|
2013-03-22 22:59:13 +08:00
|
|
|
RegConstraint<"$dst.ptrreg = $ea_res">, NoEncode<"$ea_res">,
|
2013-03-20 03:52:04 +08:00
|
|
|
PPC970_DGroup_Cracked;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STHUX : XForm_8<31, 439, (outs ptr_rc_nor0:$ea_res), (ins gprc:$rS, memrr:$dst),
|
2013-03-20 03:52:04 +08:00
|
|
|
"sthux $rS, $dst", LdStStoreUpd, []>,
|
2013-03-22 22:59:13 +08:00
|
|
|
RegConstraint<"$dst.ptrreg = $ea_res">, NoEncode<"$ea_res">,
|
2013-03-20 03:52:04 +08:00
|
|
|
PPC970_DGroup_Cracked;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STWUX : XForm_8<31, 183, (outs ptr_rc_nor0:$ea_res), (ins gprc:$rS, memrr:$dst),
|
2013-03-20 03:52:04 +08:00
|
|
|
"stwux $rS, $dst", LdStStoreUpd, []>,
|
2013-03-22 22:59:13 +08:00
|
|
|
RegConstraint<"$dst.ptrreg = $ea_res">, NoEncode<"$ea_res">,
|
2013-03-20 03:52:04 +08:00
|
|
|
PPC970_DGroup_Cracked;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STFSUX: XForm_8<31, 695, (outs ptr_rc_nor0:$ea_res), (ins f4rc:$rS, memrr:$dst),
|
2013-03-20 03:52:04 +08:00
|
|
|
"stfsux $rS, $dst", LdStSTFDU, []>,
|
2013-03-22 22:59:13 +08:00
|
|
|
RegConstraint<"$dst.ptrreg = $ea_res">, NoEncode<"$ea_res">,
|
2013-03-20 03:52:04 +08:00
|
|
|
PPC970_DGroup_Cracked;
|
2013-04-27 00:53:15 +08:00
|
|
|
def STFDUX: XForm_8<31, 759, (outs ptr_rc_nor0:$ea_res), (ins f8rc:$rS, memrr:$dst),
|
2013-03-20 03:52:04 +08:00
|
|
|
"stfdux $rS, $dst", LdStSTFDU, []>,
|
2013-03-22 22:59:13 +08:00
|
|
|
RegConstraint<"$dst.ptrreg = $ea_res">, NoEncode<"$ea_res">,
|
2013-03-20 03:52:04 +08:00
|
|
|
PPC970_DGroup_Cracked;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Patterns to match the pre-inc stores. We can't put the patterns on
|
|
|
|
// the instruction definitions directly as ISel wants the address base
|
|
|
|
// and offset to be separate operands, not a single complex operand.
|
2013-03-26 03:04:58 +08:00
|
|
|
def : Pat<(pre_truncsti8 i32:$rS, iPTR:$ptrreg, iPTR:$ptroff),
|
|
|
|
(STBUX $rS, $ptrreg, $ptroff)>;
|
|
|
|
def : Pat<(pre_truncsti16 i32:$rS, iPTR:$ptrreg, iPTR:$ptroff),
|
|
|
|
(STHUX $rS, $ptrreg, $ptroff)>;
|
|
|
|
def : Pat<(pre_store i32:$rS, iPTR:$ptrreg, iPTR:$ptroff),
|
|
|
|
(STWUX $rS, $ptrreg, $ptroff)>;
|
|
|
|
def : Pat<(pre_store f32:$rS, iPTR:$ptrreg, iPTR:$ptroff),
|
|
|
|
(STFSUX $rS, $ptrreg, $ptroff)>;
|
|
|
|
def : Pat<(pre_store f64:$rS, iPTR:$ptrreg, iPTR:$ptroff),
|
|
|
|
(STFDUX $rS, $ptrreg, $ptroff)>;
|
2013-03-20 03:52:04 +08:00
|
|
|
|
2008-08-23 01:20:54 +08:00
|
|
|
def SYNC : XForm_24_sync<31, 598, (outs), (ins),
|
|
|
|
"sync", LdStSync,
|
|
|
|
[(int_ppc_sync)]>;
|
2006-11-15 03:19:53 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PPC32 Arithmetic Instructions.
|
|
|
|
//
|
2006-11-08 10:13:12 +08:00
|
|
|
|
2006-03-12 17:13:49 +08:00
|
|
|
let PPC970_Unit = 1 in { // FXU Operations.
|
2013-04-27 00:53:15 +08:00
|
|
|
def ADDI : DForm_2<14, (outs gprc:$rD), (ins gprc_nor0:$rA, symbolLo:$imm),
|
2012-06-13 03:01:24 +08:00
|
|
|
"addi $rD, $rA, $imm", IntSimple,
|
Change some PowerPC PatLeaf definitions to ImmLeaf for fast-isel.
Using PatLeaf rather than ImmLeaf when defining immediate predicates
prevents simple patterns using those predicates from being recognized
for fast instruction selection. This patch replaces the immSExt16
PatLeaf predicate with two ImmLeaf predicates, imm32SExt16 and
imm64SExt16, allowing a few more patterns to be recognized (ADDI,
ADDIC, MULLI, ADDI8, and ADDIC8). Using the new predicates does not
help for LI, LI8, SUBFIC, and SUBFIC8 because these are rejected for
other reasons, but I see no reason to retain the PatLeaf predicate.
No functional change intended, and thus no test cases yet. This is
preliminary work for enabling fast-isel support for PowerPC. When
that support is ready, we'll be able to test this function.
llvm-svn: 182510
2013-05-23 04:09:24 +08:00
|
|
|
[(set i32:$rD, (add i32:$rA, imm32SExt16:$imm))]>;
|
2013-04-13 02:17:57 +08:00
|
|
|
let BaseName = "addic" in {
|
|
|
|
let Defs = [CARRY] in
|
2013-04-27 00:53:15 +08:00
|
|
|
def ADDIC : DForm_2<12, (outs gprc:$rD), (ins gprc:$rA, s16imm:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"addic $rD, $rA, $imm", IntGeneral,
|
Change some PowerPC PatLeaf definitions to ImmLeaf for fast-isel.
Using PatLeaf rather than ImmLeaf when defining immediate predicates
prevents simple patterns using those predicates from being recognized
for fast instruction selection. This patch replaces the immSExt16
PatLeaf predicate with two ImmLeaf predicates, imm32SExt16 and
imm64SExt16, allowing a few more patterns to be recognized (ADDI,
ADDIC, MULLI, ADDI8, and ADDIC8). Using the new predicates does not
help for LI, LI8, SUBFIC, and SUBFIC8 because these are rejected for
other reasons, but I see no reason to retain the PatLeaf predicate.
No functional change intended, and thus no test cases yet. This is
preliminary work for enabling fast-isel support for PowerPC. When
that support is ready, we'll be able to test this function.
llvm-svn: 182510
2013-05-23 04:09:24 +08:00
|
|
|
[(set i32:$rD, (addc i32:$rA, imm32SExt16:$imm))]>,
|
2013-04-12 10:18:09 +08:00
|
|
|
RecFormRel, PPC970_DGroup_Cracked;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CARRY, CR0] in
|
2013-04-27 00:53:15 +08:00
|
|
|
def ADDICo : DForm_2<13, (outs gprc:$rD), (ins gprc:$rA, s16imm:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"addic. $rD, $rA, $imm", IntGeneral,
|
2013-04-12 10:18:09 +08:00
|
|
|
[]>, isDOT, RecFormRel;
|
2009-09-19 04:15:22 +08:00
|
|
|
}
|
2013-04-27 00:53:15 +08:00
|
|
|
def ADDIS : DForm_2<15, (outs gprc:$rD), (ins gprc_nor0:$rA, symbolHi:$imm),
|
2012-06-13 03:01:24 +08:00
|
|
|
"addis $rD, $rA, $imm", IntSimple,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$rD, (add i32:$rA, imm16ShiftedSExt:$imm))]>;
|
2013-03-26 18:57:16 +08:00
|
|
|
let isCodeGenOnly = 1 in
|
2013-04-27 00:53:15 +08:00
|
|
|
def LA : DForm_2<14, (outs gprc:$rD), (ins gprc_nor0:$rA, symbolLo:$sym),
|
2005-10-20 03:51:16 +08:00
|
|
|
"la $rD, $sym($rA)", IntGeneral,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$rD, (add i32:$rA,
|
2005-11-18 01:52:01 +08:00
|
|
|
(PPClo tglobaladdr:$sym, 0)))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def MULLI : DForm_2< 7, (outs gprc:$rD), (ins gprc:$rA, s16imm:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"mulli $rD, $rA, $imm", IntMulLI,
|
Change some PowerPC PatLeaf definitions to ImmLeaf for fast-isel.
Using PatLeaf rather than ImmLeaf when defining immediate predicates
prevents simple patterns using those predicates from being recognized
for fast instruction selection. This patch replaces the immSExt16
PatLeaf predicate with two ImmLeaf predicates, imm32SExt16 and
imm64SExt16, allowing a few more patterns to be recognized (ADDI,
ADDIC, MULLI, ADDI8, and ADDIC8). Using the new predicates does not
help for LI, LI8, SUBFIC, and SUBFIC8 because these are rejected for
other reasons, but I see no reason to retain the PatLeaf predicate.
No functional change intended, and thus no test cases yet. This is
preliminary work for enabling fast-isel support for PowerPC. When
that support is ready, we'll be able to test this function.
llvm-svn: 182510
2013-05-23 04:09:24 +08:00
|
|
|
[(set i32:$rD, (mul i32:$rA, imm32SExt16:$imm))]>;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CARRY] in
|
2013-04-27 00:53:15 +08:00
|
|
|
def SUBFIC : DForm_2< 8, (outs gprc:$rD), (ins gprc:$rA, s16imm:$imm),
|
2005-10-20 03:51:16 +08:00
|
|
|
"subfic $rD, $rA, $imm", IntGeneral,
|
Change some PowerPC PatLeaf definitions to ImmLeaf for fast-isel.
Using PatLeaf rather than ImmLeaf when defining immediate predicates
prevents simple patterns using those predicates from being recognized
for fast instruction selection. This patch replaces the immSExt16
PatLeaf predicate with two ImmLeaf predicates, imm32SExt16 and
imm64SExt16, allowing a few more patterns to be recognized (ADDI,
ADDIC, MULLI, ADDI8, and ADDIC8). Using the new predicates does not
help for LI, LI8, SUBFIC, and SUBFIC8 because these are rejected for
other reasons, but I see no reason to retain the PatLeaf predicate.
No functional change intended, and thus no test cases yet. This is
preliminary work for enabling fast-isel support for PowerPC. When
that support is ready, we'll be able to test this function.
llvm-svn: 182510
2013-05-23 04:09:24 +08:00
|
|
|
[(set i32:$rD, (subc imm32SExt16:$imm, i32:$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...
llvm-svn: 44687
2007-12-08 05:42:31 +08:00
|
|
|
|
2012-08-28 10:10:33 +08:00
|
|
|
let isReMaterializable = 1, isAsCheapAsAMove = 1, isMoveImm = 1 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def LI : DForm_2_r0<14, (outs gprc:$rD), (ins symbolLo:$imm),
|
2012-06-13 03:01:24 +08:00
|
|
|
"li $rD, $imm", IntSimple,
|
Change some PowerPC PatLeaf definitions to ImmLeaf for fast-isel.
Using PatLeaf rather than ImmLeaf when defining immediate predicates
prevents simple patterns using those predicates from being recognized
for fast instruction selection. This patch replaces the immSExt16
PatLeaf predicate with two ImmLeaf predicates, imm32SExt16 and
imm64SExt16, allowing a few more patterns to be recognized (ADDI,
ADDIC, MULLI, ADDI8, and ADDIC8). Using the new predicates does not
help for LI, LI8, SUBFIC, and SUBFIC8 because these are rejected for
other reasons, but I see no reason to retain the PatLeaf predicate.
No functional change intended, and thus no test cases yet. This is
preliminary work for enabling fast-isel support for PowerPC. When
that support is ready, we'll be able to test this function.
llvm-svn: 182510
2013-05-23 04:09:24 +08:00
|
|
|
[(set i32:$rD, imm32SExt16:$imm)]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def LIS : DForm_2_r0<15, (outs gprc:$rD), (ins symbolHi:$imm),
|
2012-06-13 03:01:24 +08:00
|
|
|
"lis $rD, $imm", IntSimple,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$rD, imm16ShiftedSExt:$imm)]>;
|
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...
llvm-svn: 44687
2007-12-08 05:42:31 +08:00
|
|
|
}
|
2006-03-12 17:13:49 +08:00
|
|
|
}
|
2006-11-15 03:19:53 +08:00
|
|
|
|
2006-03-12 17:13:49 +08:00
|
|
|
let PPC970_Unit = 1 in { // FXU Operations.
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CR0] in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def ANDIo : DForm_4<28, (outs gprc:$dst), (ins gprc:$src1, u16imm:$src2),
|
2005-10-20 03:51:16 +08:00
|
|
|
"andi. $dst, $src1, $src2", IntGeneral,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (and i32:$src1, immZExt16:$src2))]>,
|
2006-02-12 17:09:52 +08:00
|
|
|
isDOT;
|
2013-04-27 00:53:15 +08:00
|
|
|
def ANDISo : DForm_4<29, (outs gprc:$dst), (ins gprc:$src1, u16imm:$src2),
|
2005-10-20 03:51:16 +08:00
|
|
|
"andis. $dst, $src1, $src2", IntGeneral,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (and i32:$src1, imm16ShiftedZExt:$src2))]>,
|
2006-02-12 17:09:52 +08:00
|
|
|
isDOT;
|
2013-04-13 02:17:57 +08:00
|
|
|
}
|
2013-04-27 00:53:15 +08:00
|
|
|
def ORI : DForm_4<24, (outs gprc:$dst), (ins gprc:$src1, u16imm:$src2),
|
2012-06-13 03:01:24 +08:00
|
|
|
"ori $dst, $src1, $src2", IntSimple,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (or i32:$src1, immZExt16:$src2))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def ORIS : DForm_4<25, (outs gprc:$dst), (ins gprc:$src1, u16imm:$src2),
|
2012-06-13 03:01:24 +08:00
|
|
|
"oris $dst, $src1, $src2", IntSimple,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (or i32:$src1, imm16ShiftedZExt:$src2))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def XORI : DForm_4<26, (outs gprc:$dst), (ins gprc:$src1, u16imm:$src2),
|
2012-06-13 03:01:24 +08:00
|
|
|
"xori $dst, $src1, $src2", IntSimple,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (xor i32:$src1, immZExt16:$src2))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def XORIS : DForm_4<27, (outs gprc:$dst), (ins gprc:$src1, u16imm:$src2),
|
2012-06-13 03:01:24 +08:00
|
|
|
"xoris $dst, $src1, $src2", IntSimple,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set i32:$dst, (xor i32:$src1, imm16ShiftedZExt:$src2))]>;
|
2012-06-13 03:01:24 +08:00
|
|
|
def NOP : DForm_4_zero<24, (outs), (ins), "nop", IntSimple,
|
2005-12-10 07:54:18 +08:00
|
|
|
[]>;
|
2013-04-15 10:37:46 +08:00
|
|
|
let isCompare = 1, neverHasSideEffects = 1 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def CMPWI : DForm_5_ext<11, (outs crrc:$crD), (ins gprc:$rA, s16imm:$imm),
|
2013-04-15 10:37:46 +08:00
|
|
|
"cmpwi $crD, $rA, $imm", IntCompare>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def CMPLWI : DForm_6_ext<10, (outs crrc:$dst), (ins gprc:$src1, u16imm:$src2),
|
2013-04-15 10:37:46 +08:00
|
|
|
"cmplwi $dst, $src1, $src2", IntCompare>;
|
|
|
|
}
|
2006-03-12 17:13:49 +08:00
|
|
|
}
|
2006-07-11 04:56:58 +08:00
|
|
|
|
2013-04-12 10:18:09 +08:00
|
|
|
let PPC970_Unit = 1, neverHasSideEffects = 1 in { // FXU Operations.
|
2013-04-27 00:53:15 +08:00
|
|
|
defm NAND : XForm_6r<31, 476, (outs gprc:$rA), (ins gprc:$rS, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"nand", "$rA, $rS, $rB", IntSimple,
|
|
|
|
[(set i32:$rA, (not (and i32:$rS, i32:$rB)))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm AND : XForm_6r<31, 28, (outs gprc:$rA), (ins gprc:$rS, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"and", "$rA, $rS, $rB", IntSimple,
|
|
|
|
[(set i32:$rA, (and i32:$rS, i32:$rB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm ANDC : XForm_6r<31, 60, (outs gprc:$rA), (ins gprc:$rS, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"andc", "$rA, $rS, $rB", IntSimple,
|
|
|
|
[(set i32:$rA, (and i32:$rS, (not i32:$rB)))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm OR : XForm_6r<31, 444, (outs gprc:$rA), (ins gprc:$rS, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"or", "$rA, $rS, $rB", IntSimple,
|
|
|
|
[(set i32:$rA, (or i32:$rS, i32:$rB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm NOR : XForm_6r<31, 124, (outs gprc:$rA), (ins gprc:$rS, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"nor", "$rA, $rS, $rB", IntSimple,
|
|
|
|
[(set i32:$rA, (not (or i32:$rS, i32:$rB)))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm ORC : XForm_6r<31, 412, (outs gprc:$rA), (ins gprc:$rS, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"orc", "$rA, $rS, $rB", IntSimple,
|
|
|
|
[(set i32:$rA, (or i32:$rS, (not i32:$rB)))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm EQV : XForm_6r<31, 284, (outs gprc:$rA), (ins gprc:$rS, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"eqv", "$rA, $rS, $rB", IntSimple,
|
|
|
|
[(set i32:$rA, (not (xor i32:$rS, i32:$rB)))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm XOR : XForm_6r<31, 316, (outs gprc:$rA), (ins gprc:$rS, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"xor", "$rA, $rS, $rB", IntSimple,
|
|
|
|
[(set i32:$rA, (xor i32:$rS, i32:$rB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm SLW : XForm_6r<31, 24, (outs gprc:$rA), (ins gprc:$rS, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"slw", "$rA, $rS, $rB", IntGeneral,
|
|
|
|
[(set i32:$rA, (PPCshl i32:$rS, i32:$rB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm SRW : XForm_6r<31, 536, (outs gprc:$rA), (ins gprc:$rS, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"srw", "$rA, $rS, $rB", IntGeneral,
|
|
|
|
[(set i32:$rA, (PPCsrl i32:$rS, i32:$rB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm SRAW : XForm_6rc<31, 792, (outs gprc:$rA), (ins gprc:$rS, gprc:$rB),
|
2013-04-13 02:17:57 +08:00
|
|
|
"sraw", "$rA, $rS, $rB", IntShift,
|
|
|
|
[(set i32:$rA, (PPCsra i32:$rS, i32:$rB))]>;
|
2009-09-19 04:15:22 +08:00
|
|
|
}
|
2006-11-15 03:19:53 +08:00
|
|
|
|
2006-03-12 17:13:49 +08:00
|
|
|
let PPC970_Unit = 1 in { // FXU Operations.
|
2013-04-12 10:18:09 +08:00
|
|
|
let neverHasSideEffects = 1 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
defm SRAWI : XForm_10rc<31, 824, (outs gprc:$rA), (ins gprc:$rS, u5imm:$SH),
|
2013-04-13 02:17:57 +08:00
|
|
|
"srawi", "$rA, $rS, $SH", IntShift,
|
|
|
|
[(set i32:$rA, (sra i32:$rS, (i32 imm:$SH)))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm CNTLZW : XForm_11r<31, 26, (outs gprc:$rA), (ins gprc:$rS),
|
2013-04-12 10:18:09 +08:00
|
|
|
"cntlzw", "$rA, $rS", IntGeneral,
|
|
|
|
[(set i32:$rA, (ctlz i32:$rS))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm EXTSB : XForm_11r<31, 954, (outs gprc:$rA), (ins gprc:$rS),
|
2013-04-12 10:18:09 +08:00
|
|
|
"extsb", "$rA, $rS", IntSimple,
|
|
|
|
[(set i32:$rA, (sext_inreg i32:$rS, i8))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm EXTSH : XForm_11r<31, 922, (outs gprc:$rA), (ins gprc:$rS),
|
2013-04-12 10:18:09 +08:00
|
|
|
"extsh", "$rA, $rS", IntSimple,
|
|
|
|
[(set i32:$rA, (sext_inreg i32:$rS, i16))]>;
|
|
|
|
}
|
2013-04-15 10:37:46 +08:00
|
|
|
let isCompare = 1, neverHasSideEffects = 1 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def CMPW : XForm_16_ext<31, 0, (outs crrc:$crD), (ins gprc:$rA, gprc:$rB),
|
2013-04-15 10:37:46 +08:00
|
|
|
"cmpw $crD, $rA, $rB", IntCompare>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def CMPLW : XForm_16_ext<31, 32, (outs crrc:$crD), (ins gprc:$rA, gprc:$rB),
|
2013-04-15 10:37:46 +08:00
|
|
|
"cmplw $crD, $rA, $rB", IntCompare>;
|
|
|
|
}
|
2006-03-12 17:13:49 +08: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))]>;
llvm-svn: 40033
2007-07-19 09:14:50 +08:00
|
|
|
//def FCMPO : XForm_17<63, 32, (outs CRRC:$crD), (ins FPRC:$fA, FPRC:$fB),
|
2005-10-20 03:51:16 +08:00
|
|
|
// "fcmpo $crD, $fA, $fB", FPCompare>;
|
2013-04-15 10:37:46 +08:00
|
|
|
let isCompare = 1, neverHasSideEffects = 1 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def FCMPUS : XForm_17<63, 0, (outs crrc:$crD), (ins f4rc:$fA, f4rc:$fB),
|
2013-04-15 10:37:46 +08:00
|
|
|
"fcmpu $crD, $fA, $fB", FPCompare>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def FCMPUD : XForm_17<63, 0, (outs crrc:$crD), (ins f8rc:$fA, f8rc:$fB),
|
2013-04-15 10:37:46 +08:00
|
|
|
"fcmpu $crD, $fA, $fB", FPCompare>;
|
|
|
|
}
|
2006-11-15 03:19:53 +08:00
|
|
|
|
2008-10-30 02:26:45 +08:00
|
|
|
let Uses = [RM] in {
|
2013-04-12 10:18:09 +08:00
|
|
|
let neverHasSideEffects = 1 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FCTIWZ : XForm_26r<63, 15, (outs f8rc:$frD), (ins f8rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fctiwz", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f64:$frD, (PPCfctiwz f64:$frB))]>;
|
2013-03-29 16:57:48 +08:00
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FRSP : XForm_26r<63, 12, (outs f4rc:$frD), (ins f8rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"frsp", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f32:$frD, (fround f64:$frB))]>;
|
2013-03-29 16:57:48 +08:00
|
|
|
|
|
|
|
// The frin -> nearbyint mapping is valid only in fast-math mode.
|
2013-04-12 10:18:09 +08:00
|
|
|
let Interpretation64Bit = 1 in
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FRIND : XForm_26r<63, 392, (outs f8rc:$frD), (ins f8rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"frin", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f64:$frD, (fnearbyint f64:$frB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FRINS : XForm_26r<63, 392, (outs f4rc:$frD), (ins f4rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"frin", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f32:$frD, (fnearbyint f32:$frB))]>;
|
|
|
|
}
|
2013-03-29 16:57:48 +08:00
|
|
|
|
2013-03-30 03:41:55 +08:00
|
|
|
// These pseudos expand to rint but also set FE_INEXACT when the result does
|
|
|
|
// not equal the argument.
|
|
|
|
let usesCustomInserter = 1, Defs = [RM] in { // FIXME: Model FPSCR!
|
2013-04-27 00:53:15 +08:00
|
|
|
def FRINDrint : Pseudo<(outs f8rc:$frD), (ins f8rc:$frB),
|
2013-03-30 03:41:55 +08:00
|
|
|
"#FRINDrint", [(set f64:$frD, (frint f64:$frB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
def FRINSrint : Pseudo<(outs f4rc:$frD), (ins f4rc:$frB),
|
2013-03-30 03:41:55 +08:00
|
|
|
"#FRINSrint", [(set f32:$frD, (frint f32:$frB))]>;
|
|
|
|
}
|
|
|
|
|
2013-04-12 10:18:09 +08:00
|
|
|
let neverHasSideEffects = 1 in {
|
|
|
|
let Interpretation64Bit = 1 in
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FRIPD : XForm_26r<63, 456, (outs f8rc:$frD), (ins f8rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"frip", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f64:$frD, (fceil f64:$frB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FRIPS : XForm_26r<63, 456, (outs f4rc:$frD), (ins f4rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"frip", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f32:$frD, (fceil f32:$frB))]>;
|
|
|
|
let Interpretation64Bit = 1 in
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FRIZD : XForm_26r<63, 424, (outs f8rc:$frD), (ins f8rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"friz", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f64:$frD, (ftrunc f64:$frB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FRIZS : XForm_26r<63, 424, (outs f4rc:$frD), (ins f4rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"friz", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f32:$frD, (ftrunc f32:$frB))]>;
|
|
|
|
let Interpretation64Bit = 1 in
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FRIMD : XForm_26r<63, 488, (outs f8rc:$frD), (ins f8rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"frim", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f64:$frD, (ffloor f64:$frB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FRIMS : XForm_26r<63, 488, (outs f4rc:$frD), (ins f4rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"frim", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f32:$frD, (ffloor f32:$frB))]>;
|
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FSQRT : XForm_26r<63, 22, (outs f8rc:$frD), (ins f8rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fsqrt", "$frD, $frB", FPSqrt,
|
|
|
|
[(set f64:$frD, (fsqrt f64:$frB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FSQRTS : XForm_26r<59, 22, (outs f4rc:$frD), (ins f4rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fsqrts", "$frD, $frB", FPSqrt,
|
|
|
|
[(set f32:$frD, (fsqrt f32:$frB))]>;
|
|
|
|
}
|
2008-10-30 02:26:45 +08:00
|
|
|
}
|
2006-03-12 17:13:49 +08:00
|
|
|
}
|
2005-10-01 09:35:02 +08:00
|
|
|
|
2010-07-17 05:03:52 +08:00
|
|
|
/// Note that FMR is defined as pseudo-ops on the PPC970 because they are
|
2006-03-24 15:12:19 +08:00
|
|
|
/// often coalesced away and we don't want the dispatch group builder to think
|
2006-03-12 17:13:49 +08:00
|
|
|
/// that they will fill slots (which could cause the load of a LSU reject to
|
|
|
|
/// sneak into a d-group with a store).
|
2013-04-07 12:56:16 +08:00
|
|
|
let neverHasSideEffects = 1 in
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FMR : XForm_26r<63, 72, (outs f4rc:$frD), (ins f4rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fmr", "$frD, $frB", FPGeneral,
|
|
|
|
[]>, // (set f32:$frD, f32:$frB)
|
|
|
|
PPC970_Unit_Pseudo;
|
2005-10-01 09:35:02 +08:00
|
|
|
|
2013-04-12 10:18:09 +08:00
|
|
|
let PPC970_Unit = 3, neverHasSideEffects = 1 in { // FPU Operations.
|
2005-10-01 09:35:02 +08:00
|
|
|
// These are artificially split into two different forms, for 4/8 byte FP.
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FABSS : XForm_26r<63, 264, (outs f4rc:$frD), (ins f4rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fabs", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f32:$frD, (fabs f32:$frB))]>;
|
|
|
|
let Interpretation64Bit = 1 in
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FABSD : XForm_26r<63, 264, (outs f8rc:$frD), (ins f8rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fabs", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f64:$frD, (fabs f64:$frB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FNABSS : XForm_26r<63, 136, (outs f4rc:$frD), (ins f4rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fnabs", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f32:$frD, (fneg (fabs f32:$frB)))]>;
|
|
|
|
let Interpretation64Bit = 1 in
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FNABSD : XForm_26r<63, 136, (outs f8rc:$frD), (ins f8rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fnabs", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f64:$frD, (fneg (fabs f64:$frB)))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FNEGS : XForm_26r<63, 40, (outs f4rc:$frD), (ins f4rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fneg", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f32:$frD, (fneg f32:$frB))]>;
|
|
|
|
let Interpretation64Bit = 1 in
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FNEGD : XForm_26r<63, 40, (outs f8rc:$frD), (ins f8rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fneg", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f64:$frD, (fneg f64:$frB))]>;
|
2013-04-03 12:01:11 +08:00
|
|
|
|
|
|
|
// Reciprocal estimates.
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FRE : XForm_26r<63, 24, (outs f8rc:$frD), (ins f8rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fre", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f64:$frD, (PPCfre f64:$frB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FRES : XForm_26r<59, 24, (outs f4rc:$frD), (ins f4rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fres", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f32:$frD, (PPCfre f32:$frB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FRSQRTE : XForm_26r<63, 26, (outs f8rc:$frD), (ins f8rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"frsqrte", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f64:$frD, (PPCfrsqrte f64:$frB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm FRSQRTES : XForm_26r<59, 26, (outs f4rc:$frD), (ins f4rc:$frB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"frsqrtes", "$frD, $frB", FPGeneral,
|
|
|
|
[(set f32:$frD, (PPCfrsqrte f32:$frB))]>;
|
2006-03-12 17:13:49 +08:00
|
|
|
}
|
2004-08-30 06:45:13 +08:00
|
|
|
|
2004-08-30 10:28:06 +08:00
|
|
|
// XL-Form instructions. condition register logical ops.
|
|
|
|
//
|
2013-04-07 13:16:57 +08:00
|
|
|
let neverHasSideEffects = 1 in
|
2013-04-27 00:53:15 +08:00
|
|
|
def MCRF : XLForm_3<19, 0, (outs crrc:$BF), (ins crrc:$BFA),
|
2006-03-12 17:13:49 +08:00
|
|
|
"mcrf $BF, $BFA", BrMCR>,
|
|
|
|
PPC970_DGroup_First, PPC970_Unit_CRU;
|
2004-08-30 10:28:06 +08:00
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def CREQV : XLForm_1<19, 289, (outs crbitrc:$CRD),
|
|
|
|
(ins crbitrc:$CRA, crbitrc:$CRB),
|
2007-02-25 13:34:32 +08:00
|
|
|
"creqv $CRD, $CRA, $CRB", BrCR,
|
|
|
|
[]>;
|
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def CROR : XLForm_1<19, 449, (outs crbitrc:$CRD),
|
|
|
|
(ins crbitrc:$CRA, crbitrc:$CRB),
|
2008-03-10 22:12:10 +08:00
|
|
|
"cror $CRD, $CRA, $CRB", BrCR,
|
|
|
|
[]>;
|
|
|
|
|
2013-03-26 18:57:16 +08:00
|
|
|
let isCodeGenOnly = 1 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def CRSET : XLForm_1_ext<19, 289, (outs crbitrc:$dst), (ins),
|
2007-02-25 13:34:32 +08:00
|
|
|
"creqv $dst, $dst, $dst", BrCR,
|
|
|
|
[]>;
|
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def CRUNSET: XLForm_1_ext<19, 193, (outs crbitrc:$dst), (ins),
|
2011-08-31 01:04:16 +08:00
|
|
|
"crxor $dst, $dst, $dst", BrCR,
|
|
|
|
[]>;
|
|
|
|
|
2012-08-28 10:10:27 +08:00
|
|
|
let Defs = [CR1EQ], CRD = 6 in {
|
|
|
|
def CR6SET : XLForm_1_ext<19, 289, (outs), (ins),
|
|
|
|
"creqv 6, 6, 6", BrCR,
|
|
|
|
[(PPCcr6set)]>;
|
|
|
|
|
|
|
|
def CR6UNSET: XLForm_1_ext<19, 193, (outs), (ins),
|
|
|
|
"crxor 6, 6, 6", BrCR,
|
|
|
|
[(PPCcr6unset)]>;
|
|
|
|
}
|
2013-03-26 18:57:16 +08:00
|
|
|
}
|
2012-08-28 10:10:27 +08:00
|
|
|
|
2006-03-12 17:13:49 +08:00
|
|
|
// XFX-Form instructions. Instructions that deal with SPRs.
|
2004-08-30 10:28:06 +08:00
|
|
|
//
|
2008-10-24 04:41:28 +08:00
|
|
|
let Uses = [CTR] in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def MFCTR : XFXForm_1_ext<31, 339, 9, (outs gprc:$rT), (ins),
|
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))]>;
llvm-svn: 40033
2007-07-19 09:14:50 +08:00
|
|
|
"mfctr $rT", SprMFSPR>,
|
2006-03-12 17:13:49 +08:00
|
|
|
PPC970_DGroup_First, PPC970_Unit_FXU;
|
2008-10-24 04:41:28 +08:00
|
|
|
}
|
2013-03-26 03:05:30 +08:00
|
|
|
let Defs = [CTR], Pattern = [(PPCmtctr i32:$rS)] in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def MTCTR : XFXForm_7_ext<31, 467, 9, (outs), (ins 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))]>;
llvm-svn: 40033
2007-07-19 09:14:50 +08:00
|
|
|
"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
llvm-svn: 26733
2006-03-14 05:52:10 +08:00
|
|
|
PPC970_DGroup_First, PPC970_Unit_FXU;
|
2006-05-18 03:00:46 +08:00
|
|
|
}
|
Implement PPC counter loops as a late IR-level pass
The old PPCCTRLoops pass, like the Hexagon pass version from which it was
derived, could only handle some simple loops in canonical form. We cannot
directly adapt the new Hexagon hardware loops pass, however, because the
Hexagon pass contains a fundamental assumption that non-constant-trip-count
loops will contain a guard, and this is not always true (the result being that
incorrect negative counts can be generated). With this commit, we replace the
pass with a late IR-level pass which makes use of SE to calculate the
backedge-taken counts and safely generate the loop-count expressions (including
any necessary max() parts). This IR level pass inserts custom intrinsics that
are lowered into the desired decrement-and-branch instructions.
The most fragile part of this new implementation is that interfering uses of
the counter register must be detected on the IR level (and, on PPC, this also
includes any indirect branches in addition to function calls). Also, to make
all of this work, we need a variant of the mtctr instruction that is marked
as having side effects. Without this, machine-code level CSE, DCE, etc.
illegally transform the resulting code. Hopefully, this can be improved
in the future.
This new pass is smaller than the original (and much smaller than the new
Hexagon hardware loops pass), and can handle many additional cases correctly.
In addition, the preheader-creation code has been copied from LoopSimplify, and
after we decide on where it belongs, this code will be refactored so that it
can be explicitly shared (making this implementation even smaller).
The new test-case files ctrloop-{le,lt,ne}.ll have been adapted from tests for
the new Hexagon pass. There are a few classes of loops that this pass does not
transform (noted by FIXMEs in the files), but these deficiencies can be
addressed within the SE infrastructure (thus helping many other passes as well).
llvm-svn: 181927
2013-05-16 05:37:41 +08:00
|
|
|
let hasSideEffects = 1, isCodeGenOnly = 1, Defs = [CTR] in {
|
|
|
|
let Pattern = [(int_ppc_mtctr i32:$rS)] in
|
2013-05-21 00:08:37 +08:00
|
|
|
def MTCTRloop : XFXForm_7_ext<31, 467, 9, (outs), (ins gprc:$rS),
|
|
|
|
"mtctr $rS", SprMTSPR>,
|
|
|
|
PPC970_DGroup_First, PPC970_Unit_FXU;
|
Implement PPC counter loops as a late IR-level pass
The old PPCCTRLoops pass, like the Hexagon pass version from which it was
derived, could only handle some simple loops in canonical form. We cannot
directly adapt the new Hexagon hardware loops pass, however, because the
Hexagon pass contains a fundamental assumption that non-constant-trip-count
loops will contain a guard, and this is not always true (the result being that
incorrect negative counts can be generated). With this commit, we replace the
pass with a late IR-level pass which makes use of SE to calculate the
backedge-taken counts and safely generate the loop-count expressions (including
any necessary max() parts). This IR level pass inserts custom intrinsics that
are lowered into the desired decrement-and-branch instructions.
The most fragile part of this new implementation is that interfering uses of
the counter register must be detected on the IR level (and, on PPC, this also
includes any indirect branches in addition to function calls). Also, to make
all of this work, we need a variant of the mtctr instruction that is marked
as having side effects. Without this, machine-code level CSE, DCE, etc.
illegally transform the resulting code. Hopefully, this can be improved
in the future.
This new pass is smaller than the original (and much smaller than the new
Hexagon hardware loops pass), and can handle many additional cases correctly.
In addition, the preheader-creation code has been copied from LoopSimplify, and
after we decide on where it belongs, this code will be refactored so that it
can be explicitly shared (making this implementation even smaller).
The new test-case files ctrloop-{le,lt,ne}.ll have been adapted from tests for
the new Hexagon pass. There are a few classes of loops that this pass does not
transform (noted by FIXMEs in the files), but these deficiencies can be
addressed within the SE infrastructure (thus helping many other passes as well).
llvm-svn: 181927
2013-05-16 05:37:41 +08: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
llvm-svn: 26733
2006-03-14 05:52:10 +08:00
|
|
|
|
2008-10-24 04:41:28 +08:00
|
|
|
let Defs = [LR] in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def MTLR : XFXForm_7_ext<31, 467, 8, (outs), (ins 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))]>;
llvm-svn: 40033
2007-07-19 09:14:50 +08:00
|
|
|
"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
llvm-svn: 26733
2006-03-14 05:52:10 +08:00
|
|
|
PPC970_DGroup_First, PPC970_Unit_FXU;
|
2008-10-24 04:41:28 +08:00
|
|
|
}
|
|
|
|
let Uses = [LR] in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def MFLR : XFXForm_1_ext<31, 339, 8, (outs gprc:$rT), (ins),
|
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))]>;
llvm-svn: 40033
2007-07-19 09:14:50 +08:00
|
|
|
"mflr $rT", SprMFSPR>,
|
2006-03-12 17:13:49 +08:00
|
|
|
PPC970_DGroup_First, PPC970_Unit_FXU;
|
2008-10-24 04:41:28 +08: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
llvm-svn: 26733
2006-03-14 05:52:10 +08: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.
|
2013-04-27 00:53:15 +08: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
llvm-svn: 26733
2006-03-14 05:52:10 +08:00
|
|
|
"mtspr 256, $rS", IntGeneral>,
|
2006-03-15 13:25:05 +08:00
|
|
|
PPC970_DGroup_Single, PPC970_Unit_FXU;
|
2013-04-27 00:53:15 +08: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
llvm-svn: 26733
2006-03-14 05:52:10 +08:00
|
|
|
"mfspr $rT, 256", IntGeneral>,
|
2006-03-15 13:25:05 +08: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
llvm-svn: 26733
2006-03-14 05:52:10 +08:00
|
|
|
|
2013-03-22 03:03:21 +08:00
|
|
|
let isCodeGenOnly = 1 in {
|
|
|
|
def MTVRSAVEv : XFXForm_7_ext<31, 467, 256,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs VRSAVERC:$reg), (ins gprc:$rS),
|
2013-03-22 03:03:21 +08:00
|
|
|
"mtspr 256, $rS", IntGeneral>,
|
|
|
|
PPC970_DGroup_Single, PPC970_Unit_FXU;
|
2013-04-27 00:53:15 +08:00
|
|
|
def MFVRSAVEv : XFXForm_1_ext<31, 339, 256, (outs gprc:$rT),
|
2013-03-22 03:03:21 +08:00
|
|
|
(ins VRSAVERC:$reg),
|
|
|
|
"mfspr $rT, 256", IntGeneral>,
|
|
|
|
PPC970_DGroup_First, PPC970_Unit_FXU;
|
|
|
|
}
|
|
|
|
|
|
|
|
// SPILL_VRSAVE - Indicate that we're dumping the VRSAVE register,
|
|
|
|
// so we'll need to scavenge a register for it.
|
|
|
|
let mayStore = 1 in
|
|
|
|
def SPILL_VRSAVE : Pseudo<(outs), (ins VRSAVERC:$vrsave, memri:$F),
|
|
|
|
"#SPILL_VRSAVE", []>;
|
|
|
|
|
|
|
|
// RESTORE_VRSAVE - Indicate that we're restoring the VRSAVE register (previously
|
|
|
|
// spilled), so we'll need to scavenge a register for it.
|
|
|
|
let mayLoad = 1 in
|
|
|
|
def RESTORE_VRSAVE : Pseudo<(outs VRSAVERC:$vrsave), (ins memri:$F),
|
|
|
|
"#RESTORE_VRSAVE", []>;
|
|
|
|
|
2013-04-07 22:33:13 +08:00
|
|
|
let neverHasSideEffects = 1 in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def MTCRF : XFXForm_5<31, 144, (outs crbitm:$FXM), (ins gprc:$rS),
|
2006-03-12 17:13:49 +08:00
|
|
|
"mtcrf $FXM, $rS", BrMCRX>,
|
|
|
|
PPC970_MicroCode, PPC970_Unit_CRU;
|
2010-05-21 01:48:26 +08:00
|
|
|
|
|
|
|
// This is a pseudo for MFCR, which implicitly uses all 8 of its subregisters;
|
|
|
|
// declaring that here gives the local register allocator problems with this:
|
2008-10-30 02:26:45 +08:00
|
|
|
// vreg = MCRF CR0
|
|
|
|
// MFCR <kill of whatever preg got assigned to vreg>
|
2010-05-21 01:48:26 +08:00
|
|
|
// while not declaring it breaks DeadMachineInstructionElimination.
|
|
|
|
// As it turns out, in all cases where we currently use this,
|
|
|
|
// we're only interested in one subregister of it. Represent this in the
|
|
|
|
// instruction to keep the register allocator from becoming confused.
|
2010-11-15 06:03:15 +08:00
|
|
|
//
|
|
|
|
// FIXME: Make this a real Pseudo instruction when the JIT switches to MC.
|
2013-03-26 18:57:16 +08:00
|
|
|
let isCodeGenOnly = 1 in
|
2013-04-27 00:53:15 +08:00
|
|
|
def MFCRpseud: XFXForm_3<31, 19, (outs gprc:$rT), (ins crbitm:$FXM),
|
2012-10-05 02:14:28 +08:00
|
|
|
"#MFCRpseud", SprMFCR>,
|
2006-03-26 18:06:40 +08:00
|
|
|
PPC970_MicroCode, PPC970_Unit_CRU;
|
2010-11-15 06:03:15 +08:00
|
|
|
|
2013-04-27 00:53:15 +08:00
|
|
|
def MFOCRF: XFXForm_5a<31, 19, (outs gprc:$rT), (ins crbitm:$FXM),
|
2012-06-11 23:43:15 +08:00
|
|
|
"mfocrf $rT, $FXM", SprMFCR>,
|
2006-03-12 17:13:49 +08:00
|
|
|
PPC970_DGroup_First, PPC970_Unit_CRU;
|
2013-04-07 22:33:13 +08:00
|
|
|
} // neverHasSideEffects = 1
|
|
|
|
|
2013-04-14 07:06:15 +08:00
|
|
|
let neverHasSideEffects = 1 in
|
2013-04-27 00:53:15 +08:00
|
|
|
def MFCR : XFXForm_3<31, 19, (outs gprc:$rT), (ins),
|
2013-04-07 22:33:13 +08:00
|
|
|
"mfcr $rT", SprMFCR>,
|
|
|
|
PPC970_MicroCode, PPC970_Unit_CRU;
|
2004-08-30 10:28:06 +08:00
|
|
|
|
2013-03-26 18:56:22 +08:00
|
|
|
// Pseudo instruction to perform FADD in round-to-zero mode.
|
|
|
|
let usesCustomInserter = 1, Uses = [RM] in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def FADDrtz: Pseudo<(outs f8rc:$FRT), (ins f8rc:$FRA, f8rc:$FRB), "",
|
2013-03-26 18:56:22 +08:00
|
|
|
[(set f64:$FRT, (PPCfaddrtz f64:$FRA, f64:$FRB))]>;
|
|
|
|
}
|
2007-10-10 09:01:31 +08:00
|
|
|
|
2013-03-26 18:56:22 +08:00
|
|
|
// The above pseudo gets expanded to make use of the following instructions
|
|
|
|
// to manipulate FPSCR. Note that FPSCR is not modeled at the DAG level.
|
2008-10-30 02:26:45 +08:00
|
|
|
let Uses = [RM], Defs = [RM] in {
|
|
|
|
def MTFSB0 : XForm_43<63, 70, (outs), (ins u5imm:$FM),
|
2013-03-26 18:56:22 +08:00
|
|
|
"mtfsb0 $FM", IntMTFSB0, []>,
|
2008-10-30 02:26:45 +08:00
|
|
|
PPC970_DGroup_Single, PPC970_Unit_FPU;
|
|
|
|
def MTFSB1 : XForm_43<63, 38, (outs), (ins u5imm:$FM),
|
2013-03-26 18:56:22 +08:00
|
|
|
"mtfsb1 $FM", IntMTFSB0, []>,
|
2008-10-30 02:26:45 +08:00
|
|
|
PPC970_DGroup_Single, PPC970_Unit_FPU;
|
2013-04-27 00:53:15 +08:00
|
|
|
def MTFSF : XFLForm<63, 711, (outs), (ins i32imm:$FM, f8rc:$rT),
|
2013-03-26 18:56:22 +08:00
|
|
|
"mtfsf $FM, $rT", IntMTFSB0, []>,
|
2008-10-30 02:26:45 +08:00
|
|
|
PPC970_DGroup_Single, PPC970_Unit_FPU;
|
|
|
|
}
|
|
|
|
let Uses = [RM] in {
|
2013-04-27 00:53:15 +08:00
|
|
|
def MFFS : XForm_42<63, 583, (outs f8rc:$rT), (ins),
|
2008-10-30 02:26:45 +08:00
|
|
|
"mffs $rT", IntMFFS,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set f64:$rT, (PPCmffs))]>,
|
2008-10-30 02:26:45 +08:00
|
|
|
PPC970_DGroup_Single, PPC970_Unit_FPU;
|
|
|
|
}
|
|
|
|
|
2007-10-10 09:01:31 +08:00
|
|
|
|
2013-04-12 10:18:09 +08:00
|
|
|
let PPC970_Unit = 1, neverHasSideEffects = 1 in { // FXU Operations.
|
2004-08-30 10:28:06 +08:00
|
|
|
// XO-Form instructions. Arithmetic instructions that can set overflow bit
|
|
|
|
//
|
2013-04-27 00:53:15 +08:00
|
|
|
defm ADD4 : XOForm_1r<31, 266, 0, (outs gprc:$rT), (ins gprc:$rA, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"add", "$rT, $rA, $rB", IntSimple,
|
|
|
|
[(set i32:$rT, (add i32:$rA, i32:$rB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm ADDC : XOForm_1rc<31, 10, 0, (outs gprc:$rT), (ins gprc:$rA, gprc:$rB),
|
2013-04-13 02:17:57 +08:00
|
|
|
"addc", "$rT, $rA, $rB", IntGeneral,
|
|
|
|
[(set i32:$rT, (addc i32:$rA, i32:$rB))]>,
|
|
|
|
PPC970_DGroup_Cracked;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm DIVW : XOForm_1r<31, 491, 0, (outs gprc:$rT), (ins gprc:$rA, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"divw", "$rT, $rA, $rB", IntDivW,
|
|
|
|
[(set i32:$rT, (sdiv i32:$rA, i32:$rB))]>,
|
|
|
|
PPC970_DGroup_First, PPC970_DGroup_Cracked;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm DIVWU : XOForm_1r<31, 459, 0, (outs gprc:$rT), (ins gprc:$rA, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"divwu", "$rT, $rA, $rB", IntDivW,
|
|
|
|
[(set i32:$rT, (udiv i32:$rA, i32:$rB))]>,
|
|
|
|
PPC970_DGroup_First, PPC970_DGroup_Cracked;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm MULHW : XOForm_1r<31, 75, 0, (outs gprc:$rT), (ins gprc:$rA, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"mulhw", "$rT, $rA, $rB", IntMulHW,
|
|
|
|
[(set i32:$rT, (mulhs i32:$rA, i32:$rB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm MULHWU : XOForm_1r<31, 11, 0, (outs gprc:$rT), (ins gprc:$rA, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"mulhwu", "$rT, $rA, $rB", IntMulHWU,
|
|
|
|
[(set i32:$rT, (mulhu i32:$rA, i32:$rB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm MULLW : XOForm_1r<31, 235, 0, (outs gprc:$rT), (ins gprc:$rA, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"mullw", "$rT, $rA, $rB", IntMulHW,
|
|
|
|
[(set i32:$rT, (mul i32:$rA, i32:$rB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm SUBF : XOForm_1r<31, 40, 0, (outs gprc:$rT), (ins gprc:$rA, gprc:$rB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"subf", "$rT, $rA, $rB", IntGeneral,
|
|
|
|
[(set i32:$rT, (sub i32:$rB, i32:$rA))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm SUBFC : XOForm_1rc<31, 8, 0, (outs gprc:$rT), (ins gprc:$rA, gprc:$rB),
|
2013-04-13 02:17:57 +08:00
|
|
|
"subfc", "$rT, $rA, $rB", IntGeneral,
|
|
|
|
[(set i32:$rT, (subc i32:$rB, i32:$rA))]>,
|
|
|
|
PPC970_DGroup_Cracked;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm NEG : XOForm_3r<31, 104, 0, (outs gprc:$rT), (ins gprc:$rA),
|
2013-04-12 10:18:09 +08:00
|
|
|
"neg", "$rT, $rA", IntSimple,
|
|
|
|
[(set i32:$rT, (ineg i32:$rA))]>;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Uses = [CARRY] in {
|
2013-04-27 00:53:15 +08:00
|
|
|
defm ADDE : XOForm_1rc<31, 138, 0, (outs gprc:$rT), (ins gprc:$rA, gprc:$rB),
|
2013-04-13 02:17:57 +08:00
|
|
|
"adde", "$rT, $rA, $rB", IntGeneral,
|
|
|
|
[(set i32:$rT, (adde i32:$rA, i32:$rB))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm ADDME : XOForm_3rc<31, 234, 0, (outs gprc:$rT), (ins gprc:$rA),
|
2013-04-13 02:17:57 +08:00
|
|
|
"addme", "$rT, $rA", IntGeneral,
|
|
|
|
[(set i32:$rT, (adde i32:$rA, -1))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm ADDZE : XOForm_3rc<31, 202, 0, (outs gprc:$rT), (ins gprc:$rA),
|
2013-04-13 02:17:57 +08:00
|
|
|
"addze", "$rT, $rA", IntGeneral,
|
|
|
|
[(set i32:$rT, (adde i32:$rA, 0))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm SUBFE : XOForm_1rc<31, 136, 0, (outs gprc:$rT), (ins gprc:$rA, gprc:$rB),
|
2013-04-13 02:17:57 +08:00
|
|
|
"subfe", "$rT, $rA, $rB", IntGeneral,
|
|
|
|
[(set i32:$rT, (sube i32:$rB, i32:$rA))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm SUBFME : XOForm_3rc<31, 232, 0, (outs gprc:$rT), (ins gprc:$rA),
|
2013-04-13 02:17:57 +08:00
|
|
|
"subfme", "$rT, $rA", IntGeneral,
|
|
|
|
[(set i32:$rT, (sube -1, i32:$rA))]>;
|
2013-04-27 00:53:15 +08:00
|
|
|
defm SUBFZE : XOForm_3rc<31, 200, 0, (outs gprc:$rT), (ins gprc:$rA),
|
2013-04-13 02:17:57 +08:00
|
|
|
"subfze", "$rT, $rA", IntGeneral,
|
|
|
|
[(set i32:$rT, (sube 0, i32:$rA))]>;
|
2006-03-12 17:13:49 +08:00
|
|
|
}
|
2009-09-19 04:15:22 +08:00
|
|
|
}
|
2004-08-30 10:28:06 +08:00
|
|
|
|
|
|
|
// A-Form instructions. Most of the instructions executed in the FPU are of
|
|
|
|
// this type.
|
|
|
|
//
|
2013-04-12 10:18:09 +08:00
|
|
|
let PPC970_Unit = 3, neverHasSideEffects = 1 in { // FPU Operations.
|
2008-10-30 02:26:45 +08:00
|
|
|
let Uses = [RM] in {
|
2013-04-12 10:18:09 +08:00
|
|
|
defm FMADD : AForm_1r<63, 29,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f8rc:$FRT), (ins f8rc:$FRA, f8rc:$FRC, f8rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fmadd", "$FRT, $FRA, $FRC, $FRB", FPFused,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set f64:$FRT, (fma f64:$FRA, f64:$FRC, f64:$FRB))]>;
|
2013-04-12 10:18:09 +08:00
|
|
|
defm FMADDS : AForm_1r<59, 29,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f4rc:$FRT), (ins f4rc:$FRA, f4rc:$FRC, f4rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fmadds", "$FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set f32:$FRT, (fma f32:$FRA, f32:$FRC, f32:$FRB))]>;
|
2013-04-12 10:18:09 +08:00
|
|
|
defm FMSUB : AForm_1r<63, 28,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f8rc:$FRT), (ins f8rc:$FRA, f8rc:$FRC, f8rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fmsub", "$FRT, $FRA, $FRC, $FRB", FPFused,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set f64:$FRT,
|
|
|
|
(fma f64:$FRA, f64:$FRC, (fneg f64:$FRB)))]>;
|
2013-04-12 10:18:09 +08:00
|
|
|
defm FMSUBS : AForm_1r<59, 28,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f4rc:$FRT), (ins f4rc:$FRA, f4rc:$FRC, f4rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fmsubs", "$FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set f32:$FRT,
|
|
|
|
(fma f32:$FRA, f32:$FRC, (fneg f32:$FRB)))]>;
|
2013-04-12 10:18:09 +08:00
|
|
|
defm FNMADD : AForm_1r<63, 31,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f8rc:$FRT), (ins f8rc:$FRA, f8rc:$FRC, f8rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fnmadd", "$FRT, $FRA, $FRC, $FRB", FPFused,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set f64:$FRT,
|
|
|
|
(fneg (fma f64:$FRA, f64:$FRC, f64:$FRB)))]>;
|
2013-04-12 10:18:09 +08:00
|
|
|
defm FNMADDS : AForm_1r<59, 31,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f4rc:$FRT), (ins f4rc:$FRA, f4rc:$FRC, f4rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fnmadds", "$FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set f32:$FRT,
|
|
|
|
(fneg (fma f32:$FRA, f32:$FRC, f32:$FRB)))]>;
|
2013-04-12 10:18:09 +08:00
|
|
|
defm FNMSUB : AForm_1r<63, 30,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f8rc:$FRT), (ins f8rc:$FRA, f8rc:$FRC, f8rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fnmsub", "$FRT, $FRA, $FRC, $FRB", FPFused,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set f64:$FRT, (fneg (fma f64:$FRA, f64:$FRC,
|
|
|
|
(fneg f64:$FRB))))]>;
|
2013-04-12 10:18:09 +08:00
|
|
|
defm FNMSUBS : AForm_1r<59, 30,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f4rc:$FRT), (ins f4rc:$FRA, f4rc:$FRC, f4rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fnmsubs", "$FRT, $FRA, $FRC, $FRB", FPGeneral,
|
2013-03-26 03:05:30 +08:00
|
|
|
[(set f32:$FRT, (fneg (fma f32:$FRA, f32:$FRC,
|
|
|
|
(fneg f32:$FRB))))]>;
|
2008-10-30 02:26:45 +08:00
|
|
|
}
|
2005-10-02 15:07:49 +08:00
|
|
|
// FSEL is artificially split into 4 and 8-byte forms for the result. To avoid
|
|
|
|
// having 4 of these, force the comparison to always be an 8-byte double (code
|
|
|
|
// should use an FMRSD if the input comparison value really wants to be a float)
|
2005-10-02 14:58:23 +08:00
|
|
|
// and 4/8 byte forms for the result and operand type..
|
2013-04-12 10:18:09 +08:00
|
|
|
let Interpretation64Bit = 1 in
|
|
|
|
defm FSELD : AForm_1r<63, 23,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f8rc:$FRT), (ins f8rc:$FRA, f8rc:$FRC, f8rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fsel", "$FRT, $FRA, $FRC, $FRB", FPGeneral,
|
|
|
|
[(set f64:$FRT, (PPCfsel f64:$FRA, f64:$FRC, f64:$FRB))]>;
|
|
|
|
defm FSELS : AForm_1r<63, 23,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f4rc:$FRT), (ins f8rc:$FRA, f4rc:$FRC, f4rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fsel", "$FRT, $FRA, $FRC, $FRB", FPGeneral,
|
|
|
|
[(set f32:$FRT, (PPCfsel f64:$FRA, f32:$FRC, f32:$FRB))]>;
|
2008-10-30 02:26:45 +08:00
|
|
|
let Uses = [RM] in {
|
2013-04-12 10:18:09 +08:00
|
|
|
defm FADD : AForm_2r<63, 21,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f8rc:$FRT), (ins f8rc:$FRA, f8rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fadd", "$FRT, $FRA, $FRB", FPAddSub,
|
|
|
|
[(set f64:$FRT, (fadd f64:$FRA, f64:$FRB))]>;
|
|
|
|
defm FADDS : AForm_2r<59, 21,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f4rc:$FRT), (ins f4rc:$FRA, f4rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fadds", "$FRT, $FRA, $FRB", FPGeneral,
|
|
|
|
[(set f32:$FRT, (fadd f32:$FRA, f32:$FRB))]>;
|
|
|
|
defm FDIV : AForm_2r<63, 18,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f8rc:$FRT), (ins f8rc:$FRA, f8rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fdiv", "$FRT, $FRA, $FRB", FPDivD,
|
|
|
|
[(set f64:$FRT, (fdiv f64:$FRA, f64:$FRB))]>;
|
|
|
|
defm FDIVS : AForm_2r<59, 18,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f4rc:$FRT), (ins f4rc:$FRA, f4rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fdivs", "$FRT, $FRA, $FRB", FPDivS,
|
|
|
|
[(set f32:$FRT, (fdiv f32:$FRA, f32:$FRB))]>;
|
|
|
|
defm FMUL : AForm_3r<63, 25,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f8rc:$FRT), (ins f8rc:$FRA, f8rc:$FRC),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fmul", "$FRT, $FRA, $FRC", FPFused,
|
|
|
|
[(set f64:$FRT, (fmul f64:$FRA, f64:$FRC))]>;
|
|
|
|
defm FMULS : AForm_3r<59, 25,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f4rc:$FRT), (ins f4rc:$FRA, f4rc:$FRC),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fmuls", "$FRT, $FRA, $FRC", FPGeneral,
|
|
|
|
[(set f32:$FRT, (fmul f32:$FRA, f32:$FRC))]>;
|
|
|
|
defm FSUB : AForm_2r<63, 20,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f8rc:$FRT), (ins f8rc:$FRA, f8rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fsub", "$FRT, $FRA, $FRB", FPAddSub,
|
|
|
|
[(set f64:$FRT, (fsub f64:$FRA, f64:$FRB))]>;
|
|
|
|
defm FSUBS : AForm_2r<59, 20,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs f4rc:$FRT), (ins f4rc:$FRA, f4rc:$FRB),
|
2013-04-12 10:18:09 +08:00
|
|
|
"fsubs", "$FRT, $FRA, $FRB", FPGeneral,
|
|
|
|
[(set f32:$FRT, (fsub f32:$FRA, f32:$FRB))]>;
|
2008-10-30 02:26:45 +08:00
|
|
|
}
|
2006-03-12 17:13:49 +08:00
|
|
|
}
|
2004-08-30 10:28:06 +08:00
|
|
|
|
2013-04-07 23:06:53 +08:00
|
|
|
let neverHasSideEffects = 1 in {
|
2012-06-23 07:10:08 +08:00
|
|
|
let PPC970_Unit = 1 in { // FXU Operations.
|
2013-04-07 23:06:53 +08:00
|
|
|
let isSelect = 1 in
|
2012-11-14 03:14:19 +08:00
|
|
|
def ISEL : AForm_4<31, 15,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$rT), (ins gprc_nor0:$rA, gprc:$rB, crbitrc:$cond),
|
2012-06-23 07:10:08 +08:00
|
|
|
"isel $rT, $rA, $rB, $cond", IntGeneral,
|
|
|
|
[]>;
|
|
|
|
}
|
|
|
|
|
2006-03-12 17:13:49 +08:00
|
|
|
let PPC970_Unit = 1 in { // FXU Operations.
|
2004-08-31 10:28:08 +08:00
|
|
|
// M-Form instructions. rotate and mask instructions.
|
|
|
|
//
|
2006-11-16 07:24:18 +08:00
|
|
|
let isCommutable = 1 in {
|
2005-09-10 02:17:41 +08:00
|
|
|
// RLWIMI can be commuted if the rotate amount is zero.
|
2013-04-27 00:53:15 +08:00
|
|
|
defm RLWIMI : MForm_2r<20, (outs gprc:$rA),
|
|
|
|
(ins gprc:$rSi, gprc:$rS, u5imm:$SH, u5imm:$MB,
|
2013-04-12 10:18:09 +08:00
|
|
|
u5imm:$ME), "rlwimi", "$rA, $rS, $SH, $MB, $ME", IntRotate,
|
|
|
|
[]>, PPC970_DGroup_Cracked, RegConstraint<"$rSi = $rA">,
|
|
|
|
NoEncode<"$rSi">;
|
2004-10-17 04:43:38 +08:00
|
|
|
}
|
2013-04-12 10:18:09 +08:00
|
|
|
let BaseName = "rlwinm" in {
|
2005-04-19 13:21:30 +08:00
|
|
|
def RLWINM : MForm_2<21,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$rA), (ins gprc:$rS, u5imm:$SH, u5imm:$MB, u5imm:$ME),
|
2005-10-20 03:51:16 +08:00
|
|
|
"rlwinm $rA, $rS, $SH, $MB, $ME", IntGeneral,
|
2013-04-12 10:18:09 +08:00
|
|
|
[]>, RecFormRel;
|
2013-04-13 02:17:57 +08:00
|
|
|
let Defs = [CR0] in
|
2005-04-19 13:21:30 +08:00
|
|
|
def RLWINMo : MForm_2<21,
|
2013-04-27 00:53:15 +08:00
|
|
|
(outs gprc:$rA), (ins gprc:$rS, u5imm:$SH, u5imm:$MB, u5imm:$ME),
|
2013-04-12 10:18:09 +08:00
|
|
|
"rlwinm. $rA, $rS, $SH, $MB, $ME", IntGeneral,
|
|
|
|
[]>, isDOT, RecFormRel, PPC970_DGroup_Cracked;
|
|
|
|
}
|
2013-04-27 00:53:15 +08:00
|
|
|
defm RLWNM : MForm_2r<23, (outs gprc:$rA),
|
|
|
|
(ins gprc:$rS, gprc:$rB, u5imm:$MB, u5imm:$ME),
|
2013-04-12 10:18:09 +08:00
|
|
|
"rlwnm", "$rA, $rS, $rB, $MB, $ME", IntGeneral,
|
|
|
|
[]>;
|
2006-03-12 17:13:49 +08:00
|
|
|
}
|
2013-04-07 23:06:53 +08:00
|
|
|
} // neverHasSideEffects = 1
|
2006-03-20 14:15:45 +08:00
|
|
|
|
2005-09-09 08:39:56 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Instruction Patterns
|
|
|
|
//
|
|
|
|
|
2005-09-27 06:20:16 +08:00
|
|
|
// Arbitrary immediate support. Implement in terms of LIS/ORI.
|
|
|
|
def : Pat<(i32 imm:$imm),
|
|
|
|
(ORI (LIS (HI16 imm:$imm)), (LO16 imm:$imm))>;
|
2005-09-29 01:13:15 +08:00
|
|
|
|
|
|
|
// Implement the 'not' operation with the NOR instruction.
|
2013-03-26 03:04:58 +08:00
|
|
|
def NOT : Pat<(not i32:$in),
|
|
|
|
(NOR $in, $in)>;
|
2005-09-29 01:13:15 +08:00
|
|
|
|
2005-09-29 07:07:13 +08:00
|
|
|
// ADD an arbitrary immediate.
|
2013-03-26 03:04:58 +08:00
|
|
|
def : Pat<(add i32:$in, imm:$imm),
|
|
|
|
(ADDIS (ADDI $in, (LO16 imm:$imm)), (HA16 imm:$imm))>;
|
2005-09-29 07:07:13 +08:00
|
|
|
// OR an arbitrary immediate.
|
2013-03-26 03:04:58 +08:00
|
|
|
def : Pat<(or i32:$in, imm:$imm),
|
|
|
|
(ORIS (ORI $in, (LO16 imm:$imm)), (HI16 imm:$imm))>;
|
2005-09-29 07:07:13 +08:00
|
|
|
// XOR an arbitrary immediate.
|
2013-03-26 03:04:58 +08:00
|
|
|
def : Pat<(xor i32:$in, imm:$imm),
|
|
|
|
(XORIS (XORI $in, (LO16 imm:$imm)), (HI16 imm:$imm))>;
|
2006-02-17 13:43:56 +08:00
|
|
|
// SUBFIC
|
Change some PowerPC PatLeaf definitions to ImmLeaf for fast-isel.
Using PatLeaf rather than ImmLeaf when defining immediate predicates
prevents simple patterns using those predicates from being recognized
for fast instruction selection. This patch replaces the immSExt16
PatLeaf predicate with two ImmLeaf predicates, imm32SExt16 and
imm64SExt16, allowing a few more patterns to be recognized (ADDI,
ADDIC, MULLI, ADDI8, and ADDIC8). Using the new predicates does not
help for LI, LI8, SUBFIC, and SUBFIC8 because these are rejected for
other reasons, but I see no reason to retain the PatLeaf predicate.
No functional change intended, and thus no test cases yet. This is
preliminary work for enabling fast-isel support for PowerPC. When
that support is ready, we'll be able to test this function.
llvm-svn: 182510
2013-05-23 04:09:24 +08:00
|
|
|
def : Pat<(sub imm32SExt16:$imm, i32:$in),
|
2013-03-26 03:04:58 +08:00
|
|
|
(SUBFIC $in, imm:$imm)>;
|
2005-10-19 09:38:02 +08:00
|
|
|
|
2006-06-17 04:22:01 +08:00
|
|
|
// SHL/SRL
|
2013-03-26 03:04:58 +08:00
|
|
|
def : Pat<(shl i32:$in, (i32 imm:$imm)),
|
|
|
|
(RLWINM $in, imm:$imm, 0, (SHL32 imm:$imm))>;
|
|
|
|
def : Pat<(srl i32:$in, (i32 imm:$imm)),
|
|
|
|
(RLWINM $in, (SRL32 imm:$imm), imm:$imm, 31)>;
|
2005-10-20 02:42:01 +08:00
|
|
|
|
2006-01-12 05:21:00 +08:00
|
|
|
// ROTL
|
2013-03-26 03:04:58 +08:00
|
|
|
def : Pat<(rotl i32:$in, i32:$sh),
|
|
|
|
(RLWNM $in, $sh, 0, 31)>;
|
|
|
|
def : Pat<(rotl i32:$in, (i32 imm:$imm)),
|
|
|
|
(RLWINM $in, imm:$imm, 0, 31)>;
|
2006-05-18 03:00:46 +08:00
|
|
|
|
2006-09-22 13:01:56 +08:00
|
|
|
// RLWNM
|
2013-03-26 03:04:58 +08:00
|
|
|
def : Pat<(and (rotl i32:$in, i32:$sh), maskimm32:$imm),
|
|
|
|
(RLWNM $in, $sh, (MB maskimm32:$imm), (ME maskimm32:$imm))>;
|
2006-09-22 13:01:56 +08:00
|
|
|
|
2006-05-18 03:00:46 +08:00
|
|
|
// Calls
|
2013-03-22 23:24:13 +08:00
|
|
|
def : Pat<(PPCcall (i32 tglobaladdr:$dst)),
|
|
|
|
(BL tglobaladdr:$dst)>;
|
|
|
|
def : Pat<(PPCcall (i32 texternalsym:$dst)),
|
|
|
|
(BL texternalsym:$dst)>;
|
2006-05-18 03:00:46 +08:00
|
|
|
|
2008-04-30 17:16:33 +08: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 15:30:41 +08:00
|
|
|
// Hi and Lo for Darwin Global Addresses.
|
2005-12-11 15:45:47 +08: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-23 02:53:45 +08:00
|
|
|
def : Pat<(PPChi tjumptable:$in, 0), (LIS tjumptable:$in)>;
|
|
|
|
def : Pat<(PPClo tjumptable:$in, 0), (LI tjumptable:$in)>;
|
2009-11-05 05:31:18 +08:00
|
|
|
def : Pat<(PPChi tblockaddress:$in, 0), (LIS tblockaddress:$in)>;
|
|
|
|
def : Pat<(PPClo tblockaddress:$in, 0), (LI tblockaddress:$in)>;
|
2013-03-26 03:04:58 +08:00
|
|
|
def : Pat<(PPChi tglobaltlsaddr:$g, i32:$in),
|
|
|
|
(ADDIS $in, tglobaltlsaddr:$g)>;
|
|
|
|
def : Pat<(PPClo tglobaltlsaddr:$g, i32:$in),
|
2013-03-26 18:55:20 +08:00
|
|
|
(ADDI $in, tglobaltlsaddr:$g)>;
|
2013-03-26 03:04:58 +08:00
|
|
|
def : Pat<(add i32:$in, (PPChi tglobaladdr:$g, 0)),
|
|
|
|
(ADDIS $in, tglobaladdr:$g)>;
|
|
|
|
def : Pat<(add i32:$in, (PPChi tconstpool:$g, 0)),
|
|
|
|
(ADDIS $in, tconstpool:$g)>;
|
|
|
|
def : Pat<(add i32:$in, (PPChi tjumptable:$g, 0)),
|
|
|
|
(ADDIS $in, tjumptable:$g)>;
|
|
|
|
def : Pat<(add i32:$in, (PPChi tblockaddress:$g, 0)),
|
|
|
|
(ADDIS $in, tblockaddress:$g)>;
|
2005-11-17 15:30:41 +08:00
|
|
|
|
2005-12-06 10:10:38 +08: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.
|
2013-03-26 03:04:58 +08:00
|
|
|
def : Pat<(sra i32:$rS, i32:$rB),
|
|
|
|
(SRAW $rS, $rB)>;
|
|
|
|
def : Pat<(srl i32:$rS, i32:$rB),
|
|
|
|
(SRW $rS, $rB)>;
|
|
|
|
def : Pat<(shl i32:$rS, i32:$rB),
|
|
|
|
(SLW $rS, $rB)>;
|
2005-12-06 10:10:38 +08:00
|
|
|
|
2006-10-10 04:57:25 +08:00
|
|
|
def : Pat<(zextloadi1 iaddr:$src),
|
2005-12-20 07:25:09 +08:00
|
|
|
(LBZ iaddr:$src)>;
|
2006-10-10 04:57:25 +08:00
|
|
|
def : Pat<(zextloadi1 xaddr:$src),
|
2005-12-20 07:25:09 +08:00
|
|
|
(LBZX xaddr:$src)>;
|
2006-10-10 04:57:25 +08:00
|
|
|
def : Pat<(extloadi1 iaddr:$src),
|
2005-12-20 07:25:09 +08:00
|
|
|
(LBZ iaddr:$src)>;
|
2006-10-10 04:57:25 +08:00
|
|
|
def : Pat<(extloadi1 xaddr:$src),
|
2005-12-20 07:25:09 +08:00
|
|
|
(LBZX xaddr:$src)>;
|
2006-10-10 04:57:25 +08:00
|
|
|
def : Pat<(extloadi8 iaddr:$src),
|
2005-12-20 07:25:09 +08:00
|
|
|
(LBZ iaddr:$src)>;
|
2006-10-10 04:57:25 +08:00
|
|
|
def : Pat<(extloadi8 xaddr:$src),
|
2005-12-20 07:25:09 +08:00
|
|
|
(LBZX xaddr:$src)>;
|
2006-10-10 04:57:25 +08:00
|
|
|
def : Pat<(extloadi16 iaddr:$src),
|
2005-12-20 07:25:09 +08:00
|
|
|
(LHZ iaddr:$src)>;
|
2006-10-10 04:57:25 +08:00
|
|
|
def : Pat<(extloadi16 xaddr:$src),
|
2005-12-20 07:25:09 +08:00
|
|
|
(LHZX xaddr:$src)>;
|
2010-07-17 05:03:52 +08:00
|
|
|
def : Pat<(f64 (extloadf32 iaddr:$src)),
|
|
|
|
(COPY_TO_REGCLASS (LFS iaddr:$src), F8RC)>;
|
|
|
|
def : Pat<(f64 (extloadf32 xaddr:$src)),
|
|
|
|
(COPY_TO_REGCLASS (LFSX xaddr:$src), F8RC)>;
|
|
|
|
|
2013-03-26 03:04:58 +08:00
|
|
|
def : Pat<(f64 (fextend f32:$src)),
|
|
|
|
(COPY_TO_REGCLASS $src, F8RC)>;
|
2005-12-20 07:25:09 +08:00
|
|
|
|
2011-07-28 06:21:52 +08:00
|
|
|
def : Pat<(atomic_fence (imm), (imm)), (SYNC)>;
|
|
|
|
|
2013-04-03 12:01:11 +08:00
|
|
|
// Additional FNMSUB patterns: -a*c + b == -(a*c - b)
|
|
|
|
def : Pat<(fma (fneg f64:$A), f64:$C, f64:$B),
|
|
|
|
(FNMSUB $A, $C, $B)>;
|
|
|
|
def : Pat<(fma f64:$A, (fneg f64:$C), f64:$B),
|
|
|
|
(FNMSUB $A, $C, $B)>;
|
|
|
|
def : Pat<(fma (fneg f32:$A), f32:$C, f32:$B),
|
|
|
|
(FNMSUBS $A, $C, $B)>;
|
|
|
|
def : Pat<(fma f32:$A, (fneg f32:$C), f32:$B),
|
|
|
|
(FNMSUBS $A, $C, $B)>;
|
|
|
|
|
2006-03-25 15:51:43 +08:00
|
|
|
include "PPCInstrAltivec.td"
|
2006-06-17 04:22:01 +08:00
|
|
|
include "PPCInstr64Bit.td"
|
2013-05-04 03:50:27 +08:00
|
|
|
|
2013-05-04 03:51:09 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Instructions used for assembler/disassembler only
|
|
|
|
//
|
|
|
|
|
|
|
|
def ISYNC : XLForm_2_ext<19, 150, 0, 0, 0, (outs), (ins),
|
|
|
|
"isync", SprISYNC, []>;
|
|
|
|
|
|
|
|
def ICBI : XForm_1a<31, 982, (outs), (ins memrr:$src),
|
|
|
|
"icbi $src", LdStICBI, []>;
|
|
|
|
|
2013-05-04 03:50:27 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PowerPC Assembler Instruction Aliases
|
|
|
|
//
|
|
|
|
|
|
|
|
// Pseudo-instructions for alternate assembly syntax (never used by codegen).
|
|
|
|
// These are aliases that require C++ handling to convert to the target
|
|
|
|
// instruction, while InstAliases can be handled directly by tblgen.
|
|
|
|
class PPCAsmPseudo<string asm, dag iops>
|
|
|
|
: Instruction {
|
|
|
|
let Namespace = "PPC";
|
|
|
|
bit PPC64 = 0; // Default value, override with isPPC64
|
|
|
|
|
|
|
|
let OutOperandList = (outs);
|
|
|
|
let InOperandList = iops;
|
|
|
|
let Pattern = [];
|
|
|
|
let AsmString = asm;
|
|
|
|
let isAsmParserOnly = 1;
|
|
|
|
let isPseudo = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
def : InstAlias<"mr $rA, $rB", (OR8 g8rc:$rA, g8rc:$rB, g8rc:$rB)>;
|
|
|
|
|
|
|
|
def SLWI : PPCAsmPseudo<"slwi $rA, $rS, $n",
|
|
|
|
(ins gprc:$rA, gprc:$rS, u5imm:$n)>;
|
|
|
|
def SRWI : PPCAsmPseudo<"srwi $rA, $rS, $n",
|
|
|
|
(ins gprc:$rA, gprc:$rS, u5imm:$n)>;
|
|
|
|
def SLDI : PPCAsmPseudo<"sldi $rA, $rS, $n",
|
|
|
|
(ins g8rc:$rA, g8rc:$rS, u6imm:$n)>;
|
|
|
|
def SRDI : PPCAsmPseudo<"srdi $rA, $rS, $n",
|
|
|
|
(ins g8rc:$rA, g8rc:$rS, u6imm:$n)>;
|
|
|
|
|
|
|
|
def : InstAlias<"blt $cc, $dst", (BCC 12, crrc:$cc, condbrtarget:$dst)>;
|
|
|
|
def : InstAlias<"bgt $cc, $dst", (BCC 44, crrc:$cc, condbrtarget:$dst)>;
|
|
|
|
def : InstAlias<"beq $cc, $dst", (BCC 76, crrc:$cc, condbrtarget:$dst)>;
|
|
|
|
def : InstAlias<"bun $cc, $dst", (BCC 108, crrc:$cc, condbrtarget:$dst)>;
|
|
|
|
def : InstAlias<"bso $cc, $dst", (BCC 108, crrc:$cc, condbrtarget:$dst)>;
|
|
|
|
def : InstAlias<"bge $cc, $dst", (BCC 4, crrc:$cc, condbrtarget:$dst)>;
|
|
|
|
def : InstAlias<"bnl $cc, $dst", (BCC 4, crrc:$cc, condbrtarget:$dst)>;
|
|
|
|
def : InstAlias<"ble $cc, $dst", (BCC 36, crrc:$cc, condbrtarget:$dst)>;
|
|
|
|
def : InstAlias<"bng $cc, $dst", (BCC 36, crrc:$cc, condbrtarget:$dst)>;
|
|
|
|
def : InstAlias<"bne $cc, $dst", (BCC 68, crrc:$cc, condbrtarget:$dst)>;
|
|
|
|
def : InstAlias<"bnu $cc, $dst", (BCC 100, crrc:$cc, condbrtarget:$dst)>;
|
|
|
|
def : InstAlias<"bns $cc, $dst", (BCC 100, crrc:$cc, condbrtarget:$dst)>;
|
|
|
|
|
|
|
|
def : InstAlias<"bltlr $cc", (BCLR 12, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bgtlr $cc", (BCLR 44, crrc:$cc)>;
|
|
|
|
def : InstAlias<"beqlr $cc", (BCLR 76, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bunlr $cc", (BCLR 108, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bsolr $cc", (BCLR 108, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bgelr $cc", (BCLR 4, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bnllr $cc", (BCLR 4, crrc:$cc)>;
|
|
|
|
def : InstAlias<"blelr $cc", (BCLR 36, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bnglr $cc", (BCLR 36, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bnelr $cc", (BCLR 68, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bnulr $cc", (BCLR 100, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bnslr $cc", (BCLR 100, crrc:$cc)>;
|
|
|
|
|
|
|
|
def : InstAlias<"bltctr $cc", (BCCTR 12, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bgtctr $cc", (BCCTR 44, crrc:$cc)>;
|
|
|
|
def : InstAlias<"beqctr $cc", (BCCTR 76, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bunctr $cc", (BCCTR 108, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bsoctr $cc", (BCCTR 108, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bgectr $cc", (BCCTR 4, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bnlctr $cc", (BCCTR 4, crrc:$cc)>;
|
|
|
|
def : InstAlias<"blectr $cc", (BCCTR 36, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bngctr $cc", (BCCTR 36, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bnectr $cc", (BCCTR 68, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bnuctr $cc", (BCCTR 100, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bnsctr $cc", (BCCTR 100, crrc:$cc)>;
|
|
|
|
|
|
|
|
def : InstAlias<"bltctrl $cc", (BCCTRL 12, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bgtctrl $cc", (BCCTRL 44, crrc:$cc)>;
|
|
|
|
def : InstAlias<"beqctrl $cc", (BCCTRL 76, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bunctrl $cc", (BCCTRL 108, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bsoctrl $cc", (BCCTRL 108, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bgectrl $cc", (BCCTRL 4, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bnlctrl $cc", (BCCTRL 4, crrc:$cc)>;
|
|
|
|
def : InstAlias<"blectrl $cc", (BCCTRL 36, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bngctrl $cc", (BCCTRL 36, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bnectrl $cc", (BCCTRL 68, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bnuctrl $cc", (BCCTRL 100, crrc:$cc)>;
|
|
|
|
def : InstAlias<"bnsctrl $cc", (BCCTRL 100, crrc:$cc)>;
|
|
|
|
|