29#define DEBUG_TYPE "x86-pseudo"
30#define X86_EXPAND_PSEUDO_NAME "X86 pseudo instruction expansion pass"
58 return "X86 pseudo instruction expansion pass";
77 void expandVastartSaveXmmRegs(
81char X86ExpandPseudo::ID = 0;
88void X86ExpandPseudo::expandICallBranchFunnel(
97 std::vector<std::pair<MachineBasicBlock *, unsigned>> TargetMBBs;
102 auto CmpTarget = [&](
unsigned Target) {
103 if (Selector.
isReg())
117 auto CreateMBB = [&]() {
128 auto *ElseMBB = CreateMBB();
129 MF->
insert(InsPt, ElseMBB);
134 auto EmitCondJumpTarget = [&](
unsigned CC,
unsigned Target) {
135 auto *ThenMBB = CreateMBB();
136 TargetMBBs.push_back({ThenMBB,
Target});
137 EmitCondJump(CC, ThenMBB);
140 auto EmitTailCall = [&](
unsigned Target) {
145 std::function<void(
unsigned,
unsigned)> EmitBranchFunnel =
147 if (NumTargets == 1) {
152 if (NumTargets == 2) {
159 if (NumTargets < 6) {
167 auto *ThenMBB = CreateMBB();
171 EmitBranchFunnel(
FirstTarget + (NumTargets / 2) + 1,
172 NumTargets - (NumTargets / 2) - 1);
174 MF->
insert(InsPt, ThenMBB);
181 for (
auto P : TargetMBBs) {
186 JTMBB->
erase(JTInst);
196 assert((
MI.getOperand(1).isGlobal() ||
MI.getOperand(1).isReg()) &&
197 "invalid operand for regular call");
199 if (
MI.getOpcode() == X86::CALL64m_RVMARKER)
201 else if (
MI.getOpcode() == X86::CALL64r_RVMARKER)
203 else if (
MI.getOpcode() == X86::CALL64pcrel32_RVMARKER)
204 Opc = X86::CALL64pcrel32;
209 bool RAXImplicitDead =
false;
213 if (
Op.isReg() &&
Op.isImplicit() &&
Op.isDead() &&
214 TRI->regsOverlap(
Op.getReg(), X86::RAX)) {
217 RAXImplicitDead =
true;
227 auto TargetReg = STI->getTargetTriple().isOSWindows() ? X86::RCX : X86::RDI;
232 if (
MI.shouldUpdateAdditionalCallInfo())
247 MI.eraseFromParent();
252 if (
TM.getTargetTriple().isOSDarwin())
263 unsigned Opcode =
MI.getOpcode();
265#define GET_EGPR_IF_ENABLED(OPC) (STI->hasEGPR() ? OPC##_EVEX : OPC)
269 case X86::TCRETURNdi:
270 case X86::TCRETURNdicc:
271 case X86::TCRETURNri:
272 case X86::TCRETURNmi:
273 case X86::TCRETURNdi64:
274 case X86::TCRETURNdi64cc:
275 case X86::TCRETURNri64:
276 case X86::TCRETURNri64_ImpCall:
277 case X86::TCRETURNmi64: {
278 bool isMem = Opcode == X86::TCRETURNmi || Opcode == X86::TCRETURNmi64;
282 assert(StackAdjust.
isImm() &&
"Expecting immediate value.");
285 int StackAdj = StackAdjust.
getImm();
286 int MaxTCDelta = X86FI->getTCReturnAddrDelta();
288 assert(MaxTCDelta <= 0 &&
"MaxTCDelta should never be positive");
291 Offset = StackAdj - MaxTCDelta;
292 assert(
Offset >= 0 &&
"Offset should never be negative");
294 if (Opcode == X86::TCRETURNdicc || Opcode == X86::TCRETURNdi64cc) {
295 assert(
Offset == 0 &&
"Conditional tail call cannot adjust the stack.");
305 bool IsX64 = STI->isTargetWin64() || STI->isTargetUEFI64();
307 if (Opcode == X86::TCRETURNdi || Opcode == X86::TCRETURNdicc ||
308 Opcode == X86::TCRETURNdi64 || Opcode == X86::TCRETURNdi64cc) {
311 case X86::TCRETURNdi:
314 case X86::TCRETURNdicc:
315 Op = X86::TAILJMPd_CC;
317 case X86::TCRETURNdi64cc:
319 "Conditional tail calls confuse "
320 "the Win64 unwinder.");
321 Op = X86::TAILJMPd64_CC;
326 Op = X86::TAILJMPd64;
338 if (
Op == X86::TAILJMPd_CC ||
Op == X86::TAILJMPd64_CC) {
342 }
else if (Opcode == X86::TCRETURNmi || Opcode == X86::TCRETURNmi64) {
343 unsigned Op = (Opcode == X86::TCRETURNmi)
345 : (IsX64 ? X86::TAILJMPm64_REX : X86::TAILJMPm64);
349 }
else if ((Opcode == X86::TCRETURNri64) ||
350 (Opcode == X86::TCRETURNri64_ImpCall)) {
353 TII->get(IsX64 ? X86::TAILJMPr64_REX : X86::TAILJMPr64))
356 assert(!IsX64 &&
"Win64 and UEFI64 require REX for indirect jumps.");
367 if (
MBBI->isCandidateForAdditionalCallInfo())
376 case X86::EH_RETURN64: {
378 assert(DestAddr.
isReg() &&
"Offset should be in register!");
379 const bool Uses64BitFramePtr = STI->isTarget64BitLP64();
382 TII->get(Uses64BitFramePtr ? X86::MOV64rr : X86::MOV32rr), StackPtr)
389 int64_t StackAdj =
MBBI->getOperand(0).getImm();
390 X86FL->emitSPUpdate(
MBB,
MBBI,
DL, StackAdj,
true);
392 unsigned RetOp = STI->is64Bit() ? X86::IRET64 : X86::IRET32;
394 if (STI->is64Bit() && STI->hasUINTR() &&
403 int64_t StackAdj =
MBBI->getOperand(0).getImm();
407 TII->get(STI->is64Bit() ? X86::RET64 : X86::RET32));
408 }
else if (isUInt<16>(StackAdj)) {
410 TII->get(STI->is64Bit() ? X86::RETI64 : X86::RETI32))
414 "shouldn't need to do this for x86_64 targets!");
418 X86FL->emitSPUpdate(
MBB,
MBBI,
DL, StackAdj,
true);
422 for (
unsigned I = 1, E =
MBBI->getNumOperands();
I != E; ++
I)
427 case X86::LCMPXCHG16B_SAVE_RBX: {
447 if (
Base.getReg() == X86::RBX ||
Base.getReg() == X86::EBX)
449 Base.getReg() == X86::RBX
451 :
Register(
TRI->getSubReg(SaveRbx, X86::sub_32bit)),
473 case X86::MASKPAIR16LOAD: {
475 assert(Disp >= 0 && Disp <= INT32_MAX - 2 &&
"Unexpected displacement");
477 bool DstIsDead =
MBBI->getOperand(0).isDead();
478 Register Reg0 =
TRI->getSubReg(Reg, X86::sub_mask_0);
479 Register Reg1 =
TRI->getSubReg(Reg, X86::sub_mask_1);
489 MIBLo.
add(
MBBI->getOperand(1 + i));
493 MIBHi.
add(
MBBI->getOperand(1 + i));
502 MIBLo.setMemRefs(MMOLo);
503 MIBHi.setMemRefs(MMOHi);
509 case X86::MASKPAIR16STORE: {
511 assert(Disp >= 0 && Disp <= INT32_MAX - 2 &&
"Unexpected displacement");
514 Register Reg0 =
TRI->getSubReg(Reg, X86::sub_mask_0);
515 Register Reg1 =
TRI->getSubReg(Reg, X86::sub_mask_1);
523 MIBLo.add(
MBBI->getOperand(i));
525 MIBHi.addImm(Disp + 2);
527 MIBHi.add(
MBBI->getOperand(i));
538 MIBLo.setMemRefs(MMOLo);
539 MIBHi.setMemRefs(MMOHi);
545 case X86::MWAITX_SAVE_RBX: {
565 case TargetOpcode::ICALL_BRANCH_FUNNEL:
566 expandICallBranchFunnel(&
MBB,
MBBI);
568 case X86::PLDTILECFGV: {
572 case X86::PTILELOADDV:
573 case X86::PTILELOADDT1V:
574 case X86::PTILELOADDRSV:
575 case X86::PTILELOADDRST1V:
576 case X86::PTCVTROWD2PSrreV:
577 case X86::PTCVTROWD2PSrriV:
578 case X86::PTCVTROWPS2BF16HrreV:
579 case X86::PTCVTROWPS2BF16HrriV:
580 case X86::PTCVTROWPS2BF16LrreV:
581 case X86::PTCVTROWPS2BF16LrriV:
582 case X86::PTCVTROWPS2PHHrreV:
583 case X86::PTCVTROWPS2PHHrriV:
584 case X86::PTCVTROWPS2PHLrreV:
585 case X86::PTCVTROWPS2PHLrriV:
586 case X86::PTILEMOVROWrreV:
587 case X86::PTILEMOVROWrriV: {
588 for (
unsigned i = 2; i > 0; --i)
592 case X86::PTILELOADDRSV:
595 case X86::PTILELOADDRST1V:
598 case X86::PTILELOADDV:
601 case X86::PTILELOADDT1V:
604 case X86::PTCVTROWD2PSrreV:
605 Opc = X86::TCVTROWD2PSrre;
607 case X86::PTCVTROWD2PSrriV:
608 Opc = X86::TCVTROWD2PSrri;
610 case X86::PTCVTROWPS2BF16HrreV:
611 Opc = X86::TCVTROWPS2BF16Hrre;
613 case X86::PTCVTROWPS2BF16HrriV:
614 Opc = X86::TCVTROWPS2BF16Hrri;
616 case X86::PTCVTROWPS2BF16LrreV:
617 Opc = X86::TCVTROWPS2BF16Lrre;
619 case X86::PTCVTROWPS2BF16LrriV:
620 Opc = X86::TCVTROWPS2BF16Lrri;
622 case X86::PTCVTROWPS2PHHrreV:
623 Opc = X86::TCVTROWPS2PHHrre;
625 case X86::PTCVTROWPS2PHHrriV:
626 Opc = X86::TCVTROWPS2PHHrri;
628 case X86::PTCVTROWPS2PHLrreV:
629 Opc = X86::TCVTROWPS2PHLrre;
631 case X86::PTCVTROWPS2PHLrriV:
632 Opc = X86::TCVTROWPS2PHLrri;
634 case X86::PTILEMOVROWrreV:
635 Opc = X86::TILEMOVROWrre;
637 case X86::PTILEMOVROWrriV:
638 Opc = X86::TILEMOVROWrri;
651 case X86::PTILEPAIRLOAD: {
654 bool DstIsDead =
MBBI->getOperand(0).isDead();
655 Register TReg0 =
TRI->getSubReg(TReg, X86::sub_t0);
656 Register TReg1 =
TRI->getSubReg(TReg, X86::sub_t1);
657 unsigned TmmSize =
TRI->getRegSizeInBits(X86::TILERegClass) / 8;
667 MIBLo.
add(
MBBI->getOperand(1 + i));
669 MIBHi.
addImm(Disp + TmmSize);
671 MIBHi.
add(
MBBI->getOperand(1 + i));
698 case X86::PTILEPAIRSTORE: {
702 Register TReg0 =
TRI->getSubReg(TReg, X86::sub_t0);
703 Register TReg1 =
TRI->getSubReg(TReg, X86::sub_t1);
704 unsigned TmmSize =
TRI->getRegSizeInBits(X86::TILERegClass) / 8;
712 MIBLo.
add(
MBBI->getOperand(i));
714 MIBHi.
addImm(Disp + TmmSize);
716 MIBHi.
add(
MBBI->getOperand(i));
739 case X86::PT2RPNTLVWZ0V:
740 case X86::PT2RPNTLVWZ0T1V:
741 case X86::PT2RPNTLVWZ1V:
742 case X86::PT2RPNTLVWZ1T1V:
743 case X86::PT2RPNTLVWZ0RSV:
744 case X86::PT2RPNTLVWZ0RST1V:
745 case X86::PT2RPNTLVWZ1RSV:
746 case X86::PT2RPNTLVWZ1RST1V: {
747 for (
unsigned i = 3; i > 0; --i)
751 case X86::PT2RPNTLVWZ0V:
754 case X86::PT2RPNTLVWZ0T1V:
757 case X86::PT2RPNTLVWZ1V:
760 case X86::PT2RPNTLVWZ1T1V:
763 case X86::PT2RPNTLVWZ0RSV:
766 case X86::PT2RPNTLVWZ0RST1V:
769 case X86::PT2RPNTLVWZ1RSV:
772 case X86::PT2RPNTLVWZ1RST1V:
781 case X86::PTTRANSPOSEDV:
782 case X86::PTCONJTFP16V: {
783 for (
int i = 2; i > 0; --i)
785 MI.setDesc(
TII->get(Opcode == X86::PTTRANSPOSEDV ? X86::TTRANSPOSED
789 case X86::PTCMMIMFP16PSV:
790 case X86::PTCMMRLFP16PSV:
795 case X86::PTDPBF16PSV:
796 case X86::PTDPFP16PSV:
797 case X86::PTTDPBF16PSV:
798 case X86::PTTDPFP16PSV:
799 case X86::PTTCMMIMFP16PSV:
800 case X86::PTTCMMRLFP16PSV:
801 case X86::PTCONJTCMMIMFP16PSV:
802 case X86::PTMMULTF32PSV:
803 case X86::PTTMMULTF32PSV:
804 case X86::PTDPBF8PSV:
805 case X86::PTDPBHF8PSV:
806 case X86::PTDPHBF8PSV:
807 case X86::PTDPHF8PSV: {
808 MI.untieRegOperand(4);
809 for (
unsigned i = 3; i > 0; --i)
813 case X86::PTCMMIMFP16PSV:
Opc = X86::TCMMIMFP16PS;
break;
814 case X86::PTCMMRLFP16PSV:
Opc = X86::TCMMRLFP16PS;
break;
815 case X86::PTDPBSSDV:
Opc = X86::TDPBSSD;
break;
816 case X86::PTDPBSUDV:
Opc = X86::TDPBSUD;
break;
817 case X86::PTDPBUSDV:
Opc = X86::TDPBUSD;
break;
818 case X86::PTDPBUUDV:
Opc = X86::TDPBUUD;
break;
819 case X86::PTDPBF16PSV:
Opc = X86::TDPBF16PS;
break;
820 case X86::PTDPFP16PSV:
Opc = X86::TDPFP16PS;
break;
821 case X86::PTTDPBF16PSV:
822 Opc = X86::TTDPBF16PS;
824 case X86::PTTDPFP16PSV:
825 Opc = X86::TTDPFP16PS;
827 case X86::PTTCMMIMFP16PSV:
828 Opc = X86::TTCMMIMFP16PS;
830 case X86::PTTCMMRLFP16PSV:
831 Opc = X86::TTCMMRLFP16PS;
833 case X86::PTCONJTCMMIMFP16PSV:
834 Opc = X86::TCONJTCMMIMFP16PS;
836 case X86::PTMMULTF32PSV:
837 Opc = X86::TMMULTF32PS;
839 case X86::PTTMMULTF32PSV:
840 Opc = X86::TTMMULTF32PS;
842 case X86::PTDPBF8PSV:
845 case X86::PTDPBHF8PSV:
846 Opc = X86::TDPBHF8PS;
848 case X86::PTDPHBF8PSV:
849 Opc = X86::TDPHBF8PS;
851 case X86::PTDPHF8PSV:
859 MI.tieOperands(0, 1);
862 case X86::PTILESTOREDV: {
863 for (
int i = 1; i >= 0; --i)
868#undef GET_EGPR_IF_ENABLED
869 case X86::PTILEZEROV: {
870 for (
int i = 2; i > 0; --i)
872 MI.setDesc(
TII->get(X86::TILEZERO));
875 case X86::CALL64pcrel32_RVMARKER:
876 case X86::CALL64r_RVMARKER:
877 case X86::CALL64m_RVMARKER:
878 expandCALL_RVMARKER(
MBB,
MBBI);
880 case X86::CALL64r_ImpCall:
881 MI.setDesc(
TII->get(X86::CALL64r));
883 case X86::ADD32mi_ND:
884 case X86::ADD64mi32_ND:
885 case X86::SUB32mi_ND:
886 case X86::SUB64mi32_ND:
887 case X86::AND32mi_ND:
888 case X86::AND64mi32_ND:
890 case X86::OR64mi32_ND:
891 case X86::XOR32mi_ND:
892 case X86::XOR64mi32_ND:
893 case X86::ADC32mi_ND:
894 case X86::ADC64mi32_ND:
895 case X86::SBB32mi_ND:
896 case X86::SBB64mi32_ND: {
914 MI.getOperand(
MI.getNumExplicitOperands() - 1);
929 if (X86MCRegisterClasses[X86::GR32RegClassID].
contains(
Base) ||
930 X86MCRegisterClasses[X86::GR32RegClassID].
contains(Index))
934 unsigned Opc, LoadOpc;
936#define MI_TO_RI(OP) \
937 case X86::OP##32mi_ND: \
938 Opc = X86::OP##32ri; \
939 LoadOpc = X86::MOV32rm; \
941 case X86::OP##64mi32_ND: \
942 Opc = X86::OP##64ri32; \
943 LoadOpc = X86::MOV64rm; \
963 for (
unsigned I =
MI.getNumImplicitOperands() + 1;
I != 0; --
I)
964 MI.removeOperand(
MI.getNumOperands() - 1);
965 MI.setDesc(
TII->get(LoadOpc));
986void X86ExpandPseudo::expandVastartSaveXmmRegs(
989 assert(VAStartPseudoInstr->getOpcode() == X86::VASTART_SAVE_XMM_REGS);
993 const DebugLoc &
DL = VAStartPseudoInstr->getDebugLoc();
994 Register CountReg = VAStartPseudoInstr->getOperand(0).getReg();
1000 LiveRegs.addLiveIns(*EntryBlk);
1002 if (
MI.getOpcode() == VAStartPseudoInstr->getOpcode())
1005 LiveRegs.stepForward(
MI, Clobbers);
1015 Func->insert(EntryBlkIter, GuardedRegsBlk);
1016 Func->insert(EntryBlkIter, TailBlk);
1024 uint64_t FrameOffset = VAStartPseudoInstr->getOperand(4).getImm();
1025 uint64_t VarArgsRegsOffset = VAStartPseudoInstr->getOperand(6).getImm();
1028 unsigned MOVOpc = STI->hasAVX() ? X86::VMOVAPSmr : X86::MOVAPSmr;
1031 for (int64_t OpndIdx = 7, RegIdx = 0;
1032 OpndIdx < VAStartPseudoInstr->getNumOperands() - 1;
1033 OpndIdx++, RegIdx++) {
1034 auto NewMI =
BuildMI(GuardedRegsBlk,
DL,
TII->get(MOVOpc));
1037 NewMI.addImm(FrameOffset + VarArgsRegsOffset + RegIdx * 16);
1039 NewMI.add(VAStartPseudoInstr->getOperand(i + 1));
1041 NewMI.addReg(VAStartPseudoInstr->getOperand(OpndIdx).getReg());
1042 assert(VAStartPseudoInstr->getOperand(OpndIdx).getReg().isPhysical());
1050 if (!STI->isCallingConvWin64(
Func->getFunction().getCallingConv())) {
1066 VAStartPseudoInstr->eraseFromParent();
1085bool X86ExpandPseudo::expandPseudosWhichAffectControlFlow(
MachineFunction &MF) {
1090 if (
Instr.getOpcode() == X86::VASTART_SAVE_XMM_REGS) {
1091 expandVastartSaveXmmRegs(&(MF.
front()), Instr);
1101 TII = STI->getInstrInfo();
1102 TRI = STI->getRegisterInfo();
1104 X86FL = STI->getFrameLowering();
1106 bool Modified = expandPseudosWhichAffectControlFlow(MF);
1115 return new X86ExpandPseudo();
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
MachineBasicBlock MachineBasicBlock::iterator MBBI
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
const HexagonInstrInfo * TII
This file implements the LivePhysRegs utility for tracking liveness of physical registers.
Register const TargetRegisterInfo * TRI
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
static bool contains(SmallPtrSetImpl< ConstantExpr * > &Cache, ConstantExpr *Expr, Constant *C)
static Target * FirstTarget
#define GET_EGPR_IF_ENABLED(OPC)
#define X86_EXPAND_PSEUDO_NAME
Represent the analysis usage information of a pass.
AnalysisUsage & addPreservedID(const void *ID)
LLVM_ABI void setPreservesCFG()
This function should be called by the pass, iff they do not:
LLVM Basic Block Representation.
This class represents an Operation in the Expression.
FunctionPass class - This class is used to implement most global optimizations.
void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I, const DebugLoc &DL, Register DestReg, Register SrcReg, bool KillSrc, bool RenamableDest=false, bool RenamableSrc=false) const override
Emit instructions to copy a pair of physical registers.
A set of physical registers with utility functions to track liveness when walking backward/forward th...
LLVM_ABI void transferSuccessorsAndUpdatePHIs(MachineBasicBlock *FromMBB)
Transfers all the successors, as in transferSuccessors, and update PHI operands in the successor bloc...
const BasicBlock * getBasicBlock() const
Return the LLVM basic block that this instance corresponded to originally.
LLVM_ABI void addSuccessor(MachineBasicBlock *Succ, BranchProbability Prob=BranchProbability::getUnknown())
Add Succ as a successor of this MachineBasicBlock.
LLVM_ABI void eraseFromParent()
This method unlinks 'this' from the containing function and deletes it.
void addLiveIn(MCRegister PhysReg, LaneBitmask LaneMask=LaneBitmask::getAll())
Adds the specified register as a live in.
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
LLVM_ABI instr_iterator erase(instr_iterator I)
Remove an instruction from the instruction list and delete it.
void splice(iterator Where, MachineBasicBlock *Other, iterator From)
Take an instruction from MBB 'Other' at the position From, and insert it into this MBB right before '...
LLVM_ABI bool isLiveIn(MCRegister Reg, LaneBitmask LaneMask=LaneBitmask::getAll()) const
Return true if the specified register is in the live in set.
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
virtual bool runOnMachineFunction(MachineFunction &MF)=0
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
virtual MachineFunctionProperties getRequiredProperties() const
Properties which a MachineFunction may have at a given point in time.
void moveAdditionalCallInfo(const MachineInstr *Old, const MachineInstr *New)
Move the call site info from Old to \New call site info.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineMemOperand * getMachineMemOperand(MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, LLT MemTy, Align base_alignment, const AAMDNodes &AAInfo=AAMDNodes(), const MDNode *Ranges=nullptr, SyncScope::ID SSID=SyncScope::System, AtomicOrdering Ordering=AtomicOrdering::NotAtomic, AtomicOrdering FailureOrdering=AtomicOrdering::NotAtomic)
getMachineMemOperand - Allocate a new MachineMemOperand.
BasicBlockListType::iterator iterator
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
const MachineBasicBlock & front() const
MachineBasicBlock * CreateMachineBasicBlock(const BasicBlock *BB=nullptr, std::optional< UniqueBBID > BBID=std::nullopt)
CreateMachineBasicBlock - Allocate a new MachineBasicBlock.
void insert(iterator MBBI, MachineBasicBlock *MBB)
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
const MachineInstrBuilder & setMemRefs(ArrayRef< MachineMemOperand * > MMOs) const
const MachineInstrBuilder & addExternalSymbol(const char *FnName, unsigned TargetFlags=0) const
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
const MachineInstrBuilder & add(const MachineOperand &MO) const
const MachineInstrBuilder & addRegMask(const uint32_t *Mask) const
const MachineInstrBuilder & addGlobalAddress(const GlobalValue *GV, int64_t Offset=0, unsigned TargetFlags=0) const
const MachineInstrBuilder & addReg(Register RegNo, unsigned flags=0, unsigned SubReg=0) const
Add a new virtual register operand.
const MachineInstrBuilder & addMBB(MachineBasicBlock *MBB, unsigned TargetFlags=0) const
MachineInstr * getInstr() const
If conversion operators fail, use this method to get the MachineInstr explicitly.
Representation of each machine instruction.
LLVM_ABI void setCFIType(MachineFunction &MF, uint32_t Type)
Set the CFI type for the instruction.
unsigned getNumOperands() const
Retuns the total number of operands.
LLVM_ABI void addOperand(MachineFunction &MF, const MachineOperand &Op)
Add the specified operand to the instruction.
LLVM_ABI void copyImplicitOps(MachineFunction &MF, const MachineInstr &MI)
Copy implicit register operands from specified instruction to this instruction.
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
const MachineOperand & getOperand(unsigned i) const
A description of a memory reference used in the backend.
MachineOperand class - Representation of each machine instruction operand.
const GlobalValue * getGlobal() const
bool isReg() const
isReg - Tests if this is a MO_Register operand.
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
bool isSymbol() const
isSymbol - Tests if this is a MO_ExternalSymbol operand.
void setIsKill(bool Val=true)
unsigned getTargetFlags() const
bool isGlobal() const
isGlobal - Tests if this is a MO_GlobalAddress operand.
const char * getSymbolName() const
Register getReg() const
getReg - Returns the register number.
static MachineOperand CreateReg(Register Reg, bool isDef, bool isImp=false, bool isKill=false, bool isDead=false, bool isUndef=false, bool isEarlyClobber=false, unsigned SubReg=0, bool isDebug=false, bool isInternalRead=false, bool isRenamable=false)
int64_t getOffset() const
Return the offset from the symbol in this operand.
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Wrapper class representing virtual and physical registers.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
TargetInstrInfo - Interface to description of machine instruction set.
CodeModel::Model getCodeModel() const
Returns the code model.
Target - Wrapper for Target specific information.
X86MachineFunctionInfo - This class is derived from MachineFunction and contains private X86 target-s...
self_iterator getIterator()
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ C
The default llvm calling convention, compatible with C.
@ Implicit
Not emitted register (e.g. carry, or temporary result).
@ Define
Register definition.
Reg
All possible values of the reg field in the ModR/M byte.
bool needSIB(MCRegister BaseReg, MCRegister IndexReg, bool In64BitMode)
int getFirstAddrOperandIdx(const MachineInstr &MI)
Return the index of the instruction's first address operand, if it has a memory reference,...
NodeAddr< InstrNode * > Instr
NodeAddr< FuncNode * > Func
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
LLVM_ABI void finalizeBundle(MachineBasicBlock &MBB, MachineBasicBlock::instr_iterator FirstMI, MachineBasicBlock::instr_iterator LastMI)
finalizeBundle - Finalize a machine instruction bundle which includes a sequence of instructions star...
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
static bool isMem(const MachineInstr &MI, unsigned Op)
LLVM_ABI char & MachineDominatorsID
MachineDominators - This pass is a machine dominators analysis pass.
unsigned getDeadRegState(bool B)
LLVM_ABI char & MachineLoopInfoID
MachineLoopInfo - This pass is a loop analysis pass.
FunctionPass * createX86ExpandPseudoPass()
Return a Machine IR pass that expands X86-specific pseudo instructions into a sequence of actual inst...
unsigned getKillRegState(bool B)
DWARFExpression::Operation Op
void addLiveIns(MachineBasicBlock &MBB, const LivePhysRegs &LiveRegs)
Adds registers contained in LiveRegs to the block live-in list of MBB.