1 //===-- SparcV8ISelDAGToDAG.cpp - A dag to dag inst selector for SparcV8 --===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by Chris Lattner and is distributed under
6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines an instruction selector for the V8 target
12 //===----------------------------------------------------------------------===//
15 #include "SparcV8TargetMachine.h"
16 #include "llvm/DerivedTypes.h"
17 #include "llvm/Function.h"
18 #include "llvm/CodeGen/MachineFrameInfo.h"
19 #include "llvm/CodeGen/MachineFunction.h"
20 #include "llvm/CodeGen/MachineInstrBuilder.h"
21 #include "llvm/CodeGen/SelectionDAG.h"
22 #include "llvm/CodeGen/SelectionDAGISel.h"
23 #include "llvm/CodeGen/SSARegMap.h"
24 #include "llvm/Target/TargetLowering.h"
25 #include "llvm/Support/Debug.h"
29 //===----------------------------------------------------------------------===//
30 // TargetLowering Implementation
31 //===----------------------------------------------------------------------===//
35 FIRST_NUMBER = ISD::BUILTIN_OP_END+V8::INSTRUCTION_LIST_END,
36 CMPICC, // Compare two GPR operands, set icc.
37 CMPFCC, // Compare two FP operands, set fcc.
38 BRICC, // Branch to dest on icc condition
39 BRFCC, // Branch to dest on fcc condition
40 SELECT_ICC, // Select between two values using the current ICC flags.
41 SELECT_FCC, // Select between two values using the current FCC flags.
43 Hi, Lo, // Hi/Lo operations, typically on a global address.
45 FTOI, // FP to Int within a FP register.
46 ITOF, // Int to FP within a FP register.
48 CALL, // A V8 call instruction.
49 RET_FLAG, // Return with a flag operand.
53 // Enums corresponding to SparcV8 condition codes, both icc's and fcc's. These
54 // values must be kept in sync with the ones in the .td file.
57 //ICC_A = 8 , // Always
58 //ICC_N = 0 , // Never
59 ICC_NE = 9 , // Not Equal
61 ICC_G = 10 , // Greater
62 ICC_LE = 2 , // Less or Equal
63 ICC_GE = 11 , // Greater or Equal
65 ICC_GU = 12 , // Greater Unsigned
66 ICC_LEU = 4 , // Less or Equal Unsigned
67 ICC_CC = 13 , // Carry Clear/Great or Equal Unsigned
68 ICC_CS = 5 , // Carry Set/Less Unsigned
69 ICC_POS = 14 , // Positive
70 ICC_NEG = 6 , // Negative
71 ICC_VC = 15 , // Overflow Clear
72 ICC_VS = 7 , // Overflow Set
74 //FCC_A = 8+16, // Always
75 //FCC_N = 0+16, // Never
76 FCC_U = 7+16, // Unordered
77 FCC_G = 6+16, // Greater
78 FCC_UG = 5+16, // Unordered or Greater
80 FCC_UL = 3+16, // Unordered or Less
81 FCC_LG = 2+16, // Less or Greater
82 FCC_NE = 1+16, // Not Equal
83 FCC_E = 9+16, // Equal
84 FCC_UE = 10+16, // Unordered or Equal
85 FCC_GE = 11+16, // Greater or Equal
86 FCC_UGE = 12+16, // Unordered or Greater or Equal
87 FCC_LE = 13+16, // Less or Equal
88 FCC_ULE = 14+16, // Unordered or Less or Equal
89 FCC_O = 15+16, // Ordered
94 /// IntCondCCodeToICC - Convert a DAG integer condition code to a SPARC ICC
96 static V8CC::CondCodes IntCondCCodeToICC(ISD::CondCode CC) {
98 default: assert(0 && "Unknown integer condition code!");
99 case ISD::SETEQ: return V8CC::ICC_E;
100 case ISD::SETNE: return V8CC::ICC_NE;
101 case ISD::SETLT: return V8CC::ICC_L;
102 case ISD::SETGT: return V8CC::ICC_G;
103 case ISD::SETLE: return V8CC::ICC_LE;
104 case ISD::SETGE: return V8CC::ICC_GE;
105 case ISD::SETULT: return V8CC::ICC_CS;
106 case ISD::SETULE: return V8CC::ICC_LEU;
107 case ISD::SETUGT: return V8CC::ICC_GU;
108 case ISD::SETUGE: return V8CC::ICC_CC;
112 /// FPCondCCodeToFCC - Convert a DAG floatingp oint condition code to a SPARC
114 static V8CC::CondCodes FPCondCCodeToFCC(ISD::CondCode CC) {
116 default: assert(0 && "Unknown fp condition code!");
117 case ISD::SETEQ: return V8CC::FCC_E;
118 case ISD::SETNE: return V8CC::FCC_NE;
119 case ISD::SETLT: return V8CC::FCC_L;
120 case ISD::SETGT: return V8CC::FCC_G;
121 case ISD::SETLE: return V8CC::FCC_LE;
122 case ISD::SETGE: return V8CC::FCC_GE;
123 case ISD::SETULT: return V8CC::FCC_UL;
124 case ISD::SETULE: return V8CC::FCC_ULE;
125 case ISD::SETUGT: return V8CC::FCC_UG;
126 case ISD::SETUGE: return V8CC::FCC_UGE;
127 case ISD::SETUO: return V8CC::FCC_U;
128 case ISD::SETO: return V8CC::FCC_O;
129 case ISD::SETONE: return V8CC::FCC_LG;
130 case ISD::SETUEQ: return V8CC::FCC_UE;
135 static unsigned SPARCCondCodeToBranchInstr(V8CC::CondCodes CC) {
137 default: assert(0 && "Unknown condition code");
138 case V8CC::ICC_NE: return V8::BNE;
139 case V8CC::ICC_E: return V8::BE;
140 case V8CC::ICC_G: return V8::BG;
141 case V8CC::ICC_LE: return V8::BLE;
142 case V8CC::ICC_GE: return V8::BGE;
143 case V8CC::ICC_L: return V8::BL;
144 case V8CC::ICC_GU: return V8::BGU;
145 case V8CC::ICC_LEU: return V8::BLEU;
146 case V8CC::ICC_CC: return V8::BCC;
147 case V8CC::ICC_CS: return V8::BCS;
148 case V8CC::ICC_POS: return V8::BPOS;
149 case V8CC::ICC_NEG: return V8::BNEG;
150 case V8CC::ICC_VC: return V8::BVC;
151 case V8CC::ICC_VS: return V8::BVS;
152 case V8CC::FCC_U: return V8::FBU;
153 case V8CC::FCC_G: return V8::FBG;
154 case V8CC::FCC_UG: return V8::FBUG;
155 case V8CC::FCC_L: return V8::FBL;
156 case V8CC::FCC_UL: return V8::FBUL;
157 case V8CC::FCC_LG: return V8::FBLG;
158 case V8CC::FCC_NE: return V8::FBNE;
159 case V8CC::FCC_E: return V8::FBE;
160 case V8CC::FCC_UE: return V8::FBUE;
161 case V8CC::FCC_GE: return V8::FBGE;
162 case V8CC::FCC_UGE: return V8::FBUGE;
163 case V8CC::FCC_LE: return V8::FBLE;
164 case V8CC::FCC_ULE: return V8::FBULE;
165 case V8CC::FCC_O: return V8::FBO;
171 class SparcV8TargetLowering : public TargetLowering {
172 int VarArgsFrameOffset; // Frame offset to start of varargs area.
174 SparcV8TargetLowering(TargetMachine &TM);
175 virtual SDOperand LowerOperation(SDOperand Op, SelectionDAG &DAG);
177 /// isMaskedValueZeroForTargetNode - Return true if 'Op & Mask' is known to
178 /// be zero. Op is expected to be a target specific node. Used by DAG
180 virtual bool isMaskedValueZeroForTargetNode(const SDOperand &Op,
181 uint64_t Mask) const;
183 virtual std::vector<SDOperand>
184 LowerArguments(Function &F, SelectionDAG &DAG);
185 virtual std::pair<SDOperand, SDOperand>
186 LowerCallTo(SDOperand Chain, const Type *RetTy, bool isVarArg,
188 bool isTailCall, SDOperand Callee, ArgListTy &Args,
190 virtual std::pair<SDOperand, SDOperand>
191 LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, unsigned Depth,
193 virtual MachineBasicBlock *InsertAtEndOfBasicBlock(MachineInstr *MI,
194 MachineBasicBlock *MBB);
196 virtual const char *getTargetNodeName(unsigned Opcode) const;
200 SparcV8TargetLowering::SparcV8TargetLowering(TargetMachine &TM)
201 : TargetLowering(TM) {
203 // Set up the register classes.
204 addRegisterClass(MVT::i32, V8::IntRegsRegisterClass);
205 addRegisterClass(MVT::f32, V8::FPRegsRegisterClass);
206 addRegisterClass(MVT::f64, V8::DFPRegsRegisterClass);
208 // Custom legalize GlobalAddress nodes into LO/HI parts.
209 setOperationAction(ISD::GlobalAddress, MVT::i32, Custom);
210 setOperationAction(ISD::ConstantPool , MVT::i32, Custom);
212 // Sparc doesn't have sext_inreg, replace them with shl/sra
213 setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16, Expand);
214 setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8 , Expand);
215 setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1 , Expand);
217 // Sparc has no REM operation.
218 setOperationAction(ISD::UREM, MVT::i32, Expand);
219 setOperationAction(ISD::SREM, MVT::i32, Expand);
221 // Custom expand fp<->sint
222 setOperationAction(ISD::FP_TO_SINT, MVT::i32, Custom);
223 setOperationAction(ISD::SINT_TO_FP, MVT::i32, Custom);
226 setOperationAction(ISD::FP_TO_UINT, MVT::i32, Expand);
227 setOperationAction(ISD::UINT_TO_FP, MVT::i32, Expand);
229 setOperationAction(ISD::BIT_CONVERT, MVT::f32, Expand);
230 setOperationAction(ISD::BIT_CONVERT, MVT::i32, Expand);
232 // Turn FP extload into load/fextend
233 setOperationAction(ISD::EXTLOAD, MVT::f32, Expand);
235 // Sparc has no select or setcc: expand to SELECT_CC.
236 setOperationAction(ISD::SELECT, MVT::i32, Expand);
237 setOperationAction(ISD::SELECT, MVT::f32, Expand);
238 setOperationAction(ISD::SELECT, MVT::f64, Expand);
239 setOperationAction(ISD::SETCC, MVT::i32, Expand);
240 setOperationAction(ISD::SETCC, MVT::f32, Expand);
241 setOperationAction(ISD::SETCC, MVT::f64, Expand);
243 // Sparc doesn't have BRCOND either, it has BR_CC.
244 setOperationAction(ISD::BRCOND, MVT::Other, Expand);
245 setOperationAction(ISD::BRCONDTWOWAY, MVT::Other, Expand);
246 setOperationAction(ISD::BRTWOWAY_CC, MVT::Other, Expand);
247 setOperationAction(ISD::BR_CC, MVT::i32, Custom);
248 setOperationAction(ISD::BR_CC, MVT::f32, Custom);
249 setOperationAction(ISD::BR_CC, MVT::f64, Custom);
251 setOperationAction(ISD::SELECT_CC, MVT::i32, Custom);
252 setOperationAction(ISD::SELECT_CC, MVT::f32, Custom);
253 setOperationAction(ISD::SELECT_CC, MVT::f64, Custom);
255 // V8 has no intrinsics for these particular operations.
256 setOperationAction(ISD::MEMMOVE, MVT::Other, Expand);
257 setOperationAction(ISD::MEMSET, MVT::Other, Expand);
258 setOperationAction(ISD::MEMCPY, MVT::Other, Expand);
260 setOperationAction(ISD::FSIN , MVT::f64, Expand);
261 setOperationAction(ISD::FCOS , MVT::f64, Expand);
262 setOperationAction(ISD::FSIN , MVT::f32, Expand);
263 setOperationAction(ISD::FCOS , MVT::f32, Expand);
264 setOperationAction(ISD::CTPOP, MVT::i32, Expand);
265 setOperationAction(ISD::CTTZ , MVT::i32, Expand);
266 setOperationAction(ISD::CTLZ , MVT::i32, Expand);
267 setOperationAction(ISD::ROTL , MVT::i32, Expand);
268 setOperationAction(ISD::ROTR , MVT::i32, Expand);
269 setOperationAction(ISD::BSWAP, MVT::i32, Expand);
271 setOperationAction(ISD::SHL_PARTS, MVT::i32, Expand);
272 setOperationAction(ISD::SRA_PARTS, MVT::i32, Expand);
273 setOperationAction(ISD::SRL_PARTS, MVT::i32, Expand);
275 // We don't have line number support yet.
276 setOperationAction(ISD::LOCATION, MVT::Other, Expand);
277 setOperationAction(ISD::DEBUG_LOC, MVT::Other, Expand);
278 setOperationAction(ISD::DEBUG_LABEL, MVT::Other, Expand);
280 // RET must be custom lowered, to meet ABI requirements
281 setOperationAction(ISD::RET , MVT::Other, Custom);
283 // VASTART needs to be custom lowered to use the VarArgsFrameIndex
284 setOperationAction(ISD::VASTART , MVT::Other, Custom);
286 // Use the default implementation.
287 setOperationAction(ISD::VAARG , MVT::Other, Expand);
288 setOperationAction(ISD::VACOPY , MVT::Other, Expand);
289 setOperationAction(ISD::VAEND , MVT::Other, Expand);
290 setOperationAction(ISD::STACKSAVE , MVT::Other, Expand);
291 setOperationAction(ISD::STACKRESTORE , MVT::Other, Expand);
292 setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32 , Expand);
294 setOperationAction(ISD::ConstantFP, MVT::f64, Expand);
295 setOperationAction(ISD::ConstantFP, MVT::f32, Expand);
297 setStackPointerRegisterToSaveRestore(V8::O6);
299 if (TM.getSubtarget<SparcV8Subtarget>().isV9()) {
300 setOperationAction(ISD::CTPOP, MVT::i32, Legal);
303 computeRegisterProperties();
306 const char *SparcV8TargetLowering::getTargetNodeName(unsigned Opcode) const {
309 case V8ISD::CMPICC: return "V8ISD::CMPICC";
310 case V8ISD::CMPFCC: return "V8ISD::CMPFCC";
311 case V8ISD::BRICC: return "V8ISD::BRICC";
312 case V8ISD::BRFCC: return "V8ISD::BRFCC";
313 case V8ISD::SELECT_ICC: return "V8ISD::SELECT_ICC";
314 case V8ISD::SELECT_FCC: return "V8ISD::SELECT_FCC";
315 case V8ISD::Hi: return "V8ISD::Hi";
316 case V8ISD::Lo: return "V8ISD::Lo";
317 case V8ISD::FTOI: return "V8ISD::FTOI";
318 case V8ISD::ITOF: return "V8ISD::ITOF";
319 case V8ISD::CALL: return "V8ISD::CALL";
320 case V8ISD::RET_FLAG: return "V8ISD::RET_FLAG";
324 /// isMaskedValueZeroForTargetNode - Return true if 'Op & Mask' is known to
325 /// be zero. Op is expected to be a target specific node. Used by DAG
327 bool SparcV8TargetLowering::
328 isMaskedValueZeroForTargetNode(const SDOperand &Op, uint64_t Mask) const {
329 switch (Op.getOpcode()) {
330 default: return false;
331 case V8ISD::SELECT_ICC:
332 case V8ISD::SELECT_FCC:
333 assert(MVT::isInteger(Op.getValueType()) && "Not an integer select!");
334 // These operations are masked zero if both the left and the right are zero.
335 return MaskedValueIsZero(Op.getOperand(0), Mask) &&
336 MaskedValueIsZero(Op.getOperand(1), Mask);
341 /// LowerArguments - V8 uses a very simple ABI, where all values are passed in
342 /// either one or two GPRs, including FP values. TODO: we should pass FP values
343 /// in FP registers for fastcc functions.
344 std::vector<SDOperand>
345 SparcV8TargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) {
346 MachineFunction &MF = DAG.getMachineFunction();
347 SSARegMap *RegMap = MF.getSSARegMap();
348 std::vector<SDOperand> ArgValues;
350 static const unsigned ArgRegs[] = {
351 V8::I0, V8::I1, V8::I2, V8::I3, V8::I4, V8::I5
354 const unsigned *CurArgReg = ArgRegs, *ArgRegEnd = ArgRegs+6;
355 unsigned ArgOffset = 68;
357 SDOperand Root = DAG.getRoot();
358 std::vector<SDOperand> OutChains;
360 for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) {
361 MVT::ValueType ObjectVT = getValueType(I->getType());
364 default: assert(0 && "Unhandled argument type!");
369 if (I->use_empty()) { // Argument is dead.
370 if (CurArgReg < ArgRegEnd) ++CurArgReg;
371 ArgValues.push_back(DAG.getNode(ISD::UNDEF, ObjectVT));
372 } else if (CurArgReg < ArgRegEnd) { // Lives in an incoming GPR
373 unsigned VReg = RegMap->createVirtualRegister(&V8::IntRegsRegClass);
374 MF.addLiveIn(*CurArgReg++, VReg);
375 SDOperand Arg = DAG.getCopyFromReg(Root, VReg, MVT::i32);
376 if (ObjectVT != MVT::i32) {
377 unsigned AssertOp = I->getType()->isSigned() ? ISD::AssertSext
379 Arg = DAG.getNode(AssertOp, MVT::i32, Arg,
380 DAG.getValueType(ObjectVT));
381 Arg = DAG.getNode(ISD::TRUNCATE, ObjectVT, Arg);
383 ArgValues.push_back(Arg);
385 int FrameIdx = MF.getFrameInfo()->CreateFixedObject(4, ArgOffset);
386 SDOperand FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
388 if (ObjectVT == MVT::i32) {
389 Load = DAG.getLoad(MVT::i32, Root, FIPtr, DAG.getSrcValue(0));
392 I->getType()->isSigned() ? ISD::SEXTLOAD : ISD::ZEXTLOAD;
394 // Sparc is big endian, so add an offset based on the ObjectVT.
395 unsigned Offset = 4-std::max(1U, MVT::getSizeInBits(ObjectVT)/8);
396 FIPtr = DAG.getNode(ISD::ADD, MVT::i32, FIPtr,
397 DAG.getConstant(Offset, MVT::i32));
398 Load = DAG.getExtLoad(LoadOp, MVT::i32, Root, FIPtr,
399 DAG.getSrcValue(0), ObjectVT);
400 Load = DAG.getNode(ISD::TRUNCATE, ObjectVT, Load);
402 ArgValues.push_back(Load);
408 if (I->use_empty()) { // Argument is dead.
409 if (CurArgReg < ArgRegEnd) ++CurArgReg;
410 ArgValues.push_back(DAG.getNode(ISD::UNDEF, ObjectVT));
411 } else if (CurArgReg < ArgRegEnd) { // Lives in an incoming GPR
412 // FP value is passed in an integer register.
413 unsigned VReg = RegMap->createVirtualRegister(&V8::IntRegsRegClass);
414 MF.addLiveIn(*CurArgReg++, VReg);
415 SDOperand Arg = DAG.getCopyFromReg(Root, VReg, MVT::i32);
417 Arg = DAG.getNode(ISD::BIT_CONVERT, MVT::f32, Arg);
418 ArgValues.push_back(Arg);
420 int FrameIdx = MF.getFrameInfo()->CreateFixedObject(4, ArgOffset);
421 SDOperand FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
422 SDOperand Load = DAG.getLoad(MVT::f32, Root, FIPtr, DAG.getSrcValue(0));
423 ArgValues.push_back(Load);
430 if (I->use_empty()) { // Argument is dead.
431 if (CurArgReg < ArgRegEnd) ++CurArgReg;
432 if (CurArgReg < ArgRegEnd) ++CurArgReg;
433 ArgValues.push_back(DAG.getNode(ISD::UNDEF, ObjectVT));
434 } else if (/* FIXME: Apparently this isn't safe?? */
435 0 && CurArgReg == ArgRegEnd && ObjectVT == MVT::f64 &&
436 ((CurArgReg-ArgRegs) & 1) == 0) {
437 // If this is a double argument and the whole thing lives on the stack,
438 // and the argument is aligned, load the double straight from the stack.
439 // We can't do a load in cases like void foo([6ints], int,double),
440 // because the double wouldn't be aligned!
441 int FrameIdx = MF.getFrameInfo()->CreateFixedObject(8, ArgOffset);
442 SDOperand FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
443 ArgValues.push_back(DAG.getLoad(MVT::f64, Root, FIPtr,
444 DAG.getSrcValue(0)));
447 if (CurArgReg < ArgRegEnd) { // Lives in an incoming GPR
448 unsigned VRegHi = RegMap->createVirtualRegister(&V8::IntRegsRegClass);
449 MF.addLiveIn(*CurArgReg++, VRegHi);
450 HiVal = DAG.getCopyFromReg(Root, VRegHi, MVT::i32);
452 int FrameIdx = MF.getFrameInfo()->CreateFixedObject(4, ArgOffset);
453 SDOperand FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
454 HiVal = DAG.getLoad(MVT::i32, Root, FIPtr, DAG.getSrcValue(0));
458 if (CurArgReg < ArgRegEnd) { // Lives in an incoming GPR
459 unsigned VRegLo = RegMap->createVirtualRegister(&V8::IntRegsRegClass);
460 MF.addLiveIn(*CurArgReg++, VRegLo);
461 LoVal = DAG.getCopyFromReg(Root, VRegLo, MVT::i32);
463 int FrameIdx = MF.getFrameInfo()->CreateFixedObject(4, ArgOffset+4);
464 SDOperand FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
465 LoVal = DAG.getLoad(MVT::i32, Root, FIPtr, DAG.getSrcValue(0));
468 // Compose the two halves together into an i64 unit.
469 SDOperand WholeValue =
470 DAG.getNode(ISD::BUILD_PAIR, MVT::i64, LoVal, HiVal);
472 // If we want a double, do a bit convert.
473 if (ObjectVT == MVT::f64)
474 WholeValue = DAG.getNode(ISD::BIT_CONVERT, MVT::f64, WholeValue);
476 ArgValues.push_back(WholeValue);
483 // Store remaining ArgRegs to the stack if this is a varargs function.
484 if (F.getFunctionType()->isVarArg()) {
485 // Remember the vararg offset for the va_start implementation.
486 VarArgsFrameOffset = ArgOffset;
488 for (; CurArgReg != ArgRegEnd; ++CurArgReg) {
489 unsigned VReg = RegMap->createVirtualRegister(&V8::IntRegsRegClass);
490 MF.addLiveIn(*CurArgReg, VReg);
491 SDOperand Arg = DAG.getCopyFromReg(DAG.getRoot(), VReg, MVT::i32);
493 int FrameIdx = MF.getFrameInfo()->CreateFixedObject(4, ArgOffset);
494 SDOperand FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
496 OutChains.push_back(DAG.getNode(ISD::STORE, MVT::Other, DAG.getRoot(),
497 Arg, FIPtr, DAG.getSrcValue(0)));
502 if (!OutChains.empty())
503 DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, OutChains));
505 // Finally, inform the code generator which regs we return values in.
506 switch (getValueType(F.getReturnType())) {
507 default: assert(0 && "Unknown type!");
508 case MVT::isVoid: break;
513 MF.addLiveOut(V8::I0);
516 MF.addLiveOut(V8::I0);
517 MF.addLiveOut(V8::I1);
520 MF.addLiveOut(V8::F0);
523 MF.addLiveOut(V8::D0);
530 std::pair<SDOperand, SDOperand>
531 SparcV8TargetLowering::LowerCallTo(SDOperand Chain, const Type *RetTy,
532 bool isVarArg, unsigned CC,
533 bool isTailCall, SDOperand Callee,
534 ArgListTy &Args, SelectionDAG &DAG) {
535 MachineFunction &MF = DAG.getMachineFunction();
536 // Count the size of the outgoing arguments.
537 unsigned ArgsSize = 0;
538 for (unsigned i = 0, e = Args.size(); i != e; ++i) {
539 switch (getValueType(Args[i].second)) {
540 default: assert(0 && "Unknown value type!");
555 ArgsSize -= 4*6; // Space for first 6 arguments is prereserved.
559 // Keep stack frames 8-byte aligned.
560 ArgsSize = (ArgsSize+7) & ~7;
562 Chain = DAG.getNode(ISD::CALLSEQ_START, MVT::Other, Chain,
563 DAG.getConstant(ArgsSize, getPointerTy()));
565 SDOperand StackPtr, NullSV;
566 std::vector<SDOperand> Stores;
567 std::vector<SDOperand> RegValuesToPass;
568 unsigned ArgOffset = 68;
569 for (unsigned i = 0, e = Args.size(); i != e; ++i) {
570 SDOperand Val = Args[i].first;
571 MVT::ValueType ObjectVT = Val.getValueType();
572 SDOperand ValToStore(0, 0);
575 default: assert(0 && "Unhandled argument type!");
579 // Promote the integer to 32-bits. If the input type is signed, use a
580 // sign extend, otherwise use a zero extend.
581 if (Args[i].second->isSigned())
582 Val = DAG.getNode(ISD::SIGN_EXTEND, MVT::i32, Val);
584 Val = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Val);
589 if (RegValuesToPass.size() >= 6) {
592 RegValuesToPass.push_back(Val);
597 if (RegValuesToPass.size() >= 6) {
600 // Convert this to a FP value in an int reg.
601 Val = DAG.getNode(ISD::BIT_CONVERT, MVT::i32, Val);
602 RegValuesToPass.push_back(Val);
607 // If we can store this directly into the outgoing slot, do so. We can
608 // do this when all ArgRegs are used and if the outgoing slot is aligned.
609 // FIXME: McGill/misr fails with this.
610 if (0 && RegValuesToPass.size() >= 6 && ((ArgOffset-68) & 7) == 0) {
615 // Otherwise, convert this to a FP value in int regs.
616 Val = DAG.getNode(ISD::BIT_CONVERT, MVT::i64, Val);
620 if (RegValuesToPass.size() >= 6) {
621 ValToStore = Val; // Whole thing is passed in memory.
625 // Split the value into top and bottom part. Top part goes in a reg.
626 SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, Val,
627 DAG.getConstant(1, MVT::i32));
628 SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, Val,
629 DAG.getConstant(0, MVT::i32));
630 RegValuesToPass.push_back(Hi);
632 if (RegValuesToPass.size() >= 6) {
637 RegValuesToPass.push_back(Lo);
642 if (ValToStore.Val) {
644 StackPtr = DAG.getRegister(V8::O6, MVT::i32);
645 NullSV = DAG.getSrcValue(NULL);
647 SDOperand PtrOff = DAG.getConstant(ArgOffset, getPointerTy());
648 PtrOff = DAG.getNode(ISD::ADD, MVT::i32, StackPtr, PtrOff);
649 Stores.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
650 ValToStore, PtrOff, NullSV));
652 ArgOffset += ObjSize;
655 // Emit all stores, make sure the occur before any copies into physregs.
657 Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, Stores);
659 static const unsigned ArgRegs[] = {
660 V8::O0, V8::O1, V8::O2, V8::O3, V8::O4, V8::O5
663 // Build a sequence of copy-to-reg nodes chained together with token chain
664 // and flag operands which copy the outgoing args into O[0-5].
666 for (unsigned i = 0, e = RegValuesToPass.size(); i != e; ++i) {
667 Chain = DAG.getCopyToReg(Chain, ArgRegs[i], RegValuesToPass[i], InFlag);
668 InFlag = Chain.getValue(1);
671 // If the callee is a GlobalAddress node (quite common, every direct call is)
672 // turn it into a TargetGlobalAddress node so that legalize doesn't hack it.
673 if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee))
674 Callee = DAG.getTargetGlobalAddress(G->getGlobal(), MVT::i32);
676 std::vector<MVT::ValueType> NodeTys;
677 NodeTys.push_back(MVT::Other); // Returns a chain
678 NodeTys.push_back(MVT::Flag); // Returns a flag for retval copy to use.
679 std::vector<SDOperand> Ops;
680 Ops.push_back(Chain);
681 Ops.push_back(Callee);
683 Ops.push_back(InFlag);
684 Chain = DAG.getNode(V8ISD::CALL, NodeTys, Ops);
685 InFlag = Chain.getValue(1);
687 MVT::ValueType RetTyVT = getValueType(RetTy);
689 if (RetTyVT != MVT::isVoid) {
691 default: assert(0 && "Unknown value type to return!");
695 RetVal = DAG.getCopyFromReg(Chain, V8::O0, MVT::i32, InFlag);
696 Chain = RetVal.getValue(1);
698 // Add a note to keep track of whether it is sign or zero extended.
699 RetVal = DAG.getNode(RetTy->isSigned() ? ISD::AssertSext :ISD::AssertZext,
700 MVT::i32, RetVal, DAG.getValueType(RetTyVT));
701 RetVal = DAG.getNode(ISD::TRUNCATE, RetTyVT, RetVal);
704 RetVal = DAG.getCopyFromReg(Chain, V8::O0, MVT::i32, InFlag);
705 Chain = RetVal.getValue(1);
708 RetVal = DAG.getCopyFromReg(Chain, V8::F0, MVT::f32, InFlag);
709 Chain = RetVal.getValue(1);
712 RetVal = DAG.getCopyFromReg(Chain, V8::D0, MVT::f64, InFlag);
713 Chain = RetVal.getValue(1);
716 SDOperand Lo = DAG.getCopyFromReg(Chain, V8::O1, MVT::i32, InFlag);
717 SDOperand Hi = DAG.getCopyFromReg(Lo.getValue(1), V8::O0, MVT::i32,
719 RetVal = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, Lo, Hi);
720 Chain = Hi.getValue(1);
725 Chain = DAG.getNode(ISD::CALLSEQ_END, MVT::Other, Chain,
726 DAG.getConstant(ArgsSize, getPointerTy()));
728 return std::make_pair(RetVal, Chain);
731 std::pair<SDOperand, SDOperand> SparcV8TargetLowering::
732 LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, unsigned Depth,
734 assert(0 && "Unimp");
738 SDOperand SparcV8TargetLowering::
739 LowerOperation(SDOperand Op, SelectionDAG &DAG) {
740 switch (Op.getOpcode()) {
741 default: assert(0 && "Should not custom lower this!");
742 case ISD::GlobalAddress: {
743 GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
744 SDOperand GA = DAG.getTargetGlobalAddress(GV, MVT::i32);
745 SDOperand Hi = DAG.getNode(V8ISD::Hi, MVT::i32, GA);
746 SDOperand Lo = DAG.getNode(V8ISD::Lo, MVT::i32, GA);
747 return DAG.getNode(ISD::ADD, MVT::i32, Lo, Hi);
749 case ISD::ConstantPool: {
750 Constant *C = cast<ConstantPoolSDNode>(Op)->get();
751 SDOperand CP = DAG.getTargetConstantPool(C, MVT::i32);
752 SDOperand Hi = DAG.getNode(V8ISD::Hi, MVT::i32, CP);
753 SDOperand Lo = DAG.getNode(V8ISD::Lo, MVT::i32, CP);
754 return DAG.getNode(ISD::ADD, MVT::i32, Lo, Hi);
756 case ISD::FP_TO_SINT:
757 // Convert the fp value to integer in an FP register.
758 assert(Op.getValueType() == MVT::i32);
759 Op = DAG.getNode(V8ISD::FTOI, MVT::f32, Op.getOperand(0));
760 return DAG.getNode(ISD::BIT_CONVERT, MVT::i32, Op);
761 case ISD::SINT_TO_FP: {
762 assert(Op.getOperand(0).getValueType() == MVT::i32);
763 SDOperand Tmp = DAG.getNode(ISD::BIT_CONVERT, MVT::f32, Op.getOperand(0));
764 // Convert the int value to FP in an FP register.
765 return DAG.getNode(V8ISD::ITOF, Op.getValueType(), Tmp);
768 SDOperand Chain = Op.getOperand(0);
769 ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(1))->get();
770 SDOperand LHS = Op.getOperand(2);
771 SDOperand RHS = Op.getOperand(3);
772 SDOperand Dest = Op.getOperand(4);
774 // Get the condition flag.
775 if (LHS.getValueType() == MVT::i32) {
776 std::vector<MVT::ValueType> VTs;
777 VTs.push_back(MVT::i32);
778 VTs.push_back(MVT::Flag);
779 std::vector<SDOperand> Ops;
782 SDOperand Cond = DAG.getNode(V8ISD::CMPICC, VTs, Ops).getValue(1);
783 SDOperand CCN = DAG.getConstant(IntCondCCodeToICC(CC), MVT::i32);
784 return DAG.getNode(V8ISD::BRICC, MVT::Other, Chain, Dest, CCN, Cond);
786 SDOperand Cond = DAG.getNode(V8ISD::CMPFCC, MVT::Flag, LHS, RHS);
787 SDOperand CCN = DAG.getConstant(FPCondCCodeToFCC(CC), MVT::i32);
788 return DAG.getNode(V8ISD::BRFCC, MVT::Other, Chain, Dest, CCN, Cond);
791 case ISD::SELECT_CC: {
792 SDOperand LHS = Op.getOperand(0);
793 SDOperand RHS = Op.getOperand(1);
794 ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get();
795 SDOperand TrueVal = Op.getOperand(2);
796 SDOperand FalseVal = Op.getOperand(3);
797 unsigned Opc, V8CC = ~0U;
799 // If this is a select_cc of a "setcc", and if the setcc got lowered into
800 // an CMP[IF]CC/SELECT_[IF]CC pair, find the original compared values.
801 if (isa<ConstantSDNode>(RHS) && cast<ConstantSDNode>(RHS)->getValue() == 0&&
803 ((LHS.getOpcode() == V8ISD::SELECT_ICC &&
804 LHS.getOperand(3).getOpcode() == V8ISD::CMPICC) ||
805 (LHS.getOpcode() == V8ISD::SELECT_FCC &&
806 LHS.getOperand(3).getOpcode() == V8ISD::CMPFCC)) &&
807 isa<ConstantSDNode>(LHS.getOperand(0)) &&
808 isa<ConstantSDNode>(LHS.getOperand(1)) &&
809 cast<ConstantSDNode>(LHS.getOperand(0))->getValue() == 1 &&
810 cast<ConstantSDNode>(LHS.getOperand(1))->getValue() == 0) {
811 SDOperand CMPCC = LHS.getOperand(3);
812 V8CC = cast<ConstantSDNode>(LHS.getOperand(2))->getValue();
813 LHS = CMPCC.getOperand(0);
814 RHS = CMPCC.getOperand(1);
817 SDOperand CompareFlag;
818 if (LHS.getValueType() == MVT::i32) {
819 std::vector<MVT::ValueType> VTs;
820 VTs.push_back(LHS.getValueType()); // subcc returns a value
821 VTs.push_back(MVT::Flag);
822 std::vector<SDOperand> Ops;
825 CompareFlag = DAG.getNode(V8ISD::CMPICC, VTs, Ops).getValue(1);
826 Opc = V8ISD::SELECT_ICC;
827 if (V8CC == ~0U) V8CC = IntCondCCodeToICC(CC);
829 CompareFlag = DAG.getNode(V8ISD::CMPFCC, MVT::Flag, LHS, RHS);
830 Opc = V8ISD::SELECT_FCC;
831 if (V8CC == ~0U) V8CC = FPCondCCodeToFCC(CC);
833 return DAG.getNode(Opc, TrueVal.getValueType(), TrueVal, FalseVal,
834 DAG.getConstant(V8CC, MVT::i32), CompareFlag);
837 // vastart just stores the address of the VarArgsFrameIndex slot into the
838 // memory location argument.
839 SDOperand Offset = DAG.getNode(ISD::ADD, MVT::i32,
840 DAG.getRegister(V8::I6, MVT::i32),
841 DAG.getConstant(VarArgsFrameOffset, MVT::i32));
842 return DAG.getNode(ISD::STORE, MVT::Other, Op.getOperand(0), Offset,
843 Op.getOperand(1), Op.getOperand(2));
848 switch(Op.getNumOperands()) {
850 assert(0 && "Do not know how to return this many arguments!");
853 return SDOperand(); // ret void is legal
856 switch(Op.getOperand(1).getValueType()) {
857 default: assert(0 && "Unknown type to return!");
858 case MVT::i32: ArgReg = V8::I0; break;
859 case MVT::f32: ArgReg = V8::F0; break;
860 case MVT::f64: ArgReg = V8::D0; break;
862 Copy = DAG.getCopyToReg(Op.getOperand(0), ArgReg, Op.getOperand(1),
867 Copy = DAG.getCopyToReg(Op.getOperand(0), V8::I0, Op.getOperand(2),
869 Copy = DAG.getCopyToReg(Copy, V8::I1, Op.getOperand(1), Copy.getValue(1));
872 return DAG.getNode(V8ISD::RET_FLAG, MVT::Other, Copy, Copy.getValue(1));
878 SparcV8TargetLowering::InsertAtEndOfBasicBlock(MachineInstr *MI,
879 MachineBasicBlock *BB) {
881 // Figure out the conditional branch opcode to use for this select_cc.
882 switch (MI->getOpcode()) {
883 default: assert(0 && "Unknown SELECT_CC!");
884 case V8::SELECT_CC_Int_ICC:
885 case V8::SELECT_CC_FP_ICC:
886 case V8::SELECT_CC_DFP_ICC:
887 case V8::SELECT_CC_Int_FCC:
888 case V8::SELECT_CC_FP_FCC:
889 case V8::SELECT_CC_DFP_FCC:
890 V8CC::CondCodes CC = (V8CC::CondCodes)MI->getOperand(3).getImmedValue();
891 BROpcode = SPARCCondCodeToBranchInstr(CC);
895 // To "insert" a SELECT_CC instruction, we actually have to insert the diamond
896 // control-flow pattern. The incoming instruction knows the destination vreg
897 // to set, the condition code register to branch on, the true/false values to
898 // select between, and a branch opcode to use.
899 const BasicBlock *LLVM_BB = BB->getBasicBlock();
900 ilist<MachineBasicBlock>::iterator It = BB;
907 // fallthrough --> copy0MBB
908 MachineBasicBlock *thisMBB = BB;
909 MachineBasicBlock *copy0MBB = new MachineBasicBlock(LLVM_BB);
910 MachineBasicBlock *sinkMBB = new MachineBasicBlock(LLVM_BB);
911 BuildMI(BB, BROpcode, 1).addMBB(sinkMBB);
912 MachineFunction *F = BB->getParent();
913 F->getBasicBlockList().insert(It, copy0MBB);
914 F->getBasicBlockList().insert(It, sinkMBB);
915 // Update machine-CFG edges
916 BB->addSuccessor(copy0MBB);
917 BB->addSuccessor(sinkMBB);
921 // # fallthrough to sinkMBB
924 // Update machine-CFG edges
925 BB->addSuccessor(sinkMBB);
928 // %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
931 BuildMI(BB, V8::PHI, 4, MI->getOperand(0).getReg())
932 .addReg(MI->getOperand(2).getReg()).addMBB(copy0MBB)
933 .addReg(MI->getOperand(1).getReg()).addMBB(thisMBB);
935 delete MI; // The pseudo instruction is gone now.
939 //===----------------------------------------------------------------------===//
940 // Instruction Selector Implementation
941 //===----------------------------------------------------------------------===//
943 //===--------------------------------------------------------------------===//
944 /// SparcV8DAGToDAGISel - SPARC specific code to select Sparc V8 machine
945 /// instructions for SelectionDAG operations.
948 class SparcV8DAGToDAGISel : public SelectionDAGISel {
949 SparcV8TargetLowering V8Lowering;
951 /// Subtarget - Keep a pointer to the Sparc Subtarget around so that we can
952 /// make the right decision when generating code for different targets.
953 const SparcV8Subtarget &Subtarget;
955 SparcV8DAGToDAGISel(TargetMachine &TM)
956 : SelectionDAGISel(V8Lowering), V8Lowering(TM),
957 Subtarget(TM.getSubtarget<SparcV8Subtarget>()) {
960 SDOperand Select(SDOperand Op);
962 // Complex Pattern Selectors.
963 bool SelectADDRrr(SDOperand N, SDOperand &R1, SDOperand &R2);
964 bool SelectADDRri(SDOperand N, SDOperand &Base, SDOperand &Offset);
966 /// InstructionSelectBasicBlock - This callback is invoked by
967 /// SelectionDAGISel when it has created a SelectionDAG for us to codegen.
968 virtual void InstructionSelectBasicBlock(SelectionDAG &DAG);
970 virtual const char *getPassName() const {
971 return "SparcV8 DAG->DAG Pattern Instruction Selection";
974 // Include the pieces autogenerated from the target description.
975 #include "SparcV8GenDAGISel.inc"
977 } // end anonymous namespace
979 /// InstructionSelectBasicBlock - This callback is invoked by
980 /// SelectionDAGISel when it has created a SelectionDAG for us to codegen.
981 void SparcV8DAGToDAGISel::InstructionSelectBasicBlock(SelectionDAG &DAG) {
984 // Select target instructions for the DAG.
985 DAG.setRoot(Select(DAG.getRoot()));
987 DAG.RemoveDeadNodes();
989 // Emit machine code to BB.
990 ScheduleAndEmitDAG(DAG);
993 bool SparcV8DAGToDAGISel::SelectADDRri(SDOperand Addr, SDOperand &Base,
995 if (FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(Addr)) {
996 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i32);
997 Offset = CurDAG->getTargetConstant(0, MVT::i32);
1001 if (Addr.getOpcode() == ISD::ADD) {
1002 if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Addr.getOperand(1))) {
1003 if (Predicate_simm13(CN)) {
1004 if (FrameIndexSDNode *FIN =
1005 dyn_cast<FrameIndexSDNode>(Addr.getOperand(0))) {
1006 // Constant offset from frame ref.
1007 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i32);
1009 Base = Select(Addr.getOperand(0));
1011 Offset = CurDAG->getTargetConstant(CN->getValue(), MVT::i32);
1015 if (Addr.getOperand(0).getOpcode() == V8ISD::Lo) {
1016 Base = Select(Addr.getOperand(1));
1017 Offset = Addr.getOperand(0).getOperand(0);
1020 if (Addr.getOperand(1).getOpcode() == V8ISD::Lo) {
1021 Base = Select(Addr.getOperand(0));
1022 Offset = Addr.getOperand(1).getOperand(0);
1026 Base = Select(Addr);
1027 Offset = CurDAG->getTargetConstant(0, MVT::i32);
1031 bool SparcV8DAGToDAGISel::SelectADDRrr(SDOperand Addr, SDOperand &R1,
1033 if (Addr.getOpcode() == ISD::FrameIndex) return false;
1034 if (Addr.getOpcode() == ISD::ADD) {
1035 if (isa<ConstantSDNode>(Addr.getOperand(1)) &&
1036 Predicate_simm13(Addr.getOperand(1).Val))
1037 return false; // Let the reg+imm pattern catch this!
1038 if (Addr.getOperand(0).getOpcode() == V8ISD::Lo ||
1039 Addr.getOperand(1).getOpcode() == V8ISD::Lo)
1040 return false; // Let the reg+imm pattern catch this!
1041 R1 = Select(Addr.getOperand(0));
1042 R2 = Select(Addr.getOperand(1));
1047 R2 = CurDAG->getRegister(V8::G0, MVT::i32);
1051 SDOperand SparcV8DAGToDAGISel::Select(SDOperand Op) {
1053 if (N->getOpcode() >= ISD::BUILTIN_OP_END &&
1054 N->getOpcode() < V8ISD::FIRST_NUMBER)
1055 return Op; // Already selected.
1056 // If this has already been converted, use it.
1057 std::map<SDOperand, SDOperand>::iterator CGMI = CodeGenMap.find(Op);
1058 if (CGMI != CodeGenMap.end()) return CGMI->second;
1060 switch (N->getOpcode()) {
1062 case ISD::FrameIndex: {
1063 int FI = cast<FrameIndexSDNode>(N)->getIndex();
1065 return CurDAG->SelectNodeTo(N, V8::ADDri, MVT::i32,
1066 CurDAG->getTargetFrameIndex(FI, MVT::i32),
1067 CurDAG->getTargetConstant(0, MVT::i32));
1068 return CodeGenMap[Op] =
1069 CurDAG->getTargetNode(V8::ADDri, MVT::i32,
1070 CurDAG->getTargetFrameIndex(FI, MVT::i32),
1071 CurDAG->getTargetConstant(0, MVT::i32));
1073 case ISD::ADD_PARTS: {
1074 SDOperand LHSL = Select(N->getOperand(0));
1075 SDOperand LHSH = Select(N->getOperand(1));
1076 SDOperand RHSL = Select(N->getOperand(2));
1077 SDOperand RHSH = Select(N->getOperand(3));
1078 // FIXME, handle immediate RHS.
1079 SDOperand Low = CurDAG->getTargetNode(V8::ADDCCrr, MVT::i32, MVT::Flag,
1081 SDOperand Hi = CurDAG->getTargetNode(V8::ADDXrr, MVT::i32, LHSH, RHSH,
1083 CodeGenMap[SDOperand(N, 0)] = Low;
1084 CodeGenMap[SDOperand(N, 1)] = Hi;
1085 return Op.ResNo ? Hi : Low;
1087 case ISD::SUB_PARTS: {
1088 SDOperand LHSL = Select(N->getOperand(0));
1089 SDOperand LHSH = Select(N->getOperand(1));
1090 SDOperand RHSL = Select(N->getOperand(2));
1091 SDOperand RHSH = Select(N->getOperand(3));
1092 // FIXME, handle immediate RHS.
1093 SDOperand Low = CurDAG->getTargetNode(V8::SUBCCrr, MVT::i32, MVT::Flag,
1095 SDOperand Hi = CurDAG->getTargetNode(V8::SUBXrr, MVT::i32, LHSH, RHSH,
1097 CodeGenMap[SDOperand(N, 0)] = Low;
1098 CodeGenMap[SDOperand(N, 1)] = Hi;
1099 return Op.ResNo ? Hi : Low;
1103 // FIXME: should use a custom expander to expose the SRA to the dag.
1104 SDOperand DivLHS = Select(N->getOperand(0));
1105 SDOperand DivRHS = Select(N->getOperand(1));
1107 // Set the Y register to the high-part.
1109 if (N->getOpcode() == ISD::SDIV) {
1110 TopPart = CurDAG->getTargetNode(V8::SRAri, MVT::i32, DivLHS,
1111 CurDAG->getTargetConstant(31, MVT::i32));
1113 TopPart = CurDAG->getRegister(V8::G0, MVT::i32);
1115 TopPart = CurDAG->getTargetNode(V8::WRYrr, MVT::Flag, TopPart,
1116 CurDAG->getRegister(V8::G0, MVT::i32));
1118 // FIXME: Handle div by immediate.
1119 unsigned Opcode = N->getOpcode() == ISD::SDIV ? V8::SDIVrr : V8::UDIVrr;
1120 return CurDAG->SelectNodeTo(N, Opcode, MVT::i32, DivLHS, DivRHS, TopPart);
1124 // FIXME: Handle mul by immediate.
1125 SDOperand MulLHS = Select(N->getOperand(0));
1126 SDOperand MulRHS = Select(N->getOperand(1));
1127 unsigned Opcode = N->getOpcode() == ISD::MULHU ? V8::UMULrr : V8::SMULrr;
1128 SDOperand Mul = CurDAG->getTargetNode(Opcode, MVT::i32, MVT::Flag,
1130 // The high part is in the Y register.
1131 return CurDAG->SelectNodeTo(N, V8::RDY, MVT::i32, Mul.getValue(1));
1134 // FIXME: This is a workaround for a bug in tblgen.
1135 { // Pattern #47: (call:Flag (tglobaladdr:i32):$dst, ICC:Flag)
1136 // Emits: (CALL:void (tglobaladdr:i32):$dst)
1137 // Pattern complexity = 2 cost = 1
1138 SDOperand N1 = N->getOperand(1);
1139 if (N1.getOpcode() != ISD::TargetGlobalAddress &&
1140 N1.getOpcode() != ISD::ExternalSymbol) goto P47Fail;
1141 SDOperand InFlag = SDOperand(0, 0);
1142 SDOperand Chain = N->getOperand(0);
1143 SDOperand Tmp0 = N1;
1144 Chain = Select(Chain);
1146 if (N->getNumOperands() == 3) {
1147 InFlag = Select(N->getOperand(2));
1148 Result = CurDAG->getTargetNode(V8::CALL, MVT::Other, MVT::Flag, Tmp0,
1151 Result = CurDAG->getTargetNode(V8::CALL, MVT::Other, MVT::Flag, Tmp0,
1154 Chain = CodeGenMap[SDOperand(N, 0)] = Result.getValue(0);
1155 CodeGenMap[SDOperand(N, 1)] = Result.getValue(1);
1156 return Result.getValue(Op.ResNo);
1162 return SelectCode(Op);
1166 /// createSparcV8ISelDag - This pass converts a legalized DAG into a
1167 /// SPARC-specific DAG, ready for instruction scheduling.
1169 FunctionPass *llvm::createSparcV8ISelDag(TargetMachine &TM) {
1170 return new SparcV8DAGToDAGISel(TM);