PPCISelDAGToDAG.cpp revision 8e2a04e21dc8299bdaba4321a6e690712dab9617
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 140c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner /// CreateTargetHazardRecognizer - Return the hazard recognizer to use for 141c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner /// this 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); 155a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner }; 156a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 157a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 158bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner/// InstructionSelectBasicBlock - This callback is invoked by 159bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner/// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 1601d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begemanvoid PPCDAGToDAGISel::InstructionSelectBasicBlock(SelectionDAG &DAG) { 161bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DEBUG(BB->dump()); 162bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 163bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // The selection process is inherently a bottom-up recursive process (users 164bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // select their uses before themselves). Given infinite stack space, we 165bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // could just start selecting on the root and traverse the whole graph. In 166bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // practice however, this causes us to run out of stack space on large basic 167bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // blocks. To avoid this problem, select the entry node, then all its uses, 168bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // iteratively instead of recursively. 169bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner std::vector<SDOperand> Worklist; 170bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Worklist.push_back(DAG.getEntryNode()); 171bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 172bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Note that we can do this in the PPC target (scanning forward across token 173bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // chain edges) because no nodes ever get folded across these edges. On a 174bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // target like X86 which supports load/modify/store operations, this would 175bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // have to be more careful. 176bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner while (!Worklist.empty()) { 177bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDOperand Node = Worklist.back(); 178bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Worklist.pop_back(); 179bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 180cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner // Chose from the least deep of the top two nodes. 181cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner if (!Worklist.empty() && 182cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner Worklist.back().Val->getNodeDepth() < Node.Val->getNodeDepth()) 183cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner std::swap(Worklist.back(), Node); 184cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner 185bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner if ((Node.Val->getOpcode() >= ISD::BUILTIN_OP_END && 186bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Node.Val->getOpcode() < PPCISD::FIRST_NUMBER) || 187bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner CodeGenMap.count(Node)) continue; 188bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 189bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner for (SDNode::use_iterator UI = Node.Val->use_begin(), 190bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner E = Node.Val->use_end(); UI != E; ++UI) { 191bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Scan the values. If this use has a value that is a token chain, add it 192bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // to the worklist. 193bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner SDNode *User = *UI; 194bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner for (unsigned i = 0, e = User->getNumValues(); i != e; ++i) 195bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner if (User->getValueType(i) == MVT::Other) { 196bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner Worklist.push_back(SDOperand(User, i)); 197bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner break; 198bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner } 199bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner } 200bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 201bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Finally, legalize this node. 20234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Dummy; 20334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Dummy, Node); 204bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner } 205cf01a70550a25af39f979eb36a9e95aadcb12e00Chris Lattner 206bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Select target instructions for the DAG. 207ba2f0a9ee53512ce840aca34281e126802a125d1Evan Cheng DAG.setRoot(SelectRoot(DAG.getRoot())); 2086a3d5a62f09d4093468525a07a0143cae0e9df41Evan Cheng assert(InFlightSet.empty() && "ISel InFlightSet has not been emptied!"); 209bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner CodeGenMap.clear(); 210afe358e7d46da9d29ba02fbbf81bdfb4ac4a4520Evan Cheng HandleMap.clear(); 211afe358e7d46da9d29ba02fbbf81bdfb4ac4a4520Evan Cheng ReplaceMap.clear(); 212bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DAG.RemoveDeadNodes(); 213bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 2141877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // Emit machine code to BB. 215bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner ScheduleAndEmitDAG(DAG); 2164bb189507281af0da8aff91743b5198acbf2398bChris Lattner} 2174bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2184bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// InsertVRSaveCode - Once the entire function has been instruction selected, 2194bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// all virtual registers are created and all machine instructions are built, 2204bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// check to see if we need to save/restore VRSAVE. If so, do it. 2214bb189507281af0da8aff91743b5198acbf2398bChris Lattnervoid PPCDAGToDAGISel::InsertVRSaveCode(Function &F) { 2221877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // Check to see if this function uses vector registers, which means we have to 2231877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // save and restore the VRSAVE register and update it with the regs we use. 2241877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2251877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // In this case, there will be virtual registers of vector type type created 2261877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // by the scheduler. Detect them now. 2274bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineFunction &Fn = MachineFunction::get(&F); 2284bb189507281af0da8aff91743b5198acbf2398bChris Lattner SSARegMap *RegMap = Fn.getSSARegMap(); 2291877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner bool HasVectorVReg = false; 2301877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner for (unsigned i = MRegisterInfo::FirstVirtualRegister, 231a08610c8a534501bc4301c5037e883f180b19a99Chris Lattner e = RegMap->getLastVirtReg()+1; i != e; ++i) 2321877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner if (RegMap->getRegClass(i) == &PPC::VRRCRegClass) { 2331877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner HasVectorVReg = true; 2341877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner break; 2351877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner } 2364bb189507281af0da8aff91743b5198acbf2398bChris Lattner if (!HasVectorVReg) return; // nothing to do. 2374bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2381877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // If we have a vector register, we want to emit code into the entry and exit 2391877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // blocks to save and restore the VRSAVE register. We do this here (instead 2401877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // of marking all vector instructions as clobbering VRSAVE) for two reasons: 2411877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2421877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 1. This (trivially) reduces the load on the register allocator, by not 2431877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // having to represent the live range of the VRSAVE register. 2441877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2. This (more significantly) allows us to create a temporary virtual 2451877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // register to hold the saved VRSAVE value, allowing this temporary to be 2461877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // register allocated, instead of forcing it to be spilled to the stack. 2474bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2484bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Create two vregs - one to hold the VRSAVE register that is live-in to the 2494bb189507281af0da8aff91743b5198acbf2398bChris Lattner // function and one for the value after having bits or'd into it. 2504bb189507281af0da8aff91743b5198acbf2398bChris Lattner unsigned InVRSAVE = RegMap->createVirtualRegister(&PPC::GPRCRegClass); 2514bb189507281af0da8aff91743b5198acbf2398bChris Lattner unsigned UpdatedVRSAVE = RegMap->createVirtualRegister(&PPC::GPRCRegClass); 2524bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2534bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock &EntryBB = *Fn.begin(); 2544bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Emit the following code into the entry block: 2554bb189507281af0da8aff91743b5198acbf2398bChris Lattner // InVRSAVE = MFVRSAVE 2564bb189507281af0da8aff91743b5198acbf2398bChris Lattner // UpdatedVRSAVE = UPDATE_VRSAVE InVRSAVE 2574bb189507281af0da8aff91743b5198acbf2398bChris Lattner // MTVRSAVE UpdatedVRSAVE 2584bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock::iterator IP = EntryBB.begin(); // Insert Point 2594bb189507281af0da8aff91743b5198acbf2398bChris Lattner BuildMI(EntryBB, IP, PPC::MFVRSAVE, 0, InVRSAVE); 2604bb189507281af0da8aff91743b5198acbf2398bChris Lattner BuildMI(EntryBB, IP, PPC::UPDATE_VRSAVE, 1, UpdatedVRSAVE).addReg(InVRSAVE); 2614bb189507281af0da8aff91743b5198acbf2398bChris Lattner BuildMI(EntryBB, IP, PPC::MTVRSAVE, 1).addReg(UpdatedVRSAVE); 2624bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2634bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Find all return blocks, outputting a restore in each epilog. 2644bb189507281af0da8aff91743b5198acbf2398bChris Lattner const TargetInstrInfo &TII = *TM.getInstrInfo(); 2654bb189507281af0da8aff91743b5198acbf2398bChris Lattner for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 2664bb189507281af0da8aff91743b5198acbf2398bChris Lattner if (!BB->empty() && TII.isReturn(BB->back().getOpcode())) { 2674bb189507281af0da8aff91743b5198acbf2398bChris Lattner IP = BB->end(); --IP; 2684bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2694bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Skip over all terminator instructions, which are part of the return 2704bb189507281af0da8aff91743b5198acbf2398bChris Lattner // sequence. 2714bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock::iterator I2 = IP; 2724bb189507281af0da8aff91743b5198acbf2398bChris Lattner while (I2 != BB->begin() && TII.isTerminatorInstr((--I2)->getOpcode())) 2734bb189507281af0da8aff91743b5198acbf2398bChris Lattner IP = I2; 2744bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2754bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Emit: MTVRSAVE InVRSave 2764bb189507281af0da8aff91743b5198acbf2398bChris Lattner BuildMI(*BB, IP, PPC::MTVRSAVE, 1).addReg(InVRSAVE); 2774bb189507281af0da8aff91743b5198acbf2398bChris Lattner } 2781877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner } 279bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner} 2806cd40d5888f905a3820d5d6c71e57cc0e02abb4aChris Lattner 2814bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2824416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// getGlobalBaseReg - Output the instructions required to put the 2834416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// base address to use for accessing globals into a register. 2844416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// 2851d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::getGlobalBaseReg() { 2864416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (!GlobalBaseReg) { 2874416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Insert the set of GlobalBaseReg into the first MBB of the function 2884416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock &FirstMBB = BB->getParent()->front(); 2894416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock::iterator MBBI = FirstMBB.begin(); 2904416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SSARegMap *RegMap = BB->getParent()->getSSARegMap(); 2911d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman // FIXME: when we get to LP64, we will need to create the appropriate 2921d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman // type of register here. 2931d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman GlobalBaseReg = RegMap->createVirtualRegister(PPC::GPRCRegisterClass); 2944416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MovePCtoLR, 0, PPC::LR); 2954416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MFLR, 1, GlobalBaseReg); 2964416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 2979944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner return CurDAG->getRegister(GlobalBaseReg, MVT::i32); 2984416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner} 2994416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 3004416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 3010f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isIntImmediate - This method tests to see if a constant operand. 3020f3257a3302b60c128a667db6736e81335316c1eNate Begeman// If so Imm will receive the 32 bit value. 3030f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isIntImmediate(SDNode *N, unsigned& Imm) { 3040f3257a3302b60c128a667db6736e81335316c1eNate Begeman if (N->getOpcode() == ISD::Constant) { 3050f3257a3302b60c128a667db6736e81335316c1eNate Begeman Imm = cast<ConstantSDNode>(N)->getValue(); 3060f3257a3302b60c128a667db6736e81335316c1eNate Begeman return true; 3070f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 3080f3257a3302b60c128a667db6736e81335316c1eNate Begeman return false; 3090f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 3100f3257a3302b60c128a667db6736e81335316c1eNate Begeman 311cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s with 312cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// any number of 0s on either side. The 1s are allowed to wrap from LSB to 313cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 0x0F0F0000 is 314cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// not, since all 1s are not contiguous. 315cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME) { 316cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isShiftedMask_32(Val)) { 317cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first non-zero bit 318cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman MB = CountLeadingZeros_32(Val); 319cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first zero bit after the run of ones 320cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman ME = CountLeadingZeros_32((Val - 1) ^ Val); 321cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return true; 3222fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } else { 3232fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner Val = ~Val; // invert mask 3242fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner if (isShiftedMask_32(Val)) { 3252fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first zero bit 3262fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner ME = CountLeadingZeros_32(Val) - 1; 3272fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first one bit after the run of zeros 3282fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner MB = CountLeadingZeros_32((Val - 1) ^ Val) + 1; 3292fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner return true; 3302fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } 331cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 332cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // no run present 333cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 334cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 335cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 33665a419a1045972729f91f82a378b7f4b7f6a2be5Chris Lattner// isRotateAndMask - Returns true if Mask and Shift can be folded into a rotate 337cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// and mask opcode and mask operation. 338cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRotateAndMask(SDNode *N, unsigned Mask, bool IsShiftMask, 339cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned &SH, unsigned &MB, unsigned &ME) { 340da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // Don't even go down this path for i64, since different logic will be 341da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // necessary for rldicl/rldicr/rldimi. 342da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman if (N->getValueType(0) != MVT::i32) 343da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman return false; 344da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman 345cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Shift = 32; 346cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Indeterminant = ~0; // bit mask marking indeterminant results 347cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Opcode = N->getOpcode(); 34815055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner if (N->getNumOperands() != 2 || 34915055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner !isIntImmediate(N->getOperand(1).Val, Shift) || (Shift > 31)) 350cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 351cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 352cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Opcode == ISD::SHL) { 353cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift left to mask if it comes first 354cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask << Shift; 355cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 356cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu << Shift); 357651dea74f6a362d30bc61fd0b549da7707af5bf8Chris Lattner } else if (Opcode == ISD::SRL) { 358cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift right to mask if it comes first 359cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask >> Shift; 360cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 361cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu >> Shift); 362cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // adjust for the left rotate 363cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Shift = 32 - Shift; 364cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 365cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 366cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 367cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 368cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // if the mask doesn't intersect any Indeterminant bits 369cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Mask && !(Mask & Indeterminant)) { 3700949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner SH = Shift & 31; 371cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // make sure the mask is still a mask (wrap arounds may not be) 372cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return isRunOfOnes(Mask, MB, ME); 373cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 374cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 375cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 376cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 3770f3257a3302b60c128a667db6736e81335316c1eNate Begeman// isOpcWithIntImmediate - This method tests to see if the node is a specific 3780f3257a3302b60c128a667db6736e81335316c1eNate Begeman// opcode and that it has a immediate integer right operand. 3790f3257a3302b60c128a667db6736e81335316c1eNate Begeman// If so Imm will receive the 32 bit value. 3800f3257a3302b60c128a667db6736e81335316c1eNate Begemanstatic bool isOpcWithIntImmediate(SDNode *N, unsigned Opc, unsigned& Imm) { 3810f3257a3302b60c128a667db6736e81335316c1eNate Begeman return N->getOpcode() == Opc && isIntImmediate(N->getOperand(1).Val, Imm); 3820f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 3830f3257a3302b60c128a667db6736e81335316c1eNate Begeman 384a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// isIntImmediate - This method tests to see if a constant operand. 385a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// If so Imm will receive the 32 bit value. 386a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerstatic bool isIntImmediate(SDOperand N, unsigned& Imm) { 387a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 388a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Imm = (unsigned)CN->getSignExtended(); 389a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return true; 390a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 391a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return false; 392a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 393a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 39402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// SelectBitfieldInsert - turn an or of two masked values into 39502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// the rotate left word immediate then mask insert (rlwimi) instruction. 3961d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDNode *PPCDAGToDAGISel::SelectBitfieldInsert(SDNode *N) { 39702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op0 = N->getOperand(0); 39802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op1 = N->getOperand(1); 39902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 40077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman uint64_t LKZ, LKO, RKZ, RKO; 4014667f2cbad246beccfca5411a26add24d1007035Nate Begeman TLI.ComputeMaskedBits(Op0, 0xFFFFFFFFULL, LKZ, LKO); 4024667f2cbad246beccfca5411a26add24d1007035Nate Begeman TLI.ComputeMaskedBits(Op1, 0xFFFFFFFFULL, RKZ, RKO); 40302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 4044667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned TargetMask = LKZ; 4054667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned InsertMask = RKZ; 4064667f2cbad246beccfca5411a26add24d1007035Nate Begeman 4074667f2cbad246beccfca5411a26add24d1007035Nate Begeman if ((TargetMask | InsertMask) == 0xFFFFFFFF) { 4084667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Op0Opc = Op0.getOpcode(); 4094667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Op1Opc = Op1.getOpcode(); 4104667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Value, SH = 0; 4114667f2cbad246beccfca5411a26add24d1007035Nate Begeman TargetMask = ~TargetMask; 4124667f2cbad246beccfca5411a26add24d1007035Nate Begeman InsertMask = ~InsertMask; 41377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 4144667f2cbad246beccfca5411a26add24d1007035Nate Begeman // If the LHS has a foldable shift and the RHS does not, then swap it to the 4154667f2cbad246beccfca5411a26add24d1007035Nate Begeman // RHS so that we can fold the shift into the insert. 41677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op0Opc == ISD::AND && Op1Opc == ISD::AND) { 41777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op0.getOperand(0).getOpcode() == ISD::SHL || 41877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op0.getOperand(0).getOpcode() == ISD::SRL) { 41977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op1.getOperand(0).getOpcode() != ISD::SHL && 42077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1.getOperand(0).getOpcode() != ISD::SRL) { 42177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman std::swap(Op0, Op1); 42277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman std::swap(Op0Opc, Op1Opc); 4234667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(TargetMask, InsertMask); 42477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 42577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 4264667f2cbad246beccfca5411a26add24d1007035Nate Begeman } else if (Op0Opc == ISD::SHL || Op0Opc == ISD::SRL) { 4274667f2cbad246beccfca5411a26add24d1007035Nate Begeman if (Op1Opc == ISD::AND && Op1.getOperand(0).getOpcode() != ISD::SHL && 4284667f2cbad246beccfca5411a26add24d1007035Nate Begeman Op1.getOperand(0).getOpcode() != ISD::SRL) { 4294667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(Op0, Op1); 4304667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(Op0Opc, Op1Opc); 4314667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(TargetMask, InsertMask); 4324667f2cbad246beccfca5411a26add24d1007035Nate Begeman } 43302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 43477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 43577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman unsigned MB, ME; 4360949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner if (InsertMask && isRunOfOnes(InsertMask, MB, ME)) { 43777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SDOperand Tmp1, Tmp2, Tmp3; 4384667f2cbad246beccfca5411a26add24d1007035Nate Begeman bool DisjointMask = (TargetMask ^ InsertMask) == 0xFFFFFFFF; 43977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 44077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if ((Op1Opc == ISD::SHL || Op1Opc == ISD::SRL) && 44177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman isIntImmediate(Op1.getOperand(1), Value)) { 44277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0); 44377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SH = (Op1Opc == ISD::SHL) ? Value : 32 - Value; 44402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 44577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op1Opc == ISD::AND) { 44677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman unsigned SHOpc = Op1.getOperand(0).getOpcode(); 44777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if ((SHOpc == ISD::SHL || SHOpc == ISD::SRL) && 44877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman isIntImmediate(Op1.getOperand(0).getOperand(1), Value)) { 44977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0).getOperand(0); 45077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SH = (SHOpc == ISD::SHL) ? Value : 32 - Value; 45177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } else { 45277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0); 45377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 45402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 45577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 45677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Tmp3 = (Op0Opc == ISD::AND && DisjointMask) ? Op0.getOperand(0) : Op0; 45777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Select(Tmp1, Tmp3); 45877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Select(Tmp2, Op1); 4590949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner SH &= 31; 46077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman return CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, Tmp1, Tmp2, 46177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 46202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 46302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 46402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 46502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman} 46602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 4677fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrImm - Returns true if the address N can be represented by 4687fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// a base register plus a signed 16-bit displacement [r+imm]. 4697fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrImm(SDOperand N, SDOperand &Disp, 4707fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Base) { 4710f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If this can be more profitably realized as r+r, fail. 4720f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (SelectAddrIdx(N, Disp, Base)) 4730f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; 4740f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 4757fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (N.getOpcode() == ISD::ADD) { 4767fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman unsigned imm = 0; 4777fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm)) { 47817e82d2858f0c003b7fcfaf7c025ca3d0aaa7a88Chris Lattner Disp = getI32Imm(imm & 0xFFFF); 4797fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0))) { 4807fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Base = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 4819944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 4827564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N.getOperand(0); 4839944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4847fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [r+i] 4857fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman } else if (N.getOperand(1).getOpcode() == PPCISD::Lo) { 4864f0f86de5f183b09d07b17d1f940bd3e298abfcdChris Lattner // Match LOAD (ADD (X, Lo(G))). 4877fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman assert(!cast<ConstantSDNode>(N.getOperand(1).getOperand(1))->getValue() 4884f0f86de5f183b09d07b17d1f940bd3e298abfcdChris Lattner && "Cannot handle constant offsets yet!"); 4897fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Disp = N.getOperand(1).getOperand(0); // The global address. 4907fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman assert(Disp.getOpcode() == ISD::TargetGlobalAddress || 49137efe6764568a3829fee26aba532283131d1a104Nate Begeman Disp.getOpcode() == ISD::TargetConstantPool || 49237efe6764568a3829fee26aba532283131d1a104Nate Begeman Disp.getOpcode() == ISD::TargetJumpTable); 4937564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N.getOperand(0); 4947fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [&g+r] 4959944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4960f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } else if (N.getOpcode() == ISD::OR) { 4970f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner unsigned imm = 0; 4980f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm)) { 4990f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If this is an or of disjoint bitfields, we can codegen this as an add 5000f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // (for better address arithmetic) if the LHS and RHS of the OR are 5010f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // provably disjoint. 5020f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner uint64_t LHSKnownZero, LHSKnownOne; 5030f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(0), ~0U, 5040f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner LHSKnownZero, LHSKnownOne); 5050f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if ((LHSKnownZero|~imm) == ~0U) { 5060f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If all of the bits are known zero on the LHS or RHS, the add won't 5070f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // carry. 5080f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Base = N.getOperand(0); 5090f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Disp = getI32Imm(imm & 0xFFFF); 5100f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return true; 5110f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 5120f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 513d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner } else if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 514d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // Loading from a constant address. 515d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner int Addr = (int)CN->getValue(); 516d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner 517d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // If this address fits entirely in a 16-bit sext immediate field, codegen 518d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // this as "d, 0" 519d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner if (Addr == (short)Addr) { 520d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner Disp = getI32Imm(Addr); 521d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner Base = CurDAG->getRegister(PPC::R0, MVT::i32); 522d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner return true; 523d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner } 524d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner 525d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // Otherwise, break this down into an LIS + disp. 526d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner Disp = getI32Imm((short)Addr); 527d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner Base = CurDAG->getConstant(Addr - (signed short)Addr, MVT::i32); 528d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner return true; 5299944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 530d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner 5317fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Disp = getI32Imm(0); 5327fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N)) 5337fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Base = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 53428a6b02626c29b1fe9bb16c14c193549fab4cab8Nate Begeman else 5357564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N; 5367fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [r+0] 5379944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner} 538a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 5397fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrIdx - Given the specified addressed, check to see if it can be 5407fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// represented as an indexed [r+r] operation. Returns false if it can 5417fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// be represented by [r+imm], which are preferred. 5427fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrIdx(SDOperand N, SDOperand &Base, 5437fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Index) { 5440f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner unsigned imm = 0; 5457fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (N.getOpcode() == ISD::ADD) { 5460f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm)) 5470f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; // r+i 5480f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (N.getOperand(1).getOpcode() == PPCISD::Lo) 5490f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; // r+i 5500f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5517564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N.getOperand(0); 5527564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Index = N.getOperand(1); 5537fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; 5540f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } else if (N.getOpcode() == ISD::OR) { 5550f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm)) 5560f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; // r+i can fold it if we can. 5570f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5580f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If this is an or of disjoint bitfields, we can codegen this as an add 5590f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // (for better address arithmetic) if the LHS and RHS of the OR are provably 5600f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // disjoint. 5610f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner uint64_t LHSKnownZero, LHSKnownOne; 5620f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner uint64_t RHSKnownZero, RHSKnownOne; 5630f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(0), ~0U, 5640f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner LHSKnownZero, LHSKnownOne); 5650f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5660f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (LHSKnownZero) { 5670f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(1), ~0U, 5680f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner RHSKnownZero, RHSKnownOne); 5690f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If all of the bits are known zero on the LHS or RHS, the add won't 5700f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // carry. 5710f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if ((LHSKnownZero | RHSKnownZero) == ~0U) { 5720f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Base = N.getOperand(0); 5730f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Index = N.getOperand(1); 5740f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return true; 5750f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 5760f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 5777fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman } 5780f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5790f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; 5807fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman} 5817fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman 5827fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrIdxOnly - Given the specified addressed, force it to be 5837fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// represented as an indexed [r+r] operation. 5847fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrIdxOnly(SDOperand N, SDOperand &Base, 5857fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Index) { 5860f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // Check to see if we can easily represent this as an [r+r] address. This 5870f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // will fail if it thinks that the address is more profitably represented as 5880f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // reg+imm, e.g. where imm = 0. 58954e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner if (SelectAddrIdx(N, Base, Index)) 59054e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner return true; 59154e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner 59254e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // If the operand is an addition, always emit this as [r+r], since this is 59354e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // better (for code size, and execution, as the memop does the add for free) 59454e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // than emitting an explicit add. 59554e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner if (N.getOpcode() == ISD::ADD) { 59654e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Base = N.getOperand(0); 59754e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Index = N.getOperand(1); 59854e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner return true; 599f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman } 60054e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner 60154e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // Otherwise, do it the hard way, using R0 as the base register. 60254e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Base = CurDAG->getRegister(PPC::R0, MVT::i32); 60354e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Index = N; 6047fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; 605f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman} 606f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman 607e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner/// SelectAddrImmShift - Returns true if the address N can be represented by 608e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner/// a base register plus a signed 14-bit displacement [r+imm*4]. Suitable 609e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner/// for use by STD and friends. 610e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattnerbool PPCDAGToDAGISel::SelectAddrImmShift(SDOperand N, SDOperand &Disp, 611e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner SDOperand &Base) { 612e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If this can be more profitably realized as r+r, fail. 613e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (SelectAddrIdx(N, Disp, Base)) 614e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return false; 615e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 616e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (N.getOpcode() == ISD::ADD) { 617e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner unsigned imm = 0; 618e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm) && 619e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner (imm & 3) == 0) { 620e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm((imm & 0xFFFF) >> 2); 621e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0))) { 622e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 623e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else { 624e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N.getOperand(0); 625e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 626e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; // [r+i] 627e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else if (N.getOperand(1).getOpcode() == PPCISD::Lo) { 628e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // Match LOAD (ADD (X, Lo(G))). 629e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner assert(!cast<ConstantSDNode>(N.getOperand(1).getOperand(1))->getValue() 630e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner && "Cannot handle constant offsets yet!"); 631e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = N.getOperand(1).getOperand(0); // The global address. 632e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner assert(Disp.getOpcode() == ISD::TargetGlobalAddress || 63337efe6764568a3829fee26aba532283131d1a104Nate Begeman Disp.getOpcode() == ISD::TargetConstantPool || 63437efe6764568a3829fee26aba532283131d1a104Nate Begeman Disp.getOpcode() == ISD::TargetJumpTable); 635e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N.getOperand(0); 636e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; // [&g+r] 637e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 638e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else if (N.getOpcode() == ISD::OR) { 639e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner unsigned imm = 0; 640e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (isIntImmediate(N.getOperand(1), imm) && isInt16(imm) && 641e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner (imm & 3) == 0) { 642e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If this is an or of disjoint bitfields, we can codegen this as an add 643e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // (for better address arithmetic) if the LHS and RHS of the OR are 644e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // provably disjoint. 645e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner uint64_t LHSKnownZero, LHSKnownOne; 646e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(0), ~0U, 647e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner LHSKnownZero, LHSKnownOne); 648e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if ((LHSKnownZero|~imm) == ~0U) { 649e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If all of the bits are known zero on the LHS or RHS, the add won't 650e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // carry. 651e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N.getOperand(0); 652e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm((imm & 0xFFFF) >> 2); 653e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; 654e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 655e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 656e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 657e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // Loading from a constant address. 658e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner int Addr = (int)CN->getValue(); 659e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if ((Addr & 3) == 0) { 660e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If this address fits entirely in a 16-bit sext immediate field, codegen 661e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // this as "d, 0" 662e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (Addr == (short)Addr) { 663e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm(Addr >> 2); 664e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = CurDAG->getRegister(PPC::R0, MVT::i32); 665e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; 666e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 667e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 668e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // Otherwise, break this down into an LIS + disp. 669e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm((short)Addr >> 2); 670e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = CurDAG->getConstant(Addr - (signed short)Addr, MVT::i32); 671e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; 672e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 673e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 674e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 675e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm(0); 676e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N)) 677e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32); 678e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner else 679e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N; 680e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; // [r+0] 681e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner} 682e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 683e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 6842fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// SelectCC - Select a comparison of the specified values with the specified 6852fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// condition code, returning the CR# of the expression. 6861d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectCC(SDOperand LHS, SDOperand RHS, 6871d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman ISD::CondCode CC) { 6882fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Always select the LHS. 68934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(LHS, LHS); 6902fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 6912fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Use U to determine whether the SETCC immediate range is signed or not. 6922fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (MVT::isInteger(LHS.getValueType())) { 6932fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner bool U = ISD::isUnsignedIntSetCC(CC); 6942fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner unsigned Imm; 6952fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner if (isIntImmediate(RHS, Imm) && 6962fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ((U && isUInt16(Imm)) || (!U && isInt16(Imm)))) 6977e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return SDOperand(CurDAG->getTargetNode(U ? PPC::CMPLWI : PPC::CMPWI, 6987e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng MVT::i32, LHS, getI32Imm(Imm & 0xFFFF)), 0); 69934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(RHS, RHS); 7007e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return SDOperand(CurDAG->getTargetNode(U ? PPC::CMPLW : PPC::CMPW, MVT::i32, 7017e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng LHS, RHS), 0); 702919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner } else if (LHS.getValueType() == MVT::f32) { 70334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(RHS, RHS); 7047e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return SDOperand(CurDAG->getTargetNode(PPC::FCMPUS, MVT::i32, LHS, RHS), 0); 7052fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 70634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(RHS, RHS); 7077e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng return SDOperand(CurDAG->getTargetNode(PPC::FCMPUD, MVT::i32, LHS, RHS), 0); 7082fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 7092fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 7102fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 7112fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// getBCCForSetCC - Returns the PowerPC condition branch mnemonic corresponding 7122fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// to Condition. 7132fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattnerstatic unsigned getBCCForSetCC(ISD::CondCode CC) { 7142fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner switch (CC) { 7152fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 716ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOEQ: // FIXME: This is incorrect see PR642. 7175d634ce466173f6fde49470fad125eb09532caebChris Lattner case ISD::SETUEQ: 7182fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETEQ: return PPC::BEQ; 719ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETONE: // FIXME: This is incorrect see PR642. 7205d634ce466173f6fde49470fad125eb09532caebChris Lattner case ISD::SETUNE: 7212fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETNE: return PPC::BNE; 722ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLT: // FIXME: This is incorrect see PR642. 7232fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULT: 7242fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLT: return PPC::BLT; 725ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLE: // FIXME: This is incorrect see PR642. 7262fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULE: 7272fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLE: return PPC::BLE; 728ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGT: // FIXME: This is incorrect see PR642. 7292fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGT: 7302fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGT: return PPC::BGT; 731ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGE: // FIXME: This is incorrect see PR642. 7322fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGE: 7332fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGE: return PPC::BGE; 7346df2507121507c24d7155605c343e467e0106c07Chris Lattner 7356df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETO: return PPC::BUN; 7366df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETUO: return PPC::BNU; 7372fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 7382fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return 0; 7392fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 7402fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 74164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// getCRIdxForSetCC - Return the index of the condition register field 74264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// associated with the SetCC condition, and whether or not the field is 74364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// treated as inverted. That is, lt = 0; ge = 0 inverted. 74464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattnerstatic unsigned getCRIdxForSetCC(ISD::CondCode CC, bool& Inv) { 74564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 74664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 747ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLT: // FIXME: This is incorrect see PR642. 74864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULT: 74964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLT: Inv = false; return 0; 750ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGE: // FIXME: This is incorrect see PR642. 75164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGE: 75264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGE: Inv = true; return 0; 753ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGT: // FIXME: This is incorrect see PR642. 75464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGT: 75564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGT: Inv = false; return 1; 756ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLE: // FIXME: This is incorrect see PR642. 75764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULE: 75864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLE: Inv = true; return 1; 759ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOEQ: // FIXME: This is incorrect see PR642. 7608e2a04e21dc8299bdaba4321a6e690712dab9617Chris Lattner case ISD::SETUEQ: 76164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETEQ: Inv = false; return 2; 762ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETONE: // FIXME: This is incorrect see PR642. 7638e2a04e21dc8299bdaba4321a6e690712dab9617Chris Lattner case ISD::SETUNE: 76464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETNE: Inv = true; return 2; 7656df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETO: Inv = true; return 3; 7666df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETUO: Inv = false; return 3; 76764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 76864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner return 0; 76964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner} 7709944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 7711d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectSETCC(SDOperand Op) { 772222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDNode *N = Op.Val; 773222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Imm; 774222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get(); 775222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (isIntImmediate(N->getOperand(1), Imm)) { 776222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // We can codegen setcc op, imm very efficiently compared to a brcond. 777222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Check for those cases here. 778222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // setcc op, 0 779222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (Imm == 0) { 78034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Op; 78134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Op, N->getOperand(0)); 782222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 783dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 784dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETEQ: 7857e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::CNTLZW, MVT::i32, Op), 0); 78671d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Op, getI32Imm(27), 78771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(5), getI32Imm(31)); 788dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 7897e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AD = 7907e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 7917e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(~0U)), 0); 79271d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, 79371d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner AD.getValue(1)); 794dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 795dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETLT: 79671d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Op, getI32Imm(1), 79771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 798dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETGT: { 7997e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand T = 8007e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::NEG, MVT::i32, Op), 0); 8017e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng T = SDOperand(CurDAG->getTargetNode(PPC::ANDC, MVT::i32, T, Op), 0); 80271d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, T, getI32Imm(1), 80371d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 804dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 805222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 806222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else if (Imm == ~0U) { // setcc op, -1 80734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Op; 80834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Op, N->getOperand(0)); 809222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 810dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 811dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETEQ: 8127e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 8137e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(1)), 0); 81471d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 8157e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::LI, MVT::i32, 8167e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(0)), 0), 81771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner Op.getValue(1)); 818dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 8197e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::NOR, MVT::i32, Op, Op), 0); 8207e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *AD = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 8217e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(~0U)); 822c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, SDOperand(AD, 0), 823c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner Op, SDOperand(AD, 1)); 824dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 825dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETLT: { 8267e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AD = SDOperand(CurDAG->getTargetNode(PPC::ADDI, MVT::i32, Op, 8277e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(1)), 0); 8287e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AN = SDOperand(CurDAG->getTargetNode(PPC::AND, MVT::i32, AD, 8297e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op), 0); 83071d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, AN, getI32Imm(1), 83171d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 832dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 833dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETGT: 8347e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Op, 8357e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(1), getI32Imm(31), 8367e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(31)), 0); 83771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Op, getI32Imm(1)); 838222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 839222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 840222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 841222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 842222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner bool Inv; 843222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Idx = getCRIdxForSetCC(CC, Inv); 844222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 845222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand IntCR; 846222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 847222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Force the ccreg into CR7. 848222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand CR7Reg = CurDAG->getRegister(PPC::CR7, MVT::i32); 849222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 85085961d5ec126bbc0c111d52dd7361d5159265ca5Chris Lattner SDOperand InFlag(0, 0); // Null incoming flag value. 851db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner CCReg = CurDAG->getCopyToReg(CurDAG->getEntryNode(), CR7Reg, CCReg, 852db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner InFlag).getValue(1); 853222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 854222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (TLI.getTargetMachine().getSubtarget<PPCSubtarget>().isGigaProcessor()) 8557e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng IntCR = SDOperand(CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, CR7Reg, 8567e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng CCReg), 0); 857222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner else 8587e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng IntCR = SDOperand(CurDAG->getTargetNode(PPC::MFCR, MVT::i32, CCReg), 0); 859222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 860222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (!Inv) { 86171d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, IntCR, 86271d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm((32-(3-Idx)) & 31), 86371d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 864222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else { 865222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand Tmp = 8667e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, IntCR, 8677e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm((32-(3-Idx)) & 31), 8687e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(31),getI32Imm(31)), 0); 86971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Tmp, getI32Imm(1)); 870222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 871222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner} 8722b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 8736a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 874a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Select - Convert the specified operand from a target-independent to a 875a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// target-specific node if it hasn't already been changed. 87634167215a8da717b21e44f1b834dc34d15279bf1Evan Chengvoid PPCDAGToDAGISel::Select(SDOperand &Result, SDOperand Op) { 877a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDNode *N = Op.Val; 8780bbea954331b8f08afa5b094dfb0841829c70eaaChris Lattner if (N->getOpcode() >= ISD::BUILTIN_OP_END && 87934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N->getOpcode() < PPCISD::FIRST_NUMBER) { 88034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = Op; 88134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; // Already selected. 88234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng } 883d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 884d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner // If this has already been converted, use it. 885d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner std::map<SDOperand, SDOperand>::iterator CGMI = CodeGenMap.find(Op); 88634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng if (CGMI != CodeGenMap.end()) { 88734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CGMI->second; 88834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 88934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng } 890a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 891a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOpcode()) { 89219c0907ba1c11c81dc231cf7b4143fdaf03466e4Chris Lattner default: break; 89334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case ISD::SETCC: 89434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = SelectSETCC(Op); 89534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 89634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case PPCISD::GlobalBaseReg: 89734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = getGlobalBaseReg(); 89834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 899860e8862c1fbd3b261da4a64a8c0096f9f373681Chris Lattner 900e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner case ISD::FrameIndex: { 901e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner int FI = cast<FrameIndexSDNode>(N)->getIndex(); 90234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng if (N->hasOneUse()) { 90334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::ADDI, MVT::i32, 90434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng CurDAG->getTargetFrameIndex(FI, MVT::i32), 90534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(0)); 90634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 90734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng } 90834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CodeGenMap[Op] = 9097e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::ADDI, MVT::i32, 9107e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng CurDAG->getTargetFrameIndex(FI, MVT::i32), 9117e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(0)), 0); 91234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 913e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } 9146d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner 9156d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner case PPCISD::MFCR: { 9166d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner SDOperand InFlag; 9176d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner Select(InFlag, N->getOperand(1)); 9186d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner // Use MFOCRF if supported. 9196d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner if (TLI.getTargetMachine().getSubtarget<PPCSubtarget>().isGigaProcessor()) 9206d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner Result = SDOperand(CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, 9216d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner N->getOperand(0), InFlag), 0); 9226d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner else 9236d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner Result = SDOperand(CurDAG->getTargetNode(PPC::MFCR, MVT::i32, InFlag), 0); 9246d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner CodeGenMap[Op] = Result; 9256d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner return; 9266d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner } 9276d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner 92888add100b3db715df4275c8ab408e6b51f28ff8fChris Lattner case ISD::SDIV: { 929405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: since this depends on the setting of the carry flag from the srawi 930405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // we should really be making notes about that for the scheduler. 931405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: It sure would be nice if we could cheaply recognize the 932405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // srl/add/sra pattern the dag combiner will generate for this as 933405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // sra/addze rather than having to handle sdiv ourselves. oh well. 9348784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner unsigned Imm; 9358784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if (isIntImmediate(N->getOperand(1), Imm)) { 93634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand N0; 93734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(N0, N->getOperand(0)); 9388784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if ((signed)Imm > 0 && isPowerOf2_32(Imm)) { 9397e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 9408784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 94134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N0, getI32Imm(Log2_32(Imm))); 94234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 9437e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Op, 0), SDOperand(Op, 1)); 9448784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } else if ((signed)Imm < 0 && isPowerOf2_32(-Imm)) { 9457e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 9462501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 94734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N0, getI32Imm(Log2_32(-Imm))); 9488784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand PT = 9497e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, 9507e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Op, 0), SDOperand(Op, 1)), 9517e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng 0); 95234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::NEG, MVT::i32, PT); 9538784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 95434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 9558784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 956047b952e298352fe6feffedf02e359601133f465Chris Lattner 957237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 958237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 959047b952e298352fe6feffedf02e359601133f465Chris Lattner } 960cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman case ISD::AND: { 96150fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman unsigned Imm, Imm2; 962cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and of a value rotated between 0 and 31 bits and then and'd 963cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // with a mask, emit rlwinm 964cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isIntImmediate(N->getOperand(1), Imm) && (isShiftedMask_32(Imm) || 965cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isShiftedMask_32(~Imm))) { 966cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SDOperand Val; 967a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned SH, MB, ME; 968cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isRotateAndMask(N->getOperand(0).Val, Imm, false, SH, MB, ME)) { 96934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Val, N->getOperand(0).getOperand(0)); 9703393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner } else if (Imm == 0) { 9713393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner // AND X, 0 -> 0, not "rlwinm 32". 97234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Result, N->getOperand(1)); 97334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return ; 9743393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner } else { 97534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Val, N->getOperand(0)); 976cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isRunOfOnes(Imm, MB, ME); 977cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = 0; 978cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 97934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Val, 98034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(SH), getI32Imm(MB), 98134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(ME)); 98234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 983cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 98450fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // ISD::OR doesn't get all the bitfield insertion fun. 98550fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // (and (or x, c1), c2) where isRunOfOnes(~(c1^c2)) is a bitfield insert 98650fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman if (isIntImmediate(N->getOperand(1), Imm) && 98750fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman N->getOperand(0).getOpcode() == ISD::OR && 98850fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman isIntImmediate(N->getOperand(0).getOperand(1), Imm2)) { 989c9a5ef524a9f461717bbf647b2d3da061aed720dChris Lattner unsigned MB, ME; 99050fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman Imm = ~(Imm^Imm2); 99150fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman if (isRunOfOnes(Imm, MB, ME)) { 99234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Tmp1, Tmp2; 99334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Tmp1, N->getOperand(0).getOperand(0)); 99434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Tmp2, N->getOperand(0).getOperand(1)); 9957e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Result = SDOperand(CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, 9967e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Tmp1, Tmp2, 9977e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(0), getI32Imm(MB), 9987e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(ME)), 0); 99934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 100050fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 100150fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 1002237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner 1003237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1004237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1005cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 100602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::OR: 100734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng if (SDNode *I = SelectBitfieldInsert(N)) { 100834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CodeGenMap[Op] = SDOperand(I, 0); 100934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 101034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng } 1011d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 1012237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1013237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1014c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SHL: { 1015c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1016c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 10172d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 101834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Val; 101934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Val, N->getOperand(0).getOperand(0)); 102034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 102134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Val, getI32Imm(SH), getI32Imm(MB), 102234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(ME)); 102334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 10248d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 10252d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 10262d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 10272d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1028c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 1029c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRL: { 1030c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1031c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 10322d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 103334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Val; 103434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Val, N->getOperand(0).getOperand(0)); 103534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 10360949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner Val, getI32Imm(SH), getI32Imm(MB), 103734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(ME)); 103834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 10398d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 10402d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 10412d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 10422d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1043c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 104413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner case ISD::SELECT_CC: { 104513794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(4))->get(); 104613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner 104713794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner // handle the setcc cases here. select_cc lhs, 0, 1, 0, cc 104813794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N->getOperand(1))) 104913794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N->getOperand(2))) 105013794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N->getOperand(3))) 105113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (N1C->isNullValue() && N3C->isNullValue() && 105213794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner N2C->getValue() == 1ULL && CC == ISD::SETNE) { 105334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand LHS; 105434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(LHS, N->getOperand(0)); 10557e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Tmp = 105613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 105713794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner LHS, getI32Imm(~0U)); 10587e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Result = CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, 10597e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Tmp, 0), LHS, 10607e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Tmp, 1)); 106134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 106213794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 10638a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 106450ff55c2c7909818165e51bbdc103a05b143dcb1Chris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 10658a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner unsigned BROpc = getBCCForSetCC(CC); 10668a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 10678a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner bool isFP = MVT::isFloatingPoint(N->getValueType(0)); 1068919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner unsigned SelectCCOp; 1069919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner if (MVT::isInteger(N->getValueType(0))) 1070919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_Int; 1071919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else if (N->getValueType(0) == MVT::f32) 1072919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F4; 1073710ff32983ca919fa0da14e077450b6a7654274fChris Lattner else if (N->getValueType(0) == MVT::f64) 1074919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F8; 1075710ff32983ca919fa0da14e077450b6a7654274fChris Lattner else 1076710ff32983ca919fa0da14e077450b6a7654274fChris Lattner SelectCCOp = PPC::SELECT_CC_VRRC; 1077710ff32983ca919fa0da14e077450b6a7654274fChris Lattner 107834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand N2, N3; 107934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(N2, N->getOperand(2)); 108034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(N3, N->getOperand(3)); 108134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, SelectCCOp, N->getValueType(0), CCReg, 108234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N2, N3, getI32Imm(BROpc)); 108334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 108413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 108581e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman case ISD::BR_CC: { 108634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Chain; 108734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Select(Chain, N->getOperand(0)); 10882fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(1))->get(); 10892fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CondCode = SelectCC(N->getOperand(2), N->getOperand(3), CC); 109081e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman Result = CurDAG->SelectNodeTo(N, PPC::COND_BRANCH, MVT::Other, 109181e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman CondCode, getI32Imm(getBCCForSetCC(CC)), 109281e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman N->getOperand(4), Chain); 109334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng return; 10942fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 109537efe6764568a3829fee26aba532283131d1a104Nate Begeman case ISD::BRIND: { 109637efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand Chain, Target; 109737efe6764568a3829fee26aba532283131d1a104Nate Begeman Select(Chain, N->getOperand(0)); 109837efe6764568a3829fee26aba532283131d1a104Nate Begeman Select(Target,N->getOperand(1)); 109937efe6764568a3829fee26aba532283131d1a104Nate Begeman Chain = SDOperand(CurDAG->getTargetNode(PPC::MTCTR, MVT::Other, Target, 110037efe6764568a3829fee26aba532283131d1a104Nate Begeman Chain), 0); 110137efe6764568a3829fee26aba532283131d1a104Nate Begeman Result = CurDAG->SelectNodeTo(N, PPC::BCTR, MVT::Other, Chain); 110237efe6764568a3829fee26aba532283131d1a104Nate Begeman return; 110337efe6764568a3829fee26aba532283131d1a104Nate Begeman } 1104a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 110525dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner 110634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SelectCode(Result, Op); 1107a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1108a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1109a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 11101d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman/// createPPCISelDag - This pass converts a legalized DAG into a 1111a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// PowerPC-specific DAG, ready for instruction scheduling. 1112a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// 1113c4c6257c1a154279bf10e9498d46d6c1793dbaa7Evan ChengFunctionPass *llvm::createPPCISelDag(PPCTargetMachine &TM) { 11141d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman return new PPCDAGToDAGISel(TM); 1115a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1116a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1117