PPCISelDAGToDAG.cpp revision 17e82d2858f0c003b7fcfaf7c025ca3d0aaa7a88
121e463b2bf864671a87ebe386cb100ef9349a540Nate Begeman//===-- PPCISelDAGToDAG.cpp - PPC --pattern matching inst selector --------===// 2a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 3a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// The LLVM Compiler Infrastructure 4a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 5a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// This file was developed by Chris Lattner and is distributed under 6a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// the University of Illinois Open Source 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 152668959b8879097db368aec7d76c455260abc75bChris Lattner#include "PPC.h" 1616e71f2f70811c69c56052dd146324fe20e31db5Chris Lattner#include "PPCTargetMachine.h" 1716e71f2f70811c69c56052dd146324fe20e31db5Chris Lattner#include "PPCISelLowering.h" 184416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 194416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 204416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/CodeGen/SSARegMap.h" 21a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/CodeGen/SelectionDAG.h" 22a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/CodeGen/SelectionDAGISel.h" 23a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Target/TargetOptions.h" 24a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/ADT/Statistic.h" 252fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner#include "llvm/Constants.h" 264416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/GlobalValue.h" 27a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Support/Debug.h" 28a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Support/MathExtras.h" 29a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerusing namespace llvm; 30a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 31a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnernamespace { 32a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Statistic<> FrameOff("ppc-codegen", "Number of frame idx offsets collapsed"); 33a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 34a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner //===--------------------------------------------------------------------===// 351d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman /// PPCDAGToDAGISel - PPC specific code to select PPC machine 36a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// instructions for SelectionDAG operations. 37a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// 381d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman class PPCDAGToDAGISel : public SelectionDAGISel { 3921e463b2bf864671a87ebe386cb100ef9349a540Nate Begeman PPCTargetLowering PPCLowering; 404416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner unsigned GlobalBaseReg; 41a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner public: 421d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman PPCDAGToDAGISel(TargetMachine &TM) 4321e463b2bf864671a87ebe386cb100ef9349a540Nate Begeman : SelectionDAGISel(PPCLowering), PPCLowering(TM) {} 44a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 454416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner virtual bool runOnFunction(Function &Fn) { 464416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Make sure we re-emit a set of the global base reg if necessary 474416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalBaseReg = 0; 484416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner return SelectionDAGISel::runOnFunction(Fn); 494416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 504416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 51a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// getI32Imm - Return a target constant with the specified value, of type 52a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// i32. 53a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner inline SDOperand getI32Imm(unsigned Imm) { 54a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return CurDAG->getTargetConstant(Imm, MVT::i32); 55a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 564416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 574416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// getGlobalBaseReg - insert code into the entry mbb to materialize the PIC 584416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// base register. Return the virtual register that holds this value. 599944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner SDOperand getGlobalBaseReg(); 60a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 61a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Select - Convert the specified operand from a target-independent to a 62a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // target-specific node if it hasn't already been changed. 63a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Select(SDOperand Op); 64a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 6502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDNode *SelectBitfieldInsert(SDNode *N); 6602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 672fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// SelectCC - Select a comparison of the specified values with the 682fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// specified condition code, returning the CR# of the expression. 692fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand SelectCC(SDOperand LHS, SDOperand RHS, ISD::CondCode CC); 702fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 717fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrImm - Returns true if the address N can be represented by 727fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// a base register plus a signed 16-bit displacement [r+imm]. 737fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman bool SelectAddrImm(SDOperand N, SDOperand &Disp, SDOperand &Base); 747fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman 757fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrIdx - Given the specified addressed, check to see if it can be 767fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// represented as an indexed [r+r] operation. Returns false if it can 777fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// be represented by [r+imm], which are preferred. 787fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman bool SelectAddrIdx(SDOperand N, SDOperand &Base, SDOperand &Index); 79f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman 807fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrIdxOnly - Given the specified addressed, force it to be 817fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// represented as an indexed [r+r] operation. 827fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman bool SelectAddrIdxOnly(SDOperand N, SDOperand &Base, SDOperand &Index); 839944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 84047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand BuildSDIVSequence(SDNode *N); 85047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand BuildUDIVSequence(SDNode *N); 86047b952e298352fe6feffedf02e359601133f465Chris Lattner 87a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// InstructionSelectBasicBlock - This callback is invoked by 88a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 89bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner virtual void InstructionSelectBasicBlock(SelectionDAG &DAG); 90bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 91a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner virtual const char *getPassName() const { 92a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return "PowerPC DAG->DAG Pattern Instruction Selection"; 93a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 94af165385112037cb942e94ea562a67990b7d6220Chris Lattner 95af165385112037cb942e94ea562a67990b7d6220Chris Lattner// Include the pieces autogenerated from the target description. 964c7b43b43fdf943c7298718e15ab5d6dfe345be7Chris Lattner#include "PPCGenDAGISel.inc" 97bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 98bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattnerprivate: 99222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand SelectDYNAMIC_STACKALLOC(SDOperand Op); 100222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand SelectADD_PARTS(SDOperand Op); 101222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand SelectSUB_PARTS(SDOperand Op); 102222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand SelectSETCC(SDOperand Op); 1036a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand SelectCALL(SDOperand Op); 104a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner }; 105a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 106a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 107bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner/// InstructionSelectBasicBlock - This callback is invoked by 108bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner/// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 1091d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begemanvoid PPCDAGToDAGISel::InstructionSelectBasicBlock(SelectionDAG &DAG) { 110bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DEBUG(BB->dump()); 111bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 112bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // The selection process is inherently a bottom-up recursive process (users 113bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // select their uses before themselves). Given infinite stack space, we 114bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // could just start selecting on the root and traverse the whole graph. In 115bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // practice however, this causes us to run out of stack space on large basic 116bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // blocks. To avoid this problem, select the entry node, then all its uses, 117bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // iteratively instead of recursively. 118bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner std::vector<SDOperand> Worklist; 119bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Worklist.push_back(DAG.getEntryNode()); 120bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 121bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Note that we can do this in the PPC target (scanning forward across token 122bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // chain edges) because no nodes ever get folded across these edges. On a 123bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // target like X86 which supports load/modify/store operations, this would 124bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // have to be more careful. 125bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner while (!Worklist.empty()) { 126bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDOperand Node = Worklist.back(); 127bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Worklist.pop_back(); 128bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 129cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner // Chose from the least deep of the top two nodes. 130cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner if (!Worklist.empty() && 131cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner Worklist.back().Val->getNodeDepth() < Node.Val->getNodeDepth()) 132cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner std::swap(Worklist.back(), Node); 133cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner 134bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner if ((Node.Val->getOpcode() >= ISD::BUILTIN_OP_END && 135bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Node.Val->getOpcode() < PPCISD::FIRST_NUMBER) || 136bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner CodeGenMap.count(Node)) continue; 137bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 138bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner for (SDNode::use_iterator UI = Node.Val->use_begin(), 139bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner E = Node.Val->use_end(); UI != E; ++UI) { 140bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Scan the values. If this use has a value that is a token chain, add it 141bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // to the worklist. 142bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDNode *User = *UI; 143bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner for (unsigned i = 0, e = User->getNumValues(); i != e; ++i) 144bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner if (User->getValueType(i) == MVT::Other) { 145bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Worklist.push_back(SDOperand(User, i)); 146bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner break; 147bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner } 148bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner } 149bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 150bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Finally, legalize this node. 151bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Select(Node); 152bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner } 153cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner 154bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Select target instructions for the DAG. 155bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DAG.setRoot(Select(DAG.getRoot())); 156bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner CodeGenMap.clear(); 157bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DAG.RemoveDeadNodes(); 158bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 159bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Emit machine code to BB. 160bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner ScheduleAndEmitDAG(DAG); 161bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner} 1626cd40d5888f905a3820d5d6c71e57cc0e02abb4aChris Lattner 1634416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// getGlobalBaseReg - Output the instructions required to put the 1644416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// base address to use for accessing globals into a register. 1654416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// 1661d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::getGlobalBaseReg() { 1674416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (!GlobalBaseReg) { 1684416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Insert the set of GlobalBaseReg into the first MBB of the function 1694416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock &FirstMBB = BB->getParent()->front(); 1704416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock::iterator MBBI = FirstMBB.begin(); 1714416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SSARegMap *RegMap = BB->getParent()->getSSARegMap(); 1721d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman // FIXME: when we get to LP64, we will need to create the appropriate 1731d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman // type of register here. 1741d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman GlobalBaseReg = RegMap->createVirtualRegister(PPC::GPRCRegisterClass); 1754416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MovePCtoLR, 0, PPC::LR); 1764416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MFLR, 1, GlobalBaseReg); 1774416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 1789944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return CurDAG->getRegister(GlobalBaseReg, MVT::i32); 1794416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner} 1804416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 1814416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 1820f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isIntImmediate - This method tests to see if a constant operand. 1830f3257a3302b60c128a667db6736e81335316c1eNate Begeman// If so Imm will receive the 32 bit value. 1840f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isIntImmediate(SDNode *N, unsigned& Imm) { 1850f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (N->getOpcode() == ISD::Constant) { 1860f3257a3302b60c128a667db6736e81335316c1eNate Begeman Imm = cast<ConstantSDNode>(N)->getValue(); 1870f3257a3302b60c128a667db6736e81335316c1eNate Begeman return true; 1880f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 1890f3257a3302b60c128a667db6736e81335316c1eNate Begeman return false; 1900f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 1910f3257a3302b60c128a667db6736e81335316c1eNate Begeman 192cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s with 193cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// any number of 0s on either side. The 1s are allowed to wrap from LSB to 194cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 0x0F0F0000 is 195cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// not, since all 1s are not contiguous. 196cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME) { 197cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isShiftedMask_32(Val)) { 198cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first non-zero bit 199cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman MB = CountLeadingZeros_32(Val); 200cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first zero bit after the run of ones 201cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman ME = CountLeadingZeros_32((Val - 1) ^ Val); 202cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return true; 2032fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } else { 2042fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner Val = ~Val; // invert mask 2052fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner if (isShiftedMask_32(Val)) { 2062fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first zero bit 2072fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner ME = CountLeadingZeros_32(Val) - 1; 2082fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first one bit after the run of zeros 2092fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner MB = CountLeadingZeros_32((Val - 1) ^ Val) + 1; 2102fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner return true; 2112fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } 212cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 213cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // no run present 214cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 215cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 216cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 21765a419a1045972729f91f82a378b7f4b7f6a2be5Chris Lattner// isRotateAndMask - Returns true if Mask and Shift can be folded into a rotate 218cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// and mask opcode and mask operation. 219cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRotateAndMask(SDNode *N, unsigned Mask, bool IsShiftMask, 220cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned &SH, unsigned &MB, unsigned &ME) { 221da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // Don't even go down this path for i64, since different logic will be 222da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // necessary for rldicl/rldicr/rldimi. 223da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman if (N->getValueType(0) != MVT::i32) 224da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman return false; 225da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman 226cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Shift = 32; 227cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Indeterminant = ~0; // bit mask marking indeterminant results 228cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Opcode = N->getOpcode(); 22915055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner if (N->getNumOperands() != 2 || 23015055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner !isIntImmediate(N->getOperand(1).Val, Shift) || (Shift > 31)) 231cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 232cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 233cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Opcode == ISD::SHL) { 234cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift left to mask if it comes first 235cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask << Shift; 236cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 237cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu << Shift); 238651dea74f6a362d30bc61fd0b549da7707af5bf8Chris Lattner } else if (Opcode == ISD::SRL) { 239cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift right to mask if it comes first 240cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask >> Shift; 241cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 242cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu >> Shift); 243cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // adjust for the left rotate 244cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Shift = 32 - Shift; 245cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 246cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 247cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 248cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 249cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // if the mask doesn't intersect any Indeterminant bits 250cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Mask && !(Mask & Indeterminant)) { 251cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = Shift; 252cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // make sure the mask is still a mask (wrap arounds may not be) 253cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return isRunOfOnes(Mask, MB, ME); 254cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 255cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 256cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 257cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 2580f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isOpcWithIntImmediate - This method tests to see if the node is a specific 2590f3257a3302b60c128a667db6736e81335316c1eNate Begeman// opcode and that it has a immediate integer right operand. 2600f3257a3302b60c128a667db6736e81335316c1eNate Begeman// If so Imm will receive the 32 bit value. 2610f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isOpcWithIntImmediate(SDNode *N, unsigned Opc, unsigned& Imm) { 2620f3257a3302b60c128a667db6736e81335316c1eNate Begeman return N->getOpcode() == Opc && isIntImmediate(N->getOperand(1).Val, Imm); 2630f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 2640f3257a3302b60c128a667db6736e81335316c1eNate Begeman 265a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// isIntImmediate - This method tests to see if a constant operand. 266a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// If so Imm will receive the 32 bit value. 267a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic bool isIntImmediate(SDOperand N, unsigned& Imm) { 268a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 269a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Imm = (unsigned)CN->getSignExtended(); 270a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return true; 271a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 272a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return false; 273a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 274a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 27502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// SelectBitfieldInsert - turn an or of two masked values into 27602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// the rotate left word immediate then mask insert (rlwimi) instruction. 27702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// Returns true on success, false if the caller still needs to select OR. 27802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 27902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// Patterns matched: 28002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 1. or shl, and 5. or and, and 28102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 2. or and, shl 6. or shl, shr 28202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 3. or shr, and 7. or shr, shl 28302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 4. or and, shr 2841d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDNode *PPCDAGToDAGISel::SelectBitfieldInsert(SDNode *N) { 28502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool IsRotate = false; 28602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned TgtMask = 0xFFFFFFFF, InsMask = 0xFFFFFFFF, SH = 0; 28702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Value; 28802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 28902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op0 = N->getOperand(0); 29002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op1 = N->getOperand(1); 29102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 29202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Op0Opc = Op0.getOpcode(); 29302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Op1Opc = Op1.getOpcode(); 29402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 29502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Verify that we have the correct opcodes 29602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (ISD::SHL != Op0Opc && ISD::SRL != Op0Opc && ISD::AND != Op0Opc) 29702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return false; 29802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (ISD::SHL != Op1Opc && ISD::SRL != Op1Opc && ISD::AND != Op1Opc) 29902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return false; 30002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 30102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Generate Mask value for Target 30202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op0.getOperand(1), Value)) { 30302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman switch(Op0Opc) { 3041368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SHL: TgtMask <<= Value; break; 3051368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SRL: TgtMask >>= Value; break; 3061368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::AND: TgtMask &= Value; break; 30702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 30802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } else { 30902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 31002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 31102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 31202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Generate Mask value for Insert 3131368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner if (!isIntImmediate(Op1.getOperand(1), Value)) 31402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 3151368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner 3161368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner switch(Op1Opc) { 3171368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SHL: 3181368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner SH = Value; 3191368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner InsMask <<= SH; 3201368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner if (Op0Opc == ISD::SRL) IsRotate = true; 3211368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner break; 3221368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SRL: 3231368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner SH = Value; 3241368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner InsMask >>= SH; 3251368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner SH = 32-SH; 3261368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner if (Op0Opc == ISD::SHL) IsRotate = true; 3271368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner break; 3281368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::AND: 3291368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner InsMask &= Value; 3301368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner break; 33102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 33202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 33302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // If both of the inputs are ANDs and one of them has a logical shift by 33402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // constant as its input, make that AND the inserted value so that we can 33502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // combine the shift into the rotate part of the rlwimi instruction 33602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool IsAndWithShiftOp = false; 33702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op0Opc == ISD::AND && Op1Opc == ISD::AND) { 33802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op1.getOperand(0).getOpcode() == ISD::SHL || 33902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op1.getOperand(0).getOpcode() == ISD::SRL) { 34002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op1.getOperand(0).getOperand(1), Value)) { 34102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Op1.getOperand(0).getOpcode() == ISD::SHL ? Value : 32 - Value; 34202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman IsAndWithShiftOp = true; 34302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 34402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } else if (Op0.getOperand(0).getOpcode() == ISD::SHL || 34502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0.getOperand(0).getOpcode() == ISD::SRL) { 34602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op0.getOperand(0).getOperand(1), Value)) { 34702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman std::swap(Op0, Op1); 34802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman std::swap(TgtMask, InsMask); 34902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Op1.getOperand(0).getOpcode() == ISD::SHL ? Value : 32 - Value; 35002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman IsAndWithShiftOp = true; 35102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 35202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 35302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 35402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 35502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Verify that the Target mask and Insert mask together form a full word mask 35602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // and that the Insert mask is a run of set bits (which implies both are runs 35702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // of set bits). Given that, Select the arguments and generate the rlwimi 35802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // instruction. 35902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned MB, ME; 36002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (((TgtMask & InsMask) == 0) && isRunOfOnes(InsMask, MB, ME)) { 36102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool fullMask = (TgtMask ^ InsMask) == 0xFFFFFFFF; 36202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool Op0IsAND = Op0Opc == ISD::AND; 36302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Check for rotlwi / rotrwi here, a special case of bitfield insert 36402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // where both bitfield halves are sourced from the same value. 36502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (IsRotate && fullMask && 36602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman N->getOperand(0).getOperand(0) == N->getOperand(1).getOperand(0)) { 36702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0 = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, 36802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Select(N->getOperand(0).getOperand(0)), 36902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman getI32Imm(SH), getI32Imm(0), getI32Imm(31)); 37002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return Op0.Val; 37102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 37202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Tmp1 = (Op0IsAND && fullMask) ? Select(Op0.getOperand(0)) 37302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman : Select(Op0); 37402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Tmp2 = IsAndWithShiftOp ? Select(Op1.getOperand(0).getOperand(0)) 37502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman : Select(Op1.getOperand(0)); 37602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0 = CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, Tmp1, Tmp2, 37702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 37802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return Op0.Val; 37902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 38002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 38102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman} 38202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 3837fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrImm - Returns true if the address N can be represented by 3847fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// a base register plus a signed 16-bit displacement [r+imm]. 3857fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrImm(SDOperand N, SDOperand &Disp, 3867fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Base) { 3877fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (N.getOpcode() == ISD::ADD) { 3887fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman unsigned imm = 0; 3897fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm)) { 39017e82d2858f0c003b7fcfaf7c025ca3d0aaa7a88Chris Lattner Disp = getI32Imm(imm & 0xFFFF); 3917fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0))) { 3927fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Base = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 3939944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 3947fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Base = Select(N.getOperand(0)); 3959944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 3967fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [r+i] 3977fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman } else if (N.getOperand(1).getOpcode() == PPCISD::Lo) { 3984f0f86de5f183b09d07b17d1f940bd3e298abfcdChris Lattner // Match LOAD (ADD (X, Lo(G))). 3997fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman assert(!cast<ConstantSDNode>(N.getOperand(1).getOperand(1))->getValue() 4004f0f86de5f183b09d07b17d1f940bd3e298abfcdChris Lattner && "Cannot handle constant offsets yet!"); 4017fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Disp = N.getOperand(1).getOperand(0); // The global address. 4027fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman assert(Disp.getOpcode() == ISD::TargetGlobalAddress || 4037fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Disp.getOpcode() == ISD::TargetConstantPool); 4047fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Base = Select(N.getOperand(0)); 4057fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [&g+r] 4069944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4077fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return false; // [r+r] 4089944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4097fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Disp = getI32Imm(0); 4107fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N)) 4117fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Base = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 41228a6b02626c29b1fe9bb16c14c193549fab4cab8Nate Begeman else 4137fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Base = Select(N); 4147fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [r+0] 4159944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner} 416a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 4177fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrIdx - Given the specified addressed, check to see if it can be 4187fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// represented as an indexed [r+r] operation. Returns false if it can 4197fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// be represented by [r+imm], which are preferred. 4207fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrIdx(SDOperand N, SDOperand &Base, 4217fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Index) { 4227fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman // Check to see if we can represent this as an [r+imm] address instead, 4237fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman // which will fail if the address is more profitably represented as an 4247fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman // [r+r] address. 4257fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (SelectAddrImm(N, Base, Index)) 4267fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return false; 427f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman 4287fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (N.getOpcode() == ISD::ADD) { 4297fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Base = Select(N.getOperand(0)); 4307fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Index = Select(N.getOperand(1)); 4317fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; 4327fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman } 4337fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman 43488276b887c426cf5d998b705a14663bfa38f8efdNate Begeman Base = CurDAG->getRegister(PPC::R0, MVT::i32); 4357fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Index = Select(N); 4367fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; 4377fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman} 4387fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman 4397fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrIdxOnly - Given the specified addressed, force it to be 4407fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// represented as an indexed [r+r] operation. 4417fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrIdxOnly(SDOperand N, SDOperand &Base, 4427fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Index) { 4437fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (N.getOpcode() == ISD::ADD) { 4447fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Base = Select(N.getOperand(0)); 4457fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Index = Select(N.getOperand(1)); 4467fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; 447f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman } 4487fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman 44988276b887c426cf5d998b705a14663bfa38f8efdNate Begeman Base = CurDAG->getRegister(PPC::R0, MVT::i32); 4507fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Index = Select(N); 4517fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; 452f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman} 453f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman 4542fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// SelectCC - Select a comparison of the specified values with the specified 4552fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// condition code, returning the CR# of the expression. 4561d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectCC(SDOperand LHS, SDOperand RHS, 4571d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman ISD::CondCode CC) { 4582fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Always select the LHS. 4592fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner LHS = Select(LHS); 4602fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 4612fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Use U to determine whether the SETCC immediate range is signed or not. 4622fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (MVT::isInteger(LHS.getValueType())) { 4632fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner bool U = ISD::isUnsignedIntSetCC(CC); 4642fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner unsigned Imm; 4652fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (isIntImmediate(RHS, Imm) && 4662fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ((U && isUInt16(Imm)) || (!U && isInt16(Imm)))) 4672fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return CurDAG->getTargetNode(U ? PPC::CMPLWI : PPC::CMPWI, MVT::i32, 46817e82d2858f0c003b7fcfaf7c025ca3d0aaa7a88Chris Lattner LHS, getI32Imm(Imm & 0xFFFF)); 4692fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return CurDAG->getTargetNode(U ? PPC::CMPLW : PPC::CMPW, MVT::i32, 4702fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner LHS, Select(RHS)); 471919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner } else if (LHS.getValueType() == MVT::f32) { 472919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner return CurDAG->getTargetNode(PPC::FCMPUS, MVT::i32, LHS, Select(RHS)); 4732fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 474919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner return CurDAG->getTargetNode(PPC::FCMPUD, MVT::i32, LHS, Select(RHS)); 4752fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 4762fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 4772fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 4782fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// getBCCForSetCC - Returns the PowerPC condition branch mnemonic corresponding 4792fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// to Condition. 4802fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattnerstatic unsigned getBCCForSetCC(ISD::CondCode CC) { 4812fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner switch (CC) { 4822fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 483ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOEQ: // FIXME: This is incorrect see PR642. 4842fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETEQ: return PPC::BEQ; 485ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETONE: // FIXME: This is incorrect see PR642. 4862fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETNE: return PPC::BNE; 487ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLT: // FIXME: This is incorrect see PR642. 4882fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULT: 4892fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLT: return PPC::BLT; 490ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLE: // FIXME: This is incorrect see PR642. 4912fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULE: 4922fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLE: return PPC::BLE; 493ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGT: // FIXME: This is incorrect see PR642. 4942fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGT: 4952fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGT: return PPC::BGT; 496ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGE: // FIXME: This is incorrect see PR642. 4972fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGE: 4982fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGE: return PPC::BGE; 4996df2507121507c24d7155605c343e467e0106c07Chris Lattner 5006df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETO: return PPC::BUN; 5016df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETUO: return PPC::BNU; 5022fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 5032fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return 0; 5042fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 5052fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 50664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// getCRIdxForSetCC - Return the index of the condition register field 50764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// associated with the SetCC condition, and whether or not the field is 50864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// treated as inverted. That is, lt = 0; ge = 0 inverted. 50964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattnerstatic unsigned getCRIdxForSetCC(ISD::CondCode CC, bool& Inv) { 51064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 51164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 512ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLT: // FIXME: This is incorrect see PR642. 51364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULT: 51464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLT: Inv = false; return 0; 515ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGE: // FIXME: This is incorrect see PR642. 51664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGE: 51764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGE: Inv = true; return 0; 518ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGT: // FIXME: This is incorrect see PR642. 51964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGT: 52064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGT: Inv = false; return 1; 521ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLE: // FIXME: This is incorrect see PR642. 52264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULE: 52364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLE: Inv = true; return 1; 524ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOEQ: // FIXME: This is incorrect see PR642. 52564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETEQ: Inv = false; return 2; 526ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETONE: // FIXME: This is incorrect see PR642. 52764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETNE: Inv = true; return 2; 5286df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETO: Inv = true; return 3; 5296df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETUO: Inv = false; return 3; 53064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 53164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner return 0; 53264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner} 5339944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 5341d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectDYNAMIC_STACKALLOC(SDOperand Op) { 535bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDNode *N = Op.Val; 536bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 537bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // FIXME: We are currently ignoring the requested alignment for handling 538bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // greater than the stack alignment. This will need to be revisited at some 539bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // point. Align = N.getOperand(2); 540bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner if (!isa<ConstantSDNode>(N->getOperand(2)) || 541bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner cast<ConstantSDNode>(N->getOperand(2))->getValue() != 0) { 542bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner std::cerr << "Cannot allocate stack object with greater alignment than" 543bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner << " the stack alignment yet!"; 544bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner abort(); 545bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner } 546bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDOperand Chain = Select(N->getOperand(0)); 547bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDOperand Amt = Select(N->getOperand(1)); 548bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 549bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDOperand R1Reg = CurDAG->getRegister(PPC::R1, MVT::i32); 550bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 551bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDOperand R1Val = CurDAG->getCopyFromReg(Chain, PPC::R1, MVT::i32); 552bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Chain = R1Val.getValue(1); 553bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 554bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Subtract the amount (guaranteed to be a multiple of the stack alignment) 555bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // from the stack pointer, giving us the result pointer. 556bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDOperand Result = CurDAG->getTargetNode(PPC::SUBF, MVT::i32, Amt, R1Val); 557bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 558bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Copy this result back into R1. 559bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Chain = CurDAG->getNode(ISD::CopyToReg, MVT::Other, Chain, R1Reg, Result); 560bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 561bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Copy this result back out of R1 to make sure we're not using the stack 562bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // space without decrementing the stack pointer. 563bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Result = CurDAG->getCopyFromReg(Chain, PPC::R1, MVT::i32); 564bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 565bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Finally, replace the DYNAMIC_STACKALLOC with the copyfromreg. 566bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner CodeGenMap[Op.getValue(0)] = Result; 567bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner CodeGenMap[Op.getValue(1)] = Result.getValue(1); 568bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner return SDOperand(Result.Val, Op.ResNo); 569bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner} 570bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 5711d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectADD_PARTS(SDOperand Op) { 5722b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDNode *N = Op.Val; 5732b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand LHSL = Select(N->getOperand(0)); 5742b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand LHSH = Select(N->getOperand(1)); 5752b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 5762b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner unsigned Imm; 5772b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner bool ME = false, ZE = false; 5782b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner if (isIntImmediate(N->getOperand(3), Imm)) { 5792b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner ME = (signed)Imm == -1; 5802b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner ZE = Imm == 0; 5812b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner } 5822b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 5832b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner std::vector<SDOperand> Result; 5842b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand CarryFromLo; 5852b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner if (isIntImmediate(N->getOperand(2), Imm) && 5862b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner ((signed)Imm >= -32768 || (signed)Imm < 32768)) { 5872b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner // Codegen the low 32 bits of the add. Interestingly, there is no 5882b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner // shifted form of add immediate carrying. 5892b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner CarryFromLo = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 5902b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner LHSL, getI32Imm(Imm)); 5912b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner } else { 5922b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner CarryFromLo = CurDAG->getTargetNode(PPC::ADDC, MVT::i32, MVT::Flag, 5932b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner LHSL, Select(N->getOperand(2))); 5942b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner } 5952b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner CarryFromLo = CarryFromLo.getValue(1); 5962b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 5972b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner // Codegen the high 32 bits, adding zero, minus one, or the full value 5982b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner // along with the carry flag produced by addc/addic. 5992b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand ResultHi; 6002b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner if (ZE) 6012b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner ResultHi = CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, LHSH, CarryFromLo); 6022b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner else if (ME) 6032b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner ResultHi = CurDAG->getTargetNode(PPC::ADDME, MVT::i32, LHSH, CarryFromLo); 6042b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner else 6052b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner ResultHi = CurDAG->getTargetNode(PPC::ADDE, MVT::i32, LHSH, 6062b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner Select(N->getOperand(3)), CarryFromLo); 6072b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner Result.push_back(CarryFromLo.getValue(0)); 6082b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner Result.push_back(ResultHi); 6092b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 6102b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner CodeGenMap[Op.getValue(0)] = Result[0]; 6112b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner CodeGenMap[Op.getValue(1)] = Result[1]; 6122b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner return Result[Op.ResNo]; 6132b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner} 6141d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectSUB_PARTS(SDOperand Op) { 6152b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDNode *N = Op.Val; 6162b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand LHSL = Select(N->getOperand(0)); 6172b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand LHSH = Select(N->getOperand(1)); 6182b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand RHSL = Select(N->getOperand(2)); 6192b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand RHSH = Select(N->getOperand(3)); 6202b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 6212b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner std::vector<SDOperand> Result; 6222b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner Result.push_back(CurDAG->getTargetNode(PPC::SUBFC, MVT::i32, MVT::Flag, 6232b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner RHSL, LHSL)); 6242b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner Result.push_back(CurDAG->getTargetNode(PPC::SUBFE, MVT::i32, RHSH, LHSH, 6252b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner Result[0].getValue(1))); 6262b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner CodeGenMap[Op.getValue(0)] = Result[0]; 6272b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner CodeGenMap[Op.getValue(1)] = Result[1]; 6282b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner return Result[Op.ResNo]; 6292b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner} 6302b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 6311d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectSETCC(SDOperand Op) { 632222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDNode *N = Op.Val; 633222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Imm; 634222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get(); 635222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (isIntImmediate(N->getOperand(1), Imm)) { 636222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // We can codegen setcc op, imm very efficiently compared to a brcond. 637222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Check for those cases here. 638222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // setcc op, 0 639222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (Imm == 0) { 640222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand Op = Select(N->getOperand(0)); 641222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 642dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 643dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETEQ: 644dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner Op = CurDAG->getTargetNode(PPC::CNTLZW, MVT::i32, Op); 64571d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Op, getI32Imm(27), 64671d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(5), getI32Imm(31)); 647dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 648dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner SDOperand AD = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 649dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner Op, getI32Imm(~0U)); 65071d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, 65171d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner AD.getValue(1)); 652dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 653dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETLT: 65471d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Op, getI32Imm(1), 65571d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 656dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETGT: { 657dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner SDOperand T = CurDAG->getTargetNode(PPC::NEG, MVT::i32, Op); 658dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner T = CurDAG->getTargetNode(PPC::ANDC, MVT::i32, T, Op);; 65971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, T, getI32Imm(1), 66071d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 661dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 662222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 663222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else if (Imm == ~0U) { // setcc op, -1 664222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand Op = Select(N->getOperand(0)); 665222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 666dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 667dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETEQ: 668dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner Op = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 669dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner Op, getI32Imm(1)); 67071d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 67171d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner CurDAG->getTargetNode(PPC::LI, MVT::i32, 67271d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(0)), 67371d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner Op.getValue(1)); 674dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 675dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner Op = CurDAG->getTargetNode(PPC::NOR, MVT::i32, Op, Op); 676dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner SDOperand AD = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 677dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner Op, getI32Imm(~0U)); 67871d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, 67971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner AD.getValue(1)); 680dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 681dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETLT: { 682dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner SDOperand AD = CurDAG->getTargetNode(PPC::ADDI, MVT::i32, Op, 683dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner getI32Imm(1)); 684dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner SDOperand AN = CurDAG->getTargetNode(PPC::AND, MVT::i32, AD, Op); 68571d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, AN, getI32Imm(1), 68671d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 687dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 688dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETGT: 689dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner Op = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Op, getI32Imm(1), 690dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner getI32Imm(31), getI32Imm(31)); 69171d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Op, getI32Imm(1)); 692222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 693222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 694222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 695222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 696222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner bool Inv; 697222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Idx = getCRIdxForSetCC(CC, Inv); 698222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 699222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand IntCR; 700222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 701222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Force the ccreg into CR7. 702222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand CR7Reg = CurDAG->getRegister(PPC::CR7, MVT::i32); 703222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 70485961d5ec126bbc0c111d52dd7361d5159265ca5Chris Lattner SDOperand InFlag(0, 0); // Null incoming flag value. 705db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner CCReg = CurDAG->getCopyToReg(CurDAG->getEntryNode(), CR7Reg, CCReg, 706db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner InFlag).getValue(1); 707222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 708222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (TLI.getTargetMachine().getSubtarget<PPCSubtarget>().isGigaProcessor()) 709222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner IntCR = CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, CR7Reg, CCReg); 710222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner else 711222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner IntCR = CurDAG->getTargetNode(PPC::MFCR, MVT::i32, CCReg); 712222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 713222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (!Inv) { 71471d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, IntCR, 71571d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm((32-(3-Idx)) & 31), 71671d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 717222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else { 718222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand Tmp = 719222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, IntCR, 7207d7b96746c1264bd617783860a4a5ab289208fb0Chris Lattner getI32Imm((32-(3-Idx)) & 31), 7217d7b96746c1264bd617783860a4a5ab289208fb0Chris Lattner getI32Imm(31),getI32Imm(31)); 72271d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Tmp, getI32Imm(1)); 723222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 724222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner} 7252b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 726422b0cee7a32636303398d8788f98a59bf15381cNate Begeman/// isCallCompatibleAddress - Return true if the specified 32-bit value is 727422b0cee7a32636303398d8788f98a59bf15381cNate Begeman/// representable in the immediate field of a Bx instruction. 728422b0cee7a32636303398d8788f98a59bf15381cNate Begemanstatic bool isCallCompatibleAddress(ConstantSDNode *C) { 729422b0cee7a32636303398d8788f98a59bf15381cNate Begeman int Addr = C->getValue(); 730422b0cee7a32636303398d8788f98a59bf15381cNate Begeman if (Addr & 3) return false; // Low 2 bits are implicitly zero. 731422b0cee7a32636303398d8788f98a59bf15381cNate Begeman return (Addr << 6 >> 6) == Addr; // Top 6 bits have to be sext of immediate. 732422b0cee7a32636303398d8788f98a59bf15381cNate Begeman} 733422b0cee7a32636303398d8788f98a59bf15381cNate Begeman 7341d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectCALL(SDOperand Op) { 7356a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDNode *N = Op.Val; 7366a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand Chain = Select(N->getOperand(0)); 7376a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7386a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner unsigned CallOpcode; 7396a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner std::vector<SDOperand> CallOperands; 7406a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7416a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (GlobalAddressSDNode *GASD = 7426a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner dyn_cast<GlobalAddressSDNode>(N->getOperand(1))) { 743422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOpcode = PPC::BL; 7442823b3e70ee7a5ed7482c45c503659a16a879a61Chris Lattner CallOperands.push_back(N->getOperand(1)); 7456a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else if (ExternalSymbolSDNode *ESSDN = 7466a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner dyn_cast<ExternalSymbolSDNode>(N->getOperand(1))) { 747422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOpcode = PPC::BL; 7486a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(N->getOperand(1)); 749422b0cee7a32636303398d8788f98a59bf15381cNate Begeman } else if (isa<ConstantSDNode>(N->getOperand(1)) && 750422b0cee7a32636303398d8788f98a59bf15381cNate Begeman isCallCompatibleAddress(cast<ConstantSDNode>(N->getOperand(1)))) { 751422b0cee7a32636303398d8788f98a59bf15381cNate Begeman ConstantSDNode *C = cast<ConstantSDNode>(N->getOperand(1)); 752422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOpcode = PPC::BLA; 753422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOperands.push_back(getI32Imm((int)C->getValue() >> 2)); 7546a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else { 7556a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // Copy the callee address into the CTR register. 7566a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand Callee = Select(N->getOperand(1)); 7576a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getTargetNode(PPC::MTCTR, MVT::Other, Callee, Chain); 7586a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7596a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // Copy the callee address into R12 on darwin. 7606a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand R12 = CurDAG->getRegister(PPC::R12, MVT::i32); 7616a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getNode(ISD::CopyToReg, MVT::Other, Chain, R12, Callee); 762422b0cee7a32636303398d8788f98a59bf15381cNate Begeman 7636a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(R12); 764422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOpcode = PPC::BCTRL; 7656a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 7666a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7676a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner unsigned GPR_idx = 0, FPR_idx = 0; 7686a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner static const unsigned GPR[] = { 7696a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::R3, PPC::R4, PPC::R5, PPC::R6, 7706a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::R7, PPC::R8, PPC::R9, PPC::R10, 7716a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner }; 7726a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner static const unsigned FPR[] = { 7736a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, 7746a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::F8, PPC::F9, PPC::F10, PPC::F11, PPC::F12, PPC::F13 7756a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner }; 7766a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7776a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand InFlag; // Null incoming flag value. 7786a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7796a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner for (unsigned i = 2, e = N->getNumOperands(); i != e; ++i) { 7806a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner unsigned DestReg = 0; 7816a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner MVT::ValueType RegTy = N->getOperand(i).getValueType(); 7826a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (RegTy == MVT::i32) { 7836a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner assert(GPR_idx < 8 && "Too many int args"); 7846a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner DestReg = GPR[GPR_idx++]; 7856a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else { 7866a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner assert(MVT::isFloatingPoint(N->getOperand(i).getValueType()) && 7876a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner "Unpromoted integer arg?"); 7886a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner assert(FPR_idx < 13 && "Too many fp args"); 7896a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner DestReg = FPR[FPR_idx++]; 7906a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 7916a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7926a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (N->getOperand(i).getOpcode() != ISD::UNDEF) { 7936a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand Val = Select(N->getOperand(i)); 7946a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyToReg(Chain, DestReg, Val, InFlag); 7956a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner InFlag = Chain.getValue(1); 7966a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(CurDAG->getRegister(DestReg, RegTy)); 7976a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 7986a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 7996a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 8006a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // Finally, once everything is in registers to pass to the call, emit the 8016a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // call itself. 8026a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (InFlag.Val) 8036a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(InFlag); // Strong dep on register copies. 8046a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner else 8056a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(Chain); // Weak dep on whatever occurs before 8066a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getTargetNode(CallOpcode, MVT::Other, MVT::Flag, 8076a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands); 8086a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 8096a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner std::vector<SDOperand> CallResults; 8106a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 8116a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // If the call has results, copy the values out of the ret val registers. 8126a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner switch (N->getValueType(0)) { 8136a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner default: assert(0 && "Unexpected ret value!"); 8146a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::Other: break; 8156a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::i32: 8166a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (N->getValueType(1) == MVT::i32) { 8176a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R4, MVT::i32, 8186a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(1)).getValue(1); 8196a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 8206a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R3, MVT::i32, 8216a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(2)).getValue(1); 8226a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 8236a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else { 8246a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R3, MVT::i32, 8256a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(1)).getValue(1); 8266a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 8276a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 8286a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner break; 8296a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::f32: 8306a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::f64: 8316a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::F1, N->getValueType(0), 8326a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(1)).getValue(1); 8336a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 8346a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner break; 8356a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 8366a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 8376a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain); 8386a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner for (unsigned i = 0, e = CallResults.size(); i != e; ++i) 8396a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CodeGenMap[Op.getValue(i)] = CallResults[i]; 8406a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner return CallResults[Op.ResNo]; 8416a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner} 8426a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 843a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Select - Convert the specified operand from a target-independent to a 844a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// target-specific node if it hasn't already been changed. 8451d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::Select(SDOperand Op) { 846a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDNode *N = Op.Val; 8470bbea954331b8f08afa5b094dfb0841829c70eaaChris Lattner if (N->getOpcode() >= ISD::BUILTIN_OP_END && 8480bbea954331b8f08afa5b094dfb0841829c70eaaChris Lattner N->getOpcode() < PPCISD::FIRST_NUMBER) 849a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return Op; // Already selected. 850d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 851d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner // If this has already been converted, use it. 852d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner std::map<SDOperand, SDOperand>::iterator CGMI = CodeGenMap.find(Op); 853d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner if (CGMI != CodeGenMap.end()) return CGMI->second; 854a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 855a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOpcode()) { 85619c0907ba1c11c81dc231cf7b4143fdaf03466e4Chris Lattner default: break; 857222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::DYNAMIC_STACKALLOC: return SelectDYNAMIC_STACKALLOC(Op); 858222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::ADD_PARTS: return SelectADD_PARTS(Op); 859222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::SUB_PARTS: return SelectSUB_PARTS(Op); 860222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::SETCC: return SelectSETCC(Op); 8616a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case ISD::CALL: return SelectCALL(Op); 8626a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case ISD::TAILCALL: return SelectCALL(Op); 863860e8862c1fbd3b261da4a64a8c0096f9f373681Chris Lattner case PPCISD::GlobalBaseReg: return getGlobalBaseReg(); 864860e8862c1fbd3b261da4a64a8c0096f9f373681Chris Lattner 865e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner case ISD::FrameIndex: { 866e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner int FI = cast<FrameIndexSDNode>(N)->getIndex(); 86771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner if (N->hasOneUse()) 86871d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::ADDI, MVT::i32, 86971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner CurDAG->getTargetFrameIndex(FI, MVT::i32), 87071d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(0)); 87105f56a529c0c9ac37b41c7472ceb7d2e95feff1eChris Lattner return CodeGenMap[Op] = 87205f56a529c0c9ac37b41c7472ceb7d2e95feff1eChris Lattner CurDAG->getTargetNode(PPC::ADDI, MVT::i32, 87305f56a529c0c9ac37b41c7472ceb7d2e95feff1eChris Lattner CurDAG->getTargetFrameIndex(FI, MVT::i32), 87405f56a529c0c9ac37b41c7472ceb7d2e95feff1eChris Lattner getI32Imm(0)); 875e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } 87688add100b3db715df4275c8ab408e6b51f28ff8fChris Lattner case ISD::SDIV: { 877405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: since this depends on the setting of the carry flag from the srawi 878405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // we should really be making notes about that for the scheduler. 879405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: It sure would be nice if we could cheaply recognize the 880405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // srl/add/sra pattern the dag combiner will generate for this as 881405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // sra/addze rather than having to handle sdiv ourselves. oh well. 8828784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner unsigned Imm; 8838784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if (isIntImmediate(N->getOperand(1), Imm)) { 8848784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if ((signed)Imm > 0 && isPowerOf2_32(Imm)) { 8858784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand Op = 8868784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 8878784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner Select(N->getOperand(0)), 8888784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner getI32Imm(Log2_32(Imm))); 88971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 89071d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner Op.getValue(0), Op.getValue(1)); 8918784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } else if ((signed)Imm < 0 && isPowerOf2_32(-Imm)) { 8928784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand Op = 8932501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 8948784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner Select(N->getOperand(0)), 8958784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner getI32Imm(Log2_32(-Imm))); 8968784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand PT = 8972501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, Op.getValue(0), 8982501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner Op.getValue(1)); 89971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::NEG, MVT::i32, PT); 9008784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 9018784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 902047b952e298352fe6feffedf02e359601133f465Chris Lattner 903237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 904237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 905047b952e298352fe6feffedf02e359601133f465Chris Lattner } 906cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman case ISD::AND: { 90750fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman unsigned Imm, Imm2; 908cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and of a value rotated between 0 and 31 bits and then and'd 909cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // with a mask, emit rlwinm 910cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isIntImmediate(N->getOperand(1), Imm) && (isShiftedMask_32(Imm) || 911cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isShiftedMask_32(~Imm))) { 912cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SDOperand Val; 913a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned SH, MB, ME; 914cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isRotateAndMask(N->getOperand(0).Val, Imm, false, SH, MB, ME)) { 915cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Val = Select(N->getOperand(0).getOperand(0)); 9163393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner } else if (Imm == 0) { 9173393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner // AND X, 0 -> 0, not "rlwinm 32". 9183393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner return Select(N->getOperand(1)); 9193393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner } else { 920cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Val = Select(N->getOperand(0)); 921cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isRunOfOnes(Imm, MB, ME); 922cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = 0; 923cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 92471d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Val, getI32Imm(SH), 92571d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(MB), getI32Imm(ME)); 926cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 92750fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // ISD::OR doesn't get all the bitfield insertion fun. 92850fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // (and (or x, c1), c2) where isRunOfOnes(~(c1^c2)) is a bitfield insert 92950fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman if (isIntImmediate(N->getOperand(1), Imm) && 93050fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman N->getOperand(0).getOpcode() == ISD::OR && 93150fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman isIntImmediate(N->getOperand(0).getOperand(1), Imm2)) { 932c9a5ef524a9f461717bbf647b2d3da061aed720dChris Lattner unsigned MB, ME; 93350fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman Imm = ~(Imm^Imm2); 93450fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman if (isRunOfOnes(Imm, MB, ME)) { 93550fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman SDOperand Tmp1 = Select(N->getOperand(0).getOperand(0)); 93650fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman SDOperand Tmp2 = Select(N->getOperand(0).getOperand(1)); 93750fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman return CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, Tmp1, Tmp2, 938c9a5ef524a9f461717bbf647b2d3da061aed720dChris Lattner getI32Imm(0), getI32Imm(MB), getI32Imm(ME)); 93950fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 94050fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 941237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner 942237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 943237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 944cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 94502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::OR: 946d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner if (SDNode *I = SelectBitfieldInsert(N)) 947d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner return CodeGenMap[Op] = SDOperand(I, 0); 948d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 949237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 950237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 951c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SHL: { 952c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 953c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 9542d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 95571d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 95671d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner Select(N->getOperand(0).getOperand(0)), 95771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 9588d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 9592d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 9602d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 9612d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 962c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 963c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRL: { 964c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 965c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 9662d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 96771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 96871d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner Select(N->getOperand(0).getOperand(0)), 96971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(SH & 0x1F), getI32Imm(MB), 97071d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(ME)); 9718d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 9722d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 9732d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 9742d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 975c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 97626653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case ISD::FNEG: { 97726653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman SDOperand Val = Select(N->getOperand(0)); 97826653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman MVT::ValueType Ty = N->getValueType(0); 9794cb5a1b8967828447e525fb9f593953f5f928bdcChris Lattner if (N->getOperand(0).Val->hasOneUse()) { 98026653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman unsigned Opc; 981528f58e813ec4929a7997afbf121eb54e8bacf4cChris Lattner switch (Val.isTargetOpcode() ? Val.getTargetOpcode() : 0) { 98226653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman default: Opc = 0; break; 983919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner case PPC::FABSS: Opc = PPC::FNABSS; break; 984919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner case PPC::FABSD: Opc = PPC::FNABSD; break; 98526653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMADD: Opc = PPC::FNMADD; break; 98626653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMADDS: Opc = PPC::FNMADDS; break; 98726653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMSUB: Opc = PPC::FNMSUB; break; 98826653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMSUBS: Opc = PPC::FNMSUBS; break; 98926653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 99026653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // If we inverted the opcode, then emit the new instruction with the 99126653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // inverted opcode and the original instruction's operands. Otherwise, 99226653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // fall through and generate a fneg instruction. 99326653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman if (Opc) { 994919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (Opc == PPC::FNABSS || Opc == PPC::FNABSD) 99571d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, Opc, Ty, Val.getOperand(0)); 99626653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman else 99771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, Opc, Ty, Val.getOperand(0), 99871d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner Val.getOperand(1), Val.getOperand(2)); 99926653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 100026653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 1001bead6612a5591003b84df52d8656a1fee54db82cChris Lattner // Other cases are autogenerated. 1002bead6612a5591003b84df52d8656a1fee54db82cChris Lattner break; 100326653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 100413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner case ISD::SELECT_CC: { 100513794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(4))->get(); 100613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner 100713794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner // handle the setcc cases here. select_cc lhs, 0, 1, 0, cc 100813794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N->getOperand(1))) 100913794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N->getOperand(2))) 101013794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N->getOperand(3))) 101113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (N1C->isNullValue() && N3C->isNullValue() && 101213794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner N2C->getValue() == 1ULL && CC == ISD::SETNE) { 101313794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner SDOperand LHS = Select(N->getOperand(0)); 101413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner SDOperand Tmp = 101513794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 101613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner LHS, getI32Imm(~0U)); 101771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, Tmp, LHS, 101871d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner Tmp.getValue(1)); 101913794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 10208a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 102150ff55c2c7909818165e51bbdc103a05b143dcb1Chris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 10228a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner unsigned BROpc = getBCCForSetCC(CC); 10238a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 10248a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner bool isFP = MVT::isFloatingPoint(N->getValueType(0)); 1025919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner unsigned SelectCCOp; 1026919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (MVT::isInteger(N->getValueType(0))) 1027919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_Int; 1028919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else if (N->getValueType(0) == MVT::f32) 1029919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F4; 1030919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else 1031919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F8; 103271d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, SelectCCOp, N->getValueType(0), CCReg, 103371d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner Select(N->getOperand(2)), 103471d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner Select(N->getOperand(3)), 103571d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(BROpc)); 103613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 10372fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::BR_CC: 10382fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::BRTWOWAY_CC: { 10392fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand Chain = Select(N->getOperand(0)); 10402fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner MachineBasicBlock *Dest = 10412fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner cast<BasicBlockSDNode>(N->getOperand(4))->getBasicBlock(); 10422fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(1))->get(); 10432fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CondCode = SelectCC(N->getOperand(2), N->getOperand(3), CC); 10442fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 10452fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // If this is a two way branch, then grab the fallthrough basic block 10462fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // argument and build a PowerPC branch pseudo-op, suitable for long branch 10472fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // conversion if necessary by the branch selection pass. Otherwise, emit a 10482fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // standard conditional branch. 10492fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (N->getOpcode() == ISD::BRTWOWAY_CC) { 1050ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner SDOperand CondTrueBlock = N->getOperand(4); 1051ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner SDOperand CondFalseBlock = N->getOperand(5); 1052ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner 1053ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner // If the false case is the current basic block, then this is a self loop. 1054ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner // We do not want to emit "Loop: ... brcond Out; br Loop", as it adds an 1055ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner // extra dispatch group to the loop. Instead, invert the condition and 1056ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner // emit "Loop: ... br!cond Loop; br Out 1057ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner if (cast<BasicBlockSDNode>(CondFalseBlock)->getBasicBlock() == BB) { 1058ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner std::swap(CondTrueBlock, CondFalseBlock); 1059ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner CC = getSetCCInverse(CC, 1060ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner MVT::isInteger(N->getOperand(2).getValueType())); 1061ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner } 1062ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner 1063ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner unsigned Opc = getBCCForSetCC(CC); 10642fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CB = CurDAG->getTargetNode(PPC::COND_BRANCH, MVT::Other, 10652fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner CondCode, getI32Imm(Opc), 1066ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner CondTrueBlock, CondFalseBlock, 10672fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner Chain); 106871d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::B, MVT::Other, CondFalseBlock, CB); 10692fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 10702fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Iterate to the next basic block 10712fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ilist<MachineBasicBlock>::iterator It = BB; 10722fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ++It; 10732fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 10742fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // If the fallthrough path is off the end of the function, which would be 10752fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // undefined behavior, set it to be the same as the current block because 10762fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // we have nothing better to set it to, and leaving it alone will cause 10772fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // the PowerPC Branch Selection pass to crash. 10782fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (It == BB->getParent()->end()) It = Dest; 107971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::COND_BRANCH, MVT::Other, CondCode, 108071d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(getBCCForSetCC(CC)), 108171d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner N->getOperand(4), CurDAG->getBasicBlock(It), 108271d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner Chain); 10832fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 10842fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 1085a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 108625dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner 108719c0907ba1c11c81dc231cf7b4143fdaf03466e4Chris Lattner return SelectCode(Op); 1088a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1089a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1090a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 10911d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman/// createPPCISelDag - This pass converts a legalized DAG into a 1092a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// PowerPC-specific DAG, ready for instruction scheduling. 1093a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// 10941d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanFunctionPass *llvm::createPPCISelDag(TargetMachine &TM) { 10951d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman return new PPCDAGToDAGISel(TM); 1096a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1097a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1098