PPCISelDAGToDAG.cpp revision a9317ed361847c96989664b84ae8502a783a9956
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" 182fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner#include "llvm/CodeGen/MachineConstantPool.h" 194416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 204416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 214416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/CodeGen/SSARegMap.h" 22a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/CodeGen/SelectionDAG.h" 23a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/CodeGen/SelectionDAGISel.h" 24a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Target/TargetOptions.h" 25a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/ADT/Statistic.h" 262fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner#include "llvm/Constants.h" 274416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/GlobalValue.h" 28a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Support/Debug.h" 29a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Support/MathExtras.h" 30a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerusing namespace llvm; 31a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 32a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnernamespace { 33a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Statistic<> FusedFP ("ppc-codegen", "Number of fused fp operations"); 34a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Statistic<> FrameOff("ppc-codegen", "Number of frame idx offsets collapsed"); 35a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 36a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner //===--------------------------------------------------------------------===// 37a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// PPC32DAGToDAGISel - PPC32 specific code to select PPC32 machine 38a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// instructions for SelectionDAG operations. 39a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// 40a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner class PPC32DAGToDAGISel : public SelectionDAGISel { 41a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner PPC32TargetLowering PPC32Lowering; 424416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner unsigned GlobalBaseReg; 43a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner public: 44a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner PPC32DAGToDAGISel(TargetMachine &TM) 45a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner : SelectionDAGISel(PPC32Lowering), PPC32Lowering(TM) {} 46a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 474416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner virtual bool runOnFunction(Function &Fn) { 484416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Make sure we re-emit a set of the global base reg if necessary 494416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalBaseReg = 0; 504416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner return SelectionDAGISel::runOnFunction(Fn); 514416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 524416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 53a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// getI32Imm - Return a target constant with the specified value, of type 54a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// i32. 55a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner inline SDOperand getI32Imm(unsigned Imm) { 56a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return CurDAG->getTargetConstant(Imm, MVT::i32); 57a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 584416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 594416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// getGlobalBaseReg - insert code into the entry mbb to materialize the PIC 604416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// base register. Return the virtual register that holds this value. 619944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner SDOperand getGlobalBaseReg(); 62a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 63a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Select - Convert the specified operand from a target-independent to a 64a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // target-specific node if it hasn't already been changed. 65a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Select(SDOperand Op); 66a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 67a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDNode *SelectIntImmediateExpr(SDOperand LHS, SDOperand RHS, 68a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned OCHi, unsigned OCLo, 69a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner bool IsArithmetic = false, 70a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner bool Negate = false); 7102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDNode *SelectBitfieldInsert(SDNode *N); 7202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 732fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// SelectCC - Select a comparison of the specified values with the 742fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// specified condition code, returning the CR# of the expression. 752fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand SelectCC(SDOperand LHS, SDOperand RHS, ISD::CondCode CC); 762fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 779944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner /// SelectAddr - Given the specified address, return the two operands for a 789944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner /// load/store instruction, and return true if it should be an indexed [r+r] 799944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner /// operation. 809944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner bool SelectAddr(SDOperand Addr, SDOperand &Op1, SDOperand &Op2); 819944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 82047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand BuildSDIVSequence(SDNode *N); 83047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand BuildUDIVSequence(SDNode *N); 84047b952e298352fe6feffedf02e359601133f465Chris Lattner 85a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// InstructionSelectBasicBlock - This callback is invoked by 86a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 87a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner virtual void InstructionSelectBasicBlock(SelectionDAG &DAG) { 88a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner DEBUG(BB->dump()); 89d607c12e8e8533028a66c9f533007c6c32a64cefChris Lattner // Select target instructions for the DAG. 90a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(DAG.getRoot()); 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 } 100a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner }; 101a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 102a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1034416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// getGlobalBaseReg - Output the instructions required to put the 1044416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// base address to use for accessing globals into a register. 1054416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// 1069944b76cfe74981d2c41c8237d25267ba0c467c7Chris LattnerSDOperand PPC32DAGToDAGISel::getGlobalBaseReg() { 1074416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (!GlobalBaseReg) { 1084416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Insert the set of GlobalBaseReg into the first MBB of the function 1094416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock &FirstMBB = BB->getParent()->front(); 1104416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock::iterator MBBI = FirstMBB.begin(); 1114416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SSARegMap *RegMap = BB->getParent()->getSSARegMap(); 1124416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalBaseReg = RegMap->createVirtualRegister(PPC32::GPRCRegisterClass); 1134416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MovePCtoLR, 0, PPC::LR); 1144416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MFLR, 1, GlobalBaseReg); 1154416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 1169944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return CurDAG->getRegister(GlobalBaseReg, MVT::i32); 1174416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner} 1184416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 1194416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 1200f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isIntImmediate - This method tests to see if a constant operand. 1210f3257a3302b60c128a667db6736e81335316c1eNate Begeman// If so Imm will receive the 32 bit value. 1220f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isIntImmediate(SDNode *N, unsigned& Imm) { 1230f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (N->getOpcode() == ISD::Constant) { 1240f3257a3302b60c128a667db6736e81335316c1eNate Begeman Imm = cast<ConstantSDNode>(N)->getValue(); 1250f3257a3302b60c128a667db6736e81335316c1eNate Begeman return true; 1260f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 1270f3257a3302b60c128a667db6736e81335316c1eNate Begeman return false; 1280f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 1290f3257a3302b60c128a667db6736e81335316c1eNate Begeman 130cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isOprShiftImm - Returns true if the specified operand is a shift opcode with 131cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// a immediate shift count less than 32. 132cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isOprShiftImm(SDNode *N, unsigned& Opc, unsigned& SH) { 133cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Opc = N->getOpcode(); 134cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return (Opc == ISD::SHL || Opc == ISD::SRL || Opc == ISD::SRA) && 135cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isIntImmediate(N->getOperand(1).Val, SH) && SH < 32; 136cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 137cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 138cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s with 139cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// any number of 0s on either side. The 1s are allowed to wrap from LSB to 140cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 0x0F0F0000 is 141cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// not, since all 1s are not contiguous. 142cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME) { 143cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isShiftedMask_32(Val)) { 144cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first non-zero bit 145cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman MB = CountLeadingZeros_32(Val); 146cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first zero bit after the run of ones 147cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman ME = CountLeadingZeros_32((Val - 1) ^ Val); 148cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return true; 1492fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } else { 1502fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner Val = ~Val; // invert mask 1512fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner if (isShiftedMask_32(Val)) { 1522fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first zero bit 1532fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner ME = CountLeadingZeros_32(Val) - 1; 1542fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first one bit after the run of zeros 1552fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner MB = CountLeadingZeros_32((Val - 1) ^ Val) + 1; 1562fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner return true; 1572fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } 158cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 159cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // no run present 160cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 161cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 162cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 163cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isRotateAndMask - Returns true if Mask and Shift can be folded in to a rotate 164cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// and mask opcode and mask operation. 165cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRotateAndMask(SDNode *N, unsigned Mask, bool IsShiftMask, 166cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned &SH, unsigned &MB, unsigned &ME) { 167cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Shift = 32; 168cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Indeterminant = ~0; // bit mask marking indeterminant results 169cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Opcode = N->getOpcode(); 170cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (!isIntImmediate(N->getOperand(1).Val, Shift) || (Shift > 31)) 171cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 172cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 173cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Opcode == ISD::SHL) { 174cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift left to mask if it comes first 175cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask << Shift; 176cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 177cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu << Shift); 178cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else if (Opcode == ISD::SRA || Opcode == ISD::SRL) { 179cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift right 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 // adjust for the left rotate 184cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Shift = 32 - Shift; 185cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 186cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 187cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 188cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 189cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // if the mask doesn't intersect any Indeterminant bits 190cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Mask && !(Mask & Indeterminant)) { 191cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = Shift; 192cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // make sure the mask is still a mask (wrap arounds may not be) 193cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return isRunOfOnes(Mask, MB, ME); 194cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 195cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 196cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 197cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 1980f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isOpcWithIntImmediate - This method tests to see if the node is a specific 1990f3257a3302b60c128a667db6736e81335316c1eNate Begeman// opcode and that it has a immediate integer right operand. 2000f3257a3302b60c128a667db6736e81335316c1eNate Begeman// If so Imm will receive the 32 bit value. 2010f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isOpcWithIntImmediate(SDNode *N, unsigned Opc, unsigned& Imm) { 2020f3257a3302b60c128a667db6736e81335316c1eNate Begeman return N->getOpcode() == Opc && isIntImmediate(N->getOperand(1).Val, Imm); 2030f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 2040f3257a3302b60c128a667db6736e81335316c1eNate Begeman 2050f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isOprNot - Returns true if the specified operand is an xor with immediate -1. 2060f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isOprNot(SDNode *N) { 2070f3257a3302b60c128a667db6736e81335316c1eNate Begeman unsigned Imm; 2080f3257a3302b60c128a667db6736e81335316c1eNate Begeman return isOpcWithIntImmediate(N, ISD::XOR, Imm) && (signed)Imm == -1; 2090f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 2100f3257a3302b60c128a667db6736e81335316c1eNate Begeman 211a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Immediate constant composers. 212a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Lo16 - grabs the lo 16 bits from a 32 bit constant. 213a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Hi16 - grabs the hi 16 bits from a 32 bit constant. 214a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// HA16 - computes the hi bits required if the lo bits are add/subtracted in 215a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// arithmethically. 216a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic unsigned Lo16(unsigned x) { return x & 0x0000FFFF; } 217a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic unsigned Hi16(unsigned x) { return Lo16(x >> 16); } 218a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic unsigned HA16(unsigned x) { return Hi16((signed)x - (signed short)x); } 219a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 220a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// isIntImmediate - This method tests to see if a constant operand. 221a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// If so Imm will receive the 32 bit value. 222a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic bool isIntImmediate(SDOperand N, unsigned& Imm) { 223a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 224a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Imm = (unsigned)CN->getSignExtended(); 225a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return true; 226a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 227a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return false; 228a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 229a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 23002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// SelectBitfieldInsert - turn an or of two masked values into 23102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// the rotate left word immediate then mask insert (rlwimi) instruction. 23202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// Returns true on success, false if the caller still needs to select OR. 23302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 23402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// Patterns matched: 23502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 1. or shl, and 5. or and, and 23602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 2. or and, shl 6. or shl, shr 23702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 3. or shr, and 7. or shr, shl 23802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 4. or and, shr 23902b88a4586704f34bc65afca3348453eae69d1d3Nate BegemanSDNode *PPC32DAGToDAGISel::SelectBitfieldInsert(SDNode *N) { 24002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool IsRotate = false; 24102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned TgtMask = 0xFFFFFFFF, InsMask = 0xFFFFFFFF, SH = 0; 24202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Value; 24302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 24402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op0 = N->getOperand(0); 24502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op1 = N->getOperand(1); 24602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 24702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Op0Opc = Op0.getOpcode(); 24802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Op1Opc = Op1.getOpcode(); 24902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 25002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Verify that we have the correct opcodes 25102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (ISD::SHL != Op0Opc && ISD::SRL != Op0Opc && ISD::AND != Op0Opc) 25202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return false; 25302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (ISD::SHL != Op1Opc && ISD::SRL != Op1Opc && ISD::AND != Op1Opc) 25402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return false; 25502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 25602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Generate Mask value for Target 25702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op0.getOperand(1), Value)) { 25802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman switch(Op0Opc) { 25902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::SHL: TgtMask <<= Value; break; 26002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::SRL: TgtMask >>= Value; break; 26102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::AND: TgtMask &= Value; break; 26202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 26302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } else { 26402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 26502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 26602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 26702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Generate Mask value for Insert 26802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op1.getOperand(1), Value)) { 26902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman switch(Op1Opc) { 27002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::SHL: 27102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Value; 27202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman InsMask <<= SH; 27302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op0Opc == ISD::SRL) IsRotate = true; 27402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman break; 27502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::SRL: 27602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Value; 27702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman InsMask >>= SH; 27802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = 32-SH; 27902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op0Opc == ISD::SHL) IsRotate = true; 28002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman break; 28102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::AND: 28202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman InsMask &= Value; 28302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman break; 28402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 28502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } else { 28602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 28702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 28802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 28902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // If both of the inputs are ANDs and one of them has a logical shift by 29002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // constant as its input, make that AND the inserted value so that we can 29102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // combine the shift into the rotate part of the rlwimi instruction 29202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool IsAndWithShiftOp = false; 29302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op0Opc == ISD::AND && Op1Opc == ISD::AND) { 29402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op1.getOperand(0).getOpcode() == ISD::SHL || 29502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op1.getOperand(0).getOpcode() == ISD::SRL) { 29602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op1.getOperand(0).getOperand(1), Value)) { 29702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Op1.getOperand(0).getOpcode() == ISD::SHL ? Value : 32 - Value; 29802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman IsAndWithShiftOp = true; 29902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 30002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } else if (Op0.getOperand(0).getOpcode() == ISD::SHL || 30102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0.getOperand(0).getOpcode() == ISD::SRL) { 30202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op0.getOperand(0).getOperand(1), Value)) { 30302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman std::swap(Op0, Op1); 30402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman std::swap(TgtMask, InsMask); 30502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Op1.getOperand(0).getOpcode() == ISD::SHL ? Value : 32 - Value; 30602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman IsAndWithShiftOp = true; 30702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 30802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 30902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 31002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 31102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Verify that the Target mask and Insert mask together form a full word mask 31202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // and that the Insert mask is a run of set bits (which implies both are runs 31302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // of set bits). Given that, Select the arguments and generate the rlwimi 31402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // instruction. 31502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned MB, ME; 31602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (((TgtMask & InsMask) == 0) && isRunOfOnes(InsMask, MB, ME)) { 31702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool fullMask = (TgtMask ^ InsMask) == 0xFFFFFFFF; 31802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool Op0IsAND = Op0Opc == ISD::AND; 31902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Check for rotlwi / rotrwi here, a special case of bitfield insert 32002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // where both bitfield halves are sourced from the same value. 32102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (IsRotate && fullMask && 32202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman N->getOperand(0).getOperand(0) == N->getOperand(1).getOperand(0)) { 32302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0 = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, 32402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Select(N->getOperand(0).getOperand(0)), 32502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman getI32Imm(SH), getI32Imm(0), getI32Imm(31)); 32602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return Op0.Val; 32702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 32802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Tmp1 = (Op0IsAND && fullMask) ? Select(Op0.getOperand(0)) 32902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman : Select(Op0); 33002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Tmp2 = IsAndWithShiftOp ? Select(Op1.getOperand(0).getOperand(0)) 33102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman : Select(Op1.getOperand(0)); 33202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0 = CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, Tmp1, Tmp2, 33302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 33402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return Op0.Val; 33502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 33602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 33702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman} 33802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 339a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// SelectIntImmediateExpr - Choose code for integer operations with an immediate 340a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// operand. 341a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris LattnerSDNode *PPC32DAGToDAGISel::SelectIntImmediateExpr(SDOperand LHS, SDOperand RHS, 342a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned OCHi, unsigned OCLo, 343a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner bool IsArithmetic, 344a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner bool Negate) { 345a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Check to make sure this is a constant. 346a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ConstantSDNode *CN = dyn_cast<ConstantSDNode>(RHS); 347a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Exit if not a constant. 348a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (!CN) return 0; 349a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Extract immediate. 350a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned C = (unsigned)CN->getValue(); 351a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Negate if required (ISD::SUB). 352a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Negate) C = -C; 353a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Get the hi and lo portions of constant. 354a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned Hi = IsArithmetic ? HA16(C) : Hi16(C); 355a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned Lo = Lo16(C); 356a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 357a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // If two instructions are needed and usage indicates it would be better to 358a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // load immediate into a register, bail out. 359a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Hi && Lo && CN->use_size() > 2) return false; 360a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 361a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Select the first operand. 362a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Opr0 = Select(LHS); 363a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 364a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Lo) // Add in the lo-part. 365a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Opr0 = CurDAG->getTargetNode(OCLo, MVT::i32, Opr0, getI32Imm(Lo)); 366a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Hi) // Add in the hi-part. 367a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Opr0 = CurDAG->getTargetNode(OCHi, MVT::i32, Opr0, getI32Imm(Hi)); 368a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return Opr0.Val; 369a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 370a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 3719944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner/// SelectAddr - Given the specified address, return the two operands for a 3729944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner/// load/store instruction, and return true if it should be an indexed [r+r] 3739944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner/// operation. 3749944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattnerbool PPC32DAGToDAGISel::SelectAddr(SDOperand Addr, SDOperand &Op1, 3759944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner SDOperand &Op2) { 3769944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner unsigned imm = 0; 3779944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (Addr.getOpcode() == ISD::ADD) { 3789944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (isIntImmediate(Addr.getOperand(1), imm) && isInt16(imm)) { 3799944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = getI32Imm(Lo16(imm)); 380e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner if (FrameIndexSDNode *FI = 381e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner dyn_cast<FrameIndexSDNode>(Addr.getOperand(0))) { 3829944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner ++FrameOff; 383e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner Op2 = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 3849944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 3859944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = Select(Addr.getOperand(0)); 3869944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 3879944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 3889944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 3899944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = Select(Addr.getOperand(0)); 3909944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = Select(Addr.getOperand(1)); 3919944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return true; // [r+r] 3929944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 3939944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 3949944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 3959944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner // Now check if we're dealing with a global, and whether or not we should emit 3969944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner // an optimized load or store for statics. 3979944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (GlobalAddressSDNode *GN = dyn_cast<GlobalAddressSDNode>(Addr)) { 3989944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner GlobalValue *GV = GN->getGlobal(); 3999944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (!GV->hasWeakLinkage() && !GV->isExternal()) { 4009944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = CurDAG->getTargetGlobalAddress(GV, MVT::i32); 4019944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (PICEnabled) 4029944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(), 4039944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1); 4049944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner else 4059944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::LIS, MVT::i32, Op1); 4069944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4079944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 408e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } else if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Addr)) { 4099944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = getI32Imm(0); 410e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner Op2 = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 4119944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4129944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Addr)) { 4139944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = Addr; 4149944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (PICEnabled) 4159944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(),Op1); 4169944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner else 4179944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::LIS, MVT::i32, Op1); 4189944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4199944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4209944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = getI32Imm(0); 4219944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = Select(Addr); 4229944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4239944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner} 424a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 4252fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// SelectCC - Select a comparison of the specified values with the specified 4262fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// condition code, returning the CR# of the expression. 4272fbb4579d6d6bbde8387283b78307c2ea477a312Chris LattnerSDOperand PPC32DAGToDAGISel::SelectCC(SDOperand LHS, SDOperand RHS, 4282fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC) { 4292fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Always select the LHS. 4302fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner LHS = Select(LHS); 4312fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 4322fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Use U to determine whether the SETCC immediate range is signed or not. 4332fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (MVT::isInteger(LHS.getValueType())) { 4342fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner bool U = ISD::isUnsignedIntSetCC(CC); 4352fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner unsigned Imm; 4362fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (isIntImmediate(RHS, Imm) && 4372fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ((U && isUInt16(Imm)) || (!U && isInt16(Imm)))) 4382fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return CurDAG->getTargetNode(U ? PPC::CMPLWI : PPC::CMPWI, MVT::i32, 4392fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner LHS, getI32Imm(Lo16(Imm))); 4402fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return CurDAG->getTargetNode(U ? PPC::CMPLW : PPC::CMPW, MVT::i32, 4412fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner LHS, Select(RHS)); 4422fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 4432fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return CurDAG->getTargetNode(PPC::FCMPU, MVT::i32, LHS, Select(RHS)); 4442fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 4452fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 4462fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 4472fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// getBCCForSetCC - Returns the PowerPC condition branch mnemonic corresponding 4482fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// to Condition. 4492fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattnerstatic unsigned getBCCForSetCC(ISD::CondCode CC) { 4502fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner switch (CC) { 4512fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 4522fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETEQ: return PPC::BEQ; 4532fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETNE: return PPC::BNE; 4542fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULT: 4552fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLT: return PPC::BLT; 4562fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULE: 4572fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLE: return PPC::BLE; 4582fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGT: 4592fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGT: return PPC::BGT; 4602fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGE: 4612fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGE: return PPC::BGE; 4622fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 4632fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return 0; 4642fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 4652fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 46664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// getCRIdxForSetCC - Return the index of the condition register field 46764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// associated with the SetCC condition, and whether or not the field is 46864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// treated as inverted. That is, lt = 0; ge = 0 inverted. 46964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattnerstatic unsigned getCRIdxForSetCC(ISD::CondCode CC, bool& Inv) { 47064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 47164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 47264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULT: 47364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLT: Inv = false; return 0; 47464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGE: 47564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGE: Inv = true; return 0; 47664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGT: 47764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGT: Inv = false; return 1; 47864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULE: 47964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLE: Inv = true; return 1; 48064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETEQ: Inv = false; return 2; 48164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETNE: Inv = true; return 2; 48264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 48364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner return 0; 48464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner} 4859944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 486047b952e298352fe6feffedf02e359601133f465Chris Lattner// Structure used to return the necessary information to codegen an SDIV as 487047b952e298352fe6feffedf02e359601133f465Chris Lattner// a multiply. 488047b952e298352fe6feffedf02e359601133f465Chris Lattnerstruct ms { 489047b952e298352fe6feffedf02e359601133f465Chris Lattner int m; // magic number 490047b952e298352fe6feffedf02e359601133f465Chris Lattner int s; // shift amount 491047b952e298352fe6feffedf02e359601133f465Chris Lattner}; 492047b952e298352fe6feffedf02e359601133f465Chris Lattner 493047b952e298352fe6feffedf02e359601133f465Chris Lattnerstruct mu { 494047b952e298352fe6feffedf02e359601133f465Chris Lattner unsigned int m; // magic number 495047b952e298352fe6feffedf02e359601133f465Chris Lattner int a; // add indicator 496047b952e298352fe6feffedf02e359601133f465Chris Lattner int s; // shift amount 497047b952e298352fe6feffedf02e359601133f465Chris Lattner}; 498047b952e298352fe6feffedf02e359601133f465Chris Lattner 499047b952e298352fe6feffedf02e359601133f465Chris Lattner/// magic - calculate the magic numbers required to codegen an integer sdiv as 500047b952e298352fe6feffedf02e359601133f465Chris Lattner/// a sequence of multiply and shifts. Requires that the divisor not be 0, 1, 501047b952e298352fe6feffedf02e359601133f465Chris Lattner/// or -1. 502047b952e298352fe6feffedf02e359601133f465Chris Lattnerstatic struct ms magic(int d) { 503047b952e298352fe6feffedf02e359601133f465Chris Lattner int p; 504047b952e298352fe6feffedf02e359601133f465Chris Lattner unsigned int ad, anc, delta, q1, r1, q2, r2, t; 505047b952e298352fe6feffedf02e359601133f465Chris Lattner const unsigned int two31 = 0x80000000U; 506047b952e298352fe6feffedf02e359601133f465Chris Lattner struct ms mag; 507047b952e298352fe6feffedf02e359601133f465Chris Lattner 508047b952e298352fe6feffedf02e359601133f465Chris Lattner ad = abs(d); 509047b952e298352fe6feffedf02e359601133f465Chris Lattner t = two31 + ((unsigned int)d >> 31); 510047b952e298352fe6feffedf02e359601133f465Chris Lattner anc = t - 1 - t%ad; // absolute value of nc 511047b952e298352fe6feffedf02e359601133f465Chris Lattner p = 31; // initialize p 512047b952e298352fe6feffedf02e359601133f465Chris Lattner q1 = two31/anc; // initialize q1 = 2p/abs(nc) 513047b952e298352fe6feffedf02e359601133f465Chris Lattner r1 = two31 - q1*anc; // initialize r1 = rem(2p,abs(nc)) 514047b952e298352fe6feffedf02e359601133f465Chris Lattner q2 = two31/ad; // initialize q2 = 2p/abs(d) 515047b952e298352fe6feffedf02e359601133f465Chris Lattner r2 = two31 - q2*ad; // initialize r2 = rem(2p,abs(d)) 516047b952e298352fe6feffedf02e359601133f465Chris Lattner do { 517047b952e298352fe6feffedf02e359601133f465Chris Lattner p = p + 1; 518047b952e298352fe6feffedf02e359601133f465Chris Lattner q1 = 2*q1; // update q1 = 2p/abs(nc) 519047b952e298352fe6feffedf02e359601133f465Chris Lattner r1 = 2*r1; // update r1 = rem(2p/abs(nc)) 520047b952e298352fe6feffedf02e359601133f465Chris Lattner if (r1 >= anc) { // must be unsigned comparison 521047b952e298352fe6feffedf02e359601133f465Chris Lattner q1 = q1 + 1; 522047b952e298352fe6feffedf02e359601133f465Chris Lattner r1 = r1 - anc; 523047b952e298352fe6feffedf02e359601133f465Chris Lattner } 524047b952e298352fe6feffedf02e359601133f465Chris Lattner q2 = 2*q2; // update q2 = 2p/abs(d) 525047b952e298352fe6feffedf02e359601133f465Chris Lattner r2 = 2*r2; // update r2 = rem(2p/abs(d)) 526047b952e298352fe6feffedf02e359601133f465Chris Lattner if (r2 >= ad) { // must be unsigned comparison 527047b952e298352fe6feffedf02e359601133f465Chris Lattner q2 = q2 + 1; 528047b952e298352fe6feffedf02e359601133f465Chris Lattner r2 = r2 - ad; 529047b952e298352fe6feffedf02e359601133f465Chris Lattner } 530047b952e298352fe6feffedf02e359601133f465Chris Lattner delta = ad - r2; 531047b952e298352fe6feffedf02e359601133f465Chris Lattner } while (q1 < delta || (q1 == delta && r1 == 0)); 532047b952e298352fe6feffedf02e359601133f465Chris Lattner 533047b952e298352fe6feffedf02e359601133f465Chris Lattner mag.m = q2 + 1; 534047b952e298352fe6feffedf02e359601133f465Chris Lattner if (d < 0) mag.m = -mag.m; // resulting magic number 535047b952e298352fe6feffedf02e359601133f465Chris Lattner mag.s = p - 32; // resulting shift 536047b952e298352fe6feffedf02e359601133f465Chris Lattner return mag; 537047b952e298352fe6feffedf02e359601133f465Chris Lattner} 538047b952e298352fe6feffedf02e359601133f465Chris Lattner 539047b952e298352fe6feffedf02e359601133f465Chris Lattner/// magicu - calculate the magic numbers required to codegen an integer udiv as 540047b952e298352fe6feffedf02e359601133f465Chris Lattner/// a sequence of multiply, add and shifts. Requires that the divisor not be 0. 541047b952e298352fe6feffedf02e359601133f465Chris Lattnerstatic struct mu magicu(unsigned d) 542047b952e298352fe6feffedf02e359601133f465Chris Lattner{ 543047b952e298352fe6feffedf02e359601133f465Chris Lattner int p; 544047b952e298352fe6feffedf02e359601133f465Chris Lattner unsigned int nc, delta, q1, r1, q2, r2; 545047b952e298352fe6feffedf02e359601133f465Chris Lattner struct mu magu; 546047b952e298352fe6feffedf02e359601133f465Chris Lattner magu.a = 0; // initialize "add" indicator 547047b952e298352fe6feffedf02e359601133f465Chris Lattner nc = - 1 - (-d)%d; 548047b952e298352fe6feffedf02e359601133f465Chris Lattner p = 31; // initialize p 549047b952e298352fe6feffedf02e359601133f465Chris Lattner q1 = 0x80000000/nc; // initialize q1 = 2p/nc 550047b952e298352fe6feffedf02e359601133f465Chris Lattner r1 = 0x80000000 - q1*nc; // initialize r1 = rem(2p,nc) 551047b952e298352fe6feffedf02e359601133f465Chris Lattner q2 = 0x7FFFFFFF/d; // initialize q2 = (2p-1)/d 552047b952e298352fe6feffedf02e359601133f465Chris Lattner r2 = 0x7FFFFFFF - q2*d; // initialize r2 = rem((2p-1),d) 553047b952e298352fe6feffedf02e359601133f465Chris Lattner do { 554047b952e298352fe6feffedf02e359601133f465Chris Lattner p = p + 1; 555047b952e298352fe6feffedf02e359601133f465Chris Lattner if (r1 >= nc - r1 ) { 556047b952e298352fe6feffedf02e359601133f465Chris Lattner q1 = 2*q1 + 1; // update q1 557047b952e298352fe6feffedf02e359601133f465Chris Lattner r1 = 2*r1 - nc; // update r1 558047b952e298352fe6feffedf02e359601133f465Chris Lattner } 559047b952e298352fe6feffedf02e359601133f465Chris Lattner else { 560047b952e298352fe6feffedf02e359601133f465Chris Lattner q1 = 2*q1; // update q1 561047b952e298352fe6feffedf02e359601133f465Chris Lattner r1 = 2*r1; // update r1 562047b952e298352fe6feffedf02e359601133f465Chris Lattner } 563047b952e298352fe6feffedf02e359601133f465Chris Lattner if (r2 + 1 >= d - r2) { 564047b952e298352fe6feffedf02e359601133f465Chris Lattner if (q2 >= 0x7FFFFFFF) magu.a = 1; 565047b952e298352fe6feffedf02e359601133f465Chris Lattner q2 = 2*q2 + 1; // update q2 566047b952e298352fe6feffedf02e359601133f465Chris Lattner r2 = 2*r2 + 1 - d; // update r2 567047b952e298352fe6feffedf02e359601133f465Chris Lattner } 568047b952e298352fe6feffedf02e359601133f465Chris Lattner else { 569047b952e298352fe6feffedf02e359601133f465Chris Lattner if (q2 >= 0x80000000) magu.a = 1; 570047b952e298352fe6feffedf02e359601133f465Chris Lattner q2 = 2*q2; // update q2 571047b952e298352fe6feffedf02e359601133f465Chris Lattner r2 = 2*r2 + 1; // update r2 572047b952e298352fe6feffedf02e359601133f465Chris Lattner } 573047b952e298352fe6feffedf02e359601133f465Chris Lattner delta = d - 1 - r2; 574047b952e298352fe6feffedf02e359601133f465Chris Lattner } while (p < 64 && (q1 < delta || (q1 == delta && r1 == 0))); 575047b952e298352fe6feffedf02e359601133f465Chris Lattner magu.m = q2 + 1; // resulting magic number 576047b952e298352fe6feffedf02e359601133f465Chris Lattner magu.s = p - 32; // resulting shift 577047b952e298352fe6feffedf02e359601133f465Chris Lattner return magu; 578047b952e298352fe6feffedf02e359601133f465Chris Lattner} 579047b952e298352fe6feffedf02e359601133f465Chris Lattner 580047b952e298352fe6feffedf02e359601133f465Chris Lattner/// BuildSDIVSequence - Given an ISD::SDIV node expressing a divide by constant, 581047b952e298352fe6feffedf02e359601133f465Chris Lattner/// return a DAG expression to select that will generate the same value by 582047b952e298352fe6feffedf02e359601133f465Chris Lattner/// multiplying by a magic number. See: 583047b952e298352fe6feffedf02e359601133f465Chris Lattner/// <http://the.wall.riscom.net/books/proc/ppc/cwg/code2.html> 584047b952e298352fe6feffedf02e359601133f465Chris LattnerSDOperand PPC32DAGToDAGISel::BuildSDIVSequence(SDNode *N) { 585047b952e298352fe6feffedf02e359601133f465Chris Lattner int d = (int)cast<ConstantSDNode>(N->getOperand(1))->getValue(); 586047b952e298352fe6feffedf02e359601133f465Chris Lattner ms magics = magic(d); 587047b952e298352fe6feffedf02e359601133f465Chris Lattner // Multiply the numerator (operand 0) by the magic value 588047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand Q = CurDAG->getNode(ISD::MULHS, MVT::i32, N->getOperand(0), 589047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->getConstant(magics.m, MVT::i32)); 590047b952e298352fe6feffedf02e359601133f465Chris Lattner // If d > 0 and m < 0, add the numerator 591047b952e298352fe6feffedf02e359601133f465Chris Lattner if (d > 0 && magics.m < 0) 592047b952e298352fe6feffedf02e359601133f465Chris Lattner Q = CurDAG->getNode(ISD::ADD, MVT::i32, Q, N->getOperand(0)); 593047b952e298352fe6feffedf02e359601133f465Chris Lattner // If d < 0 and m > 0, subtract the numerator. 594047b952e298352fe6feffedf02e359601133f465Chris Lattner if (d < 0 && magics.m > 0) 595047b952e298352fe6feffedf02e359601133f465Chris Lattner Q = CurDAG->getNode(ISD::SUB, MVT::i32, Q, N->getOperand(0)); 596047b952e298352fe6feffedf02e359601133f465Chris Lattner // Shift right algebraic if shift value is nonzero 597047b952e298352fe6feffedf02e359601133f465Chris Lattner if (magics.s > 0) 598047b952e298352fe6feffedf02e359601133f465Chris Lattner Q = CurDAG->getNode(ISD::SRA, MVT::i32, Q, 599047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->getConstant(magics.s, MVT::i32)); 600047b952e298352fe6feffedf02e359601133f465Chris Lattner // Extract the sign bit and add it to the quotient 601047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand T = 602047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->getNode(ISD::SRL, MVT::i32, Q, CurDAG->getConstant(31, MVT::i32)); 603047b952e298352fe6feffedf02e359601133f465Chris Lattner return CurDAG->getNode(ISD::ADD, MVT::i32, Q, T); 604047b952e298352fe6feffedf02e359601133f465Chris Lattner} 605047b952e298352fe6feffedf02e359601133f465Chris Lattner 606047b952e298352fe6feffedf02e359601133f465Chris Lattner/// BuildUDIVSequence - Given an ISD::UDIV node expressing a divide by constant, 607047b952e298352fe6feffedf02e359601133f465Chris Lattner/// return a DAG expression to select that will generate the same value by 608047b952e298352fe6feffedf02e359601133f465Chris Lattner/// multiplying by a magic number. See: 609047b952e298352fe6feffedf02e359601133f465Chris Lattner/// <http://the.wall.riscom.net/books/proc/ppc/cwg/code2.html> 610047b952e298352fe6feffedf02e359601133f465Chris LattnerSDOperand PPC32DAGToDAGISel::BuildUDIVSequence(SDNode *N) { 611047b952e298352fe6feffedf02e359601133f465Chris Lattner unsigned d = (unsigned)cast<ConstantSDNode>(N->getOperand(1))->getValue(); 612047b952e298352fe6feffedf02e359601133f465Chris Lattner mu magics = magicu(d); 613047b952e298352fe6feffedf02e359601133f465Chris Lattner // Multiply the numerator (operand 0) by the magic value 614047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand Q = CurDAG->getNode(ISD::MULHU, MVT::i32, N->getOperand(0), 615047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->getConstant(magics.m, MVT::i32)); 616047b952e298352fe6feffedf02e359601133f465Chris Lattner if (magics.a == 0) { 617047b952e298352fe6feffedf02e359601133f465Chris Lattner return CurDAG->getNode(ISD::SRL, MVT::i32, Q, 618047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->getConstant(magics.s, MVT::i32)); 619047b952e298352fe6feffedf02e359601133f465Chris Lattner } else { 620047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand NPQ = CurDAG->getNode(ISD::SUB, MVT::i32, N->getOperand(0), Q); 621047b952e298352fe6feffedf02e359601133f465Chris Lattner NPQ = CurDAG->getNode(ISD::SRL, MVT::i32, NPQ, 622047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->getConstant(1, MVT::i32)); 623047b952e298352fe6feffedf02e359601133f465Chris Lattner NPQ = CurDAG->getNode(ISD::ADD, MVT::i32, NPQ, Q); 624047b952e298352fe6feffedf02e359601133f465Chris Lattner return CurDAG->getNode(ISD::SRL, MVT::i32, NPQ, 625047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->getConstant(magics.s-1, MVT::i32)); 626047b952e298352fe6feffedf02e359601133f465Chris Lattner } 627047b952e298352fe6feffedf02e359601133f465Chris Lattner} 628047b952e298352fe6feffedf02e359601133f465Chris Lattner 629a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Select - Convert the specified operand from a target-independent to a 630a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// target-specific node if it hasn't already been changed. 631a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris LattnerSDOperand PPC32DAGToDAGISel::Select(SDOperand Op) { 632a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDNode *N = Op.Val; 633a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (N->getOpcode() >= ISD::BUILTIN_OP_END) 634a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return Op; // Already selected. 635a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 636a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOpcode()) { 637a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner default: 638a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner std::cerr << "Cannot yet select: "; 639a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->dump(); 640a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner std::cerr << "\n"; 641a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner abort(); 642a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::EntryToken: // These leaves remain the same. 643a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return Op; 644a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::TokenFactor: { 645a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand New; 646a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (N->getNumOperands() == 2) { 647a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Op0 = Select(N->getOperand(0)); 648a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Op1 = Select(N->getOperand(1)); 649a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner New = CurDAG->getNode(ISD::TokenFactor, MVT::Other, Op0, Op1); 650a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } else { 651a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner std::vector<SDOperand> Ops; 652a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) 6537e65997c43cc91a5e6eaa0f460b844ef1b5d2fb1Chris Lattner Ops.push_back(Select(N->getOperand(i))); 654a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner New = CurDAG->getNode(ISD::TokenFactor, MVT::Other, Ops); 655a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 656a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 657a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (New.Val != N) { 658a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->ReplaceAllUsesWith(N, New.Val); 659a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N = New.Val; 660a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 661a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 662a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 663a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::CopyFromReg: { 664a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Chain = Select(N->getOperand(0)); 665a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Chain == N->getOperand(0)) return Op; // No change 666a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand New = CurDAG->getCopyFromReg(Chain, 667a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner cast<RegisterSDNode>(N->getOperand(1))->getReg(), N->getValueType(0)); 668a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return New.getValue(Op.ResNo); 669a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 670a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::CopyToReg: { 671a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Chain = Select(N->getOperand(0)); 672a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Reg = N->getOperand(1); 673a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Val = Select(N->getOperand(2)); 674a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Chain != N->getOperand(0) || Val != N->getOperand(2)) { 675a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand New = CurDAG->getNode(ISD::CopyToReg, MVT::Other, 676a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Chain, Reg, Val); 677a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->ReplaceAllUsesWith(N, New.Val); 678a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N = New.Val; 679a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 680a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 681a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 682a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::Constant: { 683a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner assert(N->getValueType(0) == MVT::i32); 684a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned v = (unsigned)cast<ConstantSDNode>(N)->getValue(); 685a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned Hi = HA16(v); 686a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned Lo = Lo16(v); 687a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman if (Hi && Lo) { 688a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman SDOperand Top = CurDAG->getTargetNode(PPC::LIS, MVT::i32, 689a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman getI32Imm(v >> 16)); 690a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::ORI, Top, getI32Imm(v & 0xFFFF)); 691a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman } else if (Lo) { 692a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::LI, getI32Imm(v)); 693a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } else { 694a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::LIS, getI32Imm(v >> 16)); 695a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 696a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman break; 697a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 6982fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner case ISD::ConstantFP: { // FIXME: this should get sucked into the legalizer 6992fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner MachineConstantPool *CP = CurDAG->getMachineFunction().getConstantPool(); 7002fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner Constant *CFP = ConstantFP::get(Type::FloatTy, 7012fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner cast<ConstantFPSDNode>(N)->getValue()); 7022fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner SDOperand CPN = CurDAG->getConstantPool(CP->getConstantPoolIndex(CFP), 7032fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner MVT::i32); 7042fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner SDOperand Tmp; 7052fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner if (PICEnabled) 7062fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner Tmp = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(),CPN); 7072fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner else 7082fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner Tmp = CurDAG->getTargetNode(PPC::LIS, MVT::i32, CPN); 7092fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner CurDAG->SelectNodeTo(N, N->getValueType(0), PPC::LFS, CPN, Tmp); 7102fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner break; 7112fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } 7122b54400f085391a247dd2c3fffc9f36f7b2dc867Chris Lattner case ISD::UNDEF: 7132b54400f085391a247dd2c3fffc9f36f7b2dc867Chris Lattner if (N->getValueType(0) == MVT::i32) 7142b54400f085391a247dd2c3fffc9f36f7b2dc867Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::IMPLICIT_DEF_GPR); 7152b54400f085391a247dd2c3fffc9f36f7b2dc867Chris Lattner else 7162b54400f085391a247dd2c3fffc9f36f7b2dc867Chris Lattner CurDAG->SelectNodeTo(N, N->getValueType(0), PPC::IMPLICIT_DEF_FP); 7172b54400f085391a247dd2c3fffc9f36f7b2dc867Chris Lattner break; 718e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner case ISD::FrameIndex: { 719e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner int FI = cast<FrameIndexSDNode>(N)->getIndex(); 720e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::ADDI, 721e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner CurDAG->getTargetFrameIndex(FI, MVT::i32), 722e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner getI32Imm(0)); 723e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner break; 724e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } 72534e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner case ISD::ConstantPool: { 72634e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner unsigned CPIIdx = cast<ConstantPoolSDNode>(N)->getIndex(); 72734e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner SDOperand Tmp, CPI = CurDAG->getTargetConstantPool(CPIIdx, MVT::i32); 72834e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner if (PICEnabled) 72934e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner Tmp = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(),CPI); 73034e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner else 73134e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner Tmp = CurDAG->getTargetNode(PPC::LIS, MVT::i32, CPI); 73234e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::LA, Tmp, CPI); 73334e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner break; 73434e17052a77e1a52cae58b2f6d203c663af97eceChris Lattner } 7354416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner case ISD::GlobalAddress: { 7364416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalValue *GV = cast<GlobalAddressSDNode>(N)->getGlobal(); 7374416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SDOperand Tmp; 7384416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SDOperand GA = CurDAG->getTargetGlobalAddress(GV, MVT::i32); 7399944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (PICEnabled) 7409944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Tmp = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(), GA); 7419944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner else 7424416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner Tmp = CurDAG->getTargetNode(PPC::LIS, MVT::i32, GA); 7439944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 7444416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (GV->hasWeakLinkage() || GV->isExternal()) 7454416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::LWZ, GA, Tmp); 7464416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner else 7474416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::LA, Tmp, GA); 7484416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner break; 7494416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 750305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::SIGN_EXTEND_INREG: 751305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman switch(cast<VTSDNode>(N->getOperand(1))->getVT()) { 752305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman default: assert(0 && "Illegal type in SIGN_EXTEND_INREG"); break; 753305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case MVT::i16: 754305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::EXTSH, Select(N->getOperand(0))); 755305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman break; 756305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case MVT::i8: 757305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::EXTSB, Select(N->getOperand(0))); 758305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman break; 759305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman } 760305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman break; 761305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::CTLZ: 762305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman assert(N->getValueType(0) == MVT::i32); 763305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::CNTLZW, Select(N->getOperand(0))); 764305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman break; 765a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::ADD: { 766a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner MVT::ValueType Ty = N->getValueType(0); 767a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Ty == MVT::i32) { 768a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (SDNode *I = SelectIntImmediateExpr(N->getOperand(0), N->getOperand(1), 769a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner PPC::ADDIS, PPC::ADDI, true)) { 770a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->ReplaceAllUsesWith(N, I); 771a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N = I; 772a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } else { 773a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, PPC::ADD, Select(N->getOperand(0)), 774a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1))); 775a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 776a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 777a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 778a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 779a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (!NoExcessFPPrecision) { // Match FMA ops 780a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (N->getOperand(0).getOpcode() == ISD::MUL && 781a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(0).Val->hasOneUse()) { 782a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 783a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, Ty == MVT::f64 ? PPC::FMADD : PPC::FMADDS, 784a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(0)), 785a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(1)), 786a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1))); 787a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 788a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } else if (N->getOperand(1).getOpcode() == ISD::MUL && 789a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(1).hasOneUse()) { 790a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 791a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, Ty == MVT::f64 ? PPC::FMADD : PPC::FMADDS, 792a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(0)), 793a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(1)), 794a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0))); 795a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 796a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 797a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 798a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 799a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, Ty == MVT::f64 ? PPC::FADD : PPC::FADDS, 800a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0)), Select(N->getOperand(1))); 801a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 802a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 803a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::SUB: { 804a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner MVT::ValueType Ty = N->getValueType(0); 805a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Ty == MVT::i32) { 806a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned Imm; 807a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (isIntImmediate(N->getOperand(0), Imm) && isInt16(Imm)) { 808c6b0717a6caa32fc9029fd1337af4bf0d07b54e8Nate Begeman if (0 == Imm) 809c6b0717a6caa32fc9029fd1337af4bf0d07b54e8Nate Begeman CurDAG->SelectNodeTo(N, Ty, PPC::NEG, Select(N->getOperand(1))); 810c6b0717a6caa32fc9029fd1337af4bf0d07b54e8Nate Begeman else 811c6b0717a6caa32fc9029fd1337af4bf0d07b54e8Nate Begeman CurDAG->SelectNodeTo(N, Ty, PPC::SUBFIC, Select(N->getOperand(1)), 812c6b0717a6caa32fc9029fd1337af4bf0d07b54e8Nate Begeman getI32Imm(Lo16(Imm))); 813a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 814a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 815a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (SDNode *I = SelectIntImmediateExpr(N->getOperand(0), N->getOperand(1), 816a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner PPC::ADDIS, PPC::ADDI, true, true)) { 817a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->ReplaceAllUsesWith(N, I); 818a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N = I; 819a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } else { 820a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, PPC::SUBF, Select(N->getOperand(1)), 821a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0))); 822a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 823a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 824a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 825a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 826a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (!NoExcessFPPrecision) { // Match FMA ops 827a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (N->getOperand(0).getOpcode() == ISD::MUL && 828a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(0).Val->hasOneUse()) { 829a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 830a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, Ty == MVT::f64 ? PPC::FMSUB : PPC::FMSUBS, 831a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(0)), 832a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(1)), 833a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1))); 834a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 835a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } else if (N->getOperand(1).getOpcode() == ISD::MUL && 836a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(1).Val->hasOneUse()) { 837a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 838a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, Ty == MVT::f64 ? PPC::FNMSUB : PPC::FNMSUBS, 839a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(0)), 840a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(1)), 841a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0))); 842a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 843a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 844a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 845a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, Ty == MVT::f64 ? PPC::FSUB : PPC::FSUBS, 846a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0)), 847a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1))); 848a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 84926653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 850b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman case ISD::MUL: { 851b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman unsigned Imm, Opc; 852b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman if (isIntImmediate(N->getOperand(1), Imm) && isInt16(Imm)) { 853b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman CurDAG->SelectNodeTo(N, N->getValueType(0), PPC::MULLI, 854b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman Select(N->getOperand(0)), getI32Imm(Lo16(Imm))); 855b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman break; 856b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman } 857b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman switch (N->getValueType(0)) { 858b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman default: assert(0 && "Unhandled multiply type!"); 859b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman case MVT::i32: Opc = PPC::MULLW; break; 860b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman case MVT::f32: Opc = PPC::FMULS; break; 861b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman case MVT::f64: Opc = PPC::FMUL; break; 862b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman } 8638784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, Opc, Select(N->getOperand(0)), 864b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman Select(N->getOperand(1))); 865b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman break; 866b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman } 8678784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner case ISD::SDIV: { 8688784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner unsigned Imm; 8698784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if (isIntImmediate(N->getOperand(1), Imm)) { 8708784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if ((signed)Imm > 0 && isPowerOf2_32(Imm)) { 8718784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand Op = 8728784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 8738784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner Select(N->getOperand(0)), 8748784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner getI32Imm(Log2_32(Imm))); 8758784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::ADDZE, 8768784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner Op.getValue(0), Op.getValue(1)); 8778784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner break; 8788784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } else if ((signed)Imm < 0 && isPowerOf2_32(-Imm)) { 8798784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand Op = 8808784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::Flag, MVT::i32, 8818784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner Select(N->getOperand(0)), 8828784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner getI32Imm(Log2_32(-Imm))); 8838784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand PT = 8848784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, Op.getValue(1), 8858784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner Op.getValue(0)); 8868784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::NEG, PT); 8878784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner break; 888047b952e298352fe6feffedf02e359601133f465Chris Lattner } else if (Imm) { 889047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand Result = Select(BuildSDIVSequence(N)); 890047b952e298352fe6feffedf02e359601133f465Chris Lattner assert(Result.ResNo == 0); 891047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->ReplaceAllUsesWith(N, Result.Val); 892047b952e298352fe6feffedf02e359601133f465Chris Lattner N = Result.Val; 893047b952e298352fe6feffedf02e359601133f465Chris Lattner break; 8948784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 8958784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 896047b952e298352fe6feffedf02e359601133f465Chris Lattner 897047b952e298352fe6feffedf02e359601133f465Chris Lattner unsigned Opc; 898047b952e298352fe6feffedf02e359601133f465Chris Lattner switch (N->getValueType(0)) { 899047b952e298352fe6feffedf02e359601133f465Chris Lattner default: assert(0 && "Unknown type to ISD::SDIV"); break; 900047b952e298352fe6feffedf02e359601133f465Chris Lattner case MVT::i32: Opc = PPC::DIVW; break; 901047b952e298352fe6feffedf02e359601133f465Chris Lattner case MVT::f32: Opc = PPC::FDIVS; break; 902047b952e298352fe6feffedf02e359601133f465Chris Lattner case MVT::f64: Opc = PPC::FDIV; break; 903047b952e298352fe6feffedf02e359601133f465Chris Lattner } 904047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->SelectNodeTo(N, N->getValueType(0), Opc, Select(N->getOperand(0)), 905047b952e298352fe6feffedf02e359601133f465Chris Lattner Select(N->getOperand(1))); 906047b952e298352fe6feffedf02e359601133f465Chris Lattner break; 907047b952e298352fe6feffedf02e359601133f465Chris Lattner } 908047b952e298352fe6feffedf02e359601133f465Chris Lattner case ISD::UDIV: { 909047b952e298352fe6feffedf02e359601133f465Chris Lattner // If this is a divide by constant, we can emit code using some magic 910047b952e298352fe6feffedf02e359601133f465Chris Lattner // constants to implement it as a multiply instead. 911047b952e298352fe6feffedf02e359601133f465Chris Lattner unsigned Imm; 912a9317ed361847c96989664b84ae8502a783a9956Chris Lattner if (isIntImmediate(N->getOperand(1), Imm) && Imm) { 913047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand Result = Select(BuildUDIVSequence(N)); 914047b952e298352fe6feffedf02e359601133f465Chris Lattner assert(Result.ResNo == 0); 915047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->ReplaceAllUsesWith(N, Result.Val); 916047b952e298352fe6feffedf02e359601133f465Chris Lattner N = Result.Val; 917047b952e298352fe6feffedf02e359601133f465Chris Lattner break; 918047b952e298352fe6feffedf02e359601133f465Chris Lattner } 919047b952e298352fe6feffedf02e359601133f465Chris Lattner 920047b952e298352fe6feffedf02e359601133f465Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::DIVWU, Select(N->getOperand(0)), 921047b952e298352fe6feffedf02e359601133f465Chris Lattner Select(N->getOperand(1))); 922047b952e298352fe6feffedf02e359601133f465Chris Lattner break; 923047b952e298352fe6feffedf02e359601133f465Chris Lattner } 924305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::MULHS: 925b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman assert(N->getValueType(0) == MVT::i32); 926305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::MULHW, Select(N->getOperand(0)), 927305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman Select(N->getOperand(1))); 928b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman break; 929305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::MULHU: 930b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman assert(N->getValueType(0) == MVT::i32); 931305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::MULHWU, Select(N->getOperand(0)), 932305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman Select(N->getOperand(1))); 933b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman break; 934cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman case ISD::AND: { 935a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned Imm; 936cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and of a value rotated between 0 and 31 bits and then and'd 937cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // with a mask, emit rlwinm 938cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isIntImmediate(N->getOperand(1), Imm) && (isShiftedMask_32(Imm) || 939cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isShiftedMask_32(~Imm))) { 940cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SDOperand Val; 941a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned SH, MB, ME; 942cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isRotateAndMask(N->getOperand(0).Val, Imm, false, SH, MB, ME)) { 943cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Val = Select(N->getOperand(0).getOperand(0)); 944cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 945cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Val = Select(N->getOperand(0)); 946cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isRunOfOnes(Imm, MB, ME); 947cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = 0; 948cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 949cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, Val, getI32Imm(SH), 950cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman getI32Imm(MB), getI32Imm(ME)); 951cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman break; 952cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 953cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and with an immediate that isn't a mask, then codegen it as 954cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // high and low 16 bit immediate ands. 955cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (SDNode *I = SelectIntImmediateExpr(N->getOperand(0), 956cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman N->getOperand(1), 957cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman PPC::ANDISo, PPC::ANDIo)) { 958cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman CurDAG->ReplaceAllUsesWith(N, I); 959cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman N = I; 960cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman break; 961cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 962cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // Finally, check for the case where we are being asked to select 963cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // and (not(a), b) or and (a, not(b)) which can be selected as andc. 964cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isOprNot(N->getOperand(0).Val)) 965cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::ANDC, Select(N->getOperand(1)), 966cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Select(N->getOperand(0).getOperand(0))); 967cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman else if (isOprNot(N->getOperand(1).Val)) 968cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::ANDC, Select(N->getOperand(0)), 969cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Select(N->getOperand(1).getOperand(0))); 970cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman else 971cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::AND, Select(N->getOperand(0)), 972cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Select(N->getOperand(1))); 973cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman break; 974cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 97502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::OR: 97602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (SDNode *I = SelectBitfieldInsert(N)) { 97702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman CurDAG->ReplaceAllUsesWith(N, I); 97802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman N = I; 97902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman break; 98002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 98102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (SDNode *I = SelectIntImmediateExpr(N->getOperand(0), 98202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman N->getOperand(1), 98302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman PPC::ORIS, PPC::ORI)) { 98402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman CurDAG->ReplaceAllUsesWith(N, I); 98502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman N = I; 98602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman break; 98702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 98802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Finally, check for the case where we are being asked to select 98902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // 'or (not(a), b)' or 'or (a, not(b))' which can be selected as orc. 99002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isOprNot(N->getOperand(0).Val)) 99102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::ORC, Select(N->getOperand(1)), 99202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Select(N->getOperand(0).getOperand(0))); 99302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman else if (isOprNot(N->getOperand(1).Val)) 99402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::ORC, Select(N->getOperand(0)), 99502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Select(N->getOperand(1).getOperand(0))); 99602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman else 99702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::OR, Select(N->getOperand(0)), 99802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Select(N->getOperand(1))); 99902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman break; 10000f3257a3302b60c128a667db6736e81335316c1eNate Begeman case ISD::XOR: 10010f3257a3302b60c128a667db6736e81335316c1eNate Begeman // Check whether or not this node is a logical 'not'. This is represented 10020f3257a3302b60c128a667db6736e81335316c1eNate Begeman // by llvm as a xor with the constant value -1 (all bits set). If this is a 10030f3257a3302b60c128a667db6736e81335316c1eNate Begeman // 'not', then fold 'or' into 'nor', and so forth for the supported ops. 10040f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (isOprNot(N)) { 10050f3257a3302b60c128a667db6736e81335316c1eNate Begeman unsigned Opc; 1006131a8805205c383f67b3b6a11777401e27b90371Nate Begeman SDOperand Val = Select(N->getOperand(0)); 1007131a8805205c383f67b3b6a11777401e27b90371Nate Begeman switch (Val.getTargetOpcode()) { 10080f3257a3302b60c128a667db6736e81335316c1eNate Begeman default: Opc = 0; break; 1009131a8805205c383f67b3b6a11777401e27b90371Nate Begeman case PPC::OR: Opc = PPC::NOR; break; 1010131a8805205c383f67b3b6a11777401e27b90371Nate Begeman case PPC::AND: Opc = PPC::NAND; break; 1011131a8805205c383f67b3b6a11777401e27b90371Nate Begeman case PPC::XOR: Opc = PPC::EQV; break; 10120f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 10130f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (Opc) 1014131a8805205c383f67b3b6a11777401e27b90371Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, Opc, Val.getOperand(0), 1015131a8805205c383f67b3b6a11777401e27b90371Nate Begeman Val.getOperand(1)); 10160f3257a3302b60c128a667db6736e81335316c1eNate Begeman else 1017131a8805205c383f67b3b6a11777401e27b90371Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::NOR, Val, Val); 10180f3257a3302b60c128a667db6736e81335316c1eNate Begeman break; 10190f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 10200f3257a3302b60c128a667db6736e81335316c1eNate Begeman // If this is a xor with an immediate other than -1, then codegen it as high 10210f3257a3302b60c128a667db6736e81335316c1eNate Begeman // and low 16 bit immediate xors. 10220f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (SDNode *I = SelectIntImmediateExpr(N->getOperand(0), 10230f3257a3302b60c128a667db6736e81335316c1eNate Begeman N->getOperand(1), 10240f3257a3302b60c128a667db6736e81335316c1eNate Begeman PPC::XORIS, PPC::XORI)) { 10250f3257a3302b60c128a667db6736e81335316c1eNate Begeman CurDAG->ReplaceAllUsesWith(N, I); 10260f3257a3302b60c128a667db6736e81335316c1eNate Begeman N = I; 10270f3257a3302b60c128a667db6736e81335316c1eNate Begeman break; 10280f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 10290f3257a3302b60c128a667db6736e81335316c1eNate Begeman // Finally, check for the case where we are being asked to select 10300f3257a3302b60c128a667db6736e81335316c1eNate Begeman // xor (not(a), b) which is equivalent to not(xor a, b), which is eqv 10310f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (isOprNot(N->getOperand(0).Val)) 10320f3257a3302b60c128a667db6736e81335316c1eNate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::EQV, 10330f3257a3302b60c128a667db6736e81335316c1eNate Begeman Select(N->getOperand(0).getOperand(0)), 10340f3257a3302b60c128a667db6736e81335316c1eNate Begeman Select(N->getOperand(1))); 10350f3257a3302b60c128a667db6736e81335316c1eNate Begeman else 10360f3257a3302b60c128a667db6736e81335316c1eNate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::XOR, Select(N->getOperand(0)), 10370f3257a3302b60c128a667db6736e81335316c1eNate Begeman Select(N->getOperand(1))); 10380f3257a3302b60c128a667db6736e81335316c1eNate Begeman break; 1039c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SHL: { 1040c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1041c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 1042c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) 1043c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, 1044c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(0).getOperand(0)), 1045c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 1046c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else if (isIntImmediate(N->getOperand(1), Imm)) 1047c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, Select(N->getOperand(0)), 1048c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(Imm), getI32Imm(0), getI32Imm(31-Imm)); 1049c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else 1050c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::SLW, Select(N->getOperand(0)), 1051c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(1))); 1052c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman break; 1053c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 1054c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRL: { 1055c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1056c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 1057c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) 1058c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, 1059c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(0).getOperand(0)), 1060c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 1061c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else if (isIntImmediate(N->getOperand(1), Imm)) 1062c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, Select(N->getOperand(0)), 1063c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(32-Imm), getI32Imm(Imm), getI32Imm(31)); 1064c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else 1065c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::SRW, Select(N->getOperand(0)), 1066c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(1))); 1067c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman break; 1068c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 1069c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRA: { 1070c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1071c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 1072c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) 1073c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, 1074c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(0).getOperand(0)), 1075c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 1076c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else if (isIntImmediate(N->getOperand(1), Imm)) 1077c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::SRAWI, Select(N->getOperand(0)), 1078c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(Imm)); 1079c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else 1080c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::SRAW, Select(N->getOperand(0)), 1081c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(1))); 1082c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman break; 1083c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 1084305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::FABS: 10856a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman CurDAG->SelectNodeTo(N, N->getValueType(0), PPC::FABS, 10866a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman Select(N->getOperand(0))); 10876a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman break; 1088305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::FP_EXTEND: 1089305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman assert(MVT::f64 == N->getValueType(0) && 1090305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman MVT::f32 == N->getOperand(0).getValueType() && "Illegal FP_EXTEND"); 1091305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman CurDAG->SelectNodeTo(N, MVT::f64, PPC::FMR, Select(N->getOperand(0))); 1092305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman break; 1093305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::FP_ROUND: 1094305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman assert(MVT::f32 == N->getValueType(0) && 1095305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman MVT::f64 == N->getOperand(0).getValueType() && "Illegal FP_ROUND"); 1096305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman CurDAG->SelectNodeTo(N, MVT::f32, PPC::FRSP, Select(N->getOperand(0))); 1097305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman break; 109826653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case ISD::FNEG: { 109926653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman SDOperand Val = Select(N->getOperand(0)); 110026653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman MVT::ValueType Ty = N->getValueType(0); 110126653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman if (Val.Val->hasOneUse()) { 110226653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman unsigned Opc; 110326653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman switch (Val.getTargetOpcode()) { 110426653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman default: Opc = 0; break; 110526653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FABS: Opc = PPC::FNABS; break; 110626653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMADD: Opc = PPC::FNMADD; break; 110726653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMADDS: Opc = PPC::FNMADDS; break; 110826653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMSUB: Opc = PPC::FNMSUB; break; 110926653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMSUBS: Opc = PPC::FNMSUBS; break; 111026653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 111126653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // If we inverted the opcode, then emit the new instruction with the 111226653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // inverted opcode and the original instruction's operands. Otherwise, 111326653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // fall through and generate a fneg instruction. 111426653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman if (Opc) { 111526653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman if (PPC::FNABS == Opc) 111626653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman CurDAG->SelectNodeTo(N, Ty, Opc, Val.getOperand(0)); 111726653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman else 111826653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman CurDAG->SelectNodeTo(N, Ty, Opc, Val.getOperand(0), 111926653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman Val.getOperand(1), Val.getOperand(2)); 112026653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman break; 112126653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 112226653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 112326653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman CurDAG->SelectNodeTo(N, Ty, PPC::FNEG, Val); 112426653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman break; 112526653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 11266a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman case ISD::FSQRT: { 11276a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman MVT::ValueType Ty = N->getValueType(0); 11286a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman CurDAG->SelectNodeTo(N, Ty, Ty == MVT::f64 ? PPC::FSQRT : PPC::FSQRTS, 11296a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman Select(N->getOperand(0))); 11306a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman break; 11316a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman } 1132a9317ed361847c96989664b84ae8502a783a9956Chris Lattner 1133a9317ed361847c96989664b84ae8502a783a9956Chris Lattner case ISD::ADD_PARTS: { 1134a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand LHSL = Select(N->getOperand(0)); 1135a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand LHSH = Select(N->getOperand(1)); 1136a9317ed361847c96989664b84ae8502a783a9956Chris Lattner 1137a9317ed361847c96989664b84ae8502a783a9956Chris Lattner unsigned Imm; 1138a9317ed361847c96989664b84ae8502a783a9956Chris Lattner bool ME, ZE; 1139a9317ed361847c96989664b84ae8502a783a9956Chris Lattner if (isIntImmediate(N->getOperand(3), Imm)) { 1140a9317ed361847c96989664b84ae8502a783a9956Chris Lattner ME = (signed)Imm == -1; 1141a9317ed361847c96989664b84ae8502a783a9956Chris Lattner ZE = Imm == 0; 1142a9317ed361847c96989664b84ae8502a783a9956Chris Lattner } 1143a9317ed361847c96989664b84ae8502a783a9956Chris Lattner 1144a9317ed361847c96989664b84ae8502a783a9956Chris Lattner std::vector<SDOperand> Result; 1145a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand CarryFromLo; 1146a9317ed361847c96989664b84ae8502a783a9956Chris Lattner if (isIntImmediate(N->getOperand(2), Imm) && 1147a9317ed361847c96989664b84ae8502a783a9956Chris Lattner ((signed)Imm >= -32768 || (signed)Imm < 32768)) { 1148a9317ed361847c96989664b84ae8502a783a9956Chris Lattner // Codegen the low 32 bits of the add. Interestingly, there is no 1149a9317ed361847c96989664b84ae8502a783a9956Chris Lattner // shifted form of add immediate carrying. 1150a9317ed361847c96989664b84ae8502a783a9956Chris Lattner CarryFromLo = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 1151a9317ed361847c96989664b84ae8502a783a9956Chris Lattner LHSL, getI32Imm(Imm)); 1152a9317ed361847c96989664b84ae8502a783a9956Chris Lattner } else { 1153a9317ed361847c96989664b84ae8502a783a9956Chris Lattner CarryFromLo = CurDAG->getTargetNode(PPC::ADDC, MVT::i32, MVT::Flag, 1154a9317ed361847c96989664b84ae8502a783a9956Chris Lattner LHSL, Select(N->getOperand(2))); 1155a9317ed361847c96989664b84ae8502a783a9956Chris Lattner } 1156a9317ed361847c96989664b84ae8502a783a9956Chris Lattner Result.push_back(CarryFromLo); 1157a9317ed361847c96989664b84ae8502a783a9956Chris Lattner CarryFromLo = CarryFromLo.getValue(1); 1158a9317ed361847c96989664b84ae8502a783a9956Chris Lattner 1159a9317ed361847c96989664b84ae8502a783a9956Chris Lattner // Codegen the high 32 bits, adding zero, minus one, or the full value 1160a9317ed361847c96989664b84ae8502a783a9956Chris Lattner // along with the carry flag produced by addc/addic. 1161a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand ResultHi; 1162a9317ed361847c96989664b84ae8502a783a9956Chris Lattner if (ZE) 1163a9317ed361847c96989664b84ae8502a783a9956Chris Lattner ResultHi = CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, LHSH, CarryFromLo); 1164a9317ed361847c96989664b84ae8502a783a9956Chris Lattner else if (ME) 1165a9317ed361847c96989664b84ae8502a783a9956Chris Lattner ResultHi = CurDAG->getTargetNode(PPC::ADDME, MVT::i32, LHSH, CarryFromLo); 1166a9317ed361847c96989664b84ae8502a783a9956Chris Lattner else 1167a9317ed361847c96989664b84ae8502a783a9956Chris Lattner ResultHi = CurDAG->getTargetNode(PPC::ADDE, MVT::i32, LHSH, 1168a9317ed361847c96989664b84ae8502a783a9956Chris Lattner Select(N->getOperand(3)), CarryFromLo); 1169a9317ed361847c96989664b84ae8502a783a9956Chris Lattner Result.push_back(ResultHi); 1170a9317ed361847c96989664b84ae8502a783a9956Chris Lattner CurDAG->ReplaceAllUsesWith(N, Result); 1171a9317ed361847c96989664b84ae8502a783a9956Chris Lattner return Result[Op.ResNo]; 1172a9317ed361847c96989664b84ae8502a783a9956Chris Lattner } 1173a9317ed361847c96989664b84ae8502a783a9956Chris Lattner case ISD::SUB_PARTS: { 1174a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand LHSL = Select(N->getOperand(0)); 1175a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand LHSH = Select(N->getOperand(1)); 1176a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand RHSL = Select(N->getOperand(2)); 1177a9317ed361847c96989664b84ae8502a783a9956Chris Lattner SDOperand RHSH = Select(N->getOperand(3)); 1178a9317ed361847c96989664b84ae8502a783a9956Chris Lattner 1179a9317ed361847c96989664b84ae8502a783a9956Chris Lattner std::vector<SDOperand> Result; 1180a9317ed361847c96989664b84ae8502a783a9956Chris Lattner Result.push_back(CurDAG->getTargetNode(PPC::SUBFC, MVT::i32, MVT::Flag, 1181a9317ed361847c96989664b84ae8502a783a9956Chris Lattner RHSL, LHSL)); 1182a9317ed361847c96989664b84ae8502a783a9956Chris Lattner Result.push_back(CurDAG->getTargetNode(PPC::SUBFE, MVT::i32, RHSH, LHSH, 1183a9317ed361847c96989664b84ae8502a783a9956Chris Lattner Result[0].getValue(1))); 1184a9317ed361847c96989664b84ae8502a783a9956Chris Lattner CurDAG->ReplaceAllUsesWith(N, Result); 1185a9317ed361847c96989664b84ae8502a783a9956Chris Lattner return Result[Op.ResNo]; 1186a9317ed361847c96989664b84ae8502a783a9956Chris Lattner } 1187a9317ed361847c96989664b84ae8502a783a9956Chris Lattner 11889944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::LOAD: 11899944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::EXTLOAD: 11909944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::ZEXTLOAD: 11919944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::SEXTLOAD: { 11929944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner SDOperand Op1, Op2; 11939944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner bool isIdx = SelectAddr(N->getOperand(1), Op1, Op2); 11949944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 11959944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner MVT::ValueType TypeBeingLoaded = (N->getOpcode() == ISD::LOAD) ? 11969944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner N->getValueType(0) : cast<VTSDNode>(N->getOperand(3))->getVT(); 11979944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner unsigned Opc; 11989944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner switch (TypeBeingLoaded) { 11999944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner default: N->dump(); assert(0 && "Cannot load this type!"); 12009944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i1: 12019944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i8: Opc = isIdx ? PPC::LBZX : PPC::LBZ; break; 12029944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i16: 12039944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (N->getOpcode() == ISD::SEXTLOAD) { // SEXT load? 12049944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Opc = isIdx ? PPC::LHAX : PPC::LHA; 12059944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 12069944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Opc = isIdx ? PPC::LHZX : PPC::LHZ; 12079944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 12089944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner break; 12099944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i32: Opc = isIdx ? PPC::LWZX : PPC::LWZ; break; 12109944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::f32: Opc = isIdx ? PPC::LFSX : PPC::LFS; break; 12119944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::f64: Opc = isIdx ? PPC::LFDX : PPC::LFD; break; 12129944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 12139944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 12149944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner CurDAG->SelectNodeTo(N, N->getValueType(0), MVT::Other, Opc, 12159944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1, Op2, Select(N->getOperand(0))); 12169944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner break; 12179944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 12189944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 1219f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case ISD::TRUNCSTORE: 1220f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case ISD::STORE: { 1221f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner SDOperand AddrOp1, AddrOp2; 1222f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner bool isIdx = SelectAddr(N->getOperand(2), AddrOp1, AddrOp2); 1223f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner 1224f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner unsigned Opc; 1225f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner if (N->getOpcode() == ISD::STORE) { 1226f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner switch (N->getOperand(1).getValueType()) { 1227f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner default: assert(0 && "unknown Type in store"); 1228f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::i32: Opc = isIdx ? PPC::STWX : PPC::STW; break; 1229f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::f64: Opc = isIdx ? PPC::STFDX : PPC::STFD; break; 1230f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::f32: Opc = isIdx ? PPC::STFSX : PPC::STFS; break; 1231f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 1232f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } else { //ISD::TRUNCSTORE 1233f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner switch(cast<VTSDNode>(N->getOperand(4))->getVT()) { 1234f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner default: assert(0 && "unknown Type in store"); 1235f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::i1: 1236f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::i8: Opc = isIdx ? PPC::STBX : PPC::STB; break; 1237f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::i16: Opc = isIdx ? PPC::STHX : PPC::STH; break; 1238f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 1239f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 1240fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1241f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner CurDAG->SelectNodeTo(N, MVT::Other, Opc, Select(N->getOperand(1)), 1242f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner AddrOp1, AddrOp2, Select(N->getOperand(0))); 1243f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner break; 1244a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner } 124564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner 124664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETCC: { 124764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner unsigned Imm; 124864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get(); 124964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner if (isIntImmediate(N->getOperand(1), Imm)) { 125064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner // We can codegen setcc op, imm very efficiently compared to a brcond. 125164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner // Check for those cases here. 125264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner // setcc op, 0 125364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner if (Imm == 0) { 125464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand Op = Select(N->getOperand(0)); 125564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 125664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner default: assert(0 && "Unhandled SetCC condition"); abort(); 125764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETEQ: 125864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner Op = CurDAG->getTargetNode(PPC::CNTLZW, MVT::i32, Op); 125964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, Op, getI32Imm(27), 126064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(5), getI32Imm(31)); 126164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 126264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETNE: { 126364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand AD = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 126464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner Op, getI32Imm(~0U)); 126564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::SUBFE, AD, Op, AD.getValue(1)); 126664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 126764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 126864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLT: 126964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, Op, getI32Imm(1), 127064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(31), getI32Imm(31)); 127164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 127264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGT: { 127364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand T = CurDAG->getTargetNode(PPC::NEG, MVT::i32, Op); 127464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner T = CurDAG->getTargetNode(PPC::ANDC, MVT::i32, T, Op);; 127564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, T, getI32Imm(1), 127664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(31), getI32Imm(31)); 127764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 127864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 127964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 128064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 128164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } else if (Imm == ~0U) { // setcc op, -1 128264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand Op = Select(N->getOperand(0)); 128364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 128464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner default: assert(0 && "Unhandled SetCC condition"); abort(); 128564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETEQ: 128664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner Op = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 128764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner Op, getI32Imm(1)); 128864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::ADDZE, 128964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner CurDAG->getTargetNode(PPC::LI, MVT::i32, 129064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(0)), 129164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner Op.getValue(1)); 129264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 129364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETNE: { 129464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner Op = CurDAG->getTargetNode(PPC::NOR, MVT::i32, Op, Op); 129564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand AD = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, Op, 129664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(~0U)); 129764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::SUBFE, AD, Op, AD.getValue(1)); 129864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 129964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 130064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLT: { 130164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand AD = CurDAG->getTargetNode(PPC::ADDI, MVT::i32, Op, 130264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(1)); 130364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand AN = CurDAG->getTargetNode(PPC::AND, MVT::i32, AD, Op); 130464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, AN, getI32Imm(1), 130564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(31), getI32Imm(31)); 130664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 130764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 130864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGT: 130964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner Op = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Op, getI32Imm(1), 131064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(31), getI32Imm(31)); 131164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::XORI, Op, getI32Imm(1)); 131264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 131364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 131464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 131564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 131664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 131764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner 131864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner bool Inv; 131964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner unsigned Idx = getCRIdxForSetCC(CC, Inv); 132064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand CCReg = 132164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SelectCC(Select(N->getOperand(0)), Select(N->getOperand(1)), CC); 132264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand IntCR; 1323957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner 1324957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner // Force the ccreg into CR7. 1325957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner SDOperand CR7Reg = CurDAG->getRegister(PPC::CR7, MVT::i32); 1326957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner 1327957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner std::vector<MVT::ValueType> VTs; 1328957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner VTs.push_back(MVT::Other); 1329957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner VTs.push_back(MVT::Flag); // NONSTANDARD CopyToReg node: defines a flag 1330957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner std::vector<SDOperand> Ops; 1331957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner Ops.push_back(CurDAG->getEntryNode()); 1332957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner Ops.push_back(CR7Reg); 1333957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner Ops.push_back(CCReg); 1334957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner CCReg = CurDAG->getNode(ISD::CopyToReg, VTs, Ops).getValue(1); 1335957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner 1336957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner if (TLI.getTargetMachine().getSubtarget<PPCSubtarget>().isGigaProcessor()) 1337957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner IntCR = CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, CR7Reg, CCReg); 1338957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner else 1339957fcfbd8935b2973376167861a53e4a9220aefcChris Lattner IntCR = CurDAG->getTargetNode(PPC::MFCR, MVT::i32, CCReg); 134064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner 134164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner if (!Inv) { 134264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, IntCR, 134364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(32-(3-Idx)), getI32Imm(31), getI32Imm(31)); 134464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } else { 134564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner SDOperand Tmp = 134664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, IntCR, 134764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner getI32Imm(32-(3-Idx)), getI32Imm(31),getI32Imm(31)); 134864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::XORI, Tmp, getI32Imm(1)); 134964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 135064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner 135164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner break; 135264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 1353a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner 1354a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner case ISD::CALLSEQ_START: 1355a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner case ISD::CALLSEQ_END: { 1356a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner unsigned Amt = cast<ConstantSDNode>(N->getOperand(1))->getValue(); 1357a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner unsigned Opc = N->getOpcode() == ISD::CALLSEQ_START ? 1358a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner PPC::ADJCALLSTACKDOWN : PPC::ADJCALLSTACKUP; 1359fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CurDAG->SelectNodeTo(N, MVT::Other, Opc, 1360fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner getI32Imm(Amt), Select(N->getOperand(0))); 1361a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner break; 1362f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 1363fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner case ISD::CALL: 1364fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner case ISD::TAILCALL: { 1365fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner SDOperand Chain = Select(N->getOperand(0)); 1366fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1367fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner unsigned CallOpcode; 1368fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner std::vector<SDOperand> CallOperands; 1369fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1370fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner if (GlobalAddressSDNode *GASD = 1371fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner dyn_cast<GlobalAddressSDNode>(N->getOperand(1))) { 1372fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOpcode = PPC::CALLpcrel; 1373fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOperands.push_back(CurDAG->getTargetGlobalAddress(GASD->getGlobal(), 1374fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner MVT::i32)); 1375fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } else if (ExternalSymbolSDNode *ESSDN = 1376fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner dyn_cast<ExternalSymbolSDNode>(N->getOperand(1))) { 1377fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOpcode = PPC::CALLpcrel; 1378fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOperands.push_back(N->getOperand(1)); 1379fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } else { 1380fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner // Copy the callee address into the CTR register. 1381fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner SDOperand Callee = Select(N->getOperand(1)); 1382fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner Chain = CurDAG->getTargetNode(PPC::MTCTR, MVT::Other, Callee, Chain); 1383fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1384fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner // Copy the callee address into R12 on darwin. 1385fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner SDOperand R12 = CurDAG->getRegister(PPC::R12, MVT::i32); 1386fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner Chain = CurDAG->getNode(ISD::CopyToReg, MVT::Other, R12, Callee, Chain); 1387fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1388fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOperands.push_back(getI32Imm(20)); // Information to encode indcall 1389fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOperands.push_back(getI32Imm(0)); // Information to encode indcall 1390fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOperands.push_back(R12); 1391fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOpcode = PPC::CALLindirect; 1392fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } 1393fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1394fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner unsigned GPR_idx = 0, FPR_idx = 0; 1395fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner static const unsigned GPR[] = { 1396fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner PPC::R3, PPC::R4, PPC::R5, PPC::R6, 1397fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner PPC::R7, PPC::R8, PPC::R9, PPC::R10, 1398fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner }; 1399fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner static const unsigned FPR[] = { 1400fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, 1401fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner PPC::F8, PPC::F9, PPC::F10, PPC::F11, PPC::F12, PPC::F13 1402fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner }; 1403fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1404fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner for (unsigned i = 2, e = N->getNumOperands(); i != e; ++i) 1405fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner if (N->getOperand(i).getOpcode() != ISD::UNDEF) { 1406fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner unsigned DestReg = 0; 1407fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner MVT::ValueType RegTy; 1408fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner if (N->getOperand(i).getValueType() == MVT::i32) { 1409fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner assert(GPR_idx < 8 && "Too many int args"); 1410fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner DestReg = GPR[GPR_idx++]; 1411fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner RegTy = MVT::i32; 1412fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } else { 1413ed7956bfe4bbe9445cbf0a74299f714ffe4fd7a4Chris Lattner assert(MVT::isFloatingPoint(N->getOperand(i).getValueType()) && 1414fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner "Unpromoted integer arg?"); 1415fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner assert(FPR_idx < 13 && "Too many fp args"); 1416fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner DestReg = FPR[FPR_idx++]; 1417fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner RegTy = MVT::f64; // Even if this is really f32! 1418fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } 1419fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1420fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner SDOperand Reg = CurDAG->getRegister(DestReg, RegTy); 1421fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner Chain = CurDAG->getNode(ISD::CopyToReg, MVT::Other, Chain, Reg, 1422fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner Select(N->getOperand(i))); 1423fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOperands.push_back(Reg); 1424fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } 1425fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1426fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner // Finally, once everything is in registers to pass to the call, emit the 1427fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner // call itself. 1428fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallOperands.push_back(Chain); 1429fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner Chain = CurDAG->getTargetNode(CallOpcode, MVT::Other, CallOperands); 1430fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1431fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner std::vector<SDOperand> CallResults; 1432fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1433fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner // If the call has results, copy the values out of the ret val registers. 1434fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner switch (N->getValueType(0)) { 1435fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner default: assert(0 && "Unexpected ret value!"); 1436fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner case MVT::Other: break; 1437fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner case MVT::i32: 1438fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner if (N->getValueType(1) == MVT::i32) { 1439fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R4, MVT::i32).getValue(1); 1440fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallResults.push_back(Chain.getValue(0)); 1441fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R3, MVT::i32).getValue(1); 1442fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallResults.push_back(Chain.getValue(0)); 1443fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } else { 1444fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R3, MVT::i32).getValue(1); 1445fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallResults.push_back(Chain.getValue(0)); 1446fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } 1447fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner break; 1448fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner case MVT::f32: 1449fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner case MVT::f64: 1450fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::F1, MVT::f64).getValue(1); 1451fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallResults.push_back(Chain.getValue(0)); 1452fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner break; 1453fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } 1454fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner 1455fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CallResults.push_back(Chain); 1456fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner CurDAG->ReplaceAllUsesWith(N, CallResults); 1457fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner return CallResults[Op.ResNo]; 1458fb0c964364ba9f2c54ea28e0b7f404e18f7327b4Chris Lattner } 1459a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::RET: { 1460a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Chain = Select(N->getOperand(0)); // Token chain. 1461a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1462a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (N->getNumOperands() > 1) { 1463a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Val = Select(N->getOperand(1)); 1464a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOperand(1).getValueType()) { 1465a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner default: assert(0 && "Unknown return type!"); 1466a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case MVT::f64: 1467a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case MVT::f32: 1468a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Chain = CurDAG->getCopyToReg(Chain, PPC::F1, Val); 1469a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 1470a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case MVT::i32: 1471a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Chain = CurDAG->getCopyToReg(Chain, PPC::R3, Val); 1472a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 1473a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 1474a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1475a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (N->getNumOperands() > 2) { 1476a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner assert(N->getOperand(1).getValueType() == MVT::i32 && 1477a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(2).getValueType() == MVT::i32 && 1478a9317ed361847c96989664b84ae8502a783a9956Chris Lattner N->getNumOperands() == 3 && "Unknown two-register ret value!"); 1479a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Val = Select(N->getOperand(2)); 1480a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Chain = CurDAG->getCopyToReg(Chain, PPC::R4, Val); 1481a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 1482a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 1483a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1484a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Finally, select this to a blr (return) instruction. 1485a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, MVT::Other, PPC::BLR, Chain); 1486a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 1487a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 148889532c7db03543402dd5376172b87233575beb44Chris Lattner case ISD::BR: 148989532c7db03543402dd5376172b87233575beb44Chris Lattner CurDAG->SelectNodeTo(N, MVT::Other, PPC::B, N->getOperand(1), 149089532c7db03543402dd5376172b87233575beb44Chris Lattner Select(N->getOperand(0))); 149189532c7db03543402dd5376172b87233575beb44Chris Lattner break; 14922fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::BR_CC: 14932fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::BRTWOWAY_CC: { 14942fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand Chain = Select(N->getOperand(0)); 14952fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner MachineBasicBlock *Dest = 14962fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner cast<BasicBlockSDNode>(N->getOperand(4))->getBasicBlock(); 14972fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(1))->get(); 14982fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CondCode = SelectCC(N->getOperand(2), N->getOperand(3), CC); 14992fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner unsigned Opc = getBCCForSetCC(CC); 15002fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 15012fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // If this is a two way branch, then grab the fallthrough basic block 15022fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // argument and build a PowerPC branch pseudo-op, suitable for long branch 15032fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // conversion if necessary by the branch selection pass. Otherwise, emit a 15042fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // standard conditional branch. 15052fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (N->getOpcode() == ISD::BRTWOWAY_CC) { 15062fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner MachineBasicBlock *Fallthrough = 15072fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner cast<BasicBlockSDNode>(N->getOperand(5))->getBasicBlock(); 15082fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CB = CurDAG->getTargetNode(PPC::COND_BRANCH, MVT::Other, 15092fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner CondCode, getI32Imm(Opc), 15102fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner N->getOperand(4), N->getOperand(5), 15112fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner Chain); 15122fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner CurDAG->SelectNodeTo(N, MVT::Other, PPC::B, N->getOperand(5), CB); 15132fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 15142fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Iterate to the next basic block 15152fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ilist<MachineBasicBlock>::iterator It = BB; 15162fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ++It; 15172fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 15182fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // If the fallthrough path is off the end of the function, which would be 15192fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // undefined behavior, set it to be the same as the current block because 15202fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // we have nothing better to set it to, and leaving it alone will cause 15212fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // the PowerPC Branch Selection pass to crash. 15222fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (It == BB->getParent()->end()) It = Dest; 15232fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner CurDAG->SelectNodeTo(N, MVT::Other, PPC::COND_BRANCH, CondCode, 15242fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner getI32Imm(Opc), N->getOperand(4), 15252fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner CurDAG->getBasicBlock(It), Chain); 15262fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 15272fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner break; 15282fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 1529a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 1530ddf3e7dfd791f7cdbcd1bb5feb168067b5b9c16dChris Lattner return SDOperand(N, Op.ResNo); 1531a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1532a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1533a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1534a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// createPPC32ISelDag - This pass converts a legalized DAG into a 1535a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// PowerPC-specific DAG, ready for instruction scheduling. 1536a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// 1537a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris LattnerFunctionPass *llvm::createPPC32ISelDag(TargetMachine &TM) { 1538a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return new PPC32DAGToDAGISel(TM); 1539a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1540a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1541