PPCISelDAGToDAG.cpp revision 420736dc85c01702bb7bc40495f8a4be5e5f8a6c
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)) { 368cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = Shift; 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. 39402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// Returns true on success, false if the caller still needs to select OR. 39502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 39602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// Patterns matched: 39702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 1. or shl, and 5. or and, and 39802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 2. or and, shl 6. or shl, shr 39902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 3. or shr, and 7. or shr, shl 40002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// 4. or and, shr 4011d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDNode *PPCDAGToDAGISel::SelectBitfieldInsert(SDNode *N) { 40202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool IsRotate = false; 40302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned TgtMask = 0xFFFFFFFF, InsMask = 0xFFFFFFFF, SH = 0; 40402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Value; 40502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 40602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op0 = N->getOperand(0); 40702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op1 = N->getOperand(1); 40802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 40902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Op0Opc = Op0.getOpcode(); 41002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned Op1Opc = Op1.getOpcode(); 41102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 41202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Verify that we have the correct opcodes 41302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (ISD::SHL != Op0Opc && ISD::SRL != Op0Opc && ISD::AND != Op0Opc) 41402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return false; 41502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (ISD::SHL != Op1Opc && ISD::SRL != Op1Opc && ISD::AND != Op1Opc) 41602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return false; 41702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 41802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Generate Mask value for Target 41902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op0.getOperand(1), Value)) { 42002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman switch(Op0Opc) { 4211368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SHL: TgtMask <<= Value; break; 4221368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SRL: TgtMask >>= Value; break; 4231368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::AND: TgtMask &= Value; break; 42402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 42502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } else { 42602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 42702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 42802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 42902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Generate Mask value for Insert 4301368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner if (!isIntImmediate(Op1.getOperand(1), Value)) 43102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 4321368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner 4331368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner switch(Op1Opc) { 4341368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SHL: 4351368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner SH = Value; 4361368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner InsMask <<= SH; 4371368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner if (Op0Opc == ISD::SRL) IsRotate = true; 4381368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner break; 4391368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::SRL: 4401368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner SH = Value; 4411368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner InsMask >>= SH; 4421368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner SH = 32-SH; 4431368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner if (Op0Opc == ISD::SHL) IsRotate = true; 4441368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner break; 4451368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner case ISD::AND: 4461368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner InsMask &= Value; 4471368721d532d0d291a03bb3fff7f94805e5919b6Chris Lattner break; 44802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 44902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 45002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // If both of the inputs are ANDs and one of them has a logical shift by 45102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // constant as its input, make that AND the inserted value so that we can 45202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // combine the shift into the rotate part of the rlwimi instruction 45302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool IsAndWithShiftOp = false; 45402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op0Opc == ISD::AND && Op1Opc == ISD::AND) { 45502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (Op1.getOperand(0).getOpcode() == ISD::SHL || 45602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op1.getOperand(0).getOpcode() == ISD::SRL) { 45702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op1.getOperand(0).getOperand(1), Value)) { 45802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Op1.getOperand(0).getOpcode() == ISD::SHL ? Value : 32 - Value; 45902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman IsAndWithShiftOp = true; 46002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 46102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } else if (Op0.getOperand(0).getOpcode() == ISD::SHL || 46202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman Op0.getOperand(0).getOpcode() == ISD::SRL) { 46302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (isIntImmediate(Op0.getOperand(0).getOperand(1), Value)) { 46402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman std::swap(Op0, Op1); 46502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman std::swap(TgtMask, InsMask); 46602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SH = Op1.getOperand(0).getOpcode() == ISD::SHL ? Value : 32 - Value; 46702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman IsAndWithShiftOp = true; 46802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 46902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 47002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 47102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 47202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Verify that the Target mask and Insert mask together form a full word mask 47302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // and that the Insert mask is a run of set bits (which implies both are runs 47402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // of set bits). Given that, Select the arguments and generate the rlwimi 47502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // instruction. 47602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman unsigned MB, ME; 47702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (((TgtMask & InsMask) == 0) && isRunOfOnes(InsMask, MB, ME)) { 47802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool fullMask = (TgtMask ^ InsMask) == 0xFFFFFFFF; 47902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman bool Op0IsAND = Op0Opc == ISD::AND; 48002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // Check for rotlwi / rotrwi here, a special case of bitfield insert 48102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman // where both bitfield halves are sourced from the same value. 48202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman if (IsRotate && fullMask && 48302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman N->getOperand(0).getOperand(0) == N->getOperand(1).getOperand(0)) { 48434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Tmp; 48534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Tmp, N->getOperand(0).getOperand(0)); 4867e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Tmp, 4877e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(SH), getI32Imm(0), getI32Imm(31)); 48802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 48934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Tmp1, Tmp2; 49034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Tmp1, ((Op0IsAND && fullMask) ? Op0.getOperand(0) : Op0)); 49134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Tmp2, (IsAndWithShiftOp ? Op1.getOperand(0).getOperand(0) 49234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng : Op1.getOperand(0))); 4937e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, Tmp1, Tmp2, 4947e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 49502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 49602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 49702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman} 49802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 4997fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrImm - Returns true if the address N can be represented by 5007fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// a base register plus a signed 16-bit displacement [r+imm]. 5017fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrImm(SDOperand N, SDOperand &Disp, 5027fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Base) { 5030f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If this can be more profitably realized as r+r, fail. 5040f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (SelectAddrIdx(N, Disp, Base)) 5050f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; 5060f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5077fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (N.getOpcode() == ISD::ADD) { 5087fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman unsigned imm = 0; 5097fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm)) { 51017e82d2858f0c003b7fcfaf7c025ca3d0aaa7a88Chris Lattner Disp = getI32Imm(imm & 0xFFFF); 5117fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0))) { 5127fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Base = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 5139944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 5147564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N.getOperand(0); 5159944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 5167fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [r+i] 5177fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman } else if (N.getOperand(1).getOpcode() == PPCISD::Lo) { 5184f0f86de5f183b09d07b17d1f940bd3e298abfcdChris Lattner // Match LOAD (ADD (X, Lo(G))). 5197fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman assert(!cast<ConstantSDNode>(N.getOperand(1).getOperand(1))->getValue() 5204f0f86de5f183b09d07b17d1f940bd3e298abfcdChris Lattner && "Cannot handle constant offsets yet!"); 5217fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Disp = N.getOperand(1).getOperand(0); // The global address. 5227fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman assert(Disp.getOpcode() == ISD::TargetGlobalAddress || 5237fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Disp.getOpcode() == ISD::TargetConstantPool); 5247564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N.getOperand(0); 5257fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [&g+r] 5269944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 5270f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } else if (N.getOpcode() == ISD::OR) { 5280f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner unsigned imm = 0; 5290f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm)) { 5300f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If this is an or of disjoint bitfields, we can codegen this as an add 5310f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // (for better address arithmetic) if the LHS and RHS of the OR are 5320f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // provably disjoint. 5330f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner uint64_t LHSKnownZero, LHSKnownOne; 5340f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(0), ~0U, 5350f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner LHSKnownZero, LHSKnownOne); 5360f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if ((LHSKnownZero|~imm) == ~0U) { 5370f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If all of the bits are known zero on the LHS or RHS, the add won't 5380f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // carry. 5390f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Base = N.getOperand(0); 5400f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Disp = getI32Imm(imm & 0xFFFF); 5410f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return true; 5420f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 5430f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 544d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner } else if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 545d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // Loading from a constant address. 546d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner int Addr = (int)CN->getValue(); 547d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner 548d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // If this address fits entirely in a 16-bit sext immediate field, codegen 549d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // this as "d, 0" 550d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner if (Addr == (short)Addr) { 551d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner Disp = getI32Imm(Addr); 552d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner Base = CurDAG->getRegister(PPC::R0, MVT::i32); 553d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner return true; 554d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner } 555d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner 556d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // Otherwise, break this down into an LIS + disp. 557d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner Disp = getI32Imm((short)Addr); 558d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner Base = CurDAG->getConstant(Addr - (signed short)Addr, MVT::i32); 559d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner return true; 5609944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 561d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner 5627fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Disp = getI32Imm(0); 5637fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N)) 5647fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Base = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 56528a6b02626c29b1fe9bb16c14c193549fab4cab8Nate Begeman else 5667564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N; 5677fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [r+0] 5689944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner} 569a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 5707fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrIdx - Given the specified addressed, check to see if it can be 5717fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// represented as an indexed [r+r] operation. Returns false if it can 5727fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// be represented by [r+imm], which are preferred. 5737fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrIdx(SDOperand N, SDOperand &Base, 5747fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Index) { 5750f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner unsigned imm = 0; 5767fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (N.getOpcode() == ISD::ADD) { 5770f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm)) 5780f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; // r+i 5790f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (N.getOperand(1).getOpcode() == PPCISD::Lo) 5800f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; // r+i 5810f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5827564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N.getOperand(0); 5837564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Index = N.getOperand(1); 5847fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; 5850f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } else if (N.getOpcode() == ISD::OR) { 5860f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm)) 5870f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; // r+i can fold it if we can. 5880f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5890f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If this is an or of disjoint bitfields, we can codegen this as an add 5900f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // (for better address arithmetic) if the LHS and RHS of the OR are provably 5910f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // disjoint. 5920f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner uint64_t LHSKnownZero, LHSKnownOne; 5930f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner uint64_t RHSKnownZero, RHSKnownOne; 5940f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(0), ~0U, 5950f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner LHSKnownZero, LHSKnownOne); 5960f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5970f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (LHSKnownZero) { 5980f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(1), ~0U, 5990f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner RHSKnownZero, RHSKnownOne); 6000f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If all of the bits are known zero on the LHS or RHS, the add won't 6010f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // carry. 6020f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if ((LHSKnownZero | RHSKnownZero) == ~0U) { 6030f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Base = N.getOperand(0); 6040f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Index = N.getOperand(1); 6050f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return true; 6060f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 6070f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 6087fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman } 6090f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 6100f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; 6117fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman} 6127fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman 6137fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrIdxOnly - Given the specified addressed, force it to be 6147fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// represented as an indexed [r+r] operation. 6157fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrIdxOnly(SDOperand N, SDOperand &Base, 6167fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Index) { 6170f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // Check to see if we can easily represent this as an [r+r] address. This 6180f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // will fail if it thinks that the address is more profitably represented as 6190f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // reg+imm, e.g. where imm = 0. 62054e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner if (SelectAddrIdx(N, Base, Index)) 62154e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner return true; 62254e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner 62354e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // If the operand is an addition, always emit this as [r+r], since this is 62454e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // better (for code size, and execution, as the memop does the add for free) 62554e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // than emitting an explicit add. 62654e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner if (N.getOpcode() == ISD::ADD) { 62754e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Base = N.getOperand(0); 62854e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Index = N.getOperand(1); 62954e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner return true; 630f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman } 63154e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner 63254e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // Otherwise, do it the hard way, using R0 as the base register. 63354e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Base = CurDAG->getRegister(PPC::R0, MVT::i32); 63454e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Index = N; 6357fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; 636f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman} 637f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman 638e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner/// SelectAddrImmShift - Returns true if the address N can be represented by 639e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner/// a base register plus a signed 14-bit displacement [r+imm*4]. Suitable 640e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner/// for use by STD and friends. 641e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattnerbool PPCDAGToDAGISel::SelectAddrImmShift(SDOperand N, SDOperand &Disp, 642e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner SDOperand &Base) { 643e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If this can be more profitably realized as r+r, fail. 644e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (SelectAddrIdx(N, Disp, Base)) 645e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return false; 646e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 647e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (N.getOpcode() == ISD::ADD) { 648e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner unsigned imm = 0; 649e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm) && 650e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner (imm & 3) == 0) { 651e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm((imm & 0xFFFF) >> 2); 652e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0))) { 653e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 654e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else { 655e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N.getOperand(0); 656e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 657e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; // [r+i] 658e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else if (N.getOperand(1).getOpcode() == PPCISD::Lo) { 659e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // Match LOAD (ADD (X, Lo(G))). 660e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner assert(!cast<ConstantSDNode>(N.getOperand(1).getOperand(1))->getValue() 661e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner && "Cannot handle constant offsets yet!"); 662e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = N.getOperand(1).getOperand(0); // The global address. 663e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner assert(Disp.getOpcode() == ISD::TargetGlobalAddress || 664e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp.getOpcode() == ISD::TargetConstantPool); 665e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N.getOperand(0); 666e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; // [&g+r] 667e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 668e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else if (N.getOpcode() == ISD::OR) { 669e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner unsigned imm = 0; 670e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm) && 671e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner (imm & 3) == 0) { 672e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If this is an or of disjoint bitfields, we can codegen this as an add 673e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // (for better address arithmetic) if the LHS and RHS of the OR are 674e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // provably disjoint. 675e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner uint64_t LHSKnownZero, LHSKnownOne; 676e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(0), ~0U, 677e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner LHSKnownZero, LHSKnownOne); 678e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if ((LHSKnownZero|~imm) == ~0U) { 679e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If all of the bits are known zero on the LHS or RHS, the add won't 680e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // carry. 681e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N.getOperand(0); 682e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm((imm & 0xFFFF) >> 2); 683e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; 684e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 685e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 686e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 687e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // Loading from a constant address. 688e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner int Addr = (int)CN->getValue(); 689e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if ((Addr & 3) == 0) { 690e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If this address fits entirely in a 16-bit sext immediate field, codegen 691e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // this as "d, 0" 692e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (Addr == (short)Addr) { 693e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm(Addr >> 2); 694e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = CurDAG->getRegister(PPC::R0, MVT::i32); 695e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; 696e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 697e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 698e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // Otherwise, break this down into an LIS + disp. 699e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm((short)Addr >> 2); 700e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = CurDAG->getConstant(Addr - (signed short)Addr, MVT::i32); 701e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; 702e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 703e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 704e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 705e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm(0); 706e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N)) 707e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 708e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner else 709e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N; 710e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; // [r+0] 711e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner} 712e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 713e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 7142fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// SelectCC - Select a comparison of the specified values with the specified 7152fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// condition code, returning the CR# of the expression. 7161d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectCC(SDOperand LHS, SDOperand RHS, 7171d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman ISD::CondCode CC) { 7182fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Always select the LHS. 71934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(LHS, LHS); 7202fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 7212fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Use U to determine whether the SETCC immediate range is signed or not. 7222fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (MVT::isInteger(LHS.getValueType())) { 7232fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner bool U = ISD::isUnsignedIntSetCC(CC); 7242fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner unsigned Imm; 7252fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (isIntImmediate(RHS, Imm) && 7262fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ((U && isUInt16(Imm)) || (!U && isInt16(Imm)))) 7277e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return SDOperand(CurDAG->getTargetNode(U ? PPC::CMPLWI : PPC::CMPWI, 7287e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng MVT::i32, LHS, getI32Imm(Imm & 0xFFFF)), 0); 72934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(RHS, RHS); 7307e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return SDOperand(CurDAG->getTargetNode(U ? PPC::CMPLW : PPC::CMPW, MVT::i32, 7317e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng LHS, RHS), 0); 732919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner } else if (LHS.getValueType() == MVT::f32) { 73334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(RHS, RHS); 7347e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return SDOperand(CurDAG->getTargetNode(PPC::FCMPUS, MVT::i32, LHS, RHS), 0); 7352fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 73634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(RHS, RHS); 7377e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return SDOperand(CurDAG->getTargetNode(PPC::FCMPUD, MVT::i32, LHS, RHS), 0); 7382fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 7392fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 7402fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 7412fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// getBCCForSetCC - Returns the PowerPC condition branch mnemonic corresponding 7422fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// to Condition. 7432fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattnerstatic unsigned getBCCForSetCC(ISD::CondCode CC) { 7442fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner switch (CC) { 7452fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 746ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOEQ: // FIXME: This is incorrect see PR642. 7472fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETEQ: return PPC::BEQ; 748ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETONE: // FIXME: This is incorrect see PR642. 7492fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETNE: return PPC::BNE; 750ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLT: // FIXME: This is incorrect see PR642. 7512fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULT: 7522fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLT: return PPC::BLT; 753ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLE: // FIXME: This is incorrect see PR642. 7542fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULE: 7552fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLE: return PPC::BLE; 756ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGT: // FIXME: This is incorrect see PR642. 7572fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGT: 7582fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGT: return PPC::BGT; 759ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGE: // FIXME: This is incorrect see PR642. 7602fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGE: 7612fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGE: return PPC::BGE; 7626df2507121507c24d7155605c343e467e0106c07Chris Lattner 7636df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETO: return PPC::BUN; 7646df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETUO: return PPC::BNU; 7652fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 7662fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return 0; 7672fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 7682fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 76964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// getCRIdxForSetCC - Return the index of the condition register field 77064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// associated with the SetCC condition, and whether or not the field is 77164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// treated as inverted. That is, lt = 0; ge = 0 inverted. 77264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattnerstatic unsigned getCRIdxForSetCC(ISD::CondCode CC, bool& Inv) { 77364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 77464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 775ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLT: // FIXME: This is incorrect see PR642. 77664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULT: 77764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLT: Inv = false; return 0; 778ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGE: // FIXME: This is incorrect see PR642. 77964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGE: 78064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGE: Inv = true; return 0; 781ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGT: // FIXME: This is incorrect see PR642. 78264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGT: 78364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGT: Inv = false; return 1; 784ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLE: // FIXME: This is incorrect see PR642. 78564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULE: 78664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLE: Inv = true; return 1; 787ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOEQ: // FIXME: This is incorrect see PR642. 78864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETEQ: Inv = false; return 2; 789ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETONE: // FIXME: This is incorrect see PR642. 79064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETNE: Inv = true; return 2; 7916df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETO: Inv = true; return 3; 7926df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETUO: Inv = false; return 3; 79364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 79464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner return 0; 79564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner} 7969944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 7971d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectSETCC(SDOperand Op) { 798222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDNode *N = Op.Val; 799222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Imm; 800222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get(); 801222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (isIntImmediate(N->getOperand(1), Imm)) { 802222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // We can codegen setcc op, imm very efficiently compared to a brcond. 803222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Check for those cases here. 804222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // setcc op, 0 805222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (Imm == 0) { 80634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Op; 80734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Op, N->getOperand(0)); 808222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 809dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 810dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETEQ: 8117e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::CNTLZW, MVT::i32, Op), 0); 81271d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Op, getI32Imm(27), 81371d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(5), getI32Imm(31)); 814dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 8157e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AD = 8167e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 8177e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(~0U)), 0); 81871d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, 81971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner AD.getValue(1)); 820dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 821dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETLT: 82271d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Op, getI32Imm(1), 82371d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 824dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETGT: { 8257e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand T = 8267e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::NEG, MVT::i32, Op), 0); 8277e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng T = SDOperand(CurDAG->getTargetNode(PPC::ANDC, MVT::i32, T, Op), 0); 82871d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, T, getI32Imm(1), 82971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 830dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 831222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 832222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else if (Imm == ~0U) { // setcc op, -1 83334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Op; 83434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Op, N->getOperand(0)); 835222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 836dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 837dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETEQ: 8387e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 8397e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(1)), 0); 84071d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 8417e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::LI, MVT::i32, 8427e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(0)), 0), 84371d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner Op.getValue(1)); 844dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 8457e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::NOR, MVT::i32, Op, Op), 0); 8467e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *AD = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 8477e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(~0U)); 8487e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, SDOperand(AD, 0), Op, 8497e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(AD, 1)); 850dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 851dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETLT: { 8527e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AD = SDOperand(CurDAG->getTargetNode(PPC::ADDI, MVT::i32, Op, 8537e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(1)), 0); 8547e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AN = SDOperand(CurDAG->getTargetNode(PPC::AND, MVT::i32, AD, 8557e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op), 0); 85671d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, AN, getI32Imm(1), 85771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 858dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 859dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETGT: 8607e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Op, 8617e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(1), getI32Imm(31), 8627e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(31)), 0); 86371d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Op, getI32Imm(1)); 864222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 865222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 866222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 867222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 868222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner bool Inv; 869222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Idx = getCRIdxForSetCC(CC, Inv); 870222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 871222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand IntCR; 872222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 873222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Force the ccreg into CR7. 874222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand CR7Reg = CurDAG->getRegister(PPC::CR7, MVT::i32); 875222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 87685961d5ec126bbc0c111d52dd7361d5159265ca5Chris Lattner SDOperand InFlag(0, 0); // Null incoming flag value. 877db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner CCReg = CurDAG->getCopyToReg(CurDAG->getEntryNode(), CR7Reg, CCReg, 878db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner InFlag).getValue(1); 879222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 880222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (TLI.getTargetMachine().getSubtarget<PPCSubtarget>().isGigaProcessor()) 8817e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng IntCR = SDOperand(CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, CR7Reg, 8827e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng CCReg), 0); 883222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner else 8847e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng IntCR = SDOperand(CurDAG->getTargetNode(PPC::MFCR, MVT::i32, CCReg), 0); 885222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 886222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (!Inv) { 88771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, IntCR, 88871d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm((32-(3-Idx)) & 31), 88971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 890222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else { 891222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand Tmp = 8927e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, IntCR, 8937e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm((32-(3-Idx)) & 31), 8947e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(31),getI32Imm(31)), 0); 89571d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Tmp, getI32Imm(1)); 896222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 897222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner} 8982b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 899422b0cee7a32636303398d8788f98a59bf15381cNate Begeman/// isCallCompatibleAddress - Return true if the specified 32-bit value is 900422b0cee7a32636303398d8788f98a59bf15381cNate Begeman/// representable in the immediate field of a Bx instruction. 901422b0cee7a32636303398d8788f98a59bf15381cNate Begemanstatic bool isCallCompatibleAddress(ConstantSDNode *C) { 902422b0cee7a32636303398d8788f98a59bf15381cNate Begeman int Addr = C->getValue(); 903422b0cee7a32636303398d8788f98a59bf15381cNate Begeman if (Addr & 3) return false; // Low 2 bits are implicitly zero. 904422b0cee7a32636303398d8788f98a59bf15381cNate Begeman return (Addr << 6 >> 6) == Addr; // Top 6 bits have to be sext of immediate. 905422b0cee7a32636303398d8788f98a59bf15381cNate Begeman} 906422b0cee7a32636303398d8788f98a59bf15381cNate Begeman 9071d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectCALL(SDOperand Op) { 9086a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDNode *N = Op.Val; 90934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Chain; 91034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Chain, N->getOperand(0)); 9116a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9126a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner unsigned CallOpcode; 9136a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner std::vector<SDOperand> CallOperands; 9146a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9156a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (GlobalAddressSDNode *GASD = 9166a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner dyn_cast<GlobalAddressSDNode>(N->getOperand(1))) { 917422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOpcode = PPC::BL; 9182823b3e70ee7a5ed7482c45c503659a16a879a61Chris Lattner CallOperands.push_back(N->getOperand(1)); 9196a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else if (ExternalSymbolSDNode *ESSDN = 9206a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner dyn_cast<ExternalSymbolSDNode>(N->getOperand(1))) { 921422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOpcode = PPC::BL; 9226a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(N->getOperand(1)); 923422b0cee7a32636303398d8788f98a59bf15381cNate Begeman } else if (isa<ConstantSDNode>(N->getOperand(1)) && 924422b0cee7a32636303398d8788f98a59bf15381cNate Begeman isCallCompatibleAddress(cast<ConstantSDNode>(N->getOperand(1)))) { 925422b0cee7a32636303398d8788f98a59bf15381cNate Begeman ConstantSDNode *C = cast<ConstantSDNode>(N->getOperand(1)); 926422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOpcode = PPC::BLA; 927422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOperands.push_back(getI32Imm((int)C->getValue() >> 2)); 9286a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else { 9296a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // Copy the callee address into the CTR register. 93034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Callee; 93134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Callee, N->getOperand(1)); 9327e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Chain = SDOperand(CurDAG->getTargetNode(PPC::MTCTR, MVT::Other, Callee, 9337e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Chain), 0); 9346a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9356a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // Copy the callee address into R12 on darwin. 9366a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand R12 = CurDAG->getRegister(PPC::R12, MVT::i32); 9376a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getNode(ISD::CopyToReg, MVT::Other, Chain, R12, Callee); 938422b0cee7a32636303398d8788f98a59bf15381cNate Begeman 9396a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(R12); 940422b0cee7a32636303398d8788f98a59bf15381cNate Begeman CallOpcode = PPC::BCTRL; 9416a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 9426a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9436a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner unsigned GPR_idx = 0, FPR_idx = 0; 9446a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner static const unsigned GPR[] = { 9456a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::R3, PPC::R4, PPC::R5, PPC::R6, 9466a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::R7, PPC::R8, PPC::R9, PPC::R10, 9476a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner }; 9486a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner static const unsigned FPR[] = { 9496a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, 9506a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner PPC::F8, PPC::F9, PPC::F10, PPC::F11, PPC::F12, PPC::F13 9516a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner }; 9526a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9536a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner SDOperand InFlag; // Null incoming flag value. 9546a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9556a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner for (unsigned i = 2, e = N->getNumOperands(); i != e; ++i) { 9566a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner unsigned DestReg = 0; 9576a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner MVT::ValueType RegTy = N->getOperand(i).getValueType(); 9586a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (RegTy == MVT::i32) { 9596a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner assert(GPR_idx < 8 && "Too many int args"); 9606a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner DestReg = GPR[GPR_idx++]; 9616a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else { 9626a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner assert(MVT::isFloatingPoint(N->getOperand(i).getValueType()) && 9636a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner "Unpromoted integer arg?"); 9646a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner assert(FPR_idx < 13 && "Too many fp args"); 9656a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner DestReg = FPR[FPR_idx++]; 9666a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 9676a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9686a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (N->getOperand(i).getOpcode() != ISD::UNDEF) { 96934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Val; 97034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Val, N->getOperand(i)); 9716a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyToReg(Chain, DestReg, Val, InFlag); 9726a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner InFlag = Chain.getValue(1); 9736a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(CurDAG->getRegister(DestReg, RegTy)); 9746a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 9756a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 9766a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9776a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // Finally, once everything is in registers to pass to the call, emit the 9786a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // call itself. 9796a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (InFlag.Val) 9806a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(InFlag); // Strong dep on register copies. 9816a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner else 9826a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallOperands.push_back(Chain); // Weak dep on whatever occurs before 9837e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Chain = SDOperand(CurDAG->getTargetNode(CallOpcode, MVT::Other, MVT::Flag, 9847e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng CallOperands), 0); 9856a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9866a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner std::vector<SDOperand> CallResults; 9876a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 9886a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner // If the call has results, copy the values out of the ret val registers. 9896a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner switch (N->getValueType(0)) { 9906a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner default: assert(0 && "Unexpected ret value!"); 9916a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::Other: break; 9926a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::i32: 9936a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner if (N->getValueType(1) == MVT::i32) { 9946a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R4, MVT::i32, 9956a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(1)).getValue(1); 9966a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 9976a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R3, MVT::i32, 9986a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(2)).getValue(1); 9996a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 10006a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } else { 10016a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::R3, MVT::i32, 10026a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(1)).getValue(1); 10036a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 10046a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 10056a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner break; 10066a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::f32: 10076a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner case MVT::f64: 10086a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain = CurDAG->getCopyFromReg(Chain, PPC::F1, N->getValueType(0), 10096a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner Chain.getValue(1)).getValue(1); 10106a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain.getValue(0)); 10116a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner break; 10126a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner } 10136a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 10146a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CallResults.push_back(Chain); 10156a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner for (unsigned i = 0, e = CallResults.size(); i != e; ++i) 10166a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner CodeGenMap[Op.getValue(i)] = CallResults[i]; 10176a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner return CallResults[Op.ResNo]; 10186a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner} 10196a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 1020a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Select - Convert the specified operand from a target-independent to a 1021a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// target-specific node if it hasn't already been changed. 102234167215a8da717b21e44f1b834dc34d15279bf1Evan Chengvoid PPCDAGToDAGISel::Select(SDOperand &Result, SDOperand Op) { 1023a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDNode *N = Op.Val; 10240bbea954331b8f08afa5b094dfb0841829c70eaaChris Lattner if (N->getOpcode() >= ISD::BUILTIN_OP_END && 102534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N->getOpcode() < PPCISD::FIRST_NUMBER) { 102634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = Op; 102734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; // Already selected. 102834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng } 1029d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 1030d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner // If this has already been converted, use it. 1031d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner std::map<SDOperand, SDOperand>::iterator CGMI = CodeGenMap.find(Op); 103234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng if (CGMI != CodeGenMap.end()) { 103334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CGMI->second; 103434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 103534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng } 1036a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1037a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOpcode()) { 103819c0907ba1c11c81dc231cf7b4143fdaf03466e4Chris Lattner default: break; 103934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case ISD::SETCC: 104034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = SelectSETCC(Op); 104134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 104234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case PPCISD::CALL: 104334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = SelectCALL(Op); 104434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 104534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case PPCISD::GlobalBaseReg: 104634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = getGlobalBaseReg(); 104734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 1048860e8862c1fbd3b261da4a64a8c0096f9f373681Chris Lattner 1049e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner case ISD::FrameIndex: { 1050e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner int FI = cast<FrameIndexSDNode>(N)->getIndex(); 105134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng if (N->hasOneUse()) { 105234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::ADDI, MVT::i32, 105334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng CurDAG->getTargetFrameIndex(FI, MVT::i32), 105434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(0)); 105534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 105634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng } 105734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CodeGenMap[Op] = 10587e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::ADDI, MVT::i32, 10597e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng CurDAG->getTargetFrameIndex(FI, MVT::i32), 10607e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(0)), 0); 106134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 1062e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } 106388add100b3db715df4275c8ab408e6b51f28ff8fChris Lattner case ISD::SDIV: { 1064405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: since this depends on the setting of the carry flag from the srawi 1065405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // we should really be making notes about that for the scheduler. 1066405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: It sure would be nice if we could cheaply recognize the 1067405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // srl/add/sra pattern the dag combiner will generate for this as 1068405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // sra/addze rather than having to handle sdiv ourselves. oh well. 10698784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner unsigned Imm; 10708784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if (isIntImmediate(N->getOperand(1), Imm)) { 107134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand N0; 107234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(N0, N->getOperand(0)); 10738784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if ((signed)Imm > 0 && isPowerOf2_32(Imm)) { 10747e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 10758784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 107634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N0, getI32Imm(Log2_32(Imm))); 107734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 10787e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Op, 0), SDOperand(Op, 1)); 10798784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } else if ((signed)Imm < 0 && isPowerOf2_32(-Imm)) { 10807e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 10812501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 108234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N0, getI32Imm(Log2_32(-Imm))); 10838784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand PT = 10847e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, 10857e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Op, 0), SDOperand(Op, 1)), 10867e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng 0); 108734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::NEG, MVT::i32, PT); 10888784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 108934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 10908784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 1091047b952e298352fe6feffedf02e359601133f465Chris Lattner 1092237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1093237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1094047b952e298352fe6feffedf02e359601133f465Chris Lattner } 1095cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman case ISD::AND: { 109650fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman unsigned Imm, Imm2; 1097cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and of a value rotated between 0 and 31 bits and then and'd 1098cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // with a mask, emit rlwinm 1099cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isIntImmediate(N->getOperand(1), Imm) && (isShiftedMask_32(Imm) || 1100cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isShiftedMask_32(~Imm))) { 1101cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SDOperand Val; 1102a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned SH, MB, ME; 1103cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isRotateAndMask(N->getOperand(0).Val, Imm, false, SH, MB, ME)) { 110434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Val, N->getOperand(0).getOperand(0)); 11053393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner } else if (Imm == 0) { 11063393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner // AND X, 0 -> 0, not "rlwinm 32". 110734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Result, N->getOperand(1)); 110834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return ; 11093393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner } else { 111034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Val, N->getOperand(0)); 1111cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isRunOfOnes(Imm, MB, ME); 1112cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = 0; 1113cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 111434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Val, 111534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(SH), getI32Imm(MB), 111634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(ME)); 111734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 1118cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 111950fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // ISD::OR doesn't get all the bitfield insertion fun. 112050fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // (and (or x, c1), c2) where isRunOfOnes(~(c1^c2)) is a bitfield insert 112150fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman if (isIntImmediate(N->getOperand(1), Imm) && 112250fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman N->getOperand(0).getOpcode() == ISD::OR && 112350fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman isIntImmediate(N->getOperand(0).getOperand(1), Imm2)) { 1124c9a5ef524a9f461717bbf647b2d3da061aed720dChris Lattner unsigned MB, ME; 112550fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman Imm = ~(Imm^Imm2); 112650fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman if (isRunOfOnes(Imm, MB, ME)) { 112734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Tmp1, Tmp2; 112834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Tmp1, N->getOperand(0).getOperand(0)); 112934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Tmp2, N->getOperand(0).getOperand(1)); 11307e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Result = SDOperand(CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, 11317e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Tmp1, Tmp2, 11327e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(0), getI32Imm(MB), 11337e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(ME)), 0); 113434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 113550fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 113650fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 1137237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner 1138237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1139237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1140cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 114102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::OR: 114234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng if (SDNode *I = SelectBitfieldInsert(N)) { 114334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CodeGenMap[Op] = SDOperand(I, 0); 114434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 114534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng } 1146d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 1147237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1148237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1149c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SHL: { 1150c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1151c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 11522d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 115334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Val; 115434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Val, N->getOperand(0).getOperand(0)); 115534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 115634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Val, getI32Imm(SH), getI32Imm(MB), 115734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(ME)); 115834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 11598d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 11602d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 11612d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 11622d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1163c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 1164c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRL: { 1165c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1166c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 11672d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 116834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Val; 116934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Val, N->getOperand(0).getOperand(0)); 117034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 117134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Val, getI32Imm(SH & 0x1F), getI32Imm(MB), 117234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(ME)); 117334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 11748d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 11752d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 11762d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 11772d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1178c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 117913794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner case ISD::SELECT_CC: { 118013794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(4))->get(); 118113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner 118213794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner // handle the setcc cases here. select_cc lhs, 0, 1, 0, cc 118313794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N->getOperand(1))) 118413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N->getOperand(2))) 118513794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N->getOperand(3))) 118613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (N1C->isNullValue() && N3C->isNullValue() && 118713794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner N2C->getValue() == 1ULL && CC == ISD::SETNE) { 118834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand LHS; 118934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(LHS, N->getOperand(0)); 11907e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Tmp = 119113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 119213794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner LHS, getI32Imm(~0U)); 11937e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Result = CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, 11947e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Tmp, 0), LHS, 11957e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Tmp, 1)); 119634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 119713794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 11988a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 119950ff55c2c7909818165e51bbdc103a05b143dcb1Chris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 12008a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner unsigned BROpc = getBCCForSetCC(CC); 12018a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 12028a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner bool isFP = MVT::isFloatingPoint(N->getValueType(0)); 1203919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner unsigned SelectCCOp; 1204919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (MVT::isInteger(N->getValueType(0))) 1205919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_Int; 1206919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else if (N->getValueType(0) == MVT::f32) 1207919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F4; 1208919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else 1209919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F8; 121034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand N2, N3; 121134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(N2, N->getOperand(2)); 121234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(N3, N->getOperand(3)); 121334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, SelectCCOp, N->getValueType(0), CCReg, 121434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N2, N3, getI32Imm(BROpc)); 121534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 121613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 121781e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman case ISD::BR_CC: { 121834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Chain; 121934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Chain, N->getOperand(0)); 12202fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(1))->get(); 12212fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CondCode = SelectCC(N->getOperand(2), N->getOperand(3), CC); 122281e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman Result = CurDAG->SelectNodeTo(N, PPC::COND_BRANCH, MVT::Other, 122381e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman CondCode, getI32Imm(getBCCForSetCC(CC)), 122481e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman N->getOperand(4), Chain); 122534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 12262fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 1227a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 122825dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner 122934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SelectCode(Result, Op); 1230a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1231a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1232a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 12331d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman/// createPPCISelDag - This pass converts a legalized DAG into a 1234a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// PowerPC-specific DAG, ready for instruction scheduling. 1235a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// 1236c4c6257c1a154279bf10e9498d46d6c1793dbaa7Evan ChengFunctionPass *llvm::createPPCISelDag(PPCTargetMachine &TM) { 12371d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman return new PPCDAGToDAGISel(TM); 1238a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1239a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1240