1 //===-- RISCVInstrInfo.cpp - RISCV Instruction Information ------*- C++ -*-===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This file contains the RISCV implementation of the TargetInstrInfo class.
11 //===----------------------------------------------------------------------===//
13 #include "RISCVInstrInfo.h"
15 #include "RISCVSubtarget.h"
16 #include "RISCVTargetMachine.h"
17 #include "Utils/RISCVMatInt.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/CodeGen/MachineFunctionPass.h"
21 #include "llvm/CodeGen/MachineInstrBuilder.h"
22 #include "llvm/CodeGen/MachineRegisterInfo.h"
23 #include "llvm/CodeGen/RegisterScavenging.h"
24 #include "llvm/Support/ErrorHandling.h"
25 #include "llvm/Support/TargetRegistry.h"
29 #define GEN_CHECK_COMPRESS_INSTR
30 #include "RISCVGenCompressInstEmitter.inc"
32 #define GET_INSTRINFO_CTOR_DTOR
33 #include "RISCVGenInstrInfo.inc"
35 RISCVInstrInfo::RISCVInstrInfo(RISCVSubtarget &STI)
36 : RISCVGenInstrInfo(RISCV::ADJCALLSTACKDOWN, RISCV::ADJCALLSTACKUP),
39 unsigned RISCVInstrInfo::isLoadFromStackSlot(const MachineInstr &MI,
40 int &FrameIndex) const {
41 switch (MI.getOpcode()) {
56 if (MI.getOperand(1).isFI() && MI.getOperand(2).isImm() &&
57 MI.getOperand(2).getImm() == 0) {
58 FrameIndex = MI.getOperand(1).getIndex();
59 return MI.getOperand(0).getReg();
65 unsigned RISCVInstrInfo::isStoreToStackSlot(const MachineInstr &MI,
66 int &FrameIndex) const {
67 switch (MI.getOpcode()) {
79 if (MI.getOperand(1).isFI() && MI.getOperand(2).isImm() &&
80 MI.getOperand(2).getImm() == 0) {
81 FrameIndex = MI.getOperand(1).getIndex();
82 return MI.getOperand(0).getReg();
88 void RISCVInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
89 MachineBasicBlock::iterator MBBI,
90 const DebugLoc &DL, MCRegister DstReg,
91 MCRegister SrcReg, bool KillSrc) const {
92 if (RISCV::GPRRegClass.contains(DstReg, SrcReg)) {
93 BuildMI(MBB, MBBI, DL, get(RISCV::ADDI), DstReg)
94 .addReg(SrcReg, getKillRegState(KillSrc))
101 if (RISCV::FPR32RegClass.contains(DstReg, SrcReg))
102 Opc = RISCV::FSGNJ_S;
103 else if (RISCV::FPR64RegClass.contains(DstReg, SrcReg))
104 Opc = RISCV::FSGNJ_D;
106 llvm_unreachable("Impossible reg-to-reg copy");
108 BuildMI(MBB, MBBI, DL, get(Opc), DstReg)
109 .addReg(SrcReg, getKillRegState(KillSrc))
110 .addReg(SrcReg, getKillRegState(KillSrc));
113 void RISCVInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
114 MachineBasicBlock::iterator I,
115 Register SrcReg, bool IsKill, int FI,
116 const TargetRegisterClass *RC,
117 const TargetRegisterInfo *TRI) const {
120 DL = I->getDebugLoc();
124 if (RISCV::GPRRegClass.hasSubClassEq(RC))
125 Opcode = TRI->getRegSizeInBits(RISCV::GPRRegClass) == 32 ?
126 RISCV::SW : RISCV::SD;
127 else if (RISCV::FPR32RegClass.hasSubClassEq(RC))
129 else if (RISCV::FPR64RegClass.hasSubClassEq(RC))
132 llvm_unreachable("Can't store this register to stack slot");
134 BuildMI(MBB, I, DL, get(Opcode))
135 .addReg(SrcReg, getKillRegState(IsKill))
140 void RISCVInstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
141 MachineBasicBlock::iterator I,
142 Register DstReg, int FI,
143 const TargetRegisterClass *RC,
144 const TargetRegisterInfo *TRI) const {
147 DL = I->getDebugLoc();
151 if (RISCV::GPRRegClass.hasSubClassEq(RC))
152 Opcode = TRI->getRegSizeInBits(RISCV::GPRRegClass) == 32 ?
153 RISCV::LW : RISCV::LD;
154 else if (RISCV::FPR32RegClass.hasSubClassEq(RC))
156 else if (RISCV::FPR64RegClass.hasSubClassEq(RC))
159 llvm_unreachable("Can't load this register from stack slot");
161 BuildMI(MBB, I, DL, get(Opcode), DstReg).addFrameIndex(FI).addImm(0);
164 void RISCVInstrInfo::movImm(MachineBasicBlock &MBB,
165 MachineBasicBlock::iterator MBBI,
166 const DebugLoc &DL, Register DstReg, uint64_t Val,
167 MachineInstr::MIFlag Flag) const {
168 MachineFunction *MF = MBB.getParent();
169 MachineRegisterInfo &MRI = MF->getRegInfo();
170 bool IsRV64 = MF->getSubtarget<RISCVSubtarget>().is64Bit();
171 Register SrcReg = RISCV::X0;
172 Register Result = MRI.createVirtualRegister(&RISCV::GPRRegClass);
175 if (!IsRV64 && !isInt<32>(Val))
176 report_fatal_error("Should only materialize 32-bit constants for RV32");
178 RISCVMatInt::InstSeq Seq;
179 RISCVMatInt::generateInstSeq(Val, IsRV64, Seq);
180 assert(Seq.size() > 0);
182 for (RISCVMatInt::Inst &Inst : Seq) {
183 // Write the final result to DstReg if it's the last instruction in the Seq.
184 // Otherwise, write the result to the temp register.
185 if (++Num == Seq.size())
188 if (Inst.Opc == RISCV::LUI) {
189 BuildMI(MBB, MBBI, DL, get(RISCV::LUI), Result)
193 BuildMI(MBB, MBBI, DL, get(Inst.Opc), Result)
194 .addReg(SrcReg, RegState::Kill)
198 // Only the first instruction has X0 as its source.
203 // The contents of values added to Cond are not examined outside of
204 // RISCVInstrInfo, giving us flexibility in what to push to it. For RISCV, we
205 // push BranchOpcode, Reg1, Reg2.
206 static void parseCondBranch(MachineInstr &LastInst, MachineBasicBlock *&Target,
207 SmallVectorImpl<MachineOperand> &Cond) {
208 // Block ends with fall-through condbranch.
209 assert(LastInst.getDesc().isConditionalBranch() &&
210 "Unknown conditional branch");
211 Target = LastInst.getOperand(2).getMBB();
212 Cond.push_back(MachineOperand::CreateImm(LastInst.getOpcode()));
213 Cond.push_back(LastInst.getOperand(0));
214 Cond.push_back(LastInst.getOperand(1));
217 static unsigned getOppositeBranchOpcode(int Opc) {
220 llvm_unreachable("Unrecognized conditional branch");
236 bool RISCVInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
237 MachineBasicBlock *&TBB,
238 MachineBasicBlock *&FBB,
239 SmallVectorImpl<MachineOperand> &Cond,
240 bool AllowModify) const {
244 // If the block has no terminators, it just falls into the block after it.
245 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
246 if (I == MBB.end() || !isUnpredicatedTerminator(*I))
249 // Count the number of terminators and find the first unconditional or
251 MachineBasicBlock::iterator FirstUncondOrIndirectBr = MBB.end();
252 int NumTerminators = 0;
253 for (auto J = I.getReverse(); J != MBB.rend() && isUnpredicatedTerminator(*J);
256 if (J->getDesc().isUnconditionalBranch() ||
257 J->getDesc().isIndirectBranch()) {
258 FirstUncondOrIndirectBr = J.getReverse();
262 // If AllowModify is true, we can erase any terminators after
263 // FirstUncondOrIndirectBR.
264 if (AllowModify && FirstUncondOrIndirectBr != MBB.end()) {
265 while (std::next(FirstUncondOrIndirectBr) != MBB.end()) {
266 std::next(FirstUncondOrIndirectBr)->eraseFromParent();
269 I = FirstUncondOrIndirectBr;
272 // We can't handle blocks that end in an indirect branch.
273 if (I->getDesc().isIndirectBranch())
276 // We can't handle blocks with more than 2 terminators.
277 if (NumTerminators > 2)
280 // Handle a single unconditional branch.
281 if (NumTerminators == 1 && I->getDesc().isUnconditionalBranch()) {
282 TBB = getBranchDestBlock(*I);
286 // Handle a single conditional branch.
287 if (NumTerminators == 1 && I->getDesc().isConditionalBranch()) {
288 parseCondBranch(*I, TBB, Cond);
292 // Handle a conditional branch followed by an unconditional branch.
293 if (NumTerminators == 2 && std::prev(I)->getDesc().isConditionalBranch() &&
294 I->getDesc().isUnconditionalBranch()) {
295 parseCondBranch(*std::prev(I), TBB, Cond);
296 FBB = getBranchDestBlock(*I);
300 // Otherwise, we can't handle this.
304 unsigned RISCVInstrInfo::removeBranch(MachineBasicBlock &MBB,
305 int *BytesRemoved) const {
308 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
312 if (!I->getDesc().isUnconditionalBranch() &&
313 !I->getDesc().isConditionalBranch())
316 // Remove the branch.
318 *BytesRemoved += getInstSizeInBytes(*I);
319 I->eraseFromParent();
323 if (I == MBB.begin())
326 if (!I->getDesc().isConditionalBranch())
329 // Remove the branch.
331 *BytesRemoved += getInstSizeInBytes(*I);
332 I->eraseFromParent();
336 // Inserts a branch into the end of the specific MachineBasicBlock, returning
337 // the number of instructions inserted.
338 unsigned RISCVInstrInfo::insertBranch(
339 MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB,
340 ArrayRef<MachineOperand> Cond, const DebugLoc &DL, int *BytesAdded) const {
344 // Shouldn't be a fall through.
345 assert(TBB && "insertBranch must not be told to insert a fallthrough");
346 assert((Cond.size() == 3 || Cond.size() == 0) &&
347 "RISCV branch conditions have two components!");
349 // Unconditional branch.
351 MachineInstr &MI = *BuildMI(&MBB, DL, get(RISCV::PseudoBR)).addMBB(TBB);
353 *BytesAdded += getInstSizeInBytes(MI);
357 // Either a one or two-way conditional branch.
358 unsigned Opc = Cond[0].getImm();
359 MachineInstr &CondMI =
360 *BuildMI(&MBB, DL, get(Opc)).add(Cond[1]).add(Cond[2]).addMBB(TBB);
362 *BytesAdded += getInstSizeInBytes(CondMI);
364 // One-way conditional branch.
368 // Two-way conditional branch.
369 MachineInstr &MI = *BuildMI(&MBB, DL, get(RISCV::PseudoBR)).addMBB(FBB);
371 *BytesAdded += getInstSizeInBytes(MI);
375 unsigned RISCVInstrInfo::insertIndirectBranch(MachineBasicBlock &MBB,
376 MachineBasicBlock &DestBB,
379 RegScavenger *RS) const {
380 assert(RS && "RegScavenger required for long branching");
381 assert(MBB.empty() &&
382 "new block should be inserted for expanding unconditional branch");
383 assert(MBB.pred_size() == 1);
385 MachineFunction *MF = MBB.getParent();
386 MachineRegisterInfo &MRI = MF->getRegInfo();
388 if (!isInt<32>(BrOffset))
390 "Branch offsets outside of the signed 32-bit range not supported");
392 // FIXME: A virtual register must be used initially, as the register
393 // scavenger won't work with empty blocks (SIInstrInfo::insertIndirectBranch
394 // uses the same workaround).
395 Register ScratchReg = MRI.createVirtualRegister(&RISCV::GPRRegClass);
398 MachineInstr &MI = *BuildMI(MBB, II, DL, get(RISCV::PseudoJump))
399 .addReg(ScratchReg, RegState::Define | RegState::Dead)
400 .addMBB(&DestBB, RISCVII::MO_CALL);
402 RS->enterBasicBlockEnd(MBB);
403 unsigned Scav = RS->scavengeRegisterBackwards(RISCV::GPRRegClass,
404 MI.getIterator(), false, 0);
405 MRI.replaceRegWith(ScratchReg, Scav);
407 RS->setRegUsed(Scav);
411 bool RISCVInstrInfo::reverseBranchCondition(
412 SmallVectorImpl<MachineOperand> &Cond) const {
413 assert((Cond.size() == 3) && "Invalid branch condition!");
414 Cond[0].setImm(getOppositeBranchOpcode(Cond[0].getImm()));
419 RISCVInstrInfo::getBranchDestBlock(const MachineInstr &MI) const {
420 assert(MI.getDesc().isBranch() && "Unexpected opcode!");
421 // The branch target is always the last operand.
422 int NumOp = MI.getNumExplicitOperands();
423 return MI.getOperand(NumOp - 1).getMBB();
426 bool RISCVInstrInfo::isBranchOffsetInRange(unsigned BranchOp,
427 int64_t BrOffset) const {
428 unsigned XLen = STI.getXLen();
429 // Ideally we could determine the supported branch offset from the
430 // RISCVII::FormMask, but this can't be used for Pseudo instructions like
434 llvm_unreachable("Unexpected opcode!");
441 return isIntN(13, BrOffset);
443 case RISCV::PseudoBR:
444 return isIntN(21, BrOffset);
445 case RISCV::PseudoJump:
446 return isIntN(32, SignExtend64(BrOffset + 0x800, XLen));
450 unsigned RISCVInstrInfo::getInstSizeInBytes(const MachineInstr &MI) const {
451 unsigned Opcode = MI.getOpcode();
455 if (MI.getParent() && MI.getParent()->getParent()) {
456 const auto MF = MI.getMF();
457 const auto &TM = static_cast<const RISCVTargetMachine &>(MF->getTarget());
458 const MCRegisterInfo &MRI = *TM.getMCRegisterInfo();
459 const MCSubtargetInfo &STI = *TM.getMCSubtargetInfo();
460 const RISCVSubtarget &ST = MF->getSubtarget<RISCVSubtarget>();
461 if (isCompressibleInst(MI, &ST, MRI, STI))
464 return get(Opcode).getSize();
466 case TargetOpcode::EH_LABEL:
467 case TargetOpcode::IMPLICIT_DEF:
468 case TargetOpcode::KILL:
469 case TargetOpcode::DBG_VALUE:
471 // These values are determined based on RISCVExpandAtomicPseudoInsts,
472 // RISCVExpandPseudoInsts and RISCVMCCodeEmitter, depending on where the
473 // pseudos are expanded.
474 case RISCV::PseudoCALLReg:
475 case RISCV::PseudoCALL:
476 case RISCV::PseudoJump:
477 case RISCV::PseudoTAIL:
478 case RISCV::PseudoLLA:
479 case RISCV::PseudoLA:
480 case RISCV::PseudoLA_TLS_IE:
481 case RISCV::PseudoLA_TLS_GD:
483 case RISCV::PseudoAtomicLoadNand32:
484 case RISCV::PseudoAtomicLoadNand64:
486 case RISCV::PseudoMaskedAtomicSwap32:
487 case RISCV::PseudoMaskedAtomicLoadAdd32:
488 case RISCV::PseudoMaskedAtomicLoadSub32:
490 case RISCV::PseudoMaskedAtomicLoadNand32:
492 case RISCV::PseudoMaskedAtomicLoadMax32:
493 case RISCV::PseudoMaskedAtomicLoadMin32:
495 case RISCV::PseudoMaskedAtomicLoadUMax32:
496 case RISCV::PseudoMaskedAtomicLoadUMin32:
498 case RISCV::PseudoCmpXchg32:
499 case RISCV::PseudoCmpXchg64:
501 case RISCV::PseudoMaskedCmpXchg32:
503 case TargetOpcode::INLINEASM:
504 case TargetOpcode::INLINEASM_BR: {
505 const MachineFunction &MF = *MI.getParent()->getParent();
506 const auto &TM = static_cast<const RISCVTargetMachine &>(MF.getTarget());
507 return getInlineAsmLength(MI.getOperand(0).getSymbolName(),
513 bool RISCVInstrInfo::isAsCheapAsAMove(const MachineInstr &MI) const {
514 const unsigned Opcode = MI.getOpcode();
521 return (MI.getOperand(1).isReg() && MI.getOperand(1).getReg() == RISCV::X0);
523 return MI.isAsCheapAsAMove();
526 bool RISCVInstrInfo::verifyInstruction(const MachineInstr &MI,
527 StringRef &ErrInfo) const {
528 const MCInstrInfo *MCII = STI.getInstrInfo();
529 MCInstrDesc const &Desc = MCII->get(MI.getOpcode());
531 for (auto &OI : enumerate(Desc.operands())) {
532 unsigned OpType = OI.value().OperandType;
533 if (OpType >= RISCVOp::OPERAND_FIRST_RISCV_IMM &&
534 OpType <= RISCVOp::OPERAND_LAST_RISCV_IMM) {
535 const MachineOperand &MO = MI.getOperand(OI.index());
537 int64_t Imm = MO.getImm();
541 llvm_unreachable("Unexpected operand type");
542 case RISCVOp::OPERAND_UIMM4:
545 case RISCVOp::OPERAND_UIMM5:
548 case RISCVOp::OPERAND_UIMM12:
549 Ok = isUInt<12>(Imm);
551 case RISCVOp::OPERAND_SIMM12:
554 case RISCVOp::OPERAND_SIMM13_LSB0:
555 Ok = isShiftedInt<12, 1>(Imm);
557 case RISCVOp::OPERAND_UIMM20:
558 Ok = isUInt<20>(Imm);
560 case RISCVOp::OPERAND_SIMM21_LSB0:
561 Ok = isShiftedInt<20, 1>(Imm);
563 case RISCVOp::OPERAND_UIMMLOG2XLEN:
564 if (STI.getTargetTriple().isArch64Bit())
571 ErrInfo = "Invalid immediate";
581 // Return true if get the base operand, byte offset of an instruction and the
582 // memory width. Width is the size of memory that is being loaded/stored.
583 bool RISCVInstrInfo::getMemOperandWithOffsetWidth(
584 const MachineInstr &LdSt, const MachineOperand *&BaseReg, int64_t &Offset,
585 unsigned &Width, const TargetRegisterInfo *TRI) const {
586 if (!LdSt.mayLoadOrStore())
589 // Here we assume the standard RISC-V ISA, which uses a base+offset
590 // addressing mode. You'll need to relax these conditions to support custom
591 // load/stores instructions.
592 if (LdSt.getNumExplicitOperands() != 3)
594 if (!LdSt.getOperand(1).isReg() || !LdSt.getOperand(2).isImm())
597 if (!LdSt.hasOneMemOperand())
600 Width = (*LdSt.memoperands_begin())->getSize();
601 BaseReg = &LdSt.getOperand(1);
602 Offset = LdSt.getOperand(2).getImm();
606 bool RISCVInstrInfo::areMemAccessesTriviallyDisjoint(
607 const MachineInstr &MIa, const MachineInstr &MIb) const {
608 assert(MIa.mayLoadOrStore() && "MIa must be a load or store.");
609 assert(MIb.mayLoadOrStore() && "MIb must be a load or store.");
611 if (MIa.hasUnmodeledSideEffects() || MIb.hasUnmodeledSideEffects() ||
612 MIa.hasOrderedMemoryRef() || MIb.hasOrderedMemoryRef())
615 // Retrieve the base register, offset from the base register and width. Width
616 // is the size of memory that is being loaded/stored (e.g. 1, 2, 4). If
617 // base registers are identical, and the offset of a lower memory access +
618 // the width doesn't overlap the offset of a higher memory access,
619 // then the memory accesses are different.
620 const TargetRegisterInfo *TRI = STI.getRegisterInfo();
621 const MachineOperand *BaseOpA = nullptr, *BaseOpB = nullptr;
622 int64_t OffsetA = 0, OffsetB = 0;
623 unsigned int WidthA = 0, WidthB = 0;
624 if (getMemOperandWithOffsetWidth(MIa, BaseOpA, OffsetA, WidthA, TRI) &&
625 getMemOperandWithOffsetWidth(MIb, BaseOpB, OffsetB, WidthB, TRI)) {
626 if (BaseOpA->isIdenticalTo(*BaseOpB)) {
627 int LowOffset = std::min(OffsetA, OffsetB);
628 int HighOffset = std::max(OffsetA, OffsetB);
629 int LowWidth = (LowOffset == OffsetA) ? WidthA : WidthB;
630 if (LowOffset + LowWidth <= HighOffset)
637 std::pair<unsigned, unsigned>
638 RISCVInstrInfo::decomposeMachineOperandsTargetFlags(unsigned TF) const {
639 const unsigned Mask = RISCVII::MO_DIRECT_FLAG_MASK;
640 return std::make_pair(TF & Mask, TF & ~Mask);
643 ArrayRef<std::pair<unsigned, const char *>>
644 RISCVInstrInfo::getSerializableDirectMachineOperandTargetFlags() const {
645 using namespace RISCVII;
646 static const std::pair<unsigned, const char *> TargetFlags[] = {
647 {MO_CALL, "riscv-call"},
648 {MO_PLT, "riscv-plt"},
651 {MO_PCREL_LO, "riscv-pcrel-lo"},
652 {MO_PCREL_HI, "riscv-pcrel-hi"},
653 {MO_GOT_HI, "riscv-got-hi"},
654 {MO_TPREL_LO, "riscv-tprel-lo"},
655 {MO_TPREL_HI, "riscv-tprel-hi"},
656 {MO_TPREL_ADD, "riscv-tprel-add"},
657 {MO_TLS_GOT_HI, "riscv-tls-got-hi"},
658 {MO_TLS_GD_HI, "riscv-tls-gd-hi"}};
659 return makeArrayRef(TargetFlags);
661 bool RISCVInstrInfo::isFunctionSafeToOutlineFrom(
662 MachineFunction &MF, bool OutlineFromLinkOnceODRs) const {
663 const Function &F = MF.getFunction();
665 // Can F be deduplicated by the linker? If it can, don't outline from it.
666 if (!OutlineFromLinkOnceODRs && F.hasLinkOnceODRLinkage())
669 // Don't outline from functions with section markings; the program could
670 // expect that all the code is in the named section.
674 // It's safe to outline from MF.
678 bool RISCVInstrInfo::isMBBSafeToOutlineFrom(MachineBasicBlock &MBB,
679 unsigned &Flags) const {
680 // More accurate safety checking is done in getOutliningCandidateInfo.
684 // Enum values indicating how an outlined call should be constructed.
685 enum MachineOutlinerConstructionID {
686 MachineOutlinerDefault
689 outliner::OutlinedFunction RISCVInstrInfo::getOutliningCandidateInfo(
690 std::vector<outliner::Candidate> &RepeatedSequenceLocs) const {
692 // First we need to filter out candidates where the X5 register (IE t0) can't
693 // be used to setup the function call.
694 auto CannotInsertCall = [](outliner::Candidate &C) {
695 const TargetRegisterInfo *TRI = C.getMF()->getSubtarget().getRegisterInfo();
698 LiveRegUnits LRU = C.LRU;
699 return !LRU.available(RISCV::X5);
702 RepeatedSequenceLocs.erase(std::remove_if(RepeatedSequenceLocs.begin(),
703 RepeatedSequenceLocs.end(),
705 RepeatedSequenceLocs.end());
707 // If the sequence doesn't have enough candidates left, then we're done.
708 if (RepeatedSequenceLocs.size() < 2)
709 return outliner::OutlinedFunction();
711 unsigned SequenceSize = 0;
713 auto I = RepeatedSequenceLocs[0].front();
714 auto E = std::next(RepeatedSequenceLocs[0].back());
716 SequenceSize += getInstSizeInBytes(*I);
718 // call t0, function = 8 bytes.
719 unsigned CallOverhead = 8;
720 for (auto &C : RepeatedSequenceLocs)
721 C.setCallInfo(MachineOutlinerDefault, CallOverhead);
723 // jr t0 = 4 bytes, 2 bytes if compressed instructions are enabled.
724 unsigned FrameOverhead = 4;
725 if (RepeatedSequenceLocs[0].getMF()->getSubtarget()
726 .getFeatureBits()[RISCV::FeatureStdExtC])
729 return outliner::OutlinedFunction(RepeatedSequenceLocs, SequenceSize,
730 FrameOverhead, MachineOutlinerDefault);
734 RISCVInstrInfo::getOutliningType(MachineBasicBlock::iterator &MBBI,
735 unsigned Flags) const {
736 MachineInstr &MI = *MBBI;
737 MachineBasicBlock *MBB = MI.getParent();
738 const TargetRegisterInfo *TRI =
739 MBB->getParent()->getSubtarget().getRegisterInfo();
741 // Positions generally can't safely be outlined.
742 if (MI.isPosition()) {
743 // We can manually strip out CFI instructions later.
744 if (MI.isCFIInstruction())
745 return outliner::InstrType::Invisible;
747 return outliner::InstrType::Illegal;
750 // Don't trust the user to write safe inline assembly.
751 if (MI.isInlineAsm())
752 return outliner::InstrType::Illegal;
754 // We can't outline branches to other basic blocks.
755 if (MI.isTerminator() && !MBB->succ_empty())
756 return outliner::InstrType::Illegal;
758 // We need support for tail calls to outlined functions before return
759 // statements can be allowed.
761 return outliner::InstrType::Illegal;
763 // Don't allow modifying the X5 register which we use for return addresses for
764 // these outlined functions.
765 if (MI.modifiesRegister(RISCV::X5, TRI) ||
766 MI.getDesc().hasImplicitDefOfPhysReg(RISCV::X5))
767 return outliner::InstrType::Illegal;
769 // Make sure the operands don't reference something unsafe.
770 for (const auto &MO : MI.operands())
771 if (MO.isMBB() || MO.isBlockAddress() || MO.isCPI())
772 return outliner::InstrType::Illegal;
774 // Don't allow instructions which won't be materialized to impact outlining
776 if (MI.isMetaInstruction())
777 return outliner::InstrType::Invisible;
779 return outliner::InstrType::Legal;
782 void RISCVInstrInfo::buildOutlinedFrame(
783 MachineBasicBlock &MBB, MachineFunction &MF,
784 const outliner::OutlinedFunction &OF) const {
786 // Strip out any CFI instructions
790 auto I = MBB.begin();
792 for (; I != E; ++I) {
793 if (I->isCFIInstruction()) {
794 I->removeFromParent();
801 MBB.addLiveIn(RISCV::X5);
803 // Add in a return instruction to the end of the outlined frame.
804 MBB.insert(MBB.end(), BuildMI(MF, DebugLoc(), get(RISCV::JALR))
805 .addReg(RISCV::X0, RegState::Define)
810 MachineBasicBlock::iterator RISCVInstrInfo::insertOutlinedCall(
811 Module &M, MachineBasicBlock &MBB, MachineBasicBlock::iterator &It,
812 MachineFunction &MF, const outliner::Candidate &C) const {
814 // Add in a call instruction to the outlined function at the given location.
816 BuildMI(MF, DebugLoc(), get(RISCV::PseudoCALLReg), RISCV::X5)
817 .addGlobalAddress(M.getNamedValue(MF.getName()), 0,