mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 11:02:59 +02:00
Use direct types in PowerPC Pat patterns.
This commit updates the PowerPC back-end (PPCInstrInfo.td and PPCInstr64Bit.td) to use types instead of register classes in Pat patterns, along the lines of Jakob Stoklund Olesen's changes in r177829 for Sparc. llvm-svn: 177889
This commit is contained in:
Ulrich Weigand
parent
2949721b7d
commit
e66e76778d
@ -709,8 +709,8 @@ def LDgotTprelL: Pseudo<(outs G8RC:$rD), (ins symbolLo64:$disp, G8RC:$reg),
|
||||
[(set G8RC:$rD,
|
||||
(PPCldGotTprelL tglobaltlsaddr:$disp, G8RC:$reg))]>,
|
||||
isPPC64;
|
||||
def : Pat<(PPCaddTls G8RC:$in, tglobaltlsaddr:$g),
|
||||
(ADD8TLS G8RC:$in, tglobaltlsaddr:$g)>;
|
||||
def : Pat<(PPCaddTls i64:$in, tglobaltlsaddr:$g),
|
||||
(ADD8TLS $in, tglobaltlsaddr:$g)>;
|
||||
def ADDIStlsgdHA: Pseudo<(outs G8RC:$rD), (ins G8RC:$reg, symbolHi64:$disp),
|
||||
"#ADDIStlsgdHA",
|
||||
[(set G8RC:$rD,
|
||||
@ -831,23 +831,23 @@ def STDUX : XForm_8<31, 181, (outs ptr_rc_nor0:$ea_res), (ins G8RC:$rS, memrr:$d
|
||||
// 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.
|
||||
def : Pat<(pre_truncsti8 G8RC:$rS, ptr_rc_nor0:$ptrreg, iaddroff:$ptroff),
|
||||
(STBU8 G8RC:$rS, iaddroff:$ptroff, ptr_rc_nor0:$ptrreg)>;
|
||||
def : Pat<(pre_truncsti16 G8RC:$rS, ptr_rc_nor0:$ptrreg, iaddroff:$ptroff),
|
||||
(STHU8 G8RC:$rS, iaddroff:$ptroff, ptr_rc_nor0:$ptrreg)>;
|
||||
def : Pat<(pre_truncsti32 G8RC:$rS, ptr_rc_nor0:$ptrreg, iaddroff:$ptroff),
|
||||
(STWU8 G8RC:$rS, iaddroff:$ptroff, ptr_rc_nor0:$ptrreg)>;
|
||||
def : Pat<(aligned4pre_store G8RC:$rS, ptr_rc_nor0:$ptrreg, iaddroff:$ptroff),
|
||||
(STDU G8RC:$rS, iaddroff:$ptroff, ptr_rc_nor0:$ptrreg)>;
|
||||
def : Pat<(pre_truncsti8 i64:$rS, iPTR:$ptrreg, iaddroff:$ptroff),
|
||||
(STBU8 $rS, iaddroff:$ptroff, $ptrreg)>;
|
||||
def : Pat<(pre_truncsti16 i64:$rS, iPTR:$ptrreg, iaddroff:$ptroff),
|
||||
(STHU8 $rS, iaddroff:$ptroff, $ptrreg)>;
|
||||
def : Pat<(pre_truncsti32 i64:$rS, iPTR:$ptrreg, iaddroff:$ptroff),
|
||||
(STWU8 $rS, iaddroff:$ptroff, $ptrreg)>;
|
||||
def : Pat<(aligned4pre_store i64:$rS, iPTR:$ptrreg, iaddroff:$ptroff),
|
||||
(STDU $rS, iaddroff:$ptroff, $ptrreg)>;
|
||||
|
||||
def : Pat<(pre_truncsti8 G8RC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff),
|
||||
(STBUX8 G8RC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff)>;
|
||||
def : Pat<(pre_truncsti16 G8RC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff),
|
||||
(STHUX8 G8RC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff)>;
|
||||
def : Pat<(pre_truncsti32 G8RC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff),
|
||||
(STWUX8 G8RC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff)>;
|
||||
def : Pat<(pre_store G8RC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff),
|
||||
(STDUX G8RC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff)>;
|
||||
def : Pat<(pre_truncsti8 i64:$rS, iPTR:$ptrreg, iPTR:$ptroff),
|
||||
(STBUX8 $rS, $ptrreg, $ptroff)>;
|
||||
def : Pat<(pre_truncsti16 i64:$rS, iPTR:$ptrreg, iPTR:$ptroff),
|
||||
(STHUX8 $rS, $ptrreg, $ptroff)>;
|
||||
def : Pat<(pre_truncsti32 i64:$rS, iPTR:$ptrreg, iPTR:$ptroff),
|
||||
(STWUX8 $rS, $ptrreg, $ptroff)>;
|
||||
def : Pat<(pre_store i64:$rS, iPTR:$ptrreg, iPTR:$ptroff),
|
||||
(STDUX $rS, $ptrreg, $ptroff)>;
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
@ -870,13 +870,13 @@ def FCTIDZ : XForm_26<63, 815, (outs F8RC:$frD), (ins F8RC:$frB),
|
||||
//
|
||||
|
||||
// Extensions and truncates to/from 32-bit regs.
|
||||
def : Pat<(i64 (zext GPRC:$in)),
|
||||
(RLDICL (INSERT_SUBREG (i64 (IMPLICIT_DEF)), GPRC:$in, sub_32),
|
||||
def : Pat<(i64 (zext i32:$in)),
|
||||
(RLDICL (INSERT_SUBREG (i64 (IMPLICIT_DEF)), $in, sub_32),
|
||||
0, 32)>;
|
||||
def : Pat<(i64 (anyext GPRC:$in)),
|
||||
(INSERT_SUBREG (i64 (IMPLICIT_DEF)), GPRC:$in, sub_32)>;
|
||||
def : Pat<(i32 (trunc G8RC:$in)),
|
||||
(EXTRACT_SUBREG G8RC:$in, sub_32)>;
|
||||
def : Pat<(i64 (anyext i32:$in)),
|
||||
(INSERT_SUBREG (i64 (IMPLICIT_DEF)), $in, sub_32)>;
|
||||
def : Pat<(i32 (trunc i64:$in)),
|
||||
(EXTRACT_SUBREG $in, sub_32)>;
|
||||
|
||||
// Extending loads with i64 targets.
|
||||
def : Pat<(zextloadi1 iaddr:$src),
|
||||
@ -903,24 +903,24 @@ def : Pat<(extloadi32 xaddr:$src),
|
||||
// Standard shifts. These are represented separately from the real shifts above
|
||||
// so that we can distinguish between shifts that allow 6-bit and 7-bit shift
|
||||
// amounts.
|
||||
def : Pat<(sra G8RC:$rS, GPRC:$rB),
|
||||
(SRAD G8RC:$rS, GPRC:$rB)>;
|
||||
def : Pat<(srl G8RC:$rS, GPRC:$rB),
|
||||
(SRD G8RC:$rS, GPRC:$rB)>;
|
||||
def : Pat<(shl G8RC:$rS, GPRC:$rB),
|
||||
(SLD G8RC:$rS, GPRC:$rB)>;
|
||||
def : Pat<(sra i64:$rS, i32:$rB),
|
||||
(SRAD $rS, $rB)>;
|
||||
def : Pat<(srl i64:$rS, i32:$rB),
|
||||
(SRD $rS, $rB)>;
|
||||
def : Pat<(shl i64:$rS, i32:$rB),
|
||||
(SLD $rS, $rB)>;
|
||||
|
||||
// SHL/SRL
|
||||
def : Pat<(shl G8RC:$in, (i32 imm:$imm)),
|
||||
(RLDICR G8RC:$in, imm:$imm, (SHL64 imm:$imm))>;
|
||||
def : Pat<(srl G8RC:$in, (i32 imm:$imm)),
|
||||
(RLDICL G8RC:$in, (SRL64 imm:$imm), imm:$imm)>;
|
||||
def : Pat<(shl i64:$in, (i32 imm:$imm)),
|
||||
(RLDICR $in, imm:$imm, (SHL64 imm:$imm))>;
|
||||
def : Pat<(srl i64:$in, (i32 imm:$imm)),
|
||||
(RLDICL $in, (SRL64 imm:$imm), imm:$imm)>;
|
||||
|
||||
// ROTL
|
||||
def : Pat<(rotl G8RC:$in, GPRC:$sh),
|
||||
(RLDCL G8RC:$in, GPRC:$sh, 0)>;
|
||||
def : Pat<(rotl G8RC:$in, (i32 imm:$imm)),
|
||||
(RLDICL G8RC:$in, imm:$imm, 0)>;
|
||||
def : Pat<(rotl i64:$in, i32:$sh),
|
||||
(RLDCL $in, $sh, 0)>;
|
||||
def : Pat<(rotl i64:$in, (i32 imm:$imm)),
|
||||
(RLDICL $in, imm:$imm, 0)>;
|
||||
|
||||
// Hi and Lo for Darwin Global Addresses.
|
||||
def : Pat<(PPChi tglobaladdr:$in, 0), (LIS8 tglobaladdr:$in)>;
|
||||
@ -931,18 +931,18 @@ def : Pat<(PPChi tjumptable:$in , 0), (LIS8 tjumptable:$in)>;
|
||||
def : Pat<(PPClo tjumptable:$in , 0), (LI8 tjumptable:$in)>;
|
||||
def : Pat<(PPChi tblockaddress:$in, 0), (LIS8 tblockaddress:$in)>;
|
||||
def : Pat<(PPClo tblockaddress:$in, 0), (LI8 tblockaddress:$in)>;
|
||||
def : Pat<(PPChi tglobaltlsaddr:$g, G8RC:$in),
|
||||
(ADDIS8 G8RC:$in, tglobaltlsaddr:$g)>;
|
||||
def : Pat<(PPClo tglobaltlsaddr:$g, G8RC:$in),
|
||||
(ADDI8L G8RC:$in, tglobaltlsaddr:$g)>;
|
||||
def : Pat<(add G8RC:$in, (PPChi tglobaladdr:$g, 0)),
|
||||
(ADDIS8 G8RC:$in, tglobaladdr:$g)>;
|
||||
def : Pat<(add G8RC:$in, (PPChi tconstpool:$g, 0)),
|
||||
(ADDIS8 G8RC:$in, tconstpool:$g)>;
|
||||
def : Pat<(add G8RC:$in, (PPChi tjumptable:$g, 0)),
|
||||
(ADDIS8 G8RC:$in, tjumptable:$g)>;
|
||||
def : Pat<(add G8RC:$in, (PPChi tblockaddress:$g, 0)),
|
||||
(ADDIS8 G8RC:$in, tblockaddress:$g)>;
|
||||
def : Pat<(PPChi tglobaltlsaddr:$g, i64:$in),
|
||||
(ADDIS8 $in, tglobaltlsaddr:$g)>;
|
||||
def : Pat<(PPClo tglobaltlsaddr:$g, i64:$in),
|
||||
(ADDI8L $in, tglobaltlsaddr:$g)>;
|
||||
def : Pat<(add i64:$in, (PPChi tglobaladdr:$g, 0)),
|
||||
(ADDIS8 $in, tglobaladdr:$g)>;
|
||||
def : Pat<(add i64:$in, (PPChi tconstpool:$g, 0)),
|
||||
(ADDIS8 $in, tconstpool:$g)>;
|
||||
def : Pat<(add i64:$in, (PPChi tjumptable:$g, 0)),
|
||||
(ADDIS8 $in, tjumptable:$g)>;
|
||||
def : Pat<(add i64:$in, (PPChi tblockaddress:$g, 0)),
|
||||
(ADDIS8 $in, tblockaddress:$g)>;
|
||||
|
||||
// Patterns to match r+r indexed loads and stores for
|
||||
// addresses without at least 4-byte alignment.
|
||||
@ -950,6 +950,6 @@ def : Pat<(i64 (unaligned4sextloadi32 xoaddr:$src)),
|
||||
(LWAX xoaddr:$src)>;
|
||||
def : Pat<(i64 (unaligned4load xoaddr:$src)),
|
||||
(LDX xoaddr:$src)>;
|
||||
def : Pat<(unaligned4store G8RC:$rS, xoaddr:$dst),
|
||||
(STDX G8RC:$rS, xoaddr:$dst)>;
|
||||
def : Pat<(unaligned4store i64:$rS, xoaddr:$dst),
|
||||
(STDX $rS, xoaddr:$dst)>;
|
||||
|
||||
|
||||
@ -896,16 +896,16 @@ def STFDU : DForm_1<37, (outs ptr_rc_nor0:$ea_res), (ins F8RC:$rS, memri:$dst),
|
||||
// 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.
|
||||
def : Pat<(pre_truncsti8 GPRC:$rS, ptr_rc_nor0:$ptrreg, iaddroff:$ptroff),
|
||||
(STBU GPRC:$rS, iaddroff:$ptroff, ptr_rc_nor0:$ptrreg)>;
|
||||
def : Pat<(pre_truncsti16 GPRC:$rS, ptr_rc_nor0:$ptrreg, iaddroff:$ptroff),
|
||||
(STHU GPRC:$rS, iaddroff:$ptroff, ptr_rc_nor0:$ptrreg)>;
|
||||
def : Pat<(pre_store GPRC:$rS, ptr_rc_nor0:$ptrreg, iaddroff:$ptroff),
|
||||
(STWU GPRC:$rS, iaddroff:$ptroff, ptr_rc_nor0:$ptrreg)>;
|
||||
def : Pat<(pre_store F4RC:$rS, ptr_rc_nor0:$ptrreg, iaddroff:$ptroff),
|
||||
(STFSU F4RC:$rS, iaddroff:$ptroff, ptr_rc_nor0:$ptrreg)>;
|
||||
def : Pat<(pre_store F8RC:$rS, ptr_rc_nor0:$ptrreg, iaddroff:$ptroff),
|
||||
(STFDU F8RC:$rS, iaddroff:$ptroff, ptr_rc_nor0:$ptrreg)>;
|
||||
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)>;
|
||||
|
||||
// Indexed (r+r) Stores.
|
||||
let PPC970_Unit = 2 in {
|
||||
@ -970,16 +970,16 @@ def STFDUX: XForm_8<31, 759, (outs ptr_rc_nor0:$ea_res), (ins F8RC:$rS, memrr:$d
|
||||
// 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.
|
||||
def : Pat<(pre_truncsti8 GPRC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff),
|
||||
(STBUX GPRC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff)>;
|
||||
def : Pat<(pre_truncsti16 GPRC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff),
|
||||
(STHUX GPRC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff)>;
|
||||
def : Pat<(pre_store GPRC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff),
|
||||
(STWUX GPRC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff)>;
|
||||
def : Pat<(pre_store F4RC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff),
|
||||
(STFSUX F4RC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff)>;
|
||||
def : Pat<(pre_store F8RC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff),
|
||||
(STFDUX F8RC:$rS, ptr_rc_nor0:$ptrreg, ptr_rc:$ptroff)>;
|
||||
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)>;
|
||||
|
||||
def SYNC : XForm_24_sync<31, 598, (outs), (ins),
|
||||
"sync", LdStSync,
|
||||
@ -1530,37 +1530,37 @@ def : Pat<(i32 imm:$imm),
|
||||
(ORI (LIS (HI16 imm:$imm)), (LO16 imm:$imm))>;
|
||||
|
||||
// Implement the 'not' operation with the NOR instruction.
|
||||
def NOT : Pat<(not GPRC:$in),
|
||||
(NOR GPRC:$in, GPRC:$in)>;
|
||||
def NOT : Pat<(not i32:$in),
|
||||
(NOR $in, $in)>;
|
||||
|
||||
// ADD an arbitrary immediate.
|
||||
def : Pat<(add GPRC:$in, imm:$imm),
|
||||
(ADDIS (ADDI GPRC:$in, (LO16 imm:$imm)), (HA16 imm:$imm))>;
|
||||
def : Pat<(add i32:$in, imm:$imm),
|
||||
(ADDIS (ADDI $in, (LO16 imm:$imm)), (HA16 imm:$imm))>;
|
||||
// OR an arbitrary immediate.
|
||||
def : Pat<(or GPRC:$in, imm:$imm),
|
||||
(ORIS (ORI GPRC:$in, (LO16 imm:$imm)), (HI16 imm:$imm))>;
|
||||
def : Pat<(or i32:$in, imm:$imm),
|
||||
(ORIS (ORI $in, (LO16 imm:$imm)), (HI16 imm:$imm))>;
|
||||
// XOR an arbitrary immediate.
|
||||
def : Pat<(xor GPRC:$in, imm:$imm),
|
||||
(XORIS (XORI GPRC:$in, (LO16 imm:$imm)), (HI16 imm:$imm))>;
|
||||
def : Pat<(xor i32:$in, imm:$imm),
|
||||
(XORIS (XORI $in, (LO16 imm:$imm)), (HI16 imm:$imm))>;
|
||||
// SUBFIC
|
||||
def : Pat<(sub immSExt16:$imm, GPRC:$in),
|
||||
(SUBFIC GPRC:$in, imm:$imm)>;
|
||||
def : Pat<(sub immSExt16:$imm, i32:$in),
|
||||
(SUBFIC $in, imm:$imm)>;
|
||||
|
||||
// SHL/SRL
|
||||
def : Pat<(shl GPRC:$in, (i32 imm:$imm)),
|
||||
(RLWINM GPRC:$in, imm:$imm, 0, (SHL32 imm:$imm))>;
|
||||
def : Pat<(srl GPRC:$in, (i32 imm:$imm)),
|
||||
(RLWINM GPRC:$in, (SRL32 imm:$imm), imm:$imm, 31)>;
|
||||
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)>;
|
||||
|
||||
// ROTL
|
||||
def : Pat<(rotl GPRC:$in, GPRC:$sh),
|
||||
(RLWNM GPRC:$in, GPRC:$sh, 0, 31)>;
|
||||
def : Pat<(rotl GPRC:$in, (i32 imm:$imm)),
|
||||
(RLWINM GPRC:$in, imm:$imm, 0, 31)>;
|
||||
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)>;
|
||||
|
||||
// RLWNM
|
||||
def : Pat<(and (rotl GPRC:$in, GPRC:$sh), maskimm32:$imm),
|
||||
(RLWNM GPRC:$in, GPRC:$sh, (MB maskimm32:$imm), (ME maskimm32:$imm))>;
|
||||
def : Pat<(and (rotl i32:$in, i32:$sh), maskimm32:$imm),
|
||||
(RLWNM $in, $sh, (MB maskimm32:$imm), (ME maskimm32:$imm))>;
|
||||
|
||||
// Calls
|
||||
def : Pat<(PPCcall (i32 tglobaladdr:$dst)),
|
||||
@ -1589,28 +1589,28 @@ def : Pat<(PPChi tjumptable:$in, 0), (LIS tjumptable:$in)>;
|
||||
def : Pat<(PPClo tjumptable:$in, 0), (LI tjumptable:$in)>;
|
||||
def : Pat<(PPChi tblockaddress:$in, 0), (LIS tblockaddress:$in)>;
|
||||
def : Pat<(PPClo tblockaddress:$in, 0), (LI tblockaddress:$in)>;
|
||||
def : Pat<(PPChi tglobaltlsaddr:$g, GPRC:$in),
|
||||
(ADDIS GPRC:$in, tglobaltlsaddr:$g)>;
|
||||
def : Pat<(PPClo tglobaltlsaddr:$g, GPRC:$in),
|
||||
(ADDIL GPRC:$in, tglobaltlsaddr:$g)>;
|
||||
def : Pat<(add GPRC:$in, (PPChi tglobaladdr:$g, 0)),
|
||||
(ADDIS GPRC:$in, tglobaladdr:$g)>;
|
||||
def : Pat<(add GPRC:$in, (PPChi tconstpool:$g, 0)),
|
||||
(ADDIS GPRC:$in, tconstpool:$g)>;
|
||||
def : Pat<(add GPRC:$in, (PPChi tjumptable:$g, 0)),
|
||||
(ADDIS GPRC:$in, tjumptable:$g)>;
|
||||
def : Pat<(add GPRC:$in, (PPChi tblockaddress:$g, 0)),
|
||||
(ADDIS GPRC:$in, tblockaddress:$g)>;
|
||||
def : Pat<(PPChi tglobaltlsaddr:$g, i32:$in),
|
||||
(ADDIS $in, tglobaltlsaddr:$g)>;
|
||||
def : Pat<(PPClo tglobaltlsaddr:$g, i32:$in),
|
||||
(ADDIL $in, tglobaltlsaddr:$g)>;
|
||||
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)>;
|
||||
|
||||
// Standard shifts. These are represented separately from the real shifts above
|
||||
// so that we can distinguish between shifts that allow 5-bit and 6-bit shift
|
||||
// amounts.
|
||||
def : Pat<(sra GPRC:$rS, GPRC:$rB),
|
||||
(SRAW GPRC:$rS, GPRC:$rB)>;
|
||||
def : Pat<(srl GPRC:$rS, GPRC:$rB),
|
||||
(SRW GPRC:$rS, GPRC:$rB)>;
|
||||
def : Pat<(shl GPRC:$rS, GPRC:$rB),
|
||||
(SLW GPRC:$rS, GPRC:$rB)>;
|
||||
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)>;
|
||||
|
||||
def : Pat<(zextloadi1 iaddr:$src),
|
||||
(LBZ iaddr:$src)>;
|
||||
@ -1633,8 +1633,8 @@ def : Pat<(f64 (extloadf32 iaddr:$src)),
|
||||
def : Pat<(f64 (extloadf32 xaddr:$src)),
|
||||
(COPY_TO_REGCLASS (LFSX xaddr:$src), F8RC)>;
|
||||
|
||||
def : Pat<(f64 (fextend F4RC:$src)),
|
||||
(COPY_TO_REGCLASS F4RC:$src, F8RC)>;
|
||||
def : Pat<(f64 (fextend f32:$src)),
|
||||
(COPY_TO_REGCLASS $src, F8RC)>;
|
||||
|
||||
// Memory barriers
|
||||
def : Pat<(membarrier (i32 imm /*ll*/),
|
||||
|
||||
Loading…
Reference in New Issue
Block a user