SparcISelDAGToDAG.cpp revision 7d052f272d3f9ad0acdebf6811e29d529f70c1e1
1//===-- SparcISelDAGToDAG.cpp - A dag to dag inst selector for Sparc ------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines an instruction selector for the SPARC target. 11// 12//===----------------------------------------------------------------------===// 13 14#include "SparcTargetMachine.h" 15#include "llvm/CodeGen/SelectionDAGISel.h" 16#include "llvm/IR/Intrinsics.h" 17#include "llvm/Support/Compiler.h" 18#include "llvm/Support/Debug.h" 19#include "llvm/Support/ErrorHandling.h" 20#include "llvm/Support/raw_ostream.h" 21using namespace llvm; 22 23//===----------------------------------------------------------------------===// 24// Instruction Selector Implementation 25//===----------------------------------------------------------------------===// 26 27//===--------------------------------------------------------------------===// 28/// SparcDAGToDAGISel - SPARC specific code to select SPARC machine 29/// instructions for SelectionDAG operations. 30/// 31namespace { 32class SparcDAGToDAGISel : public SelectionDAGISel { 33 /// Subtarget - Keep a pointer to the Sparc Subtarget around so that we can 34 /// make the right decision when generating code for different targets. 35 const SparcSubtarget &Subtarget; 36 SparcTargetMachine &TM; 37public: 38 explicit SparcDAGToDAGISel(SparcTargetMachine &tm) 39 : SelectionDAGISel(tm), 40 Subtarget(tm.getSubtarget<SparcSubtarget>()), 41 TM(tm) { 42 } 43 44 SDNode *Select(SDNode *N); 45 46 // Complex Pattern Selectors. 47 bool SelectADDRrr(SDValue N, SDValue &R1, SDValue &R2); 48 bool SelectADDRri(SDValue N, SDValue &Base, SDValue &Offset); 49 50 /// SelectInlineAsmMemoryOperand - Implement addressing mode selection for 51 /// inline asm expressions. 52 virtual bool SelectInlineAsmMemoryOperand(const SDValue &Op, 53 char ConstraintCode, 54 std::vector<SDValue> &OutOps); 55 56 virtual const char *getPassName() const { 57 return "SPARC DAG->DAG Pattern Instruction Selection"; 58 } 59 60 // Include the pieces autogenerated from the target description. 61#include "SparcGenDAGISel.inc" 62 63private: 64 SDNode* getGlobalBaseReg(); 65}; 66} // end anonymous namespace 67 68SDNode* SparcDAGToDAGISel::getGlobalBaseReg() { 69 unsigned GlobalBaseReg = TM.getInstrInfo()->getGlobalBaseReg(MF); 70 return CurDAG->getRegister(GlobalBaseReg, 71 getTargetLowering()->getPointerTy()).getNode(); 72} 73 74bool SparcDAGToDAGISel::SelectADDRri(SDValue Addr, 75 SDValue &Base, SDValue &Offset) { 76 if (FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(Addr)) { 77 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), 78 getTargetLowering()->getPointerTy()); 79 Offset = CurDAG->getTargetConstant(0, MVT::i32); 80 return true; 81 } 82 if (Addr.getOpcode() == ISD::TargetExternalSymbol || 83 Addr.getOpcode() == ISD::TargetGlobalAddress || 84 Addr.getOpcode() == ISD::TargetGlobalTLSAddress) 85 return false; // direct calls. 86 87 if (Addr.getOpcode() == ISD::ADD) { 88 if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Addr.getOperand(1))) { 89 if (isInt<13>(CN->getSExtValue())) { 90 if (FrameIndexSDNode *FIN = 91 dyn_cast<FrameIndexSDNode>(Addr.getOperand(0))) { 92 // Constant offset from frame ref. 93 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), 94 getTargetLowering()->getPointerTy()); 95 } else { 96 Base = Addr.getOperand(0); 97 } 98 Offset = CurDAG->getTargetConstant(CN->getZExtValue(), MVT::i32); 99 return true; 100 } 101 } 102 if (Addr.getOperand(0).getOpcode() == SPISD::Lo) { 103 Base = Addr.getOperand(1); 104 Offset = Addr.getOperand(0).getOperand(0); 105 return true; 106 } 107 if (Addr.getOperand(1).getOpcode() == SPISD::Lo) { 108 Base = Addr.getOperand(0); 109 Offset = Addr.getOperand(1).getOperand(0); 110 return true; 111 } 112 } 113 Base = Addr; 114 Offset = CurDAG->getTargetConstant(0, MVT::i32); 115 return true; 116} 117 118bool SparcDAGToDAGISel::SelectADDRrr(SDValue Addr, SDValue &R1, SDValue &R2) { 119 if (Addr.getOpcode() == ISD::FrameIndex) return false; 120 if (Addr.getOpcode() == ISD::TargetExternalSymbol || 121 Addr.getOpcode() == ISD::TargetGlobalAddress || 122 Addr.getOpcode() == ISD::TargetGlobalTLSAddress) 123 return false; // direct calls. 124 125 if (Addr.getOpcode() == ISD::ADD) { 126 if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Addr.getOperand(1))) 127 if (isInt<13>(CN->getSExtValue())) 128 return false; // Let the reg+imm pattern catch this! 129 if (Addr.getOperand(0).getOpcode() == SPISD::Lo || 130 Addr.getOperand(1).getOpcode() == SPISD::Lo) 131 return false; // Let the reg+imm pattern catch this! 132 R1 = Addr.getOperand(0); 133 R2 = Addr.getOperand(1); 134 return true; 135 } 136 137 R1 = Addr; 138 R2 = CurDAG->getRegister(SP::G0, getTargetLowering()->getPointerTy()); 139 return true; 140} 141 142SDNode *SparcDAGToDAGISel::Select(SDNode *N) { 143 SDLoc dl(N); 144 if (N->isMachineOpcode()) 145 return NULL; // Already selected. 146 147 switch (N->getOpcode()) { 148 default: break; 149 case SPISD::GLOBAL_BASE_REG: 150 return getGlobalBaseReg(); 151 152 case ISD::SDIV: 153 case ISD::UDIV: { 154 // sdivx / udivx handle 64-bit divides. 155 if (N->getValueType(0) == MVT::i64) 156 break; 157 // FIXME: should use a custom expander to expose the SRA to the dag. 158 SDValue DivLHS = N->getOperand(0); 159 SDValue DivRHS = N->getOperand(1); 160 161 // Set the Y register to the high-part. 162 SDValue TopPart; 163 if (N->getOpcode() == ISD::SDIV) { 164 TopPart = SDValue(CurDAG->getMachineNode(SP::SRAri, dl, MVT::i32, DivLHS, 165 CurDAG->getTargetConstant(31, MVT::i32)), 0); 166 } else { 167 TopPart = CurDAG->getRegister(SP::G0, MVT::i32); 168 } 169 TopPart = SDValue(CurDAG->getMachineNode(SP::WRYrr, dl, MVT::Glue, TopPart, 170 CurDAG->getRegister(SP::G0, MVT::i32)), 0); 171 172 // FIXME: Handle div by immediate. 173 unsigned Opcode = N->getOpcode() == ISD::SDIV ? SP::SDIVrr : SP::UDIVrr; 174 return CurDAG->SelectNodeTo(N, Opcode, MVT::i32, DivLHS, DivRHS, 175 TopPart); 176 } 177 case ISD::MULHU: 178 case ISD::MULHS: { 179 // FIXME: Handle mul by immediate. 180 SDValue MulLHS = N->getOperand(0); 181 SDValue MulRHS = N->getOperand(1); 182 unsigned Opcode = N->getOpcode() == ISD::MULHU ? SP::UMULrr : SP::SMULrr; 183 SDNode *Mul = CurDAG->getMachineNode(Opcode, dl, MVT::i32, MVT::Glue, 184 MulLHS, MulRHS); 185 // The high part is in the Y register. 186 return CurDAG->SelectNodeTo(N, SP::RDY, MVT::i32, SDValue(Mul, 1)); 187 } 188 } 189 190 return SelectCode(N); 191} 192 193 194/// SelectInlineAsmMemoryOperand - Implement addressing mode selection for 195/// inline asm expressions. 196bool 197SparcDAGToDAGISel::SelectInlineAsmMemoryOperand(const SDValue &Op, 198 char ConstraintCode, 199 std::vector<SDValue> &OutOps) { 200 SDValue Op0, Op1; 201 switch (ConstraintCode) { 202 default: return true; 203 case 'm': // memory 204 if (!SelectADDRrr(Op, Op0, Op1)) 205 SelectADDRri(Op, Op0, Op1); 206 break; 207 } 208 209 OutOps.push_back(Op0); 210 OutOps.push_back(Op1); 211 return false; 212} 213 214/// createSparcISelDag - This pass converts a legalized DAG into a 215/// SPARC-specific DAG, ready for instruction scheduling. 216/// 217FunctionPass *llvm::createSparcISelDag(SparcTargetMachine &TM) { 218 return new SparcDAGToDAGISel(TM); 219} 220