1 //===-- SPUISelDAGToDAG.cpp - CellSPU pattern matching inst selector ------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines a pattern matching instruction selector for the Cell SPU,
11 // converting from a legalized dag to a SPU-target dag.
13 //===----------------------------------------------------------------------===//
16 #include "SPUTargetMachine.h"
17 #include "SPUISelLowering.h"
18 #include "SPUHazardRecognizers.h"
19 #include "SPUFrameInfo.h"
20 #include "SPURegisterNames.h"
21 #include "llvm/CodeGen/MachineConstantPool.h"
22 #include "llvm/CodeGen/MachineInstrBuilder.h"
23 #include "llvm/CodeGen/MachineFunction.h"
24 #include "llvm/CodeGen/SelectionDAG.h"
25 #include "llvm/CodeGen/SelectionDAGISel.h"
26 #include "llvm/Target/TargetOptions.h"
27 #include "llvm/ADT/Statistic.h"
28 #include "llvm/Constants.h"
29 #include "llvm/GlobalValue.h"
30 #include "llvm/Intrinsics.h"
31 #include "llvm/Support/Debug.h"
32 #include "llvm/Support/MathExtras.h"
33 #include "llvm/Support/Compiler.h"
40 //! ConstantSDNode predicate for i32 sign-extended, 10-bit immediates
42 isI64IntS10Immediate(ConstantSDNode *CN)
44 return isS10Constant(CN->getSignExtended());
47 //! ConstantSDNode predicate for i32 sign-extended, 10-bit immediates
49 isI32IntS10Immediate(ConstantSDNode *CN)
51 return isS10Constant(CN->getSignExtended());
55 //! SDNode predicate for sign-extended, 10-bit immediate values
57 isI32IntS10Immediate(SDNode *N)
59 return (N->getOpcode() == ISD::Constant
60 && isI32IntS10Immediate(cast<ConstantSDNode>(N)));
64 //! ConstantSDNode predicate for i32 unsigned 10-bit immediate values
66 isI32IntU10Immediate(ConstantSDNode *CN)
68 return isU10Constant(CN->getSignExtended());
71 //! ConstantSDNode predicate for i16 sign-extended, 10-bit immediate values
73 isI16IntS10Immediate(ConstantSDNode *CN)
75 return isS10Constant(CN->getSignExtended());
78 //! SDNode predicate for i16 sign-extended, 10-bit immediate values
80 isI16IntS10Immediate(SDNode *N)
82 return (N->getOpcode() == ISD::Constant
83 && isI16IntS10Immediate(cast<ConstantSDNode>(N)));
86 //! ConstantSDNode predicate for i16 unsigned 10-bit immediate values
88 isI16IntU10Immediate(ConstantSDNode *CN)
90 return isU10Constant((short) CN->getValue());
93 //! SDNode predicate for i16 sign-extended, 10-bit immediate values
95 isI16IntU10Immediate(SDNode *N)
97 return (N->getOpcode() == ISD::Constant
98 && isI16IntU10Immediate(cast<ConstantSDNode>(N)));
101 //! ConstantSDNode predicate for signed 16-bit values
103 \arg CN The constant SelectionDAG node holding the value
104 \arg Imm The returned 16-bit value, if returning true
106 This predicate tests the value in \a CN to see whether it can be
107 represented as a 16-bit, sign-extended quantity. Returns true if
111 isIntS16Immediate(ConstantSDNode *CN, short &Imm)
113 MVT vt = CN->getValueType(0);
114 Imm = (short) CN->getValue();
115 if (vt.getSimpleVT() >= MVT::i1 && vt.getSimpleVT() <= MVT::i16) {
117 } else if (vt == MVT::i32) {
118 int32_t i_val = (int32_t) CN->getValue();
119 short s_val = (short) i_val;
120 return i_val == s_val;
122 int64_t i_val = (int64_t) CN->getValue();
123 short s_val = (short) i_val;
124 return i_val == s_val;
130 //! SDNode predicate for signed 16-bit values.
132 isIntS16Immediate(SDNode *N, short &Imm)
134 return (N->getOpcode() == ISD::Constant
135 && isIntS16Immediate(cast<ConstantSDNode>(N), Imm));
138 //! ConstantFPSDNode predicate for representing floats as 16-bit sign ext.
140 isFPS16Immediate(ConstantFPSDNode *FPN, short &Imm)
142 MVT vt = FPN->getValueType(0);
143 if (vt == MVT::f32) {
144 int val = FloatToBits(FPN->getValueAPF().convertToFloat());
145 int sval = (int) ((val << 16) >> 16);
154 isHighLow(const SDValue &Op)
156 return (Op.getOpcode() == SPUISD::IndirectAddr
157 && ((Op.getOperand(0).getOpcode() == SPUISD::Hi
158 && Op.getOperand(1).getOpcode() == SPUISD::Lo)
159 || (Op.getOperand(0).getOpcode() == SPUISD::Lo
160 && Op.getOperand(1).getOpcode() == SPUISD::Hi)));
163 //===------------------------------------------------------------------===//
164 //! MVT to "useful stuff" mapping structure:
166 struct valtype_map_s {
168 unsigned ldresult_ins; /// LDRESULT instruction (0 = undefined)
169 bool ldresult_imm; /// LDRESULT instruction requires immediate?
170 int prefslot_byte; /// Byte offset of the "preferred" slot
173 const valtype_map_s valtype_map[] = {
174 { MVT::i1, 0, false, 3 },
175 { MVT::i8, SPU::ORBIr8, true, 3 },
176 { MVT::i16, SPU::ORHIr16, true, 2 },
177 { MVT::i32, SPU::ORIr32, true, 0 },
178 { MVT::i64, SPU::ORr64, false, 0 },
179 { MVT::f32, SPU::ORf32, false, 0 },
180 { MVT::f64, SPU::ORf64, false, 0 },
181 // vector types... (sigh!)
182 { MVT::v16i8, 0, false, 0 },
183 { MVT::v8i16, 0, false, 0 },
184 { MVT::v4i32, 0, false, 0 },
185 { MVT::v2i64, 0, false, 0 },
186 { MVT::v4f32, 0, false, 0 },
187 { MVT::v2f64, 0, false, 0 }
190 const size_t n_valtype_map = sizeof(valtype_map) / sizeof(valtype_map[0]);
192 const valtype_map_s *getValueTypeMapEntry(MVT VT)
194 const valtype_map_s *retval = 0;
195 for (size_t i = 0; i < n_valtype_map; ++i) {
196 if (valtype_map[i].VT == VT) {
197 retval = valtype_map + i;
205 cerr << "SPUISelDAGToDAG.cpp: getValueTypeMapEntry returns NULL for "
218 //===--------------------------------------------------------------------===//
219 /// SPUDAGToDAGISel - Cell SPU-specific code to select SPU machine
220 /// instructions for SelectionDAG operations.
222 class SPUDAGToDAGISel :
223 public SelectionDAGISel
225 SPUTargetMachine &TM;
226 SPUTargetLowering &SPUtli;
227 unsigned GlobalBaseReg;
230 explicit SPUDAGToDAGISel(SPUTargetMachine &tm) :
231 SelectionDAGISel(*tm.getTargetLowering()),
233 SPUtli(*tm.getTargetLowering())
236 virtual bool runOnFunction(Function &Fn) {
237 // Make sure we re-emit a set of the global base reg if necessary
239 SelectionDAGISel::runOnFunction(Fn);
243 /// getI32Imm - Return a target constant with the specified value, of type
245 inline SDValue getI32Imm(uint32_t Imm) {
246 return CurDAG->getTargetConstant(Imm, MVT::i32);
249 /// getI64Imm - Return a target constant with the specified value, of type
251 inline SDValue getI64Imm(uint64_t Imm) {
252 return CurDAG->getTargetConstant(Imm, MVT::i64);
255 /// getSmallIPtrImm - Return a target constant of pointer type.
256 inline SDValue getSmallIPtrImm(unsigned Imm) {
257 return CurDAG->getTargetConstant(Imm, SPUtli.getPointerTy());
260 /// Select - Convert the specified operand from a target-independent to a
261 /// target-specific node if it hasn't already been changed.
262 SDNode *Select(SDValue Op);
264 //! Returns true if the address N is an A-form (local store) address
265 bool SelectAFormAddr(SDValue Op, SDValue N, SDValue &Base,
268 //! D-form address predicate
269 bool SelectDFormAddr(SDValue Op, SDValue N, SDValue &Base,
272 /// Alternate D-form address using i7 offset predicate
273 bool SelectDForm2Addr(SDValue Op, SDValue N, SDValue &Disp,
276 /// D-form address selection workhorse
277 bool DFormAddressPredicate(SDValue Op, SDValue N, SDValue &Disp,
278 SDValue &Base, int minOffset, int maxOffset);
280 //! Address predicate if N can be expressed as an indexed [r+r] operation.
281 bool SelectXFormAddr(SDValue Op, SDValue N, SDValue &Base,
284 /// SelectInlineAsmMemoryOperand - Implement addressing mode selection for
285 /// inline asm expressions.
286 virtual bool SelectInlineAsmMemoryOperand(const SDValue &Op,
288 std::vector<SDValue> &OutOps,
291 switch (ConstraintCode) {
292 default: return true;
294 if (!SelectDFormAddr(Op, Op, Op0, Op1)
295 && !SelectAFormAddr(Op, Op, Op0, Op1))
296 SelectXFormAddr(Op, Op, Op0, Op1);
298 case 'o': // offsetable
299 if (!SelectDFormAddr(Op, Op, Op0, Op1)
300 && !SelectAFormAddr(Op, Op, Op0, Op1)) {
302 AddToISelQueue(Op0); // r+0.
303 Op1 = getSmallIPtrImm(0);
306 case 'v': // not offsetable
308 assert(0 && "InlineAsmMemoryOperand 'v' constraint not handled.");
310 SelectAddrIdxOnly(Op, Op, Op0, Op1);
315 OutOps.push_back(Op0);
316 OutOps.push_back(Op1);
320 /// InstructionSelect - This callback is invoked by
321 /// SelectionDAGISel when it has created a SelectionDAG for us to codegen.
322 virtual void InstructionSelect(SelectionDAG &DAG);
324 virtual const char *getPassName() const {
325 return "Cell SPU DAG->DAG Pattern Instruction Selection";
328 /// CreateTargetHazardRecognizer - Return the hazard recognizer to use for
329 /// this target when scheduling the DAG.
330 virtual HazardRecognizer *CreateTargetHazardRecognizer() {
331 const TargetInstrInfo *II = SPUtli.getTargetMachine().getInstrInfo();
332 assert(II && "No InstrInfo?");
333 return new SPUHazardRecognizer(*II);
336 // Include the pieces autogenerated from the target description.
337 #include "SPUGenDAGISel.inc"
342 /// InstructionSelect - This callback is invoked by
343 /// SelectionDAGISel when it has created a SelectionDAG for us to codegen.
345 SPUDAGToDAGISel::InstructionSelect(SelectionDAG &DAG)
349 // Select target instructions for the DAG.
350 DAG.setRoot(SelectRoot(DAG.getRoot()));
351 DAG.RemoveDeadNodes();
355 \arg Op The ISD instructio operand
356 \arg N The address to be tested
357 \arg Base The base address
358 \arg Index The base address index
361 SPUDAGToDAGISel::SelectAFormAddr(SDValue Op, SDValue N, SDValue &Base,
363 // These match the addr256k operand type:
364 MVT OffsVT = MVT::i16;
365 SDValue Zero = CurDAG->getTargetConstant(0, OffsVT);
367 switch (N.getOpcode()) {
369 case ISD::ConstantPool:
370 case ISD::GlobalAddress:
371 cerr << "SPU SelectAFormAddr: Constant/Pool/Global not lowered.\n";
375 case ISD::TargetConstant:
376 case ISD::TargetGlobalAddress:
377 case ISD::TargetJumpTable:
378 cerr << "SPUSelectAFormAddr: Target Constant/Pool/Global not wrapped as "
379 << "A-form address.\n";
383 case SPUISD::AFormAddr:
384 // Just load from memory if there's only a single use of the location,
385 // otherwise, this will get handled below with D-form offset addresses
387 SDValue Op0 = N.getOperand(0);
388 switch (Op0.getOpcode()) {
389 case ISD::TargetConstantPool:
390 case ISD::TargetJumpTable:
395 case ISD::TargetGlobalAddress: {
396 GlobalAddressSDNode *GSDN = cast<GlobalAddressSDNode>(Op0);
397 GlobalValue *GV = GSDN->getGlobal();
398 if (GV->getAlignment() == 16) {
413 SPUDAGToDAGISel::SelectDForm2Addr(SDValue Op, SDValue N, SDValue &Disp,
415 const int minDForm2Offset = -(1 << 7);
416 const int maxDForm2Offset = (1 << 7) - 1;
417 return DFormAddressPredicate(Op, N, Disp, Base, minDForm2Offset,
422 \arg Op The ISD instruction (ignored)
423 \arg N The address to be tested
424 \arg Base Base address register/pointer
425 \arg Index Base address index
427 Examine the input address by a base register plus a signed 10-bit
428 displacement, [r+I10] (D-form address).
430 \return true if \a N is a D-form address with \a Base and \a Index set
431 to non-empty SDValue instances.
434 SPUDAGToDAGISel::SelectDFormAddr(SDValue Op, SDValue N, SDValue &Base,
436 return DFormAddressPredicate(Op, N, Base, Index,
437 SPUFrameInfo::minFrameOffset(),
438 SPUFrameInfo::maxFrameOffset());
442 SPUDAGToDAGISel::DFormAddressPredicate(SDValue Op, SDValue N, SDValue &Base,
443 SDValue &Index, int minOffset,
445 unsigned Opc = N.getOpcode();
446 MVT PtrTy = SPUtli.getPointerTy();
448 if (Opc == ISD::FrameIndex) {
449 // Stack frame index must be less than 512 (divided by 16):
450 FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(N);
451 int FI = int(FIN->getIndex());
452 DEBUG(cerr << "SelectDFormAddr: ISD::FrameIndex = "
454 if (SPUFrameInfo::FItoStackOffset(FI) < maxOffset) {
455 Base = CurDAG->getTargetConstant(0, PtrTy);
456 Index = CurDAG->getTargetFrameIndex(FI, PtrTy);
459 } else if (Opc == ISD::ADD) {
460 // Generated by getelementptr
461 const SDValue Op0 = N.getOperand(0);
462 const SDValue Op1 = N.getOperand(1);
464 if ((Op0.getOpcode() == SPUISD::Hi && Op1.getOpcode() == SPUISD::Lo)
465 || (Op1.getOpcode() == SPUISD::Hi && Op0.getOpcode() == SPUISD::Lo)) {
466 Base = CurDAG->getTargetConstant(0, PtrTy);
469 } else if (Op1.getOpcode() == ISD::Constant
470 || Op1.getOpcode() == ISD::TargetConstant) {
471 ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Op1);
472 int32_t offset = int32_t(CN->getSignExtended());
474 if (Op0.getOpcode() == ISD::FrameIndex) {
475 FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(Op0);
476 int FI = int(FIN->getIndex());
477 DEBUG(cerr << "SelectDFormAddr: ISD::ADD offset = " << offset
478 << " frame index = " << FI << "\n");
480 if (SPUFrameInfo::FItoStackOffset(FI) < maxOffset) {
481 Base = CurDAG->getTargetConstant(offset, PtrTy);
482 Index = CurDAG->getTargetFrameIndex(FI, PtrTy);
485 } else if (offset > minOffset && offset < maxOffset) {
486 Base = CurDAG->getTargetConstant(offset, PtrTy);
490 } else if (Op0.getOpcode() == ISD::Constant
491 || Op0.getOpcode() == ISD::TargetConstant) {
492 ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Op0);
493 int32_t offset = int32_t(CN->getSignExtended());
495 if (Op1.getOpcode() == ISD::FrameIndex) {
496 FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(Op1);
497 int FI = int(FIN->getIndex());
498 DEBUG(cerr << "SelectDFormAddr: ISD::ADD offset = " << offset
499 << " frame index = " << FI << "\n");
501 if (SPUFrameInfo::FItoStackOffset(FI) < maxOffset) {
502 Base = CurDAG->getTargetConstant(offset, PtrTy);
503 Index = CurDAG->getTargetFrameIndex(FI, PtrTy);
506 } else if (offset > minOffset && offset < maxOffset) {
507 Base = CurDAG->getTargetConstant(offset, PtrTy);
512 } else if (Opc == SPUISD::IndirectAddr) {
513 // Indirect with constant offset -> D-Form address
514 const SDValue Op0 = N.getOperand(0);
515 const SDValue Op1 = N.getOperand(1);
517 if (Op0.getOpcode() == SPUISD::Hi
518 && Op1.getOpcode() == SPUISD::Lo) {
519 // (SPUindirect (SPUhi <arg>, 0), (SPUlo <arg>, 0))
520 Base = CurDAG->getTargetConstant(0, PtrTy);
523 } else if (isa<ConstantSDNode>(Op0) || isa<ConstantSDNode>(Op1)) {
527 if (isa<ConstantSDNode>(Op1)) {
528 ConstantSDNode *CN = cast<ConstantSDNode>(Op1);
529 offset = int32_t(CN->getSignExtended());
531 } else if (isa<ConstantSDNode>(Op0)) {
532 ConstantSDNode *CN = cast<ConstantSDNode>(Op0);
533 offset = int32_t(CN->getSignExtended());
537 if (offset >= minOffset && offset <= maxOffset) {
538 Base = CurDAG->getTargetConstant(offset, PtrTy);
543 } else if (Opc == SPUISD::AFormAddr) {
544 Base = CurDAG->getTargetConstant(0, N.getValueType());
547 } else if (Opc == SPUISD::LDRESULT) {
548 Base = CurDAG->getTargetConstant(0, N.getValueType());
556 \arg Op The ISD instruction operand
557 \arg N The address operand
558 \arg Base The base pointer operand
559 \arg Index The offset/index operand
561 If the address \a N can be expressed as a [r + s10imm] address, returns false.
562 Otherwise, creates two operands, Base and Index that will become the [r+r]
566 SPUDAGToDAGISel::SelectXFormAddr(SDValue Op, SDValue N, SDValue &Base,
568 if (SelectAFormAddr(Op, N, Base, Index)
569 || SelectDFormAddr(Op, N, Base, Index))
572 // All else fails, punt and use an X-form address:
573 Base = N.getOperand(0);
574 Index = N.getOperand(1);
578 //! Convert the operand from a target-independent to a target-specific node
582 SPUDAGToDAGISel::Select(SDValue Op) {
584 unsigned Opc = N->getOpcode();
587 MVT OpVT = Op.getValueType();
590 if (N->isMachineOpcode()) {
591 return NULL; // Already selected.
592 } else if (Opc == ISD::FrameIndex) {
593 // Selects to (add $sp, FI * stackSlotSize)
595 SPUFrameInfo::FItoStackOffset(cast<FrameIndexSDNode>(N)->getIndex());
596 MVT PtrVT = SPUtli.getPointerTy();
598 // Adjust stack slot to actual offset in frame:
599 if (isS10Constant(FI)) {
600 DEBUG(cerr << "SPUDAGToDAGISel: Replacing FrameIndex with AIr32 $sp, "
604 Ops[0] = CurDAG->getRegister(SPU::R1, PtrVT);
605 Ops[1] = CurDAG->getTargetConstant(FI, PtrVT);
608 DEBUG(cerr << "SPUDAGToDAGISel: Replacing FrameIndex with Ar32 $sp, "
612 Ops[0] = CurDAG->getRegister(SPU::R1, PtrVT);
613 Ops[1] = CurDAG->getConstant(FI, PtrVT);
616 AddToISelQueue(Ops[1]);
618 } else if (Opc == ISD::ZERO_EXTEND) {
619 // (zero_extend:i16 (and:i8 <arg>, <const>))
620 const SDValue &Op1 = N->getOperand(0);
622 if (Op.getValueType() == MVT::i16 && Op1.getValueType() == MVT::i8) {
623 if (Op1.getOpcode() == ISD::AND) {
624 // Fold this into a single ANDHI. This is often seen in expansions of i1
625 // to i8, then i8 to i16 in logical/branching operations.
626 DEBUG(cerr << "CellSPU: Coalescing (zero_extend:i16 (and:i8 "
627 "<arg>, <const>))\n");
628 NewOpc = SPU::ANDHIi8i16;
629 Ops[0] = Op1.getOperand(0);
630 Ops[1] = Op1.getOperand(1);
634 } else if (Opc == SPUISD::LDRESULT) {
635 // Custom select instructions for LDRESULT
636 MVT VT = N->getValueType(0);
637 SDValue Arg = N->getOperand(0);
638 SDValue Chain = N->getOperand(1);
640 const valtype_map_s *vtm = getValueTypeMapEntry(VT);
642 if (vtm->ldresult_ins == 0) {
643 cerr << "LDRESULT for unsupported type: "
650 Opc = vtm->ldresult_ins;
651 if (vtm->ldresult_imm) {
652 SDValue Zero = CurDAG->getTargetConstant(0, VT);
654 AddToISelQueue(Zero);
655 Result = CurDAG->getTargetNode(Opc, VT, MVT::Other, Arg, Zero, Chain);
657 Result = CurDAG->getTargetNode(Opc, MVT::Other, Arg, Arg, Chain);
660 Chain = SDValue(Result, 1);
661 AddToISelQueue(Chain);
664 } else if (Opc == SPUISD::IndirectAddr) {
665 SDValue Op0 = Op.getOperand(0);
666 if (Op0.getOpcode() == SPUISD::LDRESULT) {
667 /* || Op0.getOpcode() == SPUISD::AFormAddr) */
668 // (IndirectAddr (LDRESULT, imm))
669 SDValue Op1 = Op.getOperand(1);
670 MVT VT = Op.getValueType();
672 DEBUG(cerr << "CellSPU: IndirectAddr(LDRESULT, imm):\nOp0 = ");
673 DEBUG(Op.getOperand(0).Val->dump(CurDAG));
674 DEBUG(cerr << "\nOp1 = ");
675 DEBUG(Op.getOperand(1).Val->dump(CurDAG));
678 if (Op1.getOpcode() == ISD::Constant) {
679 ConstantSDNode *CN = cast<ConstantSDNode>(Op1);
680 Op1 = CurDAG->getTargetConstant(CN->getValue(), VT);
681 NewOpc = (isI32IntS10Immediate(CN) ? SPU::AIr32 : SPU::Ar32);
693 return CurDAG->SelectNodeTo(N, NewOpc, OpVT, Ops, n_ops);
695 return CurDAG->getTargetNode(NewOpc, OpVT, Ops, n_ops);
697 return SelectCode(Op);
700 /// createPPCISelDag - This pass converts a legalized DAG into a
701 /// SPU-specific DAG, ready for instruction scheduling.
703 FunctionPass *llvm::createSPUISelDag(SPUTargetMachine &TM) {
704 return new SPUDAGToDAGISel(TM);