PPCISelDAGToDAG.cpp revision 83ec4b6711980242ef3c55a4fa36b2d7a39c1bfb
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: 484bb189507281af0da8aff91743b5198acbf2398bChris Lattner 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. 64a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner inline SDOperand getI32Imm(unsigned Imm) { 65a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return CurDAG->getTargetConstant(Imm, MVT::i32); 66a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 674416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 68c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// getI64Imm - Return a target constant with the specified value, of type 69c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// i64. 70c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner inline SDOperand getI64Imm(uint64_t Imm) { 71c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return CurDAG->getTargetConstant(Imm, MVT::i64); 72c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 73c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 74c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner /// getSmallIPtrImm - Return a target constant of pointer type. 75c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner inline SDOperand getSmallIPtrImm(unsigned Imm) { 76c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return CurDAG->getTargetConstant(Imm, PPCLowering.getPointerTy()); 77c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 78c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 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. 979ade218533429146731213eacb7e12060e65ff58Evan Cheng SDNode *Select(SDOperand 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. 1032fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand SelectCC(SDOperand LHS, SDOperand 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]. 1070d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng bool SelectAddrImm(SDOperand Op, SDOperand N, SDOperand &Disp, 1080d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng SDOperand &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. 11574531e49ef97cc2bef8fc9c35963368fc63153cfChris Lattner bool SelectAddrImmOffs(SDOperand Op, SDOperand N, SDOperand &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. 1230d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng bool SelectAddrIdx(SDOperand Op, SDOperand N, SDOperand &Base, 1240d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng SDOperand &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. 1300d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng bool SelectAddrIdxOnly(SDOperand Op, SDOperand N, SDOperand &Base, 1310d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng SDOperand &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. 1380d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng bool SelectAddrImmShift(SDOperand Op, SDOperand N, SDOperand &Disp, 1390d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng SDOperand &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. 145e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner virtual bool SelectInlineAsmMemoryOperand(const SDOperand &Op, 146e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner char ConstraintCode, 147e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner std::vector<SDOperand> &OutOps, 148e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner SelectionDAG &DAG) { 149e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner SDOperand Op0, Op1; 150e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner switch (ConstraintCode) { 151e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner default: return true; 152e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'm': // memory 1530d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng if (!SelectAddrIdx(Op, Op, Op0, Op1)) 1540d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng SelectAddrImm(Op, Op, Op0, Op1); 155e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 156e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'o': // offsetable 1570d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng if (!SelectAddrImm(Op, Op, Op0, Op1)) { 1586da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng Op0 = Op; 1596da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(Op0); // r+0. 160c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Op1 = getSmallIPtrImm(0); 161e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 162e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 163e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner case 'v': // not offsetable 1640d53826f3653a789cf1491c3c40a1f4a993992b6Evan Cheng SelectAddrIdxOnly(Op, Op, Op0, Op1); 165e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner break; 166e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 167e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner 168e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner OutOps.push_back(Op0); 169e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner OutOps.push_back(Op1); 170e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner return false; 171e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner } 172e5d8861126959d01cf847b6ef280dd9ef38d33cfChris Lattner 173047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand BuildSDIVSequence(SDNode *N); 174047b952e298352fe6feffedf02e359601133f465Chris Lattner SDOperand BuildUDIVSequence(SDNode *N); 175047b952e298352fe6feffedf02e359601133f465Chris Lattner 176a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// InstructionSelectBasicBlock - This callback is invoked by 177a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner /// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 178bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner virtual void InstructionSelectBasicBlock(SelectionDAG &DAG); 179bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 1804bb189507281af0da8aff91743b5198acbf2398bChris Lattner void InsertVRSaveCode(Function &Fn); 1814bb189507281af0da8aff91743b5198acbf2398bChris Lattner 182a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner virtual const char *getPassName() const { 183a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner return "PowerPC DAG->DAG Pattern Instruction Selection"; 184a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 185c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner 186c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner /// CreateTargetHazardRecognizer - Return the hazard recognizer to use for 187c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner /// this target when scheduling the DAG. 188b0d21ef20c29f4ea46d21b488f17feaa6a8760e1Chris Lattner virtual HazardRecognizer *CreateTargetHazardRecognizer() { 189c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner // Should use subtarget info to pick the right hazard recognizer. For 190c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner // now, always return a PPC970 recognizer. 19188d211f82304e53694ece666d4a2507b170e4582Chris Lattner const TargetInstrInfo *II = PPCLowering.getTargetMachine().getInstrInfo(); 19288d211f82304e53694ece666d4a2507b170e4582Chris Lattner assert(II && "No InstrInfo?"); 19388d211f82304e53694ece666d4a2507b170e4582Chris Lattner return new PPCHazardRecognizer970(*II); 194c6644188208d4aee9a9d6c428710ec1f69837944Chris Lattner } 195af165385112037cb942e94ea562a67990b7d6220Chris Lattner 196af165385112037cb942e94ea562a67990b7d6220Chris Lattner// Include the pieces autogenerated from the target description. 1974c7b43b43fdf943c7298718e15ab5d6dfe345be7Chris Lattner#include "PPCGenDAGISel.inc" 198bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 199bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattnerprivate: 200ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner SDNode *SelectSETCC(SDOperand Op); 201a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner }; 202a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 203a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 204bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner/// InstructionSelectBasicBlock - This callback is invoked by 205bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner/// SelectionDAGISel when it has created a SelectionDAG for us to codegen. 2061d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begemanvoid PPCDAGToDAGISel::InstructionSelectBasicBlock(SelectionDAG &DAG) { 207bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DEBUG(BB->dump()); 208bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 209bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner // Select target instructions for the DAG. 210ba2f0a9ee53512ce840aca34281e126802a125d1Evan Cheng DAG.setRoot(SelectRoot(DAG.getRoot())); 211bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner DAG.RemoveDeadNodes(); 212bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner 2131877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // Emit machine code to BB. 214bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner ScheduleAndEmitDAG(DAG); 2154bb189507281af0da8aff91743b5198acbf2398bChris Lattner} 2164bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2174bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// InsertVRSaveCode - Once the entire function has been instruction selected, 2184bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// all virtual registers are created and all machine instructions are built, 2194bb189507281af0da8aff91743b5198acbf2398bChris Lattner/// check to see if we need to save/restore VRSAVE. If so, do it. 2204bb189507281af0da8aff91743b5198acbf2398bChris Lattnervoid PPCDAGToDAGISel::InsertVRSaveCode(Function &F) { 2211877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // Check to see if this function uses vector registers, which means we have to 2221877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // save and restore the VRSAVE register and update it with the regs we use. 2231877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2241877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // In this case, there will be virtual registers of vector type type created 2251877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // by the scheduler. Detect them now. 2264bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineFunction &Fn = MachineFunction::get(&F); 2271877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner bool HasVectorVReg = false; 2286f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman for (unsigned i = TargetRegisterInfo::FirstVirtualRegister, 22984bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner e = RegInfo->getLastVirtReg()+1; i != e; ++i) 23084bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner if (RegInfo->getRegClass(i) == &PPC::VRRCRegClass) { 2311877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner HasVectorVReg = true; 2321877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner break; 2331877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner } 2344bb189507281af0da8aff91743b5198acbf2398bChris Lattner if (!HasVectorVReg) return; // nothing to do. 2354bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2361877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // If we have a vector register, we want to emit code into the entry and exit 2371877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // blocks to save and restore the VRSAVE register. We do this here (instead 2381877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // of marking all vector instructions as clobbering VRSAVE) for two reasons: 2391877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2401877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 1. This (trivially) reduces the load on the register allocator, by not 2411877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // having to represent the live range of the VRSAVE register. 2421877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // 2. This (more significantly) allows us to create a temporary virtual 2431877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // register to hold the saved VRSAVE value, allowing this temporary to be 2441877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner // register allocated, instead of forcing it to be spilled to the stack. 2454bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2464bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Create two vregs - one to hold the VRSAVE register that is live-in to the 2474bb189507281af0da8aff91743b5198acbf2398bChris Lattner // function and one for the value after having bits or'd into it. 24884bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner unsigned InVRSAVE = RegInfo->createVirtualRegister(&PPC::GPRCRegClass); 24984bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner unsigned UpdatedVRSAVE = RegInfo->createVirtualRegister(&PPC::GPRCRegClass); 2504bb189507281af0da8aff91743b5198acbf2398bChris Lattner 251c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng const TargetInstrInfo &TII = *TM.getInstrInfo(); 2524bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock &EntryBB = *Fn.begin(); 2534bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Emit the following code into the entry block: 2544bb189507281af0da8aff91743b5198acbf2398bChris Lattner // InVRSAVE = MFVRSAVE 2554bb189507281af0da8aff91743b5198acbf2398bChris Lattner // UpdatedVRSAVE = UPDATE_VRSAVE InVRSAVE 2564bb189507281af0da8aff91743b5198acbf2398bChris Lattner // MTVRSAVE UpdatedVRSAVE 2574bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock::iterator IP = EntryBB.begin(); // Insert Point 258c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(EntryBB, IP, TII.get(PPC::MFVRSAVE), InVRSAVE); 25969244300b8a0112efb44b6273ecea4ca6264b8cfChris Lattner BuildMI(EntryBB, IP, TII.get(PPC::UPDATE_VRSAVE), 26069244300b8a0112efb44b6273ecea4ca6264b8cfChris Lattner UpdatedVRSAVE).addReg(InVRSAVE); 261c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(EntryBB, IP, TII.get(PPC::MTVRSAVE)).addReg(UpdatedVRSAVE); 2624bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2634bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Find all return blocks, outputting a restore in each epilog. 2644bb189507281af0da8aff91743b5198acbf2398bChris Lattner for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 265749c6f6b5ed301c84aac562e414486549d7b98ebChris Lattner if (!BB->empty() && BB->back().getDesc().isReturn()) { 2664bb189507281af0da8aff91743b5198acbf2398bChris Lattner IP = BB->end(); --IP; 2674bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2684bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Skip over all terminator instructions, which are part of the return 2694bb189507281af0da8aff91743b5198acbf2398bChris Lattner // sequence. 2704bb189507281af0da8aff91743b5198acbf2398bChris Lattner MachineBasicBlock::iterator I2 = IP; 271749c6f6b5ed301c84aac562e414486549d7b98ebChris Lattner while (I2 != BB->begin() && (--I2)->getDesc().isTerminator()) 2724bb189507281af0da8aff91743b5198acbf2398bChris Lattner IP = I2; 2734bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2744bb189507281af0da8aff91743b5198acbf2398bChris Lattner // Emit: MTVRSAVE InVRSave 275c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(*BB, IP, TII.get(PPC::MTVRSAVE)).addReg(InVRSAVE); 2764bb189507281af0da8aff91743b5198acbf2398bChris Lattner } 2771877ec9b02511e111998596b9ba9c3a2275d6a92Chris Lattner } 278bd937b98f48cac17bd3d5102b2182943b97f8c28Chris Lattner} 2796cd40d5888f905a3820d5d6c71e57cc0e02abb4aChris Lattner 2804bb189507281af0da8aff91743b5198acbf2398bChris Lattner 2814416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// getGlobalBaseReg - Output the instructions required to put the 2824416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// base address to use for accessing globals into a register. 2834416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner/// 2849ade218533429146731213eacb7e12060e65ff58Evan ChengSDNode *PPCDAGToDAGISel::getGlobalBaseReg() { 2854416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner if (!GlobalBaseReg) { 286c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng const TargetInstrInfo &TII = *TM.getInstrInfo(); 2874416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner // Insert the set of GlobalBaseReg into the first MBB of the function 2884416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock &FirstMBB = BB->getParent()->front(); 2894416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner MachineBasicBlock::iterator MBBI = FirstMBB.begin(); 290c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 291d10434215da983b58389d2a0880dfcd2cd3b7f35Chris Lattner if (PPCLowering.getPointerTy() == MVT::i32) { 29284bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner GlobalBaseReg = RegInfo->createVirtualRegister(PPC::GPRCRegisterClass); 293c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(FirstMBB, MBBI, TII.get(PPC::MovePCtoLR), PPC::LR); 294c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(FirstMBB, MBBI, TII.get(PPC::MFLR), GlobalBaseReg); 295d10434215da983b58389d2a0880dfcd2cd3b7f35Chris Lattner } else { 29684bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner GlobalBaseReg = RegInfo->createVirtualRegister(PPC::G8RCRegisterClass); 297c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(FirstMBB, MBBI, TII.get(PPC::MovePCtoLR8), PPC::LR8); 298c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(FirstMBB, MBBI, TII.get(PPC::MFLR8), GlobalBaseReg); 299d10434215da983b58389d2a0880dfcd2cd3b7f35Chris Lattner } 3004416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner } 3019ade218533429146731213eacb7e12060e65ff58Evan Cheng return CurDAG->getRegister(GlobalBaseReg, PPCLowering.getPointerTy()).Val; 3024416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner} 3034416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 304c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isIntS16Immediate - This method tests to see if the node is either a 32-bit 305c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// or 64-bit immediate, and if the value can be accurately represented as a 306c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// sign extension from a 16-bit value. If so, this returns true and the 307c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// immediate. 308c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isIntS16Immediate(SDNode *N, short &Imm) { 309c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getOpcode() != ISD::Constant) 310c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return false; 3114416f1a0a5b17906b9e162209fd506656a2e07d8Chris Lattner 312c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Imm = (short)cast<ConstantSDNode>(N)->getValue(); 313c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getValueType(0) == MVT::i32) 314c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return Imm == (int32_t)cast<ConstantSDNode>(N)->getValue(); 315c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner else 316c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return Imm == (int64_t)cast<ConstantSDNode>(N)->getValue(); 317c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 318c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 319c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isIntS16Immediate(SDOperand Op, short &Imm) { 320c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return isIntS16Immediate(Op.Val, Imm); 321c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 322c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 323c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 324c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isInt32Immediate - This method tests to see if the node is a 32-bit constant 325c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// operand. If so Imm will receive the 32-bit value. 326c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isInt32Immediate(SDNode *N, unsigned &Imm) { 327c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i32) { 3280f3257a3302b60c128a667db6736e81335316c1eNate Begeman Imm = cast<ConstantSDNode>(N)->getValue(); 3290f3257a3302b60c128a667db6736e81335316c1eNate Begeman return true; 3300f3257a3302b60c128a667db6736e81335316c1eNate Begeman } 3310f3257a3302b60c128a667db6736e81335316c1eNate Begeman return false; 3320f3257a3302b60c128a667db6736e81335316c1eNate Begeman} 3330f3257a3302b60c128a667db6736e81335316c1eNate Begeman 334c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// isInt64Immediate - This method tests to see if the node is a 64-bit constant 335c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner/// operand. If so Imm will receive the 64-bit value. 336c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isInt64Immediate(SDNode *N, uint64_t &Imm) { 337711762497c27357adc1edf8d4237c2770fa303bbChris Lattner if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i64) { 338c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Imm = cast<ConstantSDNode>(N)->getValue(); 339c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return true; 340c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 341c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return false; 342c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 343c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 344c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// isInt32Immediate - This method tests to see if a constant operand. 345c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// If so Imm will receive the 32 bit value. 346c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isInt32Immediate(SDOperand N, unsigned &Imm) { 347c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return isInt32Immediate(N.Val, Imm); 348c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 349c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 350c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 351c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// isOpcWithIntImmediate - This method tests to see if the node is a specific 352c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// opcode and that it has a immediate integer right operand. 353c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner// If so Imm will receive the 32 bit value. 354c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattnerstatic bool isOpcWithIntImmediate(SDNode *N, unsigned Opc, unsigned& Imm) { 355c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return N->getOpcode() == Opc && isInt32Immediate(N->getOperand(1).Val, Imm); 356c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner} 357c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 358f42f133938545d4f5c249bcfef63db772ce8e942Nate Begemanbool PPCDAGToDAGISel::isRunOfOnes(unsigned Val, unsigned &MB, unsigned &ME) { 359cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (isShiftedMask_32(Val)) { 360cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first non-zero bit 361cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman MB = CountLeadingZeros_32(Val); 362cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // look for the first zero bit after the run of ones 363cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman ME = CountLeadingZeros_32((Val - 1) ^ Val); 364cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return true; 3652fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } else { 3662fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner Val = ~Val; // invert mask 3672fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner if (isShiftedMask_32(Val)) { 3682fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first zero bit 3692fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner ME = CountLeadingZeros_32(Val) - 1; 3702fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner // effectively look for the first one bit after the run of zeros 3712fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner MB = CountLeadingZeros_32((Val - 1) ^ Val) + 1; 3722fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner return true; 3732fe76e58eb734a09ec08ea006a32700572ffc0caChris Lattner } 374cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 375cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // no run present 376cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 377cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 378cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 379f42f133938545d4f5c249bcfef63db772ce8e942Nate Begemanbool PPCDAGToDAGISel::isRotateAndMask(SDNode *N, unsigned Mask, 380f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman bool IsShiftMask, unsigned &SH, 381f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman unsigned &MB, unsigned &ME) { 382da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // Don't even go down this path for i64, since different logic will be 383da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman // necessary for rldicl/rldicr/rldimi. 384da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman if (N->getValueType(0) != MVT::i32) 385da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman return false; 386da32c9eed6743c29d219a5c3cb13788853f18016Nate Begeman 387cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Shift = 32; 388cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Indeterminant = ~0; // bit mask marking indeterminant results 389cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman unsigned Opcode = N->getOpcode(); 39015055733f85da5dc9a29e64cc1a2eeda38898f68Chris Lattner if (N->getNumOperands() != 2 || 391c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner !isInt32Immediate(N->getOperand(1).Val, Shift) || (Shift > 31)) 392cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 393cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 394cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Opcode == ISD::SHL) { 395cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift left to mask if it comes first 396cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask << Shift; 397cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 398cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu << Shift); 399651dea74f6a362d30bc61fd0b549da7707af5bf8Chris Lattner } else if (Opcode == ISD::SRL) { 400cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // apply shift right to mask if it comes first 401cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (IsShiftMask) Mask = Mask >> Shift; 402cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // determine which bits are made indeterminant by shift 403cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Indeterminant = ~(0xFFFFFFFFu >> Shift); 404cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // adjust for the left rotate 405cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman Shift = 32 - Shift; 406f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman } else if (Opcode == ISD::ROTL) { 407f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman Indeterminant = 0; 408cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } else { 409cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 410cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 411cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 412cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // if the mask doesn't intersect any Indeterminant bits 413cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman if (Mask && !(Mask & Indeterminant)) { 4140949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner SH = Shift & 31; 415cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // make sure the mask is still a mask (wrap arounds may not be) 416cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return isRunOfOnes(Mask, MB, ME); 417cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 418cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman return false; 419cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman} 420cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman 42102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// SelectBitfieldInsert - turn an or of two masked values into 42202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman/// the rotate left word immediate then mask insert (rlwimi) instruction. 4231d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDNode *PPCDAGToDAGISel::SelectBitfieldInsert(SDNode *N) { 42402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op0 = N->getOperand(0); 42502b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman SDOperand Op1 = N->getOperand(1); 42602b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 427b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman APInt LKZ, LKO, RKZ, RKO; 428b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman CurDAG->ComputeMaskedBits(Op0, APInt::getAllOnesValue(32), LKZ, LKO); 429b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman CurDAG->ComputeMaskedBits(Op1, APInt::getAllOnesValue(32), RKZ, RKO); 43002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 431b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman unsigned TargetMask = LKZ.getZExtValue(); 432b3564aa8367fc38efdab0a812868f6f93b9d883eDan Gohman unsigned InsertMask = RKZ.getZExtValue(); 4334667f2cbad246beccfca5411a26add24d1007035Nate Begeman 4344667f2cbad246beccfca5411a26add24d1007035Nate Begeman if ((TargetMask | InsertMask) == 0xFFFFFFFF) { 4354667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Op0Opc = Op0.getOpcode(); 4364667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Op1Opc = Op1.getOpcode(); 4374667f2cbad246beccfca5411a26add24d1007035Nate Begeman unsigned Value, SH = 0; 4384667f2cbad246beccfca5411a26add24d1007035Nate Begeman TargetMask = ~TargetMask; 4394667f2cbad246beccfca5411a26add24d1007035Nate Begeman InsertMask = ~InsertMask; 44077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 4414667f2cbad246beccfca5411a26add24d1007035Nate Begeman // If the LHS has a foldable shift and the RHS does not, then swap it to the 4424667f2cbad246beccfca5411a26add24d1007035Nate Begeman // RHS so that we can fold the shift into the insert. 44377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op0Opc == ISD::AND && Op1Opc == ISD::AND) { 44477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op0.getOperand(0).getOpcode() == ISD::SHL || 44577f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op0.getOperand(0).getOpcode() == ISD::SRL) { 44677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op1.getOperand(0).getOpcode() != ISD::SHL && 44777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1.getOperand(0).getOpcode() != ISD::SRL) { 44877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman std::swap(Op0, Op1); 44977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman std::swap(Op0Opc, Op1Opc); 4504667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(TargetMask, InsertMask); 45177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 45277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 4534667f2cbad246beccfca5411a26add24d1007035Nate Begeman } else if (Op0Opc == ISD::SHL || Op0Opc == ISD::SRL) { 4544667f2cbad246beccfca5411a26add24d1007035Nate Begeman if (Op1Opc == ISD::AND && Op1.getOperand(0).getOpcode() != ISD::SHL && 4554667f2cbad246beccfca5411a26add24d1007035Nate Begeman Op1.getOperand(0).getOpcode() != ISD::SRL) { 4564667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(Op0, Op1); 4574667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(Op0Opc, Op1Opc); 4584667f2cbad246beccfca5411a26add24d1007035Nate Begeman std::swap(TargetMask, InsertMask); 4594667f2cbad246beccfca5411a26add24d1007035Nate Begeman } 46002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 46177f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 46277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman unsigned MB, ME; 4630949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner if (InsertMask && isRunOfOnes(InsertMask, MB, ME)) { 46477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SDOperand Tmp1, Tmp2, Tmp3; 4654667f2cbad246beccfca5411a26add24d1007035Nate Begeman bool DisjointMask = (TargetMask ^ InsertMask) == 0xFFFFFFFF; 46677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 46777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if ((Op1Opc == ISD::SHL || Op1Opc == ISD::SRL) && 468c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(Op1.getOperand(1), Value)) { 46977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0); 47077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SH = (Op1Opc == ISD::SHL) ? Value : 32 - Value; 47102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 47277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if (Op1Opc == ISD::AND) { 47377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman unsigned SHOpc = Op1.getOperand(0).getOpcode(); 47477f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman if ((SHOpc == ISD::SHL || SHOpc == ISD::SRL) && 475c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(Op1.getOperand(0).getOperand(1), Value)) { 47677f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0).getOperand(0); 47777f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman SH = (SHOpc == ISD::SHL) ? Value : 32 - Value; 47877f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } else { 47977f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Op1 = Op1.getOperand(0); 48077f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman } 48102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 48277f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman 48377f361f5b3ac6ed080d6b0f401b62cd6e08614e5Nate Begeman Tmp3 = (Op0Opc == ISD::AND && DisjointMask) ? Op0.getOperand(0) : Op0; 4846da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(Tmp3); 4856da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(Op1); 4860949ed5412c0902113aaefe106fed5b383fcc696Chris Lattner SH &= 31; 4870b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng SDOperand Ops[] = { Tmp3, Op1, getI32Imm(SH), getI32Imm(MB), 4880b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(ME) }; 4890b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, Ops, 5); 49002b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 49102b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman } 49202b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman return 0; 49302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman} 49402b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman 4952fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// SelectCC - Select a comparison of the specified values with the specified 4962fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner/// condition code, returning the CR# of the expression. 4971d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate BegemanSDOperand PPCDAGToDAGISel::SelectCC(SDOperand LHS, SDOperand RHS, 4981d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman ISD::CondCode CC) { 4992fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner // Always select the LHS. 5006da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(LHS); 501c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner unsigned Opc; 502c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 503c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (LHS.getValueType() == MVT::i32) { 504529c233498c59a544b26b277f8fe30e6a80cc6f8Chris Lattner unsigned Imm; 5053836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner if (CC == ISD::SETEQ || CC == ISD::SETNE) { 5063836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner if (isInt32Immediate(RHS, Imm)) { 5073836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // SETEQ/SETNE comparison with 16-bit immediate, fold it. 5083836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner if (isUInt16(Imm)) 5093836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner return SDOperand(CurDAG->getTargetNode(PPC::CMPLWI, MVT::i32, LHS, 5103836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner getI32Imm(Imm & 0xFFFF)), 0); 5113836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // If this is a 16-bit signed immediate, fold it. 512aa43e9f73b4ccd700530803803e074eff9b3dca5Chris Lattner if (isInt16((int)Imm)) 5133836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner return SDOperand(CurDAG->getTargetNode(PPC::CMPWI, MVT::i32, LHS, 5143836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner getI32Imm(Imm & 0xFFFF)), 0); 5153836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner 5163836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // For non-equality comparisons, the default code would materialize the 5173836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // constant, then compare against it, like this: 5183836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // lis r2, 4660 5193836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // ori r2, r2, 22136 5203836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // cmpw cr0, r3, r2 5213836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // Since we are just comparing for equality, we can emit this instead: 5223836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // xoris r0,r3,0x1234 5233836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // cmplwi cr0,r0,0x5678 5243836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner // beq cr0,L6 5253836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner SDOperand Xor(CurDAG->getTargetNode(PPC::XORIS, MVT::i32, LHS, 5263836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner getI32Imm(Imm >> 16)), 0); 5273836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner return SDOperand(CurDAG->getTargetNode(PPC::CMPLWI, MVT::i32, Xor, 5283836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner getI32Imm(Imm & 0xFFFF)), 0); 5293836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner } 5303836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner Opc = PPC::CMPLW; 5313836dbd3bde1100c1df847a582784cf83d18daf6Chris Lattner } else if (ISD::isUnsignedIntSetCC(CC)) { 532c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(RHS, Imm) && isUInt16(Imm)) 533c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return SDOperand(CurDAG->getTargetNode(PPC::CMPLWI, MVT::i32, LHS, 534c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner getI32Imm(Imm & 0xFFFF)), 0); 535c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPLW; 536c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } else { 537c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short SImm; 538c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(RHS, SImm)) 539c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return SDOperand(CurDAG->getTargetNode(PPC::CMPWI, MVT::i32, LHS, 540c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner getI32Imm((int)SImm & 0xFFFF)), 541c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 0); 542c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPW; 543c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 544c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } else if (LHS.getValueType() == MVT::i64) { 545c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner uint64_t Imm; 546711762497c27357adc1edf8d4237c2770fa303bbChris Lattner if (CC == ISD::SETEQ || CC == ISD::SETNE) { 547711762497c27357adc1edf8d4237c2770fa303bbChris Lattner if (isInt64Immediate(RHS.Val, Imm)) { 548711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // SETEQ/SETNE comparison with 16-bit immediate, fold it. 549711762497c27357adc1edf8d4237c2770fa303bbChris Lattner if (isUInt16(Imm)) 550711762497c27357adc1edf8d4237c2770fa303bbChris Lattner return SDOperand(CurDAG->getTargetNode(PPC::CMPLDI, MVT::i64, LHS, 551711762497c27357adc1edf8d4237c2770fa303bbChris Lattner getI32Imm(Imm & 0xFFFF)), 0); 552711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // If this is a 16-bit signed immediate, fold it. 553711762497c27357adc1edf8d4237c2770fa303bbChris Lattner if (isInt16(Imm)) 554711762497c27357adc1edf8d4237c2770fa303bbChris Lattner return SDOperand(CurDAG->getTargetNode(PPC::CMPDI, MVT::i64, LHS, 555711762497c27357adc1edf8d4237c2770fa303bbChris Lattner getI32Imm(Imm & 0xFFFF)), 0); 556711762497c27357adc1edf8d4237c2770fa303bbChris Lattner 557711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // For non-equality comparisons, the default code would materialize the 558711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // constant, then compare against it, like this: 559711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // lis r2, 4660 560711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // ori r2, r2, 22136 561711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // cmpd cr0, r3, r2 562711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // Since we are just comparing for equality, we can emit this instead: 563711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // xoris r0,r3,0x1234 564711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // cmpldi cr0,r0,0x5678 565711762497c27357adc1edf8d4237c2770fa303bbChris Lattner // beq cr0,L6 566711762497c27357adc1edf8d4237c2770fa303bbChris Lattner if (isUInt32(Imm)) { 567711762497c27357adc1edf8d4237c2770fa303bbChris Lattner SDOperand Xor(CurDAG->getTargetNode(PPC::XORIS8, MVT::i64, LHS, 568711762497c27357adc1edf8d4237c2770fa303bbChris Lattner getI64Imm(Imm >> 16)), 0); 569711762497c27357adc1edf8d4237c2770fa303bbChris Lattner return SDOperand(CurDAG->getTargetNode(PPC::CMPLDI, MVT::i64, Xor, 570711762497c27357adc1edf8d4237c2770fa303bbChris Lattner getI64Imm(Imm & 0xFFFF)), 0); 571711762497c27357adc1edf8d4237c2770fa303bbChris Lattner } 572711762497c27357adc1edf8d4237c2770fa303bbChris Lattner } 573711762497c27357adc1edf8d4237c2770fa303bbChris Lattner Opc = PPC::CMPLD; 574711762497c27357adc1edf8d4237c2770fa303bbChris Lattner } else if (ISD::isUnsignedIntSetCC(CC)) { 575c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt64Immediate(RHS.Val, Imm) && isUInt16(Imm)) 576c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return SDOperand(CurDAG->getTargetNode(PPC::CMPLDI, MVT::i64, LHS, 577c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner getI64Imm(Imm & 0xFFFF)), 0); 578c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPLD; 579c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } else { 580c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner short SImm; 581c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isIntS16Immediate(RHS, SImm)) 582c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return SDOperand(CurDAG->getTargetNode(PPC::CMPDI, MVT::i64, LHS, 583711762497c27357adc1edf8d4237c2770fa303bbChris Lattner getI64Imm(SImm & 0xFFFF)), 584c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner 0); 585c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::CMPD; 586c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner } 587919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner } else if (LHS.getValueType() == MVT::f32) { 588c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::FCMPUS; 5892fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } else { 590c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner assert(LHS.getValueType() == MVT::f64 && "Unknown vt!"); 591c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner Opc = PPC::FCMPUD; 5922fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 5936da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(RHS); 594c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner return SDOperand(CurDAG->getTargetNode(Opc, MVT::i32, LHS, RHS), 0); 5952fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 5962fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 597df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattnerstatic PPC::Predicate getPredicateForSetCC(ISD::CondCode CC) { 5982fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner switch (CC) { 5992fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 600ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOEQ: // FIXME: This is incorrect see PR642. 6015d634ce466173f6fde49470fad125eb09532caebChris Lattner case ISD::SETUEQ: 602df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETEQ: return PPC::PRED_EQ; 603ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETONE: // FIXME: This is incorrect see PR642. 6045d634ce466173f6fde49470fad125eb09532caebChris Lattner case ISD::SETUNE: 605df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETNE: return PPC::PRED_NE; 606ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLT: // FIXME: This is incorrect see PR642. 6072fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULT: 608df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETLT: return PPC::PRED_LT; 609ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOLE: // FIXME: This is incorrect see PR642. 6102fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETULE: 611df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETLE: return PPC::PRED_LE; 612ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGT: // FIXME: This is incorrect see PR642. 6132fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGT: 614df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETGT: return PPC::PRED_GT; 615ed048c067dc7bf342b2947b4de39e915dcbd2bf0Chris Lattner case ISD::SETOGE: // FIXME: This is incorrect see PR642. 6162fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner case ISD::SETUGE: 617df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETGE: return PPC::PRED_GE; 6186df2507121507c24d7155605c343e467e0106c07Chris Lattner 619df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETO: return PPC::PRED_NU; 620df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner case ISD::SETUO: return PPC::PRED_UN; 6212fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 6222fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner} 6232fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner 62464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// getCRIdxForSetCC - Return the index of the condition register field 62564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// associated with the SetCC condition, and whether or not the field is 62664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner/// treated as inverted. That is, lt = 0; ge = 0 inverted. 627fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner/// 628fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner/// If this returns with Other != -1, then the returned comparison is an or of 629fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner/// two simpler comparisons. In this case, Invert is guaranteed to be false. 630fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattnerstatic unsigned getCRIdxForSetCC(ISD::CondCode CC, bool &Invert, int &Other) { 631fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner Invert = false; 632fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner Other = -1; 63364906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner switch (CC) { 63464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner default: assert(0 && "Unknown condition!"); abort(); 635fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETOLT: 636fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETLT: return 0; // Bit #0 = SETOLT 637fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETOGT: 638fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETGT: return 1; // Bit #1 = SETOGT 639fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETOEQ: 640fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETEQ: return 2; // Bit #2 = SETOEQ 641fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETUO: return 3; // Bit #3 = SETUO 64264906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETUGE: 643fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETGE: Invert = true; return 0; // !Bit #0 = SETUGE 64464906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner case ISD::SETULE: 645fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETLE: Invert = true; return 1; // !Bit #1 = SETULE 6468e2a04e21dc8299bdaba4321a6e690712dab9617Chris Lattner case ISD::SETUNE: 647fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETNE: Invert = true; return 2; // !Bit #2 = SETUNE 648fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETO: Invert = true; return 3; // !Bit #3 = SETO 649fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETULT: Other = 0; return 3; // SETOLT | SETUO 650fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETUGT: Other = 1; return 3; // SETOGT | SETUO 651fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETUEQ: Other = 2; return 3; // SETOEQ | SETUO 652fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETOGE: Other = 1; return 2; // SETOGT | SETOEQ 653fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETOLE: Other = 0; return 2; // SETOLT | SETOEQ 654fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner case ISD::SETONE: Other = 0; return 1; // SETOLT | SETOGT 65564906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner } 65664906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner return 0; 65764906a06b3d1cafec41c6b562f0f8130724decf6Chris Lattner} 6589944b76cfe74981d2c41c8237d25267ba0c467c7Chris Lattner 659ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris LattnerSDNode *PPCDAGToDAGISel::SelectSETCC(SDOperand Op) { 660222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDNode *N = Op.Val; 661222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner unsigned Imm; 662222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get(); 663c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm)) { 664222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // We can codegen setcc op, imm very efficiently compared to a brcond. 665222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Check for those cases here. 666222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // setcc op, 0 667222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner if (Imm == 0) { 6686da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng SDOperand Op = N->getOperand(0); 6696da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(Op); 670222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 671dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 6720b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng case ISD::SETEQ: { 6737e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::CNTLZW, MVT::i32, Op), 0); 6740b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng SDOperand Ops[] = { Op, getI32Imm(27), getI32Imm(5), getI32Imm(31) }; 6750b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 6760b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng } 677dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 6787e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AD = 6797e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 6807e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(~0U)), 0); 68171d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, 68295514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng AD.getValue(1)); 683dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 6840b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng case ISD::SETLT: { 6850b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng SDOperand Ops[] = { Op, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 6860b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 6870b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng } 688dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETGT: { 6897e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand T = 6907e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::NEG, MVT::i32, Op), 0); 6917e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng T = SDOperand(CurDAG->getTargetNode(PPC::ANDC, MVT::i32, T, Op), 0); 6920b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng SDOperand Ops[] = { T, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 6930b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 694dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 695222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 696222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } else if (Imm == ~0U) { // setcc op, -1 6976da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng SDOperand Op = N->getOperand(0); 6986da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(Op); 699222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner switch (CC) { 700dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner default: break; 701dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETEQ: 7027e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 7037e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(1)), 0); 70471d3d50b4a2182ce34d383c00a6f0e6231685cbfChris Lattner return CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 7057e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::LI, MVT::i32, 7067e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(0)), 0), 70795514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng Op.getValue(1)); 708dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETNE: { 7097e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::NOR, MVT::i32, Op, Op), 0); 7107e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *AD = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 7117e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op, getI32Imm(~0U)); 712c04ba7a97d5ad599d92a1817de2d7c5fbb145810Chris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, SDOperand(AD, 0), 71395514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng Op, SDOperand(AD, 1)); 714dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 715dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner case ISD::SETLT: { 7167e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AD = SDOperand(CurDAG->getTargetNode(PPC::ADDI, MVT::i32, Op, 7177e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng getI32Imm(1)), 0); 7187e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand AN = SDOperand(CurDAG->getTargetNode(PPC::AND, MVT::i32, AD, 7197e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng Op), 0); 7200b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng SDOperand Ops[] = { AN, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 7210b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 722dabb8291e840053a3d1a2a550d157e9c5c3c38c9Chris Lattner } 7230b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng case ISD::SETGT: { 7240b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng SDOperand Ops[] = { Op, getI32Imm(1), getI32Imm(31), getI32Imm(31) }; 7250b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng Op = SDOperand(CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Ops, 4), 0); 726ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Op, 72795514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng getI32Imm(1)); 728222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 7290b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng } 730222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 731222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 732222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 733222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner bool Inv; 734fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner int OtherCondIdx; 735fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner unsigned Idx = getCRIdxForSetCC(CC, Inv, OtherCondIdx); 736222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 737222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand IntCR; 738222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 739222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner // Force the ccreg into CR7. 740222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner SDOperand CR7Reg = CurDAG->getRegister(PPC::CR7, MVT::i32); 741222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 74285961d5ec126bbc0c111d52dd7361d5159265ca5Chris Lattner SDOperand InFlag(0, 0); // Null incoming flag value. 743db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner CCReg = CurDAG->getCopyToReg(CurDAG->getEntryNode(), CR7Reg, CCReg, 744db1cb2b3a15301c000c2bc5a99d5807510b2a456Chris Lattner InFlag).getValue(1); 745222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 746fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner if (PPCSubTarget.isGigaProcessor() && OtherCondIdx == -1) 7477e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng IntCR = SDOperand(CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, CR7Reg, 7487e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng CCReg), 0); 749222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner else 7507e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng IntCR = SDOperand(CurDAG->getTargetNode(PPC::MFCR, MVT::i32, CCReg), 0); 751222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner 7520b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng SDOperand Ops[] = { IntCR, getI32Imm((32-(3-Idx)) & 31), 7530b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(31), getI32Imm(31) }; 754fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner if (OtherCondIdx == -1 && !Inv) 7550b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 756fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 757fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // Get the specified bit. 758fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner SDOperand Tmp = 759fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner SDOperand(CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Ops, 4), 0); 760fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner if (Inv) { 761fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner assert(OtherCondIdx == -1 && "Can't have split plus negation"); 76295514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng return CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Tmp, getI32Imm(1)); 763222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner } 764fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 765fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // Otherwise, we have to turn an operation like SETONE -> SETOLT | SETOGT. 766fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // We already got the bit for the first part of the comparison (e.g. SETULE). 767fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 768fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner // Get the other bit of the comparison. 769fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner Ops[1] = getI32Imm((32-(3-OtherCondIdx)) & 31); 770fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner SDOperand OtherCond = 771fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner SDOperand(CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Ops, 4), 0); 772fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner 773fe39edde27147d4645aff715d5a7630fa07fa885Chris Lattner return CurDAG->SelectNodeTo(N, PPC::OR, MVT::i32, Tmp, OtherCond); 774222adac30a642b5ea4a916eb3e97d8d95eb32beaChris Lattner} 7752b63e4c5e2281ebc5575be3339d311d34f850b3bChris Lattner 7766a16f6a14f344eb49a218b3fe159858e95d73e94Chris Lattner 777a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// Select - Convert the specified operand from a target-independent to a 778a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner// target-specific node if it hasn't already been changed. 7799ade218533429146731213eacb7e12060e65ff58Evan ChengSDNode *PPCDAGToDAGISel::Select(SDOperand Op) { 780a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner SDNode *N = Op.Val; 7810bbea954331b8f08afa5b094dfb0841829c70eaaChris Lattner if (N->getOpcode() >= ISD::BUILTIN_OP_END && 7829ade218533429146731213eacb7e12060e65ff58Evan Cheng N->getOpcode() < PPCISD::FIRST_NUMBER) 78364a752f7c7cf160f2887d0a16d5922359832c9c2Evan Cheng return NULL; // Already selected. 784d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 785a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner switch (N->getOpcode()) { 78619c0907ba1c11c81dc231cf7b4143fdaf03466e4Chris Lattner default: break; 78778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 78878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey case ISD::Constant: { 78978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (N->getValueType(0) == MVT::i64) { 79078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Get 64 bit value. 79178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey int64_t Imm = cast<ConstantSDNode>(N)->getValue(); 79278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Assume no remaining bits. 79378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Remainder = 0; 79478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Assume no shift required. 79578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Shift = 0; 79678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 79778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // If it can't be represented as a 32 bit value. 79878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (!isInt32(Imm)) { 79978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Shift = CountTrailingZeros_64(Imm); 80078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey int64_t ImmSh = static_cast<uint64_t>(Imm) >> Shift; 80178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 80278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // If the shifted value fits 32 bits. 80378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (isInt32(ImmSh)) { 80478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Go with the shifted value. 80578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Imm = ImmSh; 80678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } else { 80778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Still stuck with a 64 bit value. 80878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Remainder = Imm; 80978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Shift = 32; 81078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Imm >>= 32; 81178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 81278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 81378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 81478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Intermediate operand. 81578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey SDNode *Result; 81678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 81778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Handle first 32 bits. 81878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Lo = Imm & 0xFFFF; 81978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned Hi = (Imm >> 16) & 0xFFFF; 82078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 82178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Simple value. 82278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (isInt16(Imm)) { 82378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Just the Lo bits. 82478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Result = CurDAG->getTargetNode(PPC::LI8, MVT::i64, getI32Imm(Lo)); 82578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } else if (Lo) { 82678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Handle the Hi bits. 82778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey unsigned OpC = Hi ? PPC::LIS8 : PPC::LI8; 82878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Result = CurDAG->getTargetNode(OpC, MVT::i64, getI32Imm(Hi)); 82978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // And Lo bits. 83078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Result = CurDAG->getTargetNode(PPC::ORI8, MVT::i64, 83178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey SDOperand(Result, 0), getI32Imm(Lo)); 83278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } else { 83378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Just the Hi bits. 83478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Result = CurDAG->getTargetNode(PPC::LIS8, MVT::i64, getI32Imm(Hi)); 83578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 83678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 83778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // If no shift, we're done. 83878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (!Shift) return Result; 83978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 84078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Shift for next step if the upper 32-bits were not zero. 84178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if (Imm) { 84278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Result = CurDAG->getTargetNode(PPC::RLDICR, MVT::i64, 84378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey SDOperand(Result, 0), 84478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey getI32Imm(Shift), getI32Imm(63 - Shift)); 84578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 84678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 84778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey // Add in the last bits as required. 84878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if ((Hi = (Remainder >> 16) & 0xFFFF)) { 84978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Result = CurDAG->getTargetNode(PPC::ORIS8, MVT::i64, 85078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey SDOperand(Result, 0), getI32Imm(Hi)); 85178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 85278f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey if ((Lo = Remainder & 0xFFFF)) { 85378f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey Result = CurDAG->getTargetNode(PPC::ORI8, MVT::i64, 85478f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey SDOperand(Result, 0), getI32Imm(Lo)); 85578f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 85678f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 85778f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey return Result; 85878f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 85978f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey break; 86078f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey } 86178f97f3118c0d7fbebf4084e24689c596d5e4fb7Jim Laskey 86234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case ISD::SETCC: 863ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return SelectSETCC(Op); 86434167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng case PPCISD::GlobalBaseReg: 8659ade218533429146731213eacb7e12060e65ff58Evan Cheng return getGlobalBaseReg(); 866860e8862c1fbd3b261da4a64a8c0096f9f373681Chris Lattner 867e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner case ISD::FrameIndex: { 868e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner int FI = cast<FrameIndexSDNode>(N)->getIndex(); 869c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner SDOperand TFI = CurDAG->getTargetFrameIndex(FI, Op.getValueType()); 870c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner unsigned Opc = Op.getValueType() == MVT::i32 ? PPC::ADDI : PPC::ADDI8; 871ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner if (N->hasOneUse()) 872ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->SelectNodeTo(N, Opc, Op.getValueType(), TFI, 87395514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng getSmallIPtrImm(0)); 874ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->getTargetNode(Opc, Op.getValueType(), TFI, 875ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner getSmallIPtrImm(0)); 876e28e40a2733c5d9a568d1569e2d1d8461716b22dChris Lattner } 8776d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner 8786d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner case PPCISD::MFCR: { 8796da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng SDOperand InFlag = N->getOperand(1); 8806da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(InFlag); 8816d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner // Use MFOCRF if supported. 882152b7e18748f7e06a93260f22cc9dac8eb3abee2Evan Cheng if (PPCSubTarget.isGigaProcessor()) 883ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->getTargetNode(PPC::MFOCRF, MVT::i32, 884ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner N->getOperand(0), InFlag); 8856d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner else 886ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->getTargetNode(PPC::MFCR, MVT::i32, InFlag); 8876d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner } 8886d92caddc4aa5fc946b294259e00cc35536e61e8Chris Lattner 88988add100b3db715df4275c8ab408e6b51f28ff8fChris Lattner case ISD::SDIV: { 890405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: since this depends on the setting of the carry flag from the srawi 891405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // we should really be making notes about that for the scheduler. 892405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // FIXME: It sure would be nice if we could cheaply recognize the 893405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // srl/add/sra pattern the dag combiner will generate for this as 894405e3ecb563f21e7b4ee30f0de57821f3eb91219Nate Begeman // sra/addze rather than having to handle sdiv ourselves. oh well. 8958784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner unsigned Imm; 896c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm)) { 8976da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng SDOperand N0 = N->getOperand(0); 8986da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N0); 8998784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner if ((signed)Imm > 0 && isPowerOf2_32(Imm)) { 9007e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 9018784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 90234167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N0, getI32Imm(Log2_32(Imm))); 903ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, 90495514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng SDOperand(Op, 0), SDOperand(Op, 1)); 9058784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } else if ((signed)Imm < 0 && isPowerOf2_32(-Imm)) { 9067e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Op = 9072501d5e29c13f41fc15c0be5fece011db27c8ab3Chris Lattner CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, MVT::Flag, 90834167215a8da717b21e44f1b834dc34d15279bf1Evan Cheng N0, getI32Imm(Log2_32(-Imm))); 9098784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner SDOperand PT = 9107e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, 9117e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDOperand(Op, 0), SDOperand(Op, 1)), 9127e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng 0); 91395514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng return CurDAG->SelectNodeTo(N, PPC::NEG, MVT::i32, PT); 9148784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 9158784a23075f8544f78f8b46cfd10457c1109d433Chris Lattner } 916047b952e298352fe6feffedf02e359601133f465Chris Lattner 917237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 918237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 919047b952e298352fe6feffedf02e359601133f465Chris Lattner } 9204eab71497d10622bd209c53f8e56152877ac5638Chris Lattner 9214eab71497d10622bd209c53f8e56152877ac5638Chris Lattner case ISD::LOAD: { 9224eab71497d10622bd209c53f8e56152877ac5638Chris Lattner // Handle preincrement loads. 9234eab71497d10622bd209c53f8e56152877ac5638Chris Lattner LoadSDNode *LD = cast<LoadSDNode>(Op); 92483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT LoadedVT = LD->getMemoryVT(); 9254eab71497d10622bd209c53f8e56152877ac5638Chris Lattner 9264eab71497d10622bd209c53f8e56152877ac5638Chris Lattner // Normal loads are handled by code generated from the .td file. 9274eab71497d10622bd209c53f8e56152877ac5638Chris Lattner if (LD->getAddressingMode() != ISD::PRE_INC) 9284eab71497d10622bd209c53f8e56152877ac5638Chris Lattner break; 9294eab71497d10622bd209c53f8e56152877ac5638Chris Lattner 9304eab71497d10622bd209c53f8e56152877ac5638Chris Lattner SDOperand Offset = LD->getOffset(); 9315b3bbc7cd7bff4275b94003d4bf1fa296c6a10d0Chris Lattner if (isa<ConstantSDNode>(Offset) || 9325b3bbc7cd7bff4275b94003d4bf1fa296c6a10d0Chris Lattner Offset.getOpcode() == ISD::TargetGlobalAddress) { 9330851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner 9340851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner unsigned Opcode; 9350851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner bool isSExt = LD->getExtensionType() == ISD::SEXTLOAD; 9360851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner if (LD->getValueType(0) != MVT::i64) { 9370851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner // Handle PPC32 integer and normal FP loads. 9387c1c261272b43f2a9397c3052819b92c53918075Anton Korobeynikov assert((!isSExt || LoadedVT == MVT::i16) && "Invalid sext update load"); 93983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands switch (LoadedVT.getSimpleVT()) { 9400851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner default: assert(0 && "Invalid PPC load type!"); 9410851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::f64: Opcode = PPC::LFDU; break; 9420851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::f32: Opcode = PPC::LFSU; break; 9430851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i32: Opcode = PPC::LWZU; break; 9440851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i16: Opcode = isSExt ? PPC::LHAU : PPC::LHZU; break; 9450851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i1: 9460851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i8: Opcode = PPC::LBZU; break; 9470851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } 9480851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } else { 9490851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner assert(LD->getValueType(0) == MVT::i64 && "Unknown load result type!"); 9507c1c261272b43f2a9397c3052819b92c53918075Anton Korobeynikov assert((!isSExt || LoadedVT == MVT::i16) && "Invalid sext update load"); 95183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands switch (LoadedVT.getSimpleVT()) { 9520851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner default: assert(0 && "Invalid PPC load type!"); 9530851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i64: Opcode = PPC::LDU; break; 9540851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i32: Opcode = PPC::LWZU8; break; 9550851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i16: Opcode = isSExt ? PPC::LHAU8 : PPC::LHZU8; break; 9560851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i1: 9570851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner case MVT::i8: Opcode = PPC::LBZU8; break; 9580851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } 9590851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner } 9600851b4f3eda110cc21c8d4b59f0d55bc84d9d088Chris Lattner 9614eab71497d10622bd209c53f8e56152877ac5638Chris Lattner SDOperand Chain = LD->getChain(); 9624eab71497d10622bd209c53f8e56152877ac5638Chris Lattner SDOperand Base = LD->getBasePtr(); 9634eab71497d10622bd209c53f8e56152877ac5638Chris Lattner AddToISelQueue(Chain); 9644eab71497d10622bd209c53f8e56152877ac5638Chris Lattner AddToISelQueue(Base); 9654eab71497d10622bd209c53f8e56152877ac5638Chris Lattner AddToISelQueue(Offset); 9664eab71497d10622bd209c53f8e56152877ac5638Chris Lattner SDOperand Ops[] = { Offset, Base, Chain }; 9674eab71497d10622bd209c53f8e56152877ac5638Chris Lattner // FIXME: PPC64 9684eab71497d10622bd209c53f8e56152877ac5638Chris Lattner return CurDAG->getTargetNode(Opcode, MVT::i32, MVT::i32, 9694eab71497d10622bd209c53f8e56152877ac5638Chris Lattner MVT::Other, Ops, 3); 9704eab71497d10622bd209c53f8e56152877ac5638Chris Lattner } else { 9714eab71497d10622bd209c53f8e56152877ac5638Chris Lattner assert(0 && "R+R preindex loads not supported yet!"); 9724eab71497d10622bd209c53f8e56152877ac5638Chris Lattner } 9734eab71497d10622bd209c53f8e56152877ac5638Chris Lattner } 9744eab71497d10622bd209c53f8e56152877ac5638Chris Lattner 975cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman case ISD::AND: { 976f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman unsigned Imm, Imm2, SH, MB, ME; 977f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman 978cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // If this is an and of a value rotated between 0 and 31 bits and then and'd 979cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman // with a mask, emit rlwinm 980c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm) && 981f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman isRotateAndMask(N->getOperand(0).Val, Imm, false, SH, MB, ME)) { 982f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman SDOperand Val = N->getOperand(0).getOperand(0); 983f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman AddToISelQueue(Val); 9840b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng SDOperand Ops[] = { Val, getI32Imm(SH), getI32Imm(MB), getI32Imm(ME) }; 9850b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 986cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 987f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman // If this is just a masked value where the input is not handled above, and 988f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman // is not a rotate-left (handled by a pattern in the .td file), emit rlwinm 989f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman if (isInt32Immediate(N->getOperand(1), Imm) && 990f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman isRunOfOnes(Imm, MB, ME) && 991f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman N->getOperand(0).getOpcode() != ISD::ROTL) { 992f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman SDOperand Val = N->getOperand(0); 993f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman AddToISelQueue(Val); 994f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman SDOperand Ops[] = { Val, getI32Imm(0), getI32Imm(MB), getI32Imm(ME) }; 995f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 996f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman } 997f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman // AND X, 0 -> 0, not "rlwinm 32". 998f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman if (isInt32Immediate(N->getOperand(1), Imm) && (Imm == 0)) { 999f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman AddToISelQueue(N->getOperand(1)); 1000f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman ReplaceUses(SDOperand(N, 0), N->getOperand(1)); 1001f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman return NULL; 1002f42f133938545d4f5c249bcfef63db772ce8e942Nate Begeman } 100350fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // ISD::OR doesn't get all the bitfield insertion fun. 100450fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman // (and (or x, c1), c2) where isRunOfOnes(~(c1^c2)) is a bitfield insert 1005c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (isInt32Immediate(N->getOperand(1), Imm) && 100650fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman N->getOperand(0).getOpcode() == ISD::OR && 1007c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner isInt32Immediate(N->getOperand(0).getOperand(1), Imm2)) { 1008c9a5ef524a9f461717bbf647b2d3da061aed720dChris Lattner unsigned MB, ME; 100950fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman Imm = ~(Imm^Imm2); 101050fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman if (isRunOfOnes(Imm, MB, ME)) { 10116da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(0).getOperand(0)); 10126da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(0).getOperand(1)); 10130b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng SDOperand Ops[] = { N->getOperand(0).getOperand(0), 10140b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng N->getOperand(0).getOperand(1), 10150b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(0), getI32Imm(MB),getI32Imm(ME) }; 10160b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->getTargetNode(PPC::RLWIMI, MVT::i32, Ops, 5); 101750fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 101850fb3c498601a84e0d82d7bab3e28c820dd64598Nate Begeman } 1019237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner 1020237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1021237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1022cffc32b6e2e1edc2ddd62a00159f7008ee765d3eNate Begeman } 102302b88a4586704f34bc65afca3348453eae69d1d3Nate Begeman case ISD::OR: 1024cccef1c6fffa292c227a289d447f6b848ab56c62Chris Lattner if (N->getValueType(0) == MVT::i32) 1025ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner if (SDNode *I = SelectBitfieldInsert(N)) 1026ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return I; 1027d3d2cf52bbb776941bf8cb03d8732ff3f407cdeaChris Lattner 1028237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner // Other cases are autogenerated. 1029237733e9335f4d2bb16a818ab184929e12fae407Chris Lattner break; 1030c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SHL: { 1031c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1032c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 10332d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 10346da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(0).getOperand(0)); 10350b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng SDOperand Ops[] = { N->getOperand(0).getOperand(0), 10360b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(SH), getI32Imm(MB), getI32Imm(ME) }; 10370b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 10388d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 10392d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 10402d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 10412d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1042c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 1043c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman case ISD::SRL: { 1044c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman unsigned Imm, SH, MB, ME; 1045c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman if (isOpcWithIntImmediate(N->getOperand(0).Val, ISD::AND, Imm) && 10462d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman isRotateAndMask(N, Imm, true, SH, MB, ME)) { 10476da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(0).getOperand(0)); 10480b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng SDOperand Ops[] = { N->getOperand(0).getOperand(0), 10490b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(SH), getI32Imm(MB), getI32Imm(ME) }; 10500b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops, 4); 10518d948323942cf031e9d1c55bda2bff9d4db4cf42Nate Begeman } 10522d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman 10532d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman // Other cases are autogenerated. 10542d5aff761d32b7f4fddc982e9444d20af48f080bNate Begeman break; 1055c15ed447f494c77a76c24661893e22192ebb2103Nate Begeman } 105613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner case ISD::SELECT_CC: { 105713794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(4))->get(); 105813794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner 1059c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner // Handle the setcc cases here. select_cc lhs, 0, 1, 0, cc 106013794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N->getOperand(1))) 106113794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N->getOperand(2))) 106213794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N->getOperand(3))) 106313794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner if (N1C->isNullValue() && N3C->isNullValue() && 1064c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner N2C->getValue() == 1ULL && CC == ISD::SETNE && 1065c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner // FIXME: Implement this optzn for PPC64. 1066c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner N->getValueType(0) == MVT::i32) { 10676da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(0)); 10687e9b26fc73425ae215fbc9c8010cb53059a93b3aEvan Cheng SDNode *Tmp = 106913794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, 10706da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng N->getOperand(0), getI32Imm(~0U)); 1071ccbe2ec890ca41b8fd8c4e8ef0f7bcb42c2f69ecChris Lattner return CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, 10726da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng SDOperand(Tmp, 0), N->getOperand(0), 107395514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng SDOperand(Tmp, 1)); 107413794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 10758a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 107650ff55c2c7909818165e51bbdc103a05b143dcb1Chris Lattner SDOperand CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC); 1077df4ed6350b2a51f71c0980e86c9078f4046ea706Chris Lattner unsigned BROpc = getPredicateForSetCC(CC); 10788a2d3ca7dff8f37ee0f1fc0042f47c194045183dChris Lattner 1079919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner unsigned SelectCCOp; 1080c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner if (N->getValueType(0) == MVT::i32) 1081c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner SelectCCOp = PPC::SELECT_CC_I4; 1082c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner else if (N->getValueType(0) == MVT::i64) 1083c08f902bb7bfcc8a97a4c7c9eb9187882dc2d6d7Chris Lattner SelectCCOp = PPC::SELECT_CC_I8; 1084919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner else if (N->getValueType(0) == MVT::f32) 1085919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F4; 1086710ff32983ca919fa0da14e077450b6a7654274fChris Lattner else if (N->getValueType(0) == MVT::f64) 1087919c032fa4511468aadc6f50d6ed9c50890710b3Chris Lattner SelectCCOp = PPC::SELECT_CC_F8; 1088710ff32983ca919fa0da14e077450b6a7654274fChris Lattner else 1089710ff32983ca919fa0da14e077450b6a7654274fChris Lattner SelectCCOp = PPC::SELECT_CC_VRRC; 1090710ff32983ca919fa0da14e077450b6a7654274fChris Lattner 10916da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(2)); 10926da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(3)); 10930b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng SDOperand Ops[] = { CCReg, N->getOperand(2), N->getOperand(3), 10940b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng getI32Imm(BROpc) }; 10950b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng return CurDAG->SelectNodeTo(N, SelectCCOp, N->getValueType(0), Ops, 4); 109613794f5d01317d76ec698b43bdf1c35eea57eae5Chris Lattner } 109718258c640466274c26e89016e361ec411ff78520Chris Lattner case PPCISD::COND_BRANCH: { 109818258c640466274c26e89016e361ec411ff78520Chris Lattner AddToISelQueue(N->getOperand(0)); // Op #0 is the Chain. 109918258c640466274c26e89016e361ec411ff78520Chris Lattner // Op #1 is the PPC::PRED_* number. 110018258c640466274c26e89016e361ec411ff78520Chris Lattner // Op #2 is the CR# 110118258c640466274c26e89016e361ec411ff78520Chris Lattner // Op #3 is the Dest MBB 110218258c640466274c26e89016e361ec411ff78520Chris Lattner AddToISelQueue(N->getOperand(4)); // Op #4 is the Flag. 11032bda17c92229e7116adf2edd3eea98c0a12f43cbEvan Cheng // Prevent PPC::PRED_* from being selected into LI. 11042bda17c92229e7116adf2edd3eea98c0a12f43cbEvan Cheng SDOperand Pred = 11052bda17c92229e7116adf2edd3eea98c0a12f43cbEvan Cheng getI32Imm(cast<ConstantSDNode>(N->getOperand(1))->getValue()); 11062bda17c92229e7116adf2edd3eea98c0a12f43cbEvan Cheng SDOperand Ops[] = { Pred, N->getOperand(2), N->getOperand(3), 110718258c640466274c26e89016e361ec411ff78520Chris Lattner N->getOperand(0), N->getOperand(4) }; 110818258c640466274c26e89016e361ec411ff78520Chris Lattner return CurDAG->SelectNodeTo(N, PPC::BCC, MVT::Other, Ops, 5); 110918258c640466274c26e89016e361ec411ff78520Chris Lattner } 111081e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman case ISD::BR_CC: { 11116da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(N->getOperand(0)); 11122fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(1))->get(); 11132fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner SDOperand CondCode = SelectCC(N->getOperand(2), N->getOperand(3), CC); 111418258c640466274c26e89016e361ec411ff78520Chris Lattner SDOperand Ops[] = { getI32Imm(getPredicateForSetCC(CC)), CondCode, 11150b828e08f94459ac0046b864871d92fed4aaef7cEvan Cheng N->getOperand(4), N->getOperand(0) }; 1116289c2d5f4566d8d7722e3934f4763d3df92886f3Chris Lattner return CurDAG->SelectNodeTo(N, PPC::BCC, MVT::Other, Ops, 4); 11172fbb4579d6d6bbde8387283b78307c2ea477a312Chris Lattner } 111837efe6764568a3829fee26aba532283131d1a104Nate Begeman case ISD::BRIND: { 1119cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner // FIXME: Should custom lower this. 11206da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng SDOperand Chain = N->getOperand(0); 11216da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng SDOperand Target = N->getOperand(1); 11226da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(Chain); 11236da2f3268d12a9e64f2635dbb94b63e1c4142f59Evan Cheng AddToISelQueue(Target); 11246b76b96c69334f3b6a2a895ff810ed047b4b75e5Chris Lattner unsigned Opc = Target.getValueType() == MVT::i32 ? PPC::MTCTR : PPC::MTCTR8; 11256b76b96c69334f3b6a2a895ff810ed047b4b75e5Chris Lattner Chain = SDOperand(CurDAG->getTargetNode(Opc, MVT::Other, Target, 112637efe6764568a3829fee26aba532283131d1a104Nate Begeman Chain), 0); 112795514bae7309ffacfc0a79b267159dcfde2b7720Evan Cheng return CurDAG->SelectNodeTo(N, PPC::BCTR, MVT::Other, Chain); 112837efe6764568a3829fee26aba532283131d1a104Nate Begeman } 1129a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner } 113025dae727f3b0c3511c17d7b7a8d476b1eed04f20Chris Lattner 11319ade218533429146731213eacb7e12060e65ff58Evan Cheng return SelectCode(Op); 1132a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1133a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1134a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1135cf0063171995c97ee52dfdf5d6bbbe090d2f5f03Chris Lattner 11361d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman/// createPPCISelDag - This pass converts a legalized DAG into a 1137a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// PowerPC-specific DAG, ready for instruction scheduling. 1138a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner/// 1139c4c6257c1a154279bf10e9498d46d6c1793dbaa7Evan ChengFunctionPass *llvm::createPPCISelDag(PPCTargetMachine &TM) { 11401d9d7427c4a4e3c7bdcfd1f725447f355e509c20Nate Begeman return new PPCDAGToDAGISel(TM); 1141a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner} 1142a5a91b10262f5bbcf1ec8abd1e66ee6585d3f00eChris Lattner 1143