PPCISelDAGToDAG.cpp revision ad2afc2a421a0e41603d5eee412d4d8c77e9bc1c
121e463b2bf864671a87ebe386cb100ef9349a540Nate Begeman//===-- PPCISelDAGToDAG.cpp - PPC --pattern matching inst selector --------===// 2a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 3a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// The LLVM Compiler Infrastructure 4a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// 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 1595b2c7da5e83670881270c1cd231a240be0556d9Chris Lattner#define DEBUG_TYPE "ppc-codegen" 162668959b8879097db368aec7d76c455260abc75bChris Lattner#include "PPC.h" 17df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner#include "PPCPredicates.h" 1816e71f2f70811c69c56052dd146324fe20e31db5Chris Lattner#include "PPCTargetMachine.h" 1916e71f2f70811c69c56052dd146324fe20e31db5Chris Lattner#include "PPCISelLowering.h" 20c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner#include "PPCHazardRecognizers.h" 214416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 224416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 23ad2afc2a421a0e41603d5eee412d4d8c77e9bc1cDan Gohman#include "llvm/CodeGen/MachineFunctionAnalysis.h" 2484bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineRegisterInfo.h" 25a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/CodeGen/SelectionDAG.h" 26a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/CodeGen/SelectionDAGISel.h" 27a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Target/TargetOptions.h" 282fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner#include "llvm/Constants.h" 299062d9a55b0b8b473b927d8b020e36990e147a58Chris Lattner#include "llvm/Function.h" 304416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/GlobalValue.h" 31420736dc85c01702bb7bc40495f8a4be5e5f8a6cChris Lattner#include "llvm/Intrinsics.h" 32a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Support/Debug.h" 33a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Support/MathExtras.h" 34a4f0b3a084d120cfc5b5bb06f64b222f5cb72740Chris Lattner#include "llvm/Support/Compiler.h" 35dac237e18209b697a8ba122d0ddd9cad4dfba1f8Torok Edwin#include "llvm/Support/ErrorHandling.h" 36dac237e18209b697a8ba122d0ddd9cad4dfba1f8Torok Edwin#include "llvm/Support/raw_ostream.h" 37a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerusing namespace llvm; 38a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 39a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnernamespace { 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; 46da8ac5fd9130b70b61be61e4819faa8d842d708fDan Gohman PPCTargetLowering &PPCLowering; 47152b7e18748f7e06a93260f22cc9dac8eb3abee2Evan Cheng const PPCSubtarget &PPCSubTarget; 484416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner unsigned GlobalBaseReg; 49a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner public: 501002c0203450620594a85454c6a095ca94b87cb2Dan Gohman explicit PPCDAGToDAGISel(PPCTargetMachine &tm) 5179ce276083ced01256a0eb7d80731e4948ca6e87Dan Gohman : SelectionDAGISel(tm), TM(tm), 52152b7e18748f7e06a93260f22cc9dac8eb3abee2Evan Cheng PPCLowering(*TM.getTargetLowering()), 53152b7e18748f7e06a93260f22cc9dac8eb3abee2Evan Cheng PPCSubTarget(*TM.getSubtargetImpl()) {} 54a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 55ad2afc2a421a0e41603d5eee412d4d8c77e9bc1cDan Gohman virtual bool runOnMachineFunction(MachineFunction &MF) { 564416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Make sure we re-emit a set of the global base reg if necessary 574416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalBaseReg = 0; 58ad2afc2a421a0e41603d5eee412d4d8c77e9bc1cDan Gohman SelectionDAGISel::runOnMachineFunction(MF); 594bb189507281af0da8aff91743b5198acbf2398bChris Lattner 60ad2afc2a421a0e41603d5eee412d4d8c77e9bc1cDan Gohman InsertVRSaveCode(MF); 614bb189507281af0da8aff91743b5198acbf2398bChris Lattner return true; 624416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 634416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 64a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// getI32Imm - Return a target constant with the specified value, of type 65a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// i32. 66475871a144eb604ddaf37503397ba0941442e5fbDan Gohman inline SDValue getI32Imm(unsigned Imm) { 67a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return CurDAG->getTargetConstant(Imm, MVT::i32); 68a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 694416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 70c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// getI64Imm - Return a target constant with the specified value, of type 71c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// i64. 72475871a144eb604ddaf37503397ba0941442e5fbDan Gohman inline SDValue getI64Imm(uint64_t Imm) { 73c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return CurDAG->getTargetConstant(Imm, MVT::i64); 74c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 75c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 76c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// getSmallIPtrImm - Return a target constant of pointer type. 77475871a144eb604ddaf37503397ba0941442e5fbDan Gohman inline SDValue getSmallIPtrImm(unsigned Imm) { 78c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return CurDAG->getTargetConstant(Imm, PPCLowering.getPointerTy()); 79c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 80c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 81f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s 82f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// with any number of 0s on either side. The 1s are allowed to wrap from 83f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// LSB to MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 84f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// 0x0F0F0000 is not, since all 1s are not contiguous. 85f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman static bool isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME); 86f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman 87f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman 88f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// isRotateAndMask - Returns true if Mask and Shift can be folded into a 89f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// rotate and mask opcode and mask operation. 90f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman static bool isRotateAndMask(SDNode *N, unsigned Mask, bool IsShiftMask, 91f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman unsigned &SH, unsigned &MB, unsigned &ME); 92c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 934416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// getGlobalBaseReg - insert code into the entry mbb to materialize the PIC 944416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// base register. Return the virtual register that holds this value. 959ade218533429146731213eacb7e12060e65ff58Evan Cheng SDNode *getGlobalBaseReg(); 96a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 97a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Select - Convert the specified operand from a target-independent to a 98a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // target-specific node if it hasn't already been changed. 99475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDNode *Select(SDValue Op); 100a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 10102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDNode *SelectBitfieldInsert(SDNode *N); 10202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 1032fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// SelectCC - Select a comparison of the specified values with the 1042fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// specified condition code, returning the CR# of the expression. 105f5f5dce897269885754fc79adeb809194da52942Dale Johannesen SDValue SelectCC(SDValue LHS, SDValue RHS, ISD::CondCode CC, DebugLoc dl); 1062fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 1077fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrImm - Returns true if the address N can be represented by 1087fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// a base register plus a signed 16-bit displacement [r+imm]. 109475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool SelectAddrImm(SDValue Op, SDValue N, SDValue &Disp, 110475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Base) { 111fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner return PPCLowering.SelectAddressRegImm(N, Disp, Base, *CurDAG); 112fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner } 11374531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner 11474531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner /// SelectAddrImmOffs - Return true if the operand is valid for a preinc 11574531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner /// immediate field. Because preinc imms have already been validated, just 11674531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner /// accept it. 117475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool SelectAddrImmOffs(SDValue Op, SDValue N, SDValue &Out) const { 11874531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner Out = N; 11974531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner return true; 12074531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner } 1217fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman 1227fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrIdx - Given the specified addressed, check to see if it can be 1237fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// represented as an indexed [r+r] operation. Returns false if it can 1247fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// be represented by [r+imm], which are preferred. 125475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool SelectAddrIdx(SDValue Op, SDValue N, SDValue &Base, 126475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Index) { 127fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner return PPCLowering.SelectAddressRegReg(N, Base, Index, *CurDAG); 128fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner } 129f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman 1307fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrIdxOnly - Given the specified addressed, force it to be 1317fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// represented as an indexed [r+r] operation. 132475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool SelectAddrIdxOnly(SDValue Op, SDValue N, SDValue &Base, 133475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Index) { 134fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner return PPCLowering.SelectAddressRegRegOnly(N, Base, Index, *CurDAG); 135fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner } 1369944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 137e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// SelectAddrImmShift - Returns true if the address N can be represented by 138e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// a base register plus a signed 14-bit displacement [r+imm*4]. Suitable 139e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// for use by STD and friends. 140475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool SelectAddrImmShift(SDValue Op, SDValue N, SDValue &Disp, 141475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Base) { 142fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner return PPCLowering.SelectAddressRegImmShift(N, Disp, Base, *CurDAG); 143fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner } 144fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner 145e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner /// SelectInlineAsmMemoryOperand - Implement addressing mode selection for 146e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner /// inline asm expressions. 147475871a144eb604ddaf37503397ba0941442e5fbDan Gohman virtual bool SelectInlineAsmMemoryOperand(const SDValue &Op, 148e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner char ConstraintCode, 149f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman std::vector<SDValue> &OutOps) { 150475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op0, Op1; 151e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner switch (ConstraintCode) { 152e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner default: return true; 153e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'm': // memory 1540d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng if (!SelectAddrIdx(Op, Op, Op0, Op1)) 1550d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng SelectAddrImm(Op, Op, Op0, Op1); 156e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 157e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'o': // offsetable 1580d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng if (!SelectAddrImm(Op, Op, Op0, Op1)) { 1596da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng Op0 = Op; 160c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Op1 = getSmallIPtrImm(0); 161e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 162e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 163e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'v': // not offsetable 1640d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng SelectAddrIdxOnly(Op, Op, Op0, Op1); 165e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 166e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 167e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner 168e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner OutOps.push_back(Op0); 169e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner OutOps.push_back(Op1); 170e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner return false; 171e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 172e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner 173475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue BuildSDIVSequence(SDNode *N); 174475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue BuildUDIVSequence(SDNode *N); 175047b952e298352fe6feffedf02e359601133f465Chris Lattner 176db8d56b825efeb576d67b9dbe39d736d93306222Evan Cheng /// InstructionSelect - This callback is invoked by 177a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 178f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman virtual void InstructionSelect(); 179bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 180ad2afc2a421a0e41603d5eee412d4d8c77e9bc1cDan Gohman void InsertVRSaveCode(MachineFunction &MF); 1814bb189507281af0da8aff91743b5198acbf2398bChris Lattner 182a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner virtual const char *getPassName() const { 183a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return "PowerPC DAG->DAG Pattern Instruction Selection"; 184a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 185c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner 186c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner /// CreateTargetHazardRecognizer - Return the hazard recognizer to use for 187c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner /// this target when scheduling the DAG. 188fc54c552963545a81e4ea38e60460590afb2d5aeDan Gohman virtual ScheduleHazardRecognizer *CreateTargetHazardRecognizer() { 189c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner // Should use subtarget info to pick the right hazard recognizer. For 190c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner // now, always return a PPC970 recognizer. 1916448d91ad1e5497fe2f7015d61b57cb5f3040879Dan Gohman const TargetInstrInfo *II = TM.getInstrInfo(); 19288d211f82304e53694ece666d4a2507b170e4582Chris Lattner assert(II && "No InstrInfo?"); 19388d211f82304e53694ece666d4a2507b170e4582Chris Lattner return new PPCHazardRecognizer970(*II); 194c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner } 195af165385112037cb942e94ea562a67990b7d6220Chris Lattner 196af165385112037cb942e94ea562a67990b7d6220Chris Lattner// Include the pieces autogenerated from the target description. 1974c7b43b43fdf943c7298718e15ab5d6dfe345be7Chris Lattner#include "PPCGenDAGISel.inc" 198bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 199bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattnerprivate: 200475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDNode *SelectSETCC(SDValue Op); 201a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner }; 202a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 203a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 204db8d56b825efeb576d67b9dbe39d736d93306222Evan Cheng/// InstructionSelect - This callback is invoked by 205bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner/// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 206f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohmanvoid PPCDAGToDAGISel::InstructionSelect() { 207bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DEBUG(BB->dump()); 208bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 209bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Select target instructions for the DAG. 2108ad4c00c00233acb8a3395098e2b575cc34de46bDavid Greene SelectRoot(*CurDAG); 211f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman CurDAG->RemoveDeadNodes(); 2124bb189507281af0da8aff91743b5198acbf2398bChris Lattner} 2134bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2144bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// InsertVRSaveCode - Once the entire function has been instruction selected, 2154bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// all virtual registers are created and all machine instructions are built, 2164bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// check to see if we need to save/restore VRSAVE. If so, do it. 217ad2afc2a421a0e41603d5eee412d4d8c77e9bc1cDan Gohmanvoid PPCDAGToDAGISel::InsertVRSaveCode(MachineFunction &Fn) { 2181877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // Check to see if this function uses vector registers, which means we have to 2191877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // save and restore the VRSAVE register and update it with the regs we use. 2201877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2211877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // In this case, there will be virtual registers of vector type type created 2221877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // by the scheduler. Detect them now. 2231877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner bool HasVectorVReg = false; 2246f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman for (unsigned i = TargetRegisterInfo::FirstVirtualRegister, 22584bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner e = RegInfo->getLastVirtReg()+1; i != e; ++i) 22684bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner if (RegInfo->getRegClass(i) == &PPC::VRRCRegClass) { 2271877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner HasVectorVReg = true; 2281877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner break; 2291877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner } 2304bb189507281af0da8aff91743b5198acbf2398bChris Lattner if (!HasVectorVReg) return; // nothing to do. 2314bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2321877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // If we have a vector register, we want to emit code into the entry and exit 2331877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // blocks to save and restore the VRSAVE register. We do this here (instead 2341877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // of marking all vector instructions as clobbering VRSAVE) for two reasons: 2351877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2361877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 1. This (trivially) reduces the load on the register allocator, by not 2371877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // having to represent the live range of the VRSAVE register. 2381877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2. This (more significantly) allows us to create a temporary virtual 2391877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // register to hold the saved VRSAVE value, allowing this temporary to be 2401877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // register allocated, instead of forcing it to be spilled to the stack. 2414bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2424bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Create two vregs - one to hold the VRSAVE register that is live-in to the 2434bb189507281af0da8aff91743b5198acbf2398bChris Lattner // function and one for the value after having bits or'd into it. 24484bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner unsigned InVRSAVE = RegInfo->createVirtualRegister(&PPC::GPRCRegClass); 24584bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner unsigned UpdatedVRSAVE = RegInfo->createVirtualRegister(&PPC::GPRCRegClass); 2464bb189507281af0da8aff91743b5198acbf2398bChris Lattner 247c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng const TargetInstrInfo &TII = *TM.getInstrInfo(); 2484bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock &EntryBB = *Fn.begin(); 249536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen DebugLoc dl = DebugLoc::getUnknownLoc(); 2504bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Emit the following code into the entry block: 2514bb189507281af0da8aff91743b5198acbf2398bChris Lattner // InVRSAVE = MFVRSAVE 2524bb189507281af0da8aff91743b5198acbf2398bChris Lattner // UpdatedVRSAVE = UPDATE_VRSAVE InVRSAVE 2534bb189507281af0da8aff91743b5198acbf2398bChris Lattner // MTVRSAVE UpdatedVRSAVE 2544bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock::iterator IP = EntryBB.begin(); // Insert Point 255536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen BuildMI(EntryBB, IP, dl, TII.get(PPC::MFVRSAVE), InVRSAVE); 256536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen BuildMI(EntryBB, IP, dl, TII.get(PPC::UPDATE_VRSAVE), 25769244300b8a0112efb44b6273ecea4ca6264b8cfChris Lattner UpdatedVRSAVE).addReg(InVRSAVE); 258536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen BuildMI(EntryBB, IP, dl, TII.get(PPC::MTVRSAVE)).addReg(UpdatedVRSAVE); 2594bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2604bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Find all return blocks, outputting a restore in each epilog. 2614bb189507281af0da8aff91743b5198acbf2398bChris Lattner for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 262749c6f6b5ed301c84aac562e414486549d7b98ebChris Lattner if (!BB->empty() && BB->back().getDesc().isReturn()) { 2634bb189507281af0da8aff91743b5198acbf2398bChris Lattner IP = BB->end(); --IP; 2644bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2654bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Skip over all terminator instructions, which are part of the return 2664bb189507281af0da8aff91743b5198acbf2398bChris Lattner // sequence. 2674bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock::iterator I2 = IP; 268749c6f6b5ed301c84aac562e414486549d7b98ebChris Lattner while (I2 != BB->begin() && (--I2)->getDesc().isTerminator()) 2694bb189507281af0da8aff91743b5198acbf2398bChris Lattner IP = I2; 2704bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2714bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Emit: MTVRSAVE InVRSave 272536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen BuildMI(*BB, IP, dl, TII.get(PPC::MTVRSAVE)).addReg(InVRSAVE); 2734bb189507281af0da8aff91743b5198acbf2398bChris Lattner } 2741877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner } 275bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner} 2766cd40d5888f905a3820d5d6c71e57cc0e02abb4aChris Lattner 2774bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2784416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// getGlobalBaseReg - Output the instructions required to put the 2794416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// base address to use for accessing globals into a register. 2804416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// 2819ade218533429146731213eacb7e12060e65ff58Evan ChengSDNode *PPCDAGToDAGISel::getGlobalBaseReg() { 2824416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (!GlobalBaseReg) { 283c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng const TargetInstrInfo &TII = *TM.getInstrInfo(); 2844416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Insert the set of GlobalBaseReg into the first MBB of the function 2854416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock &FirstMBB = BB->getParent()->front(); 2864416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock::iterator MBBI = FirstMBB.begin(); 287536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen DebugLoc dl = DebugLoc::getUnknownLoc(); 288c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 289d10434215da983b58389d2a0880dfcd2cd3b7f35Chris Lattner if (PPCLowering.getPointerTy() == MVT::i32) { 29084bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner GlobalBaseReg = RegInfo->createVirtualRegister(PPC::GPRCRegisterClass); 291536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen BuildMI(FirstMBB, MBBI, dl, TII.get(PPC::MovePCtoLR), PPC::LR); 292536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen BuildMI(FirstMBB, MBBI, dl, TII.get(PPC::MFLR), GlobalBaseReg); 293d10434215da983b58389d2a0880dfcd2cd3b7f35Chris Lattner } else { 29484bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner GlobalBaseReg = RegInfo->createVirtualRegister(PPC::G8RCRegisterClass); 295536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen BuildMI(FirstMBB, MBBI, dl, TII.get(PPC::MovePCtoLR8), PPC::LR8); 296536a2f1f8467a17f6d145bd83f25faae1f689839Dale Johannesen BuildMI(FirstMBB, MBBI, dl, TII.get(PPC::MFLR8), GlobalBaseReg); 297d10434215da983b58389d2a0880dfcd2cd3b7f35Chris Lattner } 2984416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 29993c53e5583427ee567293a9a21c6c76fccf218caGabor Greif return CurDAG->getRegister(GlobalBaseReg, 30093c53e5583427ee567293a9a21c6c76fccf218caGabor Greif PPCLowering.getPointerTy()).getNode(); 3014416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner} 3024416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 303c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isIntS16Immediate - This method tests to see if the node is either a 32-bit 304c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// or 64-bit immediate, and if the value can be accurately represented as a 305c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// sign extension from a 16-bit value. If so, this returns true and the 306c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// immediate. 307c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isIntS16Immediate(SDNode *N, short &Imm) { 308c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getOpcode() != ISD::Constant) 309c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return false; 3104416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 311f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman Imm = (short)cast<ConstantSDNode>(N)->getZExtValue(); 312c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getValueType(0) == MVT::i32) 313f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman return Imm == (int32_t)cast<ConstantSDNode>(N)->getZExtValue(); 314c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner else 315f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman return Imm == (int64_t)cast<ConstantSDNode>(N)->getZExtValue(); 316c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 317c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 318475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanstatic bool isIntS16Immediate(SDValue Op, short &Imm) { 319ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return isIntS16Immediate(Op.getNode(), Imm); 320c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 321c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 322c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 323c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isInt32Immediate - This method tests to see if the node is a 32-bit constant 324c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// operand. If so Imm will receive the 32-bit value. 325c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isInt32Immediate(SDNode *N, unsigned &Imm) { 326c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i32) { 327f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman Imm = cast<ConstantSDNode>(N)->getZExtValue(); 3280f3257a3302b60c128a667db6736e81335316c1eNate Begeman return true; 3290f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 3300f3257a3302b60c128a667db6736e81335316c1eNate Begeman return false; 3310f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 3320f3257a3302b60c128a667db6736e81335316c1eNate Begeman 333c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isInt64Immediate - This method tests to see if the node is a 64-bit constant 334c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// operand. If so Imm will receive the 64-bit value. 335c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isInt64Immediate(SDNode *N, uint64_t &Imm) { 336711762497c27357adc1edf8d4237c2770fa303bbChris Lattner if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i64) { 337f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman Imm = cast<ConstantSDNode>(N)->getZExtValue(); 338c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return true; 339c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 340c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return false; 341c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 342c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 343c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// isInt32Immediate - This method tests to see if a constant operand. 344c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// If so Imm will receive the 32 bit value. 345475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanstatic bool isInt32Immediate(SDValue N, unsigned &Imm) { 346ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return isInt32Immediate(N.getNode(), Imm); 347c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 348c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 349c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 350c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// isOpcWithIntImmediate - This method tests to see if the node is a specific 351c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// opcode and that it has a immediate integer right operand. 352c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// If so Imm will receive the 32 bit value. 353c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isOpcWithIntImmediate(SDNode *N, unsigned Opc, unsigned& Imm) { 35493c53e5583427ee567293a9a21c6c76fccf218caGabor Greif return N->getOpcode() == Opc 35593c53e5583427ee567293a9a21c6c76fccf218caGabor Greif && isInt32Immediate(N->getOperand(1).getNode(), Imm); 356c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 357c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 358f42f133938545d4f5c249bcfef63db772ce8e942Nate Begemanbool PPCDAGToDAGISel::isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME) { 359cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isShiftedMask_32(Val)) { 360cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first non-zero bit 361cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman MB = CountLeadingZeros_32(Val); 362cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first zero bit after the run of ones 363cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman ME = CountLeadingZeros_32((Val - 1) ^ Val); 364cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return true; 3652fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } else { 3662fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner Val = ~Val; // invert mask 3672fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner if (isShiftedMask_32(Val)) { 3682fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first zero bit 3692fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner ME = CountLeadingZeros_32(Val) - 1; 3702fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first one bit after the run of zeros 3712fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner MB = CountLeadingZeros_32((Val - 1) ^ Val) + 1; 3722fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner return true; 3732fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } 374cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 375cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // no run present 376cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 377cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 378cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 379f42f133938545d4f5c249bcfef63db772ce8e942Nate Begemanbool PPCDAGToDAGISel::isRotateAndMask(SDNode *N, unsigned Mask, 380f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman bool IsShiftMask, unsigned &SH, 381f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman unsigned &MB, unsigned &ME) { 382da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // Don't even go down this path for i64, since different logic will be 383da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // necessary for rldicl/rldicr/rldimi. 384da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman if (N->getValueType(0) != MVT::i32) 385da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman return false; 386da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman 387cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Shift = 32; 388cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Indeterminant = ~0; // bit mask marking indeterminant results 389cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Opcode = N->getOpcode(); 39015055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner if (N->getNumOperands() != 2 || 391ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif !isInt32Immediate(N->getOperand(1).getNode(), Shift) || (Shift > 31)) 392cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 393cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 394cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Opcode == ISD::SHL) { 395cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift left to mask if it comes first 396cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask << Shift; 397cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 398cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu << Shift); 399651dea74f6a362d30bc61fd0b549da7707af5bf8Chris Lattner } else if (Opcode == ISD::SRL) { 400cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift right to mask if it comes first 401cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask >> Shift; 402cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 403cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu >> Shift); 404cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // adjust for the left rotate 405cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Shift = 32 - Shift; 406f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman } else if (Opcode == ISD::ROTL) { 407f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman Indeterminant = 0; 408cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 409cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 410cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 411cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 412cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // if the mask doesn't intersect any Indeterminant bits 413cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Mask && !(Mask & Indeterminant)) { 4140949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner SH = Shift & 31; 415cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // make sure the mask is still a mask (wrap arounds may not be) 416cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return isRunOfOnes(Mask, MB, ME); 417cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 418cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 419cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 420cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 42102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// SelectBitfieldInsert - turn an or of two masked values into 42202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// the rotate left word immediate then mask insert (rlwimi) instruction. 4231d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDNode *PPCDAGToDAGISel::SelectBitfieldInsert(SDNode *N) { 424475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op0 = N->getOperand(0); 425475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op1 = N->getOperand(1); 426ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen DebugLoc dl = N->getDebugLoc(); 42702b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 428b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman APInt LKZ, LKO, RKZ, RKO; 429b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman CurDAG->ComputeMaskedBits(Op0, APInt::getAllOnesValue(32), LKZ, LKO); 430b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman CurDAG->ComputeMaskedBits(Op1, APInt::getAllOnesValue(32), RKZ, RKO); 43102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 432b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman unsigned TargetMask = LKZ.getZExtValue(); 433b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman unsigned InsertMask = RKZ.getZExtValue(); 4344667f2cbad246beccfca5411a26add24d1007035Nate Begeman 4354667f2cbad246beccfca5411a26add24d1007035Nate Begeman if ((TargetMask | InsertMask) == 0xFFFFFFFF) { 4364667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Op0Opc = Op0.getOpcode(); 4374667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Op1Opc = Op1.getOpcode(); 4384667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Value, SH = 0; 4394667f2cbad246beccfca5411a26add24d1007035Nate Begeman TargetMask = ~TargetMask; 4404667f2cbad246beccfca5411a26add24d1007035Nate Begeman InsertMask = ~InsertMask; 44177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 4424667f2cbad246beccfca5411a26add24d1007035Nate Begeman // If the LHS has a foldable shift and the RHS does not, then swap it to the 4434667f2cbad246beccfca5411a26add24d1007035Nate Begeman // RHS so that we can fold the shift into the insert. 44477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op0Opc == ISD::AND && Op1Opc == ISD::AND) { 44577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op0.getOperand(0).getOpcode() == ISD::SHL || 44677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op0.getOperand(0).getOpcode() == ISD::SRL) { 44777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op1.getOperand(0).getOpcode() != ISD::SHL && 44877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1.getOperand(0).getOpcode() != ISD::SRL) { 44977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman std::swap(Op0, Op1); 45077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman std::swap(Op0Opc, Op1Opc); 4514667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(TargetMask, InsertMask); 45277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 45377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 4544667f2cbad246beccfca5411a26add24d1007035Nate Begeman } else if (Op0Opc == ISD::SHL || Op0Opc == ISD::SRL) { 4554667f2cbad246beccfca5411a26add24d1007035Nate Begeman if (Op1Opc == ISD::AND && Op1.getOperand(0).getOpcode() != ISD::SHL && 4564667f2cbad246beccfca5411a26add24d1007035Nate Begeman Op1.getOperand(0).getOpcode() != ISD::SRL) { 4574667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(Op0, Op1); 4584667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(Op0Opc, Op1Opc); 4594667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(TargetMask, InsertMask); 4604667f2cbad246beccfca5411a26add24d1007035Nate Begeman } 46102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 46277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 46377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman unsigned MB, ME; 4640949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner if (InsertMask && isRunOfOnes(InsertMask, MB, ME)) { 465475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp1, Tmp2, Tmp3; 4664667f2cbad246beccfca5411a26add24d1007035Nate Begeman bool DisjointMask = (TargetMask ^ InsertMask) == 0xFFFFFFFF; 46777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 46877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if ((Op1Opc == ISD::SHL || Op1Opc == ISD::SRL) && 469c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(Op1.getOperand(1), Value)) { 47077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0); 47177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SH = (Op1Opc == ISD::SHL) ? Value : 32 - Value; 47202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 47377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op1Opc == ISD::AND) { 47477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman unsigned SHOpc = Op1.getOperand(0).getOpcode(); 47577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if ((SHOpc == ISD::SHL || SHOpc == ISD::SRL) && 476c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(Op1.getOperand(0).getOperand(1), Value)) { 47777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0).getOperand(0); 47877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SH = (SHOpc == ISD::SHL) ? Value : 32 - Value; 47977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } else { 48077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0); 48177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 48202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 48377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 48477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Tmp3 = (Op0Opc == ISD::AND && DisjointMask) ? Op0.getOperand(0) : Op0; 4850949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner SH &= 31; 486475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Tmp3, Op1, getI32Imm(SH), getI32Imm(MB), 4870b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(ME) }; 488ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen return CurDAG->getTargetNode(PPC::RLWIMI, dl, MVT::i32, Ops, 5); 48902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 49002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 49102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 49202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman} 49302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 4942fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// SelectCC - Select a comparison of the specified values with the specified 4952fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// condition code, returning the CR# of the expression. 496475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue PPCDAGToDAGISel::SelectCC(SDValue LHS, SDValue RHS, 497f5f5dce897269885754fc79adeb809194da52942Dale Johannesen ISD::CondCode CC, DebugLoc dl) { 4982fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Always select the LHS. 499c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner unsigned Opc; 500c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 501c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (LHS.getValueType() == MVT::i32) { 502529c233498c59a544b26b277f8fe30e6a80cc6f8Chris Lattner unsigned Imm; 5033836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner if (CC == ISD::SETEQ || CC == ISD::SETNE) { 5043836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner if (isInt32Immediate(RHS, Imm)) { 5053836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // SETEQ/SETNE comparison with 16-bit immediate, fold it. 5063836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner if (isUInt16(Imm)) 507f5f5dce897269885754fc79adeb809194da52942Dale Johannesen return SDValue(CurDAG->getTargetNode(PPC::CMPLWI, dl, MVT::i32, LHS, 5083836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner getI32Imm(Imm & 0xFFFF)), 0); 5093836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // If this is a 16-bit signed immediate, fold it. 510aa43e9f73b4ccd700530803803e074eff9b3dca5Chris Lattner if (isInt16((int)Imm)) 511f5f5dce897269885754fc79adeb809194da52942Dale Johannesen return SDValue(CurDAG->getTargetNode(PPC::CMPWI, dl, MVT::i32, LHS, 5123836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner getI32Imm(Imm & 0xFFFF)), 0); 5133836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner 5143836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // For non-equality comparisons, the default code would materialize the 5153836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // constant, then compare against it, like this: 5163836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // lis r2, 4660 5173836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // ori r2, r2, 22136 5183836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // cmpw cr0, r3, r2 5193836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // Since we are just comparing for equality, we can emit this instead: 5203836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // xoris r0,r3,0x1234 5213836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // cmplwi cr0,r0,0x5678 5223836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // beq cr0,L6 523f5f5dce897269885754fc79adeb809194da52942Dale Johannesen SDValue Xor(CurDAG->getTargetNode(PPC::XORIS, dl, MVT::i32, LHS, 5243836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner getI32Imm(Imm >> 16)), 0); 525f5f5dce897269885754fc79adeb809194da52942Dale Johannesen return SDValue(CurDAG->getTargetNode(PPC::CMPLWI, dl, MVT::i32, Xor, 5263836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner getI32Imm(Imm & 0xFFFF)), 0); 5273836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner } 5283836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner Opc = PPC::CMPLW; 5293836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner } else if (ISD::isUnsignedIntSetCC(CC)) { 530c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(RHS, Imm) && isUInt16(Imm)) 531f5f5dce897269885754fc79adeb809194da52942Dale Johannesen return SDValue(CurDAG->getTargetNode(PPC::CMPLWI, dl, MVT::i32, LHS, 532c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner getI32Imm(Imm & 0xFFFF)), 0); 533c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPLW; 534c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } else { 535c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short SImm; 536c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(RHS, SImm)) 537f5f5dce897269885754fc79adeb809194da52942Dale Johannesen return SDValue(CurDAG->getTargetNode(PPC::CMPWI, dl, MVT::i32, LHS, 538c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner getI32Imm((int)SImm & 0xFFFF)), 539c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 0); 540c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPW; 541c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 542c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } else if (LHS.getValueType() == MVT::i64) { 543c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner uint64_t Imm; 544711762497c27357adc1edf8d4237c2770fa303bbChris Lattner if (CC == ISD::SETEQ || CC == ISD::SETNE) { 545ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (isInt64Immediate(RHS.getNode(), Imm)) { 546711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // SETEQ/SETNE comparison with 16-bit immediate, fold it. 547711762497c27357adc1edf8d4237c2770fa303bbChris Lattner if (isUInt16(Imm)) 548f5f5dce897269885754fc79adeb809194da52942Dale Johannesen return SDValue(CurDAG->getTargetNode(PPC::CMPLDI, dl, MVT::i64, LHS, 549711762497c27357adc1edf8d4237c2770fa303bbChris Lattner getI32Imm(Imm & 0xFFFF)), 0); 550711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // If this is a 16-bit signed immediate, fold it. 551711762497c27357adc1edf8d4237c2770fa303bbChris Lattner if (isInt16(Imm)) 552f5f5dce897269885754fc79adeb809194da52942Dale Johannesen return SDValue(CurDAG->getTargetNode(PPC::CMPDI, dl, MVT::i64, LHS, 553711762497c27357adc1edf8d4237c2770fa303bbChris Lattner getI32Imm(Imm & 0xFFFF)), 0); 554711762497c27357adc1edf8d4237c2770fa303bbChris Lattner 555711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // For non-equality comparisons, the default code would materialize the 556711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // constant, then compare against it, like this: 557711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // lis r2, 4660 558711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // ori r2, r2, 22136 559711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // cmpd cr0, r3, r2 560711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // Since we are just comparing for equality, we can emit this instead: 561711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // xoris r0,r3,0x1234 562711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // cmpldi cr0,r0,0x5678 563711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // beq cr0,L6 564711762497c27357adc1edf8d4237c2770fa303bbChris Lattner if (isUInt32(Imm)) { 565f5f5dce897269885754fc79adeb809194da52942Dale Johannesen SDValue Xor(CurDAG->getTargetNode(PPC::XORIS8, dl, MVT::i64, LHS, 566711762497c27357adc1edf8d4237c2770fa303bbChris Lattner getI64Imm(Imm >> 16)), 0); 567f5f5dce897269885754fc79adeb809194da52942Dale Johannesen return SDValue(CurDAG->getTargetNode(PPC::CMPLDI, dl, MVT::i64, Xor, 568711762497c27357adc1edf8d4237c2770fa303bbChris Lattner getI64Imm(Imm & 0xFFFF)), 0); 569711762497c27357adc1edf8d4237c2770fa303bbChris Lattner } 570711762497c27357adc1edf8d4237c2770fa303bbChris Lattner } 571711762497c27357adc1edf8d4237c2770fa303bbChris Lattner Opc = PPC::CMPLD; 572711762497c27357adc1edf8d4237c2770fa303bbChris Lattner } else if (ISD::isUnsignedIntSetCC(CC)) { 573ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (isInt64Immediate(RHS.getNode(), Imm) && isUInt16(Imm)) 574f5f5dce897269885754fc79adeb809194da52942Dale Johannesen return SDValue(CurDAG->getTargetNode(PPC::CMPLDI, dl, MVT::i64, LHS, 575c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner getI64Imm(Imm & 0xFFFF)), 0); 576c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPLD; 577c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } else { 578c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short SImm; 579c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(RHS, SImm)) 580f5f5dce897269885754fc79adeb809194da52942Dale Johannesen return SDValue(CurDAG->getTargetNode(PPC::CMPDI, dl, MVT::i64, LHS, 581711762497c27357adc1edf8d4237c2770fa303bbChris Lattner getI64Imm(SImm & 0xFFFF)), 582c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 0); 583c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPD; 584c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 585919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner } else if (LHS.getValueType() == MVT::f32) { 586c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::FCMPUS; 5872fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 588c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner assert(LHS.getValueType() == MVT::f64 && "Unknown vt!"); 589c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::FCMPUD; 5902fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 591f5f5dce897269885754fc79adeb809194da52942Dale Johannesen return SDValue(CurDAG->getTargetNode(Opc, dl, MVT::i32, LHS, RHS), 0); 5922fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 5932fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 594df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattnerstatic PPC::Predicate getPredicateForSetCC(ISD::CondCode CC) { 5952fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner switch (CC) { 5965d634ce466173f6fde49470fad125eb09532caebChris Lattner case ISD::SETUEQ: 59753e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETONE: 59853e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETOLE: 59953e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETOGE: 600c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Should be lowered by legalize!"); 601c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Unknown condition!"); 60253e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETOEQ: 603df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETEQ: return PPC::PRED_EQ; 6045d634ce466173f6fde49470fad125eb09532caebChris Lattner case ISD::SETUNE: 605df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETNE: return PPC::PRED_NE; 60653e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETOLT: 607df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETLT: return PPC::PRED_LT; 6082fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULE: 609df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETLE: return PPC::PRED_LE; 61053e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETOGT: 611df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETGT: return PPC::PRED_GT; 6122fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGE: 613df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETGE: return PPC::PRED_GE; 614df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETO: return PPC::PRED_NU; 615df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETUO: return PPC::PRED_UN; 61653e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen // These two are invalid for floating point. Assume we have int. 61753e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETULT: return PPC::PRED_LT; 61853e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETUGT: return PPC::PRED_GT; 6192fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 6202fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 6212fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 62264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// getCRIdxForSetCC - Return the index of the condition register field 62364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// associated with the SetCC condition, and whether or not the field is 62464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// treated as inverted. That is, lt = 0; ge = 0 inverted. 625fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner/// 626fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner/// If this returns with Other != -1, then the returned comparison is an or of 627fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner/// two simpler comparisons. In this case, Invert is guaranteed to be false. 628fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattnerstatic unsigned getCRIdxForSetCC(ISD::CondCode CC, bool &Invert, int &Other) { 629fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner Invert = false; 630fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner Other = -1; 63164906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 632c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Unknown condition!"); 633fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETOLT: 634fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETLT: return 0; // Bit #0 = SETOLT 635fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETOGT: 636fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETGT: return 1; // Bit #1 = SETOGT 637fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETOEQ: 638fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETEQ: return 2; // Bit #2 = SETOEQ 639fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETUO: return 3; // Bit #3 = SETUO 64064906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGE: 641fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETGE: Invert = true; return 0; // !Bit #0 = SETUGE 64264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULE: 643fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETLE: Invert = true; return 1; // !Bit #1 = SETULE 6448e2a04e21dc8299bdaba4321a6e690712dab9617Chris Lattner case ISD::SETUNE: 645fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETNE: Invert = true; return 2; // !Bit #2 = SETUNE 646fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETO: Invert = true; return 3; // !Bit #3 = SETO 64753e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETUEQ: 64853e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETOGE: 64953e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETOLE: 65053e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETONE: 651c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Invalid branch code: should be expanded by legalize"); 65253e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen // These are invalid for floating point. Assume integer. 65353e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETULT: return 0; 65453e4e4478c69c2c2115db833b54385117c764d14Dale Johannesen case ISD::SETUGT: return 1; 65564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 65664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner return 0; 65764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner} 6589944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 659475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDNode *PPCDAGToDAGISel::SelectSETCC(SDValue Op) { 660ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif SDNode *N = Op.getNode(); 661a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen DebugLoc dl = N->getDebugLoc(); 662222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Imm; 663222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get(); 664c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm)) { 665222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // We can codegen setcc op, imm very efficiently compared to a brcond. 666222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Check for those cases here. 667222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // setcc op, 0 668222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (Imm == 0) { 669475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op = N->getOperand(0); 670222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 671dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 6720b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng case ISD::SETEQ: { 673a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen Op = SDValue(CurDAG->getTargetNode(PPC::CNTLZW, dl, MVT::i32, Op), 0); 674475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Op, getI32Imm(27), getI32Imm(5), getI32Imm(31) }; 6750b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 6760b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng } 677dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 678475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue AD = 679a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen SDValue(CurDAG->getTargetNode(PPC::ADDIC, dl, MVT::i32, MVT::Flag, 6807e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(~0U)), 0); 68171d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, 68295514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng AD.getValue(1)); 683dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 6840b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng case ISD::SETLT: { 685475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Op, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 6860b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 6870b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng } 688dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETGT: { 689475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue T = 690a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen SDValue(CurDAG->getTargetNode(PPC::NEG, dl, MVT::i32, Op), 0); 691a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen T = SDValue(CurDAG->getTargetNode(PPC::ANDC, dl, MVT::i32, T, Op), 0); 692475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { T, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 6930b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 694dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 695222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 696222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else if (Imm == ~0U) { // setcc op, -1 697475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op = N->getOperand(0); 698222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 699dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 700dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETEQ: 701a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen Op = SDValue(CurDAG->getTargetNode(PPC::ADDIC, dl, MVT::i32, MVT::Flag, 7027e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(1)), 0); 70371d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 704a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen SDValue(CurDAG->getTargetNode(PPC::LI, dl, 705a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen MVT::i32, 706a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen getI32Imm(0)), 0), 707a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen Op.getValue(1)); 708dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 709a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen Op = SDValue(CurDAG->getTargetNode(PPC::NOR, dl, MVT::i32, Op, Op), 0); 710a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen SDNode *AD = CurDAG->getTargetNode(PPC::ADDIC, dl, MVT::i32, MVT::Flag, 7117e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(~0U)); 712475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, SDValue(AD, 0), 713475871a144eb604ddaf37503397ba0941442e5fbDan Gohman Op, SDValue(AD, 1)); 714dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 715dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETLT: { 716a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen SDValue AD = SDValue(CurDAG->getTargetNode(PPC::ADDI, dl, MVT::i32, Op, 7177e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(1)), 0); 718a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen SDValue AN = SDValue(CurDAG->getTargetNode(PPC::AND, dl, MVT::i32, AD, 7197e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op), 0); 720475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { AN, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 7210b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 722dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 7230b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng case ISD::SETGT: { 724475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Op, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 725a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen Op = SDValue(CurDAG->getTargetNode(PPC::RLWINM, dl, MVT::i32, Ops, 4), 726a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen 0); 727ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Op, 72895514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng getI32Imm(1)); 729222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 7300b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng } 731222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 732222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 733222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 734222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner bool Inv; 735fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner int OtherCondIdx; 736fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner unsigned Idx = getCRIdxForSetCC(CC, Inv, OtherCondIdx); 737f5f5dce897269885754fc79adeb809194da52942Dale Johannesen SDValue CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC, dl); 738475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue IntCR; 739222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 740222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Force the ccreg into CR7. 741475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CR7Reg = CurDAG->getRegister(PPC::CR7, MVT::i32); 742222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 743475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue InFlag(0, 0); // Null incoming flag value. 744a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen CCReg = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, CR7Reg, CCReg, 745db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner InFlag).getValue(1); 746222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 747fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner if (PPCSubTarget.isGigaProcessor() && OtherCondIdx == -1) 748a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen IntCR = SDValue(CurDAG->getTargetNode(PPC::MFOCRF, dl, MVT::i32, CR7Reg, 7497e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng CCReg), 0); 750222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner else 751a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen IntCR = SDValue(CurDAG->getTargetNode(PPC::MFCR, dl, MVT::i32, CCReg), 0); 752222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 753475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { IntCR, getI32Imm((32-(3-Idx)) & 31), 7540b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(31), getI32Imm(31) }; 755fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner if (OtherCondIdx == -1 && !Inv) 7560b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 757fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 758fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // Get the specified bit. 759475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp = 760a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen SDValue(CurDAG->getTargetNode(PPC::RLWINM, dl, MVT::i32, Ops, 4), 0); 761fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner if (Inv) { 762fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner assert(OtherCondIdx == -1 && "Can't have split plus negation"); 76395514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Tmp, getI32Imm(1)); 764222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 765fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 766fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // Otherwise, we have to turn an operation like SETONE -> SETOLT | SETOGT. 767fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // We already got the bit for the first part of the comparison (e.g. SETULE). 768fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 769fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // Get the other bit of the comparison. 770fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner Ops[1] = getI32Imm((32-(3-OtherCondIdx)) & 31); 771475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue OtherCond = 772a05dca4f9e051fad19fe9b5f6cce2715c1e5d505Dale Johannesen SDValue(CurDAG->getTargetNode(PPC::RLWINM, dl, MVT::i32, Ops, 4), 0); 773fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 774fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner return CurDAG->SelectNodeTo(N, PPC::OR, MVT::i32, Tmp, OtherCond); 775222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner} 7762b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 7776a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 778a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Select - Convert the specified operand from a target-independent to a 779a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// target-specific node if it hasn't already been changed. 780475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDNode *PPCDAGToDAGISel::Select(SDValue Op) { 781ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif SDNode *N = Op.getNode(); 782ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen DebugLoc dl = Op.getDebugLoc(); 783e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman if (N->isMachineOpcode()) 78464a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; // Already selected. 785d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 786a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOpcode()) { 78719c0907ba1c11c81dc231cf7b4143fdaf03466e4Chris Lattner default: break; 78878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 78978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey case ISD::Constant: { 79078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (N->getValueType(0) == MVT::i64) { 79178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Get 64 bit value. 792f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman int64_t Imm = cast<ConstantSDNode>(N)->getZExtValue(); 79378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Assume no remaining bits. 79478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Remainder = 0; 79578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Assume no shift required. 79678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Shift = 0; 79778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 79878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // If it can't be represented as a 32 bit value. 79978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (!isInt32(Imm)) { 80078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Shift = CountTrailingZeros_64(Imm); 80178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey int64_t ImmSh = static_cast<uint64_t>(Imm) >> Shift; 80278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 80378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // If the shifted value fits 32 bits. 80478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (isInt32(ImmSh)) { 80578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Go with the shifted value. 80678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Imm = ImmSh; 80778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } else { 80878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Still stuck with a 64 bit value. 80978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Remainder = Imm; 81078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Shift = 32; 81178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Imm >>= 32; 81278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 81378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 81478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 81578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Intermediate operand. 81678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey SDNode *Result; 81778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 81878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Handle first 32 bits. 81978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Lo = Imm & 0xFFFF; 82078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Hi = (Imm >> 16) & 0xFFFF; 82178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 82278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Simple value. 82378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (isInt16(Imm)) { 82478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Just the Lo bits. 825ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen Result = CurDAG->getTargetNode(PPC::LI8, dl, MVT::i64, getI32Imm(Lo)); 82678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } else if (Lo) { 82778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Handle the Hi bits. 82878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned OpC = Hi ? PPC::LIS8 : PPC::LI8; 829ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen Result = CurDAG->getTargetNode(OpC, dl, MVT::i64, getI32Imm(Hi)); 83078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // And Lo bits. 831ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen Result = CurDAG->getTargetNode(PPC::ORI8, dl, MVT::i64, 832475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Result, 0), getI32Imm(Lo)); 83378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } else { 83478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Just the Hi bits. 835ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen Result = CurDAG->getTargetNode(PPC::LIS8, dl, MVT::i64, getI32Imm(Hi)); 83678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 83778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 83878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // If no shift, we're done. 83978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (!Shift) return Result; 84078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 84178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Shift for next step if the upper 32-bits were not zero. 84278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (Imm) { 843ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen Result = CurDAG->getTargetNode(PPC::RLDICR, dl, MVT::i64, 844475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Result, 0), 84578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey getI32Imm(Shift), getI32Imm(63 - Shift)); 84678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 84778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 84878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Add in the last bits as required. 84978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if ((Hi = (Remainder >> 16) & 0xFFFF)) { 850ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen Result = CurDAG->getTargetNode(PPC::ORIS8, dl, MVT::i64, 851475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Result, 0), getI32Imm(Hi)); 85278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 85378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if ((Lo = Remainder & 0xFFFF)) { 854ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen Result = CurDAG->getTargetNode(PPC::ORI8, dl, MVT::i64, 855475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Result, 0), getI32Imm(Lo)); 85678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 85778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 85878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey return Result; 85978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 86078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey break; 86178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 86278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 86334167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case ISD::SETCC: 864ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return SelectSETCC(Op); 86534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case PPCISD::GlobalBaseReg: 8669ade218533429146731213eacb7e12060e65ff58Evan Cheng return getGlobalBaseReg(); 867860e8862c1fbd3b261da4a64a8c0096f9f373681Chris Lattner 868e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner case ISD::FrameIndex: { 869e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner int FI = cast<FrameIndexSDNode>(N)->getIndex(); 870475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue TFI = CurDAG->getTargetFrameIndex(FI, Op.getValueType()); 871c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner unsigned Opc = Op.getValueType() == MVT::i32 ? PPC::ADDI : PPC::ADDI8; 872ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner if (N->hasOneUse()) 873ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->SelectNodeTo(N, Opc, Op.getValueType(), TFI, 87495514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng getSmallIPtrImm(0)); 875ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen return CurDAG->getTargetNode(Opc, dl, Op.getValueType(), TFI, 876ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner getSmallIPtrImm(0)); 877e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } 8786d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner 8796d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner case PPCISD::MFCR: { 880475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue InFlag = N->getOperand(1); 8816d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner // Use MFOCRF if supported. 882152b7e18748f7e06a93260f22cc9dac8eb3abee2Evan Cheng if (PPCSubTarget.isGigaProcessor()) 883ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen return CurDAG->getTargetNode(PPC::MFOCRF, dl, MVT::i32, 884ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner N->getOperand(0), InFlag); 8856d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner else 886ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen return CurDAG->getTargetNode(PPC::MFCR, dl, MVT::i32, InFlag); 8876d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner } 8886d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner 88988add100b3db715df4275c8ab408e6b51f28ff8fChris Lattner case ISD::SDIV: { 890405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: since this depends on the setting of the carry flag from the srawi 891405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // we should really be making notes about that for the scheduler. 892405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: It sure would be nice if we could cheaply recognize the 893405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // srl/add/sra pattern the dag combiner will generate for this as 894405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // sra/addze rather than having to handle sdiv ourselves. oh well. 8958784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner unsigned Imm; 896c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm)) { 897475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue N0 = N->getOperand(0); 8988784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if ((signed)Imm > 0 && isPowerOf2_32(Imm)) { 8997e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 900ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen CurDAG->getTargetNode(PPC::SRAWI, dl, MVT::i32, MVT::Flag, 90134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N0, getI32Imm(Log2_32(Imm))); 902ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 903475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Op, 0), SDValue(Op, 1)); 9048784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } else if ((signed)Imm < 0 && isPowerOf2_32(-Imm)) { 9057e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 906ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen CurDAG->getTargetNode(PPC::SRAWI, dl, MVT::i32, MVT::Flag, 90734167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N0, getI32Imm(Log2_32(-Imm))); 908475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue PT = 909ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen SDValue(CurDAG->getTargetNode(PPC::ADDZE, dl, MVT::i32, 910475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Op, 0), SDValue(Op, 1)), 9117e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng 0); 91295514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng return CurDAG->SelectNodeTo(N, PPC::NEG, MVT::i32, PT); 9138784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 9148784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 915047b952e298352fe6feffedf02e359601133f465Chris Lattner 916237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 917237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 918047b952e298352fe6feffedf02e359601133f465Chris Lattner } 9194eab71497d10622bd209c53f8e56152877ac5638Chris Lattner 9204eab71497d10622bd209c53f8e56152877ac5638Chris Lattner case ISD::LOAD: { 9214eab71497d10622bd209c53f8e56152877ac5638Chris Lattner // Handle preincrement loads. 9224eab71497d10622bd209c53f8e56152877ac5638Chris Lattner LoadSDNode *LD = cast<LoadSDNode>(Op); 92383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT LoadedVT = LD->getMemoryVT(); 9244eab71497d10622bd209c53f8e56152877ac5638Chris Lattner 9254eab71497d10622bd209c53f8e56152877ac5638Chris Lattner // Normal loads are handled by code generated from the .td file. 9264eab71497d10622bd209c53f8e56152877ac5638Chris Lattner if (LD->getAddressingMode() != ISD::PRE_INC) 9274eab71497d10622bd209c53f8e56152877ac5638Chris Lattner break; 9284eab71497d10622bd209c53f8e56152877ac5638Chris Lattner 929475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Offset = LD->getOffset(); 9305b3bbc7cd7bff4275b94003d4bf1fa296c6a10d0Chris Lattner if (isa<ConstantSDNode>(Offset) || 9315b3bbc7cd7bff4275b94003d4bf1fa296c6a10d0Chris Lattner Offset.getOpcode() == ISD::TargetGlobalAddress) { 9320851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner 9330851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner unsigned Opcode; 9340851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner bool isSExt = LD->getExtensionType() == ISD::SEXTLOAD; 9350851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner if (LD->getValueType(0) != MVT::i64) { 9360851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner // Handle PPC32 integer and normal FP loads. 9377c1c261272b43f2a9397c3052819b92c53918075Anton Korobeynikov assert((!isSExt || LoadedVT == MVT::i16) && "Invalid sext update load"); 93883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands switch (LoadedVT.getSimpleVT()) { 939c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Invalid PPC load type!"); 9400851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::f64: Opcode = PPC::LFDU; break; 9410851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::f32: Opcode = PPC::LFSU; break; 9420851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i32: Opcode = PPC::LWZU; break; 9430851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i16: Opcode = isSExt ? PPC::LHAU : PPC::LHZU; break; 9440851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i1: 9450851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i8: Opcode = PPC::LBZU; break; 9460851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } 9470851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } else { 9480851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner assert(LD->getValueType(0) == MVT::i64 && "Unknown load result type!"); 9497c1c261272b43f2a9397c3052819b92c53918075Anton Korobeynikov assert((!isSExt || LoadedVT == MVT::i16) && "Invalid sext update load"); 95083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands switch (LoadedVT.getSimpleVT()) { 951c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Invalid PPC load type!"); 9520851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i64: Opcode = PPC::LDU; break; 9530851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i32: Opcode = PPC::LWZU8; break; 9540851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i16: Opcode = isSExt ? PPC::LHAU8 : PPC::LHZU8; break; 9550851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i1: 9560851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i8: Opcode = PPC::LBZU8; break; 9570851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } 9580851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } 9590851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner 960475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = LD->getChain(); 961475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Base = LD->getBasePtr(); 962475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Offset, Base, Chain }; 9634eab71497d10622bd209c53f8e56152877ac5638Chris Lattner // FIXME: PPC64 964ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen return CurDAG->getTargetNode(Opcode, dl, LD->getValueType(0), 965e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman PPCLowering.getPointerTy(), 9664eab71497d10622bd209c53f8e56152877ac5638Chris Lattner MVT::Other, Ops, 3); 9674eab71497d10622bd209c53f8e56152877ac5638Chris Lattner } else { 968c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("R+R preindex loads not supported yet!"); 9694eab71497d10622bd209c53f8e56152877ac5638Chris Lattner } 9704eab71497d10622bd209c53f8e56152877ac5638Chris Lattner } 9714eab71497d10622bd209c53f8e56152877ac5638Chris Lattner 972cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman case ISD::AND: { 973f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman unsigned Imm, Imm2, SH, MB, ME; 974f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman 975cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and of a value rotated between 0 and 31 bits and then and'd 976cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // with a mask, emit rlwinm 977c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm) && 978ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif isRotateAndMask(N->getOperand(0).getNode(), Imm, false, SH, MB, ME)) { 979475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Val = N->getOperand(0).getOperand(0); 980475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Val, getI32Imm(SH), getI32Imm(MB), getI32Imm(ME) }; 9810b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 982cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 983f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman // If this is just a masked value where the input is not handled above, and 984f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman // is not a rotate-left (handled by a pattern in the .td file), emit rlwinm 985f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman if (isInt32Immediate(N->getOperand(1), Imm) && 986f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman isRunOfOnes(Imm, MB, ME) && 987f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman N->getOperand(0).getOpcode() != ISD::ROTL) { 988475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Val = N->getOperand(0); 989475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Val, getI32Imm(0), getI32Imm(MB), getI32Imm(ME) }; 990f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 991f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman } 992f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman // AND X, 0 -> 0, not "rlwinm 32". 993f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman if (isInt32Immediate(N->getOperand(1), Imm) && (Imm == 0)) { 994475871a144eb604ddaf37503397ba0941442e5fbDan Gohman ReplaceUses(SDValue(N, 0), N->getOperand(1)); 995f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman return NULL; 996f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman } 99750fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // ISD::OR doesn't get all the bitfield insertion fun. 99850fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // (and (or x, c1), c2) where isRunOfOnes(~(c1^c2)) is a bitfield insert 999c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm) && 100050fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman N->getOperand(0).getOpcode() == ISD::OR && 1001c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(N->getOperand(0).getOperand(1), Imm2)) { 1002c9a5ef524a9f461717bbf647b2d3da061aed720dChris Lattner unsigned MB, ME; 100350fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman Imm = ~(Imm^Imm2); 100450fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman if (isRunOfOnes(Imm, MB, ME)) { 1005475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { N->getOperand(0).getOperand(0), 10060b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng N->getOperand(0).getOperand(1), 10070b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(0), getI32Imm(MB),getI32Imm(ME) }; 1008ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen return CurDAG->getTargetNode(PPC::RLWIMI, dl, MVT::i32, Ops, 5); 100950fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 101050fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 1011237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner 1012237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1013237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1014cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 101502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::OR: 1016cccef1c6fffa292c227a289d447f6b848ab56c62Chris Lattner if (N->getValueType(0) == MVT::i32) 1017ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner if (SDNode *I = SelectBitfieldInsert(N)) 1018ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return I; 1019d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 1020237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1021237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1022c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SHL: { 1023c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1024ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::AND, Imm) && 10252d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 1026475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { N->getOperand(0).getOperand(0), 10270b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(SH), getI32Imm(MB), getI32Imm(ME) }; 10280b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 10298d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 10302d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 10312d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 10322d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1033c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 1034c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRL: { 1035c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1036ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::AND, Imm) && 10372d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 1038475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { N->getOperand(0).getOperand(0), 10390b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(SH), getI32Imm(MB), getI32Imm(ME) }; 10400b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 10418d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 10422d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 10432d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 10442d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1045c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 104613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner case ISD::SELECT_CC: { 104713794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(4))->get(); 104813794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner 1049c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner // Handle the setcc cases here. select_cc lhs, 0, 1, 0, cc 105013794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N->getOperand(1))) 105113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N->getOperand(2))) 105213794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N->getOperand(3))) 105313794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (N1C->isNullValue() && N3C->isNullValue() && 1054f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman N2C->getZExtValue() == 1ULL && CC == ISD::SETNE && 1055c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner // FIXME: Implement this optzn for PPC64. 1056c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner N->getValueType(0) == MVT::i32) { 10577e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Tmp = 1058ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen CurDAG->getTargetNode(PPC::ADDIC, dl, MVT::i32, MVT::Flag, 10596da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng N->getOperand(0), getI32Imm(~0U)); 1060ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, 1061475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Tmp, 0), N->getOperand(0), 1062475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Tmp, 1)); 106313794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 10648a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 1065f5f5dce897269885754fc79adeb809194da52942Dale Johannesen SDValue CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC, dl); 1066df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner unsigned BROpc = getPredicateForSetCC(CC); 10678a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 1068919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner unsigned SelectCCOp; 1069c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getValueType(0) == MVT::i32) 1070c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner SelectCCOp = PPC::SELECT_CC_I4; 1071c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner else if (N->getValueType(0) == MVT::i64) 1072c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner SelectCCOp = PPC::SELECT_CC_I8; 1073919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else if (N->getValueType(0) == MVT::f32) 1074919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F4; 1075710ff32983ca919fa0da14e077450b6a7654274fChris Lattner else if (N->getValueType(0) == MVT::f64) 1076919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F8; 1077710ff32983ca919fa0da14e077450b6a7654274fChris Lattner else 1078710ff32983ca919fa0da14e077450b6a7654274fChris Lattner SelectCCOp = PPC::SELECT_CC_VRRC; 1079710ff32983ca919fa0da14e077450b6a7654274fChris Lattner 1080475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { CCReg, N->getOperand(2), N->getOperand(3), 10810b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(BROpc) }; 10820b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, SelectCCOp, N->getValueType(0), Ops, 4); 108313794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 108418258c640466274c26e89016e361ec411ff78520Chris Lattner case PPCISD::COND_BRANCH: { 1085cbb7ab259d08ac5aa5a4764b48628c4bcb5110c7Dan Gohman // Op #0 is the Chain. 108618258c640466274c26e89016e361ec411ff78520Chris Lattner // Op #1 is the PPC::PRED_* number. 108718258c640466274c26e89016e361ec411ff78520Chris Lattner // Op #2 is the CR# 108818258c640466274c26e89016e361ec411ff78520Chris Lattner // Op #3 is the Dest MBB 10898be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman // Op #4 is the Flag. 10902bda17c92229e7116adf2edd3eea98c0a12f43cbEvan Cheng // Prevent PPC::PRED_* from being selected into LI. 1091475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Pred = 1092f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman getI32Imm(cast<ConstantSDNode>(N->getOperand(1))->getZExtValue()); 1093475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Pred, N->getOperand(2), N->getOperand(3), 109418258c640466274c26e89016e361ec411ff78520Chris Lattner N->getOperand(0), N->getOperand(4) }; 109518258c640466274c26e89016e361ec411ff78520Chris Lattner return CurDAG->SelectNodeTo(N, PPC::BCC, MVT::Other, Ops, 5); 109618258c640466274c26e89016e361ec411ff78520Chris Lattner } 109781e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman case ISD::BR_CC: { 10982fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(1))->get(); 1099f5f5dce897269885754fc79adeb809194da52942Dale Johannesen SDValue CondCode = SelectCC(N->getOperand(2), N->getOperand(3), CC, dl); 1100475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { getI32Imm(getPredicateForSetCC(CC)), CondCode, 11010b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng N->getOperand(4), N->getOperand(0) }; 1102289c2d5f4566d8d7722e3934f4763d3df92886f3Chris Lattner return CurDAG->SelectNodeTo(N, PPC::BCC, MVT::Other, Ops, 4); 11032fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 110437efe6764568a3829fee26aba532283131d1a104Nate Begeman case ISD::BRIND: { 1105cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // FIXME: Should custom lower this. 1106475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = N->getOperand(0); 1107475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Target = N->getOperand(1); 11086b76b96c69334f3b6a2a895ff810ed047b4b75e5Chris Lattner unsigned Opc = Target.getValueType() == MVT::i32 ? PPC::MTCTR : PPC::MTCTR8; 1109ed2eee63a6858312ed17582d8cb85a6856d8eb34Dale Johannesen Chain = SDValue(CurDAG->getTargetNode(Opc, dl, MVT::Other, Target, 111037efe6764568a3829fee26aba532283131d1a104Nate Begeman Chain), 0); 111195514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng return CurDAG->SelectNodeTo(N, PPC::BCTR, MVT::Other, Chain); 111237efe6764568a3829fee26aba532283131d1a104Nate Begeman } 1113ee5c2b8ba2bd9670931705ca04a46052d534ade9Evan Cheng case ISD::DECLARE: { 1114ee5c2b8ba2bd9670931705ca04a46052d534ade9Evan Cheng SDValue Chain = N->getOperand(0); 1115ee5c2b8ba2bd9670931705ca04a46052d534ade9Evan Cheng SDValue N1 = N->getOperand(1); 1116ee5c2b8ba2bd9670931705ca04a46052d534ade9Evan Cheng SDValue N2 = N->getOperand(2); 1117ee5c2b8ba2bd9670931705ca04a46052d534ade9Evan Cheng FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(N1); 1118f902d246b69c972fa3e8f652b44d10abbb1f9355Chris Lattner 1119f902d246b69c972fa3e8f652b44d10abbb1f9355Chris Lattner // FIXME: We need to handle this for VLAs. 1120f902d246b69c972fa3e8f652b44d10abbb1f9355Chris Lattner if (!FINode) { 1121f902d246b69c972fa3e8f652b44d10abbb1f9355Chris Lattner ReplaceUses(Op.getValue(0), Chain); 1122f902d246b69c972fa3e8f652b44d10abbb1f9355Chris Lattner return NULL; 1123f902d246b69c972fa3e8f652b44d10abbb1f9355Chris Lattner } 1124f902d246b69c972fa3e8f652b44d10abbb1f9355Chris Lattner 11255fc742d5b2b647b3dce2c9ba943a2499d980c347Evan Cheng if (N2.getOpcode() == ISD::ADD) { 11265fc742d5b2b647b3dce2c9ba943a2499d980c347Evan Cheng if (N2.getOperand(0).getOpcode() == ISD::ADD && 11275fc742d5b2b647b3dce2c9ba943a2499d980c347Evan Cheng N2.getOperand(0).getOperand(0).getOpcode() == PPCISD::GlobalBaseReg && 11285fc742d5b2b647b3dce2c9ba943a2499d980c347Evan Cheng N2.getOperand(0).getOperand(1).getOpcode() == PPCISD::Hi && 11295fc742d5b2b647b3dce2c9ba943a2499d980c347Evan Cheng N2.getOperand(1).getOpcode() == PPCISD::Lo) 11305fc742d5b2b647b3dce2c9ba943a2499d980c347Evan Cheng N2 = N2.getOperand(0).getOperand(1).getOperand(0); 11315fc742d5b2b647b3dce2c9ba943a2499d980c347Evan Cheng else if (N2.getOperand(0).getOpcode() == ISD::ADD && 1132c1a168a0fcbc7483a879e617e91824c4a7e6eeceEvan Cheng N2.getOperand(0).getOperand(0).getOpcode() == PPCISD::GlobalBaseReg && 1133c1a168a0fcbc7483a879e617e91824c4a7e6eeceEvan Cheng N2.getOperand(0).getOperand(1).getOpcode() == PPCISD::Lo && 11345fc742d5b2b647b3dce2c9ba943a2499d980c347Evan Cheng N2.getOperand(1).getOpcode() == PPCISD::Hi) 11355fc742d5b2b647b3dce2c9ba943a2499d980c347Evan Cheng N2 = N2.getOperand(0).getOperand(1).getOperand(0); 11365fc742d5b2b647b3dce2c9ba943a2499d980c347Evan Cheng else if (N2.getOperand(0).getOpcode() == PPCISD::Hi && 11375fc742d5b2b647b3dce2c9ba943a2499d980c347Evan Cheng N2.getOperand(1).getOpcode() == PPCISD::Lo) 11385fc742d5b2b647b3dce2c9ba943a2499d980c347Evan Cheng N2 = N2.getOperand(0).getOperand(0); 11395fc742d5b2b647b3dce2c9ba943a2499d980c347Evan Cheng } 1140f902d246b69c972fa3e8f652b44d10abbb1f9355Chris Lattner 1141f902d246b69c972fa3e8f652b44d10abbb1f9355Chris Lattner // If we don't have a global address here, the debug info is mangled, just 1142f902d246b69c972fa3e8f652b44d10abbb1f9355Chris Lattner // drop it. 1143f902d246b69c972fa3e8f652b44d10abbb1f9355Chris Lattner if (!isa<GlobalAddressSDNode>(N2)) { 1144f902d246b69c972fa3e8f652b44d10abbb1f9355Chris Lattner ReplaceUses(Op.getValue(0), Chain); 1145f902d246b69c972fa3e8f652b44d10abbb1f9355Chris Lattner return NULL; 1146f902d246b69c972fa3e8f652b44d10abbb1f9355Chris Lattner } 1147ee5c2b8ba2bd9670931705ca04a46052d534ade9Evan Cheng int FI = cast<FrameIndexSDNode>(N1)->getIndex(); 1148ee5c2b8ba2bd9670931705ca04a46052d534ade9Evan Cheng GlobalValue *GV = cast<GlobalAddressSDNode>(N2)->getGlobal(); 1149ee5c2b8ba2bd9670931705ca04a46052d534ade9Evan Cheng SDValue Tmp1 = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy()); 1150ee5c2b8ba2bd9670931705ca04a46052d534ade9Evan Cheng SDValue Tmp2 = CurDAG->getTargetGlobalAddress(GV, TLI.getPointerTy()); 1151ee5c2b8ba2bd9670931705ca04a46052d534ade9Evan Cheng return CurDAG->SelectNodeTo(N, TargetInstrInfo::DECLARE, 1152ee5c2b8ba2bd9670931705ca04a46052d534ade9Evan Cheng MVT::Other, Tmp1, Tmp2, Chain); 1153ee5c2b8ba2bd9670931705ca04a46052d534ade9Evan Cheng } 1154a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 115525dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner 11569ade218533429146731213eacb7e12060e65ff58Evan Cheng return SelectCode(Op); 1157a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1158a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1159a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1160cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 11611d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman/// createPPCISelDag - This pass converts a legalized DAG into a 1162a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// PowerPC-specific DAG, ready for instruction scheduling. 1163a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// 1164c4c6257c1a154279bf10e9498d46d6c1793dbaa7Evan ChengFunctionPass *llvm::createPPCISelDag(PPCTargetMachine &TM) { 11651d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman return new PPCDAGToDAGISel(TM); 1166a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1167a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1168