PPCISelDAGToDAG.cpp revision 64a752f7c7cf160f2887d0a16d5922359832c9c2
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" 312a41a98fb70923e2d6780220eb225ac0e8b4ff36Chris Lattner#include "llvm/Support/Visibility.h" 322c2c6c61f100bc7c3df873b11203fcea1b5e18feChris Lattner#include <iostream> 332ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng#include <queue> 34ba2f0a9ee53512ce840aca34281e126802a125d1Evan Cheng#include <set> 35a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerusing namespace llvm; 36a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 37a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnernamespace { 38a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner Statistic<> FrameOff("ppc-codegen", "Number of frame idx offsets collapsed"); 39a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 40a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner //===--------------------------------------------------------------------===// 411d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman /// PPCDAGToDAGISel - PPC specific code to select PPC machine 42a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// instructions for SelectionDAG operations. 43a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// 442a41a98fb70923e2d6780220eb225ac0e8b4ff36Chris Lattner class VISIBILITY_HIDDEN PPCDAGToDAGISel : public SelectionDAGISel { 454bb189507281af0da8aff91743b5198acbf2398bChris Lattner PPCTargetMachine &TM; 4621e463b2bf864671a87ebe386cb100ef9349a540Nate Begeman PPCTargetLowering PPCLowering; 474416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner unsigned GlobalBaseReg; 48a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner public: 494bb189507281af0da8aff91743b5198acbf2398bChris Lattner PPCDAGToDAGISel(PPCTargetMachine &tm) 504bb189507281af0da8aff91743b5198acbf2398bChris Lattner : SelectionDAGISel(PPCLowering), TM(tm), 514bb189507281af0da8aff91743b5198acbf2398bChris Lattner PPCLowering(*TM.getTargetLowering()) {} 52a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 534416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner virtual bool runOnFunction(Function &Fn) { 544416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Make sure we re-emit a set of the global base reg if necessary 554416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalBaseReg = 0; 564bb189507281af0da8aff91743b5198acbf2398bChris Lattner SelectionDAGISel::runOnFunction(Fn); 574bb189507281af0da8aff91743b5198acbf2398bChris Lattner 584bb189507281af0da8aff91743b5198acbf2398bChris Lattner InsertVRSaveCode(Fn); 594bb189507281af0da8aff91743b5198acbf2398bChris Lattner return true; 604416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 614416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 62a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// getI32Imm - Return a target constant with the specified value, of type 63a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// i32. 64a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner inline SDOperand getI32Imm(unsigned Imm) { 65a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return CurDAG->getTargetConstant(Imm, MVT::i32); 66a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 674416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 68c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// getI64Imm - Return a target constant with the specified value, of type 69c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// i64. 70c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner inline SDOperand getI64Imm(uint64_t Imm) { 71c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return CurDAG->getTargetConstant(Imm, MVT::i64); 72c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 73c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 74c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// getSmallIPtrImm - Return a target constant of pointer type. 75c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner inline SDOperand getSmallIPtrImm(unsigned Imm) { 76c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return CurDAG->getTargetConstant(Imm, PPCLowering.getPointerTy()); 77c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 78c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 79c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 804416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// getGlobalBaseReg - insert code into the entry mbb to materialize the PIC 814416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// base register. Return the virtual register that holds this value. 829944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner SDOperand getGlobalBaseReg(); 83a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 84a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Select - Convert the specified operand from a target-independent to a 85a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // target-specific node if it hasn't already been changed. 8664a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng SDNode *Select(SDOperand &Result, SDOperand Op); 87a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 8802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDNode *SelectBitfieldInsert(SDNode *N); 8902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 902fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// SelectCC - Select a comparison of the specified values with the 912fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// specified condition code, returning the CR# of the expression. 922fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand SelectCC(SDOperand LHS, SDOperand RHS, ISD::CondCode CC); 932fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 947fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrImm - Returns true if the address N can be represented by 957fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// a base register plus a signed 16-bit displacement [r+imm]. 967fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman bool SelectAddrImm(SDOperand N, SDOperand &Disp, SDOperand &Base); 977fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman 987fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrIdx - Given the specified addressed, check to see if it can be 997fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// represented as an indexed [r+r] operation. Returns false if it can 1007fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// be represented by [r+imm], which are preferred. 1017fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman bool SelectAddrIdx(SDOperand N, SDOperand &Base, SDOperand &Index); 102f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman 1037fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrIdxOnly - Given the specified addressed, force it to be 1047fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// represented as an indexed [r+r] operation. 1057fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman bool SelectAddrIdxOnly(SDOperand N, SDOperand &Base, SDOperand &Index); 1069944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 107e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// SelectAddrImmShift - Returns true if the address N can be represented by 108e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// a base register plus a signed 14-bit displacement [r+imm*4]. Suitable 109e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// for use by STD and friends. 110e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner bool SelectAddrImmShift(SDOperand N, SDOperand &Disp, SDOperand &Base); 111e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 112e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner /// SelectInlineAsmMemoryOperand - Implement addressing mode selection for 113e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner /// inline asm expressions. 114e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner virtual bool SelectInlineAsmMemoryOperand(const SDOperand &Op, 115e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner char ConstraintCode, 116e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner std::vector<SDOperand> &OutOps, 117e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner SelectionDAG &DAG) { 118e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner SDOperand Op0, Op1; 119e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner switch (ConstraintCode) { 120e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner default: return true; 121e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'm': // memory 122e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner if (!SelectAddrIdx(Op, Op0, Op1)) 123e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner SelectAddrImm(Op, Op0, Op1); 124e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 125e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'o': // offsetable 126e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner if (!SelectAddrImm(Op, Op0, Op1)) { 1272ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Op0, Op); // r+0. 128c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Op1 = getSmallIPtrImm(0); 129e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 130e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 131e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'v': // not offsetable 132e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner SelectAddrIdxOnly(Op, Op0, Op1); 133e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 134e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 135e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner 136e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner OutOps.push_back(Op0); 137e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner OutOps.push_back(Op1); 138e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner return false; 139e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 140e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner 141047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand BuildSDIVSequence(SDNode *N); 142047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand BuildUDIVSequence(SDNode *N); 143047b952e298352fe6feffedf02e359601133f465Chris Lattner 144a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// InstructionSelectBasicBlock - This callback is invoked by 145a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 146bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner virtual void InstructionSelectBasicBlock(SelectionDAG &DAG); 147bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 1484bb189507281af0da8aff91743b5198acbf2398bChris Lattner void InsertVRSaveCode(Function &Fn); 1494bb189507281af0da8aff91743b5198acbf2398bChris Lattner 150a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner virtual const char *getPassName() const { 151a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return "PowerPC DAG->DAG Pattern Instruction Selection"; 152a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 153c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner 154c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner /// CreateTargetHazardRecognizer - Return the hazard recognizer to use for 155c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner /// this target when scheduling the DAG. 156b0d21ef20c29f4ea46d21b488f17feaa6a8760e1Chris Lattner virtual HazardRecognizer *CreateTargetHazardRecognizer() { 157c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner // Should use subtarget info to pick the right hazard recognizer. For 158c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner // now, always return a PPC970 recognizer. 15988d211f82304e53694ece666d4a2507b170e4582Chris Lattner const TargetInstrInfo *II = PPCLowering.getTargetMachine().getInstrInfo(); 16088d211f82304e53694ece666d4a2507b170e4582Chris Lattner assert(II && "No InstrInfo?"); 16188d211f82304e53694ece666d4a2507b170e4582Chris Lattner return new PPCHazardRecognizer970(*II); 162c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner } 163af165385112037cb942e94ea562a67990b7d6220Chris Lattner 164af165385112037cb942e94ea562a67990b7d6220Chris Lattner// Include the pieces autogenerated from the target description. 1654c7b43b43fdf943c7298718e15ab5d6dfe345be7Chris Lattner#include "PPCGenDAGISel.inc" 166bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 167bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattnerprivate: 168222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand SelectSETCC(SDOperand Op); 16964a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng SDNode *MySelect_PPCbctrl(SDOperand &Result, SDOperand N); 17064a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng SDNode *MySelect_PPCcall(SDOperand &Result, SDOperand N); 171a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner }; 172a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 173a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 174bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner/// InstructionSelectBasicBlock - This callback is invoked by 175bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner/// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 1761d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begemanvoid PPCDAGToDAGISel::InstructionSelectBasicBlock(SelectionDAG &DAG) { 177bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DEBUG(BB->dump()); 178bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 179bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Select target instructions for the DAG. 180ba2f0a9ee53512ce840aca34281e126802a125d1Evan Cheng DAG.setRoot(SelectRoot(DAG.getRoot())); 181bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DAG.RemoveDeadNodes(); 182bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 1831877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // Emit machine code to BB. 184bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner ScheduleAndEmitDAG(DAG); 1854bb189507281af0da8aff91743b5198acbf2398bChris Lattner} 1864bb189507281af0da8aff91743b5198acbf2398bChris Lattner 1874bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// InsertVRSaveCode - Once the entire function has been instruction selected, 1884bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// all virtual registers are created and all machine instructions are built, 1894bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// check to see if we need to save/restore VRSAVE. If so, do it. 1904bb189507281af0da8aff91743b5198acbf2398bChris Lattnervoid PPCDAGToDAGISel::InsertVRSaveCode(Function &F) { 1911877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // Check to see if this function uses vector registers, which means we have to 1921877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // save and restore the VRSAVE register and update it with the regs we use. 1931877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 1941877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // In this case, there will be virtual registers of vector type type created 1951877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // by the scheduler. Detect them now. 1964bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineFunction &Fn = MachineFunction::get(&F); 1974bb189507281af0da8aff91743b5198acbf2398bChris Lattner SSARegMap *RegMap = Fn.getSSARegMap(); 1981877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner bool HasVectorVReg = false; 1991877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner for (unsigned i = MRegisterInfo::FirstVirtualRegister, 200a08610c8a534501bc4301c5037e883f180b19a99Chris Lattner e = RegMap->getLastVirtReg()+1; i != e; ++i) 2011877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner if (RegMap->getRegClass(i) == &PPC::VRRCRegClass) { 2021877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner HasVectorVReg = true; 2031877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner break; 2041877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner } 2054bb189507281af0da8aff91743b5198acbf2398bChris Lattner if (!HasVectorVReg) return; // nothing to do. 2064bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2071877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // If we have a vector register, we want to emit code into the entry and exit 2081877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // blocks to save and restore the VRSAVE register. We do this here (instead 2091877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // of marking all vector instructions as clobbering VRSAVE) for two reasons: 2101877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2111877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 1. This (trivially) reduces the load on the register allocator, by not 2121877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // having to represent the live range of the VRSAVE register. 2131877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2. This (more significantly) allows us to create a temporary virtual 2141877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // register to hold the saved VRSAVE value, allowing this temporary to be 2151877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // register allocated, instead of forcing it to be spilled to the stack. 2164bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2174bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Create two vregs - one to hold the VRSAVE register that is live-in to the 2184bb189507281af0da8aff91743b5198acbf2398bChris Lattner // function and one for the value after having bits or'd into it. 2194bb189507281af0da8aff91743b5198acbf2398bChris Lattner unsigned InVRSAVE = RegMap->createVirtualRegister(&PPC::GPRCRegClass); 2204bb189507281af0da8aff91743b5198acbf2398bChris Lattner unsigned UpdatedVRSAVE = RegMap->createVirtualRegister(&PPC::GPRCRegClass); 2214bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2224bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock &EntryBB = *Fn.begin(); 2234bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Emit the following code into the entry block: 2244bb189507281af0da8aff91743b5198acbf2398bChris Lattner // InVRSAVE = MFVRSAVE 2254bb189507281af0da8aff91743b5198acbf2398bChris Lattner // UpdatedVRSAVE = UPDATE_VRSAVE InVRSAVE 2264bb189507281af0da8aff91743b5198acbf2398bChris Lattner // MTVRSAVE UpdatedVRSAVE 2274bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock::iterator IP = EntryBB.begin(); // Insert Point 2284bb189507281af0da8aff91743b5198acbf2398bChris Lattner BuildMI(EntryBB, IP, PPC::MFVRSAVE, 0, InVRSAVE); 2294bb189507281af0da8aff91743b5198acbf2398bChris Lattner BuildMI(EntryBB, IP, PPC::UPDATE_VRSAVE, 1, UpdatedVRSAVE).addReg(InVRSAVE); 2304bb189507281af0da8aff91743b5198acbf2398bChris Lattner BuildMI(EntryBB, IP, PPC::MTVRSAVE, 1).addReg(UpdatedVRSAVE); 2314bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2324bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Find all return blocks, outputting a restore in each epilog. 2334bb189507281af0da8aff91743b5198acbf2398bChris Lattner const TargetInstrInfo &TII = *TM.getInstrInfo(); 2344bb189507281af0da8aff91743b5198acbf2398bChris Lattner for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 2354bb189507281af0da8aff91743b5198acbf2398bChris Lattner if (!BB->empty() && TII.isReturn(BB->back().getOpcode())) { 2364bb189507281af0da8aff91743b5198acbf2398bChris Lattner IP = BB->end(); --IP; 2374bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2384bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Skip over all terminator instructions, which are part of the return 2394bb189507281af0da8aff91743b5198acbf2398bChris Lattner // sequence. 2404bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock::iterator I2 = IP; 2414bb189507281af0da8aff91743b5198acbf2398bChris Lattner while (I2 != BB->begin() && TII.isTerminatorInstr((--I2)->getOpcode())) 2424bb189507281af0da8aff91743b5198acbf2398bChris Lattner IP = I2; 2434bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2444bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Emit: MTVRSAVE InVRSave 2454bb189507281af0da8aff91743b5198acbf2398bChris Lattner BuildMI(*BB, IP, PPC::MTVRSAVE, 1).addReg(InVRSAVE); 2464bb189507281af0da8aff91743b5198acbf2398bChris Lattner } 2471877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner } 248bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner} 2496cd40d5888f905a3820d5d6c71e57cc0e02abb4aChris Lattner 2504bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2514416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// getGlobalBaseReg - Output the instructions required to put the 2524416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// base address to use for accessing globals into a register. 2534416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// 2541d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::getGlobalBaseReg() { 2554416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (!GlobalBaseReg) { 2564416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Insert the set of GlobalBaseReg into the first MBB of the function 2574416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock &FirstMBB = BB->getParent()->front(); 2584416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock::iterator MBBI = FirstMBB.begin(); 2594416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner SSARegMap *RegMap = BB->getParent()->getSSARegMap(); 260c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 261c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (PPCLowering.getPointerTy() == MVT::i32) 262c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner GlobalBaseReg = RegMap->createVirtualRegister(PPC::GPRCRegisterClass); 263c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner else 264c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner GlobalBaseReg = RegMap->createVirtualRegister(PPC::G8RCRegisterClass); 265c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 2664416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MovePCtoLR, 0, PPC::LR); 2674416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner BuildMI(FirstMBB, MBBI, PPC::MFLR, 1, GlobalBaseReg); 2684416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 269c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return CurDAG->getRegister(GlobalBaseReg, PPCLowering.getPointerTy()); 2704416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner} 2714416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 272c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isIntS16Immediate - This method tests to see if the node is either a 32-bit 273c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// or 64-bit immediate, and if the value can be accurately represented as a 274c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// sign extension from a 16-bit value. If so, this returns true and the 275c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// immediate. 276c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isIntS16Immediate(SDNode *N, short &Imm) { 277c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getOpcode() != ISD::Constant) 278c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return false; 2794416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 280c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Imm = (short)cast<ConstantSDNode>(N)->getValue(); 281c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getValueType(0) == MVT::i32) 282c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return Imm == (int32_t)cast<ConstantSDNode>(N)->getValue(); 283c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner else 284c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return Imm == (int64_t)cast<ConstantSDNode>(N)->getValue(); 285c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 286c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 287c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isIntS16Immediate(SDOperand Op, short &Imm) { 288c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return isIntS16Immediate(Op.Val, Imm); 289c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 290c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 291c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 292c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isInt32Immediate - This method tests to see if the node is a 32-bit constant 293c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// operand. If so Imm will receive the 32-bit value. 294c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isInt32Immediate(SDNode *N, unsigned &Imm) { 295c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i32) { 2960f3257a3302b60c128a667db6736e81335316c1eNate Begeman Imm = cast<ConstantSDNode>(N)->getValue(); 2970f3257a3302b60c128a667db6736e81335316c1eNate Begeman return true; 2980f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 2990f3257a3302b60c128a667db6736e81335316c1eNate Begeman return false; 3000f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 3010f3257a3302b60c128a667db6736e81335316c1eNate Begeman 302c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isInt64Immediate - This method tests to see if the node is a 64-bit constant 303c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// operand. If so Imm will receive the 64-bit value. 304c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isInt64Immediate(SDNode *N, uint64_t &Imm) { 305c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i32) { 306c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Imm = cast<ConstantSDNode>(N)->getValue(); 307c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return true; 308c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 309c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return false; 310c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 311c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 312c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// isInt32Immediate - This method tests to see if a constant operand. 313c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// If so Imm will receive the 32 bit value. 314c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isInt32Immediate(SDOperand N, unsigned &Imm) { 315c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return isInt32Immediate(N.Val, Imm); 316c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 317c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 318c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 319c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// isOpcWithIntImmediate - This method tests to see if the node is a specific 320c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// opcode and that it has a immediate integer right operand. 321c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// If so Imm will receive the 32 bit value. 322c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isOpcWithIntImmediate(SDNode *N, unsigned Opc, unsigned& Imm) { 323c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return N->getOpcode() == Opc && isInt32Immediate(N->getOperand(1).Val, Imm); 324c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 325c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 326c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 327cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s with 328cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// any number of 0s on either side. The 1s are allowed to wrap from LSB to 329cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 0x0F0F0000 is 330cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// not, since all 1s are not contiguous. 331cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME) { 332cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isShiftedMask_32(Val)) { 333cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first non-zero bit 334cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman MB = CountLeadingZeros_32(Val); 335cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first zero bit after the run of ones 336cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman ME = CountLeadingZeros_32((Val - 1) ^ Val); 337cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return true; 3382fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } else { 3392fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner Val = ~Val; // invert mask 3402fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner if (isShiftedMask_32(Val)) { 3412fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first zero bit 3422fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner ME = CountLeadingZeros_32(Val) - 1; 3432fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first one bit after the run of zeros 3442fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner MB = CountLeadingZeros_32((Val - 1) ^ Val) + 1; 3452fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner return true; 3462fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } 347cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 348cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // no run present 349cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 350cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 351cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 35265a419a1045972729f91f82a378b7f4b7f6a2be5Chris Lattner// isRotateAndMask - Returns true if Mask and Shift can be folded into a rotate 353cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman// and mask opcode and mask operation. 354cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begemanstatic bool isRotateAndMask(SDNode *N, unsigned Mask, bool IsShiftMask, 355cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned &SH, unsigned &MB, unsigned &ME) { 356da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // Don't even go down this path for i64, since different logic will be 357da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // necessary for rldicl/rldicr/rldimi. 358da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman if (N->getValueType(0) != MVT::i32) 359da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman return false; 360da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman 361cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Shift = 32; 362cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Indeterminant = ~0; // bit mask marking indeterminant results 363cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Opcode = N->getOpcode(); 36415055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner if (N->getNumOperands() != 2 || 365c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner !isInt32Immediate(N->getOperand(1).Val, Shift) || (Shift > 31)) 366cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 367cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 368cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Opcode == ISD::SHL) { 369cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift left to mask if it comes first 370cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask << Shift; 371cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 372cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu << Shift); 373651dea74f6a362d30bc61fd0b549da7707af5bf8Chris Lattner } else if (Opcode == ISD::SRL) { 374cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift right to mask if it comes first 375cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask >> Shift; 376cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 377cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu >> Shift); 378cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // adjust for the left rotate 379cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Shift = 32 - Shift; 380cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 381cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 382cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 383cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 384cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // if the mask doesn't intersect any Indeterminant bits 385cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Mask && !(Mask & Indeterminant)) { 3860949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner SH = Shift & 31; 387cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // make sure the mask is still a mask (wrap arounds may not be) 388cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return isRunOfOnes(Mask, MB, ME); 389cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 390cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 391cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 392cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 39302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// SelectBitfieldInsert - turn an or of two masked values into 39402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// the rotate left word immediate then mask insert (rlwimi) instruction. 3951d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDNode *PPCDAGToDAGISel::SelectBitfieldInsert(SDNode *N) { 39602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op0 = N->getOperand(0); 39702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op1 = N->getOperand(1); 39802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 39977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman uint64_t LKZ, LKO, RKZ, RKO; 4004667f2cbad246beccfca5411a26add24d1007035Nate Begeman TLI.ComputeMaskedBits(Op0, 0xFFFFFFFFULL, LKZ, LKO); 4014667f2cbad246beccfca5411a26add24d1007035Nate Begeman TLI.ComputeMaskedBits(Op1, 0xFFFFFFFFULL, RKZ, RKO); 40202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 4034667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned TargetMask = LKZ; 4044667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned InsertMask = RKZ; 4054667f2cbad246beccfca5411a26add24d1007035Nate Begeman 4064667f2cbad246beccfca5411a26add24d1007035Nate Begeman if ((TargetMask | InsertMask) == 0xFFFFFFFF) { 4074667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Op0Opc = Op0.getOpcode(); 4084667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Op1Opc = Op1.getOpcode(); 4094667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Value, SH = 0; 4104667f2cbad246beccfca5411a26add24d1007035Nate Begeman TargetMask = ~TargetMask; 4114667f2cbad246beccfca5411a26add24d1007035Nate Begeman InsertMask = ~InsertMask; 41277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 4134667f2cbad246beccfca5411a26add24d1007035Nate Begeman // If the LHS has a foldable shift and the RHS does not, then swap it to the 4144667f2cbad246beccfca5411a26add24d1007035Nate Begeman // RHS so that we can fold the shift into the insert. 41577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op0Opc == ISD::AND && Op1Opc == ISD::AND) { 41677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op0.getOperand(0).getOpcode() == ISD::SHL || 41777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op0.getOperand(0).getOpcode() == ISD::SRL) { 41877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op1.getOperand(0).getOpcode() != ISD::SHL && 41977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1.getOperand(0).getOpcode() != ISD::SRL) { 42077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman std::swap(Op0, Op1); 42177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman std::swap(Op0Opc, Op1Opc); 4224667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(TargetMask, InsertMask); 42377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 42477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 4254667f2cbad246beccfca5411a26add24d1007035Nate Begeman } else if (Op0Opc == ISD::SHL || Op0Opc == ISD::SRL) { 4264667f2cbad246beccfca5411a26add24d1007035Nate Begeman if (Op1Opc == ISD::AND && Op1.getOperand(0).getOpcode() != ISD::SHL && 4274667f2cbad246beccfca5411a26add24d1007035Nate Begeman Op1.getOperand(0).getOpcode() != ISD::SRL) { 4284667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(Op0, Op1); 4294667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(Op0Opc, Op1Opc); 4304667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(TargetMask, InsertMask); 4314667f2cbad246beccfca5411a26add24d1007035Nate Begeman } 43202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 43377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 43477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman unsigned MB, ME; 4350949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner if (InsertMask && isRunOfOnes(InsertMask, MB, ME)) { 43677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SDOperand Tmp1, Tmp2, Tmp3; 4374667f2cbad246beccfca5411a26add24d1007035Nate Begeman bool DisjointMask = (TargetMask ^ InsertMask) == 0xFFFFFFFF; 43877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 43977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if ((Op1Opc == ISD::SHL || Op1Opc == ISD::SRL) && 440c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(Op1.getOperand(1), Value)) { 44177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0); 44277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SH = (Op1Opc == ISD::SHL) ? Value : 32 - Value; 44302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 44477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op1Opc == ISD::AND) { 44577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman unsigned SHOpc = Op1.getOperand(0).getOpcode(); 44677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if ((SHOpc == ISD::SHL || SHOpc == ISD::SRL) && 447c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(Op1.getOperand(0).getOperand(1), Value)) { 44877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0).getOperand(0); 44977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SH = (SHOpc == ISD::SHL) ? Value : 32 - Value; 45077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } else { 45177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0); 45277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 45302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 45477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 45577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Tmp3 = (Op0Opc == ISD::AND && DisjointMask) ? Op0.getOperand(0) : Op0; 4562ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Tmp1, Tmp3); 4572ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Tmp2, Op1); 4580949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner SH &= 31; 45977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman return CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, Tmp1, Tmp2, 46077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman getI32Imm(SH), getI32Imm(MB), getI32Imm(ME)); 46102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 46202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 46302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 46402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman} 46502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 4667fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrImm - Returns true if the address N can be represented by 4677fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// a base register plus a signed 16-bit displacement [r+imm]. 4687fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrImm(SDOperand N, SDOperand &Disp, 4697fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Base) { 4700f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If this can be more profitably realized as r+r, fail. 4710f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (SelectAddrIdx(N, Disp, Base)) 4720f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; 4730f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 4747fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (N.getOpcode() == ISD::ADD) { 475c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short imm = 0; 476c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(N.getOperand(1), imm)) { 477c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Disp = getI32Imm((int)imm & 0xFFFF); 4787fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0))) { 479c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Base = CurDAG->getTargetFrameIndex(FI->getIndex(), N.getValueType()); 4809944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } else { 4817564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N.getOperand(0); 4829944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4837fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [r+i] 4847fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman } else if (N.getOperand(1).getOpcode() == PPCISD::Lo) { 4854f0f86de5f183b09d07b17d1f940bd3e298abfcdChris Lattner // Match LOAD (ADD (X, Lo(G))). 4867fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman assert(!cast<ConstantSDNode>(N.getOperand(1).getOperand(1))->getValue() 4874f0f86de5f183b09d07b17d1f940bd3e298abfcdChris Lattner && "Cannot handle constant offsets yet!"); 4887fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman Disp = N.getOperand(1).getOperand(0); // The global address. 4897fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman assert(Disp.getOpcode() == ISD::TargetGlobalAddress || 49037efe6764568a3829fee26aba532283131d1a104Nate Begeman Disp.getOpcode() == ISD::TargetConstantPool || 49137efe6764568a3829fee26aba532283131d1a104Nate Begeman Disp.getOpcode() == ISD::TargetJumpTable); 4927564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N.getOperand(0); 4937fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [&g+r] 4949944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 4950f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } else if (N.getOpcode() == ISD::OR) { 496c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short imm = 0; 497c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(N.getOperand(1), imm)) { 4980f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If this is an or of disjoint bitfields, we can codegen this as an add 4990f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // (for better address arithmetic) if the LHS and RHS of the OR are 5000f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // provably disjoint. 5010f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner uint64_t LHSKnownZero, LHSKnownOne; 5020f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(0), ~0U, 5030f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner LHSKnownZero, LHSKnownOne); 504c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if ((LHSKnownZero|~(unsigned)imm) == ~0U) { 5050f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If all of the bits are known zero on the LHS or RHS, the add won't 5060f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // carry. 5070f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Base = N.getOperand(0); 508c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Disp = getI32Imm((int)imm & 0xFFFF); 5090f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return true; 5100f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 5110f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 512d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner } else if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 513d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // Loading from a constant address. 514c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 515d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // If this address fits entirely in a 16-bit sext immediate field, codegen 516d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner // this as "d, 0" 517c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short Imm; 518c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(CN, Imm)) { 519c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Disp = CurDAG->getTargetConstant(Imm, CN->getValueType(0)); 520c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Base = CurDAG->getRegister(PPC::R0, CN->getValueType(0)); 521d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner return true; 522d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner } 523c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 524c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner // FIXME: Handle small sext constant offsets in PPC64 mode also! 525c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (CN->getValueType(0) == MVT::i32) { 526c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner int Addr = (int)CN->getValue(); 527d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner 528c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner // Otherwise, break this down into an LIS + disp. 529c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Disp = getI32Imm((short)Addr); 530c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Base = CurDAG->getConstant(Addr - (signed short)Addr, MVT::i32); 531c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return true; 532c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 5339944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner } 534d97964457e972cc0c0ae0e293f975112c3d65c46Chris Lattner 535c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Disp = getSmallIPtrImm(0); 5367fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N)) 537c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Base = CurDAG->getTargetFrameIndex(FI->getIndex(), N.getValueType()); 53828a6b02626c29b1fe9bb16c14c193549fab4cab8Nate Begeman else 5397564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N; 5407fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; // [r+0] 5419944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner} 542a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 5437fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrIdx - Given the specified addressed, check to see if it can be 5447fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// represented as an indexed [r+r] operation. Returns false if it can 5457fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// be represented by [r+imm], which are preferred. 5467fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrIdx(SDOperand N, SDOperand &Base, 5477fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Index) { 548c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short imm = 0; 5497fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman if (N.getOpcode() == ISD::ADD) { 550c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(N.getOperand(1), imm)) 5510f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; // r+i 5520f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (N.getOperand(1).getOpcode() == PPCISD::Lo) 5530f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; // r+i 5540f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5557564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Base = N.getOperand(0); 5567564e0b46d68abbd43a9910882568f4f9875af50Evan Cheng Index = N.getOperand(1); 5577fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; 5580f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } else if (N.getOpcode() == ISD::OR) { 559c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(N.getOperand(1), imm)) 5600f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; // r+i can fold it if we can. 5610f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5620f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If this is an or of disjoint bitfields, we can codegen this as an add 5630f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // (for better address arithmetic) if the LHS and RHS of the OR are provably 5640f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // disjoint. 5650f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner uint64_t LHSKnownZero, LHSKnownOne; 5660f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner uint64_t RHSKnownZero, RHSKnownOne; 5670f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(0), ~0U, 5680f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner LHSKnownZero, LHSKnownOne); 5690f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5700f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if (LHSKnownZero) { 5710f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(1), ~0U, 5720f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner RHSKnownZero, RHSKnownOne); 5730f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // If all of the bits are known zero on the LHS or RHS, the add won't 5740f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // carry. 5750f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner if ((LHSKnownZero | RHSKnownZero) == ~0U) { 5760f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Base = N.getOperand(0); 5770f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner Index = N.getOperand(1); 5780f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return true; 5790f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 5800f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner } 5817fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman } 5820f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner 5830f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner return false; 5847fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman} 5857fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman 5867fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// SelectAddrIdxOnly - Given the specified addressed, force it to be 5877fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman/// represented as an indexed [r+r] operation. 5887fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begemanbool PPCDAGToDAGISel::SelectAddrIdxOnly(SDOperand N, SDOperand &Base, 5897fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman SDOperand &Index) { 5900f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // Check to see if we can easily represent this as an [r+r] address. This 5910f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // will fail if it thinks that the address is more profitably represented as 5920f6ab6ff97decd0150a7cdeda600216cd050d18aChris Lattner // reg+imm, e.g. where imm = 0. 59354e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner if (SelectAddrIdx(N, Base, Index)) 59454e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner return true; 59554e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner 59654e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // If the operand is an addition, always emit this as [r+r], since this is 59754e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // better (for code size, and execution, as the memop does the add for free) 59854e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // than emitting an explicit add. 59954e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner if (N.getOpcode() == ISD::ADD) { 60054e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Base = N.getOperand(0); 60154e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Index = N.getOperand(1); 60254e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner return true; 603f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman } 60454e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner 60554e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner // Otherwise, do it the hard way, using R0 as the base register. 606c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Base = CurDAG->getRegister(PPC::R0, N.getValueType()); 60754e869e18cd3d7c6ea6e2bce668c961b6f46f0eaChris Lattner Index = N; 6087fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman return true; 609f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman} 610f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman 611e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner/// SelectAddrImmShift - Returns true if the address N can be represented by 612e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner/// a base register plus a signed 14-bit displacement [r+imm*4]. Suitable 613e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner/// for use by STD and friends. 614e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattnerbool PPCDAGToDAGISel::SelectAddrImmShift(SDOperand N, SDOperand &Disp, 615e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner SDOperand &Base) { 616e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If this can be more profitably realized as r+r, fail. 617e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (SelectAddrIdx(N, Disp, Base)) 618e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return false; 619e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 620e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (N.getOpcode() == ISD::ADD) { 621c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short imm = 0; 622c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(N.getOperand(1), imm) && (imm & 3) == 0) { 623c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Disp = getI32Imm(((int)imm & 0xFFFF) >> 2); 624e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0))) { 625c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Base = CurDAG->getTargetFrameIndex(FI->getIndex(), N.getValueType()); 626e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else { 627e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N.getOperand(0); 628e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 629e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; // [r+i] 630e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else if (N.getOperand(1).getOpcode() == PPCISD::Lo) { 631e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // Match LOAD (ADD (X, Lo(G))). 632e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner assert(!cast<ConstantSDNode>(N.getOperand(1).getOperand(1))->getValue() 633e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner && "Cannot handle constant offsets yet!"); 634e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = N.getOperand(1).getOperand(0); // The global address. 635e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner assert(Disp.getOpcode() == ISD::TargetGlobalAddress || 63637efe6764568a3829fee26aba532283131d1a104Nate Begeman Disp.getOpcode() == ISD::TargetConstantPool || 63737efe6764568a3829fee26aba532283131d1a104Nate Begeman Disp.getOpcode() == ISD::TargetJumpTable); 638e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N.getOperand(0); 639e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; // [&g+r] 640e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 641e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else if (N.getOpcode() == ISD::OR) { 642c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short imm = 0; 643c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(N.getOperand(1), imm) && (imm & 3) == 0) { 644e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If this is an or of disjoint bitfields, we can codegen this as an add 645e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // (for better address arithmetic) if the LHS and RHS of the OR are 646e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // provably disjoint. 647e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner uint64_t LHSKnownZero, LHSKnownOne; 648e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner PPCLowering.ComputeMaskedBits(N.getOperand(0), ~0U, 649e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner LHSKnownZero, LHSKnownOne); 650c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if ((LHSKnownZero|~(unsigned)imm) == ~0U) { 651e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // If all of the bits are known zero on the LHS or RHS, the add won't 652e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // carry. 653e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N.getOperand(0); 654c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Disp = getI32Imm(((int)imm & 0xFFFF) >> 2); 655e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; 656e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 657e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 658e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } else if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) { 659e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // Loading from a constant address. 660c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 661c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner // If this address fits entirely in a 14-bit sext immediate field, codegen 662c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner // this as "d, 0" 663c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short Imm; 664c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(CN, Imm)) { 665c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Disp = getSmallIPtrImm((unsigned short)Imm >> 2); 666c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Base = CurDAG->getRegister(PPC::R0, CN->getValueType(0)); 667c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return true; 668c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 669c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 670c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner // FIXME: Handle small sext constant offsets in PPC64 mode also! 671c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (CN->getValueType(0) == MVT::i32) { 672c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner int Addr = (int)CN->getValue(); 673e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 674e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner // Otherwise, break this down into an LIS + disp. 675e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Disp = getI32Imm((short)Addr >> 2); 676e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = CurDAG->getConstant(Addr - (signed short)Addr, MVT::i32); 677e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; 678e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 679e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner } 680e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 681c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Disp = getSmallIPtrImm(0); 682e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N)) 683c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Base = CurDAG->getTargetFrameIndex(FI->getIndex(), N.getValueType()); 684e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner else 685e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner Base = N; 686e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner return true; // [r+0] 687e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner} 688e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 689e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner 6902fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// SelectCC - Select a comparison of the specified values with the specified 6912fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// condition code, returning the CR# of the expression. 6921d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectCC(SDOperand LHS, SDOperand RHS, 6931d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman ISD::CondCode CC) { 6942fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Always select the LHS. 6952ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(LHS, LHS); 696c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner unsigned Opc; 697c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 698c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (LHS.getValueType() == MVT::i32) { 699529c233498c59a544b26b277f8fe30e6a80cc6f8Chris Lattner unsigned Imm; 700c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (ISD::isUnsignedIntSetCC(CC)) { 701c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(RHS, Imm) && isUInt16(Imm)) 702c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return SDOperand(CurDAG->getTargetNode(PPC::CMPLWI, MVT::i32, LHS, 703c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner getI32Imm(Imm & 0xFFFF)), 0); 704c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPLW; 705c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } else { 706c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short SImm; 707c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(RHS, SImm)) 708c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return SDOperand(CurDAG->getTargetNode(PPC::CMPWI, MVT::i32, LHS, 709c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner getI32Imm((int)SImm & 0xFFFF)), 710c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 0); 711c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPW; 712c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 713c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } else if (LHS.getValueType() == MVT::i64) { 714c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner uint64_t Imm; 715c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (ISD::isUnsignedIntSetCC(CC)) { 716c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt64Immediate(RHS.Val, Imm) && isUInt16(Imm)) 717c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return SDOperand(CurDAG->getTargetNode(PPC::CMPLDI, MVT::i64, LHS, 718c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner getI64Imm(Imm & 0xFFFF)), 0); 719c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPLD; 720c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } else { 721c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short SImm; 722c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(RHS, SImm)) 723c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return SDOperand(CurDAG->getTargetNode(PPC::CMPDI, MVT::i64, LHS, 724c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner getI64Imm((int)SImm & 0xFFFF)), 725c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 0); 726c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPD; 727c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 728919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner } else if (LHS.getValueType() == MVT::f32) { 729c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::FCMPUS; 7302fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 731c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner assert(LHS.getValueType() == MVT::f64 && "Unknown vt!"); 732c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::FCMPUD; 7332fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 7342ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(RHS, RHS); 735c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return SDOperand(CurDAG->getTargetNode(Opc, MVT::i32, LHS, RHS), 0); 7362fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 7372fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 7382fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// getBCCForSetCC - Returns the PowerPC condition branch mnemonic corresponding 7392fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// to Condition. 7402fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattnerstatic unsigned getBCCForSetCC(ISD::CondCode CC) { 7412fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner switch (CC) { 7422fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 743ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOEQ: // FIXME: This is incorrect see PR642. 7445d634ce466173f6fde49470fad125eb09532caebChris Lattner case ISD::SETUEQ: 7452fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETEQ: return PPC::BEQ; 746ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETONE: // FIXME: This is incorrect see PR642. 7475d634ce466173f6fde49470fad125eb09532caebChris Lattner case ISD::SETUNE: 7482fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETNE: return PPC::BNE; 749ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLT: // FIXME: This is incorrect see PR642. 7502fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULT: 7512fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLT: return PPC::BLT; 752ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLE: // FIXME: This is incorrect see PR642. 7532fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULE: 7542fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETLE: return PPC::BLE; 755ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGT: // FIXME: This is incorrect see PR642. 7562fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGT: 7572fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGT: return PPC::BGT; 758ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGE: // FIXME: This is incorrect see PR642. 7592fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGE: 7602fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETGE: return PPC::BGE; 7616df2507121507c24d7155605c343e467e0106c07Chris Lattner 7626df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETO: return PPC::BUN; 7636df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETUO: return PPC::BNU; 7642fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 7652fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner return 0; 7662fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 7672fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 76864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// getCRIdxForSetCC - Return the index of the condition register field 76964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// associated with the SetCC condition, and whether or not the field is 77064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// treated as inverted. That is, lt = 0; ge = 0 inverted. 77164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattnerstatic unsigned getCRIdxForSetCC(ISD::CondCode CC, bool& Inv) { 77264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 77364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 774ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLT: // FIXME: This is incorrect see PR642. 77564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULT: 77664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLT: Inv = false; return 0; 777ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGE: // FIXME: This is incorrect see PR642. 77864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGE: 77964906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGE: Inv = true; return 0; 780ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGT: // FIXME: This is incorrect see PR642. 78164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGT: 78264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETGT: Inv = false; return 1; 783ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLE: // FIXME: This is incorrect see PR642. 78464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULE: 78564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETLE: Inv = true; return 1; 786ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOEQ: // FIXME: This is incorrect see PR642. 7878e2a04e21dc8299bdaba4321a6e690712dab9617Chris Lattner case ISD::SETUEQ: 78864906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETEQ: Inv = false; return 2; 789ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETONE: // FIXME: This is incorrect see PR642. 7908e2a04e21dc8299bdaba4321a6e690712dab9617Chris Lattner case ISD::SETUNE: 79164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETNE: Inv = true; return 2; 7926df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETO: Inv = true; return 3; 7936df2507121507c24d7155605c343e467e0106c07Chris Lattner case ISD::SETUO: Inv = false; return 3; 79464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 79564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner return 0; 79664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner} 7979944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 7981d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectSETCC(SDOperand Op) { 799222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDNode *N = Op.Val; 800222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Imm; 801222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get(); 802c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm)) { 803222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // We can codegen setcc op, imm very efficiently compared to a brcond. 804222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Check for those cases here. 805222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // setcc op, 0 806222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (Imm == 0) { 80734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Op; 8082ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Op, N->getOperand(0)); 809222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 810dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 811dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETEQ: 8127e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::CNTLZW, MVT::i32, Op), 0); 81371d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Op, getI32Imm(27), 81471d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(5), getI32Imm(31)); 815dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 8167e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AD = 8177e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 8187e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(~0U)), 0); 81971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, 82071d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner AD.getValue(1)); 821dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 822dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETLT: 82371d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Op, getI32Imm(1), 82471d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 825dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETGT: { 8267e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand T = 8277e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::NEG, MVT::i32, Op), 0); 8287e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng T = SDOperand(CurDAG->getTargetNode(PPC::ANDC, MVT::i32, T, Op), 0); 82971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, T, getI32Imm(1), 83071d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 831dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 832222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 833222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else if (Imm == ~0U) { // setcc op, -1 83434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Op; 8352ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Op, N->getOperand(0)); 836222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 837dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 838dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETEQ: 8397e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 8407e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(1)), 0); 84171d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 8427e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::LI, MVT::i32, 8437e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(0)), 0), 84471d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner Op.getValue(1)); 845dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 8467e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::NOR, MVT::i32, Op, Op), 0); 8477e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *AD = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 8487e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(~0U)); 849c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, SDOperand(AD, 0), 850c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner Op, SDOperand(AD, 1)); 851dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 852dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETLT: { 8537e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AD = SDOperand(CurDAG->getTargetNode(PPC::ADDI, MVT::i32, Op, 8547e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(1)), 0); 8557e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AN = SDOperand(CurDAG->getTargetNode(PPC::AND, MVT::i32, AD, 8567e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op), 0); 85771d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, AN, getI32Imm(1), 85871d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 859dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 860dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETGT: 8617e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Op, 8627e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(1), getI32Imm(31), 8637e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(31)), 0); 86471d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Op, getI32Imm(1)); 865222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 866222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 867222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 868222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 869222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner bool Inv; 870222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Idx = getCRIdxForSetCC(CC, Inv); 871222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 872222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand IntCR; 873222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 874222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Force the ccreg into CR7. 875222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand CR7Reg = CurDAG->getRegister(PPC::CR7, MVT::i32); 876222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 87785961d5ec126bbc0c111d52dd7361d5159265ca5Chris Lattner SDOperand InFlag(0, 0); // Null incoming flag value. 878db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner CCReg = CurDAG->getCopyToReg(CurDAG->getEntryNode(), CR7Reg, CCReg, 879db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner InFlag).getValue(1); 880222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 881222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (TLI.getTargetMachine().getSubtarget<PPCSubtarget>().isGigaProcessor()) 8827e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng IntCR = SDOperand(CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, CR7Reg, 8837e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng CCReg), 0); 884222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner else 8857e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng IntCR = SDOperand(CurDAG->getTargetNode(PPC::MFCR, MVT::i32, CCReg), 0); 886222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 887222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (!Inv) { 88871d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, IntCR, 88971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm((32-(3-Idx)) & 31), 89071d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner getI32Imm(31), getI32Imm(31)); 891222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else { 892222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand Tmp = 8937e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, IntCR, 8947e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm((32-(3-Idx)) & 31), 8957e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(31),getI32Imm(31)), 0); 89671d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Tmp, getI32Imm(1)); 897222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 898222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner} 8992b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 9006a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 901a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Select - Convert the specified operand from a target-independent to a 902a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// target-specific node if it hasn't already been changed. 90364a752f7c7cf160f2887d0a16d5922359832c9c2Evan ChengSDNode *PPCDAGToDAGISel::Select(SDOperand &Result, SDOperand Op) { 904a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDNode *N = Op.Val; 9050bbea954331b8f08afa5b094dfb0841829c70eaaChris Lattner if (N->getOpcode() >= ISD::BUILTIN_OP_END && 90634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N->getOpcode() < PPCISD::FIRST_NUMBER) { 90734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = Op; 90864a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; // Already selected. 90934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng } 910d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 911a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOpcode()) { 91219c0907ba1c11c81dc231cf7b4143fdaf03466e4Chris Lattner default: break; 91334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case ISD::SETCC: 91434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = SelectSETCC(Op); 91564a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; 91634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case PPCISD::GlobalBaseReg: 91734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = getGlobalBaseReg(); 91864a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return Result.Val; 919860e8862c1fbd3b261da4a64a8c0096f9f373681Chris Lattner 920e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner case ISD::FrameIndex: { 921e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner int FI = cast<FrameIndexSDNode>(N)->getIndex(); 922c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner SDOperand TFI = CurDAG->getTargetFrameIndex(FI, Op.getValueType()); 923c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner unsigned Opc = Op.getValueType() == MVT::i32 ? PPC::ADDI : PPC::ADDI8; 92434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng if (N->hasOneUse()) { 925c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Result = CurDAG->SelectNodeTo(N, Opc, Op.getValueType(), TFI, 926c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner getSmallIPtrImm(0)); 92764a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; 92834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng } 9292ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng Result = 930c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner SDOperand(CurDAG->getTargetNode(Opc, Op.getValueType(), TFI, 931c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner getSmallIPtrImm(0)), 0); 93264a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return Result.Val; 933e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } 9346d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner 9356d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner case PPCISD::MFCR: { 9366d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner SDOperand InFlag; 9372ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(InFlag, N->getOperand(1)); 9386d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner // Use MFOCRF if supported. 9396d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner if (TLI.getTargetMachine().getSubtarget<PPCSubtarget>().isGigaProcessor()) 9406d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner Result = SDOperand(CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, 9416d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner N->getOperand(0), InFlag), 0); 9426d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner else 9436d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner Result = SDOperand(CurDAG->getTargetNode(PPC::MFCR, MVT::i32, InFlag), 0); 94464a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return Result.Val; 9456d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner } 9466d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner 94788add100b3db715df4275c8ab408e6b51f28ff8fChris Lattner case ISD::SDIV: { 948405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: since this depends on the setting of the carry flag from the srawi 949405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // we should really be making notes about that for the scheduler. 950405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: It sure would be nice if we could cheaply recognize the 951405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // srl/add/sra pattern the dag combiner will generate for this as 952405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // sra/addze rather than having to handle sdiv ourselves. oh well. 9538784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner unsigned Imm; 954c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm)) { 95534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand N0; 9562ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(N0, N->getOperand(0)); 9578784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if ((signed)Imm > 0 && isPowerOf2_32(Imm)) { 9587e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 9598784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 96034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N0, getI32Imm(Log2_32(Imm))); 96134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 9627e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Op, 0), SDOperand(Op, 1)); 9638784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } else if ((signed)Imm < 0 && isPowerOf2_32(-Imm)) { 9647e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 9652501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 96634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N0, getI32Imm(Log2_32(-Imm))); 9678784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand PT = 9687e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, 9697e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Op, 0), SDOperand(Op, 1)), 9707e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng 0); 97134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::NEG, MVT::i32, PT); 9728784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 97364a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; 9748784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 975047b952e298352fe6feffedf02e359601133f465Chris Lattner 976237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 977237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 978047b952e298352fe6feffedf02e359601133f465Chris Lattner } 979cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman case ISD::AND: { 98050fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman unsigned Imm, Imm2; 981cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and of a value rotated between 0 and 31 bits and then and'd 982cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // with a mask, emit rlwinm 983c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm) && 984c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner (isShiftedMask_32(Imm) || isShiftedMask_32(~Imm))) { 985cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SDOperand Val; 986a69404781344c4aee05935ee921bbf2844911bc0Nate Begeman unsigned SH, MB, ME; 987cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isRotateAndMask(N->getOperand(0).Val, Imm, false, SH, MB, ME)) { 9882ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Val, N->getOperand(0).getOperand(0)); 9893393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner } else if (Imm == 0) { 9903393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner // AND X, 0 -> 0, not "rlwinm 32". 9912ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Result, N->getOperand(1)); 99264a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; 9933393e80a06bbbfd9988deafae20c614ebbd5b8e6Chris Lattner } else { 9942ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Val, N->getOperand(0)); 995cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman isRunOfOnes(Imm, MB, ME); 996cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman SH = 0; 997cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 99834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Val, 99934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(SH), getI32Imm(MB), 100034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(ME)); 100164a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; 1002cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 100350fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // ISD::OR doesn't get all the bitfield insertion fun. 100450fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // (and (or x, c1), c2) where isRunOfOnes(~(c1^c2)) is a bitfield insert 1005c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm) && 100650fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman N->getOperand(0).getOpcode() == ISD::OR && 1007c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(N->getOperand(0).getOperand(1), Imm2)) { 1008c9a5ef524a9f461717bbf647b2d3da061aed720dChris Lattner unsigned MB, ME; 100950fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman Imm = ~(Imm^Imm2); 101050fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman if (isRunOfOnes(Imm, MB, ME)) { 101134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Tmp1, Tmp2; 10122ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Tmp1, N->getOperand(0).getOperand(0)); 10132ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Tmp2, N->getOperand(0).getOperand(1)); 10147e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Result = SDOperand(CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, 10157e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Tmp1, Tmp2, 10167e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(0), getI32Imm(MB), 10177e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(ME)), 0); 101864a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return Result.Val; 101950fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 102050fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 1021237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner 1022237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1023237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1024cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 102502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::OR: 1026cccef1c6fffa292c227a289d447f6b848ab56c62Chris Lattner if (N->getValueType(0) == MVT::i32) 1027cccef1c6fffa292c227a289d447f6b848ab56c62Chris Lattner if (SDNode *I = SelectBitfieldInsert(N)) { 10282ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng Result = SDOperand(I, 0); 102964a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return Result.Val; 1030cccef1c6fffa292c227a289d447f6b848ab56c62Chris Lattner } 1031d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 1032237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1033237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1034c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SHL: { 1035c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1036c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 10372d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 103834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Val; 10392ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Val, N->getOperand(0).getOperand(0)); 104034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 104134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Val, getI32Imm(SH), getI32Imm(MB), 104234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(ME)); 104364a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; 10448d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 10452d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 10462d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 10472d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1048c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 1049c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRL: { 1050c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1051c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 10522d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 105334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Val; 10542ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Val, N->getOperand(0).getOperand(0)); 105534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, 10560949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner Val, getI32Imm(SH), getI32Imm(MB), 105734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng getI32Imm(ME)); 105864a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; 10598d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 10602d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 10612d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 10622d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1063c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 106413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner case ISD::SELECT_CC: { 106513794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(4))->get(); 106613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner 1067c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner // Handle the setcc cases here. select_cc lhs, 0, 1, 0, cc 106813794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N->getOperand(1))) 106913794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N->getOperand(2))) 107013794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N->getOperand(3))) 107113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (N1C->isNullValue() && N3C->isNullValue() && 1072c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner N2C->getValue() == 1ULL && CC == ISD::SETNE && 1073c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner // FIXME: Implement this optzn for PPC64. 1074c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner N->getValueType(0) == MVT::i32) { 107534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand LHS; 10762ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(LHS, N->getOperand(0)); 10777e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Tmp = 107813794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 107913794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner LHS, getI32Imm(~0U)); 10807e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Result = CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, 10817e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Tmp, 0), LHS, 10827e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Tmp, 1)); 108364a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; 108413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 10858a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 108650ff55c2c7909818165e51bbdc103a05b143dcb1Chris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 10878a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner unsigned BROpc = getBCCForSetCC(CC); 10888a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 10898a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner bool isFP = MVT::isFloatingPoint(N->getValueType(0)); 1090919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner unsigned SelectCCOp; 1091c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getValueType(0) == MVT::i32) 1092c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner SelectCCOp = PPC::SELECT_CC_I4; 1093c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner else if (N->getValueType(0) == MVT::i64) 1094c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner SelectCCOp = PPC::SELECT_CC_I8; 1095919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else if (N->getValueType(0) == MVT::f32) 1096919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F4; 1097710ff32983ca919fa0da14e077450b6a7654274fChris Lattner else if (N->getValueType(0) == MVT::f64) 1098919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F8; 1099710ff32983ca919fa0da14e077450b6a7654274fChris Lattner else 1100710ff32983ca919fa0da14e077450b6a7654274fChris Lattner SelectCCOp = PPC::SELECT_CC_VRRC; 1101710ff32983ca919fa0da14e077450b6a7654274fChris Lattner 110234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand N2, N3; 11032ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(N2, N->getOperand(2)); 11042ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(N3, N->getOperand(3)); 110534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng Result = CurDAG->SelectNodeTo(N, SelectCCOp, N->getValueType(0), CCReg, 110634167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N2, N3, getI32Imm(BROpc)); 110764a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; 110813794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 110981e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman case ISD::BR_CC: { 111034167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng SDOperand Chain; 11112ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Chain, N->getOperand(0)); 11122fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(1))->get(); 11132fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CondCode = SelectCC(N->getOperand(2), N->getOperand(3), CC); 111481e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman Result = CurDAG->SelectNodeTo(N, PPC::COND_BRANCH, MVT::Other, 111581e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman CondCode, getI32Imm(getBCCForSetCC(CC)), 111681e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman N->getOperand(4), Chain); 111764a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; 11182fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 111937efe6764568a3829fee26aba532283131d1a104Nate Begeman case ISD::BRIND: { 1120cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // FIXME: Should custom lower this. 112137efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand Chain, Target; 11222ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Chain, N->getOperand(0)); 11232ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Target,N->getOperand(1)); 11246b76b96c69334f3b6a2a895ff810ed047b4b75e5Chris Lattner unsigned Opc = Target.getValueType() == MVT::i32 ? PPC::MTCTR : PPC::MTCTR8; 11256b76b96c69334f3b6a2a895ff810ed047b4b75e5Chris Lattner Chain = SDOperand(CurDAG->getTargetNode(Opc, MVT::Other, Target, 112637efe6764568a3829fee26aba532283131d1a104Nate Begeman Chain), 0); 112737efe6764568a3829fee26aba532283131d1a104Nate Begeman Result = CurDAG->SelectNodeTo(N, PPC::BCTR, MVT::Other, Chain); 112864a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; 112937efe6764568a3829fee26aba532283131d1a104Nate Begeman } 1130cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // FIXME: These are manually selected because tblgen isn't handling varargs 1131cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // nodes correctly. 113264a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng case PPCISD::BCTRL: return MySelect_PPCbctrl(Result, Op); 113364a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng case PPCISD::CALL: return MySelect_PPCcall(Result, Op); 1134a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 113525dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner 113664a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return SelectCode(Result, Op); 1137a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1138a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1139a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1140cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner// FIXME: This is manually selected because tblgen isn't handling varargs nodes 1141cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner// correctly. 114264a752f7c7cf160f2887d0a16d5922359832c9c2Evan ChengSDNode *PPCDAGToDAGISel::MySelect_PPCbctrl(SDOperand &Result, SDOperand N) { 1143cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner SDOperand Chain(0, 0); 1144cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner SDNode *ResNode; 1145cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1146cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner bool hasFlag = 1147cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag; 1148cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1149bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 1150cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // Push varargs arguments, including optional flag. 1151cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner for (unsigned i = 1, e = N.getNumOperands()-hasFlag; i != e; ++i) { 11522ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Chain, N.getOperand(i)); 1153cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(Chain); 1154cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner } 1155cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 11562ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Chain, N.getOperand(0)); 1157cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(Chain); 1158cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1159cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner if (hasFlag) { 11602ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Chain, N.getOperand(N.getNumOperands()-1)); 1161cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(Chain); 1162cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner } 1163cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1164bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner ResNode = CurDAG->getTargetNode(PPC::BCTRL, MVT::Other, MVT::Flag, 1165bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Ops[0], Ops.size()); 1166cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Result = SDOperand(ResNode, N.ResNo); 116764a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return ResNode; 1168cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner} 1169cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1170cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner// FIXME: This is manually selected because tblgen isn't handling varargs nodes 1171cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner// correctly. 117264a752f7c7cf160f2887d0a16d5922359832c9c2Evan ChengSDNode *PPCDAGToDAGISel::MySelect_PPCcall(SDOperand &Result, SDOperand N) { 1173cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner SDOperand Chain(0, 0); 1174cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner SDOperand N1(0, 0); 1175cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner SDOperand Tmp0(0, 0); 1176cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner SDNode *ResNode; 1177cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Chain = N.getOperand(0); 1178cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner N1 = N.getOperand(1); 1179cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1180cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // Pattern: (PPCcall:void (imm:i32):$func) 1181cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // Emits: (BLA:void (imm:i32):$func) 1182cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // Pattern complexity = 4 cost = 1 1183cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner if (N1.getOpcode() == ISD::Constant) { 1184cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 1185cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1186bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 1187cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(CurDAG->getTargetConstant(Tmp0C, MVT::i32)); 1188cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1189cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner bool hasFlag = 1190cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag; 1191cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1192cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // Push varargs arguments, not including optional flag. 1193cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner for (unsigned i = 2, e = N.getNumOperands()-hasFlag; i != e; ++i) { 11942ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Chain, N.getOperand(i)); 1195cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(Chain); 1196cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner } 11972ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Chain, N.getOperand(0)); 1198cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(Chain); 1199cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner if (hasFlag) { 12002ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Chain, N.getOperand(N.getNumOperands()-1)); 1201cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(Chain); 1202cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner } 1203bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner ResNode = CurDAG->getTargetNode(PPC::BLA, MVT::Other, MVT::Flag, 1204bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Ops[0], Ops.size()); 1205cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1206cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Result = SDOperand(ResNode, N.ResNo); 120764a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return ResNode; 1208cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner } 1209cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1210cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // Pattern: (PPCcall:void (tglobaladdr:i32):$dst) 1211cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // Emits: (BL:void (tglobaladdr:i32):$dst) 1212cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // Pattern complexity = 4 cost = 1 1213cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner if (N1.getOpcode() == ISD::TargetGlobalAddress) { 1214bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 1215cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(N1); 1216cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1217cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner bool hasFlag = 1218cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag; 1219cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1220cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // Push varargs arguments, not including optional flag. 1221cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner for (unsigned i = 2, e = N.getNumOperands()-hasFlag; i != e; ++i) { 12222ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Chain, N.getOperand(i)); 1223cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(Chain); 1224cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner } 12252ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Chain, N.getOperand(0)); 1226cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(Chain); 1227cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner if (hasFlag) { 12282ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Chain, N.getOperand(N.getNumOperands()-1)); 1229cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(Chain); 1230cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner } 1231cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1232bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner ResNode = CurDAG->getTargetNode(PPC::BL, MVT::Other, MVT::Flag, 1233bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Ops[0], Ops.size()); 1234cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1235cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Result = SDOperand(ResNode, N.ResNo); 123664a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return ResNode; 1237cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner } 1238cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1239cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // Pattern: (PPCcall:void (texternalsym:i32):$dst) 1240cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // Emits: (BL:void (texternalsym:i32):$dst) 1241cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // Pattern complexity = 4 cost = 1 1242cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner if (N1.getOpcode() == ISD::TargetExternalSymbol) { 1243cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner std::vector<SDOperand> Ops; 1244cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(N1); 1245cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1246cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner bool hasFlag = 1247cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag; 1248cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1249cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // Push varargs arguments, not including optional flag. 1250cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner for (unsigned i = 2, e = N.getNumOperands()-hasFlag; i != e; ++i) { 12512ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Chain, N.getOperand(i)); 1252cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(Chain); 1253cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner } 12542ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Chain, N.getOperand(0)); 1255cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(Chain); 1256cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner if (hasFlag) { 12572ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng AddToQueue(Chain, N.getOperand(N.getNumOperands()-1)); 1258cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Ops.push_back(Chain); 1259cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner } 1260cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1261bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner ResNode = CurDAG->getTargetNode(PPC::BL, MVT::Other, MVT::Flag, 1262bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Ops[0], Ops.size()); 1263cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1264cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner Result = SDOperand(ResNode, N.ResNo); 126564a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return ResNode; 1266cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner } 1267cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner std::cerr << "Cannot yet select: "; 1268cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner N.Val->dump(CurDAG); 1269cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner std::cerr << '\n'; 1270cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner abort(); 127164a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng 127264a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; 1273cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner} 1274cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 1275cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 12761d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman/// createPPCISelDag - This pass converts a legalized DAG into a 1277a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// PowerPC-specific DAG, ready for instruction scheduling. 1278a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// 1279c4c6257c1a154279bf10e9498d46d6c1793dbaa7Evan ChengFunctionPass *llvm::createPPCISelDag(PPCTargetMachine &TM) { 12801d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman return new PPCDAGToDAGISel(TM); 1281a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1282a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1283