PPCISelDAGToDAG.cpp revision 93c53e5583427ee567293a9a21c6c76fccf218ca
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" 2384bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineRegisterInfo.h" 24a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/CodeGen/SelectionDAG.h" 25a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/CodeGen/SelectionDAGISel.h" 26a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Target/TargetOptions.h" 272fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner#include "llvm/Constants.h" 284416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner#include "llvm/GlobalValue.h" 29420736dc85c01702bb7bc40495f8a4be5e5f8a6cChris Lattner#include "llvm/Intrinsics.h" 30a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Support/Debug.h" 31a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner#include "llvm/Support/MathExtras.h" 32a4f0b3a084d120cfc5b5bb06f64b222f5cb72740Chris Lattner#include "llvm/Support/Compiler.h" 332ef88a09b71f458ad415b35a1fb431c3d15d7eb1Evan Cheng#include <queue> 34ba2f0a9ee53512ce840aca34281e126802a125d1Evan Cheng#include <set> 35a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnerusing namespace llvm; 36a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 37a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattnernamespace { 38a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner //===--------------------------------------------------------------------===// 391d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman /// PPCDAGToDAGISel - PPC specific code to select PPC machine 40a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// instructions for SelectionDAG operations. 41a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// 422a41a98fb70923e2d6780220eb225ac0e8b4ff36Chris Lattner class VISIBILITY_HIDDEN PPCDAGToDAGISel : public SelectionDAGISel { 434bb189507281af0da8aff91743b5198acbf2398bChris Lattner PPCTargetMachine &TM; 4421e463b2bf864671a87ebe386cb100ef9349a540Nate Begeman PPCTargetLowering PPCLowering; 45152b7e18748f7e06a93260f22cc9dac8eb3abee2Evan Cheng const PPCSubtarget &PPCSubTarget; 464416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner unsigned GlobalBaseReg; 47a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner public: 481002c0203450620594a85454c6a095ca94b87cb2Dan Gohman explicit PPCDAGToDAGISel(PPCTargetMachine &tm) 494bb189507281af0da8aff91743b5198acbf2398bChris Lattner : SelectionDAGISel(PPCLowering), TM(tm), 50152b7e18748f7e06a93260f22cc9dac8eb3abee2Evan Cheng PPCLowering(*TM.getTargetLowering()), 51152b7e18748f7e06a93260f22cc9dac8eb3abee2Evan Cheng PPCSubTarget(*TM.getSubtargetImpl()) {} 52a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 534416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner virtual bool runOnFunction(Function &Fn) { 544416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Make sure we re-emit a set of the global base reg if necessary 554416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner GlobalBaseReg = 0; 564bb189507281af0da8aff91743b5198acbf2398bChris Lattner SelectionDAGISel::runOnFunction(Fn); 574bb189507281af0da8aff91743b5198acbf2398bChris Lattner 584bb189507281af0da8aff91743b5198acbf2398bChris Lattner InsertVRSaveCode(Fn); 594bb189507281af0da8aff91743b5198acbf2398bChris Lattner return true; 604416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 614416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 62a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// getI32Imm - Return a target constant with the specified value, of type 63a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// i32. 64475871a144eb604ddaf37503397ba0941442e5fbDan Gohman inline SDValue getI32Imm(unsigned Imm) { 65a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return CurDAG->getTargetConstant(Imm, MVT::i32); 66a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 674416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 68c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// getI64Imm - Return a target constant with the specified value, of type 69c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// i64. 70475871a144eb604ddaf37503397ba0941442e5fbDan Gohman inline SDValue getI64Imm(uint64_t Imm) { 71c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return CurDAG->getTargetConstant(Imm, MVT::i64); 72c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 73c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 74c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// getSmallIPtrImm - Return a target constant of pointer type. 75475871a144eb604ddaf37503397ba0941442e5fbDan Gohman inline SDValue getSmallIPtrImm(unsigned Imm) { 76c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return CurDAG->getTargetConstant(Imm, PPCLowering.getPointerTy()); 77c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 78c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 79f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s 80f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// with any number of 0s on either side. The 1s are allowed to wrap from 81f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// LSB to MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 82f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// 0x0F0F0000 is not, since all 1s are not contiguous. 83f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman static bool isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME); 84f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman 85f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman 86f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// isRotateAndMask - Returns true if Mask and Shift can be folded into a 87f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman /// rotate and mask opcode and mask operation. 88f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman static bool isRotateAndMask(SDNode *N, unsigned Mask, bool IsShiftMask, 89f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman unsigned &SH, unsigned &MB, unsigned &ME); 90c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 914416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// getGlobalBaseReg - insert code into the entry mbb to materialize the PIC 924416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner /// base register. Return the virtual register that holds this value. 939ade218533429146731213eacb7e12060e65ff58Evan Cheng SDNode *getGlobalBaseReg(); 94a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 95a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // Select - Convert the specified operand from a target-independent to a 96a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner // target-specific node if it hasn't already been changed. 97475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDNode *Select(SDValue Op); 98a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 9902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDNode *SelectBitfieldInsert(SDNode *N); 10002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 1012fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// SelectCC - Select a comparison of the specified values with the 1022fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner /// specified condition code, returning the CR# of the expression. 103475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue SelectCC(SDValue LHS, SDValue RHS, ISD::CondCode CC); 1042fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 1057fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrImm - Returns true if the address N can be represented by 1067fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// a base register plus a signed 16-bit displacement [r+imm]. 107475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool SelectAddrImm(SDValue Op, SDValue N, SDValue &Disp, 108475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Base) { 109fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner return PPCLowering.SelectAddressRegImm(N, Disp, Base, *CurDAG); 110fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner } 11174531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner 11274531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner /// SelectAddrImmOffs - Return true if the operand is valid for a preinc 11374531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner /// immediate field. Because preinc imms have already been validated, just 11474531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner /// accept it. 115475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool SelectAddrImmOffs(SDValue Op, SDValue N, SDValue &Out) const { 11674531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner Out = N; 11774531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner return true; 11874531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner } 1197fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman 1207fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrIdx - Given the specified addressed, check to see if it can be 1217fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// represented as an indexed [r+r] operation. Returns false if it can 1227fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// be represented by [r+imm], which are preferred. 123475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool SelectAddrIdx(SDValue Op, SDValue N, SDValue &Base, 124475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Index) { 125fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner return PPCLowering.SelectAddressRegReg(N, Base, Index, *CurDAG); 126fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner } 127f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman 1287fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// SelectAddrIdxOnly - Given the specified addressed, force it to be 1297fd1edd32e9a6782dbcd00818bbdaf82f14284a1Nate Begeman /// represented as an indexed [r+r] operation. 130475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool SelectAddrIdxOnly(SDValue Op, SDValue N, SDValue &Base, 131475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Index) { 132fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner return PPCLowering.SelectAddressRegRegOnly(N, Base, Index, *CurDAG); 133fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner } 1349944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 135e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// SelectAddrImmShift - Returns true if the address N can be represented by 136e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// a base register plus a signed 14-bit displacement [r+imm*4]. Suitable 137e5ba580ab05b18eaa9fd4d36e31466e41f693ad9Chris Lattner /// for use by STD and friends. 138475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool SelectAddrImmShift(SDValue Op, SDValue N, SDValue &Disp, 139475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Base) { 140fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner return PPCLowering.SelectAddressRegImmShift(N, Disp, Base, *CurDAG); 141fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner } 142fc5b1ab94959879a91c34aee8859e652a50270d0Chris Lattner 143e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner /// SelectInlineAsmMemoryOperand - Implement addressing mode selection for 144e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner /// inline asm expressions. 145475871a144eb604ddaf37503397ba0941442e5fbDan Gohman virtual bool SelectInlineAsmMemoryOperand(const SDValue &Op, 146e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner char ConstraintCode, 147f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman std::vector<SDValue> &OutOps) { 148475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op0, Op1; 149e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner switch (ConstraintCode) { 150e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner default: return true; 151e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'm': // memory 1520d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng if (!SelectAddrIdx(Op, Op, Op0, Op1)) 1530d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng SelectAddrImm(Op, Op, Op0, Op1); 154e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 155e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'o': // offsetable 1560d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng if (!SelectAddrImm(Op, Op, Op0, Op1)) { 1576da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng Op0 = Op; 1586da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(Op0); // r+0. 159c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Op1 = getSmallIPtrImm(0); 160e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 161e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 162e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'v': // not offsetable 1630d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng SelectAddrIdxOnly(Op, Op, Op0, Op1); 164e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 165e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 166e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner 167e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner OutOps.push_back(Op0); 168e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner OutOps.push_back(Op1); 169e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner return false; 170e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 171e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner 172475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue BuildSDIVSequence(SDNode *N); 173475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue BuildUDIVSequence(SDNode *N); 174047b952e298352fe6feffedf02e359601133f465Chris Lattner 175db8d56b825efeb576d67b9dbe39d736d93306222Evan Cheng /// InstructionSelect - This callback is invoked by 176a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 177f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman virtual void InstructionSelect(); 178bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 1794bb189507281af0da8aff91743b5198acbf2398bChris Lattner void InsertVRSaveCode(Function &Fn); 1804bb189507281af0da8aff91743b5198acbf2398bChris Lattner 181a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner virtual const char *getPassName() const { 182a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return "PowerPC DAG->DAG Pattern Instruction Selection"; 183a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 184c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner 185c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner /// CreateTargetHazardRecognizer - Return the hazard recognizer to use for 186c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner /// this target when scheduling the DAG. 187b0d21ef20c29f4ea46d21b488f17feaa6a8760e1Chris Lattner virtual HazardRecognizer *CreateTargetHazardRecognizer() { 188c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner // Should use subtarget info to pick the right hazard recognizer. For 189c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner // now, always return a PPC970 recognizer. 19088d211f82304e53694ece666d4a2507b170e4582Chris Lattner const TargetInstrInfo *II = PPCLowering.getTargetMachine().getInstrInfo(); 19188d211f82304e53694ece666d4a2507b170e4582Chris Lattner assert(II && "No InstrInfo?"); 19288d211f82304e53694ece666d4a2507b170e4582Chris Lattner return new PPCHazardRecognizer970(*II); 193c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner } 194af165385112037cb942e94ea562a67990b7d6220Chris Lattner 195af165385112037cb942e94ea562a67990b7d6220Chris Lattner// Include the pieces autogenerated from the target description. 1964c7b43b43fdf943c7298718e15ab5d6dfe345be7Chris Lattner#include "PPCGenDAGISel.inc" 197bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 198bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattnerprivate: 199475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDNode *SelectSETCC(SDValue Op); 200a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner }; 201a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 202a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 203db8d56b825efeb576d67b9dbe39d736d93306222Evan Cheng/// InstructionSelect - This callback is invoked by 204bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner/// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 205f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohmanvoid PPCDAGToDAGISel::InstructionSelect() { 206bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DEBUG(BB->dump()); 207bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 208bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Select target instructions for the DAG. 209ad3460c3c968e33c5b9a07104b9fe5a5c27ff55bDan Gohman SelectRoot(); 210f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman CurDAG->RemoveDeadNodes(); 2114bb189507281af0da8aff91743b5198acbf2398bChris Lattner} 2124bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2134bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// InsertVRSaveCode - Once the entire function has been instruction selected, 2144bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// all virtual registers are created and all machine instructions are built, 2154bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// check to see if we need to save/restore VRSAVE. If so, do it. 2164bb189507281af0da8aff91743b5198acbf2398bChris Lattnervoid PPCDAGToDAGISel::InsertVRSaveCode(Function &F) { 2171877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // Check to see if this function uses vector registers, which means we have to 2181877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // save and restore the VRSAVE register and update it with the regs we use. 2191877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2201877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // In this case, there will be virtual registers of vector type type created 2211877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // by the scheduler. Detect them now. 2224bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineFunction &Fn = MachineFunction::get(&F); 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(); 2494bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Emit the following code into the entry block: 2504bb189507281af0da8aff91743b5198acbf2398bChris Lattner // InVRSAVE = MFVRSAVE 2514bb189507281af0da8aff91743b5198acbf2398bChris Lattner // UpdatedVRSAVE = UPDATE_VRSAVE InVRSAVE 2524bb189507281af0da8aff91743b5198acbf2398bChris Lattner // MTVRSAVE UpdatedVRSAVE 2534bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock::iterator IP = EntryBB.begin(); // Insert Point 254c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(EntryBB, IP, TII.get(PPC::MFVRSAVE), InVRSAVE); 25569244300b8a0112efb44b6273ecea4ca6264b8cfChris Lattner BuildMI(EntryBB, IP, TII.get(PPC::UPDATE_VRSAVE), 25669244300b8a0112efb44b6273ecea4ca6264b8cfChris Lattner UpdatedVRSAVE).addReg(InVRSAVE); 257c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(EntryBB, IP, TII.get(PPC::MTVRSAVE)).addReg(UpdatedVRSAVE); 2584bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2594bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Find all return blocks, outputting a restore in each epilog. 2604bb189507281af0da8aff91743b5198acbf2398bChris Lattner for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 261749c6f6b5ed301c84aac562e414486549d7b98ebChris Lattner if (!BB->empty() && BB->back().getDesc().isReturn()) { 2624bb189507281af0da8aff91743b5198acbf2398bChris Lattner IP = BB->end(); --IP; 2634bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2644bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Skip over all terminator instructions, which are part of the return 2654bb189507281af0da8aff91743b5198acbf2398bChris Lattner // sequence. 2664bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock::iterator I2 = IP; 267749c6f6b5ed301c84aac562e414486549d7b98ebChris Lattner while (I2 != BB->begin() && (--I2)->getDesc().isTerminator()) 2684bb189507281af0da8aff91743b5198acbf2398bChris Lattner IP = I2; 2694bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2704bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Emit: MTVRSAVE InVRSave 271c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(*BB, IP, TII.get(PPC::MTVRSAVE)).addReg(InVRSAVE); 2724bb189507281af0da8aff91743b5198acbf2398bChris Lattner } 2731877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner } 274bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner} 2756cd40d5888f905a3820d5d6c71e57cc0e02abb4aChris Lattner 2764bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2774416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// getGlobalBaseReg - Output the instructions required to put the 2784416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// base address to use for accessing globals into a register. 2794416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// 2809ade218533429146731213eacb7e12060e65ff58Evan ChengSDNode *PPCDAGToDAGISel::getGlobalBaseReg() { 2814416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (!GlobalBaseReg) { 282c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng const TargetInstrInfo &TII = *TM.getInstrInfo(); 2834416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Insert the set of GlobalBaseReg into the first MBB of the function 2844416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock &FirstMBB = BB->getParent()->front(); 2854416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock::iterator MBBI = FirstMBB.begin(); 286c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 287d10434215da983b58389d2a0880dfcd2cd3b7f35Chris Lattner if (PPCLowering.getPointerTy() == MVT::i32) { 28884bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner GlobalBaseReg = RegInfo->createVirtualRegister(PPC::GPRCRegisterClass); 289c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(FirstMBB, MBBI, TII.get(PPC::MovePCtoLR), PPC::LR); 290c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(FirstMBB, MBBI, TII.get(PPC::MFLR), GlobalBaseReg); 291d10434215da983b58389d2a0880dfcd2cd3b7f35Chris Lattner } else { 29284bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner GlobalBaseReg = RegInfo->createVirtualRegister(PPC::G8RCRegisterClass); 293c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(FirstMBB, MBBI, TII.get(PPC::MovePCtoLR8), PPC::LR8); 294c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(FirstMBB, MBBI, TII.get(PPC::MFLR8), GlobalBaseReg); 295d10434215da983b58389d2a0880dfcd2cd3b7f35Chris Lattner } 2964416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 29793c53e5583427ee567293a9a21c6c76fccf218caGabor Greif return CurDAG->getRegister(GlobalBaseReg, 29893c53e5583427ee567293a9a21c6c76fccf218caGabor Greif PPCLowering.getPointerTy()).getNode(); 2994416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner} 3004416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 301c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isIntS16Immediate - This method tests to see if the node is either a 32-bit 302c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// or 64-bit immediate, and if the value can be accurately represented as a 303c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// sign extension from a 16-bit value. If so, this returns true and the 304c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// immediate. 305c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isIntS16Immediate(SDNode *N, short &Imm) { 306c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getOpcode() != ISD::Constant) 307c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return false; 3084416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 309c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Imm = (short)cast<ConstantSDNode>(N)->getValue(); 310c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getValueType(0) == MVT::i32) 311c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return Imm == (int32_t)cast<ConstantSDNode>(N)->getValue(); 312c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner else 313c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return Imm == (int64_t)cast<ConstantSDNode>(N)->getValue(); 314c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 315c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 316475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanstatic bool isIntS16Immediate(SDValue Op, short &Imm) { 317ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return isIntS16Immediate(Op.getNode(), Imm); 318c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 319c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 320c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 321c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isInt32Immediate - This method tests to see if the node is a 32-bit constant 322c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// operand. If so Imm will receive the 32-bit value. 323c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isInt32Immediate(SDNode *N, unsigned &Imm) { 324c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i32) { 3250f3257a3302b60c128a667db6736e81335316c1eNate Begeman Imm = cast<ConstantSDNode>(N)->getValue(); 3260f3257a3302b60c128a667db6736e81335316c1eNate Begeman return true; 3270f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 3280f3257a3302b60c128a667db6736e81335316c1eNate Begeman return false; 3290f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 3300f3257a3302b60c128a667db6736e81335316c1eNate Begeman 331c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isInt64Immediate - This method tests to see if the node is a 64-bit constant 332c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// operand. If so Imm will receive the 64-bit value. 333c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isInt64Immediate(SDNode *N, uint64_t &Imm) { 334711762497c27357adc1edf8d4237c2770fa303bbChris Lattner if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i64) { 335c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Imm = cast<ConstantSDNode>(N)->getValue(); 336c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return true; 337c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 338c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return false; 339c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 340c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 341c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// isInt32Immediate - This method tests to see if a constant operand. 342c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// If so Imm will receive the 32 bit value. 343475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanstatic bool isInt32Immediate(SDValue N, unsigned &Imm) { 344ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return isInt32Immediate(N.getNode(), Imm); 345c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 346c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 347c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 348c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// isOpcWithIntImmediate - This method tests to see if the node is a specific 349c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// opcode and that it has a immediate integer right operand. 350c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// If so Imm will receive the 32 bit value. 351c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isOpcWithIntImmediate(SDNode *N, unsigned Opc, unsigned& Imm) { 35293c53e5583427ee567293a9a21c6c76fccf218caGabor Greif return N->getOpcode() == Opc 35393c53e5583427ee567293a9a21c6c76fccf218caGabor Greif && isInt32Immediate(N->getOperand(1).getNode(), Imm); 354c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 355c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 356f42f133938545d4f5c249bcfef63db772ce8e942Nate Begemanbool PPCDAGToDAGISel::isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME) { 357cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isShiftedMask_32(Val)) { 358cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first non-zero bit 359cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman MB = CountLeadingZeros_32(Val); 360cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first zero bit after the run of ones 361cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman ME = CountLeadingZeros_32((Val - 1) ^ Val); 362cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return true; 3632fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } else { 3642fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner Val = ~Val; // invert mask 3652fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner if (isShiftedMask_32(Val)) { 3662fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first zero bit 3672fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner ME = CountLeadingZeros_32(Val) - 1; 3682fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first one bit after the run of zeros 3692fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner MB = CountLeadingZeros_32((Val - 1) ^ Val) + 1; 3702fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner return true; 3712fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } 372cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 373cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // no run present 374cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 375cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 376cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 377f42f133938545d4f5c249bcfef63db772ce8e942Nate Begemanbool PPCDAGToDAGISel::isRotateAndMask(SDNode *N, unsigned Mask, 378f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman bool IsShiftMask, unsigned &SH, 379f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman unsigned &MB, unsigned &ME) { 380da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // Don't even go down this path for i64, since different logic will be 381da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // necessary for rldicl/rldicr/rldimi. 382da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman if (N->getValueType(0) != MVT::i32) 383da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman return false; 384da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman 385cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Shift = 32; 386cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Indeterminant = ~0; // bit mask marking indeterminant results 387cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Opcode = N->getOpcode(); 38815055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner if (N->getNumOperands() != 2 || 389ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif !isInt32Immediate(N->getOperand(1).getNode(), Shift) || (Shift > 31)) 390cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 391cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 392cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Opcode == ISD::SHL) { 393cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift left to mask if it comes first 394cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask << Shift; 395cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 396cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu << Shift); 397651dea74f6a362d30bc61fd0b549da7707af5bf8Chris Lattner } else if (Opcode == ISD::SRL) { 398cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift right to mask if it comes first 399cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask >> Shift; 400cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 401cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu >> Shift); 402cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // adjust for the left rotate 403cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Shift = 32 - Shift; 404f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman } else if (Opcode == ISD::ROTL) { 405f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman Indeterminant = 0; 406cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 407cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 408cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 409cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 410cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // if the mask doesn't intersect any Indeterminant bits 411cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Mask && !(Mask & Indeterminant)) { 4120949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner SH = Shift & 31; 413cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // make sure the mask is still a mask (wrap arounds may not be) 414cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return isRunOfOnes(Mask, MB, ME); 415cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 416cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 417cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 418cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 41902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// SelectBitfieldInsert - turn an or of two masked values into 42002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// the rotate left word immediate then mask insert (rlwimi) instruction. 4211d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDNode *PPCDAGToDAGISel::SelectBitfieldInsert(SDNode *N) { 422475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op0 = N->getOperand(0); 423475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op1 = N->getOperand(1); 42402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 425b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman APInt LKZ, LKO, RKZ, RKO; 426b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman CurDAG->ComputeMaskedBits(Op0, APInt::getAllOnesValue(32), LKZ, LKO); 427b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman CurDAG->ComputeMaskedBits(Op1, APInt::getAllOnesValue(32), RKZ, RKO); 42802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 429b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman unsigned TargetMask = LKZ.getZExtValue(); 430b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman unsigned InsertMask = RKZ.getZExtValue(); 4314667f2cbad246beccfca5411a26add24d1007035Nate Begeman 4324667f2cbad246beccfca5411a26add24d1007035Nate Begeman if ((TargetMask | InsertMask) == 0xFFFFFFFF) { 4334667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Op0Opc = Op0.getOpcode(); 4344667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Op1Opc = Op1.getOpcode(); 4354667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Value, SH = 0; 4364667f2cbad246beccfca5411a26add24d1007035Nate Begeman TargetMask = ~TargetMask; 4374667f2cbad246beccfca5411a26add24d1007035Nate Begeman InsertMask = ~InsertMask; 43877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 4394667f2cbad246beccfca5411a26add24d1007035Nate Begeman // If the LHS has a foldable shift and the RHS does not, then swap it to the 4404667f2cbad246beccfca5411a26add24d1007035Nate Begeman // RHS so that we can fold the shift into the insert. 44177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op0Opc == ISD::AND && Op1Opc == ISD::AND) { 44277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op0.getOperand(0).getOpcode() == ISD::SHL || 44377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op0.getOperand(0).getOpcode() == ISD::SRL) { 44477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op1.getOperand(0).getOpcode() != ISD::SHL && 44577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1.getOperand(0).getOpcode() != ISD::SRL) { 44677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman std::swap(Op0, Op1); 44777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman std::swap(Op0Opc, Op1Opc); 4484667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(TargetMask, InsertMask); 44977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 45077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 4514667f2cbad246beccfca5411a26add24d1007035Nate Begeman } else if (Op0Opc == ISD::SHL || Op0Opc == ISD::SRL) { 4524667f2cbad246beccfca5411a26add24d1007035Nate Begeman if (Op1Opc == ISD::AND && Op1.getOperand(0).getOpcode() != ISD::SHL && 4534667f2cbad246beccfca5411a26add24d1007035Nate Begeman Op1.getOperand(0).getOpcode() != ISD::SRL) { 4544667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(Op0, Op1); 4554667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(Op0Opc, Op1Opc); 4564667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(TargetMask, InsertMask); 4574667f2cbad246beccfca5411a26add24d1007035Nate Begeman } 45802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 45977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 46077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman unsigned MB, ME; 4610949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner if (InsertMask && isRunOfOnes(InsertMask, MB, ME)) { 462475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp1, Tmp2, Tmp3; 4634667f2cbad246beccfca5411a26add24d1007035Nate Begeman bool DisjointMask = (TargetMask ^ InsertMask) == 0xFFFFFFFF; 46477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 46577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if ((Op1Opc == ISD::SHL || Op1Opc == ISD::SRL) && 466c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(Op1.getOperand(1), Value)) { 46777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0); 46877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SH = (Op1Opc == ISD::SHL) ? Value : 32 - Value; 46902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 47077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op1Opc == ISD::AND) { 47177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman unsigned SHOpc = Op1.getOperand(0).getOpcode(); 47277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if ((SHOpc == ISD::SHL || SHOpc == ISD::SRL) && 473c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(Op1.getOperand(0).getOperand(1), Value)) { 47477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0).getOperand(0); 47577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SH = (SHOpc == ISD::SHL) ? Value : 32 - Value; 47677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } else { 47777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0); 47877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 47902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 48077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 48177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Tmp3 = (Op0Opc == ISD::AND && DisjointMask) ? Op0.getOperand(0) : Op0; 4826da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(Tmp3); 4836da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(Op1); 4840949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner SH &= 31; 485475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Tmp3, Op1, getI32Imm(SH), getI32Imm(MB), 4860b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(ME) }; 4870b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, Ops, 5); 48802b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 48902b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 49002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 49102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman} 49202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 4932fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// SelectCC - Select a comparison of the specified values with the specified 4942fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// condition code, returning the CR# of the expression. 495475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue PPCDAGToDAGISel::SelectCC(SDValue LHS, SDValue RHS, 4961d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman ISD::CondCode CC) { 4972fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Always select the LHS. 4986da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(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)) 507475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(CurDAG->getTargetNode(PPC::CMPLWI, 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)) 511475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(CurDAG->getTargetNode(PPC::CMPWI, 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 523475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Xor(CurDAG->getTargetNode(PPC::XORIS, MVT::i32, LHS, 5243836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner getI32Imm(Imm >> 16)), 0); 525475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(CurDAG->getTargetNode(PPC::CMPLWI, 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)) 531475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(CurDAG->getTargetNode(PPC::CMPLWI, 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)) 537475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(CurDAG->getTargetNode(PPC::CMPWI, 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)) 548475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(CurDAG->getTargetNode(PPC::CMPLDI, 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)) 552475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(CurDAG->getTargetNode(PPC::CMPDI, 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)) { 565475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Xor(CurDAG->getTargetNode(PPC::XORIS8, MVT::i64, LHS, 566711762497c27357adc1edf8d4237c2770fa303bbChris Lattner getI64Imm(Imm >> 16)), 0); 567475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(CurDAG->getTargetNode(PPC::CMPLDI, 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)) 574475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(CurDAG->getTargetNode(PPC::CMPLDI, 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)) 580475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(CurDAG->getTargetNode(PPC::CMPDI, 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 } 5916da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(RHS); 592475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue(CurDAG->getTargetNode(Opc, MVT::i32, LHS, RHS), 0); 5932fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 5942fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 595df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattnerstatic PPC::Predicate getPredicateForSetCC(ISD::CondCode CC) { 5962fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner switch (CC) { 5972fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 598ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOEQ: // FIXME: This is incorrect see PR642. 5995d634ce466173f6fde49470fad125eb09532caebChris Lattner case ISD::SETUEQ: 600df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETEQ: return PPC::PRED_EQ; 601ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETONE: // FIXME: This is incorrect see PR642. 6025d634ce466173f6fde49470fad125eb09532caebChris Lattner case ISD::SETUNE: 603df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETNE: return PPC::PRED_NE; 604ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLT: // FIXME: This is incorrect see PR642. 6052fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULT: 606df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETLT: return PPC::PRED_LT; 607ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLE: // FIXME: This is incorrect see PR642. 6082fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULE: 609df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETLE: return PPC::PRED_LE; 610ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGT: // FIXME: This is incorrect see PR642. 6112fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGT: 612df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETGT: return PPC::PRED_GT; 613ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGE: // FIXME: This is incorrect see PR642. 6142fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGE: 615df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETGE: return PPC::PRED_GE; 6166df2507121507c24d7155605c343e467e0106c07Chris Lattner 617df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETO: return PPC::PRED_NU; 618df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETUO: return PPC::PRED_UN; 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) { 63264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 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 647fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETULT: Other = 0; return 3; // SETOLT | SETUO 648fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETUGT: Other = 1; return 3; // SETOGT | SETUO 649fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETUEQ: Other = 2; return 3; // SETOEQ | SETUO 650fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETOGE: Other = 1; return 2; // SETOGT | SETOEQ 651fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETOLE: Other = 0; return 2; // SETOLT | SETOEQ 652fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETONE: Other = 0; return 1; // SETOLT | SETOGT 65364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 65464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner return 0; 65564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner} 6569944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 657475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDNode *PPCDAGToDAGISel::SelectSETCC(SDValue Op) { 658ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif SDNode *N = Op.getNode(); 659222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Imm; 660222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get(); 661c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm)) { 662222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // We can codegen setcc op, imm very efficiently compared to a brcond. 663222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Check for those cases here. 664222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // setcc op, 0 665222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (Imm == 0) { 666475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op = N->getOperand(0); 6676da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(Op); 668222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 669dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 6700b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng case ISD::SETEQ: { 671475871a144eb604ddaf37503397ba0941442e5fbDan Gohman Op = SDValue(CurDAG->getTargetNode(PPC::CNTLZW, MVT::i32, Op), 0); 672475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Op, getI32Imm(27), getI32Imm(5), getI32Imm(31) }; 6730b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 6740b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng } 675dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 676475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue AD = 677475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 6787e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(~0U)), 0); 67971d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, 68095514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng AD.getValue(1)); 681dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 6820b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng case ISD::SETLT: { 683475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Op, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 6840b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 6850b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng } 686dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETGT: { 687475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue T = 688475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(CurDAG->getTargetNode(PPC::NEG, MVT::i32, Op), 0); 689475871a144eb604ddaf37503397ba0941442e5fbDan Gohman T = SDValue(CurDAG->getTargetNode(PPC::ANDC, MVT::i32, T, Op), 0); 690475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { T, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 6910b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 692dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 693222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 694222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else if (Imm == ~0U) { // setcc op, -1 695475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op = N->getOperand(0); 6966da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(Op); 697222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 698dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 699dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETEQ: 700475871a144eb604ddaf37503397ba0941442e5fbDan Gohman Op = SDValue(CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 7017e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(1)), 0); 70271d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 703475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(CurDAG->getTargetNode(PPC::LI, MVT::i32, 7047e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(0)), 0), 70595514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng Op.getValue(1)); 706dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 707475871a144eb604ddaf37503397ba0941442e5fbDan Gohman Op = SDValue(CurDAG->getTargetNode(PPC::NOR, MVT::i32, Op, Op), 0); 7087e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *AD = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 7097e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(~0U)); 710475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, SDValue(AD, 0), 711475871a144eb604ddaf37503397ba0941442e5fbDan Gohman Op, SDValue(AD, 1)); 712dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 713dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETLT: { 714475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue AD = SDValue(CurDAG->getTargetNode(PPC::ADDI, MVT::i32, Op, 7157e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(1)), 0); 716475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue AN = SDValue(CurDAG->getTargetNode(PPC::AND, MVT::i32, AD, 7177e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op), 0); 718475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { AN, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 7190b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 720dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 7210b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng case ISD::SETGT: { 722475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Op, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 723475871a144eb604ddaf37503397ba0941442e5fbDan Gohman Op = SDValue(CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Ops, 4), 0); 724ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Op, 72595514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng getI32Imm(1)); 726222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 7270b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng } 728222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 729222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 730222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 731222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner bool Inv; 732fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner int OtherCondIdx; 733fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner unsigned Idx = getCRIdxForSetCC(CC, Inv, OtherCondIdx); 734475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 735475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue IntCR; 736222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 737222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Force the ccreg into CR7. 738475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CR7Reg = CurDAG->getRegister(PPC::CR7, MVT::i32); 739222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 740475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue InFlag(0, 0); // Null incoming flag value. 741db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner CCReg = CurDAG->getCopyToReg(CurDAG->getEntryNode(), CR7Reg, CCReg, 742db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner InFlag).getValue(1); 743222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 744fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner if (PPCSubTarget.isGigaProcessor() && OtherCondIdx == -1) 745475871a144eb604ddaf37503397ba0941442e5fbDan Gohman IntCR = SDValue(CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, CR7Reg, 7467e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng CCReg), 0); 747222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner else 748475871a144eb604ddaf37503397ba0941442e5fbDan Gohman IntCR = SDValue(CurDAG->getTargetNode(PPC::MFCR, MVT::i32, CCReg), 0); 749222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 750475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { IntCR, getI32Imm((32-(3-Idx)) & 31), 7510b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(31), getI32Imm(31) }; 752fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner if (OtherCondIdx == -1 && !Inv) 7530b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 754fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 755fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // Get the specified bit. 756475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp = 757475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Ops, 4), 0); 758fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner if (Inv) { 759fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner assert(OtherCondIdx == -1 && "Can't have split plus negation"); 76095514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Tmp, getI32Imm(1)); 761222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 762fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 763fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // Otherwise, we have to turn an operation like SETONE -> SETOLT | SETOGT. 764fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // We already got the bit for the first part of the comparison (e.g. SETULE). 765fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 766fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // Get the other bit of the comparison. 767fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner Ops[1] = getI32Imm((32-(3-OtherCondIdx)) & 31); 768475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue OtherCond = 769475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Ops, 4), 0); 770fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 771fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner return CurDAG->SelectNodeTo(N, PPC::OR, MVT::i32, Tmp, OtherCond); 772222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner} 7732b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 7746a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 775a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Select - Convert the specified operand from a target-independent to a 776a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// target-specific node if it hasn't already been changed. 777475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDNode *PPCDAGToDAGISel::Select(SDValue Op) { 778ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif SDNode *N = Op.getNode(); 779e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman if (N->isMachineOpcode()) 78064a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; // Already selected. 781d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 782a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOpcode()) { 78319c0907ba1c11c81dc231cf7b4143fdaf03466e4Chris Lattner default: break; 78478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 78578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey case ISD::Constant: { 78678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (N->getValueType(0) == MVT::i64) { 78778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Get 64 bit value. 78878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey int64_t Imm = cast<ConstantSDNode>(N)->getValue(); 78978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Assume no remaining bits. 79078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Remainder = 0; 79178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Assume no shift required. 79278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Shift = 0; 79378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 79478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // If it can't be represented as a 32 bit value. 79578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (!isInt32(Imm)) { 79678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Shift = CountTrailingZeros_64(Imm); 79778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey int64_t ImmSh = static_cast<uint64_t>(Imm) >> Shift; 79878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 79978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // If the shifted value fits 32 bits. 80078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (isInt32(ImmSh)) { 80178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Go with the shifted value. 80278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Imm = ImmSh; 80378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } else { 80478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Still stuck with a 64 bit value. 80578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Remainder = Imm; 80678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Shift = 32; 80778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Imm >>= 32; 80878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 80978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 81078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 81178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Intermediate operand. 81278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey SDNode *Result; 81378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 81478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Handle first 32 bits. 81578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Lo = Imm & 0xFFFF; 81678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Hi = (Imm >> 16) & 0xFFFF; 81778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 81878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Simple value. 81978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (isInt16(Imm)) { 82078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Just the Lo bits. 82178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Result = CurDAG->getTargetNode(PPC::LI8, MVT::i64, getI32Imm(Lo)); 82278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } else if (Lo) { 82378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Handle the Hi bits. 82478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned OpC = Hi ? PPC::LIS8 : PPC::LI8; 82578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Result = CurDAG->getTargetNode(OpC, MVT::i64, getI32Imm(Hi)); 82678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // And Lo bits. 82778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Result = CurDAG->getTargetNode(PPC::ORI8, MVT::i64, 828475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Result, 0), getI32Imm(Lo)); 82978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } else { 83078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Just the Hi bits. 83178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Result = CurDAG->getTargetNode(PPC::LIS8, MVT::i64, getI32Imm(Hi)); 83278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 83378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 83478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // If no shift, we're done. 83578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (!Shift) return Result; 83678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 83778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Shift for next step if the upper 32-bits were not zero. 83878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (Imm) { 83978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Result = CurDAG->getTargetNode(PPC::RLDICR, MVT::i64, 840475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Result, 0), 84178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey getI32Imm(Shift), getI32Imm(63 - Shift)); 84278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 84378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 84478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Add in the last bits as required. 84578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if ((Hi = (Remainder >> 16) & 0xFFFF)) { 84678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Result = CurDAG->getTargetNode(PPC::ORIS8, MVT::i64, 847475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Result, 0), getI32Imm(Hi)); 84878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 84978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if ((Lo = Remainder & 0xFFFF)) { 85078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Result = CurDAG->getTargetNode(PPC::ORI8, MVT::i64, 851475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Result, 0), getI32Imm(Lo)); 85278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 85378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 85478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey return Result; 85578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 85678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey break; 85778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 85878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 85934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case ISD::SETCC: 860ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return SelectSETCC(Op); 86134167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case PPCISD::GlobalBaseReg: 8629ade218533429146731213eacb7e12060e65ff58Evan Cheng return getGlobalBaseReg(); 863860e8862c1fbd3b261da4a64a8c0096f9f373681Chris Lattner 864e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner case ISD::FrameIndex: { 865e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner int FI = cast<FrameIndexSDNode>(N)->getIndex(); 866475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue TFI = CurDAG->getTargetFrameIndex(FI, Op.getValueType()); 867c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner unsigned Opc = Op.getValueType() == MVT::i32 ? PPC::ADDI : PPC::ADDI8; 868ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner if (N->hasOneUse()) 869ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->SelectNodeTo(N, Opc, Op.getValueType(), TFI, 87095514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng getSmallIPtrImm(0)); 871ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->getTargetNode(Opc, Op.getValueType(), TFI, 872ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner getSmallIPtrImm(0)); 873e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } 8746d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner 8756d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner case PPCISD::MFCR: { 876475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue InFlag = N->getOperand(1); 8776da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(InFlag); 8786d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner // Use MFOCRF if supported. 879152b7e18748f7e06a93260f22cc9dac8eb3abee2Evan Cheng if (PPCSubTarget.isGigaProcessor()) 880ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, 881ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner N->getOperand(0), InFlag); 8826d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner else 883ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->getTargetNode(PPC::MFCR, MVT::i32, InFlag); 8846d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner } 8856d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner 88688add100b3db715df4275c8ab408e6b51f28ff8fChris Lattner case ISD::SDIV: { 887405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: since this depends on the setting of the carry flag from the srawi 888405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // we should really be making notes about that for the scheduler. 889405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: It sure would be nice if we could cheaply recognize the 890405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // srl/add/sra pattern the dag combiner will generate for this as 891405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // sra/addze rather than having to handle sdiv ourselves. oh well. 8928784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner unsigned Imm; 893c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm)) { 894475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue N0 = N->getOperand(0); 8956da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N0); 8968784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if ((signed)Imm > 0 && isPowerOf2_32(Imm)) { 8977e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 8988784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 89934167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N0, getI32Imm(Log2_32(Imm))); 900ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 901475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Op, 0), SDValue(Op, 1)); 9028784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } else if ((signed)Imm < 0 && isPowerOf2_32(-Imm)) { 9037e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 9042501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 90534167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N0, getI32Imm(Log2_32(-Imm))); 906475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue PT = 907475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, 908475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Op, 0), SDValue(Op, 1)), 9097e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng 0); 91095514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng return CurDAG->SelectNodeTo(N, PPC::NEG, MVT::i32, PT); 9118784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 9128784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 913047b952e298352fe6feffedf02e359601133f465Chris Lattner 914237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 915237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 916047b952e298352fe6feffedf02e359601133f465Chris Lattner } 9174eab71497d10622bd209c53f8e56152877ac5638Chris Lattner 9184eab71497d10622bd209c53f8e56152877ac5638Chris Lattner case ISD::LOAD: { 9194eab71497d10622bd209c53f8e56152877ac5638Chris Lattner // Handle preincrement loads. 9204eab71497d10622bd209c53f8e56152877ac5638Chris Lattner LoadSDNode *LD = cast<LoadSDNode>(Op); 92183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT LoadedVT = LD->getMemoryVT(); 9224eab71497d10622bd209c53f8e56152877ac5638Chris Lattner 9234eab71497d10622bd209c53f8e56152877ac5638Chris Lattner // Normal loads are handled by code generated from the .td file. 9244eab71497d10622bd209c53f8e56152877ac5638Chris Lattner if (LD->getAddressingMode() != ISD::PRE_INC) 9254eab71497d10622bd209c53f8e56152877ac5638Chris Lattner break; 9264eab71497d10622bd209c53f8e56152877ac5638Chris Lattner 927475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Offset = LD->getOffset(); 9285b3bbc7cd7bff4275b94003d4bf1fa296c6a10d0Chris Lattner if (isa<ConstantSDNode>(Offset) || 9295b3bbc7cd7bff4275b94003d4bf1fa296c6a10d0Chris Lattner Offset.getOpcode() == ISD::TargetGlobalAddress) { 9300851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner 9310851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner unsigned Opcode; 9320851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner bool isSExt = LD->getExtensionType() == ISD::SEXTLOAD; 9330851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner if (LD->getValueType(0) != MVT::i64) { 9340851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner // Handle PPC32 integer and normal FP loads. 9357c1c261272b43f2a9397c3052819b92c53918075Anton Korobeynikov assert((!isSExt || LoadedVT == MVT::i16) && "Invalid sext update load"); 93683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands switch (LoadedVT.getSimpleVT()) { 9370851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner default: assert(0 && "Invalid PPC load type!"); 9380851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::f64: Opcode = PPC::LFDU; break; 9390851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::f32: Opcode = PPC::LFSU; break; 9400851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i32: Opcode = PPC::LWZU; break; 9410851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i16: Opcode = isSExt ? PPC::LHAU : PPC::LHZU; break; 9420851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i1: 9430851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i8: Opcode = PPC::LBZU; break; 9440851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } 9450851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } else { 9460851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner assert(LD->getValueType(0) == MVT::i64 && "Unknown load result type!"); 9477c1c261272b43f2a9397c3052819b92c53918075Anton Korobeynikov assert((!isSExt || LoadedVT == MVT::i16) && "Invalid sext update load"); 94883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands switch (LoadedVT.getSimpleVT()) { 9490851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner default: assert(0 && "Invalid PPC load type!"); 9500851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i64: Opcode = PPC::LDU; break; 9510851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i32: Opcode = PPC::LWZU8; break; 9520851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i16: Opcode = isSExt ? PPC::LHAU8 : PPC::LHZU8; break; 9530851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i1: 9540851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i8: Opcode = PPC::LBZU8; break; 9550851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } 9560851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } 9570851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner 958475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = LD->getChain(); 959475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Base = LD->getBasePtr(); 9604eab71497d10622bd209c53f8e56152877ac5638Chris Lattner AddToISelQueue(Chain); 9614eab71497d10622bd209c53f8e56152877ac5638Chris Lattner AddToISelQueue(Base); 9624eab71497d10622bd209c53f8e56152877ac5638Chris Lattner AddToISelQueue(Offset); 963475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Offset, Base, Chain }; 9644eab71497d10622bd209c53f8e56152877ac5638Chris Lattner // FIXME: PPC64 965e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman return CurDAG->getTargetNode(Opcode, LD->getValueType(0), 966e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman PPCLowering.getPointerTy(), 9674eab71497d10622bd209c53f8e56152877ac5638Chris Lattner MVT::Other, Ops, 3); 9684eab71497d10622bd209c53f8e56152877ac5638Chris Lattner } else { 9694eab71497d10622bd209c53f8e56152877ac5638Chris Lattner assert(0 && "R+R preindex loads not supported yet!"); 9704eab71497d10622bd209c53f8e56152877ac5638Chris Lattner } 9714eab71497d10622bd209c53f8e56152877ac5638Chris Lattner } 9724eab71497d10622bd209c53f8e56152877ac5638Chris Lattner 973cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman case ISD::AND: { 974f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman unsigned Imm, Imm2, SH, MB, ME; 975f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman 976cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and of a value rotated between 0 and 31 bits and then and'd 977cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // with a mask, emit rlwinm 978c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm) && 979ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif isRotateAndMask(N->getOperand(0).getNode(), Imm, false, SH, MB, ME)) { 980475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Val = N->getOperand(0).getOperand(0); 981f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman AddToISelQueue(Val); 982475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Val, getI32Imm(SH), getI32Imm(MB), getI32Imm(ME) }; 9830b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 984cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 985f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman // If this is just a masked value where the input is not handled above, and 986f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman // is not a rotate-left (handled by a pattern in the .td file), emit rlwinm 987f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman if (isInt32Immediate(N->getOperand(1), Imm) && 988f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman isRunOfOnes(Imm, MB, ME) && 989f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman N->getOperand(0).getOpcode() != ISD::ROTL) { 990475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Val = N->getOperand(0); 991f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman AddToISelQueue(Val); 992475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Val, getI32Imm(0), getI32Imm(MB), getI32Imm(ME) }; 993f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 994f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman } 995f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman // AND X, 0 -> 0, not "rlwinm 32". 996f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman if (isInt32Immediate(N->getOperand(1), Imm) && (Imm == 0)) { 997f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman AddToISelQueue(N->getOperand(1)); 998475871a144eb604ddaf37503397ba0941442e5fbDan Gohman ReplaceUses(SDValue(N, 0), N->getOperand(1)); 999f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman return NULL; 1000f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman } 100150fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // ISD::OR doesn't get all the bitfield insertion fun. 100250fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // (and (or x, c1), c2) where isRunOfOnes(~(c1^c2)) is a bitfield insert 1003c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm) && 100450fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman N->getOperand(0).getOpcode() == ISD::OR && 1005c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(N->getOperand(0).getOperand(1), Imm2)) { 1006c9a5ef524a9f461717bbf647b2d3da061aed720dChris Lattner unsigned MB, ME; 100750fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman Imm = ~(Imm^Imm2); 100850fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman if (isRunOfOnes(Imm, MB, ME)) { 10096da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(0).getOperand(0)); 10106da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(0).getOperand(1)); 1011475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { N->getOperand(0).getOperand(0), 10120b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng N->getOperand(0).getOperand(1), 10130b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(0), getI32Imm(MB),getI32Imm(ME) }; 10140b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, Ops, 5); 101550fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 101650fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 1017237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner 1018237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1019237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1020cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 102102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::OR: 1022cccef1c6fffa292c227a289d447f6b848ab56c62Chris Lattner if (N->getValueType(0) == MVT::i32) 1023ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner if (SDNode *I = SelectBitfieldInsert(N)) 1024ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return I; 1025d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 1026237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1027237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1028c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SHL: { 1029c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1030ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::AND, Imm) && 10312d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 10326da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(0).getOperand(0)); 1033475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { N->getOperand(0).getOperand(0), 10340b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(SH), getI32Imm(MB), getI32Imm(ME) }; 10350b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 10368d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 10372d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 10382d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 10392d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1040c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 1041c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRL: { 1042c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1043ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::AND, Imm) && 10442d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 10456da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(0).getOperand(0)); 1046475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { N->getOperand(0).getOperand(0), 10470b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(SH), getI32Imm(MB), getI32Imm(ME) }; 10480b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 10498d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 10502d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 10512d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 10522d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1053c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 105413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner case ISD::SELECT_CC: { 105513794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(4))->get(); 105613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner 1057c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner // Handle the setcc cases here. select_cc lhs, 0, 1, 0, cc 105813794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N->getOperand(1))) 105913794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N->getOperand(2))) 106013794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N->getOperand(3))) 106113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (N1C->isNullValue() && N3C->isNullValue() && 1062c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner N2C->getValue() == 1ULL && CC == ISD::SETNE && 1063c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner // FIXME: Implement this optzn for PPC64. 1064c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner N->getValueType(0) == MVT::i32) { 10656da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(0)); 10667e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Tmp = 106713794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 10686da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng N->getOperand(0), getI32Imm(~0U)); 1069ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, 1070475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Tmp, 0), N->getOperand(0), 1071475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue(Tmp, 1)); 107213794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 10738a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 1074475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 1075df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner unsigned BROpc = getPredicateForSetCC(CC); 10768a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 1077919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner unsigned SelectCCOp; 1078c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getValueType(0) == MVT::i32) 1079c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner SelectCCOp = PPC::SELECT_CC_I4; 1080c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner else if (N->getValueType(0) == MVT::i64) 1081c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner SelectCCOp = PPC::SELECT_CC_I8; 1082919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else if (N->getValueType(0) == MVT::f32) 1083919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F4; 1084710ff32983ca919fa0da14e077450b6a7654274fChris Lattner else if (N->getValueType(0) == MVT::f64) 1085919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F8; 1086710ff32983ca919fa0da14e077450b6a7654274fChris Lattner else 1087710ff32983ca919fa0da14e077450b6a7654274fChris Lattner SelectCCOp = PPC::SELECT_CC_VRRC; 1088710ff32983ca919fa0da14e077450b6a7654274fChris Lattner 10896da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(2)); 10906da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(3)); 1091475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { CCReg, N->getOperand(2), N->getOperand(3), 10920b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(BROpc) }; 10930b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, SelectCCOp, N->getValueType(0), Ops, 4); 109413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 109518258c640466274c26e89016e361ec411ff78520Chris Lattner case PPCISD::COND_BRANCH: { 109618258c640466274c26e89016e361ec411ff78520Chris Lattner AddToISelQueue(N->getOperand(0)); // Op #0 is the Chain. 109718258c640466274c26e89016e361ec411ff78520Chris Lattner // Op #1 is the PPC::PRED_* number. 109818258c640466274c26e89016e361ec411ff78520Chris Lattner // Op #2 is the CR# 109918258c640466274c26e89016e361ec411ff78520Chris Lattner // Op #3 is the Dest MBB 110018258c640466274c26e89016e361ec411ff78520Chris Lattner AddToISelQueue(N->getOperand(4)); // Op #4 is the Flag. 11012bda17c92229e7116adf2edd3eea98c0a12f43cbEvan Cheng // Prevent PPC::PRED_* from being selected into LI. 1102475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Pred = 11032bda17c92229e7116adf2edd3eea98c0a12f43cbEvan Cheng getI32Imm(cast<ConstantSDNode>(N->getOperand(1))->getValue()); 1104475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Pred, N->getOperand(2), N->getOperand(3), 110518258c640466274c26e89016e361ec411ff78520Chris Lattner N->getOperand(0), N->getOperand(4) }; 110618258c640466274c26e89016e361ec411ff78520Chris Lattner return CurDAG->SelectNodeTo(N, PPC::BCC, MVT::Other, Ops, 5); 110718258c640466274c26e89016e361ec411ff78520Chris Lattner } 110881e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman case ISD::BR_CC: { 11096da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(0)); 11102fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(1))->get(); 1111475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CondCode = SelectCC(N->getOperand(2), N->getOperand(3), CC); 1112475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { getI32Imm(getPredicateForSetCC(CC)), CondCode, 11130b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng N->getOperand(4), N->getOperand(0) }; 1114289c2d5f4566d8d7722e3934f4763d3df92886f3Chris Lattner return CurDAG->SelectNodeTo(N, PPC::BCC, MVT::Other, Ops, 4); 11152fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 111637efe6764568a3829fee26aba532283131d1a104Nate Begeman case ISD::BRIND: { 1117cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // FIXME: Should custom lower this. 1118475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = N->getOperand(0); 1119475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Target = N->getOperand(1); 11206da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(Chain); 11216da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(Target); 11226b76b96c69334f3b6a2a895ff810ed047b4b75e5Chris Lattner unsigned Opc = Target.getValueType() == MVT::i32 ? PPC::MTCTR : PPC::MTCTR8; 1123475871a144eb604ddaf37503397ba0941442e5fbDan Gohman Chain = SDValue(CurDAG->getTargetNode(Opc, MVT::Other, Target, 112437efe6764568a3829fee26aba532283131d1a104Nate Begeman Chain), 0); 112595514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng return CurDAG->SelectNodeTo(N, PPC::BCTR, MVT::Other, Chain); 112637efe6764568a3829fee26aba532283131d1a104Nate Begeman } 1127a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 112825dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner 11299ade218533429146731213eacb7e12060e65ff58Evan Cheng return SelectCode(Op); 1130a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1131a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1132a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1133cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 11341d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman/// createPPCISelDag - This pass converts a legalized DAG into a 1135a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// PowerPC-specific DAG, ready for instruction scheduling. 1136a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// 1137c4c6257c1a154279bf10e9498d46d6c1793dbaa7Evan ChengFunctionPass *llvm::createPPCISelDag(PPCTargetMachine &TM) { 11381d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman return new PPCDAGToDAGISel(TM); 1139a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1140a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1141