PPCISelDAGToDAG.cpp revision a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8
1a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner//===-- PPC32ISelDAGToDAG.cpp - PPC32 pattern matching inst selector ------===// 2a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 3a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// The LLVM Compiler Infrastructure 4a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 5a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// This file was developed by Chris Lattner and is distributed under 6a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// the University of Illinois Open Source License. See LICENSE.TXT for details. 7a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 8a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner//===----------------------------------------------------------------------===// 9a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 10a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// This file defines a pattern matching instruction selector for 32 bit PowerPC, 11a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// converting from a legalized dag to a PPC dag. 12a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 13a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner//===----------------------------------------------------------------------===// 14a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 15a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "PowerPC.h" 16a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "PPC32TargetMachine.h" 17a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "PPC32ISelLowering.h" 184416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 194416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 204416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/CodeGen/SSARegMap.h" 21a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/CodeGen/SelectionDAG.h" 22a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/CodeGen/SelectionDAGISel.h" 23a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Target/TargetOptions.h" 24a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/ADT/Statistic.h" 254416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/GlobalValue.h" 26a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Support/Debug.h" 27a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Support/MathExtras.h" 28a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerusing namespace llvm; 29a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 30a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnernamespace { 31a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Statistic<> Recorded("ppc-codegen", "Number of recording ops emitted"); 32a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Statistic<> FusedFP ("ppc-codegen", "Number of fused fp operations"); 33a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Statistic<> FrameOff("ppc-codegen", "Number of frame idx offsets collapsed"); 34a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 35a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner //===--------------------------------------------------------------------===// 36a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// PPC32DAGToDAGISel - PPC32 specific code to select PPC32 machine 37a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// instructions for SelectionDAG operations. 38a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// 39a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner class PPC32DAGToDAGISel : public SelectionDAGISel { 40a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner PPC32TargetLowering PPC32Lowering; 414416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner unsigned GlobalBaseReg; 42a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner public: 43a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner PPC32DAGToDAGISel(TargetMachine &TM) 44a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner : SelectionDAGISel(PPC32Lowering), PPC32Lowering(TM) {} 45a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 464416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner virtual bool runOnFunction(Function &Fn) { 474416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Make sure we re-emit a set of the global base reg if necessary 484416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalBaseReg = 0; 494416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner return SelectionDAGISel::runOnFunction(Fn); 504416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 514416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 52a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// getI32Imm - Return a target constant with the specified value, of type 53a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// i32. 54a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner inline SDOperand getI32Imm(unsigned Imm) { 55a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return CurDAG->getTargetConstant(Imm, MVT::i32); 56a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 574416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 584416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// getGlobalBaseReg - insert code into the entry mbb to materialize the PIC 594416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// base register. Return the virtual register that holds this value. 609944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner SDOperand getGlobalBaseReg(); 61a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 62a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Select - Convert the specified operand from a target-independent to a 63a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // target-specific node if it hasn't already been changed. 64a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Select(SDOperand Op); 65a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 66a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDNode *SelectIntImmediateExpr(SDOperand LHS, SDOperand RHS, 67a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned OCHi, unsigned OCLo, 68a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner bool IsArithmetic = false, 69a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner bool Negate = false); 7002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDNode *SelectBitfieldInsert(SDNode *N); 7102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 722fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// SelectCC - Select a comparison of the specified values with the 732fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// specified condition code, returning the CR# of the expression. 742fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand SelectCC(SDOperand LHS, SDOperand RHS, ISD::CondCode CC); 752fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 769944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner /// SelectAddr - Given the specified address, return the two operands for a 779944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner /// load/store instruction, and return true if it should be an indexed [r+r] 789944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner /// operation. 799944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner bool SelectAddr(SDOperand Addr, SDOperand &Op1, SDOperand &Op2); 809944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 81a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// InstructionSelectBasicBlock - This callback is invoked by 82a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 83a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner virtual void InstructionSelectBasicBlock(SelectionDAG &DAG) { 84a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner DEBUG(BB->dump()); 85d607c12e8e8533028a66c9f533007c6c32a64cefChris Lattner // Select target instructions for the DAG. 86a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(DAG.getRoot()); 87a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner DAG.RemoveDeadNodes(); 88d607c12e8e8533028a66c9f533007c6c32a64cefChris Lattner 89d607c12e8e8533028a66c9f533007c6c32a64cefChris Lattner // Emit machine code to BB. 90d607c12e8e8533028a66c9f533007c6c32a64cefChris Lattner ScheduleAndEmitDAG(DAG); 91a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 92a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 93a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner virtual const char *getPassName() const { 94a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return "PowerPC DAG->DAG Pattern Instruction Selection"; 95a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 96a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner }; 97a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 98a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 994416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// getGlobalBaseReg - Output the instructions required to put the 1004416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// base address to use for accessing globals into a register. 1014416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// 1029944b76cfe74981d2c41c8237d25267ba0c467c7Chris LattnerSDOperand PPC32DAGToDAGISel::getGlobalBaseReg() { 1034416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (!GlobalBaseReg) { 1044416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Insert the set of GlobalBaseReg into the first MBB of the function 1054416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock &FirstMBB = BB->getParent()->front(); 1064416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock::iterator MBBI = FirstMBB.begin(); 1074416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SSARegMap *RegMap = BB->getParent()->getSSARegMap(); 1084416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalBaseReg = RegMap->createVirtualRegister(PPC32::GPRCRegisterClass); 1094416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MovePCtoLR, 0, PPC::LR); 1104416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MFLR, 1, GlobalBaseReg); 1114416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 1129944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return CurDAG->getRegister(GlobalBaseReg, MVT::i32); 1134416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner} 1144416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 1154416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 1160f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isIntImmediate - This method tests to see if a constant operand. 1170f3257a3302b60c128a667db6736e81335316c1eNate Begeman// If so Imm will receive the 32 bit value. 1180f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isIntImmediate(SDNode *N, unsigned& Imm) { 1190f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (N->getOpcode() == ISD::Constant) { 1200f3257a3302b60c128a667db6736e81335316c1eNate Begeman Imm = cast<ConstantSDNode>(N)->getValue(); 1210f3257a3302b60c128a667db6736e81335316c1eNate Begeman return true; 1220f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 1230f3257a3302b60c128a667db6736e81335316c1eNate Begeman return false; 1240f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 1250f3257a3302b60c128a667db6736e81335316c1eNate Begeman 126cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isOprShiftImm - Returns true if the specified operand is a shift opcode with 127cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// a immediate shift count less than 32. 128cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isOprShiftImm(SDNode *N, unsigned& Opc, unsigned& SH) { 129cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Opc = N->getOpcode(); 130cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return (Opc == ISD::SHL || Opc == ISD::SRL || Opc == ISD::SRA) && 131cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isIntImmediate(N->getOperand(1).Val, SH) && SH < 32; 132cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 133cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 134cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s with 135cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// any number of 0s on either side. The 1s are allowed to wrap from LSB to 136cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 0x0F0F0000 is 137cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// not, since all 1s are not contiguous. 138cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME) { 139cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isShiftedMask_32(Val)) { 140cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first non-zero bit 141cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman MB = CountLeadingZeros_32(Val); 142cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first zero bit after the run of ones 143cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman ME = CountLeadingZeros_32((Val - 1) ^ Val); 144cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return true; 145cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else if (isShiftedMask_32(Val = ~Val)) { // invert mask 146cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // effectively look for the first zero bit 147cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman ME = CountLeadingZeros_32(Val) - 1; 148cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // effectively look for the first one bit after the run of zeros 149cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman MB = CountLeadingZeros_32((Val - 1) ^ Val) + 1; 150cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return true; 151cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 152cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // no run present 153cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 154cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 155cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 156cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isRotateAndMask - Returns true if Mask and Shift can be folded in to a rotate 157cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// and mask opcode and mask operation. 158cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRotateAndMask(SDNode *N, unsigned Mask, bool IsShiftMask, 159cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned &SH, unsigned &MB, unsigned &ME) { 160cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Shift = 32; 161cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Indeterminant = ~0; // bit mask marking indeterminant results 162cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Opcode = N->getOpcode(); 163cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (!isIntImmediate(N->getOperand(1).Val, Shift) || (Shift > 31)) 164cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 165cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 166cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Opcode == ISD::SHL) { 167cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift left to mask if it comes first 168cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask << Shift; 169cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 170cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu << Shift); 171cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else if (Opcode == ISD::SRA || Opcode == ISD::SRL) { 172cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift right to mask if it comes first 173cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask >> Shift; 174cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 175cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu >> Shift); 176cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // adjust for the left rotate 177cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Shift = 32 - Shift; 178cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 179cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 180cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 181cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 182cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // if the mask doesn't intersect any Indeterminant bits 183cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Mask && !(Mask & Indeterminant)) { 184cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = Shift; 185cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // make sure the mask is still a mask (wrap arounds may not be) 186cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return isRunOfOnes(Mask, MB, ME); 187cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 188cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 189cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 190cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 1910f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isOpcWithIntImmediate - This method tests to see if the node is a specific 1920f3257a3302b60c128a667db6736e81335316c1eNate Begeman// opcode and that it has a immediate integer right operand. 1930f3257a3302b60c128a667db6736e81335316c1eNate Begeman// If so Imm will receive the 32 bit value. 1940f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isOpcWithIntImmediate(SDNode *N, unsigned Opc, unsigned& Imm) { 1950f3257a3302b60c128a667db6736e81335316c1eNate Begeman return N->getOpcode() == Opc && isIntImmediate(N->getOperand(1).Val, Imm); 1960f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 1970f3257a3302b60c128a667db6736e81335316c1eNate Begeman 1980f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isOprNot - Returns true if the specified operand is an xor with immediate -1. 1990f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isOprNot(SDNode *N) { 2000f3257a3302b60c128a667db6736e81335316c1eNate Begeman unsigned Imm; 2010f3257a3302b60c128a667db6736e81335316c1eNate Begeman return isOpcWithIntImmediate(N, ISD::XOR, Imm) && (signed)Imm == -1; 2020f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 2030f3257a3302b60c128a667db6736e81335316c1eNate Begeman 204a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Immediate constant composers. 205a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Lo16 - grabs the lo 16 bits from a 32 bit constant. 206a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Hi16 - grabs the hi 16 bits from a 32 bit constant. 207a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// HA16 - computes the hi bits required if the lo bits are add/subtracted in 208a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// arithmethically. 209a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic unsigned Lo16(unsigned x) { return x & 0x0000FFFF; } 210a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic unsigned Hi16(unsigned x) { return Lo16(x >> 16); } 211a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic unsigned HA16(unsigned x) { return Hi16((signed)x - (signed short)x); } 212a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 213a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// isIntImmediate - This method tests to see if a constant operand. 214a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// If so Imm will receive the 32 bit value. 215a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic bool isIntImmediate(SDOperand N, unsigned& Imm) { 216a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 217a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Imm = (unsigned)CN->getSignExtended(); 218a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return true; 219a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 220a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return false; 221a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 222a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 22302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// SelectBitfieldInsert - turn an or of two masked values into 22402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// the rotate left word immediate then mask insert (rlwimi) instruction. 22502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// Returns true on success, false if the caller still needs to select OR. 22602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 22702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// Patterns matched: 22802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 1. or shl, and 5. or and, and 22902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 2. or and, shl 6. or shl, shr 23002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 3. or shr, and 7. or shr, shl 23102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 4. or and, shr 23202b88a4586704f34bc65afca3348453eae69d1d3Nate BegemanSDNode *PPC32DAGToDAGISel::SelectBitfieldInsert(SDNode *N) { 23302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool IsRotate = false; 23402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned TgtMask = 0xFFFFFFFF, InsMask = 0xFFFFFFFF, SH = 0; 23502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Value; 23602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 23702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op0 = N->getOperand(0); 23802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op1 = N->getOperand(1); 23902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 24002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Op0Opc = Op0.getOpcode(); 24102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Op1Opc = Op1.getOpcode(); 24202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 24302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Verify that we have the correct opcodes 24402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (ISD::SHL != Op0Opc && ISD::SRL != Op0Opc && ISD::AND != Op0Opc) 24502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return false; 24602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (ISD::SHL != Op1Opc && ISD::SRL != Op1Opc && ISD::AND != Op1Opc) 24702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return false; 24802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 24902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Generate Mask value for Target 25002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op0.getOperand(1), Value)) { 25102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman switch(Op0Opc) { 25202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::SHL: TgtMask <<= Value; break; 25302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::SRL: TgtMask >>= Value; break; 25402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::AND: TgtMask &= Value; break; 25502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 25602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } else { 25702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 25802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 25902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 26002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Generate Mask value for Insert 26102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op1.getOperand(1), Value)) { 26202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman switch(Op1Opc) { 26302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::SHL: 26402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Value; 26502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman InsMask <<= SH; 26602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op0Opc == ISD::SRL) IsRotate = true; 26702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman break; 26802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::SRL: 26902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Value; 27002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman InsMask >>= SH; 27102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = 32-SH; 27202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op0Opc == ISD::SHL) IsRotate = true; 27302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman break; 27402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::AND: 27502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman InsMask &= Value; 27602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman break; 27702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 27802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } else { 27902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 28002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 28102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 28202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // If both of the inputs are ANDs and one of them has a logical shift by 28302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // constant as its input, make that AND the inserted value so that we can 28402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // combine the shift into the rotate part of the rlwimi instruction 28502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool IsAndWithShiftOp = false; 28602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op0Opc == ISD::AND && Op1Opc == ISD::AND) { 28702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op1.getOperand(0).getOpcode() == ISD::SHL || 28802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op1.getOperand(0).getOpcode() == ISD::SRL) { 28902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op1.getOperand(0).getOperand(1), Value)) { 29002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Op1.getOperand(0).getOpcode() == ISD::SHL ? Value : 32 - Value; 29102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman IsAndWithShiftOp = true; 29202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 29302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } else if (Op0.getOperand(0).getOpcode() == ISD::SHL || 29402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0.getOperand(0).getOpcode() == ISD::SRL) { 29502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op0.getOperand(0).getOperand(1), Value)) { 29602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman std::swap(Op0, Op1); 29702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman std::swap(TgtMask, InsMask); 29802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Op1.getOperand(0).getOpcode() == ISD::SHL ? Value : 32 - Value; 29902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman IsAndWithShiftOp = true; 30002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 30102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 30202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 30302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 30402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Verify that the Target mask and Insert mask together form a full word mask 30502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // and that the Insert mask is a run of set bits (which implies both are runs 30602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // of set bits). Given that, Select the arguments and generate the rlwimi 30702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // instruction. 30802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned MB, ME; 30902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (((TgtMask & InsMask) == 0) && isRunOfOnes(InsMask, MB, ME)) { 31002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool fullMask = (TgtMask ^ InsMask) == 0xFFFFFFFF; 31102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool Op0IsAND = Op0Opc == ISD::AND; 31202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Check for rotlwi / rotrwi here, a special case of bitfield insert 31302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // where both bitfield halves are sourced from the same value. 31402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (IsRotate && fullMask && 31502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman N->getOperand(0).getOperand(0) == N->getOperand(1).getOperand(0)) { 31602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0 = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, 31702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Select(N->getOperand(0).getOperand(0)), 31802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman getI32Imm(SH), getI32Imm(0), getI32Imm(31)); 31902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return Op0.Val; 32002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 32102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Tmp1 = (Op0IsAND && fullMask) ? Select(Op0.getOperand(0)) 32202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman : Select(Op0); 32302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Tmp2 = IsAndWithShiftOp ? Select(Op1.getOperand(0).getOperand(0)) 32402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman : Select(Op1.getOperand(0)); 32502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0 = CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, Tmp1, Tmp2, 32602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 32702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return Op0.Val; 32802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 32902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 33002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman} 33102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 332a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// SelectIntImmediateExpr - Choose code for integer operations with an immediate 333a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// operand. 334a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris LattnerSDNode *PPC32DAGToDAGISel::SelectIntImmediateExpr(SDOperand LHS, SDOperand RHS, 335a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned OCHi, unsigned OCLo, 336a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner bool IsArithmetic, 337a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner bool Negate) { 338a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Check to make sure this is a constant. 339a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ConstantSDNode *CN = dyn_cast<ConstantSDNode>(RHS); 340a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Exit if not a constant. 341a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (!CN) return 0; 342a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Extract immediate. 343a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned C = (unsigned)CN->getValue(); 344a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Negate if required (ISD::SUB). 345a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Negate) C = -C; 346a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Get the hi and lo portions of constant. 347a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned Hi = IsArithmetic ? HA16(C) : Hi16(C); 348a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned Lo = Lo16(C); 349a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 350a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // If two instructions are needed and usage indicates it would be better to 351a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // load immediate into a register, bail out. 352a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Hi && Lo && CN->use_size() > 2) return false; 353a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 354a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Select the first operand. 355a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Opr0 = Select(LHS); 356a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 357a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Lo) // Add in the lo-part. 358a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Opr0 = CurDAG->getTargetNode(OCLo, MVT::i32, Opr0, getI32Imm(Lo)); 359a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Hi) // Add in the hi-part. 360a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Opr0 = CurDAG->getTargetNode(OCHi, MVT::i32, Opr0, getI32Imm(Hi)); 361a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return Opr0.Val; 362a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 363a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 3649944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner/// SelectAddr - Given the specified address, return the two operands for a 3659944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner/// load/store instruction, and return true if it should be an indexed [r+r] 3669944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner/// operation. 3679944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattnerbool PPC32DAGToDAGISel::SelectAddr(SDOperand Addr, SDOperand &Op1, 3689944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner SDOperand &Op2) { 3699944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner unsigned imm = 0; 3709944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (Addr.getOpcode() == ISD::ADD) { 3719944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (isIntImmediate(Addr.getOperand(1), imm) && isInt16(imm)) { 3729944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = getI32Imm(Lo16(imm)); 3739944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (isa<FrameIndexSDNode>(Addr.getOperand(0))) { 3749944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner ++FrameOff; 3759944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = Addr.getOperand(0); 3769944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 3779944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = Select(Addr.getOperand(0)); 3789944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 3799944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 3809944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 3819944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = Select(Addr.getOperand(0)); 3829944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = Select(Addr.getOperand(1)); 3839944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return true; // [r+r] 3849944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 3859944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 3869944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 3879944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner // Now check if we're dealing with a global, and whether or not we should emit 3889944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner // an optimized load or store for statics. 3899944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (GlobalAddressSDNode *GN = dyn_cast<GlobalAddressSDNode>(Addr)) { 3909944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner GlobalValue *GV = GN->getGlobal(); 3919944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (!GV->hasWeakLinkage() && !GV->isExternal()) { 3929944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = CurDAG->getTargetGlobalAddress(GV, MVT::i32); 3939944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (PICEnabled) 3949944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(), 3959944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1); 3969944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner else 3979944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::LIS, MVT::i32, Op1); 3989944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 3999944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4009944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else if (isa<FrameIndexSDNode>(Addr)) { 4019944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = getI32Imm(0); 4029944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = Addr; 4039944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4049944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Addr)) { 4059944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = Addr; 4069944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (PICEnabled) 4079944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(),Op1); 4089944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner else 4099944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = CurDAG->getTargetNode(PPC::LIS, MVT::i32, Op1); 4109944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4119944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4129944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1 = getI32Imm(0); 4139944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op2 = Select(Addr); 4149944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return false; 4159944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner} 416a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 4172fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// SelectCC - Select a comparison of the specified values with the specified 4182fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// condition code, returning the CR# of the expression. 4192fbb4579d6d6bbde8387283b78307c2ea477a312Chris LattnerSDOperand PPC32DAGToDAGISel::SelectCC(SDOperand LHS, SDOperand RHS, 4202fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC) { 4212fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Always select the LHS. 4222fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner LHS = Select(LHS); 4232fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 4242fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Use U to determine whether the SETCC immediate range is signed or not. 4252fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (MVT::isInteger(LHS.getValueType())) { 4262fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner bool U = ISD::isUnsignedIntSetCC(CC); 4272fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner unsigned Imm; 4282fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (isIntImmediate(RHS, Imm) && 4292fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ((U && isUInt16(Imm)) || (!U && isInt16(Imm)))) 4302fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return CurDAG->getTargetNode(U ? PPC::CMPLWI : PPC::CMPWI, MVT::i32, 4312fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner LHS, getI32Imm(Lo16(Imm))); 4322fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return CurDAG->getTargetNode(U ? PPC::CMPLW : PPC::CMPW, MVT::i32, 4332fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner LHS, Select(RHS)); 4342fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 4352fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return CurDAG->getTargetNode(PPC::FCMPU, MVT::i32, LHS, Select(RHS)); 4362fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 4372fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 4382fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 4392fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// getBCCForSetCC - Returns the PowerPC condition branch mnemonic corresponding 4402fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// to Condition. 4412fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattnerstatic unsigned getBCCForSetCC(ISD::CondCode CC) { 4422fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner switch (CC) { 4432fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 4442fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETEQ: return PPC::BEQ; 4452fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETNE: return PPC::BNE; 4462fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULT: 4472fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLT: return PPC::BLT; 4482fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULE: 4492fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLE: return PPC::BLE; 4502fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGT: 4512fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGT: return PPC::BGT; 4522fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGE: 4532fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGE: return PPC::BGE; 4542fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 4552fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return 0; 4562fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 4572fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 4589944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 459a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Select - Convert the specified operand from a target-independent to a 460a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// target-specific node if it hasn't already been changed. 461a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris LattnerSDOperand PPC32DAGToDAGISel::Select(SDOperand Op) { 462a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDNode *N = Op.Val; 463a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (N->getOpcode() >= ISD::BUILTIN_OP_END) 464a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return Op; // Already selected. 465a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 466a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOpcode()) { 467a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner default: 468a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner std::cerr << "Cannot yet select: "; 469a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->dump(); 470a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner std::cerr << "\n"; 471a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner abort(); 472a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::EntryToken: // These leaves remain the same. 473a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::UNDEF: 474a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return Op; 475a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::TokenFactor: { 476a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand New; 477a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (N->getNumOperands() == 2) { 478a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Op0 = Select(N->getOperand(0)); 479a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Op1 = Select(N->getOperand(1)); 480a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner New = CurDAG->getNode(ISD::TokenFactor, MVT::Other, Op0, Op1); 481a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } else { 482a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner std::vector<SDOperand> Ops; 483a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) 4847e65997c43cc91a5e6eaa0f460b844ef1b5d2fb1Chris Lattner Ops.push_back(Select(N->getOperand(i))); 485a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner New = CurDAG->getNode(ISD::TokenFactor, MVT::Other, Ops); 486a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 487a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 488a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (New.Val != N) { 489a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->ReplaceAllUsesWith(N, New.Val); 490a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N = New.Val; 491a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 492a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 493a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 494a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::CopyFromReg: { 495a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Chain = Select(N->getOperand(0)); 496a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Chain == N->getOperand(0)) return Op; // No change 497a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand New = CurDAG->getCopyFromReg(Chain, 498a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner cast<RegisterSDNode>(N->getOperand(1))->getReg(), N->getValueType(0)); 499a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return New.getValue(Op.ResNo); 500a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 501a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::CopyToReg: { 502a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Chain = Select(N->getOperand(0)); 503a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Reg = N->getOperand(1); 504a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Val = Select(N->getOperand(2)); 505a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Chain != N->getOperand(0) || Val != N->getOperand(2)) { 506a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand New = CurDAG->getNode(ISD::CopyToReg, MVT::Other, 507a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Chain, Reg, Val); 508a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->ReplaceAllUsesWith(N, New.Val); 509a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N = New.Val; 510a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 511a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 512a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 513a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::Constant: { 514a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner assert(N->getValueType(0) == MVT::i32); 515a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned v = (unsigned)cast<ConstantSDNode>(N)->getValue(); 516a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned Hi = HA16(v); 517a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned Lo = Lo16(v); 518a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman if (Hi && Lo) { 519a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman SDOperand Top = CurDAG->getTargetNode(PPC::LIS, MVT::i32, 520a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman getI32Imm(v >> 16)); 521a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::ORI, Top, getI32Imm(v & 0xFFFF)); 522a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman } else if (Lo) { 523a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::LI, getI32Imm(v)); 524a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } else { 525a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::LIS, getI32Imm(v >> 16)); 526a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 527a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman break; 528a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 5294416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner case ISD::GlobalAddress: { 5304416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalValue *GV = cast<GlobalAddressSDNode>(N)->getGlobal(); 5314416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SDOperand Tmp; 5324416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SDOperand GA = CurDAG->getTargetGlobalAddress(GV, MVT::i32); 5339944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (PICEnabled) 5349944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Tmp = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(), GA); 5359944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner else 5364416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner Tmp = CurDAG->getTargetNode(PPC::LIS, MVT::i32, GA); 5379944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 5384416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (GV->hasWeakLinkage() || GV->isExternal()) 5394416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::LWZ, GA, Tmp); 5404416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner else 5414416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner CurDAG->SelectNodeTo(N, MVT::i32, PPC::LA, Tmp, GA); 5424416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner break; 5434416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 544305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::SIGN_EXTEND_INREG: 545305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman switch(cast<VTSDNode>(N->getOperand(1))->getVT()) { 546305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman default: assert(0 && "Illegal type in SIGN_EXTEND_INREG"); break; 547305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case MVT::i16: 548305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::EXTSH, Select(N->getOperand(0))); 549305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman break; 550305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case MVT::i8: 551305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::EXTSB, Select(N->getOperand(0))); 552305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman break; 553305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman } 554305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman break; 555305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::CTLZ: 556305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman assert(N->getValueType(0) == MVT::i32); 557305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::CNTLZW, Select(N->getOperand(0))); 558305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman break; 559a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::ADD: { 560a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner MVT::ValueType Ty = N->getValueType(0); 561a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Ty == MVT::i32) { 562a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (SDNode *I = SelectIntImmediateExpr(N->getOperand(0), N->getOperand(1), 563a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner PPC::ADDIS, PPC::ADDI, true)) { 564a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->ReplaceAllUsesWith(N, I); 565a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N = I; 566a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } else { 567a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, PPC::ADD, Select(N->getOperand(0)), 568a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1))); 569a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 570a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 571a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 572a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 573a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (!NoExcessFPPrecision) { // Match FMA ops 574a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (N->getOperand(0).getOpcode() == ISD::MUL && 575a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(0).Val->hasOneUse()) { 576a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 577a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, Ty == MVT::f64 ? PPC::FMADD : PPC::FMADDS, 578a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(0)), 579a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(1)), 580a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1))); 581a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 582a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } else if (N->getOperand(1).getOpcode() == ISD::MUL && 583a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(1).hasOneUse()) { 584a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 585a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, Ty == MVT::f64 ? PPC::FMADD : PPC::FMADDS, 586a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(0)), 587a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(1)), 588a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0))); 589a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 590a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 591a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 592a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 593a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, Ty == MVT::f64 ? PPC::FADD : PPC::FADDS, 594a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0)), Select(N->getOperand(1))); 595a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 596a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 597a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::SUB: { 598a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner MVT::ValueType Ty = N->getValueType(0); 599a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (Ty == MVT::i32) { 600a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner unsigned Imm; 601a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (isIntImmediate(N->getOperand(0), Imm) && isInt16(Imm)) { 602a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, PPC::SUBFIC, Select(N->getOperand(1)), 603a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner getI32Imm(Lo16(Imm))); 604a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 605a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 606a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (SDNode *I = SelectIntImmediateExpr(N->getOperand(0), N->getOperand(1), 607a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner PPC::ADDIS, PPC::ADDI, true, true)) { 608a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->ReplaceAllUsesWith(N, I); 609a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N = I; 610a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } else { 611a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, PPC::SUBF, Select(N->getOperand(1)), 612a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0))); 613a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 614a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 615a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 616a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 617a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (!NoExcessFPPrecision) { // Match FMA ops 618a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (N->getOperand(0).getOpcode() == ISD::MUL && 619a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(0).Val->hasOneUse()) { 620a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 621a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, Ty == MVT::f64 ? PPC::FMSUB : PPC::FMSUBS, 622a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(0)), 623a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0).getOperand(1)), 624a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1))); 625a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 626a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } else if (N->getOperand(1).getOpcode() == ISD::MUL && 627a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(1).Val->hasOneUse()) { 628a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner ++FusedFP; // Statistic 629a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, Ty == MVT::f64 ? PPC::FNMSUB : PPC::FNMSUBS, 630a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(0)), 631a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1).getOperand(1)), 632a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0))); 633a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 634a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 635a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 636a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, Ty, Ty == MVT::f64 ? PPC::FSUB : PPC::FSUBS, 637a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(0)), 638a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Select(N->getOperand(1))); 639a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 64026653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 641b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman case ISD::MUL: { 642b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman unsigned Imm, Opc; 643b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman if (isIntImmediate(N->getOperand(1), Imm) && isInt16(Imm)) { 644b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman CurDAG->SelectNodeTo(N, N->getValueType(0), PPC::MULLI, 645b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman Select(N->getOperand(0)), getI32Imm(Lo16(Imm))); 646b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman break; 647b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman } 648b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman switch (N->getValueType(0)) { 649b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman default: assert(0 && "Unhandled multiply type!"); 650b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman case MVT::i32: Opc = PPC::MULLW; break; 651b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman case MVT::f32: Opc = PPC::FMULS; break; 652b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman case MVT::f64: Opc = PPC::FMUL; break; 653b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman } 654b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman CurDAG->SelectNodeTo(N, N->getValueType(0), Opc, Select(N->getOperand(0)), 655b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman Select(N->getOperand(1))); 656b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman break; 657b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman } 658305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::MULHS: 659b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman assert(N->getValueType(0) == MVT::i32); 660305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::MULHW, Select(N->getOperand(0)), 661305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman Select(N->getOperand(1))); 662b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman break; 663305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::MULHU: 664b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman assert(N->getValueType(0) == MVT::i32); 665305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::MULHWU, Select(N->getOperand(0)), 666305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman Select(N->getOperand(1))); 667b5a0668d43582297e19d03df34e0a0c09a1f6c45Nate Begeman break; 668cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman case ISD::AND: { 669a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned Imm; 670cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and of a value rotated between 0 and 31 bits and then and'd 671cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // with a mask, emit rlwinm 672cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isIntImmediate(N->getOperand(1), Imm) && (isShiftedMask_32(Imm) || 673cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isShiftedMask_32(~Imm))) { 674cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SDOperand Val; 675a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned SH, MB, ME; 676cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isRotateAndMask(N->getOperand(0).Val, Imm, false, SH, MB, ME)) { 677cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Val = Select(N->getOperand(0).getOperand(0)); 678cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 679cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Val = Select(N->getOperand(0)); 680cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isRunOfOnes(Imm, MB, ME); 681cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = 0; 682cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 683cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, Val, getI32Imm(SH), 684cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman getI32Imm(MB), getI32Imm(ME)); 685cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman break; 686cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 687cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and with an immediate that isn't a mask, then codegen it as 688cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // high and low 16 bit immediate ands. 689cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (SDNode *I = SelectIntImmediateExpr(N->getOperand(0), 690cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman N->getOperand(1), 691cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman PPC::ANDISo, PPC::ANDIo)) { 692cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman CurDAG->ReplaceAllUsesWith(N, I); 693cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman N = I; 694cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman break; 695cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 696cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // Finally, check for the case where we are being asked to select 697cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // and (not(a), b) or and (a, not(b)) which can be selected as andc. 698cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isOprNot(N->getOperand(0).Val)) 699cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::ANDC, Select(N->getOperand(1)), 700cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Select(N->getOperand(0).getOperand(0))); 701cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman else if (isOprNot(N->getOperand(1).Val)) 702cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::ANDC, Select(N->getOperand(0)), 703cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Select(N->getOperand(1).getOperand(0))); 704cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman else 705cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::AND, Select(N->getOperand(0)), 706cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Select(N->getOperand(1))); 707cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman break; 708cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 70902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::OR: 71002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (SDNode *I = SelectBitfieldInsert(N)) { 71102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman CurDAG->ReplaceAllUsesWith(N, I); 71202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman N = I; 71302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman break; 71402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 71502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (SDNode *I = SelectIntImmediateExpr(N->getOperand(0), 71602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman N->getOperand(1), 71702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman PPC::ORIS, PPC::ORI)) { 71802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman CurDAG->ReplaceAllUsesWith(N, I); 71902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman N = I; 72002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman break; 72102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 72202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Finally, check for the case where we are being asked to select 72302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // 'or (not(a), b)' or 'or (a, not(b))' which can be selected as orc. 72402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isOprNot(N->getOperand(0).Val)) 72502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::ORC, Select(N->getOperand(1)), 72602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Select(N->getOperand(0).getOperand(0))); 72702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman else if (isOprNot(N->getOperand(1).Val)) 72802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::ORC, Select(N->getOperand(0)), 72902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Select(N->getOperand(1).getOperand(0))); 73002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman else 73102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::OR, Select(N->getOperand(0)), 73202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Select(N->getOperand(1))); 73302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman break; 7340f3257a3302b60c128a667db6736e81335316c1eNate Begeman case ISD::XOR: 7350f3257a3302b60c128a667db6736e81335316c1eNate Begeman // Check whether or not this node is a logical 'not'. This is represented 7360f3257a3302b60c128a667db6736e81335316c1eNate Begeman // by llvm as a xor with the constant value -1 (all bits set). If this is a 7370f3257a3302b60c128a667db6736e81335316c1eNate Begeman // 'not', then fold 'or' into 'nor', and so forth for the supported ops. 7380f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (isOprNot(N)) { 7390f3257a3302b60c128a667db6736e81335316c1eNate Begeman unsigned Opc; 740131a8805205c383f67b3b6a11777401e27b90371Nate Begeman SDOperand Val = Select(N->getOperand(0)); 741131a8805205c383f67b3b6a11777401e27b90371Nate Begeman switch (Val.getTargetOpcode()) { 7420f3257a3302b60c128a667db6736e81335316c1eNate Begeman default: Opc = 0; break; 743131a8805205c383f67b3b6a11777401e27b90371Nate Begeman case PPC::OR: Opc = PPC::NOR; break; 744131a8805205c383f67b3b6a11777401e27b90371Nate Begeman case PPC::AND: Opc = PPC::NAND; break; 745131a8805205c383f67b3b6a11777401e27b90371Nate Begeman case PPC::XOR: Opc = PPC::EQV; break; 7460f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 7470f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (Opc) 748131a8805205c383f67b3b6a11777401e27b90371Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, Opc, Val.getOperand(0), 749131a8805205c383f67b3b6a11777401e27b90371Nate Begeman Val.getOperand(1)); 7500f3257a3302b60c128a667db6736e81335316c1eNate Begeman else 751131a8805205c383f67b3b6a11777401e27b90371Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::NOR, Val, Val); 7520f3257a3302b60c128a667db6736e81335316c1eNate Begeman break; 7530f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 7540f3257a3302b60c128a667db6736e81335316c1eNate Begeman // If this is a xor with an immediate other than -1, then codegen it as high 7550f3257a3302b60c128a667db6736e81335316c1eNate Begeman // and low 16 bit immediate xors. 7560f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (SDNode *I = SelectIntImmediateExpr(N->getOperand(0), 7570f3257a3302b60c128a667db6736e81335316c1eNate Begeman N->getOperand(1), 7580f3257a3302b60c128a667db6736e81335316c1eNate Begeman PPC::XORIS, PPC::XORI)) { 7590f3257a3302b60c128a667db6736e81335316c1eNate Begeman CurDAG->ReplaceAllUsesWith(N, I); 7600f3257a3302b60c128a667db6736e81335316c1eNate Begeman N = I; 7610f3257a3302b60c128a667db6736e81335316c1eNate Begeman break; 7620f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 7630f3257a3302b60c128a667db6736e81335316c1eNate Begeman // Finally, check for the case where we are being asked to select 7640f3257a3302b60c128a667db6736e81335316c1eNate Begeman // xor (not(a), b) which is equivalent to not(xor a, b), which is eqv 7650f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (isOprNot(N->getOperand(0).Val)) 7660f3257a3302b60c128a667db6736e81335316c1eNate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::EQV, 7670f3257a3302b60c128a667db6736e81335316c1eNate Begeman Select(N->getOperand(0).getOperand(0)), 7680f3257a3302b60c128a667db6736e81335316c1eNate Begeman Select(N->getOperand(1))); 7690f3257a3302b60c128a667db6736e81335316c1eNate Begeman else 7700f3257a3302b60c128a667db6736e81335316c1eNate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::XOR, Select(N->getOperand(0)), 7710f3257a3302b60c128a667db6736e81335316c1eNate Begeman Select(N->getOperand(1))); 7720f3257a3302b60c128a667db6736e81335316c1eNate Begeman break; 773c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SHL: { 774c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 775c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 776c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) 777c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, 778c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(0).getOperand(0)), 779c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 780c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else if (isIntImmediate(N->getOperand(1), Imm)) 781c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, Select(N->getOperand(0)), 782c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(Imm), getI32Imm(0), getI32Imm(31-Imm)); 783c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else 784c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::SLW, Select(N->getOperand(0)), 785c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(1))); 786c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman break; 787c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 788c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRL: { 789c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 790c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 791c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) 792c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, 793c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(0).getOperand(0)), 794c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 795c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else if (isIntImmediate(N->getOperand(1), Imm)) 796c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, Select(N->getOperand(0)), 797c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(32-Imm), getI32Imm(Imm), getI32Imm(31)); 798c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else 799c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::SRW, Select(N->getOperand(0)), 800c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(1))); 801c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman break; 802c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 803c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRA: { 804c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 805c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 806c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) 807c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::RLWINM, 808c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(0).getOperand(0)), 809c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 810c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else if (isIntImmediate(N->getOperand(1), Imm)) 811c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::SRAWI, Select(N->getOperand(0)), 812c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman getI32Imm(Imm)); 813c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman else 814c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman CurDAG->SelectNodeTo(N, MVT::i32, PPC::SRAW, Select(N->getOperand(0)), 815c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman Select(N->getOperand(1))); 816c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman break; 817c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 818305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::FABS: 8196a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman CurDAG->SelectNodeTo(N, N->getValueType(0), PPC::FABS, 8206a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman Select(N->getOperand(0))); 8216a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman break; 822305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::FP_EXTEND: 823305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman assert(MVT::f64 == N->getValueType(0) && 824305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman MVT::f32 == N->getOperand(0).getValueType() && "Illegal FP_EXTEND"); 825305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman CurDAG->SelectNodeTo(N, MVT::f64, PPC::FMR, Select(N->getOperand(0))); 826305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman break; 827305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman case ISD::FP_ROUND: 828305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman assert(MVT::f32 == N->getValueType(0) && 829305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman MVT::f64 == N->getOperand(0).getValueType() && "Illegal FP_ROUND"); 830305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman CurDAG->SelectNodeTo(N, MVT::f32, PPC::FRSP, Select(N->getOperand(0))); 831305a1c75cfcc1b2e97c2bccebd42a70d99e7d127Nate Begeman break; 83226653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case ISD::FNEG: { 83326653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman SDOperand Val = Select(N->getOperand(0)); 83426653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman MVT::ValueType Ty = N->getValueType(0); 83526653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman if (Val.Val->hasOneUse()) { 83626653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman unsigned Opc; 83726653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman switch (Val.getTargetOpcode()) { 83826653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman default: Opc = 0; break; 83926653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FABS: Opc = PPC::FNABS; break; 84026653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMADD: Opc = PPC::FNMADD; break; 84126653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMADDS: Opc = PPC::FNMADDS; break; 84226653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMSUB: Opc = PPC::FNMSUB; break; 84326653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman case PPC::FMSUBS: Opc = PPC::FNMSUBS; break; 84426653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 84526653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // If we inverted the opcode, then emit the new instruction with the 84626653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // inverted opcode and the original instruction's operands. Otherwise, 84726653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman // fall through and generate a fneg instruction. 84826653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman if (Opc) { 84926653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman if (PPC::FNABS == Opc) 85026653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman CurDAG->SelectNodeTo(N, Ty, Opc, Val.getOperand(0)); 85126653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman else 85226653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman CurDAG->SelectNodeTo(N, Ty, Opc, Val.getOperand(0), 85326653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman Val.getOperand(1), Val.getOperand(2)); 85426653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman break; 85526653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 85626653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 85726653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman CurDAG->SelectNodeTo(N, Ty, PPC::FNEG, Val); 85826653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman break; 85926653500bbbc21cd1c2d12ecc433fa439536b657Nate Begeman } 8606a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman case ISD::FSQRT: { 8616a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman MVT::ValueType Ty = N->getValueType(0); 8626a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman CurDAG->SelectNodeTo(N, Ty, Ty == MVT::f64 ? PPC::FSQRT : PPC::FSQRTS, 8636a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman Select(N->getOperand(0))); 8646a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman break; 8656a7d61179c77c23dc22cd64e5e922bc40ed234e9Nate Begeman } 8669944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::LOAD: 8679944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::EXTLOAD: 8689944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::ZEXTLOAD: 8699944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case ISD::SEXTLOAD: { 8709944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner SDOperand Op1, Op2; 8719944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner bool isIdx = SelectAddr(N->getOperand(1), Op1, Op2); 8729944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 8739944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner MVT::ValueType TypeBeingLoaded = (N->getOpcode() == ISD::LOAD) ? 8749944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner N->getValueType(0) : cast<VTSDNode>(N->getOperand(3))->getVT(); 8759944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner unsigned Opc; 8769944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner switch (TypeBeingLoaded) { 8779944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner default: N->dump(); assert(0 && "Cannot load this type!"); 8789944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i1: 8799944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i8: Opc = isIdx ? PPC::LBZX : PPC::LBZ; break; 8809944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i16: 8819944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner if (N->getOpcode() == ISD::SEXTLOAD) { // SEXT load? 8829944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Opc = isIdx ? PPC::LHAX : PPC::LHA; 8839944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 8849944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Opc = isIdx ? PPC::LHZX : PPC::LHZ; 8859944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 8869944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner break; 8879944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::i32: Opc = isIdx ? PPC::LWZX : PPC::LWZ; break; 8889944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::f32: Opc = isIdx ? PPC::LFSX : PPC::LFS; break; 8899944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner case MVT::f64: Opc = isIdx ? PPC::LFDX : PPC::LFD; break; 8909944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 8919944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 8929944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner CurDAG->SelectNodeTo(N, N->getValueType(0), MVT::Other, Opc, 8939944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner Op1, Op2, Select(N->getOperand(0))); 8949944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner break; 8959944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 8969944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 897f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case ISD::TRUNCSTORE: 898f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case ISD::STORE: { 899f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner SDOperand AddrOp1, AddrOp2; 900f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner bool isIdx = SelectAddr(N->getOperand(2), AddrOp1, AddrOp2); 901f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner 902f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner unsigned Opc; 903f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner if (N->getOpcode() == ISD::STORE) { 904f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner switch (N->getOperand(1).getValueType()) { 905f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner default: assert(0 && "unknown Type in store"); 906f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::i32: Opc = isIdx ? PPC::STWX : PPC::STW; break; 907f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::f64: Opc = isIdx ? PPC::STFDX : PPC::STFD; break; 908f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::f32: Opc = isIdx ? PPC::STFSX : PPC::STFS; break; 909f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 910f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } else { //ISD::TRUNCSTORE 911f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner switch(cast<VTSDNode>(N->getOperand(4))->getVT()) { 912f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner default: assert(0 && "unknown Type in store"); 913f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::i1: 914f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::i8: Opc = isIdx ? PPC::STBX : PPC::STB; break; 915f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner case MVT::i16: Opc = isIdx ? PPC::STHX : PPC::STH; break; 916f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 917f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 918f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner 919f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner CurDAG->SelectNodeTo(N, MVT::Other, Opc, Select(N->getOperand(1)), 920f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner AddrOp1, AddrOp2, Select(N->getOperand(0))); 921f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner break; 922a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner } 923a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner 924a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner case ISD::CALLSEQ_START: 925a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner case ISD::CALLSEQ_END: { 926a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner unsigned Amt = cast<ConstantSDNode>(N->getOperand(1))->getValue(); 927a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner unsigned Opc = N->getOpcode() == ISD::CALLSEQ_START ? 928a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner PPC::ADJCALLSTACKDOWN : PPC::ADJCALLSTACKUP; 929a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner CurDAG->SelectNodeTo(N, MVT::Other, Opc, Select(N->getOperand(0)), 930a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner getI32Imm(Amt)); 931a2590c5b3eaa24002e3f83f146f0e5b6c95a89c8Chris Lattner break; 932f7f22555053a8992b2f97db77a62458ff8a69d7fChris Lattner } 933a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case ISD::RET: { 934a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Chain = Select(N->getOperand(0)); // Token chain. 935a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 936a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (N->getNumOperands() > 1) { 937a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDOperand Val = Select(N->getOperand(1)); 938a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOperand(1).getValueType()) { 939a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner default: assert(0 && "Unknown return type!"); 940a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case MVT::f64: 941a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case MVT::f32: 942a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Chain = CurDAG->getCopyToReg(Chain, PPC::F1, Val); 943a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 944a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner case MVT::i32: 945a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Chain = CurDAG->getCopyToReg(Chain, PPC::R3, Val); 946a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 947a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 948a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 949a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (N->getNumOperands() > 2) { 950a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner assert(N->getOperand(1).getValueType() == MVT::i32 && 951a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getOperand(2).getValueType() == MVT::i32 && 952a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner N->getNumOperands() == 2 && "Unknown two-register ret value!"); 953a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Val = Select(N->getOperand(2)); 954a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Chain = CurDAG->getCopyToReg(Chain, PPC::R4, Val); 955a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 956a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 957a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 958a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Finally, select this to a blr (return) instruction. 959a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner CurDAG->SelectNodeTo(N, MVT::Other, PPC::BLR, Chain); 960a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner break; 961a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 9622fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 9632fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::BR_CC: 9642fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::BRTWOWAY_CC: { 9652fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand Chain = Select(N->getOperand(0)); 9662fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner MachineBasicBlock *Dest = 9672fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner cast<BasicBlockSDNode>(N->getOperand(4))->getBasicBlock(); 9682fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(1))->get(); 9692fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CondCode = SelectCC(N->getOperand(2), N->getOperand(3), CC); 9702fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner unsigned Opc = getBCCForSetCC(CC); 9712fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 9722fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // If this is a two way branch, then grab the fallthrough basic block 9732fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // argument and build a PowerPC branch pseudo-op, suitable for long branch 9742fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // conversion if necessary by the branch selection pass. Otherwise, emit a 9752fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // standard conditional branch. 9762fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (N->getOpcode() == ISD::BRTWOWAY_CC) { 9772fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner MachineBasicBlock *Fallthrough = 9782fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner cast<BasicBlockSDNode>(N->getOperand(5))->getBasicBlock(); 9792fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CB = CurDAG->getTargetNode(PPC::COND_BRANCH, MVT::Other, 9802fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner CondCode, getI32Imm(Opc), 9812fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner N->getOperand(4), N->getOperand(5), 9822fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner Chain); 9832fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner CurDAG->SelectNodeTo(N, MVT::Other, PPC::B, N->getOperand(5), CB); 9842fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 9852fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Iterate to the next basic block 9862fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ilist<MachineBasicBlock>::iterator It = BB; 9872fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ++It; 9882fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 9892fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // If the fallthrough path is off the end of the function, which would be 9902fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // undefined behavior, set it to be the same as the current block because 9912fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // we have nothing better to set it to, and leaving it alone will cause 9922fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // the PowerPC Branch Selection pass to crash. 9932fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (It == BB->getParent()->end()) It = Dest; 9942fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner CurDAG->SelectNodeTo(N, MVT::Other, PPC::COND_BRANCH, CondCode, 9952fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner getI32Imm(Opc), N->getOperand(4), 9962fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner CurDAG->getBasicBlock(It), Chain); 9972fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 9982fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner break; 9992fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 1000a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 1001ddf3e7dfd791f7cdbcd1bb5feb168067b5b9c16dChris Lattner return SDOperand(N, Op.ResNo); 1002a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1003a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1004a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1005a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// createPPC32ISelDag - This pass converts a legalized DAG into a 1006a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// PowerPC-specific DAG, ready for instruction scheduling. 1007a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// 1008a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris LattnerFunctionPass *llvm::createPPC32ISelDag(TargetMachine &TM) { 1009a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return new PPC32DAGToDAGISel(TM); 1010a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1011a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1012