121e463b2bf864671a87ebe386cb100ef9349a540Nate Begeman//===-- PPCISelDAGToDAG.cpp - PPC --pattern matching inst selector --------===// 2a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 3a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// The LLVM Compiler Infrastructure 4a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 8a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner//===----------------------------------------------------------------------===// 9a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 1021e463b2bf864671a87ebe386cb100ef9349a540Nate Begeman// This file defines a pattern matching instruction selector for PowerPC, 11a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// converting from a legalized dag to a PPC dag. 12a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 13a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner//===----------------------------------------------------------------------===// 14a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1595b2c7da5e83670881270c1cd231a240be0556d9Chris Lattner#define DEBUG_TYPE "ppc-codegen" 162668959b8879097db368aec7d76c455260abc75bChris Lattner#include "PPC.h" 1716e71f2f70811c69c56052dd146324fe20e31db5Chris Lattner#include "PPCTargetMachine.h" 1894b9550a32d189704a8eae55505edf62662c0534Evan Cheng#include "MCTargetDesc/PPCPredicates.h" 194416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 204416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 2184bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineRegisterInfo.h" 22a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/CodeGen/SelectionDAG.h" 23a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/CodeGen/SelectionDAGISel.h" 24a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Target/TargetOptions.h" 252fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner#include "llvm/Constants.h" 269062d9a55b0b8b473b927d8b020e36990e147a58Chris Lattner#include "llvm/Function.h" 274416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/GlobalValue.h" 28420736dc85c01702bb7bc40495f8a4be5e5f8a6cChris Lattner#include "llvm/Intrinsics.h" 29a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Support/Debug.h" 30a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Support/MathExtras.h" 31dac237e18209b697a8ba122d0ddd9cad4dfba1f8Torok Edwin#include "llvm/Support/ErrorHandling.h" 32dac237e18209b697a8ba122d0ddd9cad4dfba1f8Torok Edwin#include "llvm/Support/raw_ostream.h" 33a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerusing namespace llvm; 34a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 35a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnernamespace { 36a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner //===--------------------------------------------------------------------===// 371d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman /// PPCDAGToDAGISel - PPC specific code to select PPC machine 38a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// instructions for SelectionDAG operations. 39a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// 406726b6d75a8b679068a58cb954ba97cf9d1690baNick Lewycky class PPCDAGToDAGISel : public SelectionDAGISel { 41d858e90f039f5fcdc2fa93035e911a5a9505cc50Dan Gohman const PPCTargetMachine &TM; 42d858e90f039f5fcdc2fa93035e911a5a9505cc50Dan Gohman const PPCTargetLowering &PPCLowering; 43152b7e18748f7e06a93260f22cc9dac8eb3abee2Evan Cheng const PPCSubtarget &PPCSubTarget; 444416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner unsigned GlobalBaseReg; 45a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner public: 461002c0203450620594a85454c6a095ca94b87cb2Dan Gohman explicit PPCDAGToDAGISel(PPCTargetMachine &tm) 4779ce276083ced01256a0eb7d80731e4948ca6e87Dan Gohman : SelectionDAGISel(tm), TM(tm), 48152b7e18748f7e06a93260f22cc9dac8eb3abee2Evan Cheng PPCLowering(*TM.getTargetLowering()), 49152b7e18748f7e06a93260f22cc9dac8eb3abee2Evan Cheng PPCSubTarget(*TM.getSubtargetImpl()) {} 506e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 51ad2afc2a421a0e41603d5eee412d4d8c77e9bc1cDan Gohman virtual bool runOnMachineFunction(MachineFunction &MF) { 524416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Make sure we re-emit a set of the global base reg if necessary 534416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalBaseReg = 0; 54ad2afc2a421a0e41603d5eee412d4d8c77e9bc1cDan Gohman SelectionDAGISel::runOnMachineFunction(MF); 556e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 56ad2afc2a421a0e41603d5eee412d4d8c77e9bc1cDan Gohman InsertVRSaveCode(MF); 574bb189507281af0da8aff91743b5198acbf2398bChris Lattner return true; 584416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 596e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 60a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// getI32Imm - Return a target constant with the specified value, of type 61a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// i32. 62475871a144eb604ddaf37503397ba0941442e5fbDan Gohman inline SDValue getI32Imm(unsigned Imm) { 63825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->getTargetConstant(Imm, MVT::i32); 64a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 654416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 66c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// getI64Imm - Return a target constant with the specified value, of type 67c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// i64. 68475871a144eb604ddaf37503397ba0941442e5fbDan Gohman inline SDValue getI64Imm(uint64_t Imm) { 69825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->getTargetConstant(Imm, MVT::i64); 70c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 716e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 72c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// getSmallIPtrImm - Return a target constant of pointer type. 73475871a144eb604ddaf37503397ba0941442e5fbDan Gohman inline SDValue getSmallIPtrImm(unsigned Imm) { 74c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return CurDAG->getTargetConstant(Imm, PPCLowering.getPointerTy()); 75c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 766e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 776e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick /// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s 78f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// with any number of 0s on either side. The 1s are allowed to wrap from 79f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// LSB to MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 80f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// 0x0F0F0000 is not, since all 1s are not contiguous. 81f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman static bool isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME); 82f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman 83f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman 84f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// isRotateAndMask - Returns true if Mask and Shift can be folded into a 85f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// rotate and mask opcode and mask operation. 86b60d5194f52349b74914593919764fe8f4396bdfDale Johannesen static bool isRotateAndMask(SDNode *N, unsigned Mask, bool isShiftMask, 87f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman unsigned &SH, unsigned &MB, unsigned &ME); 886e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 894416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// getGlobalBaseReg - insert code into the entry mbb to materialize the PIC 904416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// base register. Return the virtual register that holds this value. 919ade218533429146731213eacb7e12060e65ff58Evan Cheng SDNode *getGlobalBaseReg(); 926e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 93a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Select - Convert the specified operand from a target-independent to a 94a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // target-specific node if it hasn't already been changed. 95eeb3a00b84b7767d236ec8cf0619b9217fc247b9Dan Gohman SDNode *Select(SDNode *N); 966e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 9702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDNode *SelectBitfieldInsert(SDNode *N); 9802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 992fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// SelectCC - Select a comparison of the specified values with the 1002fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// specified condition code, returning the CR# of the expression. 101f5f5dce897269885754fc79adeb809194da52942Dale Johannesen SDValue SelectCC(SDValue LHS, SDValue RHS, ISD::CondCode CC, DebugLoc dl); 1022fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 1037fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrImm - Returns true if the address N can be represented by 1047fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// a base register plus a signed 16-bit displacement [r+imm]. 10552a261b3c1391c5fec399ddeb3fc6ee9541e8790Chris Lattner bool SelectAddrImm(SDValue N, SDValue &Disp, 106475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Base) { 107fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner return PPCLowering.SelectAddressRegImm(N, Disp, Base, *CurDAG); 108fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner } 1096e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 11074531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner /// SelectAddrImmOffs - Return true if the operand is valid for a preinc 11174531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner /// immediate field. Because preinc imms have already been validated, just 11274531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner /// accept it. 11352a261b3c1391c5fec399ddeb3fc6ee9541e8790Chris Lattner bool SelectAddrImmOffs(SDValue N, SDValue &Out) const { 11474531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner Out = N; 11574531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner return true; 11674531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner } 1176e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 1187fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrIdx - Given the specified addressed, check to see if it can be 1197fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// represented as an indexed [r+r] operation. Returns false if it can 1207fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// be represented by [r+imm], which are preferred. 12152a261b3c1391c5fec399ddeb3fc6ee9541e8790Chris Lattner bool SelectAddrIdx(SDValue N, SDValue &Base, SDValue &Index) { 122fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner return PPCLowering.SelectAddressRegReg(N, Base, Index, *CurDAG); 123fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner } 1246e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 1257fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrIdxOnly - Given the specified addressed, force it to be 1267fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// represented as an indexed [r+r] operation. 12752a261b3c1391c5fec399ddeb3fc6ee9541e8790Chris Lattner bool SelectAddrIdxOnly(SDValue N, SDValue &Base, SDValue &Index) { 128fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner return PPCLowering.SelectAddressRegRegOnly(N, Base, Index, *CurDAG); 129fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner } 1309944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 131e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// SelectAddrImmShift - Returns true if the address N can be represented by 132e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// a base register plus a signed 14-bit displacement [r+imm*4]. Suitable 133e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// for use by STD and friends. 13452a261b3c1391c5fec399ddeb3fc6ee9541e8790Chris Lattner bool SelectAddrImmShift(SDValue N, SDValue &Disp, SDValue &Base) { 135fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner return PPCLowering.SelectAddressRegImmShift(N, Disp, Base, *CurDAG); 136fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner } 1376e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 138e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner /// SelectInlineAsmMemoryOperand - Implement addressing mode selection for 1395cfd4ddece1b73a719830ae84eb74d491f87b9d5Dale Johannesen /// inline asm expressions. It is always correct to compute the value into 1405cfd4ddece1b73a719830ae84eb74d491f87b9d5Dale Johannesen /// a register. The case of adding a (possibly relocatable) constant to a 1415cfd4ddece1b73a719830ae84eb74d491f87b9d5Dale Johannesen /// register can be improved, but it is wrong to substitute Reg+Reg for 1425cfd4ddece1b73a719830ae84eb74d491f87b9d5Dale Johannesen /// Reg in an asm, because the load or store opcode would have to change. 1435cfd4ddece1b73a719830ae84eb74d491f87b9d5Dale Johannesen virtual bool SelectInlineAsmMemoryOperand(const SDValue &Op, 144e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner char ConstraintCode, 145f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman std::vector<SDValue> &OutOps) { 1465cfd4ddece1b73a719830ae84eb74d491f87b9d5Dale Johannesen OutOps.push_back(Op); 147e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner return false; 148e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 1496e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 150ad2afc2a421a0e41603d5eee412d4d8c77e9bc1cDan Gohman void InsertVRSaveCode(MachineFunction &MF); 1514bb189507281af0da8aff91743b5198acbf2398bChris Lattner 152a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner virtual const char *getPassName() const { 153a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return "PowerPC DAG->DAG Pattern Instruction Selection"; 1546e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick } 1556e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 156af165385112037cb942e94ea562a67990b7d6220Chris Lattner// Include the pieces autogenerated from the target description. 1574c7b43b43fdf943c7298718e15ab5d6dfe345be7Chris Lattner#include "PPCGenDAGISel.inc" 1586e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 159bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattnerprivate: 160eeb3a00b84b7767d236ec8cf0619b9217fc247b9Dan Gohman SDNode *SelectSETCC(SDNode *N); 161a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner }; 162a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 163a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1644bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// InsertVRSaveCode - Once the entire function has been instruction selected, 1654bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// all virtual registers are created and all machine instructions are built, 1664bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// check to see if we need to save/restore VRSAVE. If so, do it. 167ad2afc2a421a0e41603d5eee412d4d8c77e9bc1cDan Gohmanvoid PPCDAGToDAGISel::InsertVRSaveCode(MachineFunction &Fn) { 1681877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // Check to see if this function uses vector registers, which means we have to 1696e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick // save and restore the VRSAVE register and update it with the regs we use. 1701877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 171f451cb870efcf9e0302d25ed05f4cac6bb494e42Dan Gohman // In this case, there will be virtual registers of vector type created 1721877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // by the scheduler. Detect them now. 1731877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner bool HasVectorVReg = false; 174b2581353011673d1241af2d7d334be46088248d8Jakob Stoklund Olesen for (unsigned i = 0, e = RegInfo->getNumVirtRegs(); i != e; ++i) { 175b2581353011673d1241af2d7d334be46088248d8Jakob Stoklund Olesen unsigned Reg = TargetRegisterInfo::index2VirtReg(i); 176b2581353011673d1241af2d7d334be46088248d8Jakob Stoklund Olesen if (RegInfo->getRegClass(Reg) == &PPC::VRRCRegClass) { 1771877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner HasVectorVReg = true; 1781877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner break; 1791877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner } 180b2581353011673d1241af2d7d334be46088248d8Jakob Stoklund Olesen } 1814bb189507281af0da8aff91743b5198acbf2398bChris Lattner if (!HasVectorVReg) return; // nothing to do. 1826e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 1831877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // If we have a vector register, we want to emit code into the entry and exit 1841877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // blocks to save and restore the VRSAVE register. We do this here (instead 1851877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // of marking all vector instructions as clobbering VRSAVE) for two reasons: 1861877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 1871877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 1. This (trivially) reduces the load on the register allocator, by not 1881877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // having to represent the live range of the VRSAVE register. 1891877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2. This (more significantly) allows us to create a temporary virtual 1901877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // register to hold the saved VRSAVE value, allowing this temporary to be 1911877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // register allocated, instead of forcing it to be spilled to the stack. 1924bb189507281af0da8aff91743b5198acbf2398bChris Lattner 1934bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Create two vregs - one to hold the VRSAVE register that is live-in to the 1944bb189507281af0da8aff91743b5198acbf2398bChris Lattner // function and one for the value after having bits or'd into it. 19584bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner unsigned InVRSAVE = RegInfo->createVirtualRegister(&PPC::GPRCRegClass); 19684bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner unsigned UpdatedVRSAVE = RegInfo->createVirtualRegister(&PPC::GPRCRegClass); 1976e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 198c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng const TargetInstrInfo &TII = *TM.getInstrInfo(); 1994bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock &EntryBB = *Fn.begin(); 200c7f3ace20c325521c68335a1689645b43b06ddf0Chris Lattner DebugLoc dl; 2014bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Emit the following code into the entry block: 2024bb189507281af0da8aff91743b5198acbf2398bChris Lattner // InVRSAVE = MFVRSAVE 2034bb189507281af0da8aff91743b5198acbf2398bChris Lattner // UpdatedVRSAVE = UPDATE_VRSAVE InVRSAVE 2044bb189507281af0da8aff91743b5198acbf2398bChris Lattner // MTVRSAVE UpdatedVRSAVE 2054bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock::iterator IP = EntryBB.begin(); // Insert Point 206536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen BuildMI(EntryBB, IP, dl, TII.get(PPC::MFVRSAVE), InVRSAVE); 207536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen BuildMI(EntryBB, IP, dl, TII.get(PPC::UPDATE_VRSAVE), 20869244300b8a0112efb44b6273ecea4ca6264b8cfChris Lattner UpdatedVRSAVE).addReg(InVRSAVE); 209536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen BuildMI(EntryBB, IP, dl, TII.get(PPC::MTVRSAVE)).addReg(UpdatedVRSAVE); 2106e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 2114bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Find all return blocks, outputting a restore in each epilog. 2124bb189507281af0da8aff91743b5198acbf2398bChris Lattner for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 2135a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (!BB->empty() && BB->back().isReturn()) { 2144bb189507281af0da8aff91743b5198acbf2398bChris Lattner IP = BB->end(); --IP; 2156e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 2164bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Skip over all terminator instructions, which are part of the return 2174bb189507281af0da8aff91743b5198acbf2398bChris Lattner // sequence. 2184bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock::iterator I2 = IP; 2195a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng while (I2 != BB->begin() && (--I2)->isTerminator()) 2204bb189507281af0da8aff91743b5198acbf2398bChris Lattner IP = I2; 2216e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 2224bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Emit: MTVRSAVE InVRSave 223536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen BuildMI(*BB, IP, dl, TII.get(PPC::MTVRSAVE)).addReg(InVRSAVE); 2246e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick } 2251877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner } 226bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner} 2276cd40d5888f905a3820d5d6c71e57cc0e02abb4aChris Lattner 2284bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2294416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// getGlobalBaseReg - Output the instructions required to put the 2304416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// base address to use for accessing globals into a register. 2314416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// 2329ade218533429146731213eacb7e12060e65ff58Evan ChengSDNode *PPCDAGToDAGISel::getGlobalBaseReg() { 2334416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (!GlobalBaseReg) { 234c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng const TargetInstrInfo &TII = *TM.getInstrInfo(); 2354416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Insert the set of GlobalBaseReg into the first MBB of the function 236bd51c677390d8e13560cbf3ea972b95a5fbc1f9aDan Gohman MachineBasicBlock &FirstMBB = MF->front(); 2374416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock::iterator MBBI = FirstMBB.begin(); 238c7f3ace20c325521c68335a1689645b43b06ddf0Chris Lattner DebugLoc dl; 239c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 240825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (PPCLowering.getPointerTy() == MVT::i32) { 24184bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner GlobalBaseReg = RegInfo->createVirtualRegister(PPC::GPRCRegisterClass); 2420113e4e3f242fef41e6c733d1945f9950276cc9cCameron Zwarich BuildMI(FirstMBB, MBBI, dl, TII.get(PPC::MovePCtoLR)); 243536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen BuildMI(FirstMBB, MBBI, dl, TII.get(PPC::MFLR), GlobalBaseReg); 244d10434215da983b58389d2a0880dfcd2cd3b7f35Chris Lattner } else { 24584bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner GlobalBaseReg = RegInfo->createVirtualRegister(PPC::G8RCRegisterClass); 2460113e4e3f242fef41e6c733d1945f9950276cc9cCameron Zwarich BuildMI(FirstMBB, MBBI, dl, TII.get(PPC::MovePCtoLR8)); 247536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen BuildMI(FirstMBB, MBBI, dl, TII.get(PPC::MFLR8), GlobalBaseReg); 248d10434215da983b58389d2a0880dfcd2cd3b7f35Chris Lattner } 2494416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 25093c53e5583427ee567293a9a21c6c76fccf218caGabor Greif return CurDAG->getRegister(GlobalBaseReg, 25193c53e5583427ee567293a9a21c6c76fccf218caGabor Greif PPCLowering.getPointerTy()).getNode(); 2524416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner} 2534416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 254c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isIntS16Immediate - This method tests to see if the node is either a 32-bit 255c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// or 64-bit immediate, and if the value can be accurately represented as a 256c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// sign extension from a 16-bit value. If so, this returns true and the 257c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// immediate. 258c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isIntS16Immediate(SDNode *N, short &Imm) { 259c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getOpcode() != ISD::Constant) 260c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return false; 2614416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 262f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman Imm = (short)cast<ConstantSDNode>(N)->getZExtValue(); 263825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (N->getValueType(0) == MVT::i32) 264f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman return Imm == (int32_t)cast<ConstantSDNode>(N)->getZExtValue(); 265c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner else 266f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman return Imm == (int64_t)cast<ConstantSDNode>(N)->getZExtValue(); 267c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 268c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 269475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanstatic bool isIntS16Immediate(SDValue Op, short &Imm) { 270ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return isIntS16Immediate(Op.getNode(), Imm); 271c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 272c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 273c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 274c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isInt32Immediate - This method tests to see if the node is a 32-bit constant 275c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// operand. If so Imm will receive the 32-bit value. 276c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isInt32Immediate(SDNode *N, unsigned &Imm) { 277825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i32) { 278f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman Imm = cast<ConstantSDNode>(N)->getZExtValue(); 2790f3257a3302b60c128a667db6736e81335316c1eNate Begeman return true; 2800f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 2810f3257a3302b60c128a667db6736e81335316c1eNate Begeman return false; 2820f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 2830f3257a3302b60c128a667db6736e81335316c1eNate Begeman 284c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isInt64Immediate - This method tests to see if the node is a 64-bit constant 285c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// operand. If so Imm will receive the 64-bit value. 286c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isInt64Immediate(SDNode *N, uint64_t &Imm) { 287825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i64) { 288f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman Imm = cast<ConstantSDNode>(N)->getZExtValue(); 289c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return true; 290c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 291c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return false; 292c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 293c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 294c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// isInt32Immediate - This method tests to see if a constant operand. 295c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// If so Imm will receive the 32 bit value. 296475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanstatic bool isInt32Immediate(SDValue N, unsigned &Imm) { 297ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return isInt32Immediate(N.getNode(), Imm); 298c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 299c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 300c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 301c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// isOpcWithIntImmediate - This method tests to see if the node is a specific 302c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// opcode and that it has a immediate integer right operand. 303c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// If so Imm will receive the 32 bit value. 304c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isOpcWithIntImmediate(SDNode *N, unsigned Opc, unsigned& Imm) { 30593c53e5583427ee567293a9a21c6c76fccf218caGabor Greif return N->getOpcode() == Opc 30693c53e5583427ee567293a9a21c6c76fccf218caGabor Greif && isInt32Immediate(N->getOperand(1).getNode(), Imm); 307c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 308c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 309f42f133938545d4f5c249bcfef63db772ce8e942Nate Begemanbool PPCDAGToDAGISel::isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME) { 310cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isShiftedMask_32(Val)) { 311cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first non-zero bit 312cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman MB = CountLeadingZeros_32(Val); 313cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first zero bit after the run of ones 314cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman ME = CountLeadingZeros_32((Val - 1) ^ Val); 315cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return true; 3162fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } else { 3172fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner Val = ~Val; // invert mask 3182fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner if (isShiftedMask_32(Val)) { 3192fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first zero bit 3202fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner ME = CountLeadingZeros_32(Val) - 1; 3212fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first one bit after the run of zeros 3222fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner MB = CountLeadingZeros_32((Val - 1) ^ Val) + 1; 3232fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner return true; 3242fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } 325cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 326cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // no run present 327cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 328cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 329cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 3306e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trickbool PPCDAGToDAGISel::isRotateAndMask(SDNode *N, unsigned Mask, 3316e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick bool isShiftMask, unsigned &SH, 332f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman unsigned &MB, unsigned &ME) { 333da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // Don't even go down this path for i64, since different logic will be 334da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // necessary for rldicl/rldicr/rldimi. 335825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (N->getValueType(0) != MVT::i32) 336da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman return false; 337da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman 338cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Shift = 32; 339cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Indeterminant = ~0; // bit mask marking indeterminant results 340cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Opcode = N->getOpcode(); 34115055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner if (N->getNumOperands() != 2 || 342ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif !isInt32Immediate(N->getOperand(1).getNode(), Shift) || (Shift > 31)) 343cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 3446e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 345cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Opcode == ISD::SHL) { 346cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift left to mask if it comes first 347b60d5194f52349b74914593919764fe8f4396bdfDale Johannesen if (isShiftMask) Mask = Mask << Shift; 348cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 349cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu << Shift); 3506e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick } else if (Opcode == ISD::SRL) { 351cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift right to mask if it comes first 352b60d5194f52349b74914593919764fe8f4396bdfDale Johannesen if (isShiftMask) Mask = Mask >> Shift; 353cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 354cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu >> Shift); 355cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // adjust for the left rotate 356cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Shift = 32 - Shift; 357f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman } else if (Opcode == ISD::ROTL) { 358f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman Indeterminant = 0; 359cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 360cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 361cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 3626e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 363cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // if the mask doesn't intersect any Indeterminant bits 364cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Mask && !(Mask & Indeterminant)) { 3650949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner SH = Shift & 31; 366cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // make sure the mask is still a mask (wrap arounds may not be) 367cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return isRunOfOnes(Mask, MB, ME); 368cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 369cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 370cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 371cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 37202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// SelectBitfieldInsert - turn an or of two masked values into 37302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// the rotate left word immediate then mask insert (rlwimi) instruction. 3741d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDNode *PPCDAGToDAGISel::SelectBitfieldInsert(SDNode *N) { 375475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op0 = N->getOperand(0); 376475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op1 = N->getOperand(1); 377ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen DebugLoc dl = N->getDebugLoc(); 3786e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 379b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman APInt LKZ, LKO, RKZ, RKO; 38026c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola CurDAG->ComputeMaskedBits(Op0, LKZ, LKO); 38126c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola CurDAG->ComputeMaskedBits(Op1, RKZ, RKO); 3826e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 383b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman unsigned TargetMask = LKZ.getZExtValue(); 384b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman unsigned InsertMask = RKZ.getZExtValue(); 3856e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 3864667f2cbad246beccfca5411a26add24d1007035Nate Begeman if ((TargetMask | InsertMask) == 0xFFFFFFFF) { 3874667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Op0Opc = Op0.getOpcode(); 3884667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Op1Opc = Op1.getOpcode(); 3894667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Value, SH = 0; 3904667f2cbad246beccfca5411a26add24d1007035Nate Begeman TargetMask = ~TargetMask; 3914667f2cbad246beccfca5411a26add24d1007035Nate Begeman InsertMask = ~InsertMask; 39277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 3934667f2cbad246beccfca5411a26add24d1007035Nate Begeman // If the LHS has a foldable shift and the RHS does not, then swap it to the 3944667f2cbad246beccfca5411a26add24d1007035Nate Begeman // RHS so that we can fold the shift into the insert. 39577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op0Opc == ISD::AND && Op1Opc == ISD::AND) { 39677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op0.getOperand(0).getOpcode() == ISD::SHL || 39777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op0.getOperand(0).getOpcode() == ISD::SRL) { 39877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op1.getOperand(0).getOpcode() != ISD::SHL && 39977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1.getOperand(0).getOpcode() != ISD::SRL) { 40077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman std::swap(Op0, Op1); 40177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman std::swap(Op0Opc, Op1Opc); 4024667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(TargetMask, InsertMask); 40377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 40477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 4054667f2cbad246beccfca5411a26add24d1007035Nate Begeman } else if (Op0Opc == ISD::SHL || Op0Opc == ISD::SRL) { 4064667f2cbad246beccfca5411a26add24d1007035Nate Begeman if (Op1Opc == ISD::AND && Op1.getOperand(0).getOpcode() != ISD::SHL && 4074667f2cbad246beccfca5411a26add24d1007035Nate Begeman Op1.getOperand(0).getOpcode() != ISD::SRL) { 4084667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(Op0, Op1); 4094667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(Op0Opc, Op1Opc); 4104667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(TargetMask, InsertMask); 4114667f2cbad246beccfca5411a26add24d1007035Nate Begeman } 41202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 4136e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 41477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman unsigned MB, ME; 4150949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner if (InsertMask && isRunOfOnes(InsertMask, MB, ME)) { 4165ca124691bc81ed013593151c500d8104f7068ddDale Johannesen SDValue Tmp1, Tmp2; 41777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 41877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if ((Op1Opc == ISD::SHL || Op1Opc == ISD::SRL) && 419c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(Op1.getOperand(1), Value)) { 42077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0); 42177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SH = (Op1Opc == ISD::SHL) ? Value : 32 - Value; 42202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 42377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op1Opc == ISD::AND) { 42477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman unsigned SHOpc = Op1.getOperand(0).getOpcode(); 42577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if ((SHOpc == ISD::SHL || SHOpc == ISD::SRL) && 426c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(Op1.getOperand(0).getOperand(1), Value)) { 42777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0).getOperand(0); 42877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SH = (SHOpc == ISD::SHL) ? Value : 32 - Value; 42977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } else { 43077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0); 43177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 43202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 4335ca124691bc81ed013593151c500d8104f7068ddDale Johannesen 4340949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner SH &= 31; 4355ca124691bc81ed013593151c500d8104f7068ddDale Johannesen SDValue Ops[] = { Op0, Op1, getI32Imm(SH), getI32Imm(MB), 4360b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(ME) }; 437602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return CurDAG->getMachineNode(PPC::RLWIMI, dl, MVT::i32, Ops, 5); 43802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 43902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 44002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 44102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman} 44202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 4432fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// SelectCC - Select a comparison of the specified values with the specified 4442fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// condition code, returning the CR# of the expression. 445475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue PPCDAGToDAGISel::SelectCC(SDValue LHS, SDValue RHS, 446f5f5dce897269885754fc79adeb809194da52942Dale Johannesen ISD::CondCode CC, DebugLoc dl) { 4472fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Always select the LHS. 448c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner unsigned Opc; 4496e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 450825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (LHS.getValueType() == MVT::i32) { 451529c233498c59a544b26b277f8fe30e6a80cc6f8Chris Lattner unsigned Imm; 4523836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner if (CC == ISD::SETEQ || CC == ISD::SETNE) { 4533836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner if (isInt32Immediate(RHS, Imm)) { 4543836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // SETEQ/SETNE comparison with 16-bit immediate, fold it. 45534247a0f356edf45ae3ad9ce04e1f90a77c6dba7Benjamin Kramer if (isUInt<16>(Imm)) 456602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return SDValue(CurDAG->getMachineNode(PPC::CMPLWI, dl, MVT::i32, LHS, 457602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI32Imm(Imm & 0xFFFF)), 0); 4583836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // If this is a 16-bit signed immediate, fold it. 45934247a0f356edf45ae3ad9ce04e1f90a77c6dba7Benjamin Kramer if (isInt<16>((int)Imm)) 460602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return SDValue(CurDAG->getMachineNode(PPC::CMPWI, dl, MVT::i32, LHS, 461602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI32Imm(Imm & 0xFFFF)), 0); 4626e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 4633836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // For non-equality comparisons, the default code would materialize the 4643836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // constant, then compare against it, like this: 4653836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // lis r2, 4660 4666e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick // ori r2, r2, 22136 4673836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // cmpw cr0, r3, r2 4683836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // Since we are just comparing for equality, we can emit this instead: 4693836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // xoris r0,r3,0x1234 4703836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // cmplwi cr0,r0,0x5678 4713836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // beq cr0,L6 472602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue Xor(CurDAG->getMachineNode(PPC::XORIS, dl, MVT::i32, LHS, 473602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI32Imm(Imm >> 16)), 0); 474602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return SDValue(CurDAG->getMachineNode(PPC::CMPLWI, dl, MVT::i32, Xor, 475602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI32Imm(Imm & 0xFFFF)), 0); 4763836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner } 4773836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner Opc = PPC::CMPLW; 4783836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner } else if (ISD::isUnsignedIntSetCC(CC)) { 47934247a0f356edf45ae3ad9ce04e1f90a77c6dba7Benjamin Kramer if (isInt32Immediate(RHS, Imm) && isUInt<16>(Imm)) 480602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return SDValue(CurDAG->getMachineNode(PPC::CMPLWI, dl, MVT::i32, LHS, 481602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI32Imm(Imm & 0xFFFF)), 0); 482c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPLW; 483c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } else { 484c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short SImm; 485c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(RHS, SImm)) 486602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return SDValue(CurDAG->getMachineNode(PPC::CMPWI, dl, MVT::i32, LHS, 487602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI32Imm((int)SImm & 0xFFFF)), 488c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 0); 489c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPW; 490c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 491825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (LHS.getValueType() == MVT::i64) { 492c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner uint64_t Imm; 493711762497c27357adc1edf8d4237c2770fa303bbChris Lattner if (CC == ISD::SETEQ || CC == ISD::SETNE) { 494ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (isInt64Immediate(RHS.getNode(), Imm)) { 495711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // SETEQ/SETNE comparison with 16-bit immediate, fold it. 49634247a0f356edf45ae3ad9ce04e1f90a77c6dba7Benjamin Kramer if (isUInt<16>(Imm)) 497602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return SDValue(CurDAG->getMachineNode(PPC::CMPLDI, dl, MVT::i64, LHS, 498602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI32Imm(Imm & 0xFFFF)), 0); 499711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // If this is a 16-bit signed immediate, fold it. 50034247a0f356edf45ae3ad9ce04e1f90a77c6dba7Benjamin Kramer if (isInt<16>(Imm)) 501602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return SDValue(CurDAG->getMachineNode(PPC::CMPDI, dl, MVT::i64, LHS, 502602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI32Imm(Imm & 0xFFFF)), 0); 5036e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 504711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // For non-equality comparisons, the default code would materialize the 505711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // constant, then compare against it, like this: 506711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // lis r2, 4660 5076e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick // ori r2, r2, 22136 508711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // cmpd cr0, r3, r2 509711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // Since we are just comparing for equality, we can emit this instead: 510711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // xoris r0,r3,0x1234 511711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // cmpldi cr0,r0,0x5678 512711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // beq cr0,L6 51334247a0f356edf45ae3ad9ce04e1f90a77c6dba7Benjamin Kramer if (isUInt<32>(Imm)) { 514602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue Xor(CurDAG->getMachineNode(PPC::XORIS8, dl, MVT::i64, LHS, 515602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI64Imm(Imm >> 16)), 0); 516602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return SDValue(CurDAG->getMachineNode(PPC::CMPLDI, dl, MVT::i64, Xor, 517602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI64Imm(Imm & 0xFFFF)), 0); 518711762497c27357adc1edf8d4237c2770fa303bbChris Lattner } 519711762497c27357adc1edf8d4237c2770fa303bbChris Lattner } 520711762497c27357adc1edf8d4237c2770fa303bbChris Lattner Opc = PPC::CMPLD; 521711762497c27357adc1edf8d4237c2770fa303bbChris Lattner } else if (ISD::isUnsignedIntSetCC(CC)) { 52234247a0f356edf45ae3ad9ce04e1f90a77c6dba7Benjamin Kramer if (isInt64Immediate(RHS.getNode(), Imm) && isUInt<16>(Imm)) 523602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return SDValue(CurDAG->getMachineNode(PPC::CMPLDI, dl, MVT::i64, LHS, 524602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI64Imm(Imm & 0xFFFF)), 0); 525c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPLD; 526c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } else { 527c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short SImm; 528c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(RHS, SImm)) 529602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return SDValue(CurDAG->getMachineNode(PPC::CMPDI, dl, MVT::i64, LHS, 530602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI64Imm(SImm & 0xFFFF)), 531c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 0); 532c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPD; 533c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 534825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (LHS.getValueType() == MVT::f32) { 535c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::FCMPUS; 5362fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 537825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson assert(LHS.getValueType() == MVT::f64 && "Unknown vt!"); 538c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::FCMPUD; 5392fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 540602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return SDValue(CurDAG->getMachineNode(Opc, dl, MVT::i32, LHS, RHS), 0); 5412fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 5422fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 543df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattnerstatic PPC::Predicate getPredicateForSetCC(ISD::CondCode CC) { 5442fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner switch (CC) { 5455d634ce466173f6fde49470fad125eb09532caebChris Lattner case ISD::SETUEQ: 54653e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETONE: 54753e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETOLE: 54853e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETOGE: 549c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Should be lowered by legalize!"); 550c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Unknown condition!"); 55153e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETOEQ: 552df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETEQ: return PPC::PRED_EQ; 5535d634ce466173f6fde49470fad125eb09532caebChris Lattner case ISD::SETUNE: 554df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETNE: return PPC::PRED_NE; 55553e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETOLT: 556df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETLT: return PPC::PRED_LT; 5572fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULE: 558df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETLE: return PPC::PRED_LE; 55953e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETOGT: 560df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETGT: return PPC::PRED_GT; 5612fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGE: 562df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETGE: return PPC::PRED_GE; 563df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETO: return PPC::PRED_NU; 564df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETUO: return PPC::PRED_UN; 56553e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen // These two are invalid for floating point. Assume we have int. 56653e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETULT: return PPC::PRED_LT; 56753e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETUGT: return PPC::PRED_GT; 5682fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 5692fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 5702fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 57164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// getCRIdxForSetCC - Return the index of the condition register field 57264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// associated with the SetCC condition, and whether or not the field is 57364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// treated as inverted. That is, lt = 0; ge = 0 inverted. 574fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner/// 575fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner/// If this returns with Other != -1, then the returned comparison is an or of 576fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner/// two simpler comparisons. In this case, Invert is guaranteed to be false. 577fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattnerstatic unsigned getCRIdxForSetCC(ISD::CondCode CC, bool &Invert, int &Other) { 578fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner Invert = false; 579fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner Other = -1; 58064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 581c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Unknown condition!"); 582fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETOLT: 583fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETLT: return 0; // Bit #0 = SETOLT 584fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETOGT: 585fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETGT: return 1; // Bit #1 = SETOGT 586fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETOEQ: 587fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETEQ: return 2; // Bit #2 = SETOEQ 588fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETUO: return 3; // Bit #3 = SETUO 58964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGE: 590fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETGE: Invert = true; return 0; // !Bit #0 = SETUGE 59164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULE: 592fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETLE: Invert = true; return 1; // !Bit #1 = SETULE 5938e2a04e21dc8299bdaba4321a6e690712dab9617Chris Lattner case ISD::SETUNE: 594fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETNE: Invert = true; return 2; // !Bit #2 = SETUNE 595fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETO: Invert = true; return 3; // !Bit #3 = SETO 5966e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick case ISD::SETUEQ: 5976e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick case ISD::SETOGE: 5986e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick case ISD::SETOLE: 59953e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETONE: 600c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Invalid branch code: should be expanded by legalize"); 60153e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen // These are invalid for floating point. Assume integer. 60253e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETULT: return 0; 60353e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETUGT: return 1; 60464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 60564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner} 6069944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 607eeb3a00b84b7767d236ec8cf0619b9217fc247b9Dan GohmanSDNode *PPCDAGToDAGISel::SelectSETCC(SDNode *N) { 608a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen DebugLoc dl = N->getDebugLoc(); 609222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Imm; 610222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get(); 6118e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky EVT PtrVT = CurDAG->getTargetLoweringInfo().getPointerTy(); 6128e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky bool isPPC64 = (PtrVT == MVT::i64); 6138e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky 614c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm)) { 615222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // We can codegen setcc op, imm very efficiently compared to a brcond. 616222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Check for those cases here. 617222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // setcc op, 0 618222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (Imm == 0) { 619475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op = N->getOperand(0); 620222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 621dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 6220b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng case ISD::SETEQ: { 623602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman Op = SDValue(CurDAG->getMachineNode(PPC::CNTLZW, dl, MVT::i32, Op), 0); 624475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Op, getI32Imm(27), getI32Imm(5), getI32Imm(31) }; 625825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 6260b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng } 627dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 6288e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky if (isPPC64) break; 629475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue AD = 630f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner SDValue(CurDAG->getMachineNode(PPC::ADDIC, dl, MVT::i32, MVT::Glue, 631602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman Op, getI32Imm(~0U)), 0); 6326e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, 63395514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng AD.getValue(1)); 634dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 6350b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng case ISD::SETLT: { 636475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Op, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 637825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 6380b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng } 639dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETGT: { 640475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue T = 641602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue(CurDAG->getMachineNode(PPC::NEG, dl, MVT::i32, Op), 0); 642602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman T = SDValue(CurDAG->getMachineNode(PPC::ANDC, dl, MVT::i32, T, Op), 0); 643475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { T, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 644825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 645dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 646222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 647222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else if (Imm == ~0U) { // setcc op, -1 648475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op = N->getOperand(0); 649222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 650dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 651dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETEQ: 6528e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky if (isPPC64) break; 653f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner Op = SDValue(CurDAG->getMachineNode(PPC::ADDIC, dl, MVT::i32, MVT::Glue, 654602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman Op, getI32Imm(1)), 0); 6556e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick return CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 6566e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick SDValue(CurDAG->getMachineNode(PPC::LI, dl, 657602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman MVT::i32, 658602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI32Imm(0)), 0), 659a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen Op.getValue(1)); 660dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 6618e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky if (isPPC64) break; 662602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman Op = SDValue(CurDAG->getMachineNode(PPC::NOR, dl, MVT::i32, Op, Op), 0); 663f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner SDNode *AD = CurDAG->getMachineNode(PPC::ADDIC, dl, MVT::i32, MVT::Glue, 664602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman Op, getI32Imm(~0U)); 665825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, SDValue(AD, 0), 666475871a144eb604ddaf37503397ba0941442e5fbDan Gohman Op, SDValue(AD, 1)); 667dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 668dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETLT: { 669602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue AD = SDValue(CurDAG->getMachineNode(PPC::ADDI, dl, MVT::i32, Op, 670602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI32Imm(1)), 0); 671602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue AN = SDValue(CurDAG->getMachineNode(PPC::AND, dl, MVT::i32, AD, 672602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman Op), 0); 673475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { AN, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 674825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 675dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 6760b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng case ISD::SETGT: { 677475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Op, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 6786e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick Op = SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32, Ops, 4), 679a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen 0); 6806e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Op, 68195514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng getI32Imm(1)); 682222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 6830b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng } 684222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 685222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 6866e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 687222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner bool Inv; 688fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner int OtherCondIdx; 689fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner unsigned Idx = getCRIdxForSetCC(CC, Inv, OtherCondIdx); 690f5f5dce897269885754fc79adeb809194da52942Dale Johannesen SDValue CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC, dl); 691475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue IntCR; 6926e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 693222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Force the ccreg into CR7. 694825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson SDValue CR7Reg = CurDAG->getRegister(PPC::CR7, MVT::i32); 6956e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 696475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue InFlag(0, 0); // Null incoming flag value. 6976e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick CCReg = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, CR7Reg, CCReg, 698db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner InFlag).getValue(1); 6996e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 700fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner if (PPCSubTarget.isGigaProcessor() && OtherCondIdx == -1) 701602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman IntCR = SDValue(CurDAG->getMachineNode(PPC::MFOCRF, dl, MVT::i32, CR7Reg, 702602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman CCReg), 0); 7035f07d5224ddc32f405d7e19de8e58e91ab2816bcDale Johannesen else 7045f07d5224ddc32f405d7e19de8e58e91ab2816bcDale Johannesen IntCR = SDValue(CurDAG->getMachineNode(PPC::MFCRpseud, dl, MVT::i32, 7055f07d5224ddc32f405d7e19de8e58e91ab2816bcDale Johannesen CR7Reg, CCReg), 0); 7066e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 707475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { IntCR, getI32Imm((32-(3-Idx)) & 31), 7080b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(31), getI32Imm(31) }; 709fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner if (OtherCondIdx == -1 && !Inv) 710825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 711fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 712fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // Get the specified bit. 713475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp = 714602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32, Ops, 4), 0); 715fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner if (Inv) { 716fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner assert(OtherCondIdx == -1 && "Can't have split plus negation"); 717825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Tmp, getI32Imm(1)); 718222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 719fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 720fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // Otherwise, we have to turn an operation like SETONE -> SETOLT | SETOGT. 721fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // We already got the bit for the first part of the comparison (e.g. SETULE). 722fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 723fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // Get the other bit of the comparison. 724fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner Ops[1] = getI32Imm((32-(3-OtherCondIdx)) & 31); 7256e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick SDValue OtherCond = 726602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32, Ops, 4), 0); 727fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 728825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::OR, MVT::i32, Tmp, OtherCond); 729222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner} 7302b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 7316a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 732a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Select - Convert the specified operand from a target-independent to a 733a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// target-specific node if it hasn't already been changed. 734eeb3a00b84b7767d236ec8cf0619b9217fc247b9Dan GohmanSDNode *PPCDAGToDAGISel::Select(SDNode *N) { 735eeb3a00b84b7767d236ec8cf0619b9217fc247b9Dan Gohman DebugLoc dl = N->getDebugLoc(); 736e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman if (N->isMachineOpcode()) 73764a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; // Already selected. 738d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 739a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOpcode()) { 74019c0907ba1c11c81dc231cf7b4143fdaf03466e4Chris Lattner default: break; 7416e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 74278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey case ISD::Constant: { 743825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (N->getValueType(0) == MVT::i64) { 74478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Get 64 bit value. 745f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman int64_t Imm = cast<ConstantSDNode>(N)->getZExtValue(); 74678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Assume no remaining bits. 74778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Remainder = 0; 74878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Assume no shift required. 74978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Shift = 0; 7506e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 75178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // If it can't be represented as a 32 bit value. 75234247a0f356edf45ae3ad9ce04e1f90a77c6dba7Benjamin Kramer if (!isInt<32>(Imm)) { 75378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Shift = CountTrailingZeros_64(Imm); 75478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey int64_t ImmSh = static_cast<uint64_t>(Imm) >> Shift; 7556e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 75678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // If the shifted value fits 32 bits. 75734247a0f356edf45ae3ad9ce04e1f90a77c6dba7Benjamin Kramer if (isInt<32>(ImmSh)) { 75878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Go with the shifted value. 75978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Imm = ImmSh; 76078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } else { 76178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Still stuck with a 64 bit value. 76278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Remainder = Imm; 76378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Shift = 32; 76478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Imm >>= 32; 76578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 76678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 7676e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 76878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Intermediate operand. 76978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey SDNode *Result; 77078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 77178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Handle first 32 bits. 77278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Lo = Imm & 0xFFFF; 77378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Hi = (Imm >> 16) & 0xFFFF; 7746e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 77578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Simple value. 77634247a0f356edf45ae3ad9ce04e1f90a77c6dba7Benjamin Kramer if (isInt<16>(Imm)) { 77778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Just the Lo bits. 778602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman Result = CurDAG->getMachineNode(PPC::LI8, dl, MVT::i64, getI32Imm(Lo)); 77978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } else if (Lo) { 78078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Handle the Hi bits. 78178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned OpC = Hi ? PPC::LIS8 : PPC::LI8; 782602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman Result = CurDAG->getMachineNode(OpC, dl, MVT::i64, getI32Imm(Hi)); 78378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // And Lo bits. 784602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman Result = CurDAG->getMachineNode(PPC::ORI8, dl, MVT::i64, 785602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue(Result, 0), getI32Imm(Lo)); 78678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } else { 78778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Just the Hi bits. 788602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman Result = CurDAG->getMachineNode(PPC::LIS8, dl, MVT::i64, getI32Imm(Hi)); 78978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 7906e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 79178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // If no shift, we're done. 79278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (!Shift) return Result; 79378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 79478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Shift for next step if the upper 32-bits were not zero. 79578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (Imm) { 796602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman Result = CurDAG->getMachineNode(PPC::RLDICR, dl, MVT::i64, 797602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue(Result, 0), 798602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI32Imm(Shift), 799602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getI32Imm(63 - Shift)); 80078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 80178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 80278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Add in the last bits as required. 80378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if ((Hi = (Remainder >> 16) & 0xFFFF)) { 804602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman Result = CurDAG->getMachineNode(PPC::ORIS8, dl, MVT::i64, 805602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue(Result, 0), getI32Imm(Hi)); 8066e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick } 80778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if ((Lo = Remainder & 0xFFFF)) { 808602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman Result = CurDAG->getMachineNode(PPC::ORI8, dl, MVT::i64, 809602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue(Result, 0), getI32Imm(Lo)); 81078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 8116e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 81278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey return Result; 81378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 81478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey break; 81578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 8166e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 81734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case ISD::SETCC: 818eeb3a00b84b7767d236ec8cf0619b9217fc247b9Dan Gohman return SelectSETCC(N); 81934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case PPCISD::GlobalBaseReg: 8209ade218533429146731213eacb7e12060e65ff58Evan Cheng return getGlobalBaseReg(); 8216e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 822e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner case ISD::FrameIndex: { 823e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner int FI = cast<FrameIndexSDNode>(N)->getIndex(); 824eeb3a00b84b7767d236ec8cf0619b9217fc247b9Dan Gohman SDValue TFI = CurDAG->getTargetFrameIndex(FI, N->getValueType(0)); 825eeb3a00b84b7767d236ec8cf0619b9217fc247b9Dan Gohman unsigned Opc = N->getValueType(0) == MVT::i32 ? PPC::ADDI : PPC::ADDI8; 826ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner if (N->hasOneUse()) 827eeb3a00b84b7767d236ec8cf0619b9217fc247b9Dan Gohman return CurDAG->SelectNodeTo(N, Opc, N->getValueType(0), TFI, 82895514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng getSmallIPtrImm(0)); 829eeb3a00b84b7767d236ec8cf0619b9217fc247b9Dan Gohman return CurDAG->getMachineNode(Opc, dl, N->getValueType(0), TFI, 830602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman getSmallIPtrImm(0)); 831e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } 8326d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner 8336d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner case PPCISD::MFCR: { 834475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue InFlag = N->getOperand(1); 8356d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner // Use MFOCRF if supported. 836152b7e18748f7e06a93260f22cc9dac8eb3abee2Evan Cheng if (PPCSubTarget.isGigaProcessor()) 837602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return CurDAG->getMachineNode(PPC::MFOCRF, dl, MVT::i32, 838602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman N->getOperand(0), InFlag); 8396d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner else 8405f07d5224ddc32f405d7e19de8e58e91ab2816bcDale Johannesen return CurDAG->getMachineNode(PPC::MFCRpseud, dl, MVT::i32, 8415f07d5224ddc32f405d7e19de8e58e91ab2816bcDale Johannesen N->getOperand(0), InFlag); 8426d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner } 8436e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 84488add100b3db715df4275c8ab408e6b51f28ff8fChris Lattner case ISD::SDIV: { 845405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: since this depends on the setting of the carry flag from the srawi 846405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // we should really be making notes about that for the scheduler. 8476e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick // FIXME: It sure would be nice if we could cheaply recognize the 848405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // srl/add/sra pattern the dag combiner will generate for this as 849405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // sra/addze rather than having to handle sdiv ourselves. oh well. 8508784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner unsigned Imm; 851c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm)) { 852475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue N0 = N->getOperand(0); 8538784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if ((signed)Imm > 0 && isPowerOf2_32(Imm)) { 8547e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 855f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner CurDAG->getMachineNode(PPC::SRAWI, dl, MVT::i32, MVT::Glue, 856602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman N0, getI32Imm(Log2_32(Imm))); 8576e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick return CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 858475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Op, 0), SDValue(Op, 1)); 8598784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } else if ((signed)Imm < 0 && isPowerOf2_32(-Imm)) { 8607e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 861f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner CurDAG->getMachineNode(PPC::SRAWI, dl, MVT::i32, MVT::Glue, 862602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman N0, getI32Imm(Log2_32(-Imm))); 863475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue PT = 864602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue(CurDAG->getMachineNode(PPC::ADDZE, dl, MVT::i32, 865602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue(Op, 0), SDValue(Op, 1)), 8667e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng 0); 867825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::NEG, MVT::i32, PT); 8688784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 8698784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 8706e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 871237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 872237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 873047b952e298352fe6feffedf02e359601133f465Chris Lattner } 8746e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 8754eab71497d10622bd209c53f8e56152877ac5638Chris Lattner case ISD::LOAD: { 8764eab71497d10622bd209c53f8e56152877ac5638Chris Lattner // Handle preincrement loads. 877eeb3a00b84b7767d236ec8cf0619b9217fc247b9Dan Gohman LoadSDNode *LD = cast<LoadSDNode>(N); 878e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT LoadedVT = LD->getMemoryVT(); 8796e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 8804eab71497d10622bd209c53f8e56152877ac5638Chris Lattner // Normal loads are handled by code generated from the .td file. 8814eab71497d10622bd209c53f8e56152877ac5638Chris Lattner if (LD->getAddressingMode() != ISD::PRE_INC) 8824eab71497d10622bd209c53f8e56152877ac5638Chris Lattner break; 8836e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 884475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Offset = LD->getOffset(); 8855b3bbc7cd7bff4275b94003d4bf1fa296c6a10d0Chris Lattner if (isa<ConstantSDNode>(Offset) || 8865b3bbc7cd7bff4275b94003d4bf1fa296c6a10d0Chris Lattner Offset.getOpcode() == ISD::TargetGlobalAddress) { 8876e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 8880851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner unsigned Opcode; 8890851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner bool isSExt = LD->getExtensionType() == ISD::SEXTLOAD; 890825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (LD->getValueType(0) != MVT::i64) { 8910851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner // Handle PPC32 integer and normal FP loads. 892825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson assert((!isSExt || LoadedVT == MVT::i16) && "Invalid sext update load"); 893825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson switch (LoadedVT.getSimpleVT().SimpleTy) { 894c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Invalid PPC load type!"); 895825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::f64: Opcode = PPC::LFDU; break; 896825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::f32: Opcode = PPC::LFSU; break; 897825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::i32: Opcode = PPC::LWZU; break; 898825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::i16: Opcode = isSExt ? PPC::LHAU : PPC::LHZU; break; 899825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::i1: 900825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::i8: Opcode = PPC::LBZU; break; 9010851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } 9020851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } else { 903825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson assert(LD->getValueType(0) == MVT::i64 && "Unknown load result type!"); 904825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson assert((!isSExt || LoadedVT == MVT::i16) && "Invalid sext update load"); 905825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson switch (LoadedVT.getSimpleVT().SimpleTy) { 906c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Invalid PPC load type!"); 907825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::i64: Opcode = PPC::LDU; break; 908825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::i32: Opcode = PPC::LWZU8; break; 909825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::i16: Opcode = isSExt ? PPC::LHAU8 : PPC::LHZU8; break; 910825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::i1: 911825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::i8: Opcode = PPC::LBZU8; break; 9120851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } 9130851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } 9146e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 915475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = LD->getChain(); 916475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Base = LD->getBasePtr(); 917475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Offset, Base, Chain }; 9184eab71497d10622bd209c53f8e56152877ac5638Chris Lattner // FIXME: PPC64 919602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return CurDAG->getMachineNode(Opcode, dl, LD->getValueType(0), 920602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman PPCLowering.getPointerTy(), 921602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman MVT::Other, Ops, 3); 9224eab71497d10622bd209c53f8e56152877ac5638Chris Lattner } else { 923c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("R+R preindex loads not supported yet!"); 9244eab71497d10622bd209c53f8e56152877ac5638Chris Lattner } 9254eab71497d10622bd209c53f8e56152877ac5638Chris Lattner } 9266e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 927cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman case ISD::AND: { 928f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman unsigned Imm, Imm2, SH, MB, ME; 929f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman 930cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and of a value rotated between 0 and 31 bits and then and'd 931cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // with a mask, emit rlwinm 932c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm) && 933ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif isRotateAndMask(N->getOperand(0).getNode(), Imm, false, SH, MB, ME)) { 934475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Val = N->getOperand(0).getOperand(0); 935475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Val, getI32Imm(SH), getI32Imm(MB), getI32Imm(ME) }; 936825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 937cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 938f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman // If this is just a masked value where the input is not handled above, and 939f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman // is not a rotate-left (handled by a pattern in the .td file), emit rlwinm 940f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman if (isInt32Immediate(N->getOperand(1), Imm) && 9416e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick isRunOfOnes(Imm, MB, ME) && 942f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman N->getOperand(0).getOpcode() != ISD::ROTL) { 943475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Val = N->getOperand(0); 944475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Val, getI32Imm(0), getI32Imm(MB), getI32Imm(ME) }; 945825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 946f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman } 947f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman // AND X, 0 -> 0, not "rlwinm 32". 948f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman if (isInt32Immediate(N->getOperand(1), Imm) && (Imm == 0)) { 949475871a144eb604ddaf37503397ba0941442e5fbDan Gohman ReplaceUses(SDValue(N, 0), N->getOperand(1)); 950f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman return NULL; 951f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman } 95250fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // ISD::OR doesn't get all the bitfield insertion fun. 95350fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // (and (or x, c1), c2) where isRunOfOnes(~(c1^c2)) is a bitfield insert 9546e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick if (isInt32Immediate(N->getOperand(1), Imm) && 95550fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman N->getOperand(0).getOpcode() == ISD::OR && 956c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(N->getOperand(0).getOperand(1), Imm2)) { 957c9a5ef524a9f461717bbf647b2d3da061aed720dChris Lattner unsigned MB, ME; 95850fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman Imm = ~(Imm^Imm2); 95950fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman if (isRunOfOnes(Imm, MB, ME)) { 960475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { N->getOperand(0).getOperand(0), 9610b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng N->getOperand(0).getOperand(1), 9620b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(0), getI32Imm(MB),getI32Imm(ME) }; 963602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman return CurDAG->getMachineNode(PPC::RLWIMI, dl, MVT::i32, Ops, 5); 96450fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 96550fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 9666e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 967237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 968237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 969cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 97002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::OR: 971825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (N->getValueType(0) == MVT::i32) 972ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner if (SDNode *I = SelectBitfieldInsert(N)) 973ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return I; 9746e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 975237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 976237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 977c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SHL: { 978c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 979ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::AND, Imm) && 9802d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 981475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { N->getOperand(0).getOperand(0), 9820b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(SH), getI32Imm(MB), getI32Imm(ME) }; 983825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 9848d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 9856e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 9862d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 9872d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 988c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 989c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRL: { 990c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 991ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::AND, Imm) && 9926e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick isRotateAndMask(N, Imm, true, SH, MB, ME)) { 993475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { N->getOperand(0).getOperand(0), 9940b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(SH), getI32Imm(MB), getI32Imm(ME) }; 995825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 9968d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 9976e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 9982d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 9992d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1000c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 100113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner case ISD::SELECT_CC: { 100213794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(4))->get(); 10038e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky EVT PtrVT = CurDAG->getTargetLoweringInfo().getPointerTy(); 10048e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky bool isPPC64 = (PtrVT == MVT::i64); 10056e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 1006c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner // Handle the setcc cases here. select_cc lhs, 0, 1, 0, cc 10078e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky if (!isPPC64) 10088e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N->getOperand(1))) 10098e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky if (ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N->getOperand(2))) 10108e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky if (ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N->getOperand(3))) 10118e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky if (N1C->isNullValue() && N3C->isNullValue() && 10128e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky N2C->getZExtValue() == 1ULL && CC == ISD::SETNE && 10138e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky // FIXME: Implement this optzn for PPC64. 10148e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky N->getValueType(0) == MVT::i32) { 10158e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky SDNode *Tmp = 10168e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky CurDAG->getMachineNode(PPC::ADDIC, dl, MVT::i32, MVT::Glue, 10178e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky N->getOperand(0), getI32Imm(~0U)); 10188e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, 10198e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky SDValue(Tmp, 0), N->getOperand(0), 10208e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky SDValue(Tmp, 1)); 10218e9d6720c3b62ad45bb97d43b47867a3097b433aRoman Divacky } 10228a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 1023f5f5dce897269885754fc79adeb809194da52942Dale Johannesen SDValue CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC, dl); 1024df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner unsigned BROpc = getPredicateForSetCC(CC); 10258a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 1026919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner unsigned SelectCCOp; 1027825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (N->getValueType(0) == MVT::i32) 1028c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner SelectCCOp = PPC::SELECT_CC_I4; 1029825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (N->getValueType(0) == MVT::i64) 1030c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner SelectCCOp = PPC::SELECT_CC_I8; 1031825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (N->getValueType(0) == MVT::f32) 1032919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F4; 1033825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson else if (N->getValueType(0) == MVT::f64) 1034919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F8; 1035710ff32983ca919fa0da14e077450b6a7654274fChris Lattner else 1036710ff32983ca919fa0da14e077450b6a7654274fChris Lattner SelectCCOp = PPC::SELECT_CC_VRRC; 1037710ff32983ca919fa0da14e077450b6a7654274fChris Lattner 1038475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { CCReg, N->getOperand(2), N->getOperand(3), 10390b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(BROpc) }; 10400b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, SelectCCOp, N->getValueType(0), Ops, 4); 104113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 104218258c640466274c26e89016e361ec411ff78520Chris Lattner case PPCISD::COND_BRANCH: { 1043cbb7ab259d08ac5aa5a4764b48628c4bcb5110c7Dan Gohman // Op #0 is the Chain. 104418258c640466274c26e89016e361ec411ff78520Chris Lattner // Op #1 is the PPC::PRED_* number. 104518258c640466274c26e89016e361ec411ff78520Chris Lattner // Op #2 is the CR# 104618258c640466274c26e89016e361ec411ff78520Chris Lattner // Op #3 is the Dest MBB 10478be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman // Op #4 is the Flag. 10482bda17c92229e7116adf2edd3eea98c0a12f43cbEvan Cheng // Prevent PPC::PRED_* from being selected into LI. 1049475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Pred = 1050f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman getI32Imm(cast<ConstantSDNode>(N->getOperand(1))->getZExtValue()); 1051475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Pred, N->getOperand(2), N->getOperand(3), 105218258c640466274c26e89016e361ec411ff78520Chris Lattner N->getOperand(0), N->getOperand(4) }; 1053825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::BCC, MVT::Other, Ops, 5); 105418258c640466274c26e89016e361ec411ff78520Chris Lattner } 105581e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman case ISD::BR_CC: { 10562fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(1))->get(); 1057f5f5dce897269885754fc79adeb809194da52942Dale Johannesen SDValue CondCode = SelectCC(N->getOperand(2), N->getOperand(3), CC, dl); 10586e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick SDValue Ops[] = { getI32Imm(getPredicateForSetCC(CC)), CondCode, 10590b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng N->getOperand(4), N->getOperand(0) }; 1060825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return CurDAG->SelectNodeTo(N, PPC::BCC, MVT::Other, Ops, 4); 10612fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 106237efe6764568a3829fee26aba532283131d1a104Nate Begeman case ISD::BRIND: { 1063cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // FIXME: Should custom lower this. 1064475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = N->getOperand(0); 1065475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Target = N->getOperand(1); 1066825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson unsigned Opc = Target.getValueType() == MVT::i32 ? PPC::MTCTR : PPC::MTCTR8; 10670c9b559bfd0b476c2dde787285a1195f3142c423Roman Divacky unsigned Reg = Target.getValueType() == MVT::i32 ? PPC::BCTR : PPC::BCTR8; 106867724526447efae608ef3c8cf333cd797efa8737Hal Finkel Chain = SDValue(CurDAG->getMachineNode(Opc, dl, MVT::Glue, Target, 1069602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman Chain), 0); 10700c9b559bfd0b476c2dde787285a1195f3142c423Roman Divacky return CurDAG->SelectNodeTo(N, Reg, MVT::Other, Chain); 107137efe6764568a3829fee26aba532283131d1a104Nate Begeman } 1072a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 10736e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick 1074eeb3a00b84b7767d236ec8cf0619b9217fc247b9Dan Gohman return SelectCode(N); 1075a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1076a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1077a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1078cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 10796e8f4c404825b79f9b9176483653f1aa927dfbdeAndrew Trick/// createPPCISelDag - This pass converts a legalized DAG into a 1080a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// PowerPC-specific DAG, ready for instruction scheduling. 1081a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// 1082c4c6257c1a154279bf10e9498d46d6c1793dbaa7Evan ChengFunctionPass *llvm::createPPCISelDag(PPCTargetMachine &TM) { 10831d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman return new PPCDAGToDAGISel(TM); 1084a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1085a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1086