PPCISelDAGToDAG.cpp revision 919c032fa4511468aadc6f50d6ed9c50890710b3
1a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner//===-- PPC32ISelDAGToDAG.cpp - PPC32 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// 10a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// This file defines a pattern matching instruction selector for 32 bit PowerPC, 11a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// converting from a legalized dag to a PPC dag. 12a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 13a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner//===----------------------------------------------------------------------===// 14a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 15a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "PowerPC.h" 16a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "PPC32TargetMachine.h" 17a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "PPC32ISelLowering.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 //===--------------------------------------------------------------------===// 36a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// PPC32DAGToDAGISel - PPC32 specific code to select PPC32 machine 37a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// instructions for SelectionDAG operations. 38a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// 39a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner class PPC32DAGToDAGISel : public SelectionDAGISel { 40a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner PPC32TargetLowering PPC32Lowering; 414416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner unsigned GlobalBaseReg; 42a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner public: 43a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner PPC32DAGToDAGISel(TargetMachine &TM) 44a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner : SelectionDAGISel(PPC32Lowering), PPC32Lowering(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 66a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDNode *SelectIntImmediateExpr(SDOperand LHS, SDOperand RHS, 67a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned OCHi, unsigned OCLo, 68a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner bool IsArithmetic = false, 69a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner bool Negate = false); 7002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDNode *SelectBitfieldInsert(SDNode *N); 7102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 722fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// SelectCC - Select a comparison of the specified values with the 732fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// specified condition code, returning the CR# of the expression. 742fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand SelectCC(SDOperand LHS, SDOperand RHS, ISD::CondCode CC); 752fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 769944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner /// SelectAddr - Given the specified address, return the two operands for a 779944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner /// load/store instruction, and return true if it should be an indexed [r+r] 789944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner /// operation. 799944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner bool SelectAddr(SDOperand Addr, SDOperand &Op1, SDOperand &Op2); 809944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 81047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand BuildSDIVSequence(SDNode *N); 82047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand BuildUDIVSequence(SDNode *N); 83047b952e298352fe6feffedf02e359601133f465Chris Lattner 84a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// InstructionSelectBasicBlock - This callback is invoked by 85a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 86a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner virtual void InstructionSelectBasicBlock(SelectionDAG &DAG) { 87a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner DEBUG(BB->dump()); 88d607c12e8e8533028a66c9f533007c6c32a64cefChris Lattner // Select target instructions for the DAG. 89efa6abcb957b9002a7e6708eb6f7885a93957ea7Chris Lattner DAG.setRoot(Select(DAG.getRoot())); 90333bd835bd0d01f0e49b2f3d590be685a4959e16Chris Lattner CodeGenMap.clear(); 91a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner DAG.RemoveDeadNodes(); 92d607c12e8e8533028a66c9f533007c6c32a64cefChris Lattner 93d607c12e8e8533028a66c9f533007c6c32a64cefChris Lattner // Emit machine code to BB. 94d607c12e8e8533028a66c9f533007c6c32a64cefChris Lattner ScheduleAndEmitDAG(DAG); 95a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 96a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 97a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner virtual const char *getPassName() const { 98a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return "PowerPC DAG->DAG Pattern Instruction Selection"; 99a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 100af165385112037cb942e94ea562a67990b7d6220Chris Lattner 101af165385112037cb942e94ea562a67990b7d6220Chris Lattner// Include the pieces autogenerated from the target description. 102af165385112037cb942e94ea562a67990b7d6220Chris Lattner#include "PPC32GenDAGISel.inc" 103a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner }; 104a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 105a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1066cd40d5888f905a3820d5d6c71e57cc0e02abb4aChris Lattner 1074416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// getGlobalBaseReg - Output the instructions required to put the 1084416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// base address to use for accessing globals into a register. 1094416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// 1109944b76cfe74981d2c41c8237d25267ba0c467c7Chris LattnerSDOperand PPC32DAGToDAGISel::getGlobalBaseReg() { 1114416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (!GlobalBaseReg) { 1124416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Insert the set of GlobalBaseReg into the first MBB of the function 1134416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock &FirstMBB = BB->getParent()->front(); 1144416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock::iterator MBBI = FirstMBB.begin(); 1154416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SSARegMap *RegMap = BB->getParent()->getSSARegMap(); 1164416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalBaseReg = RegMap->createVirtualRegister(PPC32::GPRCRegisterClass); 1174416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MovePCtoLR, 0, PPC::LR); 1184416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MFLR, 1, GlobalBaseReg); 1194416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 1209944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return CurDAG->getRegister(GlobalBaseReg, MVT::i32); 1214416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner} 1224416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 1234416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 1240f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isIntImmediate - This method tests to see if a constant operand. 1250f3257a3302b60c128a667db6736e81335316c1eNate Begeman// If so Imm will receive the 32 bit value. 1260f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isIntImmediate(SDNode *N, unsigned& Imm) { 1270f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (N->getOpcode() == ISD::Constant) { 1280f3257a3302b60c128a667db6736e81335316c1eNate Begeman Imm = cast<ConstantSDNode>(N)->getValue(); 1290f3257a3302b60c128a667db6736e81335316c1eNate Begeman return true; 1300f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 1310f3257a3302b60c128a667db6736e81335316c1eNate Begeman return false; 1320f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 1330f3257a3302b60c128a667db6736e81335316c1eNate Begeman 134cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isOprShiftImm - Returns true if the specified operand is a shift opcode with 135cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// a immediate shift count less than 32. 136cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isOprShiftImm(SDNode *N, unsigned& Opc, unsigned& SH) { 137cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Opc = N->getOpcode(); 138cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return (Opc == ISD::SHL || Opc == ISD::SRL || Opc == ISD::SRA) && 139cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isIntImmediate(N->getOperand(1).Val, SH) && SH < 32; 140cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 141cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 142cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s with 143cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// any number of 0s on either side. The 1s are allowed to wrap from LSB to 144cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 0x0F0F0000 is 145cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// not, since all 1s are not contiguous. 146cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME) { 147cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isShiftedMask_32(Val)) { 148cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first non-zero bit 149cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman MB = CountLeadingZeros_32(Val); 150cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first zero bit after the run of ones 151cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman ME = CountLeadingZeros_32((Val - 1) ^ Val); 152cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return true; 1532fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } else { 1542fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner Val = ~Val; // invert mask 1552fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner if (isShiftedMask_32(Val)) { 1562fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first zero bit 1572fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner ME = CountLeadingZeros_32(Val) - 1; 1582fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first one bit after the run of zeros 1592fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner MB = CountLeadingZeros_32((Val - 1) ^ Val) + 1; 1602fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner return true; 1612fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } 162cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 163cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // no run present 164cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 165cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 166cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 167cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isRotateAndMask - Returns true if Mask and Shift can be folded in to a rotate 168cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// and mask opcode and mask operation. 169cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRotateAndMask(SDNode *N, unsigned Mask, bool IsShiftMask, 170cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned &SH, unsigned &MB, unsigned &ME) { 171cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Shift = 32; 172cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Indeterminant = ~0; // bit mask marking indeterminant results 173cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Opcode = N->getOpcode(); 17415055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner if (N->getNumOperands() != 2 || 17515055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner !isIntImmediate(N->getOperand(1).Val, Shift) || (Shift > 31)) 176cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 177cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 178cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Opcode == ISD::SHL) { 179cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift left to mask if it comes first 180cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask << Shift; 181cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 182cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu << Shift); 183cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else if (Opcode == ISD::SRA || Opcode == ISD::SRL) { 184cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift right to mask if it comes first 185cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask >> Shift; 186cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 187cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu >> Shift); 188cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // adjust for the left rotate 189cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Shift = 32 - Shift; 190cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 191cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 192cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 193cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 194cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // if the mask doesn't intersect any Indeterminant bits 195cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Mask && !(Mask & Indeterminant)) { 196cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = Shift; 197cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // make sure the mask is still a mask (wrap arounds may not be) 198cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return isRunOfOnes(Mask, MB, ME); 199cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 200cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 201cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 202cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 2030f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isOpcWithIntImmediate - This method tests to see if the node is a specific 2040f3257a3302b60c128a667db6736e81335316c1eNate Begeman// opcode and that it has a immediate integer right operand. 2050f3257a3302b60c128a667db6736e81335316c1eNate Begeman// If so Imm will receive the 32 bit value. 2060f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isOpcWithIntImmediate(SDNode *N, unsigned Opc, unsigned& Imm) { 2070f3257a3302b60c128a667db6736e81335316c1eNate Begeman return N->getOpcode() == Opc && isIntImmediate(N->getOperand(1).Val, Imm); 2080f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 2090f3257a3302b60c128a667db6736e81335316c1eNate Begeman 2100f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isOprNot - Returns true if the specified operand is an xor with immediate -1. 2110f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isOprNot(SDNode *N) { 2120f3257a3302b60c128a667db6736e81335316c1eNate Begeman unsigned Imm; 2130f3257a3302b60c128a667db6736e81335316c1eNate Begeman return isOpcWithIntImmediate(N, ISD::XOR, Imm) && (signed)Imm == -1; 2140f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 2150f3257a3302b60c128a667db6736e81335316c1eNate Begeman 216a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Immediate constant composers. 217a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Lo16 - grabs the lo 16 bits from a 32 bit constant. 218a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Hi16 - grabs the hi 16 bits from a 32 bit constant. 219a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// HA16 - computes the hi bits required if the lo bits are add/subtracted in 220a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// arithmethically. 221a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic unsigned Lo16(unsigned x) { return x & 0x0000FFFF; } 222a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic unsigned Hi16(unsigned x) { return Lo16(x >> 16); } 223a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic unsigned HA16(unsigned x) { return Hi16((signed)x - (signed short)x); } 224a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 225a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// isIntImmediate - This method tests to see if a constant operand. 226a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// If so Imm will receive the 32 bit value. 227a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic bool isIntImmediate(SDOperand N, unsigned& Imm) { 228a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 229a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Imm = (unsigned)CN->getSignExtended(); 230a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return true; 231a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 232a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return false; 233a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 234a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 23502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// SelectBitfieldInsert - turn an or of two masked values into 23602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// the rotate left word immediate then mask insert (rlwimi) instruction. 23702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// Returns true on success, false if the caller still needs to select OR. 23802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 23902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// Patterns matched: 24002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 1. or shl, and 5. or and, and 24102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 2. or and, shl 6. or shl, shr 24202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 3. or shr, and 7. or shr, shl 24302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 4. or and, shr 24402b88a4586704f34bc65afca3348453eae69d1d3Nate BegemanSDNode *PPC32DAGToDAGISel::SelectBitfieldInsert(SDNode *N) { 24502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool IsRotate = false; 24602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned TgtMask = 0xFFFFFFFF, InsMask = 0xFFFFFFFF, SH = 0; 24702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Value; 24802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 24902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op0 = N->getOperand(0); 25002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op1 = N->getOperand(1); 25102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 25202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Op0Opc = Op0.getOpcode(); 25302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Op1Opc = Op1.getOpcode(); 25402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 25502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Verify that we have the correct opcodes 25602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (ISD::SHL != Op0Opc && ISD::SRL != Op0Opc && ISD::AND != Op0Opc) 25702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return false; 25802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (ISD::SHL != Op1Opc && ISD::SRL != Op1Opc && ISD::AND != Op1Opc) 25902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return false; 26002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 26102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Generate Mask value for Target 26202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op0.getOperand(1), Value)) { 26302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman switch(Op0Opc) { 2641368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SHL: TgtMask <<= Value; break; 2651368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SRL: TgtMask >>= Value; break; 2661368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::AND: TgtMask &= Value; break; 26702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 26802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } else { 26902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 27002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 27102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 27202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Generate Mask value for Insert 2731368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner if (!isIntImmediate(Op1.getOperand(1), Value)) 27402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 2751368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner 2761368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner switch(Op1Opc) { 2771368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SHL: 2781368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner SH = Value; 2791368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner InsMask <<= SH; 2801368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner if (Op0Opc == ISD::SRL) IsRotate = true; 2811368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner break; 2821368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SRL: 2831368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner SH = Value; 2841368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner InsMask >>= SH; 2851368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner SH = 32-SH; 2861368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner if (Op0Opc == ISD::SHL) IsRotate = true; 2871368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner break; 2881368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::AND: 2891368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner InsMask &= Value; 2901368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner break; 29102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 29202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 29302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // If both of the inputs are ANDs and one of them has a logical shift by 29402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // constant as its input, make that AND the inserted value so that we can 29502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // combine the shift into the rotate part of the rlwimi instruction 29602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool IsAndWithShiftOp = false; 29702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op0Opc == ISD::AND && Op1Opc == ISD::AND) { 29802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op1.getOperand(0).getOpcode() == ISD::SHL || 29902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op1.getOperand(0).getOpcode() == ISD::SRL) { 30002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op1.getOperand(0).getOperand(1), Value)) { 30102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Op1.getOperand(0).getOpcode() == ISD::SHL ? Value : 32 - Value; 30202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman IsAndWithShiftOp = true; 30302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 30402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } else if (Op0.getOperand(0).getOpcode() == ISD::SHL || 30502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0.getOperand(0).getOpcode() == ISD::SRL) { 30602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op0.getOperand(0).getOperand(1), Value)) { 30702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman std::swap(Op0, Op1); 30802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman std::swap(TgtMask, InsMask); 30902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Op1.getOperand(0).getOpcode() == ISD::SHL ? Value : 32 - Value; 31002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman IsAndWithShiftOp = true; 31102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 31202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 31302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 31402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 31502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Verify that the Target mask and Insert mask together form a full word mask 31602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // and that the Insert mask is a run of set bits (which implies both are runs 31702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // of set bits). Given that, Select the arguments and generate the rlwimi 31802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // instruction. 31902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned MB, ME; 32002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (((TgtMask & InsMask) == 0) && isRunOfOnes(InsMask, MB, ME)) { 32102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool fullMask = (TgtMask ^ InsMask) == 0xFFFFFFFF; 32202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool Op0IsAND = Op0Opc == ISD::AND; 32302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Check for rotlwi / rotrwi here, a special case of bitfield insert 32402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // where both bitfield halves are sourced from the same value. 32502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (IsRotate && fullMask && 32602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman N->getOperand(0).getOperand(0) == N->getOperand(1).getOperand(0)) { 32702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0 = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, 32802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Select(N->getOperand(0).getOperand(0)), 32902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman getI32Imm(SH), getI32Imm(0), getI32Imm(31)); 33002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return Op0.Val; 33102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 33202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Tmp1 = (Op0IsAND && fullMask) ? Select(Op0.getOperand(0)) 33302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman : Select(Op0); 33402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Tmp2 = IsAndWithShiftOp ? Select(Op1.getOperand(0).getOperand(0)) 33502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman : Select(Op1.getOperand(0)); 33602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0 = CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, Tmp1, Tmp2, 33702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 33802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return Op0.Val; 33902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 34002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 34102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman} 34202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 343a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// SelectIntImmediateExpr - Choose code for integer operations with an immediate 344a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// operand. 345a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris LattnerSDNode *PPC32DAGToDAGISel::SelectIntImmediateExpr(SDOperand LHS, SDOperand RHS, 346a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned OCHi, unsigned OCLo, 347a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner bool IsArithmetic, 348a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner bool Negate) { 349a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Check to make sure this is a constant. 350a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ConstantSDNode *CN = dyn_cast<ConstantSDNode>(RHS); 351a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Exit if not a constant. 352a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (!CN) return 0; 353a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Extract immediate. 354a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned C = (unsigned)CN->getValue(); 355a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Negate if required (ISD::SUB). 356a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Negate) C = -C; 357a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Get the hi and lo portions of constant. 358a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned Hi = IsArithmetic ? HA16(C) : Hi16(C); 359a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned Lo = Lo16(C); 360a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 361a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // If two instructions are needed and usage indicates it would be better to 362a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // load immediate into a register, bail out. 363a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Hi && Lo && CN->use_size() > 2) return false; 364a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 365a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Select the first operand. 366a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Opr0 = Select(LHS); 367a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 368a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Lo) // Add in the lo-part. 369a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Opr0 = CurDAG->getTargetNode(OCLo, MVT::i32, Opr0, getI32Imm(Lo)); 370a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Hi) // Add in the hi-part. 371a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Opr0 = CurDAG->getTargetNode(OCHi, MVT::i32, Opr0, getI32Imm(Hi)); 372a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return Opr0.Val; 373a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 374a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 3759944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner/// SelectAddr - Given the specified address, return the two operands for a 3769944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner/// load/store instruction, and return true if it should be an indexed [r+r] 3779944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner/// operation. 3789944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattnerbool PPC32DAGToDAGISel::SelectAddr(SDOperand Addr, SDOperand &Op1, 3799944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner SDOperand &Op2) { 3809944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner unsigned imm = 0; 3819944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (Addr.getOpcode() == ISD::ADD) { 3829944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (isIntImmediate(Addr.getOperand(1), imm) && isInt16(imm)) { 3839944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = getI32Imm(Lo16(imm)); 384e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner if (FrameIndexSDNode *FI = 385e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner dyn_cast<FrameIndexSDNode>(Addr.getOperand(0))) { 3869944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner ++FrameOff; 387e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner Op2 = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 3889944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 3899944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = Select(Addr.getOperand(0)); 3909944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 3919944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 3929944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 3939944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = Select(Addr.getOperand(0)); 3949944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = Select(Addr.getOperand(1)); 3959944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return true; // [r+r] 3969944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 3979944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 3989944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 3999944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner // Now check if we're dealing with a global, and whether or not we should emit 4009944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner // an optimized load or store for statics. 4019944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (GlobalAddressSDNode *GN = dyn_cast<GlobalAddressSDNode>(Addr)) { 4029944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner GlobalValue *GV = GN->getGlobal(); 4039944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (!GV->hasWeakLinkage() && !GV->isExternal()) { 4049944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = CurDAG->getTargetGlobalAddress(GV, MVT::i32); 4059944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (PICEnabled) 4069944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(), 4079944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1); 4089944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner else 4099944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::LIS, MVT::i32, Op1); 4109944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4119944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 412e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } else if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Addr)) { 4139944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = getI32Imm(0); 414e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner Op2 = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 4159944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4169944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Addr)) { 4179944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = Addr; 4189944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (PICEnabled) 4199944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(),Op1); 4209944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner else 4219944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::LIS, MVT::i32, Op1); 4229944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4239944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4249944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = getI32Imm(0); 4259944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = Select(Addr); 4269944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4279944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner} 428a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 4292fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// SelectCC - Select a comparison of the specified values with the specified 4302fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// condition code, returning the CR# of the expression. 4312fbb4579d6d6bbde8387283b78307c2ea477a312Chris LattnerSDOperand PPC32DAGToDAGISel::SelectCC(SDOperand LHS, SDOperand RHS, 4322fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC) { 4332fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Always select the LHS. 4342fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner LHS = Select(LHS); 4352fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 4362fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Use U to determine whether the SETCC immediate range is signed or not. 4372fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (MVT::isInteger(LHS.getValueType())) { 4382fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner bool U = ISD::isUnsignedIntSetCC(CC); 4392fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner unsigned Imm; 4402fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (isIntImmediate(RHS, Imm) && 4412fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ((U && isUInt16(Imm)) || (!U && isInt16(Imm)))) 4422fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return CurDAG->getTargetNode(U ? PPC::CMPLWI : PPC::CMPWI, MVT::i32, 4432fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner LHS, getI32Imm(Lo16(Imm))); 4442fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return CurDAG->getTargetNode(U ? PPC::CMPLW : PPC::CMPW, MVT::i32, 4452fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner LHS, Select(RHS)); 446919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner } else if (LHS.getValueType() == MVT::f32) { 447919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner return CurDAG->getTargetNode(PPC::FCMPUS, MVT::i32, LHS, Select(RHS)); 4482fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 449919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner return CurDAG->getTargetNode(PPC::FCMPUD, MVT::i32, LHS, Select(RHS)); 4502fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 4512fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 4522fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 4532fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// getBCCForSetCC - Returns the PowerPC condition branch mnemonic corresponding 4542fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// to Condition. 4552fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattnerstatic unsigned getBCCForSetCC(ISD::CondCode CC) { 4562fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner switch (CC) { 4572fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 4582fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETEQ: return PPC::BEQ; 4592fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETNE: return PPC::BNE; 4602fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULT: 4612fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLT: return PPC::BLT; 4622fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULE: 4632fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLE: return PPC::BLE; 4642fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGT: 4652fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGT: return PPC::BGT; 4662fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGE: 4672fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGE: return PPC::BGE; 4682fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 4692fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return 0; 4702fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 4712fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 47264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// getCRIdxForSetCC - Return the index of the condition register field 47364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// associated with the SetCC condition, and whether or not the field is 47464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// treated as inverted. That is, lt = 0; ge = 0 inverted. 47564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattnerstatic unsigned getCRIdxForSetCC(ISD::CondCode CC, bool& Inv) { 47664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 47764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 47864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULT: 47964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLT: Inv = false; return 0; 48064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGE: 48164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGE: Inv = true; return 0; 48264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGT: 48364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGT: Inv = false; return 1; 48464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULE: 48564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLE: Inv = true; return 1; 48664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETEQ: Inv = false; return 2; 48764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETNE: Inv = true; return 2; 48864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 48964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner return 0; 49064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner} 4919944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 492047b952e298352fe6feffedf02e359601133f465Chris Lattner// Structure used to return the necessary information to codegen an SDIV as 493047b952e298352fe6feffedf02e359601133f465Chris Lattner// a multiply. 494047b952e298352fe6feffedf02e359601133f465Chris Lattnerstruct ms { 495047b952e298352fe6feffedf02e359601133f465Chris Lattner int m; // magic number 496047b952e298352fe6feffedf02e359601133f465Chris Lattner int s; // shift amount 497047b952e298352fe6feffedf02e359601133f465Chris Lattner}; 498047b952e298352fe6feffedf02e359601133f465Chris Lattner 499047b952e298352fe6feffedf02e359601133f465Chris Lattnerstruct mu { 500047b952e298352fe6feffedf02e359601133f465Chris Lattner unsigned int m; // magic number 501047b952e298352fe6feffedf02e359601133f465Chris Lattner int a; // add indicator 502047b952e298352fe6feffedf02e359601133f465Chris Lattner int s; // shift amount 503047b952e298352fe6feffedf02e359601133f465Chris Lattner}; 504047b952e298352fe6feffedf02e359601133f465Chris Lattner 505047b952e298352fe6feffedf02e359601133f465Chris Lattner/// magic - calculate the magic numbers required to codegen an integer sdiv as 506047b952e298352fe6feffedf02e359601133f465Chris Lattner/// a sequence of multiply and shifts. Requires that the divisor not be 0, 1, 507047b952e298352fe6feffedf02e359601133f465Chris Lattner/// or -1. 508047b952e298352fe6feffedf02e359601133f465Chris Lattnerstatic struct ms magic(int d) { 509047b952e298352fe6feffedf02e359601133f465Chris Lattner int p; 510047b952e298352fe6feffedf02e359601133f465Chris Lattner unsigned int ad, anc, delta, q1, r1, q2, r2, t; 511047b952e298352fe6feffedf02e359601133f465Chris Lattner const unsigned int two31 = 0x80000000U; 512047b952e298352fe6feffedf02e359601133f465Chris Lattner struct ms mag; 513047b952e298352fe6feffedf02e359601133f465Chris Lattner 514047b952e298352fe6feffedf02e359601133f465Chris Lattner ad = abs(d); 515047b952e298352fe6feffedf02e359601133f465Chris Lattner t = two31 + ((unsigned int)d >> 31); 516047b952e298352fe6feffedf02e359601133f465Chris Lattner anc = t - 1 - t%ad; // absolute value of nc 517047b952e298352fe6feffedf02e359601133f465Chris Lattner p = 31; // initialize p 518047b952e298352fe6feffedf02e359601133f465Chris Lattner q1 = two31/anc; // initialize q1 = 2p/abs(nc) 519047b952e298352fe6feffedf02e359601133f465Chris Lattner r1 = two31 - q1*anc; // initialize r1 = rem(2p,abs(nc)) 520047b952e298352fe6feffedf02e359601133f465Chris Lattner q2 = two31/ad; // initialize q2 = 2p/abs(d) 521047b952e298352fe6feffedf02e359601133f465Chris Lattner r2 = two31 - q2*ad; // initialize r2 = rem(2p,abs(d)) 522047b952e298352fe6feffedf02e359601133f465Chris Lattner do { 523047b952e298352fe6feffedf02e359601133f465Chris Lattner p = p + 1; 524047b952e298352fe6feffedf02e359601133f465Chris Lattner q1 = 2*q1; // update q1 = 2p/abs(nc) 525047b952e298352fe6feffedf02e359601133f465Chris Lattner r1 = 2*r1; // update r1 = rem(2p/abs(nc)) 526047b952e298352fe6feffedf02e359601133f465Chris Lattner if (r1 >= anc) { // must be unsigned comparison 527047b952e298352fe6feffedf02e359601133f465Chris Lattner q1 = q1 + 1; 528047b952e298352fe6feffedf02e359601133f465Chris Lattner r1 = r1 - anc; 529047b952e298352fe6feffedf02e359601133f465Chris Lattner } 530047b952e298352fe6feffedf02e359601133f465Chris Lattner q2 = 2*q2; // update q2 = 2p/abs(d) 531047b952e298352fe6feffedf02e359601133f465Chris Lattner r2 = 2*r2; // update r2 = rem(2p/abs(d)) 532047b952e298352fe6feffedf02e359601133f465Chris Lattner if (r2 >= ad) { // must be unsigned comparison 533047b952e298352fe6feffedf02e359601133f465Chris Lattner q2 = q2 + 1; 534047b952e298352fe6feffedf02e359601133f465Chris Lattner r2 = r2 - ad; 535047b952e298352fe6feffedf02e359601133f465Chris Lattner } 536047b952e298352fe6feffedf02e359601133f465Chris Lattner delta = ad - r2; 537047b952e298352fe6feffedf02e359601133f465Chris Lattner } while (q1 < delta || (q1 == delta && r1 == 0)); 538047b952e298352fe6feffedf02e359601133f465Chris Lattner 539047b952e298352fe6feffedf02e359601133f465Chris Lattner mag.m = q2 + 1; 540047b952e298352fe6feffedf02e359601133f465Chris Lattner if (d < 0) mag.m = -mag.m; // resulting magic number 541047b952e298352fe6feffedf02e359601133f465Chris Lattner mag.s = p - 32; // resulting shift 542047b952e298352fe6feffedf02e359601133f465Chris Lattner return mag; 543047b952e298352fe6feffedf02e359601133f465Chris Lattner} 544047b952e298352fe6feffedf02e359601133f465Chris Lattner 545047b952e298352fe6feffedf02e359601133f465Chris Lattner/// magicu - calculate the magic numbers required to codegen an integer udiv as 546047b952e298352fe6feffedf02e359601133f465Chris Lattner/// a sequence of multiply, add and shifts. Requires that the divisor not be 0. 547047b952e298352fe6feffedf02e359601133f465Chris Lattnerstatic struct mu magicu(unsigned d) 548047b952e298352fe6feffedf02e359601133f465Chris Lattner{ 549047b952e298352fe6feffedf02e359601133f465Chris Lattner int p; 550047b952e298352fe6feffedf02e359601133f465Chris Lattner unsigned int nc, delta, q1, r1, q2, r2; 551047b952e298352fe6feffedf02e359601133f465Chris Lattner struct mu magu; 552047b952e298352fe6feffedf02e359601133f465Chris Lattner magu.a = 0; // initialize "add" indicator 553047b952e298352fe6feffedf02e359601133f465Chris Lattner nc = - 1 - (-d)%d; 554047b952e298352fe6feffedf02e359601133f465Chris Lattner p = 31; // initialize p 555047b952e298352fe6feffedf02e359601133f465Chris Lattner q1 = 0x80000000/nc; // initialize q1 = 2p/nc 556047b952e298352fe6feffedf02e359601133f465Chris Lattner r1 = 0x80000000 - q1*nc; // initialize r1 = rem(2p,nc) 557047b952e298352fe6feffedf02e359601133f465Chris Lattner q2 = 0x7FFFFFFF/d; // initialize q2 = (2p-1)/d 558047b952e298352fe6feffedf02e359601133f465Chris Lattner r2 = 0x7FFFFFFF - q2*d; // initialize r2 = rem((2p-1),d) 559047b952e298352fe6feffedf02e359601133f465Chris Lattner do { 560047b952e298352fe6feffedf02e359601133f465Chris Lattner p = p + 1; 561047b952e298352fe6feffedf02e359601133f465Chris Lattner if (r1 >= nc - r1 ) { 562047b952e298352fe6feffedf02e359601133f465Chris Lattner q1 = 2*q1 + 1; // update q1 563047b952e298352fe6feffedf02e359601133f465Chris Lattner r1 = 2*r1 - nc; // update r1 564047b952e298352fe6feffedf02e359601133f465Chris Lattner } 565047b952e298352fe6feffedf02e359601133f465Chris Lattner else { 566047b952e298352fe6feffedf02e359601133f465Chris Lattner q1 = 2*q1; // update q1 567047b952e298352fe6feffedf02e359601133f465Chris Lattner r1 = 2*r1; // update r1 568047b952e298352fe6feffedf02e359601133f465Chris Lattner } 569047b952e298352fe6feffedf02e359601133f465Chris Lattner if (r2 + 1 >= d - r2) { 570047b952e298352fe6feffedf02e359601133f465Chris Lattner if (q2 >= 0x7FFFFFFF) magu.a = 1; 571047b952e298352fe6feffedf02e359601133f465Chris Lattner q2 = 2*q2 + 1; // update q2 572047b952e298352fe6feffedf02e359601133f465Chris Lattner r2 = 2*r2 + 1 - d; // update r2 573047b952e298352fe6feffedf02e359601133f465Chris Lattner } 574047b952e298352fe6feffedf02e359601133f465Chris Lattner else { 575047b952e298352fe6feffedf02e359601133f465Chris Lattner if (q2 >= 0x80000000) magu.a = 1; 576047b952e298352fe6feffedf02e359601133f465Chris Lattner q2 = 2*q2; // update q2 577047b952e298352fe6feffedf02e359601133f465Chris Lattner r2 = 2*r2 + 1; // update r2 578047b952e298352fe6feffedf02e359601133f465Chris Lattner } 579047b952e298352fe6feffedf02e359601133f465Chris Lattner delta = d - 1 - r2; 580047b952e298352fe6feffedf02e359601133f465Chris Lattner } while (p < 64 && (q1 < delta || (q1 == delta && r1 == 0))); 581047b952e298352fe6feffedf02e359601133f465Chris Lattner magu.m = q2 + 1; // resulting magic number 582047b952e298352fe6feffedf02e359601133f465Chris Lattner magu.s = p - 32; // resulting shift 583047b952e298352fe6feffedf02e359601133f465Chris Lattner return magu; 584047b952e298352fe6feffedf02e359601133f465Chris Lattner} 585047b952e298352fe6feffedf02e359601133f465Chris Lattner 586047b952e298352fe6feffedf02e359601133f465Chris Lattner/// BuildSDIVSequence - Given an ISD::SDIV node expressing a divide by constant, 587047b952e298352fe6feffedf02e359601133f465Chris Lattner/// return a DAG expression to select that will generate the same value by 588047b952e298352fe6feffedf02e359601133f465Chris Lattner/// multiplying by a magic number. See: 589047b952e298352fe6feffedf02e359601133f465Chris Lattner/// <http://the.wall.riscom.net/books/proc/ppc/cwg/code2.html> 590047b952e298352fe6feffedf02e359601133f465Chris LattnerSDOperand PPC32DAGToDAGISel::BuildSDIVSequence(SDNode *N) { 591047b952e298352fe6feffedf02e359601133f465Chris Lattner int d = (int)cast<ConstantSDNode>(N->getOperand(1))->getValue(); 592047b952e298352fe6feffedf02e359601133f465Chris Lattner ms magics = magic(d); 593047b952e298352fe6feffedf02e359601133f465Chris Lattner // Multiply the numerator (operand 0) by the magic value 594047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand Q = CurDAG->getNode(ISD::MULHS, MVT::i32, N->getOperand(0), 595047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->getConstant(magics.m, MVT::i32)); 596047b952e298352fe6feffedf02e359601133f465Chris Lattner // If d > 0 and m < 0, add the numerator 597047b952e298352fe6feffedf02e359601133f465Chris Lattner if (d > 0 && magics.m < 0) 598047b952e298352fe6feffedf02e359601133f465Chris Lattner Q = CurDAG->getNode(ISD::ADD, MVT::i32, Q, N->getOperand(0)); 599047b952e298352fe6feffedf02e359601133f465Chris Lattner // If d < 0 and m > 0, subtract the numerator. 600047b952e298352fe6feffedf02e359601133f465Chris Lattner if (d < 0 && magics.m > 0) 601047b952e298352fe6feffedf02e359601133f465Chris Lattner Q = CurDAG->getNode(ISD::SUB, MVT::i32, Q, N->getOperand(0)); 602047b952e298352fe6feffedf02e359601133f465Chris Lattner // Shift right algebraic if shift value is nonzero 603047b952e298352fe6feffedf02e359601133f465Chris Lattner if (magics.s > 0) 604047b952e298352fe6feffedf02e359601133f465Chris Lattner Q = CurDAG->getNode(ISD::SRA, MVT::i32, Q, 605047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->getConstant(magics.s, MVT::i32)); 606047b952e298352fe6feffedf02e359601133f465Chris Lattner // Extract the sign bit and add it to the quotient 607047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand T = 608047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->getNode(ISD::SRL, MVT::i32, Q, CurDAG->getConstant(31, MVT::i32)); 609047b952e298352fe6feffedf02e359601133f465Chris Lattner return CurDAG->getNode(ISD::ADD, MVT::i32, Q, T); 610047b952e298352fe6feffedf02e359601133f465Chris Lattner} 611047b952e298352fe6feffedf02e359601133f465Chris Lattner 612047b952e298352fe6feffedf02e359601133f465Chris Lattner/// BuildUDIVSequence - Given an ISD::UDIV node expressing a divide by constant, 613047b952e298352fe6feffedf02e359601133f465Chris Lattner/// return a DAG expression to select that will generate the same value by 614047b952e298352fe6feffedf02e359601133f465Chris Lattner/// multiplying by a magic number. See: 615047b952e298352fe6feffedf02e359601133f465Chris Lattner/// <http://the.wall.riscom.net/books/proc/ppc/cwg/code2.html> 616047b952e298352fe6feffedf02e359601133f465Chris LattnerSDOperand PPC32DAGToDAGISel::BuildUDIVSequence(SDNode *N) { 617047b952e298352fe6feffedf02e359601133f465Chris Lattner unsigned d = (unsigned)cast<ConstantSDNode>(N->getOperand(1))->getValue(); 618047b952e298352fe6feffedf02e359601133f465Chris Lattner mu magics = magicu(d); 619047b952e298352fe6feffedf02e359601133f465Chris Lattner // Multiply the numerator (operand 0) by the magic value 620047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand Q = CurDAG->getNode(ISD::MULHU, MVT::i32, N->getOperand(0), 621047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->getConstant(magics.m, MVT::i32)); 622047b952e298352fe6feffedf02e359601133f465Chris Lattner if (magics.a == 0) { 623047b952e298352fe6feffedf02e359601133f465Chris Lattner return CurDAG->getNode(ISD::SRL, MVT::i32, Q, 624047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->getConstant(magics.s, MVT::i32)); 625047b952e298352fe6feffedf02e359601133f465Chris Lattner } else { 626047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand NPQ = CurDAG->getNode(ISD::SUB, MVT::i32, N->getOperand(0), Q); 627047b952e298352fe6feffedf02e359601133f465Chris Lattner NPQ = CurDAG->getNode(ISD::SRL, MVT::i32, NPQ, 628047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->getConstant(1, MVT::i32)); 629047b952e298352fe6feffedf02e359601133f465Chris Lattner NPQ = CurDAG->getNode(ISD::ADD, MVT::i32, NPQ, Q); 630047b952e298352fe6feffedf02e359601133f465Chris Lattner return CurDAG->getNode(ISD::SRL, MVT::i32, NPQ, 631047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->getConstant(magics.s-1, MVT::i32)); 632047b952e298352fe6feffedf02e359601133f465Chris Lattner } 633047b952e298352fe6feffedf02e359601133f465Chris Lattner} 634047b952e298352fe6feffedf02e359601133f465Chris Lattner 635a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Select - Convert the specified operand from a target-independent to a 636a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// target-specific node if it hasn't already been changed. 637a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris LattnerSDOperand PPC32DAGToDAGISel::Select(SDOperand Op) { 638a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDNode *N = Op.Val; 6390bbea954331b8f08afa5b094dfb0841829c70eaaChris Lattner if (N->getOpcode() >= ISD::BUILTIN_OP_END && 6400bbea954331b8f08afa5b094dfb0841829c70eaaChris Lattner N->getOpcode() < PPCISD::FIRST_NUMBER) 641a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return Op; // Already selected. 642d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 643d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner // If this has already been converted, use it. 644d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner std::map<SDOperand, SDOperand>::iterator CGMI = CodeGenMap.find(Op); 645d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner if (CGMI != CodeGenMap.end()) return CGMI->second; 646a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 647a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOpcode()) { 64819c0907ba1c11c81dc231cf7b4143fdaf03466e4Chris Lattner default: break; 649a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::TokenFactor: { 650a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand New; 651a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (N->getNumOperands() == 2) { 652a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Op0 = Select(N->getOperand(0)); 653a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Op1 = Select(N->getOperand(1)); 654a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner New = CurDAG->getNode(ISD::TokenFactor, MVT::Other, Op0, Op1); 655a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } else { 656a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner std::vector<SDOperand> Ops; 657a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) 6587e65997c43cc91a5e6eaa0f460b844ef1b5d2fb1Chris Lattner Ops.push_back(Select(N->getOperand(i))); 659a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner New = CurDAG->getNode(ISD::TokenFactor, MVT::Other, Ops); 660a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 661a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 662d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner if (!N->hasOneUse()) CodeGenMap[Op] = New; 663d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner return New; 664a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 665a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::CopyFromReg: { 666a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Chain = Select(N->getOperand(0)); 667a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Chain == N->getOperand(0)) return Op; // No change 668a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand New = CurDAG->getCopyFromReg(Chain, 669a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner cast<RegisterSDNode>(N->getOperand(1))->getReg(), N->getValueType(0)); 670a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return New.getValue(Op.ResNo); 671a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 672a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::CopyToReg: { 673a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Chain = Select(N->getOperand(0)); 674a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Reg = N->getOperand(1); 675a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Val = Select(N->getOperand(2)); 676d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner SDOperand New = CurDAG->getNode(ISD::CopyToReg, MVT::Other, 677d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner Chain, Reg, Val); 678d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner if (!N->hasOneUse()) CodeGenMap[Op] = New; 679d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner return New; 680a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 6812b54400f085391a247dd2c3fffc9f36f7b2dc867Chris Lattner case ISD::UNDEF: 6822b54400f085391a247dd2c3fffc9f36f7b2dc867Chris Lattner if (N->getValueType(0) == MVT::i32) 6832bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::IMPLICIT_DEF_GPR, MVT::i32); 684919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else if (N->getValueType(0) == MVT::f32) 685919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CurDAG->SelectNodeTo(N, PPC::IMPLICIT_DEF_F4, MVT::f32); 686919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else 687919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CurDAG->SelectNodeTo(N, PPC::IMPLICIT_DEF_F8, MVT::f64); 68825dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 689e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner case ISD::FrameIndex: { 690e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner int FI = cast<FrameIndexSDNode>(N)->getIndex(); 6912bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::ADDI, MVT::i32, 692e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner CurDAG->getTargetFrameIndex(FI, MVT::i32), 693e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner getI32Imm(0)); 69425dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 695e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } 69634e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner case ISD::ConstantPool: { 6975839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner Constant *C = cast<ConstantPoolSDNode>(N)->get(); 6985839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand Tmp, CPI = CurDAG->getTargetConstantPool(C, MVT::i32); 69934e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner if (PICEnabled) 70034e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner Tmp = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(),CPI); 70134e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner else 70234e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner Tmp = CurDAG->getTargetNode(PPC::LIS, MVT::i32, CPI); 7032bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::LA, MVT::i32, Tmp, CPI); 70425dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 70534e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner } 7064416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner case ISD::GlobalAddress: { 7074416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalValue *GV = cast<GlobalAddressSDNode>(N)->getGlobal(); 7084416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SDOperand Tmp; 7094416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SDOperand GA = CurDAG->getTargetGlobalAddress(GV, MVT::i32); 7109944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (PICEnabled) 7119944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Tmp = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(), GA); 7129944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner else 7134416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner Tmp = CurDAG->getTargetNode(PPC::LIS, MVT::i32, GA); 7149944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 7154416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (GV->hasWeakLinkage() || GV->isExternal()) 7162bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::LWZ, MVT::i32, GA, Tmp); 7174416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner else 7182bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::LA, MVT::i32, Tmp, GA); 71925dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 7204416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 7219c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner case ISD::DYNAMIC_STACKALLOC: { 7229c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner // FIXME: We are currently ignoring the requested alignment for handling 7239c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner // greater than the stack alignment. This will need to be revisited at some 7249c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner // point. Align = N.getOperand(2); 7259c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner if (!isa<ConstantSDNode>(N->getOperand(2)) || 7269c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner cast<ConstantSDNode>(N->getOperand(2))->getValue() != 0) { 7279c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner std::cerr << "Cannot allocate stack object with greater alignment than" 7289c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner << " the stack alignment yet!"; 7299c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner abort(); 7309c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner } 7319c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner SDOperand Chain = Select(N->getOperand(0)); 7329c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner SDOperand Amt = Select(N->getOperand(1)); 7339c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner 7349c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner SDOperand R1Reg = CurDAG->getRegister(PPC::R1, MVT::i32); 7359c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner 73675592e4137c3ae7800e1fb8736db28a65bb3c94dChris Lattner SDOperand R1Val = CurDAG->getCopyFromReg(Chain, PPC::R1, MVT::i32); 73775592e4137c3ae7800e1fb8736db28a65bb3c94dChris Lattner Chain = R1Val.getValue(1); 73875592e4137c3ae7800e1fb8736db28a65bb3c94dChris Lattner 7399c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner // Subtract the amount (guaranteed to be a multiple of the stack alignment) 7409c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner // from the stack pointer, giving us the result pointer. 74175592e4137c3ae7800e1fb8736db28a65bb3c94dChris Lattner SDOperand Result = CurDAG->getTargetNode(PPC::SUBF, MVT::i32, Amt, R1Val); 7429c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner 7439c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner // Copy this result back into R1. 7449c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner Chain = CurDAG->getNode(ISD::CopyToReg, MVT::Other, Chain, R1Reg, Result); 7459c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner 7469c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner // Copy this result back out of R1 to make sure we're not using the stack 7479c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner // space without decrementing the stack pointer. 7489c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner Result = CurDAG->getCopyFromReg(Chain, PPC::R1, MVT::i32); 7499c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner 7509c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner // Finally, replace the DYNAMIC_STACKALLOC with the copyfromreg. 751d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner CodeGenMap[Op.getValue(0)] = Result; 752d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner CodeGenMap[Op.getValue(1)] = Result.getValue(1); 75325dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(Result.Val, Op.ResNo); 7549c2dece8e2daed25eb2db0f034e004a8342462e6Chris Lattner } 7550bbea954331b8f08afa5b094dfb0841829c70eaaChris Lattner case PPCISD::FSEL: 756919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (N->getValueType(0) == MVT::f32) 757919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CurDAG->SelectNodeTo(N, PPC::FSELS, MVT::f32, 758919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner Select(N->getOperand(0)), 759919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner Select(N->getOperand(1)), 760919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner Select(N->getOperand(2))); 761919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else 762919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CurDAG->SelectNodeTo(N, PPC::FSELD, MVT::f64, 763919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner Select(N->getOperand(0)), 764919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner Select(N->getOperand(1)), 765919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner Select(N->getOperand(2))); 76625dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 767c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman case PPCISD::FCFID: 768c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman CurDAG->SelectNodeTo(N, PPC::FCFID, N->getValueType(0), 769c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman Select(N->getOperand(0))); 770c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman return SDOperand(N, 0); 771c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman case PPCISD::FCTIDZ: 772c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman CurDAG->SelectNodeTo(N, PPC::FCTIDZ, N->getValueType(0), 773c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman Select(N->getOperand(0))); 774c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman return SDOperand(N, 0); 775f76053269ecc6c7bd3d0b1e90ebdd0cef1bb2bdcChris Lattner case PPCISD::FCTIWZ: 776f76053269ecc6c7bd3d0b1e90ebdd0cef1bb2bdcChris Lattner CurDAG->SelectNodeTo(N, PPC::FCTIWZ, N->getValueType(0), 777f76053269ecc6c7bd3d0b1e90ebdd0cef1bb2bdcChris Lattner Select(N->getOperand(0))); 77825dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 779615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner case ISD::FADD: { 780615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner MVT::ValueType Ty = N->getValueType(0); 781a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (!NoExcessFPPrecision) { // Match FMA ops 782615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner if (N->getOperand(0).getOpcode() == ISD::FMUL && 783a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(0).Val->hasOneUse()) { 784a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 7852bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Ty == MVT::f64 ? PPC::FMADD : PPC::FMADDS, Ty, 786a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(0)), 787a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(1)), 788a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1))); 78925dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 790615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner } else if (N->getOperand(1).getOpcode() == ISD::FMUL && 791a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(1).hasOneUse()) { 792a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 7932bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Ty == MVT::f64 ? PPC::FMADD : PPC::FMADDS, Ty, 794a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(0)), 795a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(1)), 796a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0))); 79725dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 798a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 799a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 800a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 8012bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Ty == MVT::f64 ? PPC::FADD : PPC::FADDS, Ty, 802a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0)), Select(N->getOperand(1))); 80325dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 804a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 805615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner case ISD::FSUB: { 806615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner MVT::ValueType Ty = N->getValueType(0); 807a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 808a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (!NoExcessFPPrecision) { // Match FMA ops 809615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner if (N->getOperand(0).getOpcode() == ISD::FMUL && 810a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(0).Val->hasOneUse()) { 811a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 8122bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Ty == MVT::f64 ? PPC::FMSUB : PPC::FMSUBS, Ty, 813a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(0)), 814a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(1)), 815a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1))); 81625dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 817615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner } else if (N->getOperand(1).getOpcode() == ISD::FMUL && 818a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(1).Val->hasOneUse()) { 819a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 8202bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Ty == MVT::f64 ? PPC::FNMSUB : PPC::FNMSUBS, Ty, 821a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(0)), 822a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(1)), 823a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0))); 82425dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 825a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 826a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 8272bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Ty == MVT::f64 ? PPC::FSUB : PPC::FSUBS, Ty, 828a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0)), 829a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1))); 83025dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 83126653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 83288add100b3db715df4275c8ab408e6b51f28ff8fChris Lattner case ISD::SDIV: { 8338784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner unsigned Imm; 8348784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if (isIntImmediate(N->getOperand(1), Imm)) { 8358784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if ((signed)Imm > 0 && isPowerOf2_32(Imm)) { 8368784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand Op = 8378784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 8388784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner Select(N->getOperand(0)), 8398784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner getI32Imm(Log2_32(Imm))); 8402bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 8418784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner Op.getValue(0), Op.getValue(1)); 84225dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 8438784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } else if ((signed)Imm < 0 && isPowerOf2_32(-Imm)) { 8448784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand Op = 8452501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 8468784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner Select(N->getOperand(0)), 8478784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner getI32Imm(Log2_32(-Imm))); 8488784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand PT = 8492501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, Op.getValue(0), 8502501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner Op.getValue(1)); 8512bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::NEG, MVT::i32, PT); 85225dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 853047b952e298352fe6feffedf02e359601133f465Chris Lattner } else if (Imm) { 854047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand Result = Select(BuildSDIVSequence(N)); 855d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner CodeGenMap[Op] = Result; 856d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner return Result; 8578784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 8588784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 859047b952e298352fe6feffedf02e359601133f465Chris Lattner 860237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 861237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 862047b952e298352fe6feffedf02e359601133f465Chris Lattner } 863047b952e298352fe6feffedf02e359601133f465Chris Lattner case ISD::UDIV: { 864047b952e298352fe6feffedf02e359601133f465Chris Lattner // If this is a divide by constant, we can emit code using some magic 865047b952e298352fe6feffedf02e359601133f465Chris Lattner // constants to implement it as a multiply instead. 866047b952e298352fe6feffedf02e359601133f465Chris Lattner unsigned Imm; 867a9317ed361847c96989664b84ae8502a783a9956Chris Lattner if (isIntImmediate(N->getOperand(1), Imm) && Imm) { 868047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand Result = Select(BuildUDIVSequence(N)); 869d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner CodeGenMap[Op] = Result; 870d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner return Result; 871047b952e298352fe6feffedf02e359601133f465Chris Lattner } 872047b952e298352fe6feffedf02e359601133f465Chris Lattner 873237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 874237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 875047b952e298352fe6feffedf02e359601133f465Chris Lattner } 876cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman case ISD::AND: { 877a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned Imm; 878cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and of a value rotated between 0 and 31 bits and then and'd 879cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // with a mask, emit rlwinm 880cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isIntImmediate(N->getOperand(1), Imm) && (isShiftedMask_32(Imm) || 881cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isShiftedMask_32(~Imm))) { 882cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SDOperand Val; 883a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned SH, MB, ME; 884cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isRotateAndMask(N->getOperand(0).Val, Imm, false, SH, MB, ME)) { 885cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Val = Select(N->getOperand(0).getOperand(0)); 886cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 887cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Val = Select(N->getOperand(0)); 888cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isRunOfOnes(Imm, MB, ME); 889cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = 0; 890cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 8912bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Val, getI32Imm(SH), 892cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman getI32Imm(MB), getI32Imm(ME)); 89325dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 894cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 895237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner 896237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 897237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 898cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 89902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::OR: 900d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner if (SDNode *I = SelectBitfieldInsert(N)) 901d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner return CodeGenMap[Op] = SDOperand(I, 0); 902d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 90302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (SDNode *I = SelectIntImmediateExpr(N->getOperand(0), 90402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman N->getOperand(1), 905d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner PPC::ORIS, PPC::ORI)) 906d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner return CodeGenMap[Op] = SDOperand(I, 0); 907d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 908237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 909237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 910c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SHL: { 911c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 912c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 913c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) 9142bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 915c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(0).getOperand(0)), 916c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 917c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else if (isIntImmediate(N->getOperand(1), Imm)) 9182bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Select(N->getOperand(0)), 919c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(Imm), getI32Imm(0), getI32Imm(31-Imm)); 920c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else 9212bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::SLW, MVT::i32, Select(N->getOperand(0)), 922c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(1))); 92325dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 924c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 925c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRL: { 926c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 927c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 928c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) 9292bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 930c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(0).getOperand(0)), 931c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman getI32Imm(SH & 0x1F), getI32Imm(MB), getI32Imm(ME)); 932c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else if (isIntImmediate(N->getOperand(1), Imm)) 9332bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Select(N->getOperand(0)), 934c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman getI32Imm((32-Imm) & 0x1F), getI32Imm(Imm), 935c09eeec0ebc378644bafd04916e5efafa7d98152Nate Begeman getI32Imm(31)); 936c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else 9372bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::SRW, MVT::i32, Select(N->getOperand(0)), 938c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(1))); 93925dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 940c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 941c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRA: { 942c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 943c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 944c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) 9452bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 946c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(0).getOperand(0)), 947c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 948c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else if (isIntImmediate(N->getOperand(1), Imm)) 9492bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::SRAWI, MVT::i32, Select(N->getOperand(0)), 950c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(Imm)); 951c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else 9522bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::SRAW, MVT::i32, Select(N->getOperand(0)), 953c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(1))); 95425dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 955c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 956d8ead9e25021d5c07b222f8550b621b4f31c874fChris Lattner case ISD::FMUL: { 957d8ead9e25021d5c07b222f8550b621b4f31c874fChris Lattner unsigned Opc = N->getValueType(0) == MVT::f32 ? PPC::FMULS : PPC::FMUL; 958d8ead9e25021d5c07b222f8550b621b4f31c874fChris Lattner CurDAG->SelectNodeTo(N, Opc, N->getValueType(0), Select(N->getOperand(0)), 959d8ead9e25021d5c07b222f8550b621b4f31c874fChris Lattner Select(N->getOperand(1))); 960d8ead9e25021d5c07b222f8550b621b4f31c874fChris Lattner return SDOperand(N, 0); 961d8ead9e25021d5c07b222f8550b621b4f31c874fChris Lattner } 962d8ead9e25021d5c07b222f8550b621b4f31c874fChris Lattner case ISD::FDIV: { 963d8ead9e25021d5c07b222f8550b621b4f31c874fChris Lattner unsigned Opc = N->getValueType(0) == MVT::f32 ? PPC::FDIVS : PPC::FDIV; 964d8ead9e25021d5c07b222f8550b621b4f31c874fChris Lattner CurDAG->SelectNodeTo(N, Opc, N->getValueType(0), Select(N->getOperand(0)), 965d8ead9e25021d5c07b222f8550b621b4f31c874fChris Lattner Select(N->getOperand(1))); 966d8ead9e25021d5c07b222f8550b621b4f31c874fChris Lattner return SDOperand(N, 0); 967d8ead9e25021d5c07b222f8550b621b4f31c874fChris Lattner } 968305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::FABS: 969919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (N->getValueType(0) == MVT::f32) 970919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CurDAG->SelectNodeTo(N, PPC::FABSS, MVT::f32, Select(N->getOperand(0))); 971919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else 972919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CurDAG->SelectNodeTo(N, PPC::FABSD, MVT::f64, Select(N->getOperand(0))); 97325dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 9748f838720ad578349e7929b32fa9117aa317bb3a5Chris Lattner case ISD::FP_EXTEND: 975305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman assert(MVT::f64 == N->getValueType(0) && 976305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman MVT::f32 == N->getOperand(0).getValueType() && "Illegal FP_EXTEND"); 9778f838720ad578349e7929b32fa9117aa317bb3a5Chris Lattner // We need to emit an FMR to make sure that the result has the right value 9788f838720ad578349e7929b32fa9117aa317bb3a5Chris Lattner // type. 979919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CurDAG->SelectNodeTo(N, PPC::FMRSD, MVT::f64, Select(N->getOperand(0))); 98025dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 981305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::FP_ROUND: 982305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman assert(MVT::f32 == N->getValueType(0) && 983305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman MVT::f64 == N->getOperand(0).getValueType() && "Illegal FP_ROUND"); 9842bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::FRSP, MVT::f32, Select(N->getOperand(0))); 98525dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 98626653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case ISD::FNEG: { 98726653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman SDOperand Val = Select(N->getOperand(0)); 98826653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman MVT::ValueType Ty = N->getValueType(0); 98926653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman if (Val.Val->hasOneUse()) { 99026653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman unsigned Opc; 991528f58e813ec4929a7997afbf121eb54e8bacf4cChris Lattner switch (Val.isTargetOpcode() ? Val.getTargetOpcode() : 0) { 99226653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman default: Opc = 0; break; 993919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner case PPC::FABSS: Opc = PPC::FNABSS; break; 994919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner case PPC::FABSD: Opc = PPC::FNABSD; break; 99526653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMADD: Opc = PPC::FNMADD; break; 99626653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMADDS: Opc = PPC::FNMADDS; break; 99726653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMSUB: Opc = PPC::FNMSUB; break; 99826653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMSUBS: Opc = PPC::FNMSUBS; break; 99926653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 100026653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // If we inverted the opcode, then emit the new instruction with the 100126653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // inverted opcode and the original instruction's operands. Otherwise, 100226653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // fall through and generate a fneg instruction. 100326653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman if (Opc) { 1004919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (Opc == PPC::FNABSS || Opc == PPC::FNABSD) 10052bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Opc, Ty, Val.getOperand(0)); 100626653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman else 10072bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Opc, Ty, Val.getOperand(0), 100826653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman Val.getOperand(1), Val.getOperand(2)); 100925dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 101026653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 101126653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 1012919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (Ty == MVT::f32) 1013919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CurDAG->SelectNodeTo(N, PPC::FNEGS, MVT::f32, Val); 1014919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else 1015919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CurDAG->SelectNodeTo(N, PPC::FNEGS, MVT::f64, Val); 101625dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 101726653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 10186a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman case ISD::FSQRT: { 10196a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman MVT::ValueType Ty = N->getValueType(0); 10202bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Ty == MVT::f64 ? PPC::FSQRT : PPC::FSQRTS, Ty, 10216a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman Select(N->getOperand(0))); 102225dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 10236a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman } 1024a9317ed361847c96989664b84ae8502a783a9956Chris Lattner 1025a9317ed361847c96989664b84ae8502a783a9956Chris Lattner case ISD::ADD_PARTS: { 1026a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand LHSL = Select(N->getOperand(0)); 1027a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand LHSH = Select(N->getOperand(1)); 1028a9317ed361847c96989664b84ae8502a783a9956Chris Lattner 1029a9317ed361847c96989664b84ae8502a783a9956Chris Lattner unsigned Imm; 103095e0682a4276fb9f5978039dc4bae675bdf66ee3Chris Lattner bool ME = false, ZE = false; 1031a9317ed361847c96989664b84ae8502a783a9956Chris Lattner if (isIntImmediate(N->getOperand(3), Imm)) { 1032a9317ed361847c96989664b84ae8502a783a9956Chris Lattner ME = (signed)Imm == -1; 1033a9317ed361847c96989664b84ae8502a783a9956Chris Lattner ZE = Imm == 0; 1034a9317ed361847c96989664b84ae8502a783a9956Chris Lattner } 1035a9317ed361847c96989664b84ae8502a783a9956Chris Lattner 1036a9317ed361847c96989664b84ae8502a783a9956Chris Lattner std::vector<SDOperand> Result; 1037a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand CarryFromLo; 1038a9317ed361847c96989664b84ae8502a783a9956Chris Lattner if (isIntImmediate(N->getOperand(2), Imm) && 1039a9317ed361847c96989664b84ae8502a783a9956Chris Lattner ((signed)Imm >= -32768 || (signed)Imm < 32768)) { 1040a9317ed361847c96989664b84ae8502a783a9956Chris Lattner // Codegen the low 32 bits of the add. Interestingly, there is no 1041a9317ed361847c96989664b84ae8502a783a9956Chris Lattner // shifted form of add immediate carrying. 1042a9317ed361847c96989664b84ae8502a783a9956Chris Lattner CarryFromLo = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 1043a9317ed361847c96989664b84ae8502a783a9956Chris Lattner LHSL, getI32Imm(Imm)); 1044a9317ed361847c96989664b84ae8502a783a9956Chris Lattner } else { 1045a9317ed361847c96989664b84ae8502a783a9956Chris Lattner CarryFromLo = CurDAG->getTargetNode(PPC::ADDC, MVT::i32, MVT::Flag, 1046a9317ed361847c96989664b84ae8502a783a9956Chris Lattner LHSL, Select(N->getOperand(2))); 1047a9317ed361847c96989664b84ae8502a783a9956Chris Lattner } 1048a9317ed361847c96989664b84ae8502a783a9956Chris Lattner CarryFromLo = CarryFromLo.getValue(1); 1049a9317ed361847c96989664b84ae8502a783a9956Chris Lattner 1050a9317ed361847c96989664b84ae8502a783a9956Chris Lattner // Codegen the high 32 bits, adding zero, minus one, or the full value 1051a9317ed361847c96989664b84ae8502a783a9956Chris Lattner // along with the carry flag produced by addc/addic. 1052a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand ResultHi; 1053a9317ed361847c96989664b84ae8502a783a9956Chris Lattner if (ZE) 1054a9317ed361847c96989664b84ae8502a783a9956Chris Lattner ResultHi = CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, LHSH, CarryFromLo); 1055a9317ed361847c96989664b84ae8502a783a9956Chris Lattner else if (ME) 1056a9317ed361847c96989664b84ae8502a783a9956Chris Lattner ResultHi = CurDAG->getTargetNode(PPC::ADDME, MVT::i32, LHSH, CarryFromLo); 1057a9317ed361847c96989664b84ae8502a783a9956Chris Lattner else 1058a9317ed361847c96989664b84ae8502a783a9956Chris Lattner ResultHi = CurDAG->getTargetNode(PPC::ADDE, MVT::i32, LHSH, 1059a9317ed361847c96989664b84ae8502a783a9956Chris Lattner Select(N->getOperand(3)), CarryFromLo); 1060b20c318df02c19a5ba4ba89c76f2bf3daae64ad2Chris Lattner Result.push_back(CarryFromLo.getValue(0)); 106114b86c72a28a064373ac1670ed8ee62dab41e2f4Chris Lattner Result.push_back(ResultHi); 1062d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 1063d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner CodeGenMap[Op.getValue(0)] = Result[0]; 1064d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner CodeGenMap[Op.getValue(1)] = Result[1]; 1065a9317ed361847c96989664b84ae8502a783a9956Chris Lattner return Result[Op.ResNo]; 1066a9317ed361847c96989664b84ae8502a783a9956Chris Lattner } 1067a9317ed361847c96989664b84ae8502a783a9956Chris Lattner case ISD::SUB_PARTS: { 1068a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand LHSL = Select(N->getOperand(0)); 1069a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand LHSH = Select(N->getOperand(1)); 1070a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand RHSL = Select(N->getOperand(2)); 1071a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand RHSH = Select(N->getOperand(3)); 1072a9317ed361847c96989664b84ae8502a783a9956Chris Lattner 1073a9317ed361847c96989664b84ae8502a783a9956Chris Lattner std::vector<SDOperand> Result; 1074a9317ed361847c96989664b84ae8502a783a9956Chris Lattner Result.push_back(CurDAG->getTargetNode(PPC::SUBFC, MVT::i32, MVT::Flag, 1075a9317ed361847c96989664b84ae8502a783a9956Chris Lattner RHSL, LHSL)); 1076a9317ed361847c96989664b84ae8502a783a9956Chris Lattner Result.push_back(CurDAG->getTargetNode(PPC::SUBFE, MVT::i32, RHSH, LHSH, 1077a9317ed361847c96989664b84ae8502a783a9956Chris Lattner Result[0].getValue(1))); 1078d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner CodeGenMap[Op.getValue(0)] = Result[0]; 1079d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner CodeGenMap[Op.getValue(1)] = Result[1]; 1080a9317ed361847c96989664b84ae8502a783a9956Chris Lattner return Result[Op.ResNo]; 1081a9317ed361847c96989664b84ae8502a783a9956Chris Lattner } 1082a9317ed361847c96989664b84ae8502a783a9956Chris Lattner 10839944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::LOAD: 10849944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::EXTLOAD: 10859944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::ZEXTLOAD: 10869944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::SEXTLOAD: { 10879944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner SDOperand Op1, Op2; 10889944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner bool isIdx = SelectAddr(N->getOperand(1), Op1, Op2); 10899944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 10909944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner MVT::ValueType TypeBeingLoaded = (N->getOpcode() == ISD::LOAD) ? 10919944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner N->getValueType(0) : cast<VTSDNode>(N->getOperand(3))->getVT(); 10929944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner unsigned Opc; 10939944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner switch (TypeBeingLoaded) { 10949944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner default: N->dump(); assert(0 && "Cannot load this type!"); 10959944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i1: 10969944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i8: Opc = isIdx ? PPC::LBZX : PPC::LBZ; break; 10979944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i16: 10989944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (N->getOpcode() == ISD::SEXTLOAD) { // SEXT load? 10999944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Opc = isIdx ? PPC::LHAX : PPC::LHA; 11009944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 11019944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Opc = isIdx ? PPC::LHZX : PPC::LHZ; 11029944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 11039944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner break; 11049944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i32: Opc = isIdx ? PPC::LWZX : PPC::LWZ; break; 11059944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::f32: Opc = isIdx ? PPC::LFSX : PPC::LFS; break; 11069944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::f64: Opc = isIdx ? PPC::LFDX : PPC::LFD; break; 11079944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 11089944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 1109919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner // If this is an f32 -> f64 load, emit the f32 load, then use an 'extending 1110919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner // copy'. 1111919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (TypeBeingLoaded != MVT::f32 || N->getOpcode() == ISD::LOAD) { 1112919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CurDAG->SelectNodeTo(N, Opc, N->getValueType(0), MVT::Other, 1113919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner Op1, Op2, Select(N->getOperand(0))); 1114919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner return SDOperand(N, Op.ResNo); 1115919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner } else { 1116919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner std::vector<SDOperand> Ops; 1117919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner Ops.push_back(Op1); 1118919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner Ops.push_back(Op2); 1119919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner Ops.push_back(Select(N->getOperand(0))); 1120919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SDOperand Res = CurDAG->getTargetNode(Opc, MVT::f32, MVT::Other, Ops); 1121919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SDOperand Ext = CurDAG->getTargetNode(PPC::FMRSD, MVT::f64, Res); 1122919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CodeGenMap[Op.getValue(0)] = Ext; 1123919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner CodeGenMap[Op.getValue(1)] = Res.getValue(1); 1124919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (Op.ResNo) 1125919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner return Res.getValue(1); 1126919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else 1127919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner return Ext; 1128919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner } 11299944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 11309944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 1131f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case ISD::TRUNCSTORE: 1132f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case ISD::STORE: { 1133f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner SDOperand AddrOp1, AddrOp2; 1134f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner bool isIdx = SelectAddr(N->getOperand(2), AddrOp1, AddrOp2); 1135f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner 1136f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner unsigned Opc; 1137f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner if (N->getOpcode() == ISD::STORE) { 1138f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner switch (N->getOperand(1).getValueType()) { 1139f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner default: assert(0 && "unknown Type in store"); 1140f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::i32: Opc = isIdx ? PPC::STWX : PPC::STW; break; 1141f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::f64: Opc = isIdx ? PPC::STFDX : PPC::STFD; break; 1142f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::f32: Opc = isIdx ? PPC::STFSX : PPC::STFS; break; 1143f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 1144f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } else { //ISD::TRUNCSTORE 1145f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner switch(cast<VTSDNode>(N->getOperand(4))->getVT()) { 1146f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner default: assert(0 && "unknown Type in store"); 1147f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::i8: Opc = isIdx ? PPC::STBX : PPC::STB; break; 1148f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::i16: Opc = isIdx ? PPC::STHX : PPC::STH; break; 1149f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 1150f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 1151fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 11522bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Opc, MVT::Other, Select(N->getOperand(1)), 1153f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner AddrOp1, AddrOp2, Select(N->getOperand(0))); 115425dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 1155a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner } 115664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner 115764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETCC: { 115864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner unsigned Imm; 115964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get(); 116064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner if (isIntImmediate(N->getOperand(1), Imm)) { 116164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner // We can codegen setcc op, imm very efficiently compared to a brcond. 116264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner // Check for those cases here. 116364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner // setcc op, 0 116464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner if (Imm == 0) { 116564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand Op = Select(N->getOperand(0)); 116664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 116764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner default: assert(0 && "Unhandled SetCC condition"); abort(); 116864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETEQ: 116964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner Op = CurDAG->getTargetNode(PPC::CNTLZW, MVT::i32, Op); 11702bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Op, getI32Imm(27), 117164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(5), getI32Imm(31)); 117264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 117364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETNE: { 117464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand AD = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 117564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner Op, getI32Imm(~0U)); 11762bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, AD.getValue(1)); 117764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 117864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 117964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLT: 11802bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Op, getI32Imm(1), 118164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(31), getI32Imm(31)); 118264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 118364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGT: { 118464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand T = CurDAG->getTargetNode(PPC::NEG, MVT::i32, Op); 118564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner T = CurDAG->getTargetNode(PPC::ANDC, MVT::i32, T, Op);; 11862bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, T, getI32Imm(1), 118764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(31), getI32Imm(31)); 118864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 118964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 119064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 119125dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 119264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } else if (Imm == ~0U) { // setcc op, -1 119364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand Op = Select(N->getOperand(0)); 119464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 119564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner default: assert(0 && "Unhandled SetCC condition"); abort(); 119664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETEQ: 119764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner Op = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 119864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner Op, getI32Imm(1)); 11992bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 120064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner CurDAG->getTargetNode(PPC::LI, MVT::i32, 120164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(0)), 120264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner Op.getValue(1)); 120364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 120464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETNE: { 120564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner Op = CurDAG->getTargetNode(PPC::NOR, MVT::i32, Op, Op); 12068bbcc20a9dccd258d5977d1d99520367b9ca9e7eChris Lattner SDOperand AD = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 12078bbcc20a9dccd258d5977d1d99520367b9ca9e7eChris Lattner Op, getI32Imm(~0U)); 12082bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, AD.getValue(1)); 120964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 121064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 121164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLT: { 121264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand AD = CurDAG->getTargetNode(PPC::ADDI, MVT::i32, Op, 121364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(1)); 121464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand AN = CurDAG->getTargetNode(PPC::AND, MVT::i32, AD, Op); 12152bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, AN, getI32Imm(1), 121664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(31), getI32Imm(31)); 121764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 121864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 121964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGT: 122064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner Op = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Op, getI32Imm(1), 122164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(31), getI32Imm(31)); 12222bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Op, getI32Imm(1)); 122364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 122464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 122525dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 122664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 122764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 122864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner 122964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner bool Inv; 123064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner unsigned Idx = getCRIdxForSetCC(CC, Inv); 123150ff55c2c7909818165e51bbdc103a05b143dcb1Chris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 123264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand IntCR; 1233957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner 1234957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner // Force the ccreg into CR7. 1235957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner SDOperand CR7Reg = CurDAG->getRegister(PPC::CR7, MVT::i32); 1236957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner 1237957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner std::vector<MVT::ValueType> VTs; 1238957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner VTs.push_back(MVT::Other); 1239957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner VTs.push_back(MVT::Flag); // NONSTANDARD CopyToReg node: defines a flag 1240957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner std::vector<SDOperand> Ops; 1241957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner Ops.push_back(CurDAG->getEntryNode()); 1242957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner Ops.push_back(CR7Reg); 1243957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner Ops.push_back(CCReg); 1244957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner CCReg = CurDAG->getNode(ISD::CopyToReg, VTs, Ops).getValue(1); 1245957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner 1246957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner if (TLI.getTargetMachine().getSubtarget<PPCSubtarget>().isGigaProcessor()) 1247957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner IntCR = CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, CR7Reg, CCReg); 1248957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner else 1249957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner IntCR = CurDAG->getTargetNode(PPC::MFCR, MVT::i32, CCReg); 125064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner 125164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner if (!Inv) { 12522bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, IntCR, 125364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(32-(3-Idx)), getI32Imm(31), getI32Imm(31)); 125464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } else { 125564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand Tmp = 125664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, IntCR, 125764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(32-(3-Idx)), getI32Imm(31),getI32Imm(31)); 12582bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Tmp, getI32Imm(1)); 125964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 126064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner 126125dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 126264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 1263a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner 126413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner case ISD::SELECT_CC: { 126513794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(4))->get(); 126613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner 126713794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner // handle the setcc cases here. select_cc lhs, 0, 1, 0, cc 126813794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N->getOperand(1))) 126913794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N->getOperand(2))) 127013794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N->getOperand(3))) 127113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (N1C->isNullValue() && N3C->isNullValue() && 127213794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner N2C->getValue() == 1ULL && CC == ISD::SETNE) { 127313794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner SDOperand LHS = Select(N->getOperand(0)); 127413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner SDOperand Tmp = 127513794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 127613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner LHS, getI32Imm(~0U)); 127713794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, Tmp, LHS, 127813794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner Tmp.getValue(1)); 127925dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 128013794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 12818a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 128250ff55c2c7909818165e51bbdc103a05b143dcb1Chris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 12838a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner unsigned BROpc = getBCCForSetCC(CC); 12848a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 12858a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner bool isFP = MVT::isFloatingPoint(N->getValueType(0)); 1286919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner unsigned SelectCCOp; 1287919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (MVT::isInteger(N->getValueType(0))) 1288919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_Int; 1289919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else if (N->getValueType(0) == MVT::f32) 1290919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F4; 1291919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else 1292919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F8; 12938a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner CurDAG->SelectNodeTo(N, SelectCCOp, N->getValueType(0), CCReg, 12948a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner Select(N->getOperand(2)), Select(N->getOperand(3)), 12958a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner getI32Imm(BROpc)); 129625dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 129713794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 129813794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner 1299a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner case ISD::CALLSEQ_START: 1300a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner case ISD::CALLSEQ_END: { 1301a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner unsigned Amt = cast<ConstantSDNode>(N->getOperand(1))->getValue(); 1302a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner unsigned Opc = N->getOpcode() == ISD::CALLSEQ_START ? 1303a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner PPC::ADJCALLSTACKDOWN : PPC::ADJCALLSTACKUP; 13042bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, Opc, MVT::Other, 1305fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner getI32Imm(Amt), Select(N->getOperand(0))); 130625dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 1307f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 1308fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner case ISD::CALL: 1309fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner case ISD::TAILCALL: { 1310fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner SDOperand Chain = Select(N->getOperand(0)); 1311fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1312fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner unsigned CallOpcode; 1313fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner std::vector<SDOperand> CallOperands; 1314fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1315fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner if (GlobalAddressSDNode *GASD = 1316fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner dyn_cast<GlobalAddressSDNode>(N->getOperand(1))) { 1317fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOpcode = PPC::CALLpcrel; 1318fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOperands.push_back(CurDAG->getTargetGlobalAddress(GASD->getGlobal(), 1319fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner MVT::i32)); 1320fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } else if (ExternalSymbolSDNode *ESSDN = 1321fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner dyn_cast<ExternalSymbolSDNode>(N->getOperand(1))) { 1322fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOpcode = PPC::CALLpcrel; 1323fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOperands.push_back(N->getOperand(1)); 1324fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } else { 1325fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner // Copy the callee address into the CTR register. 1326fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner SDOperand Callee = Select(N->getOperand(1)); 1327fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner Chain = CurDAG->getTargetNode(PPC::MTCTR, MVT::Other, Callee, Chain); 1328fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1329fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner // Copy the callee address into R12 on darwin. 1330fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner SDOperand R12 = CurDAG->getRegister(PPC::R12, MVT::i32); 13312a06a5ef363382479e74cae2d39f139e11f40225Chris Lattner Chain = CurDAG->getNode(ISD::CopyToReg, MVT::Other, Chain, R12, Callee); 1332fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1333fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOperands.push_back(getI32Imm(20)); // Information to encode indcall 1334fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOperands.push_back(getI32Imm(0)); // Information to encode indcall 1335fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOperands.push_back(R12); 1336fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOpcode = PPC::CALLindirect; 1337fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } 1338fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1339fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner unsigned GPR_idx = 0, FPR_idx = 0; 1340fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner static const unsigned GPR[] = { 1341fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner PPC::R3, PPC::R4, PPC::R5, PPC::R6, 1342fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner PPC::R7, PPC::R8, PPC::R9, PPC::R10, 1343fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner }; 1344fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner static const unsigned FPR[] = { 1345fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, 1346fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner PPC::F8, PPC::F9, PPC::F10, PPC::F11, PPC::F12, PPC::F13 1347fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner }; 1348fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 134931ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner SDOperand InFlag; // Null incoming flag value. 135031ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner 13517107c10501e62d2e3ed34b349585e616b8f6da3eChris Lattner for (unsigned i = 2, e = N->getNumOperands(); i != e; ++i) { 13527107c10501e62d2e3ed34b349585e616b8f6da3eChris Lattner unsigned DestReg = 0; 1353eb80fe8ff684121c8130db716fe4a7cb5ca3ac0dChris Lattner MVT::ValueType RegTy = N->getOperand(i).getValueType(); 1354eb80fe8ff684121c8130db716fe4a7cb5ca3ac0dChris Lattner if (RegTy == MVT::i32) { 13557107c10501e62d2e3ed34b349585e616b8f6da3eChris Lattner assert(GPR_idx < 8 && "Too many int args"); 13567107c10501e62d2e3ed34b349585e616b8f6da3eChris Lattner DestReg = GPR[GPR_idx++]; 13577107c10501e62d2e3ed34b349585e616b8f6da3eChris Lattner } else { 13587107c10501e62d2e3ed34b349585e616b8f6da3eChris Lattner assert(MVT::isFloatingPoint(N->getOperand(i).getValueType()) && 13597107c10501e62d2e3ed34b349585e616b8f6da3eChris Lattner "Unpromoted integer arg?"); 13607107c10501e62d2e3ed34b349585e616b8f6da3eChris Lattner assert(FPR_idx < 13 && "Too many fp args"); 13617107c10501e62d2e3ed34b349585e616b8f6da3eChris Lattner DestReg = FPR[FPR_idx++]; 13627107c10501e62d2e3ed34b349585e616b8f6da3eChris Lattner } 13637107c10501e62d2e3ed34b349585e616b8f6da3eChris Lattner 1364fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner if (N->getOperand(i).getOpcode() != ISD::UNDEF) { 13652ea0c66ae56b3254698c960f7b89b4eaed6bd83fChris Lattner SDOperand Val = Select(N->getOperand(i)); 13662ea0c66ae56b3254698c960f7b89b4eaed6bd83fChris Lattner Chain = CurDAG->getCopyToReg(Chain, DestReg, Val, InFlag); 136731ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner InFlag = Chain.getValue(1); 136831ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner CallOperands.push_back(CurDAG->getRegister(DestReg, RegTy)); 1369fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } 13707107c10501e62d2e3ed34b349585e616b8f6da3eChris Lattner } 1371fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1372fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner // Finally, once everything is in registers to pass to the call, emit the 1373fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner // call itself. 137431ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner if (InFlag.Val) 137531ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner CallOperands.push_back(InFlag); // Strong dep on register copies. 137631ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner else 137731ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner CallOperands.push_back(Chain); // Weak dep on whatever occurs before 137831ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner Chain = CurDAG->getTargetNode(CallOpcode, MVT::Other, MVT::Flag, 137931ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner CallOperands); 1380fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1381fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner std::vector<SDOperand> CallResults; 1382fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1383fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner // If the call has results, copy the values out of the ret val registers. 1384fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner switch (N->getValueType(0)) { 1385fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner default: assert(0 && "Unexpected ret value!"); 1386fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner case MVT::Other: break; 1387fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner case MVT::i32: 1388fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner if (N->getValueType(1) == MVT::i32) { 138931ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R4, MVT::i32, 139031ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner Chain.getValue(1)).getValue(1); 1391fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallResults.push_back(Chain.getValue(0)); 139231ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R3, MVT::i32, 1393242f2557cc242b2d132e5a3e6c3a98961a7e4349Jim Laskey Chain.getValue(2)).getValue(1); 1394fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallResults.push_back(Chain.getValue(0)); 1395fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } else { 139631ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R3, MVT::i32, 139731ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner Chain.getValue(1)).getValue(1); 1398fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallResults.push_back(Chain.getValue(0)); 1399fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } 1400fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner break; 1401fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner case MVT::f32: 1402fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner case MVT::f64: 1403eb80fe8ff684121c8130db716fe4a7cb5ca3ac0dChris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::F1, N->getValueType(0), 140431ce12f4f57db4375392e9129772773bed1bd4ccChris Lattner Chain.getValue(1)).getValue(1); 1405eb80fe8ff684121c8130db716fe4a7cb5ca3ac0dChris Lattner CallResults.push_back(Chain.getValue(0)); 1406fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner break; 1407fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } 1408fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1409fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallResults.push_back(Chain); 1410d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner for (unsigned i = 0, e = CallResults.size(); i != e; ++i) 1411d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner CodeGenMap[Op.getValue(i)] = CallResults[i]; 1412fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner return CallResults[Op.ResNo]; 1413fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } 1414a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::RET: { 1415a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Chain = Select(N->getOperand(0)); // Token chain. 1416a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 14177a49fdcd1136c26d9c60b19c087ca9d578cc9834Chris Lattner if (N->getNumOperands() == 2) { 1418a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Val = Select(N->getOperand(1)); 1419eb80fe8ff684121c8130db716fe4a7cb5ca3ac0dChris Lattner if (N->getOperand(1).getValueType() == MVT::i32) { 1420a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Chain = CurDAG->getCopyToReg(Chain, PPC::R3, Val); 1421eb80fe8ff684121c8130db716fe4a7cb5ca3ac0dChris Lattner } else { 1422eb80fe8ff684121c8130db716fe4a7cb5ca3ac0dChris Lattner assert(MVT::isFloatingPoint(N->getOperand(1).getValueType())); 1423eb80fe8ff684121c8130db716fe4a7cb5ca3ac0dChris Lattner Chain = CurDAG->getCopyToReg(Chain, PPC::F1, Val); 1424a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 14257a49fdcd1136c26d9c60b19c087ca9d578cc9834Chris Lattner } else if (N->getNumOperands() > 1) { 14267a49fdcd1136c26d9c60b19c087ca9d578cc9834Chris Lattner assert(N->getOperand(1).getValueType() == MVT::i32 && 14277a49fdcd1136c26d9c60b19c087ca9d578cc9834Chris Lattner N->getOperand(2).getValueType() == MVT::i32 && 14287a49fdcd1136c26d9c60b19c087ca9d578cc9834Chris Lattner N->getNumOperands() == 3 && "Unknown two-register ret value!"); 14297a49fdcd1136c26d9c60b19c087ca9d578cc9834Chris Lattner Chain = CurDAG->getCopyToReg(Chain, PPC::R4, Select(N->getOperand(1))); 14307a49fdcd1136c26d9c60b19c087ca9d578cc9834Chris Lattner Chain = CurDAG->getCopyToReg(Chain, PPC::R3, Select(N->getOperand(2))); 1431a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 1432a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1433a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Finally, select this to a blr (return) instruction. 14342bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::BLR, MVT::Other, Chain); 143525dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 1436a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 143789532c7db03543402dd5376172b87233575beb44Chris Lattner case ISD::BR: 14382bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::B, MVT::Other, N->getOperand(1), 143989532c7db03543402dd5376172b87233575beb44Chris Lattner Select(N->getOperand(0))); 144025dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 14412fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::BR_CC: 14422fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::BRTWOWAY_CC: { 14432fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand Chain = Select(N->getOperand(0)); 14442fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner MachineBasicBlock *Dest = 14452fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner cast<BasicBlockSDNode>(N->getOperand(4))->getBasicBlock(); 14462fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(1))->get(); 14472fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CondCode = SelectCC(N->getOperand(2), N->getOperand(3), CC); 14482fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner unsigned Opc = getBCCForSetCC(CC); 14492fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 14502fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // If this is a two way branch, then grab the fallthrough basic block 14512fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // argument and build a PowerPC branch pseudo-op, suitable for long branch 14522fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // conversion if necessary by the branch selection pass. Otherwise, emit a 14532fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // standard conditional branch. 14542fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (N->getOpcode() == ISD::BRTWOWAY_CC) { 14552fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner MachineBasicBlock *Fallthrough = 14562fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner cast<BasicBlockSDNode>(N->getOperand(5))->getBasicBlock(); 14572fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CB = CurDAG->getTargetNode(PPC::COND_BRANCH, MVT::Other, 14582fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner CondCode, getI32Imm(Opc), 14592fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner N->getOperand(4), N->getOperand(5), 14602fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner Chain); 14612bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::B, MVT::Other, N->getOperand(5), CB); 14622fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 14632fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Iterate to the next basic block 14642fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ilist<MachineBasicBlock>::iterator It = BB; 14652fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ++It; 14662fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 14672fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // If the fallthrough path is off the end of the function, which would be 14682fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // undefined behavior, set it to be the same as the current block because 14692fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // we have nothing better to set it to, and leaving it alone will cause 14702fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // the PowerPC Branch Selection pass to crash. 14712fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (It == BB->getParent()->end()) It = Dest; 14722bb06cdf27905cf95bd39e4120f1ad57c68ac73eChris Lattner CurDAG->SelectNodeTo(N, PPC::COND_BRANCH, MVT::Other, CondCode, 14732fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner getI32Imm(Opc), N->getOperand(4), 14742fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner CurDAG->getBasicBlock(It), Chain); 14752fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 147625dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner return SDOperand(N, 0); 14772fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 1478a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 147925dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner 148019c0907ba1c11c81dc231cf7b4143fdaf03466e4Chris Lattner return SelectCode(Op); 1481a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1482a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1483a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1484a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// createPPC32ISelDag - This pass converts a legalized DAG into a 1485a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// PowerPC-specific DAG, ready for instruction scheduling. 1486a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// 1487a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris LattnerFunctionPass *llvm::createPPC32ISelDag(TargetMachine &TM) { 1488a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return new PPC32DAGToDAGISel(TM); 1489a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1490a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1491