PPCISelDAGToDAG.cpp revision 405e3ecb563f21e7b4ee30f0de57821f3eb91219
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<> FusedFP ("ppc-codegen", "Number of fused fp operations"); 33a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Statistic<> FrameOff("ppc-codegen", "Number of frame idx offsets collapsed"); 34a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 35a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner //===--------------------------------------------------------------------===// 361d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman /// PPCDAGToDAGISel - PPC specific code to select PPC machine 37a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// instructions for SelectionDAG operations. 38a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// 391d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman class PPCDAGToDAGISel : public SelectionDAGISel { 4021e463b2bf864671a87ebe386cb100ef9349a540Nate Begeman PPCTargetLowering PPCLowering; 414416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner unsigned GlobalBaseReg; 42a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner public: 431d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman PPCDAGToDAGISel(TargetMachine &TM) 4421e463b2bf864671a87ebe386cb100ef9349a540Nate Begeman : SelectionDAGISel(PPCLowering), PPCLowering(TM) {} 45a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 464416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner virtual bool runOnFunction(Function &Fn) { 474416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Make sure we re-emit a set of the global base reg if necessary 484416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalBaseReg = 0; 494416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner return SelectionDAGISel::runOnFunction(Fn); 504416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 514416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 52a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// getI32Imm - Return a target constant with the specified value, of type 53a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// i32. 54a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner inline SDOperand getI32Imm(unsigned Imm) { 55a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return CurDAG->getTargetConstant(Imm, MVT::i32); 56a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 574416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 584416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// getGlobalBaseReg - insert code into the entry mbb to materialize the PIC 594416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// base register. Return the virtual register that holds this value. 609944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner SDOperand getGlobalBaseReg(); 61a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 62a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Select - Convert the specified operand from a target-independent to a 63a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // target-specific node if it hasn't already been changed. 64a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Select(SDOperand Op); 65a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 6602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDNode *SelectBitfieldInsert(SDNode *N); 6702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 682fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// SelectCC - Select a comparison of the specified values with the 692fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// specified condition code, returning the CR# of the expression. 702fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand SelectCC(SDOperand LHS, SDOperand RHS, ISD::CondCode CC); 712fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 729944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner /// SelectAddr - Given the specified address, return the two operands for a 739944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner /// load/store instruction, and return true if it should be an indexed [r+r] 749944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner /// operation. 759944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner bool SelectAddr(SDOperand Addr, SDOperand &Op1, SDOperand &Op2); 769944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 77047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand BuildSDIVSequence(SDNode *N); 78047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand BuildUDIVSequence(SDNode *N); 79047b952e298352fe6feffedf02e359601133f465Chris Lattner 80a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// InstructionSelectBasicBlock - This callback is invoked by 81a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 82bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner virtual void InstructionSelectBasicBlock(SelectionDAG &DAG); 83bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 84a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner virtual const char *getPassName() const { 85a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return "PowerPC DAG->DAG Pattern Instruction Selection"; 86a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 87af165385112037cb942e94ea562a67990b7d6220Chris Lattner 88af165385112037cb942e94ea562a67990b7d6220Chris Lattner// Include the pieces autogenerated from the target description. 894c7b43b43fdf943c7298718e15ab5d6dfe345be7Chris Lattner#include "PPCGenDAGISel.inc" 90bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 91bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattnerprivate: 92222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand SelectDYNAMIC_STACKALLOC(SDOperand Op); 93222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand SelectADD_PARTS(SDOperand Op); 94222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand SelectSUB_PARTS(SDOperand Op); 95222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand SelectSETCC(SDOperand Op); 966a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand SelectCALL(SDOperand Op); 97a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner }; 98a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 99a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 100bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner/// InstructionSelectBasicBlock - This callback is invoked by 101bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner/// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 1021d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begemanvoid PPCDAGToDAGISel::InstructionSelectBasicBlock(SelectionDAG &DAG) { 103bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DEBUG(BB->dump()); 104bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 105bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // The selection process is inherently a bottom-up recursive process (users 106bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // select their uses before themselves). Given infinite stack space, we 107bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // could just start selecting on the root and traverse the whole graph. In 108bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // practice however, this causes us to run out of stack space on large basic 109bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // blocks. To avoid this problem, select the entry node, then all its uses, 110bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // iteratively instead of recursively. 111bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner std::vector<SDOperand> Worklist; 112bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Worklist.push_back(DAG.getEntryNode()); 113bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 114bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Note that we can do this in the PPC target (scanning forward across token 115bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // chain edges) because no nodes ever get folded across these edges. On a 116bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // target like X86 which supports load/modify/store operations, this would 117bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // have to be more careful. 118bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner while (!Worklist.empty()) { 119bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDOperand Node = Worklist.back(); 120bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Worklist.pop_back(); 121bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 122cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner // Chose from the least deep of the top two nodes. 123cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner if (!Worklist.empty() && 124cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner Worklist.back().Val->getNodeDepth() < Node.Val->getNodeDepth()) 125cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner std::swap(Worklist.back(), Node); 126cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner 127bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner if ((Node.Val->getOpcode() >= ISD::BUILTIN_OP_END && 128bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Node.Val->getOpcode() < PPCISD::FIRST_NUMBER) || 129bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner CodeGenMap.count(Node)) continue; 130bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 131bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner for (SDNode::use_iterator UI = Node.Val->use_begin(), 132bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner E = Node.Val->use_end(); UI != E; ++UI) { 133bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Scan the values. If this use has a value that is a token chain, add it 134bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // to the worklist. 135bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDNode *User = *UI; 136bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner for (unsigned i = 0, e = User->getNumValues(); i != e; ++i) 137bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner if (User->getValueType(i) == MVT::Other) { 138bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Worklist.push_back(SDOperand(User, i)); 139bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner break; 140bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner } 141bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner } 142bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 143bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Finally, legalize this node. 144bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Select(Node); 145bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner } 146cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner 147bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Select target instructions for the DAG. 148bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DAG.setRoot(Select(DAG.getRoot())); 149bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner CodeGenMap.clear(); 150bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DAG.RemoveDeadNodes(); 151bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 152bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Emit machine code to BB. 153bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner ScheduleAndEmitDAG(DAG); 154bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner} 1556cd40d5888f905a3820d5d6c71e57cc0e02abb4aChris Lattner 1564416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// getGlobalBaseReg - Output the instructions required to put the 1574416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// base address to use for accessing globals into a register. 1584416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// 1591d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::getGlobalBaseReg() { 1604416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (!GlobalBaseReg) { 1614416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Insert the set of GlobalBaseReg into the first MBB of the function 1624416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock &FirstMBB = BB->getParent()->front(); 1634416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock::iterator MBBI = FirstMBB.begin(); 1644416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SSARegMap *RegMap = BB->getParent()->getSSARegMap(); 1651d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman // FIXME: when we get to LP64, we will need to create the appropriate 1661d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman // type of register here. 1671d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman GlobalBaseReg = RegMap->createVirtualRegister(PPC::GPRCRegisterClass); 1684416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MovePCtoLR, 0, PPC::LR); 1694416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MFLR, 1, GlobalBaseReg); 1704416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 1719944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return CurDAG->getRegister(GlobalBaseReg, MVT::i32); 1724416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner} 1734416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 1744416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 1750f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isIntImmediate - This method tests to see if a constant operand. 1760f3257a3302b60c128a667db6736e81335316c1eNate Begeman// If so Imm will receive the 32 bit value. 1770f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isIntImmediate(SDNode *N, unsigned& Imm) { 1780f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (N->getOpcode() == ISD::Constant) { 1790f3257a3302b60c128a667db6736e81335316c1eNate Begeman Imm = cast<ConstantSDNode>(N)->getValue(); 1800f3257a3302b60c128a667db6736e81335316c1eNate Begeman return true; 1810f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 1820f3257a3302b60c128a667db6736e81335316c1eNate Begeman return false; 1830f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 1840f3257a3302b60c128a667db6736e81335316c1eNate Begeman 185cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isOprShiftImm - Returns true if the specified operand is a shift opcode with 186cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// a immediate shift count less than 32. 187cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isOprShiftImm(SDNode *N, unsigned& Opc, unsigned& SH) { 188cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Opc = N->getOpcode(); 189cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return (Opc == ISD::SHL || Opc == ISD::SRL || Opc == ISD::SRA) && 190cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isIntImmediate(N->getOperand(1).Val, SH) && SH < 32; 191cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 192cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 193cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s with 194cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// any number of 0s on either side. The 1s are allowed to wrap from LSB to 195cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 0x0F0F0000 is 196cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// not, since all 1s are not contiguous. 197cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME) { 198cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isShiftedMask_32(Val)) { 199cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first non-zero bit 200cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman MB = CountLeadingZeros_32(Val); 201cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first zero bit after the run of ones 202cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman ME = CountLeadingZeros_32((Val - 1) ^ Val); 203cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return true; 2042fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } else { 2052fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner Val = ~Val; // invert mask 2062fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner if (isShiftedMask_32(Val)) { 2072fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first zero bit 2082fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner ME = CountLeadingZeros_32(Val) - 1; 2092fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first one bit after the run of zeros 2102fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner MB = CountLeadingZeros_32((Val - 1) ^ Val) + 1; 2112fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner return true; 2122fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } 213cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 214cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // no run present 215cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 216cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 217cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 21865a419a1045972729f91f82a378b7f4b7f6a2be5Chris Lattner// isRotateAndMask - Returns true if Mask and Shift can be folded into a rotate 219cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// and mask opcode and mask operation. 220cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRotateAndMask(SDNode *N, unsigned Mask, bool IsShiftMask, 221cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned &SH, unsigned &MB, unsigned &ME) { 222da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // Don't even go down this path for i64, since different logic will be 223da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // necessary for rldicl/rldicr/rldimi. 224da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman if (N->getValueType(0) != MVT::i32) 225da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman return false; 226da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman 227cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Shift = 32; 228cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Indeterminant = ~0; // bit mask marking indeterminant results 229cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Opcode = N->getOpcode(); 23015055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner if (N->getNumOperands() != 2 || 23115055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner !isIntImmediate(N->getOperand(1).Val, Shift) || (Shift > 31)) 232cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 233cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 234cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Opcode == ISD::SHL) { 235cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift left to mask if it comes first 236cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask << Shift; 237cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 238cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu << Shift); 239651dea74f6a362d30bc61fd0b549da7707af5bf8Chris Lattner } else if (Opcode == ISD::SRL) { 240cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift right to mask if it comes first 241cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask >> Shift; 242cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 243cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu >> Shift); 244cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // adjust for the left rotate 245cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Shift = 32 - Shift; 246cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 247cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 248cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 249cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 250cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // if the mask doesn't intersect any Indeterminant bits 251cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Mask && !(Mask & Indeterminant)) { 252cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = Shift; 253cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // make sure the mask is still a mask (wrap arounds may not be) 254cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return isRunOfOnes(Mask, MB, ME); 255cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 256cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 257cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 258cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 2590f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isOpcWithIntImmediate - This method tests to see if the node is a specific 2600f3257a3302b60c128a667db6736e81335316c1eNate Begeman// opcode and that it has a immediate integer right operand. 2610f3257a3302b60c128a667db6736e81335316c1eNate Begeman// If so Imm will receive the 32 bit value. 2620f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isOpcWithIntImmediate(SDNode *N, unsigned Opc, unsigned& Imm) { 2630f3257a3302b60c128a667db6736e81335316c1eNate Begeman return N->getOpcode() == Opc && isIntImmediate(N->getOperand(1).Val, Imm); 2640f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 2650f3257a3302b60c128a667db6736e81335316c1eNate Begeman 2660f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isOprNot - Returns true if the specified operand is an xor with immediate -1. 2670f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isOprNot(SDNode *N) { 2680f3257a3302b60c128a667db6736e81335316c1eNate Begeman unsigned Imm; 2690f3257a3302b60c128a667db6736e81335316c1eNate Begeman return isOpcWithIntImmediate(N, ISD::XOR, Imm) && (signed)Imm == -1; 2700f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 2710f3257a3302b60c128a667db6736e81335316c1eNate Begeman 272a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Immediate constant composers. 273a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Lo16 - grabs the lo 16 bits from a 32 bit constant. 274a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Hi16 - grabs the hi 16 bits from a 32 bit constant. 275a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// HA16 - computes the hi bits required if the lo bits are add/subtracted in 276a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// arithmethically. 277a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic unsigned Lo16(unsigned x) { return x & 0x0000FFFF; } 278a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic unsigned Hi16(unsigned x) { return Lo16(x >> 16); } 279a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic unsigned HA16(unsigned x) { return Hi16((signed)x - (signed short)x); } 280a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 281a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// isIntImmediate - This method tests to see if a constant operand. 282a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// If so Imm will receive the 32 bit value. 283a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic bool isIntImmediate(SDOperand N, unsigned& Imm) { 284a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 285a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Imm = (unsigned)CN->getSignExtended(); 286a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return true; 287a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 288a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return false; 289a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 290a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 29102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// SelectBitfieldInsert - turn an or of two masked values into 29202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// the rotate left word immediate then mask insert (rlwimi) instruction. 29302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// Returns true on success, false if the caller still needs to select OR. 29402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 29502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// Patterns matched: 29602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 1. or shl, and 5. or and, and 29702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 2. or and, shl 6. or shl, shr 29802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 3. or shr, and 7. or shr, shl 29902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 4. or and, shr 3001d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDNode *PPCDAGToDAGISel::SelectBitfieldInsert(SDNode *N) { 30102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool IsRotate = false; 30202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned TgtMask = 0xFFFFFFFF, InsMask = 0xFFFFFFFF, SH = 0; 30302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Value; 30402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 30502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op0 = N->getOperand(0); 30602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op1 = N->getOperand(1); 30702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 30802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Op0Opc = Op0.getOpcode(); 30902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Op1Opc = Op1.getOpcode(); 31002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 31102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Verify that we have the correct opcodes 31202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (ISD::SHL != Op0Opc && ISD::SRL != Op0Opc && ISD::AND != Op0Opc) 31302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return false; 31402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (ISD::SHL != Op1Opc && ISD::SRL != Op1Opc && ISD::AND != Op1Opc) 31502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return false; 31602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 31702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Generate Mask value for Target 31802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op0.getOperand(1), Value)) { 31902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman switch(Op0Opc) { 3201368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SHL: TgtMask <<= Value; break; 3211368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SRL: TgtMask >>= Value; break; 3221368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::AND: TgtMask &= Value; break; 32302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 32402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } else { 32502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 32602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 32702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 32802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Generate Mask value for Insert 3291368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner if (!isIntImmediate(Op1.getOperand(1), Value)) 33002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 3311368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner 3321368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner switch(Op1Opc) { 3331368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SHL: 3341368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner SH = Value; 3351368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner InsMask <<= SH; 3361368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner if (Op0Opc == ISD::SRL) IsRotate = true; 3371368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner break; 3381368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SRL: 3391368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner SH = Value; 3401368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner InsMask >>= SH; 3411368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner SH = 32-SH; 3421368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner if (Op0Opc == ISD::SHL) IsRotate = true; 3431368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner break; 3441368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::AND: 3451368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner InsMask &= Value; 3461368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner break; 34702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 34802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 34902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // If both of the inputs are ANDs and one of them has a logical shift by 35002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // constant as its input, make that AND the inserted value so that we can 35102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // combine the shift into the rotate part of the rlwimi instruction 35202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool IsAndWithShiftOp = false; 35302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op0Opc == ISD::AND && Op1Opc == ISD::AND) { 35402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op1.getOperand(0).getOpcode() == ISD::SHL || 35502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op1.getOperand(0).getOpcode() == ISD::SRL) { 35602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op1.getOperand(0).getOperand(1), Value)) { 35702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Op1.getOperand(0).getOpcode() == ISD::SHL ? Value : 32 - Value; 35802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman IsAndWithShiftOp = true; 35902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 36002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } else if (Op0.getOperand(0).getOpcode() == ISD::SHL || 36102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0.getOperand(0).getOpcode() == ISD::SRL) { 36202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op0.getOperand(0).getOperand(1), Value)) { 36302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman std::swap(Op0, Op1); 36402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman std::swap(TgtMask, InsMask); 36502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Op1.getOperand(0).getOpcode() == ISD::SHL ? Value : 32 - Value; 36602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman IsAndWithShiftOp = true; 36702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 36802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 36902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 37002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 37102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Verify that the Target mask and Insert mask together form a full word mask 37202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // and that the Insert mask is a run of set bits (which implies both are runs 37302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // of set bits). Given that, Select the arguments and generate the rlwimi 37402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // instruction. 37502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned MB, ME; 37602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (((TgtMask & InsMask) == 0) && isRunOfOnes(InsMask, MB, ME)) { 37702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool fullMask = (TgtMask ^ InsMask) == 0xFFFFFFFF; 37802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool Op0IsAND = Op0Opc == ISD::AND; 37902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Check for rotlwi / rotrwi here, a special case of bitfield insert 38002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // where both bitfield halves are sourced from the same value. 38102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (IsRotate && fullMask && 38202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman N->getOperand(0).getOperand(0) == N->getOperand(1).getOperand(0)) { 38302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0 = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, 38402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Select(N->getOperand(0).getOperand(0)), 38502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman getI32Imm(SH), getI32Imm(0), getI32Imm(31)); 38602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return Op0.Val; 38702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 38802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Tmp1 = (Op0IsAND && fullMask) ? Select(Op0.getOperand(0)) 38902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman : Select(Op0); 39002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Tmp2 = IsAndWithShiftOp ? Select(Op1.getOperand(0).getOperand(0)) 39102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman : Select(Op1.getOperand(0)); 39202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0 = CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, Tmp1, Tmp2, 39302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 39402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return Op0.Val; 39502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 39602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 39702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman} 39802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 3999944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner/// SelectAddr - Given the specified address, return the two operands for a 4009944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner/// load/store instruction, and return true if it should be an indexed [r+r] 4019944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner/// operation. 4021d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begemanbool PPCDAGToDAGISel::SelectAddr(SDOperand Addr, SDOperand &Op1, 4031d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman SDOperand &Op2) { 4049944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner unsigned imm = 0; 4059944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (Addr.getOpcode() == ISD::ADD) { 4069944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (isIntImmediate(Addr.getOperand(1), imm) && isInt16(imm)) { 4079944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = getI32Imm(Lo16(imm)); 408e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner if (FrameIndexSDNode *FI = 409e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner dyn_cast<FrameIndexSDNode>(Addr.getOperand(0))) { 4109944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner ++FrameOff; 411e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner Op2 = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 4129944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 4139944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = Select(Addr.getOperand(0)); 4149944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4159944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4169944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 4179944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = Select(Addr.getOperand(0)); 4189944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = Select(Addr.getOperand(1)); 4199944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return true; // [r+r] 4209944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4219944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4229944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 4239944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner // Now check if we're dealing with a global, and whether or not we should emit 4249944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner // an optimized load or store for statics. 4259944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (GlobalAddressSDNode *GN = dyn_cast<GlobalAddressSDNode>(Addr)) { 4269944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner GlobalValue *GV = GN->getGlobal(); 4279944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (!GV->hasWeakLinkage() && !GV->isExternal()) { 4289944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = CurDAG->getTargetGlobalAddress(GV, MVT::i32); 4299944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (PICEnabled) 4309944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(), 4319944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1); 4329944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner else 4339944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::LIS, MVT::i32, Op1); 4349944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4359944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 436e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } else if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Addr)) { 4379944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = getI32Imm(0); 438e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner Op2 = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 4399944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4409944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Addr)) { 4419944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = Addr; 4429944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (PICEnabled) 4439944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(),Op1); 4449944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner else 4459944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::LIS, MVT::i32, Op1); 4469944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4479944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4489944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = getI32Imm(0); 4499944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = Select(Addr); 4509944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4519944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner} 452a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 4532fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// SelectCC - Select a comparison of the specified values with the specified 4542fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// condition code, returning the CR# of the expression. 4551d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectCC(SDOperand LHS, SDOperand RHS, 4561d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman ISD::CondCode CC) { 4572fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Always select the LHS. 4582fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner LHS = Select(LHS); 4592fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 4602fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Use U to determine whether the SETCC immediate range is signed or not. 4612fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (MVT::isInteger(LHS.getValueType())) { 4622fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner bool U = ISD::isUnsignedIntSetCC(CC); 4632fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner unsigned Imm; 4642fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (isIntImmediate(RHS, Imm) && 4652fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ((U && isUInt16(Imm)) || (!U && isInt16(Imm)))) 4662fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return CurDAG->getTargetNode(U ? PPC::CMPLWI : PPC::CMPWI, MVT::i32, 4672fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner LHS, getI32Imm(Lo16(Imm))); 4682fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return CurDAG->getTargetNode(U ? PPC::CMPLW : PPC::CMPW, MVT::i32, 4692fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner LHS, Select(RHS)); 470919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner } else if (LHS.getValueType() == MVT::f32) { 471919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner return CurDAG->getTargetNode(PPC::FCMPUS, MVT::i32, LHS, Select(RHS)); 4722fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 473919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner return CurDAG->getTargetNode(PPC::FCMPUD, MVT::i32, LHS, Select(RHS)); 4742fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 4752fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 4762fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 4772fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// getBCCForSetCC - Returns the PowerPC condition branch mnemonic corresponding 4782fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// to Condition. 4792fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattnerstatic unsigned getBCCForSetCC(ISD::CondCode CC) { 4802fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner switch (CC) { 4812fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 4822fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETEQ: return PPC::BEQ; 4832fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETNE: return PPC::BNE; 4842fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULT: 4852fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLT: return PPC::BLT; 4862fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULE: 4872fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLE: return PPC::BLE; 4882fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGT: 4892fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGT: return PPC::BGT; 4902fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGE: 4912fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGE: return PPC::BGE; 4922fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 4932fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return 0; 4942fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 4952fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 49664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// getCRIdxForSetCC - Return the index of the condition register field 49764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// associated with the SetCC condition, and whether or not the field is 49864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// treated as inverted. That is, lt = 0; ge = 0 inverted. 49964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattnerstatic unsigned getCRIdxForSetCC(ISD::CondCode CC, bool& Inv) { 50064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 50164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 50264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULT: 50364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLT: Inv = false; return 0; 50464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGE: 50564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGE: Inv = true; return 0; 50664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGT: 50764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGT: Inv = false; return 1; 50864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULE: 50964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLE: Inv = true; return 1; 51064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETEQ: Inv = false; return 2; 51164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETNE: Inv = true; return 2; 51264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 51364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner return 0; 51464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner} 5159944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 5161d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectDYNAMIC_STACKALLOC(SDOperand Op) { 517bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDNode *N = Op.Val; 518bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 519bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // FIXME: We are currently ignoring the requested alignment for handling 520bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // greater than the stack alignment. This will need to be revisited at some 521bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // point. Align = N.getOperand(2); 522bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner if (!isa<ConstantSDNode>(N->getOperand(2)) || 523bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner cast<ConstantSDNode>(N->getOperand(2))->getValue() != 0) { 524bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner std::cerr << "Cannot allocate stack object with greater alignment than" 525bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner << " the stack alignment yet!"; 526bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner abort(); 527bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner } 528bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDOperand Chain = Select(N->getOperand(0)); 529bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDOperand Amt = Select(N->getOperand(1)); 530bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 531bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDOperand R1Reg = CurDAG->getRegister(PPC::R1, MVT::i32); 532bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 533bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDOperand R1Val = CurDAG->getCopyFromReg(Chain, PPC::R1, MVT::i32); 534bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Chain = R1Val.getValue(1); 535bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 536bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Subtract the amount (guaranteed to be a multiple of the stack alignment) 537bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // from the stack pointer, giving us the result pointer. 538bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDOperand Result = CurDAG->getTargetNode(PPC::SUBF, MVT::i32, Amt, R1Val); 539bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 540bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Copy this result back into R1. 541bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Chain = CurDAG->getNode(ISD::CopyToReg, MVT::Other, Chain, R1Reg, Result); 542bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 543bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Copy this result back out of R1 to make sure we're not using the stack 544bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // space without decrementing the stack pointer. 545bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Result = CurDAG->getCopyFromReg(Chain, PPC::R1, MVT::i32); 546bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 547bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Finally, replace the DYNAMIC_STACKALLOC with the copyfromreg. 548bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner CodeGenMap[Op.getValue(0)] = Result; 549bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner CodeGenMap[Op.getValue(1)] = Result.getValue(1); 550bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner return SDOperand(Result.Val, Op.ResNo); 551bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner} 552bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 5531d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectADD_PARTS(SDOperand Op) { 5542b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDNode *N = Op.Val; 5552b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand LHSL = Select(N->getOperand(0)); 5562b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand LHSH = Select(N->getOperand(1)); 5572b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 5582b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner unsigned Imm; 5592b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner bool ME = false, ZE = false; 5602b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner if (isIntImmediate(N->getOperand(3), Imm)) { 5612b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner ME = (signed)Imm == -1; 5622b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner ZE = Imm == 0; 5632b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner } 5642b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 5652b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner std::vector<SDOperand> Result; 5662b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand CarryFromLo; 5672b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner if (isIntImmediate(N->getOperand(2), Imm) && 5682b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner ((signed)Imm >= -32768 || (signed)Imm < 32768)) { 5692b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner // Codegen the low 32 bits of the add. Interestingly, there is no 5702b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner // shifted form of add immediate carrying. 5712b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner CarryFromLo = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 5722b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner LHSL, getI32Imm(Imm)); 5732b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner } else { 5742b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner CarryFromLo = CurDAG->getTargetNode(PPC::ADDC, MVT::i32, MVT::Flag, 5752b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner LHSL, Select(N->getOperand(2))); 5762b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner } 5772b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner CarryFromLo = CarryFromLo.getValue(1); 5782b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 5792b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner // Codegen the high 32 bits, adding zero, minus one, or the full value 5802b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner // along with the carry flag produced by addc/addic. 5812b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand ResultHi; 5822b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner if (ZE) 5832b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner ResultHi = CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, LHSH, CarryFromLo); 5842b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner else if (ME) 5852b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner ResultHi = CurDAG->getTargetNode(PPC::ADDME, MVT::i32, LHSH, CarryFromLo); 5862b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner else 5872b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner ResultHi = CurDAG->getTargetNode(PPC::ADDE, MVT::i32, LHSH, 5882b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner Select(N->getOperand(3)), CarryFromLo); 5892b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner Result.push_back(CarryFromLo.getValue(0)); 5902b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner Result.push_back(ResultHi); 5912b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 5922b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner CodeGenMap[Op.getValue(0)] = Result[0]; 5932b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner CodeGenMap[Op.getValue(1)] = Result[1]; 5942b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner return Result[Op.ResNo]; 5952b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner} 5961d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectSUB_PARTS(SDOperand Op) { 5972b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDNode *N = Op.Val; 5982b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand LHSL = Select(N->getOperand(0)); 5992b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand LHSH = Select(N->getOperand(1)); 6002b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand RHSL = Select(N->getOperand(2)); 6012b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner SDOperand RHSH = Select(N->getOperand(3)); 6022b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 6032b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner std::vector<SDOperand> Result; 6042b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner Result.push_back(CurDAG->getTargetNode(PPC::SUBFC, MVT::i32, MVT::Flag, 6052b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner RHSL, LHSL)); 6062b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner Result.push_back(CurDAG->getTargetNode(PPC::SUBFE, MVT::i32, RHSH, LHSH, 6072b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner Result[0].getValue(1))); 6082b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner CodeGenMap[Op.getValue(0)] = Result[0]; 6092b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner CodeGenMap[Op.getValue(1)] = Result[1]; 6102b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner return Result[Op.ResNo]; 6112b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner} 6122b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 6131d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectSETCC(SDOperand Op) { 614222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDNode *N = Op.Val; 615222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Imm; 616222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get(); 617222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (isIntImmediate(N->getOperand(1), Imm)) { 618222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // We can codegen setcc op, imm very efficiently compared to a brcond. 619222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Check for those cases here. 620222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // setcc op, 0 621222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (Imm == 0) { 622222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand Op = Select(N->getOperand(0)); 623222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 624222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner default: assert(0 && "Unhandled SetCC condition"); abort(); 625222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::SETEQ: 626222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner Op = CurDAG->getTargetNode(PPC::CNTLZW, MVT::i32, Op); 627222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Op, getI32Imm(27), 628222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner getI32Imm(5), getI32Imm(31)); 629222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner break; 630222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::SETNE: { 631222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand AD = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 632222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner Op, getI32Imm(~0U)); 633222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, AD.getValue(1)); 634222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner break; 635222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 636222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::SETLT: 637222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Op, getI32Imm(1), 638222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner getI32Imm(31), getI32Imm(31)); 639222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner break; 640222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::SETGT: { 641222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand T = CurDAG->getTargetNode(PPC::NEG, MVT::i32, Op); 642222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner T = CurDAG->getTargetNode(PPC::ANDC, MVT::i32, T, Op);; 643222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, T, getI32Imm(1), 644222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner getI32Imm(31), getI32Imm(31)); 645222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner break; 646222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 647222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 648222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner return SDOperand(N, 0); 649222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else if (Imm == ~0U) { // setcc op, -1 650222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand Op = Select(N->getOperand(0)); 651222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 652222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner default: assert(0 && "Unhandled SetCC condition"); abort(); 653222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::SETEQ: 654222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner Op = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 655222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner Op, getI32Imm(1)); 656222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 657222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner CurDAG->getTargetNode(PPC::LI, MVT::i32, 658222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner getI32Imm(0)), 659222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner Op.getValue(1)); 660222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner break; 661222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::SETNE: { 662222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner Op = CurDAG->getTargetNode(PPC::NOR, MVT::i32, Op, Op); 663222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand AD = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 664222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner Op, getI32Imm(~0U)); 665222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, AD.getValue(1)); 666222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner break; 667222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 668222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::SETLT: { 669222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand AD = CurDAG->getTargetNode(PPC::ADDI, MVT::i32, Op, 670222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner getI32Imm(1)); 671222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand AN = CurDAG->getTargetNode(PPC::AND, MVT::i32, AD, Op); 672222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, AN, getI32Imm(1), 673222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner getI32Imm(31), getI32Imm(31)); 674222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner break; 675222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 676222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::SETGT: 677222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner Op = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Op, getI32Imm(1), 678222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner getI32Imm(31), getI32Imm(31)); 679222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Op, getI32Imm(1)); 680222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner break; 681222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 682222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner return SDOperand(N, 0); 683222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 684222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 685222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 686222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner bool Inv; 687222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Idx = getCRIdxForSetCC(CC, Inv); 688222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 689222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand IntCR; 690222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 691222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Force the ccreg into CR7. 692222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand CR7Reg = CurDAG->getRegister(PPC::CR7, MVT::i32); 693222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 694222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner std::vector<MVT::ValueType> VTs; 695222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner VTs.push_back(MVT::Other); 696222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner VTs.push_back(MVT::Flag); // NONSTANDARD CopyToReg node: defines a flag 697222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner std::vector<SDOperand> Ops; 698222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner Ops.push_back(CurDAG->getEntryNode()); 699222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner Ops.push_back(CR7Reg); 700222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner Ops.push_back(CCReg); 701222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner CCReg = CurDAG->getNode(ISD::CopyToReg, VTs, Ops).getValue(1); 702222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 703222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (TLI.getTargetMachine().getSubtarget<PPCSubtarget>().isGigaProcessor()) 704222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner IntCR = CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, CR7Reg, CCReg); 705222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner else 706222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner IntCR = CurDAG->getTargetNode(PPC::MFCR, MVT::i32, CCReg); 707222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 708222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (!Inv) { 709222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, IntCR, 710222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner getI32Imm(32-(3-Idx)), getI32Imm(31), getI32Imm(31)); 711222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else { 712222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand Tmp = 713222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, IntCR, 714222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner getI32Imm(32-(3-Idx)), getI32Imm(31),getI32Imm(31)); 715222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Tmp, getI32Imm(1)); 716222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 717222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 718222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner return SDOperand(N, 0); 719222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner} 7202b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 7211d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectCALL(SDOperand Op) { 7226a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDNode *N = Op.Val; 7236a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand Chain = Select(N->getOperand(0)); 7246a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7256a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner unsigned CallOpcode; 7266a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner std::vector<SDOperand> CallOperands; 7276a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7286a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (GlobalAddressSDNode *GASD = 7296a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner dyn_cast<GlobalAddressSDNode>(N->getOperand(1))) { 7306a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOpcode = PPC::CALLpcrel; 7316a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(CurDAG->getTargetGlobalAddress(GASD->getGlobal(), 7326a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner MVT::i32)); 7336a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else if (ExternalSymbolSDNode *ESSDN = 7346a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner dyn_cast<ExternalSymbolSDNode>(N->getOperand(1))) { 7356a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOpcode = PPC::CALLpcrel; 7366a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(N->getOperand(1)); 7376a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else { 7386a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // Copy the callee address into the CTR register. 7396a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand Callee = Select(N->getOperand(1)); 7406a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getTargetNode(PPC::MTCTR, MVT::Other, Callee, Chain); 7416a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7426a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // Copy the callee address into R12 on darwin. 7436a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand R12 = CurDAG->getRegister(PPC::R12, MVT::i32); 7446a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getNode(ISD::CopyToReg, MVT::Other, Chain, R12, Callee); 7456a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7466a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(getI32Imm(20)); // Information to encode indcall 7476a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(getI32Imm(0)); // Information to encode indcall 7486a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(R12); 7496a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOpcode = PPC::CALLindirect; 7506a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 7516a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7526a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner unsigned GPR_idx = 0, FPR_idx = 0; 7536a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner static const unsigned GPR[] = { 7546a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::R3, PPC::R4, PPC::R5, PPC::R6, 7556a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::R7, PPC::R8, PPC::R9, PPC::R10, 7566a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner }; 7576a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner static const unsigned FPR[] = { 7586a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, 7596a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::F8, PPC::F9, PPC::F10, PPC::F11, PPC::F12, PPC::F13 7606a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner }; 7616a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7626a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand InFlag; // Null incoming flag value. 7636a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7646a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner for (unsigned i = 2, e = N->getNumOperands(); i != e; ++i) { 7656a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner unsigned DestReg = 0; 7666a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner MVT::ValueType RegTy = N->getOperand(i).getValueType(); 7676a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (RegTy == MVT::i32) { 7686a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner assert(GPR_idx < 8 && "Too many int args"); 7696a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner DestReg = GPR[GPR_idx++]; 7706a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else { 7716a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner assert(MVT::isFloatingPoint(N->getOperand(i).getValueType()) && 7726a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner "Unpromoted integer arg?"); 7736a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner assert(FPR_idx < 13 && "Too many fp args"); 7746a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner DestReg = FPR[FPR_idx++]; 7756a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 7766a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7776a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (N->getOperand(i).getOpcode() != ISD::UNDEF) { 7786a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand Val = Select(N->getOperand(i)); 7796a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyToReg(Chain, DestReg, Val, InFlag); 7806a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner InFlag = Chain.getValue(1); 7816a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(CurDAG->getRegister(DestReg, RegTy)); 7826a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 7836a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 7846a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7856a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // Finally, once everything is in registers to pass to the call, emit the 7866a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // call itself. 7876a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (InFlag.Val) 7886a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(InFlag); // Strong dep on register copies. 7896a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner else 7906a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(Chain); // Weak dep on whatever occurs before 7916a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getTargetNode(CallOpcode, MVT::Other, MVT::Flag, 7926a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands); 7936a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7946a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner std::vector<SDOperand> CallResults; 7956a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 7966a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // If the call has results, copy the values out of the ret val registers. 7976a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner switch (N->getValueType(0)) { 7986a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner default: assert(0 && "Unexpected ret value!"); 7996a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::Other: break; 8006a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::i32: 8016a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (N->getValueType(1) == MVT::i32) { 8026a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R4, MVT::i32, 8036a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(1)).getValue(1); 8046a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 8056a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R3, MVT::i32, 8066a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(2)).getValue(1); 8076a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 8086a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else { 8096a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R3, MVT::i32, 8106a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(1)).getValue(1); 8116a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 8126a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 8136a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner break; 8146a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::f32: 8156a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::f64: 8166a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::F1, N->getValueType(0), 8176a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(1)).getValue(1); 8186a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 8196a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner break; 8206a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 8216a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 8226a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain); 8236a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner for (unsigned i = 0, e = CallResults.size(); i != e; ++i) 8246a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CodeGenMap[Op.getValue(i)] = CallResults[i]; 8256a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner return CallResults[Op.ResNo]; 8266a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner} 8276a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 828a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Select - Convert the specified operand from a target-independent to a 829a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// target-specific node if it hasn't already been changed. 8301d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::Select(SDOperand Op) { 831a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDNode *N = Op.Val; 8320bbea954331b8f08afa5b094dfb0841829c70eaaChris Lattner if (N->getOpcode() >= ISD::BUILTIN_OP_END && 8330bbea954331b8f08afa5b094dfb0841829c70eaaChris Lattner N->getOpcode() < PPCISD::FIRST_NUMBER) 834a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return Op; // Already selected. 835d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 836d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner // If this has already been converted, use it. 837d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner std::map<SDOperand, SDOperand>::iterator CGMI = CodeGenMap.find(Op); 838d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner if (CGMI != CodeGenMap.end()) return CGMI->second; 839a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 840a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOpcode()) { 84119c0907ba1c11c81dc231cf7b4143fdaf03466e4Chris Lattner default: break; 842222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::DYNAMIC_STACKALLOC: return SelectDYNAMIC_STACKALLOC(Op); 843222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::ADD_PARTS: return SelectADD_PARTS(Op); 844222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::SUB_PARTS: return SelectSUB_PARTS(Op); 845222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner case ISD::SETCC: return SelectSETCC(Op); 8466a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case ISD::CALL: return SelectCALL(Op); 8476a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case ISD::TAILCALL: return SelectCALL(Op); 8486a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 849a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::TokenFactor: { 850a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand New; 851a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (N->getNumOperands() == 2) { 852a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Op0 = Select(N->getOperand(0)); 853a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Op1 = Select(N->getOperand(1)); 854a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner New = CurDAG->getNode(ISD::TokenFactor, MVT::Other, Op0, Op1); 855a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } else { 856a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner std::vector<SDOperand> Ops; 857a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) 8587e65997c43cc91a5e6eaa0f460b844ef1b5d2fb1Chris Lattner Ops.push_back(Select(N->getOperand(i))); 859a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner New = CurDAG->getNode(ISD::TokenFactor, MVT::Other, Ops); 860a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 861a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 862cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner CodeGenMap[Op] = New; 863d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner return New; 864a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 865a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::CopyFromReg: { 866a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Chain = Select(N->getOperand(0)); 867a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Chain == N->getOperand(0)) return Op; // No change 868a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand New = CurDAG->getCopyFromReg(Chain, 869a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner cast<RegisterSDNode>(N->getOperand(1))->getReg(), N->getValueType(0)); 870a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return New.getValue(Op.ResNo); 871a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 872a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::CopyToReg: { 873a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Chain = Select(N->getOperand(0)); 874a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Reg = N->getOperand(1); 875a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Val = Select(N->getOperand(2)); 876d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner SDOperand New = CurDAG->getNode(ISD::CopyToReg, MVT::Other, 877d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner Chain, Reg, Val); 878cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner CodeGenMap[Op] = New; 879d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner return New; 880a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 8812b54400f085391a247dd2c3fffc9f36f7b2dc867Chris Lattner case ISD::UNDEF: 8822b54400f085391a247dd2c3fffc9f36f7b2dc867Chris Lattner if (N->getValueType(0) == MVT::i32) 8832bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::IMPLICIT_DEF_GPR, MVT::i32); 884919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else if (N->getValueType(0) == MVT::f32) 885919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CurDAG->SelectNodeTo(N, PPC::IMPLICIT_DEF_F4, MVT::f32); 886919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else 887919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CurDAG->SelectNodeTo(N, PPC::IMPLICIT_DEF_F8, MVT::f64); 88825dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 889e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner case ISD::FrameIndex: { 890e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner int FI = cast<FrameIndexSDNode>(N)->getIndex(); 8912bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::ADDI, MVT::i32, 892e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner CurDAG->getTargetFrameIndex(FI, MVT::i32), 893e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner getI32Imm(0)); 89425dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 895e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } 89634e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner case ISD::ConstantPool: { 8975839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner Constant *C = cast<ConstantPoolSDNode>(N)->get(); 8985839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand Tmp, CPI = CurDAG->getTargetConstantPool(C, MVT::i32); 89934e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner if (PICEnabled) 90034e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner Tmp = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(),CPI); 90134e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner else 90234e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner Tmp = CurDAG->getTargetNode(PPC::LIS, MVT::i32, CPI); 9032bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::LA, MVT::i32, Tmp, CPI); 90425dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 90534e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner } 9064416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner case ISD::GlobalAddress: { 9074416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalValue *GV = cast<GlobalAddressSDNode>(N)->getGlobal(); 9084416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SDOperand Tmp; 9094416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SDOperand GA = CurDAG->getTargetGlobalAddress(GV, MVT::i32); 9109944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (PICEnabled) 9119944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Tmp = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(), GA); 9129944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner else 9134416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner Tmp = CurDAG->getTargetNode(PPC::LIS, MVT::i32, GA); 9149944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 9154416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (GV->hasWeakLinkage() || GV->isExternal()) 9162bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::LWZ, MVT::i32, GA, Tmp); 9174416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner else 9182bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::LA, MVT::i32, Tmp, GA); 91925dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 9204416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 921222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 922867940d1b738504a3186276542e94f088821c7f3Chris Lattner case PPCISD::FSEL: { 92343f07a4bbcac695c51def1d0bcd9c9ddb9e6a94dChris Lattner SDOperand Comparison = Select(N->getOperand(0)); 92443f07a4bbcac695c51def1d0bcd9c9ddb9e6a94dChris Lattner // Extend the comparison to 64-bits. 92543f07a4bbcac695c51def1d0bcd9c9ddb9e6a94dChris Lattner if (Comparison.getValueType() == MVT::f32) 92643f07a4bbcac695c51def1d0bcd9c9ddb9e6a94dChris Lattner Comparison = CurDAG->getTargetNode(PPC::FMRSD, MVT::f64, Comparison); 92743f07a4bbcac695c51def1d0bcd9c9ddb9e6a94dChris Lattner 92843f07a4bbcac695c51def1d0bcd9c9ddb9e6a94dChris Lattner unsigned Opc = N->getValueType(0) == MVT::f32 ? PPC::FSELS : PPC::FSELD; 92943f07a4bbcac695c51def1d0bcd9c9ddb9e6a94dChris Lattner CurDAG->SelectNodeTo(N, Opc, N->getValueType(0), Comparison, 93043f07a4bbcac695c51def1d0bcd9c9ddb9e6a94dChris Lattner Select(N->getOperand(1)), Select(N->getOperand(2))); 93125dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 932867940d1b738504a3186276542e94f088821c7f3Chris Lattner } 933c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman case PPCISD::FCFID: 934c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman CurDAG->SelectNodeTo(N, PPC::FCFID, N->getValueType(0), 935c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman Select(N->getOperand(0))); 936c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman return SDOperand(N, 0); 937c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman case PPCISD::FCTIDZ: 938c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman CurDAG->SelectNodeTo(N, PPC::FCTIDZ, N->getValueType(0), 939c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman Select(N->getOperand(0))); 940c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman return SDOperand(N, 0); 941f76053269ecc6c7bd3d0b1e90ebdd0cef1bb2bdcChris Lattner case PPCISD::FCTIWZ: 942f76053269ecc6c7bd3d0b1e90ebdd0cef1bb2bdcChris Lattner CurDAG->SelectNodeTo(N, PPC::FCTIWZ, N->getValueType(0), 943f76053269ecc6c7bd3d0b1e90ebdd0cef1bb2bdcChris Lattner Select(N->getOperand(0))); 94425dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 945615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner case ISD::FADD: { 946615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner MVT::ValueType Ty = N->getValueType(0); 947a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (!NoExcessFPPrecision) { // Match FMA ops 948615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner if (N->getOperand(0).getOpcode() == ISD::FMUL && 949a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(0).Val->hasOneUse()) { 950a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 9512bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Ty == MVT::f64 ? PPC::FMADD : PPC::FMADDS, Ty, 952a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(0)), 953a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(1)), 954a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1))); 95525dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 956615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner } else if (N->getOperand(1).getOpcode() == ISD::FMUL && 957a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(1).hasOneUse()) { 958a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 9592bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Ty == MVT::f64 ? PPC::FMADD : PPC::FMADDS, Ty, 960a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(0)), 961a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(1)), 962a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0))); 96325dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 964a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 965a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 966a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 9672bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Ty == MVT::f64 ? PPC::FADD : PPC::FADDS, Ty, 968a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0)), Select(N->getOperand(1))); 96925dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 970a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 971615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner case ISD::FSUB: { 972615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner MVT::ValueType Ty = N->getValueType(0); 973a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 974a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (!NoExcessFPPrecision) { // Match FMA ops 975615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner if (N->getOperand(0).getOpcode() == ISD::FMUL && 976a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(0).Val->hasOneUse()) { 977a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 9782bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Ty == MVT::f64 ? PPC::FMSUB : PPC::FMSUBS, Ty, 979a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(0)), 980a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(1)), 981a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1))); 98225dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 983615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner } else if (N->getOperand(1).getOpcode() == ISD::FMUL && 984a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(1).Val->hasOneUse()) { 985a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 9862bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Ty == MVT::f64 ? PPC::FNMSUB : PPC::FNMSUBS, Ty, 987a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(0)), 988a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(1)), 989a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0))); 99025dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 991a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 992a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 9932bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Ty == MVT::f64 ? PPC::FSUB : PPC::FSUBS, Ty, 994a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0)), 995a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1))); 99625dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 99726653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 99888add100b3db715df4275c8ab408e6b51f28ff8fChris Lattner case ISD::SDIV: { 999405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: since this depends on the setting of the carry flag from the srawi 1000405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // we should really be making notes about that for the scheduler. 1001405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: It sure would be nice if we could cheaply recognize the 1002405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // srl/add/sra pattern the dag combiner will generate for this as 1003405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // sra/addze rather than having to handle sdiv ourselves. oh well. 10048784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner unsigned Imm; 10058784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if (isIntImmediate(N->getOperand(1), Imm)) { 10068784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if ((signed)Imm > 0 && isPowerOf2_32(Imm)) { 10078784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand Op = 10088784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 10098784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner Select(N->getOperand(0)), 10108784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner getI32Imm(Log2_32(Imm))); 10112bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 10128784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner Op.getValue(0), Op.getValue(1)); 101325dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 10148784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } else if ((signed)Imm < 0 && isPowerOf2_32(-Imm)) { 10158784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand Op = 10162501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 10178784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner Select(N->getOperand(0)), 10188784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner getI32Imm(Log2_32(-Imm))); 10198784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand PT = 10202501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, Op.getValue(0), 10212501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner Op.getValue(1)); 10222bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::NEG, MVT::i32, PT); 102325dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 10248784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 10258784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 1026047b952e298352fe6feffedf02e359601133f465Chris Lattner 1027237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1028237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1029047b952e298352fe6feffedf02e359601133f465Chris Lattner } 1030cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman case ISD::AND: { 1031a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned Imm; 1032cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and of a value rotated between 0 and 31 bits and then and'd 1033cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // with a mask, emit rlwinm 1034cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isIntImmediate(N->getOperand(1), Imm) && (isShiftedMask_32(Imm) || 1035cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isShiftedMask_32(~Imm))) { 1036cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SDOperand Val; 1037a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned SH, MB, ME; 1038cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isRotateAndMask(N->getOperand(0).Val, Imm, false, SH, MB, ME)) { 1039cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Val = Select(N->getOperand(0).getOperand(0)); 1040cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 1041cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Val = Select(N->getOperand(0)); 1042cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isRunOfOnes(Imm, MB, ME); 1043cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = 0; 1044cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 10452bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Val, getI32Imm(SH), 1046cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman getI32Imm(MB), getI32Imm(ME)); 104725dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 1048cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 1049237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner 1050237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1051237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1052cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 105302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::OR: 1054d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner if (SDNode *I = SelectBitfieldInsert(N)) 1055d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner return CodeGenMap[Op] = SDOperand(I, 0); 1056d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 1057237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1058237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1059c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SHL: { 1060c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1061c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 10622d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 10632bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 1064c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(0).getOperand(0)), 1065c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 10662d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman return SDOperand(N, 0); 10678d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 10682d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 10692d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 10702d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1071c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 1072c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRL: { 1073c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1074c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 10752d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 10762bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 1077c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(0).getOperand(0)), 1078c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman getI32Imm(SH & 0x1F), getI32Imm(MB), getI32Imm(ME)); 10792d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman return SDOperand(N, 0); 10808d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 10812d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 10822d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 10832d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1084c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 108526653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case ISD::FNEG: { 108626653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman SDOperand Val = Select(N->getOperand(0)); 108726653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman MVT::ValueType Ty = N->getValueType(0); 10884cb5a1b8967828447e525fb9f593953f5f928bdcChris Lattner if (N->getOperand(0).Val->hasOneUse()) { 108926653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman unsigned Opc; 1090528f58e813ec4929a7997afbf121eb54e8bacf4cChris Lattner switch (Val.isTargetOpcode() ? Val.getTargetOpcode() : 0) { 109126653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman default: Opc = 0; break; 1092919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner case PPC::FABSS: Opc = PPC::FNABSS; break; 1093919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner case PPC::FABSD: Opc = PPC::FNABSD; break; 109426653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMADD: Opc = PPC::FNMADD; break; 109526653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMADDS: Opc = PPC::FNMADDS; break; 109626653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMSUB: Opc = PPC::FNMSUB; break; 109726653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMSUBS: Opc = PPC::FNMSUBS; break; 109826653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 109926653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // If we inverted the opcode, then emit the new instruction with the 110026653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // inverted opcode and the original instruction's operands. Otherwise, 110126653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // fall through and generate a fneg instruction. 110226653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman if (Opc) { 1103919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (Opc == PPC::FNABSS || Opc == PPC::FNABSD) 11042bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Opc, Ty, Val.getOperand(0)); 110526653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman else 11062bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Opc, Ty, Val.getOperand(0), 110726653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman Val.getOperand(1), Val.getOperand(2)); 110825dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 110926653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 111026653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 1111919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (Ty == MVT::f32) 1112919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CurDAG->SelectNodeTo(N, PPC::FNEGS, MVT::f32, Val); 1113919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else 11142c1760f636df659df8fcbc91055c0afd970f16c8Chris Lattner CurDAG->SelectNodeTo(N, PPC::FNEGD, MVT::f64, Val); 111525dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 111626653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 11179944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::LOAD: 11189944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::EXTLOAD: 11199944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::ZEXTLOAD: 11209944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::SEXTLOAD: { 11219944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner SDOperand Op1, Op2; 11229944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner bool isIdx = SelectAddr(N->getOperand(1), Op1, Op2); 11239944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 11249944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner MVT::ValueType TypeBeingLoaded = (N->getOpcode() == ISD::LOAD) ? 11259944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner N->getValueType(0) : cast<VTSDNode>(N->getOperand(3))->getVT(); 11269944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner unsigned Opc; 11279944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner switch (TypeBeingLoaded) { 11289944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner default: N->dump(); assert(0 && "Cannot load this type!"); 11299944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i1: 11309944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i8: Opc = isIdx ? PPC::LBZX : PPC::LBZ; break; 11319944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i16: 11329944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (N->getOpcode() == ISD::SEXTLOAD) { // SEXT load? 11339944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Opc = isIdx ? PPC::LHAX : PPC::LHA; 11349944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 11359944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Opc = isIdx ? PPC::LHZX : PPC::LHZ; 11369944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 11379944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner break; 11389944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i32: Opc = isIdx ? PPC::LWZX : PPC::LWZ; break; 11399944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::f32: Opc = isIdx ? PPC::LFSX : PPC::LFS; break; 11409944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::f64: Opc = isIdx ? PPC::LFDX : PPC::LFD; break; 11419944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 11429944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 1143919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner // If this is an f32 -> f64 load, emit the f32 load, then use an 'extending 1144919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner // copy'. 1145919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (TypeBeingLoaded != MVT::f32 || N->getOpcode() == ISD::LOAD) { 1146919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CurDAG->SelectNodeTo(N, Opc, N->getValueType(0), MVT::Other, 1147919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner Op1, Op2, Select(N->getOperand(0))); 1148919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner return SDOperand(N, Op.ResNo); 1149919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner } else { 1150919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner std::vector<SDOperand> Ops; 1151919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner Ops.push_back(Op1); 1152919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner Ops.push_back(Op2); 1153919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner Ops.push_back(Select(N->getOperand(0))); 1154919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SDOperand Res = CurDAG->getTargetNode(Opc, MVT::f32, MVT::Other, Ops); 1155919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SDOperand Ext = CurDAG->getTargetNode(PPC::FMRSD, MVT::f64, Res); 1156919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CodeGenMap[Op.getValue(0)] = Ext; 1157919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CodeGenMap[Op.getValue(1)] = Res.getValue(1); 1158919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (Op.ResNo) 1159919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner return Res.getValue(1); 1160919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else 1161919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner return Ext; 1162919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner } 11639944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 1164f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case ISD::TRUNCSTORE: 1165f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case ISD::STORE: { 1166f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner SDOperand AddrOp1, AddrOp2; 1167f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner bool isIdx = SelectAddr(N->getOperand(2), AddrOp1, AddrOp2); 1168f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner 1169f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner unsigned Opc; 1170f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner if (N->getOpcode() == ISD::STORE) { 1171f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner switch (N->getOperand(1).getValueType()) { 1172f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner default: assert(0 && "unknown Type in store"); 1173f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::i32: Opc = isIdx ? PPC::STWX : PPC::STW; break; 1174f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::f64: Opc = isIdx ? PPC::STFDX : PPC::STFD; break; 1175f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::f32: Opc = isIdx ? PPC::STFSX : PPC::STFS; break; 1176f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 1177f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } else { //ISD::TRUNCSTORE 1178f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner switch(cast<VTSDNode>(N->getOperand(4))->getVT()) { 1179f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner default: assert(0 && "unknown Type in store"); 1180f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::i8: Opc = isIdx ? PPC::STBX : PPC::STB; break; 1181f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::i16: Opc = isIdx ? PPC::STHX : PPC::STH; break; 1182f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 1183f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 1184fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 11852bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Opc, MVT::Other, Select(N->getOperand(1)), 1186f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner AddrOp1, AddrOp2, Select(N->getOperand(0))); 118725dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 1188a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner } 118964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner 119013794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner case ISD::SELECT_CC: { 119113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(4))->get(); 119213794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner 119313794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner // handle the setcc cases here. select_cc lhs, 0, 1, 0, cc 119413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N->getOperand(1))) 119513794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N->getOperand(2))) 119613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N->getOperand(3))) 119713794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (N1C->isNullValue() && N3C->isNullValue() && 119813794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner N2C->getValue() == 1ULL && CC == ISD::SETNE) { 119913794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner SDOperand LHS = Select(N->getOperand(0)); 120013794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner SDOperand Tmp = 120113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 120213794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner LHS, getI32Imm(~0U)); 120313794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, Tmp, LHS, 120413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner Tmp.getValue(1)); 120525dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 120613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 12078a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 120850ff55c2c7909818165e51bbdc103a05b143dcb1Chris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 12098a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner unsigned BROpc = getBCCForSetCC(CC); 12108a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 12118a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner bool isFP = MVT::isFloatingPoint(N->getValueType(0)); 1212919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner unsigned SelectCCOp; 1213919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (MVT::isInteger(N->getValueType(0))) 1214919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_Int; 1215919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else if (N->getValueType(0) == MVT::f32) 1216919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F4; 1217919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else 1218919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F8; 12198a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner CurDAG->SelectNodeTo(N, SelectCCOp, N->getValueType(0), CCReg, 12208a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner Select(N->getOperand(2)), Select(N->getOperand(3)), 12218a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner getI32Imm(BROpc)); 122225dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 122313794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 122413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner 1225a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner case ISD::CALLSEQ_START: 1226a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner case ISD::CALLSEQ_END: { 1227a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner unsigned Amt = cast<ConstantSDNode>(N->getOperand(1))->getValue(); 1228a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner unsigned Opc = N->getOpcode() == ISD::CALLSEQ_START ? 1229a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner PPC::ADJCALLSTACKDOWN : PPC::ADJCALLSTACKUP; 12302bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Opc, MVT::Other, 1231fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner getI32Imm(Amt), Select(N->getOperand(0))); 123225dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 1233f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 1234a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::RET: { 1235a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Chain = Select(N->getOperand(0)); // Token chain. 1236a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 12377a49fdcd1136c26d9c60b19c087ca9d578cc9834Chris Lattner if (N->getNumOperands() == 2) { 1238a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Val = Select(N->getOperand(1)); 1239eb80fe8ff684121c8130db716fe4a7cb5ca3ac0dChris Lattner if (N->getOperand(1).getValueType() == MVT::i32) { 1240a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Chain = CurDAG->getCopyToReg(Chain, PPC::R3, Val); 1241eb80fe8ff684121c8130db716fe4a7cb5ca3ac0dChris Lattner } else { 1242eb80fe8ff684121c8130db716fe4a7cb5ca3ac0dChris Lattner assert(MVT::isFloatingPoint(N->getOperand(1).getValueType())); 1243eb80fe8ff684121c8130db716fe4a7cb5ca3ac0dChris Lattner Chain = CurDAG->getCopyToReg(Chain, PPC::F1, Val); 1244a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 12457a49fdcd1136c26d9c60b19c087ca9d578cc9834Chris Lattner } else if (N->getNumOperands() > 1) { 12467a49fdcd1136c26d9c60b19c087ca9d578cc9834Chris Lattner assert(N->getOperand(1).getValueType() == MVT::i32 && 12477a49fdcd1136c26d9c60b19c087ca9d578cc9834Chris Lattner N->getOperand(2).getValueType() == MVT::i32 && 12487a49fdcd1136c26d9c60b19c087ca9d578cc9834Chris Lattner N->getNumOperands() == 3 && "Unknown two-register ret value!"); 12497a49fdcd1136c26d9c60b19c087ca9d578cc9834Chris Lattner Chain = CurDAG->getCopyToReg(Chain, PPC::R4, Select(N->getOperand(1))); 12507a49fdcd1136c26d9c60b19c087ca9d578cc9834Chris Lattner Chain = CurDAG->getCopyToReg(Chain, PPC::R3, Select(N->getOperand(2))); 1251a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 1252a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1253a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Finally, select this to a blr (return) instruction. 12542bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::BLR, MVT::Other, Chain); 125525dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 1256a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 125789532c7db03543402dd5376172b87233575beb44Chris Lattner case ISD::BR: 12582bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::B, MVT::Other, N->getOperand(1), 125989532c7db03543402dd5376172b87233575beb44Chris Lattner Select(N->getOperand(0))); 126025dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 12612fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::BR_CC: 12622fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::BRTWOWAY_CC: { 12632fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand Chain = Select(N->getOperand(0)); 12642fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner MachineBasicBlock *Dest = 12652fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner cast<BasicBlockSDNode>(N->getOperand(4))->getBasicBlock(); 12662fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(1))->get(); 12672fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CondCode = SelectCC(N->getOperand(2), N->getOperand(3), CC); 12682fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 12692fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // If this is a two way branch, then grab the fallthrough basic block 12702fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // argument and build a PowerPC branch pseudo-op, suitable for long branch 12712fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // conversion if necessary by the branch selection pass. Otherwise, emit a 12722fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // standard conditional branch. 12732fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (N->getOpcode() == ISD::BRTWOWAY_CC) { 1274ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner SDOperand CondTrueBlock = N->getOperand(4); 1275ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner SDOperand CondFalseBlock = N->getOperand(5); 1276ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner 1277ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner // If the false case is the current basic block, then this is a self loop. 1278ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner // We do not want to emit "Loop: ... brcond Out; br Loop", as it adds an 1279ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner // extra dispatch group to the loop. Instead, invert the condition and 1280ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner // emit "Loop: ... br!cond Loop; br Out 1281ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner if (cast<BasicBlockSDNode>(CondFalseBlock)->getBasicBlock() == BB) { 1282ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner std::swap(CondTrueBlock, CondFalseBlock); 1283ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner CC = getSetCCInverse(CC, 1284ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner MVT::isInteger(N->getOperand(2).getValueType())); 1285ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner } 1286ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner 1287ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner unsigned Opc = getBCCForSetCC(CC); 12882fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CB = CurDAG->getTargetNode(PPC::COND_BRANCH, MVT::Other, 12892fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner CondCode, getI32Imm(Opc), 1290ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner CondTrueBlock, CondFalseBlock, 12912fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner Chain); 1292ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner CurDAG->SelectNodeTo(N, PPC::B, MVT::Other, CondFalseBlock, CB); 12932fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 12942fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Iterate to the next basic block 12952fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ilist<MachineBasicBlock>::iterator It = BB; 12962fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ++It; 12972fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 12982fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // If the fallthrough path is off the end of the function, which would be 12992fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // undefined behavior, set it to be the same as the current block because 13002fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // we have nothing better to set it to, and leaving it alone will cause 13012fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // the PowerPC Branch Selection pass to crash. 13022fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (It == BB->getParent()->end()) It = Dest; 13032bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::COND_BRANCH, MVT::Other, CondCode, 1304ca0a4778a8e3036df7e51ed375cc867e6bf024bdChris Lattner getI32Imm(getBCCForSetCC(CC)), N->getOperand(4), 13052fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner CurDAG->getBasicBlock(It), Chain); 13062fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 130725dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 13082fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 1309a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 131025dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner 131119c0907ba1c11c81dc231cf7b4143fdaf03466e4Chris Lattner return SelectCode(Op); 1312a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1313a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1314a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 13151d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman/// createPPCISelDag - This pass converts a legalized DAG into a 1316a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// PowerPC-specific DAG, ready for instruction scheduling. 1317a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// 13181d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanFunctionPass *llvm::createPPCISelDag(TargetMachine &TM) { 13191d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman return new PPCDAGToDAGISel(TM); 1320a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1321a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1322