PPCISelDAGToDAG.cpp revision 0949ed5412c0902113aaefe106fed5b383fcc696
121e463b2bf864671a87ebe386cb100ef9349a540Nate Begeman//===-- PPCISelDAGToDAG.cpp - PPC --pattern matching inst selector --------===// 2a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 3a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// The LLVM Compiler Infrastructure 4a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 5a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// This file was developed by Chris Lattner and is distributed under 6a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// the University of Illinois Open Source License. See LICENSE.TXT for details. 7a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 8a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner//===----------------------------------------------------------------------===// 9a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 1021e463b2bf864671a87ebe386cb100ef9349a540Nate Begeman// This file defines a pattern matching instruction selector for PowerPC, 11a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// converting from a legalized dag to a PPC dag. 12a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 13a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner//===----------------------------------------------------------------------===// 14a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 152668959b8879097db368aec7d76c455260abc75bChris Lattner#include "PPC.h" 1616e71f2f70811c69c56052dd146324fe20e31db5Chris Lattner#include "PPCTargetMachine.h" 1716e71f2f70811c69c56052dd146324fe20e31db5Chris Lattner#include "PPCISelLowering.h" 18c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner#include "PPCHazardRecognizers.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" 28420736dc85c01702bb7bc40495f8a4be5e5f8a6cChris Lattner#include "llvm/Intrinsics.h" 29a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Support/Debug.h" 30a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Support/MathExtras.h" 312c2c6c61f100bc7c3df873b11203fcea1b5e18feChris Lattner#include <iostream> 32ba2f0a9ee53512ce840aca34281e126802a125d1Evan Cheng#include <set> 33a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerusing namespace llvm; 34a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 35a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnernamespace { 36a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Statistic<> FrameOff("ppc-codegen", "Number of frame idx offsets collapsed"); 37a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 38a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner //===--------------------------------------------------------------------===// 391d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman /// PPCDAGToDAGISel - PPC specific code to select PPC machine 40a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// instructions for SelectionDAG operations. 41a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// 421d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman class PPCDAGToDAGISel : public SelectionDAGISel { 434bb189507281af0da8aff91743b5198acbf2398bChris Lattner PPCTargetMachine &TM; 4421e463b2bf864671a87ebe386cb100ef9349a540Nate Begeman PPCTargetLowering PPCLowering; 454416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner unsigned GlobalBaseReg; 46a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner public: 474bb189507281af0da8aff91743b5198acbf2398bChris Lattner PPCDAGToDAGISel(PPCTargetMachine &tm) 484bb189507281af0da8aff91743b5198acbf2398bChris Lattner : SelectionDAGISel(PPCLowering), TM(tm), 494bb189507281af0da8aff91743b5198acbf2398bChris Lattner PPCLowering(*TM.getTargetLowering()) {} 50a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 514416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner virtual bool runOnFunction(Function &Fn) { 524416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Make sure we re-emit a set of the global base reg if necessary 534416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalBaseReg = 0; 544bb189507281af0da8aff91743b5198acbf2398bChris Lattner SelectionDAGISel::runOnFunction(Fn); 554bb189507281af0da8aff91743b5198acbf2398bChris Lattner 564bb189507281af0da8aff91743b5198acbf2398bChris Lattner InsertVRSaveCode(Fn); 574bb189507281af0da8aff91743b5198acbf2398bChris Lattner return true; 584416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 594416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 60a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// getI32Imm - Return a target constant with the specified value, of type 61a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// i32. 62a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner inline SDOperand getI32Imm(unsigned Imm) { 63a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return CurDAG->getTargetConstant(Imm, MVT::i32); 64a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 654416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 664416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// getGlobalBaseReg - insert code into the entry mbb to materialize the PIC 674416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// base register. Return the virtual register that holds this value. 689944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner SDOperand getGlobalBaseReg(); 69a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 70a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Select - Convert the specified operand from a target-independent to a 71a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // target-specific node if it hasn't already been changed. 7234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng void Select(SDOperand &Result, SDOperand Op); 73a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 7402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDNode *SelectBitfieldInsert(SDNode *N); 7502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 762fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// SelectCC - Select a comparison of the specified values with the 772fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// specified condition code, returning the CR# of the expression. 782fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand SelectCC(SDOperand LHS, SDOperand RHS, ISD::CondCode CC); 792fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 807fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrImm - Returns true if the address N can be represented by 817fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// a base register plus a signed 16-bit displacement [r+imm]. 827fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman bool SelectAddrImm(SDOperand N, SDOperand &Disp, SDOperand &Base); 837fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman 847fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrIdx - Given the specified addressed, check to see if it can be 857fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// represented as an indexed [r+r] operation. Returns false if it can 867fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// be represented by [r+imm], which are preferred. 877fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman bool SelectAddrIdx(SDOperand N, SDOperand &Base, SDOperand &Index); 88f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman 897fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrIdxOnly - Given the specified addressed, force it to be 907fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// represented as an indexed [r+r] operation. 917fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman bool SelectAddrIdxOnly(SDOperand N, SDOperand &Base, SDOperand &Index); 929944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 93e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// SelectAddrImmShift - Returns true if the address N can be represented by 94e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// a base register plus a signed 14-bit displacement [r+imm*4]. Suitable 95e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// for use by STD and friends. 96e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner bool SelectAddrImmShift(SDOperand N, SDOperand &Disp, SDOperand &Base); 97e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 98e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner /// SelectInlineAsmMemoryOperand - Implement addressing mode selection for 99e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner /// inline asm expressions. 100e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner virtual bool SelectInlineAsmMemoryOperand(const SDOperand &Op, 101e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner char ConstraintCode, 102e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner std::vector<SDOperand> &OutOps, 103e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner SelectionDAG &DAG) { 104e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner SDOperand Op0, Op1; 105e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner switch (ConstraintCode) { 106e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner default: return true; 107e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'm': // memory 108e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner if (!SelectAddrIdx(Op, Op0, Op1)) 109e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner SelectAddrImm(Op, Op0, Op1); 110e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 111e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'o': // offsetable 112e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner if (!SelectAddrImm(Op, Op0, Op1)) { 113e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner Select(Op0, Op); // r+0. 114e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner Op1 = getI32Imm(0); 115e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 116e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 117e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'v': // not offsetable 118e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner SelectAddrIdxOnly(Op, Op0, Op1); 119e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 120e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 121e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner 122e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner OutOps.push_back(Op0); 123e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner OutOps.push_back(Op1); 124e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner return false; 125e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 126e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner 127047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand BuildSDIVSequence(SDNode *N); 128047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand BuildUDIVSequence(SDNode *N); 129047b952e298352fe6feffedf02e359601133f465Chris Lattner 130a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// InstructionSelectBasicBlock - This callback is invoked by 131a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 132bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner virtual void InstructionSelectBasicBlock(SelectionDAG &DAG); 133bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 1344bb189507281af0da8aff91743b5198acbf2398bChris Lattner void InsertVRSaveCode(Function &Fn); 1354bb189507281af0da8aff91743b5198acbf2398bChris Lattner 136a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner virtual const char *getPassName() const { 137a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return "PowerPC DAG->DAG Pattern Instruction Selection"; 138a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 139c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner 140b0d21ef20c29f4ea46d21b488f17feaa6a8760e1Chris Lattner /// CreateTargetHazardRecognizer - Return the hazard recognizer to use for this 141c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner /// target when scheduling the DAG. 142b0d21ef20c29f4ea46d21b488f17feaa6a8760e1Chris Lattner virtual HazardRecognizer *CreateTargetHazardRecognizer() { 143c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner // Should use subtarget info to pick the right hazard recognizer. For 144c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner // now, always return a PPC970 recognizer. 14588d211f82304e53694ece666d4a2507b170e4582Chris Lattner const TargetInstrInfo *II = PPCLowering.getTargetMachine().getInstrInfo(); 14688d211f82304e53694ece666d4a2507b170e4582Chris Lattner assert(II && "No InstrInfo?"); 14788d211f82304e53694ece666d4a2507b170e4582Chris Lattner return new PPCHazardRecognizer970(*II); 148c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner } 149af165385112037cb942e94ea562a67990b7d6220Chris Lattner 150af165385112037cb942e94ea562a67990b7d6220Chris Lattner// Include the pieces autogenerated from the target description. 1514c7b43b43fdf943c7298718e15ab5d6dfe345be7Chris Lattner#include "PPCGenDAGISel.inc" 152bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 153bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattnerprivate: 154222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand SelectSETCC(SDOperand Op); 1556a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand SelectCALL(SDOperand Op); 156a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner }; 157a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 158a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 159bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner/// InstructionSelectBasicBlock - This callback is invoked by 160bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner/// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 1611d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begemanvoid PPCDAGToDAGISel::InstructionSelectBasicBlock(SelectionDAG &DAG) { 162bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DEBUG(BB->dump()); 163bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 164bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // The selection process is inherently a bottom-up recursive process (users 165bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // select their uses before themselves). Given infinite stack space, we 166bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // could just start selecting on the root and traverse the whole graph. In 167bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // practice however, this causes us to run out of stack space on large basic 168bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // blocks. To avoid this problem, select the entry node, then all its uses, 169bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // iteratively instead of recursively. 170bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner std::vector<SDOperand> Worklist; 171bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Worklist.push_back(DAG.getEntryNode()); 172bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 173bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Note that we can do this in the PPC target (scanning forward across token 174bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // chain edges) because no nodes ever get folded across these edges. On a 175bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // target like X86 which supports load/modify/store operations, this would 176bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // have to be more careful. 177bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner while (!Worklist.empty()) { 178bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDOperand Node = Worklist.back(); 179bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Worklist.pop_back(); 180bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 181cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner // Chose from the least deep of the top two nodes. 182cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner if (!Worklist.empty() && 183cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner Worklist.back().Val->getNodeDepth() < Node.Val->getNodeDepth()) 184cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner std::swap(Worklist.back(), Node); 185cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner 186bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner if ((Node.Val->getOpcode() >= ISD::BUILTIN_OP_END && 187bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Node.Val->getOpcode() < PPCISD::FIRST_NUMBER) || 188bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner CodeGenMap.count(Node)) continue; 189bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 190bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner for (SDNode::use_iterator UI = Node.Val->use_begin(), 191bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner E = Node.Val->use_end(); UI != E; ++UI) { 192bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Scan the values. If this use has a value that is a token chain, add it 193bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // to the worklist. 194bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDNode *User = *UI; 195bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner for (unsigned i = 0, e = User->getNumValues(); i != e; ++i) 196bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner if (User->getValueType(i) == MVT::Other) { 197bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Worklist.push_back(SDOperand(User, i)); 198bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner break; 199bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner } 200bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner } 201bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 202bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Finally, legalize this node. 20334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Dummy; 20434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Dummy, Node); 205bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner } 206cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner 207bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Select target instructions for the DAG. 208ba2f0a9ee53512ce840aca34281e126802a125d1Evan Cheng DAG.setRoot(SelectRoot(DAG.getRoot())); 209bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner CodeGenMap.clear(); 210bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DAG.RemoveDeadNodes(); 211bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 2121877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // Emit machine code to BB. 213bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner ScheduleAndEmitDAG(DAG); 2144bb189507281af0da8aff91743b5198acbf2398bChris Lattner} 2154bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2164bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// InsertVRSaveCode - Once the entire function has been instruction selected, 2174bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// all virtual registers are created and all machine instructions are built, 2184bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// check to see if we need to save/restore VRSAVE. If so, do it. 2194bb189507281af0da8aff91743b5198acbf2398bChris Lattnervoid PPCDAGToDAGISel::InsertVRSaveCode(Function &F) { 2201877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // Check to see if this function uses vector registers, which means we have to 2211877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // save and restore the VRSAVE register and update it with the regs we use. 2221877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2231877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // In this case, there will be virtual registers of vector type type created 2241877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // by the scheduler. Detect them now. 2254bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineFunction &Fn = MachineFunction::get(&F); 2264bb189507281af0da8aff91743b5198acbf2398bChris Lattner SSARegMap *RegMap = Fn.getSSARegMap(); 2271877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner bool HasVectorVReg = false; 2281877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner for (unsigned i = MRegisterInfo::FirstVirtualRegister, 229a08610c8a534501bc4301c5037e883f180b19a99Chris Lattner e = RegMap->getLastVirtReg()+1; i != e; ++i) 2301877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner if (RegMap->getRegClass(i) == &PPC::VRRCRegClass) { 2311877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner HasVectorVReg = true; 2321877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner break; 2331877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner } 2344bb189507281af0da8aff91743b5198acbf2398bChris Lattner if (!HasVectorVReg) return; // nothing to do. 2354bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2361877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // If we have a vector register, we want to emit code into the entry and exit 2371877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // blocks to save and restore the VRSAVE register. We do this here (instead 2381877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // of marking all vector instructions as clobbering VRSAVE) for two reasons: 2391877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2401877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 1. This (trivially) reduces the load on the register allocator, by not 2411877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // having to represent the live range of the VRSAVE register. 2421877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2. This (more significantly) allows us to create a temporary virtual 2431877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // register to hold the saved VRSAVE value, allowing this temporary to be 2441877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // register allocated, instead of forcing it to be spilled to the stack. 2454bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2464bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Create two vregs - one to hold the VRSAVE register that is live-in to the 2474bb189507281af0da8aff91743b5198acbf2398bChris Lattner // function and one for the value after having bits or'd into it. 2484bb189507281af0da8aff91743b5198acbf2398bChris Lattner unsigned InVRSAVE = RegMap->createVirtualRegister(&PPC::GPRCRegClass); 2494bb189507281af0da8aff91743b5198acbf2398bChris Lattner unsigned UpdatedVRSAVE = RegMap->createVirtualRegister(&PPC::GPRCRegClass); 2504bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2514bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock &EntryBB = *Fn.begin(); 2524bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Emit the following code into the entry block: 2534bb189507281af0da8aff91743b5198acbf2398bChris Lattner // InVRSAVE = MFVRSAVE 2544bb189507281af0da8aff91743b5198acbf2398bChris Lattner // UpdatedVRSAVE = UPDATE_VRSAVE InVRSAVE 2554bb189507281af0da8aff91743b5198acbf2398bChris Lattner // MTVRSAVE UpdatedVRSAVE 2564bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock::iterator IP = EntryBB.begin(); // Insert Point 2574bb189507281af0da8aff91743b5198acbf2398bChris Lattner BuildMI(EntryBB, IP, PPC::MFVRSAVE, 0, InVRSAVE); 2584bb189507281af0da8aff91743b5198acbf2398bChris Lattner BuildMI(EntryBB, IP, PPC::UPDATE_VRSAVE, 1, UpdatedVRSAVE).addReg(InVRSAVE); 2594bb189507281af0da8aff91743b5198acbf2398bChris Lattner BuildMI(EntryBB, IP, PPC::MTVRSAVE, 1).addReg(UpdatedVRSAVE); 2604bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2614bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Find all return blocks, outputting a restore in each epilog. 2624bb189507281af0da8aff91743b5198acbf2398bChris Lattner const TargetInstrInfo &TII = *TM.getInstrInfo(); 2634bb189507281af0da8aff91743b5198acbf2398bChris Lattner for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 2644bb189507281af0da8aff91743b5198acbf2398bChris Lattner if (!BB->empty() && TII.isReturn(BB->back().getOpcode())) { 2654bb189507281af0da8aff91743b5198acbf2398bChris Lattner IP = BB->end(); --IP; 2664bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2674bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Skip over all terminator instructions, which are part of the return 2684bb189507281af0da8aff91743b5198acbf2398bChris Lattner // sequence. 2694bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock::iterator I2 = IP; 2704bb189507281af0da8aff91743b5198acbf2398bChris Lattner while (I2 != BB->begin() && TII.isTerminatorInstr((--I2)->getOpcode())) 2714bb189507281af0da8aff91743b5198acbf2398bChris Lattner IP = I2; 2724bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2734bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Emit: MTVRSAVE InVRSave 2744bb189507281af0da8aff91743b5198acbf2398bChris Lattner BuildMI(*BB, IP, PPC::MTVRSAVE, 1).addReg(InVRSAVE); 2754bb189507281af0da8aff91743b5198acbf2398bChris Lattner } 2761877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner } 277bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner} 2786cd40d5888f905a3820d5d6c71e57cc0e02abb4aChris Lattner 2794bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2804416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// getGlobalBaseReg - Output the instructions required to put the 2814416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// base address to use for accessing globals into a register. 2824416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// 2831d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::getGlobalBaseReg() { 2844416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (!GlobalBaseReg) { 2854416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Insert the set of GlobalBaseReg into the first MBB of the function 2864416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock &FirstMBB = BB->getParent()->front(); 2874416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock::iterator MBBI = FirstMBB.begin(); 2884416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SSARegMap *RegMap = BB->getParent()->getSSARegMap(); 2891d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman // FIXME: when we get to LP64, we will need to create the appropriate 2901d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman // type of register here. 2911d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman GlobalBaseReg = RegMap->createVirtualRegister(PPC::GPRCRegisterClass); 2924416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MovePCtoLR, 0, PPC::LR); 2934416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MFLR, 1, GlobalBaseReg); 2944416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 2959944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return CurDAG->getRegister(GlobalBaseReg, MVT::i32); 2964416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner} 2974416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 2984416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 2990f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isIntImmediate - This method tests to see if a constant operand. 3000f3257a3302b60c128a667db6736e81335316c1eNate Begeman// If so Imm will receive the 32 bit value. 3010f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isIntImmediate(SDNode *N, unsigned& Imm) { 3020f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (N->getOpcode() == ISD::Constant) { 3030f3257a3302b60c128a667db6736e81335316c1eNate Begeman Imm = cast<ConstantSDNode>(N)->getValue(); 3040f3257a3302b60c128a667db6736e81335316c1eNate Begeman return true; 3050f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 3060f3257a3302b60c128a667db6736e81335316c1eNate Begeman return false; 3070f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 3080f3257a3302b60c128a667db6736e81335316c1eNate Begeman 309cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s with 310cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// any number of 0s on either side. The 1s are allowed to wrap from LSB to 311cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 0x0F0F0000 is 312cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// not, since all 1s are not contiguous. 313cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME) { 314cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isShiftedMask_32(Val)) { 315cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first non-zero bit 316cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman MB = CountLeadingZeros_32(Val); 317cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first zero bit after the run of ones 318cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman ME = CountLeadingZeros_32((Val - 1) ^ Val); 319cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return true; 3202fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } else { 3212fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner Val = ~Val; // invert mask 3222fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner if (isShiftedMask_32(Val)) { 3232fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first zero bit 3242fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner ME = CountLeadingZeros_32(Val) - 1; 3252fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first one bit after the run of zeros 3262fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner MB = CountLeadingZeros_32((Val - 1) ^ Val) + 1; 3272fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner return true; 3282fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } 329cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 330cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // no run present 331cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 332cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 333cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 33465a419a1045972729f91f82a378b7f4b7f6a2be5Chris Lattner// isRotateAndMask - Returns true if Mask and Shift can be folded into a rotate 335cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// and mask opcode and mask operation. 336cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRotateAndMask(SDNode *N, unsigned Mask, bool IsShiftMask, 337cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned &SH, unsigned &MB, unsigned &ME) { 338da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // Don't even go down this path for i64, since different logic will be 339da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // necessary for rldicl/rldicr/rldimi. 340da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman if (N->getValueType(0) != MVT::i32) 341da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman return false; 342da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman 343cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Shift = 32; 344cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Indeterminant = ~0; // bit mask marking indeterminant results 345cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Opcode = N->getOpcode(); 34615055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner if (N->getNumOperands() != 2 || 34715055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner !isIntImmediate(N->getOperand(1).Val, Shift) || (Shift > 31)) 348cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 349cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 350cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Opcode == ISD::SHL) { 351cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift left to mask if it comes first 352cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask << Shift; 353cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 354cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu << Shift); 355651dea74f6a362d30bc61fd0b549da7707af5bf8Chris Lattner } else if (Opcode == ISD::SRL) { 356cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift right to mask if it comes first 357cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask >> Shift; 358cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 359cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu >> Shift); 360cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // adjust for the left rotate 361cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Shift = 32 - Shift; 362cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 363cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 364cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 365cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 366cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // if the mask doesn't intersect any Indeterminant bits 367cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Mask && !(Mask & Indeterminant)) { 3680949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner SH = Shift & 31; 369cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // make sure the mask is still a mask (wrap arounds may not be) 370cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return isRunOfOnes(Mask, MB, ME); 371cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 372cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 373cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 374cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 3750f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isOpcWithIntImmediate - This method tests to see if the node is a specific 3760f3257a3302b60c128a667db6736e81335316c1eNate Begeman// opcode and that it has a immediate integer right operand. 3770f3257a3302b60c128a667db6736e81335316c1eNate Begeman// If so Imm will receive the 32 bit value. 3780f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isOpcWithIntImmediate(SDNode *N, unsigned Opc, unsigned& Imm) { 3790f3257a3302b60c128a667db6736e81335316c1eNate Begeman return N->getOpcode() == Opc && isIntImmediate(N->getOperand(1).Val, Imm); 3800f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 3810f3257a3302b60c128a667db6736e81335316c1eNate Begeman 382a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// isIntImmediate - This method tests to see if a constant operand. 383a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// If so Imm will receive the 32 bit value. 384a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic bool isIntImmediate(SDOperand N, unsigned& Imm) { 385a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 386a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Imm = (unsigned)CN->getSignExtended(); 387a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return true; 388a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 389a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return false; 390a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 391a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 39202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// SelectBitfieldInsert - turn an or of two masked values into 39302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// the rotate left word immediate then mask insert (rlwimi) instruction. 3941d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDNode *PPCDAGToDAGISel::SelectBitfieldInsert(SDNode *N) { 39502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op0 = N->getOperand(0); 39602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op1 = N->getOperand(1); 39702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 39877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman uint64_t LKZ, LKO, RKZ, RKO; 3994667f2cbad246beccfca5411a26add24d1007035Nate Begeman TLI.ComputeMaskedBits(Op0, 0xFFFFFFFFULL, LKZ, LKO); 4004667f2cbad246beccfca5411a26add24d1007035Nate Begeman TLI.ComputeMaskedBits(Op1, 0xFFFFFFFFULL, RKZ, RKO); 40102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 4024667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned TargetMask = LKZ; 4034667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned InsertMask = RKZ; 4044667f2cbad246beccfca5411a26add24d1007035Nate Begeman 4054667f2cbad246beccfca5411a26add24d1007035Nate Begeman if ((TargetMask | InsertMask) == 0xFFFFFFFF) { 4064667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Op0Opc = Op0.getOpcode(); 4074667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Op1Opc = Op1.getOpcode(); 4084667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Value, SH = 0; 4094667f2cbad246beccfca5411a26add24d1007035Nate Begeman TargetMask = ~TargetMask; 4104667f2cbad246beccfca5411a26add24d1007035Nate Begeman InsertMask = ~InsertMask; 41177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 4124667f2cbad246beccfca5411a26add24d1007035Nate Begeman // If the LHS has a foldable shift and the RHS does not, then swap it to the 4134667f2cbad246beccfca5411a26add24d1007035Nate Begeman // RHS so that we can fold the shift into the insert. 41477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op0Opc == ISD::AND && Op1Opc == ISD::AND) { 41577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op0.getOperand(0).getOpcode() == ISD::SHL || 41677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op0.getOperand(0).getOpcode() == ISD::SRL) { 41777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op1.getOperand(0).getOpcode() != ISD::SHL && 41877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1.getOperand(0).getOpcode() != ISD::SRL) { 41977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman std::swap(Op0, Op1); 42077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman std::swap(Op0Opc, Op1Opc); 4214667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(TargetMask, InsertMask); 42277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 42377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 4244667f2cbad246beccfca5411a26add24d1007035Nate Begeman } else if (Op0Opc == ISD::SHL || Op0Opc == ISD::SRL) { 4254667f2cbad246beccfca5411a26add24d1007035Nate Begeman if (Op1Opc == ISD::AND && Op1.getOperand(0).getOpcode() != ISD::SHL && 4264667f2cbad246beccfca5411a26add24d1007035Nate Begeman Op1.getOperand(0).getOpcode() != ISD::SRL) { 4274667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(Op0, Op1); 4284667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(Op0Opc, Op1Opc); 4294667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(TargetMask, InsertMask); 4304667f2cbad246beccfca5411a26add24d1007035Nate Begeman } 43102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 43277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 43377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman unsigned MB, ME; 4340949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner if (InsertMask && isRunOfOnes(InsertMask, MB, ME)) { 43577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SDOperand Tmp1, Tmp2, Tmp3; 4364667f2cbad246beccfca5411a26add24d1007035Nate Begeman bool DisjointMask = (TargetMask ^ InsertMask) == 0xFFFFFFFF; 43777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 43877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if ((Op1Opc == ISD::SHL || Op1Opc == ISD::SRL) && 43977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman isIntImmediate(Op1.getOperand(1), Value)) { 44077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0); 44177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SH = (Op1Opc == ISD::SHL) ? Value : 32 - Value; 44202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 44377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op1Opc == ISD::AND) { 44477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman unsigned SHOpc = Op1.getOperand(0).getOpcode(); 44577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if ((SHOpc == ISD::SHL || SHOpc == ISD::SRL) && 44677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman isIntImmediate(Op1.getOperand(0).getOperand(1), Value)) { 44777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0).getOperand(0); 44877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SH = (SHOpc == ISD::SHL) ? Value : 32 - Value; 44977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } else { 45077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0); 45177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 45202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 45377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 45477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Tmp3 = (Op0Opc == ISD::AND && DisjointMask) ? Op0.getOperand(0) : Op0; 45577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Select(Tmp1, Tmp3); 45677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Select(Tmp2, Op1); 4570949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner SH &= 31; 45877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman return CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, Tmp1, Tmp2, 45977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 46002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 46102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 46202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 46302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman} 46402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 4657fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrImm - Returns true if the address N can be represented by 4667fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// a base register plus a signed 16-bit displacement [r+imm]. 4677fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrImm(SDOperand N, SDOperand &Disp, 4687fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Base) { 4690f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If this can be more profitably realized as r+r, fail. 4700f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (SelectAddrIdx(N, Disp, Base)) 4710f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; 4720f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 4737fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (N.getOpcode() == ISD::ADD) { 4747fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman unsigned imm = 0; 4757fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm)) { 47617e82d2858f0c003b7fcfaf7c025ca3d0aaa7a88Chris Lattner Disp = getI32Imm(imm & 0xFFFF); 4777fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0))) { 4787fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Base = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 4799944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 4807564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N.getOperand(0); 4819944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4827fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [r+i] 4837fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman } else if (N.getOperand(1).getOpcode() == PPCISD::Lo) { 4844f0f86de5f183b09d07b17d1f940bd3e298abfcdChris Lattner // Match LOAD (ADD (X, Lo(G))). 4857fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman assert(!cast<ConstantSDNode>(N.getOperand(1).getOperand(1))->getValue() 4864f0f86de5f183b09d07b17d1f940bd3e298abfcdChris Lattner && "Cannot handle constant offsets yet!"); 4877fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Disp = N.getOperand(1).getOperand(0); // The global address. 4887fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman assert(Disp.getOpcode() == ISD::TargetGlobalAddress || 48937efe6764568a3829fee26aba532283131d1a104Nate Begeman Disp.getOpcode() == ISD::TargetConstantPool || 49037efe6764568a3829fee26aba532283131d1a104Nate Begeman Disp.getOpcode() == ISD::TargetJumpTable); 4917564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N.getOperand(0); 4927fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [&g+r] 4939944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4940f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } else if (N.getOpcode() == ISD::OR) { 4950f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner unsigned imm = 0; 4960f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm)) { 4970f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If this is an or of disjoint bitfields, we can codegen this as an add 4980f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // (for better address arithmetic) if the LHS and RHS of the OR are 4990f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // provably disjoint. 5000f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner uint64_t LHSKnownZero, LHSKnownOne; 5010f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(0), ~0U, 5020f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner LHSKnownZero, LHSKnownOne); 5030f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if ((LHSKnownZero|~imm) == ~0U) { 5040f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If all of the bits are known zero on the LHS or RHS, the add won't 5050f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // carry. 5060f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Base = N.getOperand(0); 5070f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Disp = getI32Imm(imm & 0xFFFF); 5080f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return true; 5090f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 5100f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 511d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner } else if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 512d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // Loading from a constant address. 513d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner int Addr = (int)CN->getValue(); 514d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner 515d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // If this address fits entirely in a 16-bit sext immediate field, codegen 516d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // this as "d, 0" 517d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner if (Addr == (short)Addr) { 518d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner Disp = getI32Imm(Addr); 519d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner Base = CurDAG->getRegister(PPC::R0, MVT::i32); 520d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner return true; 521d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner } 522d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner 523d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // Otherwise, break this down into an LIS + disp. 524d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner Disp = getI32Imm((short)Addr); 525d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner Base = CurDAG->getConstant(Addr - (signed short)Addr, MVT::i32); 526d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner return true; 5279944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 528d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner 5297fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Disp = getI32Imm(0); 5307fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N)) 5317fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Base = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 53228a6b02626c29b1fe9bb16c14c193549fab4cab8Nate Begeman else 5337564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N; 5347fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [r+0] 5359944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner} 536a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 5377fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrIdx - Given the specified addressed, check to see if it can be 5387fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// represented as an indexed [r+r] operation. Returns false if it can 5397fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// be represented by [r+imm], which are preferred. 5407fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrIdx(SDOperand N, SDOperand &Base, 5417fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Index) { 5420f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner unsigned imm = 0; 5437fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (N.getOpcode() == ISD::ADD) { 5440f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm)) 5450f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; // r+i 5460f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (N.getOperand(1).getOpcode() == PPCISD::Lo) 5470f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; // r+i 5480f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5497564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N.getOperand(0); 5507564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Index = N.getOperand(1); 5517fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; 5520f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } else if (N.getOpcode() == ISD::OR) { 5530f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm)) 5540f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; // r+i can fold it if we can. 5550f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5560f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If this is an or of disjoint bitfields, we can codegen this as an add 5570f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // (for better address arithmetic) if the LHS and RHS of the OR are provably 5580f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // disjoint. 5590f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner uint64_t LHSKnownZero, LHSKnownOne; 5600f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner uint64_t RHSKnownZero, RHSKnownOne; 5610f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(0), ~0U, 5620f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner LHSKnownZero, LHSKnownOne); 5630f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5640f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (LHSKnownZero) { 5650f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(1), ~0U, 5660f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner RHSKnownZero, RHSKnownOne); 5670f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If all of the bits are known zero on the LHS or RHS, the add won't 5680f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // carry. 5690f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if ((LHSKnownZero | RHSKnownZero) == ~0U) { 5700f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Base = N.getOperand(0); 5710f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Index = N.getOperand(1); 5720f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return true; 5730f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 5740f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 5757fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman } 5760f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5770f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; 5787fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman} 5797fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman 5807fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrIdxOnly - Given the specified addressed, force it to be 5817fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// represented as an indexed [r+r] operation. 5827fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrIdxOnly(SDOperand N, SDOperand &Base, 5837fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Index) { 5840f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // Check to see if we can easily represent this as an [r+r] address. This 5850f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // will fail if it thinks that the address is more profitably represented as 5860f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // reg+imm, e.g. where imm = 0. 58754e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner if (SelectAddrIdx(N, Base, Index)) 58854e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner return true; 58954e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner 59054e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // If the operand is an addition, always emit this as [r+r], since this is 59154e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // better (for code size, and execution, as the memop does the add for free) 59254e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // than emitting an explicit add. 59354e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner if (N.getOpcode() == ISD::ADD) { 59454e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Base = N.getOperand(0); 59554e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Index = N.getOperand(1); 59654e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner return true; 597f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman } 59854e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner 59954e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // Otherwise, do it the hard way, using R0 as the base register. 60054e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Base = CurDAG->getRegister(PPC::R0, MVT::i32); 60154e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Index = N; 6027fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; 603f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman} 604f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman 605e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner/// SelectAddrImmShift - Returns true if the address N can be represented by 606e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner/// a base register plus a signed 14-bit displacement [r+imm*4]. Suitable 607e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner/// for use by STD and friends. 608e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattnerbool PPCDAGToDAGISel::SelectAddrImmShift(SDOperand N, SDOperand &Disp, 609e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner SDOperand &Base) { 610e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If this can be more profitably realized as r+r, fail. 611e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (SelectAddrIdx(N, Disp, Base)) 612e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return false; 613e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 614e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (N.getOpcode() == ISD::ADD) { 615e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner unsigned imm = 0; 616e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm) && 617e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner (imm & 3) == 0) { 618e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm((imm & 0xFFFF) >> 2); 619e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0))) { 620e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 621e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else { 622e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N.getOperand(0); 623e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 624e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; // [r+i] 625e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else if (N.getOperand(1).getOpcode() == PPCISD::Lo) { 626e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // Match LOAD (ADD (X, Lo(G))). 627e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner assert(!cast<ConstantSDNode>(N.getOperand(1).getOperand(1))->getValue() 628e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner && "Cannot handle constant offsets yet!"); 629e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = N.getOperand(1).getOperand(0); // The global address. 630e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner assert(Disp.getOpcode() == ISD::TargetGlobalAddress || 63137efe6764568a3829fee26aba532283131d1a104Nate Begeman Disp.getOpcode() == ISD::TargetConstantPool || 63237efe6764568a3829fee26aba532283131d1a104Nate Begeman Disp.getOpcode() == ISD::TargetJumpTable); 633e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N.getOperand(0); 634e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; // [&g+r] 635e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 636e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else if (N.getOpcode() == ISD::OR) { 637e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner unsigned imm = 0; 638e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm) && 639e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner (imm & 3) == 0) { 640e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If this is an or of disjoint bitfields, we can codegen this as an add 641e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // (for better address arithmetic) if the LHS and RHS of the OR are 642e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // provably disjoint. 643e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner uint64_t LHSKnownZero, LHSKnownOne; 644e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(0), ~0U, 645e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner LHSKnownZero, LHSKnownOne); 646e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if ((LHSKnownZero|~imm) == ~0U) { 647e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If all of the bits are known zero on the LHS or RHS, the add won't 648e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // carry. 649e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N.getOperand(0); 650e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm((imm & 0xFFFF) >> 2); 651e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; 652e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 653e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 654e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 655e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // Loading from a constant address. 656e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner int Addr = (int)CN->getValue(); 657e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if ((Addr & 3) == 0) { 658e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If this address fits entirely in a 16-bit sext immediate field, codegen 659e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // this as "d, 0" 660e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (Addr == (short)Addr) { 661e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm(Addr >> 2); 662e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = CurDAG->getRegister(PPC::R0, MVT::i32); 663e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; 664e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 665e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 666e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // Otherwise, break this down into an LIS + disp. 667e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm((short)Addr >> 2); 668e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = CurDAG->getConstant(Addr - (signed short)Addr, MVT::i32); 669e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; 670e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 671e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 672e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 673e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm(0); 674e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N)) 675e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 676e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner else 677e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N; 678e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; // [r+0] 679e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner} 680e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 681e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 6822fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// SelectCC - Select a comparison of the specified values with the specified 6832fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// condition code, returning the CR# of the expression. 6841d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectCC(SDOperand LHS, SDOperand RHS, 6851d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman ISD::CondCode CC) { 6862fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Always select the LHS. 68734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(LHS, LHS); 6882fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 6892fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Use U to determine whether the SETCC immediate range is signed or not. 6902fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (MVT::isInteger(LHS.getValueType())) { 6912fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner bool U = ISD::isUnsignedIntSetCC(CC); 6922fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner unsigned Imm; 6932fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (isIntImmediate(RHS, Imm) && 6942fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ((U && isUInt16(Imm)) || (!U && isInt16(Imm)))) 6957e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return SDOperand(CurDAG->getTargetNode(U ? PPC::CMPLWI : PPC::CMPWI, 6967e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng MVT::i32, LHS, getI32Imm(Imm & 0xFFFF)), 0); 69734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(RHS, RHS); 6987e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return SDOperand(CurDAG->getTargetNode(U ? PPC::CMPLW : PPC::CMPW, MVT::i32, 6997e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng LHS, RHS), 0); 700919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner } else if (LHS.getValueType() == MVT::f32) { 70134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(RHS, RHS); 7027e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return SDOperand(CurDAG->getTargetNode(PPC::FCMPUS, MVT::i32, LHS, RHS), 0); 7032fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 70434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(RHS, RHS); 7057e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return SDOperand(CurDAG->getTargetNode(PPC::FCMPUD, MVT::i32, LHS, RHS), 0); 7062fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 7072fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 7082fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 7092fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// getBCCForSetCC - Returns the PowerPC condition branch mnemonic corresponding 7102fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// to Condition. 7112fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattnerstatic unsigned getBCCForSetCC(ISD::CondCode CC) { 7122fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner switch (CC) { 7132fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 714ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOEQ: // FIXME: This is incorrect see PR642. 7152fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETEQ: return PPC::BEQ; 716ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETONE: // FIXME: This is incorrect see PR642. 7172fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETNE: return PPC::BNE; 718ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLT: // FIXME: This is incorrect see PR642. 7192fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULT: 7202fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLT: return PPC::BLT; 721ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLE: // FIXME: This is incorrect see PR642. 7222fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULE: 7232fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLE: return PPC::BLE; 724ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGT: // FIXME: This is incorrect see PR642. 7252fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGT: 7262fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGT: return PPC::BGT; 727ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGE: // FIXME: This is incorrect see PR642. 7282fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGE: 7292fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGE: return PPC::BGE; 7306df2507121507c24d7155605c343e467e0106c07Chris Lattner 7316df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETO: return PPC::BUN; 7326df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETUO: return PPC::BNU; 7332fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 7342fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return 0; 7352fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 7362fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 73764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// getCRIdxForSetCC - Return the index of the condition register field 73864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// associated with the SetCC condition, and whether or not the field is 73964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// treated as inverted. That is, lt = 0; ge = 0 inverted. 74064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattnerstatic unsigned getCRIdxForSetCC(ISD::CondCode CC, bool& Inv) { 74164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 74264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 743ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLT: // FIXME: This is incorrect see PR642. 74464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULT: 74564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLT: Inv = false; return 0; 746ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGE: // FIXME: This is incorrect see PR642. 74764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGE: 74864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGE: Inv = true; return 0; 749ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGT: // FIXME: This is incorrect see PR642. 75064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGT: 75164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGT: Inv = false; return 1; 752ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLE: // FIXME: This is incorrect see PR642. 75364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULE: 75464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLE: Inv = true; return 1; 755ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOEQ: // FIXME: This is incorrect see PR642. 75664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETEQ: Inv = false; return 2; 757ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETONE: // FIXME: This is incorrect see PR642. 75864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETNE: Inv = true; return 2; 7596df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETO: Inv = true; return 3; 7606df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETUO: Inv = false; return 3; 76164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 76264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner return 0; 76364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner} 7649944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 7651d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectSETCC(SDOperand Op) { 766222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDNode *N = Op.Val; 767222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Imm; 768222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get(); 769222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (isIntImmediate(N->getOperand(1), Imm)) { 770222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // We can codegen setcc op, imm very efficiently compared to a brcond. 771222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Check for those cases here. 772222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // setcc op, 0 773222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (Imm == 0) { 77434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Op; 77534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Op, N->getOperand(0)); 776222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 777dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 778dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETEQ: 7797e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::CNTLZW, MVT::i32, Op), 0); 78071d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Op, getI32Imm(27), 78171d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(5), getI32Imm(31)); 782dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 7837e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AD = 7847e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 7857e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(~0U)), 0); 78671d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, 78771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner AD.getValue(1)); 788dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 789dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETLT: 79071d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Op, getI32Imm(1), 79171d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 792dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETGT: { 7937e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand T = 7947e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::NEG, MVT::i32, Op), 0); 7957e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng T = SDOperand(CurDAG->getTargetNode(PPC::ANDC, MVT::i32, T, Op), 0); 79671d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, T, getI32Imm(1), 79771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 798dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 799222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 800222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else if (Imm == ~0U) { // setcc op, -1 80134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Op; 80234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Op, N->getOperand(0)); 803222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 804dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 805dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETEQ: 8067e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 8077e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(1)), 0); 80871d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 8097e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::LI, MVT::i32, 8107e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(0)), 0), 81171d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner Op.getValue(1)); 812dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 8137e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::NOR, MVT::i32, Op, Op), 0); 8147e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *AD = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 8157e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(~0U)); 8167e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, SDOperand(AD, 0), Op, 8177e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(AD, 1)); 818dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 819dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETLT: { 8207e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AD = SDOperand(CurDAG->getTargetNode(PPC::ADDI, MVT::i32, Op, 8217e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(1)), 0); 8227e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AN = SDOperand(CurDAG->getTargetNode(PPC::AND, MVT::i32, AD, 8237e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op), 0); 82471d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, AN, getI32Imm(1), 82571d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 826dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 827dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETGT: 8287e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Op, 8297e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(1), getI32Imm(31), 8307e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(31)), 0); 83171d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Op, getI32Imm(1)); 832222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 833222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 834222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 835222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 836222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner bool Inv; 837222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Idx = getCRIdxForSetCC(CC, Inv); 838222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 839222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand IntCR; 840222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 841222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Force the ccreg into CR7. 842222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand CR7Reg = CurDAG->getRegister(PPC::CR7, MVT::i32); 843222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 84485961d5ec126bbc0c111d52dd7361d5159265ca5Chris Lattner SDOperand InFlag(0, 0); // Null incoming flag value. 845db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner CCReg = CurDAG->getCopyToReg(CurDAG->getEntryNode(), CR7Reg, CCReg, 846db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner InFlag).getValue(1); 847222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 848222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (TLI.getTargetMachine().getSubtarget<PPCSubtarget>().isGigaProcessor()) 8497e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng IntCR = SDOperand(CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, CR7Reg, 8507e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng CCReg), 0); 851222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner else 8527e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng IntCR = SDOperand(CurDAG->getTargetNode(PPC::MFCR, MVT::i32, CCReg), 0); 853222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 854222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (!Inv) { 85571d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, IntCR, 85671d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm((32-(3-Idx)) & 31), 85771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 858222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else { 859222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand Tmp = 8607e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, IntCR, 8617e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm((32-(3-Idx)) & 31), 8627e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(31),getI32Imm(31)), 0); 86371d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Tmp, getI32Imm(1)); 864222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 865222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner} 8662b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 867422b0cee7a32636303398d8788f98a59bf15381cNate Begeman/// isCallCompatibleAddress - Return true if the specified 32-bit value is 868422b0cee7a32636303398d8788f98a59bf15381cNate Begeman/// representable in the immediate field of a Bx instruction. 869422b0cee7a32636303398d8788f98a59bf15381cNate Begemanstatic bool isCallCompatibleAddress(ConstantSDNode *C) { 870422b0cee7a32636303398d8788f98a59bf15381cNate Begeman int Addr = C->getValue(); 871422b0cee7a32636303398d8788f98a59bf15381cNate Begeman if (Addr & 3) return false; // Low 2 bits are implicitly zero. 872422b0cee7a32636303398d8788f98a59bf15381cNate Begeman return (Addr << 6 >> 6) == Addr; // Top 6 bits have to be sext of immediate. 873422b0cee7a32636303398d8788f98a59bf15381cNate Begeman} 874422b0cee7a32636303398d8788f98a59bf15381cNate Begeman 8751d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectCALL(SDOperand Op) { 8766a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDNode *N = Op.Val; 87734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Chain; 87834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Chain, N->getOperand(0)); 8796a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 8806a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner unsigned CallOpcode; 8816a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner std::vector<SDOperand> CallOperands; 8826a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 8836a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (GlobalAddressSDNode *GASD = 8846a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner dyn_cast<GlobalAddressSDNode>(N->getOperand(1))) { 885422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOpcode = PPC::BL; 8862823b3e70ee7a5ed7482c45c503659a16a879a61Chris Lattner CallOperands.push_back(N->getOperand(1)); 8876a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else if (ExternalSymbolSDNode *ESSDN = 8886a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner dyn_cast<ExternalSymbolSDNode>(N->getOperand(1))) { 889422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOpcode = PPC::BL; 8906a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(N->getOperand(1)); 891422b0cee7a32636303398d8788f98a59bf15381cNate Begeman } else if (isa<ConstantSDNode>(N->getOperand(1)) && 892422b0cee7a32636303398d8788f98a59bf15381cNate Begeman isCallCompatibleAddress(cast<ConstantSDNode>(N->getOperand(1)))) { 893422b0cee7a32636303398d8788f98a59bf15381cNate Begeman ConstantSDNode *C = cast<ConstantSDNode>(N->getOperand(1)); 894422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOpcode = PPC::BLA; 895422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOperands.push_back(getI32Imm((int)C->getValue() >> 2)); 8966a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else { 8976a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // Copy the callee address into the CTR register. 89834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Callee; 89934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Callee, N->getOperand(1)); 9007e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Chain = SDOperand(CurDAG->getTargetNode(PPC::MTCTR, MVT::Other, Callee, 9017e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Chain), 0); 9026a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9036a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // Copy the callee address into R12 on darwin. 9046a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand R12 = CurDAG->getRegister(PPC::R12, MVT::i32); 9056a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getNode(ISD::CopyToReg, MVT::Other, Chain, R12, Callee); 906422b0cee7a32636303398d8788f98a59bf15381cNate Begeman 9076a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(R12); 908422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOpcode = PPC::BCTRL; 9096a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 9106a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9116a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner unsigned GPR_idx = 0, FPR_idx = 0; 9126a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner static const unsigned GPR[] = { 9136a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::R3, PPC::R4, PPC::R5, PPC::R6, 9146a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::R7, PPC::R8, PPC::R9, PPC::R10, 9156a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner }; 9166a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner static const unsigned FPR[] = { 9176a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, 9186a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::F8, PPC::F9, PPC::F10, PPC::F11, PPC::F12, PPC::F13 9196a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner }; 9206a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9216a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand InFlag; // Null incoming flag value. 9226a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9236a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner for (unsigned i = 2, e = N->getNumOperands(); i != e; ++i) { 9246a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner unsigned DestReg = 0; 9256a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner MVT::ValueType RegTy = N->getOperand(i).getValueType(); 9266a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (RegTy == MVT::i32) { 9276a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner assert(GPR_idx < 8 && "Too many int args"); 9286a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner DestReg = GPR[GPR_idx++]; 9296a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else { 9306a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner assert(MVT::isFloatingPoint(N->getOperand(i).getValueType()) && 9316a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner "Unpromoted integer arg?"); 9326a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner assert(FPR_idx < 13 && "Too many fp args"); 9336a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner DestReg = FPR[FPR_idx++]; 9346a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 9356a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9366a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (N->getOperand(i).getOpcode() != ISD::UNDEF) { 93734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Val; 93834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Val, N->getOperand(i)); 9396a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyToReg(Chain, DestReg, Val, InFlag); 9406a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner InFlag = Chain.getValue(1); 9416a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(CurDAG->getRegister(DestReg, RegTy)); 9426a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 9436a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 9446a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9456a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // Finally, once everything is in registers to pass to the call, emit the 9466a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // call itself. 9476a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (InFlag.Val) 9486a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(InFlag); // Strong dep on register copies. 9496a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner else 9506a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(Chain); // Weak dep on whatever occurs before 9517e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Chain = SDOperand(CurDAG->getTargetNode(CallOpcode, MVT::Other, MVT::Flag, 9527e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng CallOperands), 0); 9536a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9546a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner std::vector<SDOperand> CallResults; 9556a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9566a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // If the call has results, copy the values out of the ret val registers. 9576a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner switch (N->getValueType(0)) { 9586a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner default: assert(0 && "Unexpected ret value!"); 9596a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::Other: break; 9606a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::i32: 9616a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (N->getValueType(1) == MVT::i32) { 9626a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R4, MVT::i32, 9636a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(1)).getValue(1); 9646a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 9656a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R3, MVT::i32, 9666a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(2)).getValue(1); 9676a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 9686a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else { 9696a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R3, MVT::i32, 9706a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(1)).getValue(1); 9716a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 9726a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 9736a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner break; 9746a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::f32: 9756a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::f64: 9766a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::F1, N->getValueType(0), 9776a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(1)).getValue(1); 9786a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 9796a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner break; 9806a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 9816a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9826a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain); 9836a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner for (unsigned i = 0, e = CallResults.size(); i != e; ++i) 9846a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CodeGenMap[Op.getValue(i)] = CallResults[i]; 9856a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner return CallResults[Op.ResNo]; 9866a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner} 9876a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 988a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Select - Convert the specified operand from a target-independent to a 989a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// target-specific node if it hasn't already been changed. 99034167215a8da717b21e44f1b834dc34d15279bf1Evan Chengvoid PPCDAGToDAGISel::Select(SDOperand &Result, SDOperand Op) { 991a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDNode *N = Op.Val; 9920bbea954331b8f08afa5b094dfb0841829c70eaaChris Lattner if (N->getOpcode() >= ISD::BUILTIN_OP_END && 99334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N->getOpcode() < PPCISD::FIRST_NUMBER) { 99434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = Op; 99534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; // Already selected. 99634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng } 997d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 998d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner // If this has already been converted, use it. 999d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner std::map<SDOperand, SDOperand>::iterator CGMI = CodeGenMap.find(Op); 100034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng if (CGMI != CodeGenMap.end()) { 100134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CGMI->second; 100234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 100334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng } 1004a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1005a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOpcode()) { 100619c0907ba1c11c81dc231cf7b4143fdaf03466e4Chris Lattner default: break; 100734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case ISD::SETCC: 100834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = SelectSETCC(Op); 100934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 101034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case PPCISD::CALL: 101134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = SelectCALL(Op); 101234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 101334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case PPCISD::GlobalBaseReg: 101434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = getGlobalBaseReg(); 101534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 1016860e8862c1fbd3b261da4a64a8c0096f9f373681Chris Lattner 1017e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner case ISD::FrameIndex: { 1018e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner int FI = cast<FrameIndexSDNode>(N)->getIndex(); 101934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng if (N->hasOneUse()) { 102034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::ADDI, MVT::i32, 102134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng CurDAG->getTargetFrameIndex(FI, MVT::i32), 102234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(0)); 102334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 102434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng } 102534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CodeGenMap[Op] = 10267e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::ADDI, MVT::i32, 10277e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng CurDAG->getTargetFrameIndex(FI, MVT::i32), 10287e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(0)), 0); 102934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 1030e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } 10316d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner 10326d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner case PPCISD::MFCR: { 10336d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner SDOperand InFlag; 10346d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner Select(InFlag, N->getOperand(1)); 10356d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner // Use MFOCRF if supported. 10366d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner if (TLI.getTargetMachine().getSubtarget<PPCSubtarget>().isGigaProcessor()) 10376d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner Result = SDOperand(CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, 10386d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner N->getOperand(0), InFlag), 0); 10396d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner else 10406d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner Result = SDOperand(CurDAG->getTargetNode(PPC::MFCR, MVT::i32, InFlag), 0); 10416d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner CodeGenMap[Op] = Result; 10426d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner return; 10436d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner } 10446d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner 104588add100b3db715df4275c8ab408e6b51f28ff8fChris Lattner case ISD::SDIV: { 1046405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: since this depends on the setting of the carry flag from the srawi 1047405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // we should really be making notes about that for the scheduler. 1048405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: It sure would be nice if we could cheaply recognize the 1049405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // srl/add/sra pattern the dag combiner will generate for this as 1050405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // sra/addze rather than having to handle sdiv ourselves. oh well. 10518784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner unsigned Imm; 10528784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if (isIntImmediate(N->getOperand(1), Imm)) { 105334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand N0; 105434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(N0, N->getOperand(0)); 10558784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if ((signed)Imm > 0 && isPowerOf2_32(Imm)) { 10567e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 10578784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 105834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N0, getI32Imm(Log2_32(Imm))); 105934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 10607e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Op, 0), SDOperand(Op, 1)); 10618784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } else if ((signed)Imm < 0 && isPowerOf2_32(-Imm)) { 10627e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 10632501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 106434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N0, getI32Imm(Log2_32(-Imm))); 10658784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand PT = 10667e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, 10677e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Op, 0), SDOperand(Op, 1)), 10687e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng 0); 106934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::NEG, MVT::i32, PT); 10708784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 107134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 10728784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 1073047b952e298352fe6feffedf02e359601133f465Chris Lattner 1074237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1075237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1076047b952e298352fe6feffedf02e359601133f465Chris Lattner } 1077cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman case ISD::AND: { 107850fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman unsigned Imm, Imm2; 1079cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and of a value rotated between 0 and 31 bits and then and'd 1080cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // with a mask, emit rlwinm 1081cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isIntImmediate(N->getOperand(1), Imm) && (isShiftedMask_32(Imm) || 1082cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isShiftedMask_32(~Imm))) { 1083cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SDOperand Val; 1084a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned SH, MB, ME; 1085cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isRotateAndMask(N->getOperand(0).Val, Imm, false, SH, MB, ME)) { 108634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Val, N->getOperand(0).getOperand(0)); 10873393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner } else if (Imm == 0) { 10883393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner // AND X, 0 -> 0, not "rlwinm 32". 108934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Result, N->getOperand(1)); 109034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return ; 10913393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner } else { 109234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Val, N->getOperand(0)); 1093cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isRunOfOnes(Imm, MB, ME); 1094cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = 0; 1095cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 109634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Val, 109734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(SH), getI32Imm(MB), 109834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(ME)); 109934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 1100cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 110150fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // ISD::OR doesn't get all the bitfield insertion fun. 110250fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // (and (or x, c1), c2) where isRunOfOnes(~(c1^c2)) is a bitfield insert 110350fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman if (isIntImmediate(N->getOperand(1), Imm) && 110450fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman N->getOperand(0).getOpcode() == ISD::OR && 110550fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman isIntImmediate(N->getOperand(0).getOperand(1), Imm2)) { 1106c9a5ef524a9f461717bbf647b2d3da061aed720dChris Lattner unsigned MB, ME; 110750fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman Imm = ~(Imm^Imm2); 110850fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman if (isRunOfOnes(Imm, MB, ME)) { 110934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Tmp1, Tmp2; 111034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Tmp1, N->getOperand(0).getOperand(0)); 111134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Tmp2, N->getOperand(0).getOperand(1)); 11127e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Result = SDOperand(CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, 11137e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Tmp1, Tmp2, 11147e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(0), getI32Imm(MB), 11157e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(ME)), 0); 111634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 111750fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 111850fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 1119237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner 1120237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1121237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1122cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 112302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::OR: 112434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng if (SDNode *I = SelectBitfieldInsert(N)) { 112534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CodeGenMap[Op] = SDOperand(I, 0); 112634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 112734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng } 1128d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 1129237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1130237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1131c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SHL: { 1132c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1133c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 11342d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 113534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Val; 113634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Val, N->getOperand(0).getOperand(0)); 113734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 113834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Val, getI32Imm(SH), getI32Imm(MB), 113934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(ME)); 114034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 11418d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 11422d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 11432d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 11442d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1145c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 1146c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRL: { 1147c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1148c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 11492d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 115034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Val; 115134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Val, N->getOperand(0).getOperand(0)); 115234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 11530949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner Val, getI32Imm(SH), getI32Imm(MB), 115434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(ME)); 115534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 11568d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 11572d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 11582d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 11592d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1160c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 116113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner case ISD::SELECT_CC: { 116213794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(4))->get(); 116313794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner 116413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner // handle the setcc cases here. select_cc lhs, 0, 1, 0, cc 116513794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N->getOperand(1))) 116613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N->getOperand(2))) 116713794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N->getOperand(3))) 116813794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (N1C->isNullValue() && N3C->isNullValue() && 116913794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner N2C->getValue() == 1ULL && CC == ISD::SETNE) { 117034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand LHS; 117134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(LHS, N->getOperand(0)); 11727e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Tmp = 117313794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 117413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner LHS, getI32Imm(~0U)); 11757e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Result = CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, 11767e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Tmp, 0), LHS, 11777e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Tmp, 1)); 117834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 117913794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 11808a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 118150ff55c2c7909818165e51bbdc103a05b143dcb1Chris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 11828a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner unsigned BROpc = getBCCForSetCC(CC); 11838a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 11848a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner bool isFP = MVT::isFloatingPoint(N->getValueType(0)); 1185919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner unsigned SelectCCOp; 1186919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (MVT::isInteger(N->getValueType(0))) 1187919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_Int; 1188919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else if (N->getValueType(0) == MVT::f32) 1189919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F4; 1190710ff32983ca919fa0da14e077450b6a7654274fChris Lattner else if (N->getValueType(0) == MVT::f64) 1191919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F8; 1192710ff32983ca919fa0da14e077450b6a7654274fChris Lattner else 1193710ff32983ca919fa0da14e077450b6a7654274fChris Lattner SelectCCOp = PPC::SELECT_CC_VRRC; 1194710ff32983ca919fa0da14e077450b6a7654274fChris Lattner 119534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand N2, N3; 119634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(N2, N->getOperand(2)); 119734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(N3, N->getOperand(3)); 119834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, SelectCCOp, N->getValueType(0), CCReg, 119934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N2, N3, getI32Imm(BROpc)); 120034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 120113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 120281e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman case ISD::BR_CC: { 120334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Chain; 120434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Chain, N->getOperand(0)); 12052fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(1))->get(); 12062fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CondCode = SelectCC(N->getOperand(2), N->getOperand(3), CC); 120781e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman Result = CurDAG->SelectNodeTo(N, PPC::COND_BRANCH, MVT::Other, 120881e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman CondCode, getI32Imm(getBCCForSetCC(CC)), 120981e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman N->getOperand(4), Chain); 121034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 12112fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 121237efe6764568a3829fee26aba532283131d1a104Nate Begeman case ISD::BRIND: { 121337efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand Chain, Target; 121437efe6764568a3829fee26aba532283131d1a104Nate Begeman Select(Chain, N->getOperand(0)); 121537efe6764568a3829fee26aba532283131d1a104Nate Begeman Select(Target,N->getOperand(1)); 121637efe6764568a3829fee26aba532283131d1a104Nate Begeman Chain = SDOperand(CurDAG->getTargetNode(PPC::MTCTR, MVT::Other, Target, 121737efe6764568a3829fee26aba532283131d1a104Nate Begeman Chain), 0); 121837efe6764568a3829fee26aba532283131d1a104Nate Begeman Result = CurDAG->SelectNodeTo(N, PPC::BCTR, MVT::Other, Chain); 121937efe6764568a3829fee26aba532283131d1a104Nate Begeman return; 122037efe6764568a3829fee26aba532283131d1a104Nate Begeman } 1221a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 122225dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner 122334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SelectCode(Result, Op); 1224a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1225a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1226a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 12271d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman/// createPPCISelDag - This pass converts a legalized DAG into a 1228a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// PowerPC-specific DAG, ready for instruction scheduling. 1229a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// 1230c4c6257c1a154279bf10e9498d46d6c1793dbaa7Evan ChengFunctionPass *llvm::createPPCISelDag(PPCTargetMachine &TM) { 12311d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman return new PPCDAGToDAGISel(TM); 1232a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1233a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1234