1 //===-- TargetInstrInfo.cpp - Target Instruction Information --------------===//
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 implements the TargetInstrInfo class.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/Target/TargetInstrInfo.h"
15 #include "llvm/CodeGen/MachineFrameInfo.h"
16 #include "llvm/CodeGen/MachineInstrBuilder.h"
17 #include "llvm/CodeGen/MachineMemOperand.h"
18 #include "llvm/CodeGen/MachineRegisterInfo.h"
19 #include "llvm/CodeGen/PseudoSourceValue.h"
20 #include "llvm/CodeGen/ScoreboardHazardRecognizer.h"
21 #include "llvm/CodeGen/StackMaps.h"
22 #include "llvm/IR/DataLayout.h"
23 #include "llvm/MC/MCAsmInfo.h"
24 #include "llvm/MC/MCInstrItineraries.h"
25 #include "llvm/Support/CommandLine.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include "llvm/Target/TargetFrameLowering.h"
29 #include "llvm/Target/TargetLowering.h"
30 #include "llvm/Target/TargetMachine.h"
31 #include "llvm/Target/TargetRegisterInfo.h"
35 static cl::opt
<bool> DisableHazardRecognizer(
36 "disable-sched-hazard", cl::Hidden
, cl::init(false),
37 cl::desc("Disable hazard detection during preRA scheduling"));
39 TargetInstrInfo::~TargetInstrInfo() {
42 const TargetRegisterClass
*
43 TargetInstrInfo::getRegClass(const MCInstrDesc
&MCID
, unsigned OpNum
,
44 const TargetRegisterInfo
*TRI
,
45 const MachineFunction
&MF
) const {
46 if (OpNum
>= MCID
.getNumOperands())
49 short RegClass
= MCID
.OpInfo
[OpNum
].RegClass
;
50 if (MCID
.OpInfo
[OpNum
].isLookupPtrRegClass())
51 return TRI
->getPointerRegClass(MF
, RegClass
);
53 // Instructions like INSERT_SUBREG do not have fixed register classes.
57 // Otherwise just look it up normally.
58 return TRI
->getRegClass(RegClass
);
61 /// insertNoop - Insert a noop into the instruction stream at the specified
63 void TargetInstrInfo::insertNoop(MachineBasicBlock
&MBB
,
64 MachineBasicBlock::iterator MI
) const {
65 llvm_unreachable("Target didn't implement insertNoop!");
68 /// Measure the specified inline asm to determine an approximation of its
70 /// Comments (which run till the next SeparatorString or newline) do not
71 /// count as an instruction.
72 /// Any other non-whitespace text is considered an instruction, with
73 /// multiple instructions separated by SeparatorString or newlines.
74 /// Variable-length instructions are not handled here; this function
75 /// may be overloaded in the target code to do that.
76 unsigned TargetInstrInfo::getInlineAsmLength(const char *Str
,
77 const MCAsmInfo
&MAI
) const {
80 // Count the number of instructions in the asm.
81 bool atInsnStart
= true;
84 if (*Str
== '\n' || strncmp(Str
, MAI
.getSeparatorString(),
85 strlen(MAI
.getSeparatorString())) == 0)
87 if (atInsnStart
&& !std::isspace(static_cast<unsigned char>(*Str
))) {
88 Length
+= MAI
.getMaxInstLength();
91 if (atInsnStart
&& strncmp(Str
, MAI
.getCommentString(),
92 strlen(MAI
.getCommentString())) == 0)
99 /// ReplaceTailWithBranchTo - Delete the instruction OldInst and everything
100 /// after it, replacing it with an unconditional branch to NewDest.
102 TargetInstrInfo::ReplaceTailWithBranchTo(MachineBasicBlock::iterator Tail
,
103 MachineBasicBlock
*NewDest
) const {
104 MachineBasicBlock
*MBB
= Tail
->getParent();
106 // Remove all the old successors of MBB from the CFG.
107 while (!MBB
->succ_empty())
108 MBB
->removeSuccessor(MBB
->succ_begin());
110 // Remove all the dead instructions from the end of MBB.
111 MBB
->erase(Tail
, MBB
->end());
113 // If MBB isn't immediately before MBB, insert a branch to it.
114 if (++MachineFunction::iterator(MBB
) != MachineFunction::iterator(NewDest
))
115 InsertBranch(*MBB
, NewDest
, nullptr, SmallVector
<MachineOperand
, 0>(),
116 Tail
->getDebugLoc());
117 MBB
->addSuccessor(NewDest
);
120 // commuteInstruction - The default implementation of this method just exchanges
121 // the two operands returned by findCommutedOpIndices.
122 MachineInstr
*TargetInstrInfo::commuteInstruction(MachineInstr
*MI
,
124 const MCInstrDesc
&MCID
= MI
->getDesc();
125 bool HasDef
= MCID
.getNumDefs();
126 if (HasDef
&& !MI
->getOperand(0).isReg())
127 // No idea how to commute this instruction. Target should implement its own.
130 if (!findCommutedOpIndices(MI
, Idx1
, Idx2
)) {
131 assert(MI
->isCommutable() && "Precondition violation: MI must be commutable.");
135 assert(MI
->getOperand(Idx1
).isReg() && MI
->getOperand(Idx2
).isReg() &&
136 "This only knows how to commute register operands so far");
137 unsigned Reg0
= HasDef
? MI
->getOperand(0).getReg() : 0;
138 unsigned Reg1
= MI
->getOperand(Idx1
).getReg();
139 unsigned Reg2
= MI
->getOperand(Idx2
).getReg();
140 unsigned SubReg0
= HasDef
? MI
->getOperand(0).getSubReg() : 0;
141 unsigned SubReg1
= MI
->getOperand(Idx1
).getSubReg();
142 unsigned SubReg2
= MI
->getOperand(Idx2
).getSubReg();
143 bool Reg1IsKill
= MI
->getOperand(Idx1
).isKill();
144 bool Reg2IsKill
= MI
->getOperand(Idx2
).isKill();
145 // If destination is tied to either of the commuted source register, then
146 // it must be updated.
147 if (HasDef
&& Reg0
== Reg1
&&
148 MI
->getDesc().getOperandConstraint(Idx1
, MCOI::TIED_TO
) == 0) {
152 } else if (HasDef
&& Reg0
== Reg2
&&
153 MI
->getDesc().getOperandConstraint(Idx2
, MCOI::TIED_TO
) == 0) {
160 // Create a new instruction.
161 MachineFunction
&MF
= *MI
->getParent()->getParent();
162 MI
= MF
.CloneMachineInstr(MI
);
166 MI
->getOperand(0).setReg(Reg0
);
167 MI
->getOperand(0).setSubReg(SubReg0
);
169 MI
->getOperand(Idx2
).setReg(Reg1
);
170 MI
->getOperand(Idx1
).setReg(Reg2
);
171 MI
->getOperand(Idx2
).setSubReg(SubReg1
);
172 MI
->getOperand(Idx1
).setSubReg(SubReg2
);
173 MI
->getOperand(Idx2
).setIsKill(Reg1IsKill
);
174 MI
->getOperand(Idx1
).setIsKill(Reg2IsKill
);
178 /// findCommutedOpIndices - If specified MI is commutable, return the two
179 /// operand indices that would swap value. Return true if the instruction
180 /// is not in a form which this routine understands.
181 bool TargetInstrInfo::findCommutedOpIndices(MachineInstr
*MI
,
183 unsigned &SrcOpIdx2
) const {
184 assert(!MI
->isBundle() &&
185 "TargetInstrInfo::findCommutedOpIndices() can't handle bundles");
187 const MCInstrDesc
&MCID
= MI
->getDesc();
188 if (!MCID
.isCommutable())
190 // This assumes v0 = op v1, v2 and commuting would swap v1 and v2. If this
191 // is not true, then the target must implement this.
192 SrcOpIdx1
= MCID
.getNumDefs();
193 SrcOpIdx2
= SrcOpIdx1
+ 1;
194 if (!MI
->getOperand(SrcOpIdx1
).isReg() ||
195 !MI
->getOperand(SrcOpIdx2
).isReg())
203 TargetInstrInfo::isUnpredicatedTerminator(const MachineInstr
*MI
) const {
204 if (!MI
->isTerminator()) return false;
206 // Conditional branch is a special case.
207 if (MI
->isBranch() && !MI
->isBarrier())
209 if (!MI
->isPredicable())
211 return !isPredicated(MI
);
215 bool TargetInstrInfo::PredicateInstruction(MachineInstr
*MI
,
216 const SmallVectorImpl
<MachineOperand
> &Pred
) const {
217 bool MadeChange
= false;
219 assert(!MI
->isBundle() &&
220 "TargetInstrInfo::PredicateInstruction() can't handle bundles");
222 const MCInstrDesc
&MCID
= MI
->getDesc();
223 if (!MI
->isPredicable())
226 for (unsigned j
= 0, i
= 0, e
= MI
->getNumOperands(); i
!= e
; ++i
) {
227 if (MCID
.OpInfo
[i
].isPredicate()) {
228 MachineOperand
&MO
= MI
->getOperand(i
);
230 MO
.setReg(Pred
[j
].getReg());
232 } else if (MO
.isImm()) {
233 MO
.setImm(Pred
[j
].getImm());
235 } else if (MO
.isMBB()) {
236 MO
.setMBB(Pred
[j
].getMBB());
245 bool TargetInstrInfo::hasLoadFromStackSlot(const MachineInstr
*MI
,
246 const MachineMemOperand
*&MMO
,
247 int &FrameIndex
) const {
248 for (MachineInstr::mmo_iterator o
= MI
->memoperands_begin(),
249 oe
= MI
->memoperands_end();
252 if ((*o
)->isLoad()) {
253 if (const FixedStackPseudoSourceValue
*Value
=
254 dyn_cast_or_null
<FixedStackPseudoSourceValue
>(
255 (*o
)->getPseudoValue())) {
256 FrameIndex
= Value
->getFrameIndex();
265 bool TargetInstrInfo::hasStoreToStackSlot(const MachineInstr
*MI
,
266 const MachineMemOperand
*&MMO
,
267 int &FrameIndex
) const {
268 for (MachineInstr::mmo_iterator o
= MI
->memoperands_begin(),
269 oe
= MI
->memoperands_end();
272 if ((*o
)->isStore()) {
273 if (const FixedStackPseudoSourceValue
*Value
=
274 dyn_cast_or_null
<FixedStackPseudoSourceValue
>(
275 (*o
)->getPseudoValue())) {
276 FrameIndex
= Value
->getFrameIndex();
285 bool TargetInstrInfo::getStackSlotRange(const TargetRegisterClass
*RC
,
286 unsigned SubIdx
, unsigned &Size
,
288 const TargetMachine
*TM
) const {
290 Size
= RC
->getSize();
295 TM
->getSubtargetImpl()->getRegisterInfo()->getSubRegIdxSize(SubIdx
);
296 // Convert bit size to byte size to be consistent with
297 // MCRegisterClass::getSize().
302 TM
->getSubtargetImpl()->getRegisterInfo()->getSubRegIdxOffset(SubIdx
);
303 if (BitOffset
< 0 || BitOffset
% 8)
307 Offset
= (unsigned)BitOffset
/ 8;
309 assert(RC
->getSize() >= (Offset
+ Size
) && "bad subregister range");
311 if (!TM
->getSubtargetImpl()->getDataLayout()->isLittleEndian()) {
312 Offset
= RC
->getSize() - (Offset
+ Size
);
317 void TargetInstrInfo::reMaterialize(MachineBasicBlock
&MBB
,
318 MachineBasicBlock::iterator I
,
321 const MachineInstr
*Orig
,
322 const TargetRegisterInfo
&TRI
) const {
323 MachineInstr
*MI
= MBB
.getParent()->CloneMachineInstr(Orig
);
324 MI
->substituteRegister(MI
->getOperand(0).getReg(), DestReg
, SubIdx
, TRI
);
329 TargetInstrInfo::produceSameValue(const MachineInstr
*MI0
,
330 const MachineInstr
*MI1
,
331 const MachineRegisterInfo
*MRI
) const {
332 return MI0
->isIdenticalTo(MI1
, MachineInstr::IgnoreVRegDefs
);
335 MachineInstr
*TargetInstrInfo::duplicate(MachineInstr
*Orig
,
336 MachineFunction
&MF
) const {
337 assert(!Orig
->isNotDuplicable() &&
338 "Instruction cannot be duplicated");
339 return MF
.CloneMachineInstr(Orig
);
342 // If the COPY instruction in MI can be folded to a stack operation, return
343 // the register class to use.
344 static const TargetRegisterClass
*canFoldCopy(const MachineInstr
*MI
,
346 assert(MI
->isCopy() && "MI must be a COPY instruction");
347 if (MI
->getNumOperands() != 2)
349 assert(FoldIdx
<2 && "FoldIdx refers no nonexistent operand");
351 const MachineOperand
&FoldOp
= MI
->getOperand(FoldIdx
);
352 const MachineOperand
&LiveOp
= MI
->getOperand(1-FoldIdx
);
354 if (FoldOp
.getSubReg() || LiveOp
.getSubReg())
357 unsigned FoldReg
= FoldOp
.getReg();
358 unsigned LiveReg
= LiveOp
.getReg();
360 assert(TargetRegisterInfo::isVirtualRegister(FoldReg
) &&
361 "Cannot fold physregs");
363 const MachineRegisterInfo
&MRI
= MI
->getParent()->getParent()->getRegInfo();
364 const TargetRegisterClass
*RC
= MRI
.getRegClass(FoldReg
);
366 if (TargetRegisterInfo::isPhysicalRegister(LiveOp
.getReg()))
367 return RC
->contains(LiveOp
.getReg()) ? RC
: nullptr;
369 if (RC
->hasSubClassEq(MRI
.getRegClass(LiveReg
)))
372 // FIXME: Allow folding when register classes are memory compatible.
376 void TargetInstrInfo::getNoopForMachoTarget(MCInst
&NopInst
) const {
377 llvm_unreachable("Not a MachO target");
380 bool TargetInstrInfo::
381 canFoldMemoryOperand(const MachineInstr
*MI
,
382 const SmallVectorImpl
<unsigned> &Ops
) const {
383 return MI
->isCopy() && Ops
.size() == 1 && canFoldCopy(MI
, Ops
[0]);
386 static MachineInstr
* foldPatchpoint(MachineFunction
&MF
,
388 const SmallVectorImpl
<unsigned> &Ops
,
390 const TargetInstrInfo
&TII
) {
391 unsigned StartIdx
= 0;
392 switch (MI
->getOpcode()) {
393 case TargetOpcode::STACKMAP
:
394 StartIdx
= 2; // Skip ID, nShadowBytes.
396 case TargetOpcode::PATCHPOINT
: {
397 // For PatchPoint, the call args are not foldable.
398 PatchPointOpers
opers(MI
);
399 StartIdx
= opers
.getVarIdx();
403 llvm_unreachable("unexpected stackmap opcode");
406 // Return false if any operands requested for folding are not foldable (not
407 // part of the stackmap's live values).
408 for (SmallVectorImpl
<unsigned>::const_iterator I
= Ops
.begin(), E
= Ops
.end();
414 MachineInstr
*NewMI
=
415 MF
.CreateMachineInstr(TII
.get(MI
->getOpcode()), MI
->getDebugLoc(), true);
416 MachineInstrBuilder
MIB(MF
, NewMI
);
418 // No need to fold return, the meta data, and function arguments
419 for (unsigned i
= 0; i
< StartIdx
; ++i
)
420 MIB
.addOperand(MI
->getOperand(i
));
422 for (unsigned i
= StartIdx
; i
< MI
->getNumOperands(); ++i
) {
423 MachineOperand
&MO
= MI
->getOperand(i
);
424 if (std::find(Ops
.begin(), Ops
.end(), i
) != Ops
.end()) {
426 unsigned SpillOffset
;
427 // Compute the spill slot size and offset.
428 const TargetRegisterClass
*RC
=
429 MF
.getRegInfo().getRegClass(MO
.getReg());
430 bool Valid
= TII
.getStackSlotRange(RC
, MO
.getSubReg(), SpillSize
,
431 SpillOffset
, &MF
.getTarget());
433 report_fatal_error("cannot spill patchpoint subregister operand");
434 MIB
.addImm(StackMaps::IndirectMemRefOp
);
435 MIB
.addImm(SpillSize
);
436 MIB
.addFrameIndex(FrameIndex
);
437 MIB
.addImm(SpillOffset
);
445 /// foldMemoryOperand - Attempt to fold a load or store of the specified stack
446 /// slot into the specified machine instruction for the specified operand(s).
447 /// If this is possible, a new instruction is returned with the specified
448 /// operand folded, otherwise NULL is returned. The client is responsible for
449 /// removing the old instruction and adding the new one in the instruction
452 TargetInstrInfo::foldMemoryOperand(MachineBasicBlock::iterator MI
,
453 const SmallVectorImpl
<unsigned> &Ops
,
456 for (unsigned i
= 0, e
= Ops
.size(); i
!= e
; ++i
)
457 if (MI
->getOperand(Ops
[i
]).isDef())
458 Flags
|= MachineMemOperand::MOStore
;
460 Flags
|= MachineMemOperand::MOLoad
;
462 MachineBasicBlock
*MBB
= MI
->getParent();
463 assert(MBB
&& "foldMemoryOperand needs an inserted instruction");
464 MachineFunction
&MF
= *MBB
->getParent();
466 MachineInstr
*NewMI
= nullptr;
468 if (MI
->getOpcode() == TargetOpcode::STACKMAP
||
469 MI
->getOpcode() == TargetOpcode::PATCHPOINT
) {
470 // Fold stackmap/patchpoint.
471 NewMI
= foldPatchpoint(MF
, MI
, Ops
, FI
, *this);
473 // Ask the target to do the actual folding.
474 NewMI
=foldMemoryOperandImpl(MF
, MI
, Ops
, FI
);
478 NewMI
->setMemRefs(MI
->memoperands_begin(), MI
->memoperands_end());
479 // Add a memory operand, foldMemoryOperandImpl doesn't do that.
480 assert((!(Flags
& MachineMemOperand::MOStore
) ||
481 NewMI
->mayStore()) &&
482 "Folded a def to a non-store!");
483 assert((!(Flags
& MachineMemOperand::MOLoad
) ||
485 "Folded a use to a non-load!");
486 const MachineFrameInfo
&MFI
= *MF
.getFrameInfo();
487 assert(MFI
.getObjectOffset(FI
) != -1);
488 MachineMemOperand
*MMO
=
489 MF
.getMachineMemOperand(MachinePointerInfo::getFixedStack(FI
),
490 Flags
, MFI
.getObjectSize(FI
),
491 MFI
.getObjectAlignment(FI
));
492 NewMI
->addMemOperand(MF
, MMO
);
494 // FIXME: change foldMemoryOperandImpl semantics to also insert NewMI.
495 return MBB
->insert(MI
, NewMI
);
498 // Straight COPY may fold as load/store.
499 if (!MI
->isCopy() || Ops
.size() != 1)
502 const TargetRegisterClass
*RC
= canFoldCopy(MI
, Ops
[0]);
506 const MachineOperand
&MO
= MI
->getOperand(1-Ops
[0]);
507 MachineBasicBlock::iterator Pos
= MI
;
508 const TargetRegisterInfo
*TRI
= MF
.getSubtarget().getRegisterInfo();
510 if (Flags
== MachineMemOperand::MOStore
)
511 storeRegToStackSlot(*MBB
, Pos
, MO
.getReg(), MO
.isKill(), FI
, RC
, TRI
);
513 loadRegFromStackSlot(*MBB
, Pos
, MO
.getReg(), FI
, RC
, TRI
);
517 /// foldMemoryOperand - Same as the previous version except it allows folding
518 /// of any load and store from / to any address, not just from a specific
521 TargetInstrInfo::foldMemoryOperand(MachineBasicBlock::iterator MI
,
522 const SmallVectorImpl
<unsigned> &Ops
,
523 MachineInstr
* LoadMI
) const {
524 assert(LoadMI
->canFoldAsLoad() && "LoadMI isn't foldable!");
526 for (unsigned i
= 0, e
= Ops
.size(); i
!= e
; ++i
)
527 assert(MI
->getOperand(Ops
[i
]).isUse() && "Folding load into def!");
529 MachineBasicBlock
&MBB
= *MI
->getParent();
530 MachineFunction
&MF
= *MBB
.getParent();
532 // Ask the target to do the actual folding.
533 MachineInstr
*NewMI
= nullptr;
536 if ((MI
->getOpcode() == TargetOpcode::STACKMAP
||
537 MI
->getOpcode() == TargetOpcode::PATCHPOINT
) &&
538 isLoadFromStackSlot(LoadMI
, FrameIndex
)) {
539 // Fold stackmap/patchpoint.
540 NewMI
= foldPatchpoint(MF
, MI
, Ops
, FrameIndex
, *this);
542 // Ask the target to do the actual folding.
543 NewMI
= foldMemoryOperandImpl(MF
, MI
, Ops
, LoadMI
);
546 if (!NewMI
) return nullptr;
548 NewMI
= MBB
.insert(MI
, NewMI
);
550 // Copy the memoperands from the load to the folded instruction.
551 if (MI
->memoperands_empty()) {
552 NewMI
->setMemRefs(LoadMI
->memoperands_begin(),
553 LoadMI
->memoperands_end());
556 // Handle the rare case of folding multiple loads.
557 NewMI
->setMemRefs(MI
->memoperands_begin(),
558 MI
->memoperands_end());
559 for (MachineInstr::mmo_iterator I
= LoadMI
->memoperands_begin(),
560 E
= LoadMI
->memoperands_end(); I
!= E
; ++I
) {
561 NewMI
->addMemOperand(MF
, *I
);
567 bool TargetInstrInfo::
568 isReallyTriviallyReMaterializableGeneric(const MachineInstr
*MI
,
569 AliasAnalysis
*AA
) const {
570 const MachineFunction
&MF
= *MI
->getParent()->getParent();
571 const MachineRegisterInfo
&MRI
= MF
.getRegInfo();
573 // Remat clients assume operand 0 is the defined register.
574 if (!MI
->getNumOperands() || !MI
->getOperand(0).isReg())
576 unsigned DefReg
= MI
->getOperand(0).getReg();
578 // A sub-register definition can only be rematerialized if the instruction
579 // doesn't read the other parts of the register. Otherwise it is really a
580 // read-modify-write operation on the full virtual register which cannot be
582 if (TargetRegisterInfo::isVirtualRegister(DefReg
) &&
583 MI
->getOperand(0).getSubReg() && MI
->readsVirtualRegister(DefReg
))
586 // A load from a fixed stack slot can be rematerialized. This may be
587 // redundant with subsequent checks, but it's target-independent,
588 // simple, and a common case.
590 if (isLoadFromStackSlot(MI
, FrameIdx
) &&
591 MF
.getFrameInfo()->isImmutableObjectIndex(FrameIdx
))
594 // Avoid instructions obviously unsafe for remat.
595 if (MI
->isNotDuplicable() || MI
->mayStore() ||
596 MI
->hasUnmodeledSideEffects())
599 // Don't remat inline asm. We have no idea how expensive it is
600 // even if it's side effect free.
601 if (MI
->isInlineAsm())
604 // Avoid instructions which load from potentially varying memory.
605 if (MI
->mayLoad() && !MI
->isInvariantLoad(AA
))
608 // If any of the registers accessed are non-constant, conservatively assume
609 // the instruction is not rematerializable.
610 for (unsigned i
= 0, e
= MI
->getNumOperands(); i
!= e
; ++i
) {
611 const MachineOperand
&MO
= MI
->getOperand(i
);
612 if (!MO
.isReg()) continue;
613 unsigned Reg
= MO
.getReg();
617 // Check for a well-behaved physical register.
618 if (TargetRegisterInfo::isPhysicalRegister(Reg
)) {
620 // If the physreg has no defs anywhere, it's just an ambient register
621 // and we can freely move its uses. Alternatively, if it's allocatable,
622 // it could get allocated to something with a def during allocation.
623 if (!MRI
.isConstantPhysReg(Reg
, MF
))
626 // A physreg def. We can't remat it.
632 // Only allow one virtual-register def. There may be multiple defs of the
633 // same virtual register, though.
634 if (MO
.isDef() && Reg
!= DefReg
)
637 // Don't allow any virtual-register uses. Rematting an instruction with
638 // virtual register uses would length the live ranges of the uses, which
639 // is not necessarily a good idea, certainly not "trivial".
644 // Everything checked out.
648 int TargetInstrInfo::getSPAdjust(const MachineInstr
*MI
) const {
649 const MachineFunction
*MF
= MI
->getParent()->getParent();
650 const TargetFrameLowering
*TFI
= MF
->getSubtarget().getFrameLowering();
651 bool StackGrowsDown
=
652 TFI
->getStackGrowthDirection() == TargetFrameLowering::StackGrowsDown
;
654 int FrameSetupOpcode
= getCallFrameSetupOpcode();
655 int FrameDestroyOpcode
= getCallFrameDestroyOpcode();
657 if (MI
->getOpcode() != FrameSetupOpcode
&&
658 MI
->getOpcode() != FrameDestroyOpcode
)
661 int SPAdj
= MI
->getOperand(0).getImm();
663 if ((!StackGrowsDown
&& MI
->getOpcode() == FrameSetupOpcode
) ||
664 (StackGrowsDown
&& MI
->getOpcode() == FrameDestroyOpcode
))
670 /// isSchedulingBoundary - Test if the given instruction should be
671 /// considered a scheduling boundary. This primarily includes labels
673 bool TargetInstrInfo::isSchedulingBoundary(const MachineInstr
*MI
,
674 const MachineBasicBlock
*MBB
,
675 const MachineFunction
&MF
) const {
676 // Terminators and labels can't be scheduled around.
677 if (MI
->isTerminator() || MI
->isPosition())
680 // Don't attempt to schedule around any instruction that defines
681 // a stack-oriented pointer, as it's unlikely to be profitable. This
682 // saves compile time, because it doesn't require every single
683 // stack slot reference to depend on the instruction that does the
685 const TargetLowering
&TLI
= *MF
.getSubtarget().getTargetLowering();
686 const TargetRegisterInfo
*TRI
= MF
.getSubtarget().getRegisterInfo();
687 if (MI
->modifiesRegister(TLI
.getStackPointerRegisterToSaveRestore(), TRI
))
693 // Provide a global flag for disabling the PreRA hazard recognizer that targets
694 // may choose to honor.
695 bool TargetInstrInfo::usePreRAHazardRecognizer() const {
696 return !DisableHazardRecognizer
;
699 // Default implementation of CreateTargetRAHazardRecognizer.
700 ScheduleHazardRecognizer
*TargetInstrInfo::
701 CreateTargetHazardRecognizer(const TargetSubtargetInfo
*STI
,
702 const ScheduleDAG
*DAG
) const {
703 // Dummy hazard recognizer allows all instructions to issue.
704 return new ScheduleHazardRecognizer();
707 // Default implementation of CreateTargetMIHazardRecognizer.
708 ScheduleHazardRecognizer
*TargetInstrInfo::
709 CreateTargetMIHazardRecognizer(const InstrItineraryData
*II
,
710 const ScheduleDAG
*DAG
) const {
711 return (ScheduleHazardRecognizer
*)
712 new ScoreboardHazardRecognizer(II
, DAG
, "misched");
715 // Default implementation of CreateTargetPostRAHazardRecognizer.
716 ScheduleHazardRecognizer
*TargetInstrInfo::
717 CreateTargetPostRAHazardRecognizer(const InstrItineraryData
*II
,
718 const ScheduleDAG
*DAG
) const {
719 return (ScheduleHazardRecognizer
*)
720 new ScoreboardHazardRecognizer(II
, DAG
, "post-RA-sched");
723 //===----------------------------------------------------------------------===//
724 // SelectionDAG latency interface.
725 //===----------------------------------------------------------------------===//
728 TargetInstrInfo::getOperandLatency(const InstrItineraryData
*ItinData
,
729 SDNode
*DefNode
, unsigned DefIdx
,
730 SDNode
*UseNode
, unsigned UseIdx
) const {
731 if (!ItinData
|| ItinData
->isEmpty())
734 if (!DefNode
->isMachineOpcode())
737 unsigned DefClass
= get(DefNode
->getMachineOpcode()).getSchedClass();
738 if (!UseNode
->isMachineOpcode())
739 return ItinData
->getOperandCycle(DefClass
, DefIdx
);
740 unsigned UseClass
= get(UseNode
->getMachineOpcode()).getSchedClass();
741 return ItinData
->getOperandLatency(DefClass
, DefIdx
, UseClass
, UseIdx
);
744 int TargetInstrInfo::getInstrLatency(const InstrItineraryData
*ItinData
,
746 if (!ItinData
|| ItinData
->isEmpty())
749 if (!N
->isMachineOpcode())
752 return ItinData
->getStageLatency(get(N
->getMachineOpcode()).getSchedClass());
755 //===----------------------------------------------------------------------===//
756 // MachineInstr latency interface.
757 //===----------------------------------------------------------------------===//
760 TargetInstrInfo::getNumMicroOps(const InstrItineraryData
*ItinData
,
761 const MachineInstr
*MI
) const {
762 if (!ItinData
|| ItinData
->isEmpty())
765 unsigned Class
= MI
->getDesc().getSchedClass();
766 int UOps
= ItinData
->Itineraries
[Class
].NumMicroOps
;
770 // The # of u-ops is dynamically determined. The specific target should
771 // override this function to return the right number.
775 /// Return the default expected latency for a def based on it's opcode.
776 unsigned TargetInstrInfo::defaultDefLatency(const MCSchedModel
&SchedModel
,
777 const MachineInstr
*DefMI
) const {
778 if (DefMI
->isTransient())
780 if (DefMI
->mayLoad())
781 return SchedModel
.LoadLatency
;
782 if (isHighLatencyDef(DefMI
->getOpcode()))
783 return SchedModel
.HighLatency
;
787 unsigned TargetInstrInfo::getPredicationCost(const MachineInstr
*) const {
791 unsigned TargetInstrInfo::
792 getInstrLatency(const InstrItineraryData
*ItinData
,
793 const MachineInstr
*MI
,
794 unsigned *PredCost
) const {
795 // Default to one cycle for no itinerary. However, an "empty" itinerary may
796 // still have a MinLatency property, which getStageLatency checks.
798 return MI
->mayLoad() ? 2 : 1;
800 return ItinData
->getStageLatency(MI
->getDesc().getSchedClass());
803 bool TargetInstrInfo::hasLowDefLatency(const InstrItineraryData
*ItinData
,
804 const MachineInstr
*DefMI
,
805 unsigned DefIdx
) const {
806 if (!ItinData
|| ItinData
->isEmpty())
809 unsigned DefClass
= DefMI
->getDesc().getSchedClass();
810 int DefCycle
= ItinData
->getOperandCycle(DefClass
, DefIdx
);
811 return (DefCycle
!= -1 && DefCycle
<= 1);
814 /// Both DefMI and UseMI must be valid. By default, call directly to the
815 /// itinerary. This may be overriden by the target.
816 int TargetInstrInfo::
817 getOperandLatency(const InstrItineraryData
*ItinData
,
818 const MachineInstr
*DefMI
, unsigned DefIdx
,
819 const MachineInstr
*UseMI
, unsigned UseIdx
) const {
820 unsigned DefClass
= DefMI
->getDesc().getSchedClass();
821 unsigned UseClass
= UseMI
->getDesc().getSchedClass();
822 return ItinData
->getOperandLatency(DefClass
, DefIdx
, UseClass
, UseIdx
);
825 /// If we can determine the operand latency from the def only, without itinerary
826 /// lookup, do so. Otherwise return -1.
827 int TargetInstrInfo::computeDefOperandLatency(
828 const InstrItineraryData
*ItinData
,
829 const MachineInstr
*DefMI
) const {
831 // Let the target hook getInstrLatency handle missing itineraries.
833 return getInstrLatency(ItinData
, DefMI
);
835 if(ItinData
->isEmpty())
836 return defaultDefLatency(ItinData
->SchedModel
, DefMI
);
838 // ...operand lookup required
842 /// computeOperandLatency - Compute and return the latency of the given data
843 /// dependent def and use when the operand indices are already known. UseMI may
844 /// be NULL for an unknown use.
846 /// FindMin may be set to get the minimum vs. expected latency. Minimum
847 /// latency is used for scheduling groups, while expected latency is for
848 /// instruction cost and critical path.
850 /// Depending on the subtarget's itinerary properties, this may or may not need
851 /// to call getOperandLatency(). For most subtargets, we don't need DefIdx or
852 /// UseIdx to compute min latency.
853 unsigned TargetInstrInfo::
854 computeOperandLatency(const InstrItineraryData
*ItinData
,
855 const MachineInstr
*DefMI
, unsigned DefIdx
,
856 const MachineInstr
*UseMI
, unsigned UseIdx
) const {
858 int DefLatency
= computeDefOperandLatency(ItinData
, DefMI
);
862 assert(ItinData
&& !ItinData
->isEmpty() && "computeDefOperandLatency fail");
866 OperLatency
= getOperandLatency(ItinData
, DefMI
, DefIdx
, UseMI
, UseIdx
);
868 unsigned DefClass
= DefMI
->getDesc().getSchedClass();
869 OperLatency
= ItinData
->getOperandCycle(DefClass
, DefIdx
);
871 if (OperLatency
>= 0)
874 // No operand latency was found.
875 unsigned InstrLatency
= getInstrLatency(ItinData
, DefMI
);
877 // Expected latency is the max of the stage latency and itinerary props.
878 InstrLatency
= std::max(InstrLatency
,
879 defaultDefLatency(ItinData
->SchedModel
, DefMI
));
883 bool TargetInstrInfo::getRegSequenceInputs(
884 const MachineInstr
&MI
, unsigned DefIdx
,
885 SmallVectorImpl
<RegSubRegPairAndIdx
> &InputRegs
) const {
886 assert((MI
.isRegSequence() ||
887 MI
.isRegSequenceLike()) && "Instruction do not have the proper type");
889 if (!MI
.isRegSequence())
890 return getRegSequenceLikeInputs(MI
, DefIdx
, InputRegs
);
892 // We are looking at:
893 // Def = REG_SEQUENCE v0, sub0, v1, sub1, ...
894 assert(DefIdx
== 0 && "REG_SEQUENCE only has one def");
895 for (unsigned OpIdx
= 1, EndOpIdx
= MI
.getNumOperands(); OpIdx
!= EndOpIdx
;
897 const MachineOperand
&MOReg
= MI
.getOperand(OpIdx
);
898 const MachineOperand
&MOSubIdx
= MI
.getOperand(OpIdx
+ 1);
899 assert(MOSubIdx
.isImm() &&
900 "One of the subindex of the reg_sequence is not an immediate");
901 // Record Reg:SubReg, SubIdx.
902 InputRegs
.push_back(RegSubRegPairAndIdx(MOReg
.getReg(), MOReg
.getSubReg(),
903 (unsigned)MOSubIdx
.getImm()));
908 bool TargetInstrInfo::getExtractSubregInputs(
909 const MachineInstr
&MI
, unsigned DefIdx
,
910 RegSubRegPairAndIdx
&InputReg
) const {
911 assert((MI
.isExtractSubreg() ||
912 MI
.isExtractSubregLike()) && "Instruction do not have the proper type");
914 if (!MI
.isExtractSubreg())
915 return getExtractSubregLikeInputs(MI
, DefIdx
, InputReg
);
917 // We are looking at:
918 // Def = EXTRACT_SUBREG v0.sub1, sub0.
919 assert(DefIdx
== 0 && "EXTRACT_SUBREG only has one def");
920 const MachineOperand
&MOReg
= MI
.getOperand(1);
921 const MachineOperand
&MOSubIdx
= MI
.getOperand(2);
922 assert(MOSubIdx
.isImm() &&
923 "The subindex of the extract_subreg is not an immediate");
925 InputReg
.Reg
= MOReg
.getReg();
926 InputReg
.SubReg
= MOReg
.getSubReg();
927 InputReg
.SubIdx
= (unsigned)MOSubIdx
.getImm();
931 bool TargetInstrInfo::getInsertSubregInputs(
932 const MachineInstr
&MI
, unsigned DefIdx
,
933 RegSubRegPair
&BaseReg
, RegSubRegPairAndIdx
&InsertedReg
) const {
934 assert((MI
.isInsertSubreg() ||
935 MI
.isInsertSubregLike()) && "Instruction do not have the proper type");
937 if (!MI
.isInsertSubreg())
938 return getInsertSubregLikeInputs(MI
, DefIdx
, BaseReg
, InsertedReg
);
940 // We are looking at:
941 // Def = INSERT_SEQUENCE v0, v1, sub0.
942 assert(DefIdx
== 0 && "INSERT_SUBREG only has one def");
943 const MachineOperand
&MOBaseReg
= MI
.getOperand(1);
944 const MachineOperand
&MOInsertedReg
= MI
.getOperand(2);
945 const MachineOperand
&MOSubIdx
= MI
.getOperand(3);
946 assert(MOSubIdx
.isImm() &&
947 "One of the subindex of the reg_sequence is not an immediate");
948 BaseReg
.Reg
= MOBaseReg
.getReg();
949 BaseReg
.SubReg
= MOBaseReg
.getSubReg();
951 InsertedReg
.Reg
= MOInsertedReg
.getReg();
952 InsertedReg
.SubReg
= MOInsertedReg
.getSubReg();
953 InsertedReg
.SubIdx
= (unsigned)MOSubIdx
.getImm();