LLVM 20.0.0git
Public Member Functions | Static Public Member Functions | Protected Member Functions | List of all members
llvm::X86InstrInfo Class Referencefinal

#include "Target/X86/X86InstrInfo.h"

Inheritance diagram for llvm::X86InstrInfo:
Inheritance graph
[legend]

Public Member Functions

 X86InstrInfo (X86Subtarget &STI)
 
const TargetRegisterClassgetRegClass (const MCInstrDesc &MCID, unsigned OpNum, const TargetRegisterInfo *TRI, const MachineFunction &MF) const override
 Given a machine instruction descriptor, returns the register class constraint for OpNum, or NULL.
 
const X86RegisterInfogetRegisterInfo () const
 getRegisterInfo - TargetInstrInfo is a superset of MRegister info.
 
int64_t getFrameAdjustment (const MachineInstr &I) const
 Returns the stack pointer adjustment that happens inside the frame setup..destroy sequence (e.g.
 
void setFrameAdjustment (MachineInstr &I, int64_t V) const
 Sets the stack pointer adjustment made inside the frame made up by this instruction.
 
int getSPAdjust (const MachineInstr &MI) const override
 getSPAdjust - This returns the stack pointer adjustment made by this instruction.
 
bool isCoalescableExtInstr (const MachineInstr &MI, Register &SrcReg, Register &DstReg, unsigned &SubIdx) const override
 isCoalescableExtInstr - Return true if the instruction is a "coalescable" extension instruction.
 
Register isLoadFromStackSlot (const MachineInstr &MI, int &FrameIndex) const override
 
Register isLoadFromStackSlot (const MachineInstr &MI, int &FrameIndex, unsigned &MemBytes) const override
 
Register isLoadFromStackSlotPostFE (const MachineInstr &MI, int &FrameIndex) const override
 isLoadFromStackSlotPostFE - Check for post-frame ptr elimination stack locations as well.
 
Register isStoreToStackSlot (const MachineInstr &MI, int &FrameIndex) const override
 
Register isStoreToStackSlot (const MachineInstr &MI, int &FrameIndex, unsigned &MemBytes) const override
 
Register isStoreToStackSlotPostFE (const MachineInstr &MI, int &FrameIndex) const override
 isStoreToStackSlotPostFE - Check for post-frame ptr elimination stack locations as well.
 
bool isReallyTriviallyReMaterializable (const MachineInstr &MI) const override
 
void reMaterialize (MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, Register DestReg, unsigned SubIdx, const MachineInstr &Orig, const TargetRegisterInfo &TRI) const override
 
bool classifyLEAReg (MachineInstr &MI, const MachineOperand &Src, unsigned LEAOpcode, bool AllowSP, Register &NewSrc, bool &isKill, MachineOperand &ImplicitOp, LiveVariables *LV, LiveIntervals *LIS) const
 Given an operand within a MachineInstr, insert preceding code to put it into the right format for a particular kind of LEA instruction.
 
MachineInstrconvertToThreeAddress (MachineInstr &MI, LiveVariables *LV, LiveIntervals *LIS) const override
 convertToThreeAddress - This method must be implemented by targets that set the M_CONVERTIBLE_TO_3_ADDR flag.
 
bool findCommutedOpIndices (const MachineInstr &MI, unsigned &SrcOpIdx1, unsigned &SrcOpIdx2) const override
 Returns true iff the routine could find two commutable operands in the given machine instruction.
 
bool hasCommutePreference (MachineInstr &MI, bool &Commute) const override
 Returns true if we have preference on the operands order in MI, the commute decision is returned in Commute.
 
unsigned getFMA3OpcodeToCommuteOperands (const MachineInstr &MI, unsigned SrcOpIdx1, unsigned SrcOpIdx2, const X86InstrFMA3Group &FMA3Group) const
 Returns an adjusted FMA opcode that must be used in FMA instruction that performs the same computations as the given MI but which has the operands SrcOpIdx1 and SrcOpIdx2 commuted.
 
bool isUnconditionalTailCall (const MachineInstr &MI) const override
 
bool canMakeTailCallConditional (SmallVectorImpl< MachineOperand > &Cond, const MachineInstr &TailCall) const override
 
void replaceBranchWithTailCall (MachineBasicBlock &MBB, SmallVectorImpl< MachineOperand > &Cond, const MachineInstr &TailCall) const override
 
bool analyzeBranch (MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB, SmallVectorImpl< MachineOperand > &Cond, bool AllowModify) const override
 
int getJumpTableIndex (const MachineInstr &MI) const override
 
std::optional< ExtAddrModegetAddrModeFromMemoryOp (const MachineInstr &MemI, const TargetRegisterInfo *TRI) const override
 
bool getConstValDefinedInReg (const MachineInstr &MI, const Register Reg, int64_t &ImmVal) const override
 
bool preservesZeroValueInReg (const MachineInstr *MI, const Register NullValueReg, const TargetRegisterInfo *TRI) const override
 
bool getMemOperandsWithOffsetWidth (const MachineInstr &LdSt, SmallVectorImpl< const MachineOperand * > &BaseOps, int64_t &Offset, bool &OffsetIsScalable, LocationSize &Width, const TargetRegisterInfo *TRI) const override
 
bool analyzeBranchPredicate (MachineBasicBlock &MBB, TargetInstrInfo::MachineBranchPredicate &MBP, bool AllowModify=false) const override
 
unsigned removeBranch (MachineBasicBlock &MBB, int *BytesRemoved=nullptr) const override
 
unsigned insertBranch (MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB, ArrayRef< MachineOperand > Cond, const DebugLoc &DL, int *BytesAdded=nullptr) const override
 
bool canInsertSelect (const MachineBasicBlock &, ArrayRef< MachineOperand > Cond, Register, Register, Register, int &, int &, int &) const override
 
void insertSelect (MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, const DebugLoc &DL, Register DstReg, ArrayRef< MachineOperand > Cond, Register TrueReg, Register FalseReg) const override
 
void copyPhysReg (MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, const DebugLoc &DL, MCRegister DestReg, MCRegister SrcReg, bool KillSrc) const override
 
void storeRegToStackSlot (MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, Register SrcReg, bool isKill, int FrameIndex, const TargetRegisterClass *RC, const TargetRegisterInfo *TRI, Register VReg) const override
 
void loadRegFromStackSlot (MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, Register DestReg, int FrameIndex, const TargetRegisterClass *RC, const TargetRegisterInfo *TRI, Register VReg) const override
 
void loadStoreTileReg (MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, unsigned Opc, Register Reg, int FrameIdx, bool isKill=false) const
 
bool expandPostRAPseudo (MachineInstr &MI) const override
 
bool isSubregFoldable () const override
 Check whether the target can fold a load that feeds a subreg operand (or a subreg operand that feeds a store).
 
MachineInstrfoldMemoryOperandImpl (MachineFunction &MF, MachineInstr &MI, ArrayRef< unsigned > Ops, MachineBasicBlock::iterator InsertPt, int FrameIndex, LiveIntervals *LIS=nullptr, VirtRegMap *VRM=nullptr) const override
 Fold a load or store of the specified stack slot into the specified machine instruction for the specified operand(s).
 
MachineInstrfoldMemoryOperandImpl (MachineFunction &MF, MachineInstr &MI, ArrayRef< unsigned > Ops, MachineBasicBlock::iterator InsertPt, MachineInstr &LoadMI, LiveIntervals *LIS=nullptr) const override
 Same as the previous version except it allows folding of any load and store from / to any address, not just from a specific stack slot.
 
bool unfoldMemoryOperand (MachineFunction &MF, MachineInstr &MI, unsigned Reg, bool UnfoldLoad, bool UnfoldStore, SmallVectorImpl< MachineInstr * > &NewMIs) const override
 
bool unfoldMemoryOperand (SelectionDAG &DAG, SDNode *N, SmallVectorImpl< SDNode * > &NewNodes) const override
 
unsigned getOpcodeAfterMemoryUnfold (unsigned Opc, bool UnfoldLoad, bool UnfoldStore, unsigned *LoadRegIndex=nullptr) const override
 
bool areLoadsFromSameBasePtr (SDNode *Load1, SDNode *Load2, int64_t &Offset1, int64_t &Offset2) const override
 
bool isSchedulingBoundary (const MachineInstr &MI, const MachineBasicBlock *MBB, const MachineFunction &MF) const override
 Overrides the isSchedulingBoundary from Codegen/TargetInstrInfo.cpp to make it capable of identifying ENDBR intructions and prevent it from being re-scheduled.
 
bool shouldScheduleLoadsNear (SDNode *Load1, SDNode *Load2, int64_t Offset1, int64_t Offset2, unsigned NumLoads) const override
 This is a used by the pre-regalloc scheduler to determine (in conjunction with areLoadsFromSameBasePtr) if two loads should be scheduled togther.
 
void insertNoop (MachineBasicBlock &MBB, MachineBasicBlock::iterator MI) const override
 
MCInst getNop () const override
 Return the noop instruction to use for a noop.
 
bool reverseBranchCondition (SmallVectorImpl< MachineOperand > &Cond) const override
 
bool isSafeToMoveRegClassDefs (const TargetRegisterClass *RC) const override
 
bool hasLiveCondCodeDef (MachineInstr &MI) const
 True if MI has a condition code def, e.g.
 
unsigned getGlobalBaseReg (MachineFunction *MF) const
 getGlobalBaseReg - Return a virtual register initialized with the the global base register value.
 
std::pair< uint16_t, uint16_tgetExecutionDomain (const MachineInstr &MI) const override
 
uint16_t getExecutionDomainCustom (const MachineInstr &MI) const
 
void setExecutionDomain (MachineInstr &MI, unsigned Domain) const override
 
bool setExecutionDomainCustom (MachineInstr &MI, unsigned Domain) const
 
unsigned getPartialRegUpdateClearance (const MachineInstr &MI, unsigned OpNum, const TargetRegisterInfo *TRI) const override
 Inform the BreakFalseDeps pass how many idle instructions we would like before a partial register update.
 
unsigned getUndefRegClearance (const MachineInstr &MI, unsigned OpNum, const TargetRegisterInfo *TRI) const override
 Inform the BreakFalseDeps pass how many idle instructions we would like before certain undef register reads.
 
void breakPartialRegDependency (MachineInstr &MI, unsigned OpNum, const TargetRegisterInfo *TRI) const override
 
MachineInstrfoldMemoryOperandImpl (MachineFunction &MF, MachineInstr &MI, unsigned OpNum, ArrayRef< MachineOperand > MOs, MachineBasicBlock::iterator InsertPt, unsigned Size, Align Alignment, bool AllowCommute) const
 
bool isHighLatencyDef (int opc) const override
 
bool hasHighOperandLatency (const TargetSchedModel &SchedModel, const MachineRegisterInfo *MRI, const MachineInstr &DefMI, unsigned DefIdx, const MachineInstr &UseMI, unsigned UseIdx) const override
 
bool useMachineCombiner () const override
 
bool isAssociativeAndCommutative (const MachineInstr &Inst, bool Invert) const override
 
bool hasReassociableOperands (const MachineInstr &Inst, const MachineBasicBlock *MBB) const override
 
void setSpecialOperandAttr (MachineInstr &OldMI1, MachineInstr &OldMI2, MachineInstr &NewMI1, MachineInstr &NewMI2) const override
 This is an architecture-specific helper function of reassociateOps.
 
bool analyzeCompare (const MachineInstr &MI, Register &SrcReg, Register &SrcReg2, int64_t &CmpMask, int64_t &CmpValue) const override
 
bool optimizeCompareInstr (MachineInstr &CmpInstr, Register SrcReg, Register SrcReg2, int64_t CmpMask, int64_t CmpValue, const MachineRegisterInfo *MRI) const override
 Check if there exists an earlier instruction that operates on the same source operands and sets eflags in the same way as CMP and remove CMP if possible.
 
MachineInstroptimizeLoadInstr (MachineInstr &MI, const MachineRegisterInfo *MRI, Register &FoldAsLoadDefReg, MachineInstr *&DefMI) const override
 Try to remove the load by folding it to a register operand at the use.
 
bool foldImmediate (MachineInstr &UseMI, MachineInstr &DefMI, Register Reg, MachineRegisterInfo *MRI) const override
 foldImmediate - 'Reg' is known to be defined by a move immediate instruction, try to fold the immediate into the use instruction.
 
std::pair< unsigned, unsigneddecomposeMachineOperandsTargetFlags (unsigned TF) const override
 
ArrayRef< std::pair< unsigned, const char * > > getSerializableDirectMachineOperandTargetFlags () const override
 
std::optional< outliner::OutlinedFunctiongetOutliningCandidateInfo (const MachineModuleInfo &MMI, std::vector< outliner::Candidate > &RepeatedSequenceLocs) const override
 
bool isFunctionSafeToOutlineFrom (MachineFunction &MF, bool OutlineFromLinkOnceODRs) const override
 
outliner::InstrType getOutliningTypeImpl (const MachineModuleInfo &MMI, MachineBasicBlock::iterator &MIT, unsigned Flags) const override
 
void buildOutlinedFrame (MachineBasicBlock &MBB, MachineFunction &MF, const outliner::OutlinedFunction &OF) const override
 
MachineBasicBlock::iterator insertOutlinedCall (Module &M, MachineBasicBlock &MBB, MachineBasicBlock::iterator &It, MachineFunction &MF, outliner::Candidate &C) const override
 
void buildClearRegister (Register Reg, MachineBasicBlock &MBB, MachineBasicBlock::iterator Iter, DebugLoc &DL, bool AllowSideEffects=true) const override
 
bool verifyInstruction (const MachineInstr &MI, StringRef &ErrInfo) const override
 
std::optional< ParamLoadedValuedescribeLoadedValue (const MachineInstr &MI, Register Reg) const override
 

Static Public Member Functions

static bool isDataInvariant (MachineInstr &MI)
 Returns true if the instruction has no behavior (specified or otherwise) that is based on the value of any of its register operands.
 
static bool isDataInvariantLoad (MachineInstr &MI)
 Returns true if the instruction has no behavior (specified or otherwise) that is based on the value loaded from memory or the value of any non-address register operands.
 
static bool hasLockPrefix (const MachineInstr &MI)
 

Protected Member Functions

MachineInstrcommuteInstructionImpl (MachineInstr &MI, bool NewMI, unsigned CommuteOpIdx1, unsigned CommuteOpIdx2) const override
 
std::optional< DestSourcePairisCopyInstrImpl (const MachineInstr &MI) const override
 
bool getMachineCombinerPatterns (MachineInstr &Root, SmallVectorImpl< unsigned > &Patterns, bool DoRegPressureReduce) const override
 
void genAlternativeCodeSequence (MachineInstr &Root, unsigned Pattern, SmallVectorImpl< MachineInstr * > &InsInstrs, SmallVectorImpl< MachineInstr * > &DelInstrs, DenseMap< unsigned, unsigned > &InstrIdxForVirtReg) const override
 When getMachineCombinerPatterns() finds potential patterns, this function generates the instructions that could replace the original code sequence.
 
bool accumulateInstrSeqToRootLatency (MachineInstr &Root) const override
 When calculate the latency of the root instruction, accumulate the latency of the sequence to the root latency.
 
void getFrameIndexOperands (SmallVectorImpl< MachineOperand > &Ops, int FI) const override
 

Detailed Description

Definition at line 177 of file X86InstrInfo.h.

Constructor & Destructor Documentation

◆ X86InstrInfo()

X86InstrInfo::X86InstrInfo ( X86Subtarget STI)
explicit

Definition at line 85 of file X86InstrInfo.cpp.

Member Function Documentation

◆ accumulateInstrSeqToRootLatency()

bool llvm::X86InstrInfo::accumulateInstrSeqToRootLatency ( MachineInstr Root) const
inlineoverrideprotected

When calculate the latency of the root instruction, accumulate the latency of the sequence to the root latency.

Parameters
Root- Instruction that could be combined with one of its operands For X86 instruction (vpmaddwd + vpmaddwd) -> vpdpwssd, the vpmaddwd is not in the critical path, so the root latency only include vpmaddwd.

Definition at line 648 of file X86InstrInfo.h.

◆ analyzeBranch()

bool X86InstrInfo::analyzeBranch ( MachineBasicBlock MBB,
MachineBasicBlock *&  TBB,
MachineBasicBlock *&  FBB,
SmallVectorImpl< MachineOperand > &  Cond,
bool  AllowModify 
) const
override

Definition at line 3934 of file X86InstrInfo.cpp.

References Cond, MBB, and TBB.

◆ analyzeBranchPredicate()

bool X86InstrInfo::analyzeBranchPredicate ( MachineBasicBlock MBB,
TargetInstrInfo::MachineBranchPredicate MBP,
bool  AllowModify = false 
) const
override

◆ analyzeCompare()

bool X86InstrInfo::analyzeCompare ( const MachineInstr MI,
Register SrcReg,
Register SrcReg2,
int64_t &  CmpMask,
int64_t &  CmpValue 
) const
override

Definition at line 4820 of file X86InstrInfo.cpp.

References CASE_ND, and MI.

◆ areLoadsFromSameBasePtr()

bool X86InstrInfo::areLoadsFromSameBasePtr ( SDNode Load1,
SDNode Load2,
int64_t &  Offset1,
int64_t &  Offset2 
) const
override

◆ breakPartialRegDependency()

void X86InstrInfo::breakPartialRegDependency ( MachineInstr MI,
unsigned  OpNum,
const TargetRegisterInfo TRI 
) const
override

◆ buildClearRegister()

void X86InstrInfo::buildClearRegister ( Register  Reg,
MachineBasicBlock MBB,
MachineBasicBlock::iterator  Iter,
DebugLoc DL,
bool  AllowSideEffects = true 
) const
override

◆ buildOutlinedFrame()

void X86InstrInfo::buildOutlinedFrame ( MachineBasicBlock MBB,
MachineFunction MF,
const outliner::OutlinedFunction OF 
) const
override

◆ canInsertSelect()

bool X86InstrInfo::canInsertSelect ( const MachineBasicBlock MBB,
ArrayRef< MachineOperand Cond,
Register  DstReg,
Register  TrueReg,
Register  FalseReg,
int &  CondCycles,
int &  TrueCycles,
int &  FalseCycles 
) const
override

◆ canMakeTailCallConditional()

bool X86InstrInfo::canMakeTailCallConditional ( SmallVectorImpl< MachineOperand > &  Cond,
const MachineInstr TailCall 
) const
override

◆ classifyLEAReg()

bool X86InstrInfo::classifyLEAReg ( MachineInstr MI,
const MachineOperand Src,
unsigned  LEAOpcode,
bool  AllowSP,
Register NewSrc,
bool isKill,
MachineOperand ImplicitOp,
LiveVariables LV,
LiveIntervals LIS 
) const

Given an operand within a MachineInstr, insert preceding code to put it into the right format for a particular kind of LEA instruction.

This may involve using an appropriate super-register instead (with an implicit use of the original) or creating a new virtual register and inserting COPY instructions to get the data into the right class.

Reference parameters are set to indicate how caller should add this operand to the LEA instruction.

Definition at line 1160 of file X86InstrInfo.cpp.

References llvm::MachineInstrBuilder::addReg(), assert(), llvm::BuildMI(), llvm::MachineRegisterInfo::constrainRegClass(), llvm::MachineRegisterInfo::createVirtualRegister(), llvm::RegState::Define, llvm::LiveRange::Segment::end, llvm::get(), llvm::SlotIndex::getBaseIndex(), llvm::LiveIntervals::getInstructionIndex(), llvm::LiveIntervals::getInterval(), llvm::getKillRegState(), llvm::MachineFunction::getRegInfo(), llvm::SlotIndex::getRegSlot(), llvm::LiveRange::getSegmentContaining(), llvm::getX86SubSuperRegister(), Idx, llvm::LiveIntervals::InsertMachineInstrInMaps(), llvm::Register::isPhysical(), llvm::Register::isValid(), llvm::Register::isVirtual(), MI, llvm::LiveVariables::replaceKillInstruction(), llvm::MachineOperand::setImplicit(), and llvm::RegState::Undef.

Referenced by convertToThreeAddress().

◆ commuteInstructionImpl()

MachineInstr * X86InstrInfo::commuteInstructionImpl ( MachineInstr MI,
bool  NewMI,
unsigned  CommuteOpIdx1,
unsigned  CommuteOpIdx2 
) const
overrideprotected

◆ convertToThreeAddress()

MachineInstr * X86InstrInfo::convertToThreeAddress ( MachineInstr MI,
LiveVariables LV,
LiveIntervals LIS 
) const
override

convertToThreeAddress - This method must be implemented by targets that set the M_CONVERTIBLE_TO_3_ADDR flag.

This method must be implemented by targets that set the M_CONVERTIBLE_TO_3_ADDR flag.

When this flag is set, the target may be able to convert a two-address instruction into a true three-address instruction on demand. This allows the X86 target (for example) to convert ADD and SHL instructions into LEA instructions if they would require register copies due to two-addressness.

This method returns a null pointer if the transformation cannot be performed, otherwise it returns the new instruction.

FIXME: Support these similar to ADD8ri/ADD16ri*.

Definition at line 1406 of file X86InstrInfo.cpp.

References llvm::MachineInstrBuilder::add(), llvm::MachineInstrBuilder::addImm(), llvm::addOffset(), llvm::MachineInstrBuilder::addReg(), llvm::addRegReg(), assert(), llvm::BuildMI(), classifyLEAReg(), llvm::MachineRegisterInfo::constrainRegClass(), llvm::MachineOperand::CreateReg(), llvm::get(), llvm::LiveIntervals::getInterval(), llvm::getKillRegState(), llvm::MachineOperand::getReg(), llvm::MachineFunction::getRegInfo(), getTruncatedShiftCount(), llvm::LiveVariables::getVarInfo(), hasLiveCondCodeDef(), I, llvm::MachineBasicBlock::insert(), isTruncatedShiftCountForLEA(), llvm::LiveVariables::VarInfo::Kills, llvm_unreachable, MBB, MI, llvm::LiveVariables::replaceKillInstruction(), and llvm::LiveIntervals::ReplaceMachineInstrInMaps().

◆ copyPhysReg()

void X86InstrInfo::copyPhysReg ( MachineBasicBlock MBB,
MachineBasicBlock::iterator  MI,
const DebugLoc DL,
MCRegister  DestReg,
MCRegister  SrcReg,
bool  KillSrc 
) const
override

◆ decomposeMachineOperandsTargetFlags()

std::pair< unsigned, unsigned > X86InstrInfo::decomposeMachineOperandsTargetFlags ( unsigned  TF) const
override

Definition at line 10243 of file X86InstrInfo.cpp.

◆ describeLoadedValue()

std::optional< ParamLoadedValue > X86InstrInfo::describeLoadedValue ( const MachineInstr MI,
Register  Reg 
) const
override

◆ expandPostRAPseudo()

bool X86InstrInfo::expandPostRAPseudo ( MachineInstr MI) const
override

◆ findCommutedOpIndices()

bool X86InstrInfo::findCommutedOpIndices ( const MachineInstr MI,
unsigned SrcOpIdx1,
unsigned SrcOpIdx2 
) const
override

Returns true iff the routine could find two commutable operands in the given machine instruction.

The 'SrcOpIdx1' and 'SrcOpIdx2' are INPUT and OUTPUT arguments. Their input values can be re-defined in this method only if the input values are not pre-defined, which is designated by the special value 'CommuteAnyOperandIndex' assigned to it. If both of indices are pre-defined and refer to some operands, then the method simply returns true if the corresponding operands are commutable and returns false otherwise.

For example, calling this method this way: unsigned Op1 = 1, Op2 = CommuteAnyOperandIndex; findCommutedOpIndices(MI, Op1, Op2); can be interpreted as a query asking to find an operand that would be commutable with the operand#1.

Definition at line 2816 of file X86InstrInfo.cpp.

References llvm::X86II::EncodingMask, llvm::X86II::EVEX, llvm::TargetInstrInfo::findCommutedOpIndices(), llvm::getFMA3Group(), llvm::X86Subtarget::hasSSE2(), llvm::X86Subtarget::hasSSE41(), llvm::X86InstrFMA3Group::isIntrinsic(), llvm::X86II::isKMasked(), llvm::X86II::isKMergeMasked(), MI, and llvm::MCOI::TIED_TO.

◆ foldImmediate()

bool X86InstrInfo::foldImmediate ( MachineInstr UseMI,
MachineInstr DefMI,
Register  Reg,
MachineRegisterInfo MRI 
) const
override

foldImmediate - 'Reg' is known to be defined by a move immediate instruction, try to fold the immediate into the use instruction.

Definition at line 5914 of file X86InstrInfo.cpp.

References DefMI, getConstValDefinedInReg(), MRI, and UseMI.

◆ foldMemoryOperandImpl() [1/3]

MachineInstr * X86InstrInfo::foldMemoryOperandImpl ( MachineFunction MF,
MachineInstr MI,
ArrayRef< unsigned Ops,
MachineBasicBlock::iterator  InsertPt,
int  FrameIndex,
LiveIntervals LIS = nullptr,
VirtRegMap VRM = nullptr 
) const
override

◆ foldMemoryOperandImpl() [2/3]

MachineInstr * X86InstrInfo::foldMemoryOperandImpl ( MachineFunction MF,
MachineInstr MI,
ArrayRef< unsigned Ops,
MachineBasicBlock::iterator  InsertPt,
MachineInstr LoadMI,
LiveIntervals LIS = nullptr 
) const
override

Same as the previous version except it allows folding of any load and store from / to any address, not just from a specific stack slot.

Definition at line 8041 of file X86InstrInfo.cpp.

References llvm::X86::AddrNumOperands, llvm::SmallVectorImpl< T >::append(), llvm::CallingConv::C, llvm::MachineOperand::CreateCPI(), llvm::MachineOperand::CreateImm(), llvm::MachineOperand::CreateReg(), FOLD_BROADCAST, foldMemoryOperandImpl(), llvm::get(), llvm::FixedVectorType::get(), llvm::getAlign(), llvm::Constant::getAllOnesValue(), llvm::TargetMachine::getCodeModel(), llvm::MachineFunction::getConstantPool(), llvm::MachineConstantPool::getConstantPoolIndex(), llvm::Function::getContext(), llvm::MachineInstr::getDesc(), llvm::Type::getDoubleTy(), llvm::Type::getFloatTy(), llvm::Type::getFP128Ty(), llvm::MachineFunction::getFunction(), llvm::Type::getHalfTy(), llvm::Type::getInt32Ty(), llvm::Constant::getNullValue(), llvm::MCInstrDesc::getNumOperands(), llvm::MachineInstr::getOpcode(), llvm::MachineInstr::getOperand(), llvm::MachineOperand::getSubReg(), llvm::MachineFunction::getTarget(), llvm::MachineInstr::hasOneMemOperand(), llvm::Function::hasOptSize(), hasPartialRegUpdate(), isLoadFromStackSlot(), isNonFoldablePartialRegisterLoad(), llvm::TargetMachine::isPositionIndependent(), llvm::CodeModel::Large, llvm::MachineInstr::memoperands_begin(), MI, NoFusing, llvm::MachineInstr::operands_begin(), llvm::SmallVectorTemplateBase< T, bool >::push_back(), shouldPreventUndefRegUpdateMemFold(), and llvm::ArrayRef< T >::size().

◆ foldMemoryOperandImpl() [3/3]

MachineInstr * X86InstrInfo::foldMemoryOperandImpl ( MachineFunction MF,
MachineInstr MI,
unsigned  OpNum,
ArrayRef< MachineOperand MOs,
MachineBasicBlock::iterator  InsertPt,
unsigned  Size,
Align  Alignment,
bool  AllowCommute 
) const

◆ genAlternativeCodeSequence()

void X86InstrInfo::genAlternativeCodeSequence ( MachineInstr Root,
unsigned  Pattern,
SmallVectorImpl< MachineInstr * > &  InsInstrs,
SmallVectorImpl< MachineInstr * > &  DelInstrs,
DenseMap< unsigned, unsigned > &  InstrIdxForVirtReg 
) const
overrideprotected

When getMachineCombinerPatterns() finds potential patterns, this function generates the instructions that could replace the original code sequence.

Definition at line 10858 of file X86InstrInfo.cpp.

References llvm::DPWSSD, llvm::TargetInstrInfo::genAlternativeCodeSequence(), and genAlternativeDpCodeSequence().

◆ getAddrModeFromMemoryOp()

std::optional< ExtAddrMode > X86InstrInfo::getAddrModeFromMemoryOp ( const MachineInstr MemI,
const TargetRegisterInfo TRI 
) const
override

◆ getConstValDefinedInReg()

bool X86InstrInfo::getConstValDefinedInReg ( const MachineInstr MI,
const Register  Reg,
int64_t &  ImmVal 
) const
override

◆ getExecutionDomain()

std::pair< uint16_t, uint16_t > X86InstrInfo::getExecutionDomain ( const MachineInstr MI) const
override

◆ getExecutionDomainCustom()

uint16_t X86InstrInfo::getExecutionDomainCustom ( const MachineInstr MI) const

Definition at line 8989 of file X86InstrInfo.cpp.

References AdjustBlendMask(), llvm::X86Subtarget::hasAVX2(), and MI.

Referenced by getExecutionDomain().

◆ getFMA3OpcodeToCommuteOperands()

unsigned X86InstrInfo::getFMA3OpcodeToCommuteOperands ( const MachineInstr MI,
unsigned  SrcOpIdx1,
unsigned  SrcOpIdx2,
const X86InstrFMA3Group FMA3Group 
) const

Returns an adjusted FMA opcode that must be used in FMA instruction that performs the same computations as the given MI but which has the operands SrcOpIdx1 and SrcOpIdx2 commuted.

It may return 0 if it is unsafe to commute the operands. Note that a machine instruction (instead of its opcode) is passed as the first parameter to make it possible to analyze the instruction's uses and commute the first operand of FMA even when it seems unsafe when you look at the opcode. For example, it is Ok to commute the first operand of VFMADD*SD_Int, if ONLY the lowest 64-bit element of the result is used.

The returned FMA opcode may differ from the opcode in the given MI. For example, commuting the operands #1 and #3 in the following FMA FMA213 #1, #2, #3 results into instruction with adjusted opcode: FMA231 #3, #2, #1

Definition at line 2074 of file X86InstrInfo.cpp.

References assert(), llvm::X86InstrFMA3Group::get132Opcode(), llvm::X86InstrFMA3Group::get213Opcode(), llvm::X86InstrFMA3Group::get231Opcode(), getThreeSrcCommuteCase(), llvm::X86InstrFMA3Group::isIntrinsic(), llvm_unreachable, and MI.

Referenced by commuteInstructionImpl().

◆ getFrameAdjustment()

int64_t llvm::X86InstrInfo::getFrameAdjustment ( const MachineInstr I) const
inline

Returns the stack pointer adjustment that happens inside the frame setup..destroy sequence (e.g.

by pushes, or inside the callee).

Definition at line 215 of file X86InstrInfo.h.

References assert(), and I.

Referenced by llvm::X86FrameLowering::eliminateCallFramePseudoInstr(), and getSPAdjust().

◆ getFrameIndexOperands()

void X86InstrInfo::getFrameIndexOperands ( SmallVectorImpl< MachineOperand > &  Ops,
int  FI 
) const
overrideprotected

Definition at line 10877 of file X86InstrInfo.cpp.

References llvm::X86AddressMode::FrameIndexBase.

◆ getGlobalBaseReg()

unsigned X86InstrInfo::getGlobalBaseReg ( MachineFunction MF) const

getGlobalBaseReg - Return a virtual register initialized with the the global base register value.

Return a virtual register initialized with the the global base register value.

Output instructions required to initialize the register in the function entry block, if necessary.

Output instructions required to initialize the register in the function entry block, if necessary.

TODO: Eliminate this and move the code to X86MachineFunctionInfo.

Definition at line 8922 of file X86InstrInfo.cpp.

References llvm::MachineRegisterInfo::createVirtualRegister(), llvm::X86MachineFunctionInfo::getGlobalBaseReg(), llvm::MachineFunction::getInfo(), llvm::MachineFunction::getRegInfo(), and llvm::X86MachineFunctionInfo::setGlobalBaseReg().

◆ getJumpTableIndex()

int X86InstrInfo::getJumpTableIndex ( const MachineInstr MI) const
override

◆ getMachineCombinerPatterns()

bool X86InstrInfo::getMachineCombinerPatterns ( MachineInstr Root,
SmallVectorImpl< unsigned > &  Patterns,
bool  DoRegPressureReduce 
) const
overrideprotected

◆ getMemOperandsWithOffsetWidth()

bool X86InstrInfo::getMemOperandsWithOffsetWidth ( const MachineInstr LdSt,
SmallVectorImpl< const MachineOperand * > &  BaseOps,
int64_t &  Offset,
bool OffsetIsScalable,
LocationSize Width,
const TargetRegisterInfo TRI 
) const
override

◆ getNop()

MCInst X86InstrInfo::getNop ( ) const
override

Return the noop instruction to use for a noop.

Definition at line 9352 of file X86InstrInfo.cpp.

References llvm::MCInst::setOpcode().

◆ getOpcodeAfterMemoryUnfold()

unsigned X86InstrInfo::getOpcodeAfterMemoryUnfold ( unsigned  Opc,
bool  UnfoldLoad,
bool  UnfoldStore,
unsigned LoadRegIndex = nullptr 
) const
override

◆ getOutliningCandidateInfo()

std::optional< outliner::OutlinedFunction > X86InstrInfo::getOutliningCandidateInfo ( const MachineModuleInfo MMI,
std::vector< outliner::Candidate > &  RepeatedSequenceLocs 
) const
override

◆ getOutliningTypeImpl()

outliner::InstrType X86InstrInfo::getOutliningTypeImpl ( const MachineModuleInfo MMI,
MachineBasicBlock::iterator MIT,
unsigned  Flags 
) const
override

Definition at line 10603 of file X86InstrInfo.cpp.

References llvm::outliner::Illegal, llvm::outliner::Legal, and MI.

◆ getPartialRegUpdateClearance()

unsigned X86InstrInfo::getPartialRegUpdateClearance ( const MachineInstr MI,
unsigned  OpNum,
const TargetRegisterInfo TRI 
) const
override

Inform the BreakFalseDeps pass how many idle instructions we would like before a partial register update.

Definition at line 6708 of file X86InstrInfo.cpp.

References llvm::MachineOperand::getReg(), hasPartialRegUpdate(), MI, PartialRegUpdateClearance, llvm::MachineOperand::readsReg(), and TRI.

◆ getRegClass()

const TargetRegisterClass * X86InstrInfo::getRegClass ( const MCInstrDesc MCID,
unsigned  OpNum,
const TargetRegisterInfo TRI,
const MachineFunction MF 
) const
override

Given a machine instruction descriptor, returns the register class constraint for OpNum, or NULL.

Returned register class may be different from the definition in the TD file, e.g. GR*RegClass (definition in TD file) -> GR*_NOREX2RegClass (Returned register class)

Definition at line 94 of file X86InstrInfo.cpp.

References llvm::X86II::canUseApxExtendedReg(), llvm::TargetInstrInfo::getRegClass(), and TRI.

Referenced by foldMemoryOperandImpl(), and unfoldMemoryOperand().

◆ getRegisterInfo()

const X86RegisterInfo & llvm::X86InstrInfo::getRegisterInfo ( ) const
inline

getRegisterInfo - TargetInstrInfo is a superset of MRegister info.

As such, whenever a client has an instance of instruction info, it should always be able to get register info as well (through this method).

Definition at line 211 of file X86InstrInfo.h.

Referenced by analyzeBranchPredicate(), buildClearRegister(), copyPhysReg(), describeLoadedValue(), expandPostRAPseudo(), llvm::X86Subtarget::getRegisterInfo(), optimizeCompareInstr(), and replaceBranchWithTailCall().

◆ getSerializableDirectMachineOperandTargetFlags()

ArrayRef< std::pair< unsigned, const char * > > X86InstrInfo::getSerializableDirectMachineOperandTargetFlags ( ) const
override

Definition at line 10248 of file X86InstrInfo.cpp.

◆ getSPAdjust()

int X86InstrInfo::getSPAdjust ( const MachineInstr MI) const
override

getSPAdjust - This returns the stack pointer adjustment made by this instruction.

For x86, we need to handle more complex call sequences involving PUSHes.

Definition at line 424 of file X86InstrInfo.cpp.

References llvm::alignTo(), llvm::MachineBasicBlock::end(), getFrameAdjustment(), llvm::TargetSubtargetInfo::getFrameLowering(), llvm::TargetFrameLowering::getStackAlign(), llvm::MachineFunction::getSubtarget(), I, MBB, and MI.

◆ getUndefRegClearance()

unsigned X86InstrInfo::getUndefRegClearance ( const MachineInstr MI,
unsigned  OpNum,
const TargetRegisterInfo TRI 
) const
override

Inform the BreakFalseDeps pass how many idle instructions we would like before certain undef register reads.

This catches the VCVTSI2SD family of instructions:

vcvtsi2sdq rax, undef xmm0, xmm14

We should to be careful not to catch VXOR idioms which are presumably handled specially in the pipeline:

vxorps undef xmm1, undef xmm1, xmm1

Like getPartialRegUpdateClearance, this makes a strong assumption that the high bits that are passed-through are not live.

Definition at line 7078 of file X86InstrInfo.cpp.

References llvm::MachineOperand::getReg(), hasUndefRegUpdate(), llvm::Register::isPhysical(), MI, and UndefRegClearance.

◆ hasCommutePreference()

bool X86InstrInfo::hasCommutePreference ( MachineInstr MI,
bool Commute 
) const
override

Returns true if we have preference on the operands order in MI, the commute decision is returned in Commute.

Definition at line 3141 of file X86InstrInfo.cpp.

References isConvertibleLEA(), MI, and MRI.

◆ hasHighOperandLatency()

bool X86InstrInfo::hasHighOperandLatency ( const TargetSchedModel SchedModel,
const MachineRegisterInfo MRI,
const MachineInstr DefMI,
unsigned  DefIdx,
const MachineInstr UseMI,
unsigned  UseIdx 
) const
override

Definition at line 9669 of file X86InstrInfo.cpp.

References DefMI, and isHighLatencyDef().

◆ hasLiveCondCodeDef()

bool X86InstrInfo::hasLiveCondCodeDef ( MachineInstr MI) const

True if MI has a condition code def, e.g.

True if MI has a condition code def, e.g. EFLAGS, that is not marked dead.

EFLAGS, that is not marked dead.

Definition at line 1011 of file X86InstrInfo.cpp.

References MI.

Referenced by convertToThreeAddress().

◆ hasLockPrefix()

static bool llvm::X86InstrInfo::hasLockPrefix ( const MachineInstr MI)
inlinestatic

Definition at line 615 of file X86InstrInfo.h.

References llvm::X86II::LOCK, and MI.

◆ hasReassociableOperands()

bool X86InstrInfo::hasReassociableOperands ( const MachineInstr Inst,
const MachineBasicBlock MBB 
) const
override

◆ insertBranch()

unsigned X86InstrInfo::insertBranch ( MachineBasicBlock MBB,
MachineBasicBlock TBB,
MachineBasicBlock FBB,
ArrayRef< MachineOperand Cond,
const DebugLoc DL,
int *  BytesAdded = nullptr 
) const
override

◆ insertNoop()

void X86InstrInfo::insertNoop ( MachineBasicBlock MBB,
MachineBasicBlock::iterator  MI 
) const
override

Definition at line 9345 of file X86InstrInfo.cpp.

References llvm::BuildMI(), DL, llvm::get(), MBB, and MI.

◆ insertOutlinedCall()

MachineBasicBlock::iterator X86InstrInfo::insertOutlinedCall ( Module M,
MachineBasicBlock MBB,
MachineBasicBlock::iterator It,
MachineFunction MF,
outliner::Candidate C 
) const
override

◆ insertSelect()

void X86InstrInfo::insertSelect ( MachineBasicBlock MBB,
MachineBasicBlock::iterator  MI,
const DebugLoc DL,
Register  DstReg,
ArrayRef< MachineOperand Cond,
Register  TrueReg,
Register  FalseReg 
) const
override

◆ isAssociativeAndCommutative()

bool X86InstrInfo::isAssociativeAndCommutative ( const MachineInstr Inst,
bool  Invert 
) const
override

◆ isCoalescableExtInstr()

bool X86InstrInfo::isCoalescableExtInstr ( const MachineInstr MI,
Register SrcReg,
Register DstReg,
unsigned SubIdx 
) const
override

isCoalescableExtInstr - Return true if the instruction is a "coalescable" extension instruction.

That is, it's like a copy where it's legal for the source to overlap the destination. e.g. X86::MOVSX64rr32. If this returns true, then it's expected the pre-extension value is available as a subreg of the result register. This also returns the sub-register index in SubIdx.

Definition at line 124 of file X86InstrInfo.cpp.

References llvm_unreachable, and MI.

◆ isCopyInstrImpl()

std::optional< DestSourcePair > X86InstrInfo::isCopyInstrImpl ( const MachineInstr MI) const
overrideprotected

Definition at line 4380 of file X86InstrInfo.cpp.

References MI.

◆ isDataInvariant()

bool X86InstrInfo::isDataInvariant ( MachineInstr MI)
static

Returns true if the instruction has no behavior (specified or otherwise) that is based on the value of any of its register operands.

Instructions are considered data invariant even if they set EFLAGS.

A classical example of something that is inherently not data invariant is an indirect jump – the destination is loaded into icache based on the bits set in the jump destination register.

FIXME: This should become part of our instruction tables.

Definition at line 174 of file X86InstrInfo.cpp.

References isLEA(), and MI.

◆ isDataInvariantLoad()

bool X86InstrInfo::isDataInvariantLoad ( MachineInstr MI)
static

Returns true if the instruction has no behavior (specified or otherwise) that is based on the value loaded from memory or the value of any non-address register operands.

For example, if the latency of the instruction is dependent on the particular bits set in any of the registers or any of the bits loaded from memory.

Instructions are considered data invariant even if they set EFLAGS.

A classical example of something that is inherently not data invariant is an indirect jump – the destination is loaded into icache based on the bits set in the jump destination register.

FIXME: This should become part of our instruction tables.

Definition at line 241 of file X86InstrInfo.cpp.

References MI.

◆ isFunctionSafeToOutlineFrom()

bool X86InstrInfo::isFunctionSafeToOutlineFrom ( MachineFunction MF,
bool  OutlineFromLinkOnceODRs 
) const
override

◆ isHighLatencyDef()

bool X86InstrInfo::isHighLatencyDef ( int  opc) const
override

Definition at line 9358 of file X86InstrInfo.cpp.

Referenced by hasHighOperandLatency().

◆ isLoadFromStackSlot() [1/2]

Register X86InstrInfo::isLoadFromStackSlot ( const MachineInstr MI,
int &  FrameIndex 
) const
override

◆ isLoadFromStackSlot() [2/2]

Register X86InstrInfo::isLoadFromStackSlot ( const MachineInstr MI,
int &  FrameIndex,
unsigned MemBytes 
) const
override

Definition at line 695 of file X86InstrInfo.cpp.

References isFrameLoadOpcode(), and MI.

◆ isLoadFromStackSlotPostFE()

Register X86InstrInfo::isLoadFromStackSlotPostFE ( const MachineInstr MI,
int &  FrameIndex 
) const
override

isLoadFromStackSlotPostFE - Check for post-frame ptr elimination stack locations as well.

This uses a heuristic so it isn't reliable for correctness.

Definition at line 704 of file X86InstrInfo.cpp.

References llvm::SmallVectorTemplateCommon< T, typename >::front(), isFrameLoadOpcode(), isLoadFromStackSlot(), and MI.

◆ isReallyTriviallyReMaterializable()

bool X86InstrInfo::isReallyTriviallyReMaterializable ( const MachineInstr MI) const
override

◆ isSafeToMoveRegClassDefs()

bool X86InstrInfo::isSafeToMoveRegClassDefs ( const TargetRegisterClass RC) const
override

Definition at line 8907 of file X86InstrInfo.cpp.

◆ isSchedulingBoundary()

bool X86InstrInfo::isSchedulingBoundary ( const MachineInstr MI,
const MachineBasicBlock MBB,
const MachineFunction MF 
) const
override

Overrides the isSchedulingBoundary from Codegen/TargetInstrInfo.cpp to make it capable of identifying ENDBR intructions and prevent it from being re-scheduled.

Definition at line 8881 of file X86InstrInfo.cpp.

References llvm::MachineInstr::FrameDestroy, llvm::MachineInstr::FrameSetup, llvm::TargetInstrInfo::isSchedulingBoundary(), MBB, and MI.

◆ isStoreToStackSlot() [1/2]

Register X86InstrInfo::isStoreToStackSlot ( const MachineInstr MI,
int &  FrameIndex 
) const
override

◆ isStoreToStackSlot() [2/2]

Register X86InstrInfo::isStoreToStackSlot ( const MachineInstr MI,
int &  FrameIndex,
unsigned MemBytes 
) const
override

Definition at line 729 of file X86InstrInfo.cpp.

References llvm::X86::AddrNumOperands, isFrameStoreOpcode(), and MI.

◆ isStoreToStackSlotPostFE()

Register X86InstrInfo::isStoreToStackSlotPostFE ( const MachineInstr MI,
int &  FrameIndex 
) const
override

isStoreToStackSlotPostFE - Check for post-frame ptr elimination stack locations as well.

This uses a heuristic so it isn't reliable for correctness.

Definition at line 739 of file X86InstrInfo.cpp.

References llvm::X86::AddrNumOperands, llvm::SmallVectorTemplateCommon< T, typename >::front(), isFrameStoreOpcode(), isStoreToStackSlot(), and MI.

◆ isSubregFoldable()

bool llvm::X86InstrInfo::isSubregFoldable ( ) const
inlineoverride

Check whether the target can fold a load that feeds a subreg operand (or a subreg operand that feeds a store).

Definition at line 443 of file X86InstrInfo.h.

◆ isUnconditionalTailCall()

bool X86InstrInfo::isUnconditionalTailCall ( const MachineInstr MI) const
override

Definition at line 3684 of file X86InstrInfo.cpp.

References MI.

◆ loadRegFromStackSlot()

void X86InstrInfo::loadRegFromStackSlot ( MachineBasicBlock MBB,
MachineBasicBlock::iterator  MI,
Register  DestReg,
int  FrameIndex,
const TargetRegisterClass RC,
const TargetRegisterInfo TRI,
Register  VReg 
) const
override

◆ loadStoreTileReg()

void X86InstrInfo::loadStoreTileReg ( MachineBasicBlock MBB,
MachineBasicBlock::iterator  MI,
unsigned  Opc,
Register  Reg,
int  FrameIdx,
bool  isKill = false 
) const

◆ optimizeCompareInstr()

bool X86InstrInfo::optimizeCompareInstr ( MachineInstr CmpInstr,
Register  SrcReg,
Register  SrcReg2,
int64_t  CmpMask,
int64_t  CmpValue,
const MachineRegisterInfo MRI 
) const
override

Check if there exists an earlier instruction that operates on the same source operands and sets eflags in the same way as CMP and remove CMP if possible.

Check if there exists an earlier instruction that operates on the same source operands and sets flags in the same way as Compare; remove Compare if possible.

Definition at line 5258 of file X86InstrInfo.cpp.

References llvm::MachineBasicBlock::addLiveIn(), assert(), llvm::BitWidth, CASE_ND, llvm::X86::COND_A, llvm::X86::COND_AE, llvm::X86::COND_B, llvm::X86::COND_BE, llvm::X86::COND_E, llvm::X86::COND_G, llvm::X86::COND_GE, llvm::X86::COND_INVALID, llvm::X86::COND_L, llvm::X86::COND_LE, llvm::X86::COND_NE, llvm::X86::COND_NO, llvm::X86::COND_NS, llvm::X86::COND_O, llvm::X86::COND_S, llvm::MachineInstr::dropDebugNumber(), llvm::MachineBasicBlock::end(), llvm::MachineInstr::eraseFromParent(), findRedundantFlagInstr(), llvm::MachineInstr::findRegisterDefOperand(), From, FROM_TO, llvm::get(), llvm::X86::getCondFromMI(), llvm::APInt::getMaxValue(), llvm::DWARFExpression::Operation::getNumOperands(), llvm::MachineInstr::getOpcode(), llvm::MachineInstr::getOperand(), GetOppositeBranchCondition(), llvm::MachineInstr::getParent(), llvm::MachineOperand::getReg(), getRegisterInfo(), llvm::APInt::getSignedMaxValue(), llvm::APInt::getSignedMinValue(), getSwappedCondition(), isDefConvertible(), llvm::MachineBasicBlock::isLiveIn(), llvm::Register::isPhysical(), isUseDefConvertible(), llvm_unreachable, llvm::make_range(), MBB, MI, MRI, llvm::MachineBasicBlock::pred_begin(), llvm::MachineBasicBlock::pred_size(), llvm::SmallVectorTemplateBase< T, bool >::push_back(), llvm::MachineBasicBlock::rbegin(), llvm::MachineBasicBlock::remove(), llvm::MachineInstr::removeOperand(), llvm::MachineBasicBlock::rend(), llvm::MachineInstr::setDesc(), llvm::MachineOperand::setIsDead(), llvm::Successor, llvm::MachineBasicBlock::successors(), and TRI.

◆ optimizeLoadInstr()

MachineInstr * X86InstrInfo::optimizeLoadInstr ( MachineInstr MI,
const MachineRegisterInfo MRI,
Register FoldAsLoadDefReg,
MachineInstr *&  DefMI 
) const
override

Try to remove the load by folding it to a register operand at the use.

We fold the load instructions if load defines a virtual register, the virtual register is used once in the same BB, and the instructions in-between do not load or store, and have no side effects.

Definition at line 5638 of file X86InstrInfo.cpp.

References assert(), DefMI, llvm::SmallVectorBase< Size_T >::empty(), llvm::MachineOperand::getReg(), llvm::MachineOperand::getSubReg(), llvm::MachineOperand::isDef(), llvm::MachineOperand::isReg(), llvm::MachineInstr::isSafeToMove(), MI, MRI, and llvm::SmallVectorTemplateBase< T, bool >::push_back().

◆ preservesZeroValueInReg()

bool X86InstrInfo::preservesZeroValueInReg ( const MachineInstr MI,
const Register  NullValueReg,
const TargetRegisterInfo TRI 
) const
override

Definition at line 4641 of file X86InstrInfo.cpp.

References llvm::all_of(), assert(), llvm_unreachable, MI, and TRI.

◆ reMaterialize()

void X86InstrInfo::reMaterialize ( MachineBasicBlock MBB,
MachineBasicBlock::iterator  MI,
Register  DestReg,
unsigned  SubIdx,
const MachineInstr Orig,
const TargetRegisterInfo TRI 
) const
override

◆ removeBranch()

unsigned X86InstrInfo::removeBranch ( MachineBasicBlock MBB,
int *  BytesRemoved = nullptr 
) const
override

◆ replaceBranchWithTailCall()

void X86InstrInfo::replaceBranchWithTailCall ( MachineBasicBlock MBB,
SmallVectorImpl< MachineOperand > &  Cond,
const MachineInstr TailCall 
) const
override

◆ reverseBranchCondition()

bool X86InstrInfo::reverseBranchCondition ( SmallVectorImpl< MachineOperand > &  Cond) const
override

Definition at line 8899 of file X86InstrInfo.cpp.

References assert(), CC, Cond, and GetOppositeBranchCondition().

◆ setExecutionDomain()

void X86InstrInfo::setExecutionDomain ( MachineInstr MI,
unsigned  Domain 
) const
override

◆ setExecutionDomainCustom()

bool X86InstrInfo::setExecutionDomainCustom ( MachineInstr MI,
unsigned  Domain 
) const

◆ setFrameAdjustment()

void llvm::X86InstrInfo::setFrameAdjustment ( MachineInstr I,
int64_t  V 
) const
inline

Sets the stack pointer adjustment made inside the frame made up by this instruction.

Definition at line 224 of file X86InstrInfo.h.

References assert(), and I.

◆ setSpecialOperandAttr()

void X86InstrInfo::setSpecialOperandAttr ( MachineInstr OldMI1,
MachineInstr OldMI2,
MachineInstr NewMI1,
MachineInstr NewMI2 
) const
override

This is an architecture-specific helper function of reassociateOps.

Set special operand attributes for new instructions after reassociation.

Definition at line 10207 of file X86InstrInfo.cpp.

References assert(), llvm::MachineInstr::findRegisterDefOperand(), llvm::MachineOperand::isDead(), and llvm::MachineOperand::setIsDead().

◆ shouldScheduleLoadsNear()

bool X86InstrInfo::shouldScheduleLoadsNear ( SDNode Load1,
SDNode Load2,
int64_t  Offset1,
int64_t  Offset2,
unsigned  NumLoads 
) const
override

This is a used by the pre-regalloc scheduler to determine (in conjunction with areLoadsFromSameBasePtr) if two loads should be scheduled togther.

On some targets if two loads are loading from addresses in the same cache line, it's better if they are scheduled together. This function takes two integers that represent the load offsets from the common base address. It returns true if it decides it's desirable to schedule the two loads together. "NumLoads" is the number of loads that have already been scheduled after Load1.

Definition at line 8832 of file X86InstrInfo.cpp.

References assert(), llvm::SDNode::getMachineOpcode(), llvm::EVT::getSimpleVT(), llvm::SDNode::getValueType(), and llvm::MVT::SimpleTy.

◆ storeRegToStackSlot()

void X86InstrInfo::storeRegToStackSlot ( MachineBasicBlock MBB,
MachineBasicBlock::iterator  MI,
Register  SrcReg,
bool  isKill,
int  FrameIndex,
const TargetRegisterClass RC,
const TargetRegisterInfo TRI,
Register  VReg 
) const
override

◆ unfoldMemoryOperand() [1/2]

bool X86InstrInfo::unfoldMemoryOperand ( MachineFunction MF,
MachineInstr MI,
unsigned  Reg,
bool  UnfoldLoad,
bool  UnfoldStore,
SmallVectorImpl< MachineInstr * > &  NewMIs 
) const
override

◆ unfoldMemoryOperand() [2/2]

bool X86InstrInfo::unfoldMemoryOperand ( SelectionDAG DAG,
SDNode N,
SmallVectorImpl< SDNode * > &  NewNodes 
) const
override

◆ useMachineCombiner()

bool llvm::X86InstrInfo::useMachineCombiner ( ) const
inlineoverride

Definition at line 550 of file X86InstrInfo.h.

◆ verifyInstruction()

bool X86InstrInfo::verifyInstruction ( const MachineInstr MI,
StringRef ErrInfo 
) const
override

The documentation for this class was generated from the following files: