~TargetRegisterInfo [destructor] [virtual] | Destroy the target register info object. |
InitMCRegisterInfo | Initialize MCRegisterInfo, called by TableGen auto-generated routines. DO NOT USE. |
adjustStackMapLiveOutMask [virtual] | Adjust a stackmap/patchpoint live-out mask before it is emitted. |
canRealignStack [virtual] | True if the stack can be realigned for the target. |
checkAllSuperRegsMarked | Returns true if for every register in the set all super registers are part of the set as well. |
checkSubRegInterference | Returns true if the two subregisters are equal or overlap. The registers may be virtual registers. |
composeSubRegIndexLaneMask | Transforms a LaneMask computed for one subregister to the lanemask that would have been computed when composing the subsubregisters with IdxA first. |
composeSubRegIndices | Return the subregister index you get from composing two subregister indices. |
eliminateFrameIndex [virtual] | Eliminate an abstract frame index operand from the current instruction. |
eliminateFrameIndicesBackwards [virtual] | Return true if frame indices should be processed in reverse block order. |
explainReservedReg [virtual] | Return an explanation for why PhysReg is reserved, if available. |
findCommonRegClass | Find a common register class that can accomodate both the source and destination operands of a copy-like instruction: |
get | Provide a get method, equivalent to [], but more useful with a pointer to this object. |
getAllocatableClass | Return the maximal subclass of the given register class that is allocatable or NULL. |
getAllocatableSet | Returns a bitset indexed by register number indicating if a register is allocatable or not. If a register class is specified, returns the subset for the class. |
getCSRCost [virtual] | FIXME: We should deprecate this usage. |
getCSRCostScale [virtual] | Scale the CSRFirstUseCost with this number. The scale is a percentage (e.g., 30 means 30% of the base cost). Target can tune and override this default value. |
getCSRFirstUseCost [virtual] | Return the cost of using a callee-saved register for the first time. |
getCallPreservedMask [virtual] | Return the call-preserved register mask for a calling convention. |
getCalleeSavedRegs [virtual] | Return the target callee-saved register list for MF. |
getCodeViewRegNum | Map a target register to an equivalent CodeView register number. |
getCommonMinimalPhysRegClass | Returns the common Register Class of two physical registers, picking the smallest register subclass that contains these two physregs. |
getCommonSubClass | Find the largest common subclass of A and B. Return NULL if there is no common subclass. |
getCommonSuperRegClass | Find a common super-register class if it exists. |
getConstrainedRegClassForOperand [virtual] | Return a constrained register class for operand MO, if any. |
getCoveringLanes | Return the lane mask of lanes that completely cover their sub-registers. |
getCoveringSubRegIndexes | Try to find one or more subregister indexes to cover LaneMask. |
getCrossCopyRegClass [virtual] | Return a legal register class for copying values of class RC. |
getCustomEHPadPreservedMask [virtual] | Return a register mask for the registers preserved by the unwinder, or nullptr if no custom mask is needed. |
getDwarfRegNum [virtual] | Map a target register to an equivalent dwarf register number. |
getDwarfRegNumForVirtReg [virtual] | Return the DWARF register number for virtual register RegNum. |
getDwarfRegNumFromDwarfEHRegNum | Map a target EH register number to an equivalent DWARF register number. |
getEncodingValue | Returns the encoding for Reg |
getFrameIndexInstrOffset [virtual] | Get the offset from the referenced frame index in the instruction, if there is one. |
getFrameRegister [virtual] | Return the register used as a base for the current stack frame. |
getIPRACSRegs [virtual] | Return the IPRA callee-saved register list for MF. |
getIntraCallClobberedRegs [virtual] | Return registers clobbered inside a call to MF. |
getLLVMRegNum | Map a dwarf register back to a target register. Returns std::nullopt if there is no mapping. |
getLargestLegalSuperClass [virtual] | Return the largest legal same-spill-size super-class of RC. |
getLargestRegClassForRegPressureSet [virtual] | Get the register class for this pressure set with the largest RegClassWeight::WeightLimit. |
getMatchingSuperReg | Return a super-register of the specified register Reg so its sub-register of index SubIdx is Reg. |
getMatchingSuperRegClass [virtual] | Return a subclass of the register class A so that each register in it has a sub-register of sub-register index Idx which is in the register class B. |
getMinimalPhysRegClass [virtual] | Returns the Register Class of a physical register, picking the smallest register subclass that contains this physreg. |
getName | Return the human-readable symbolic target-specific name for the specified physical register. |
getNoPreservedMask [virtual] | Return a register mask that clobbers everything. |
getNumRegClasses | Return the number of register classes defined by the target. |
getNumRegPressureSets [virtual] | Get the number of dimensions of register pressure. |
getNumRegUnits | Return the number of (native) register units in the target. |
getNumRegs | Return the number of registers this target has (useful for sizing arrays holding per register information) |
getNumSubRegIndices | Return the number of sub-register indices understood by the target. |
getNumSupportedRegs [virtual] | Return the number of registers for the function. (may overestimate) |
getOffsetOpcodes [virtual] | Gets the DWARF expression opcodes for Offset. |
getPhysRegBaseClass [virtual] | Return the target-defined base register class for physical register Reg. |
getPointerRegClass [virtual] | Returns a TargetRegisterClass used for pointer values. If a target supports multiple different pointer register classes, kind specifies which one is indicated. |
getProgramCounter | Return the register which is the program counter. |
getRARegister | This method should return the register where the return address can be found. |
getRawAllocationOrder [virtual] | Return the preferred allocation order for registers in RC. |
getRegAllocationHints [virtual] | Get preferred physical registers to try first for VirtReg. |
getRegAsmName [virtual] | Return the assembly name for Reg. |
getRegClass | Returns the register class associated with the enumeration value. See class MCOperandInfo. |
getRegClassName | Return the name of register class Class. |
getRegClassPressureSets [virtual] | Get the dimensions of register pressure impacted by this register class. Returns a -1 terminated array of pressure set IDs. |
getRegClassWeight [virtual] | Get the weight in units of pressure for this register class. |
getRegMaskNames [virtual] | Return the names of the call-preserved register masks for this target. |
getRegMasks [virtual] | Return all the call-preserved register masks defined for this target. |
getRegPressureLimit [virtual] | Return the register-pressure high-water mark for RC. |
getRegPressureSetLimit [virtual] | Get the register unit pressure limit for this dimension. This limit must be adjusted dynamically for reserved registers. |
getRegPressureSetName [virtual] | Get the name of this register unit pressure set. |
getRegPressureSetScore [virtual] | Return a heuristic score for increasing pressure set PSetID. |
getRegSizeInBits | getRegSizeInBits overloads |
getRegUnitPressureSets [virtual] | Get the dimensions of register pressure impacted by this register unit. Returns a -1 terminated array of pressure set IDs. |
getRegUnitWeight [virtual] | Get the weight in units of pressure for this register unit. |
getRegisterCosts | Get a list of cost values for all registers that correspond to the index returned by RegisterCostTableIndex. |
getReservedRegs [virtual] | Return the set of registers reserved for MF. |
getSEHRegNum | Map a target register to an equivalent SEH register number. Returns LLVM register number if there is no equivalent value. |
getSpillAlign | Return the minimum required alignment in bytes for a spill slot for a register of this class. |
getSpillSize | Return the size in bytes of the stack slot allocated to hold a spilled copy of a register from class RC. |
getSpillStackID | Return the stack ID for spill slots holding a spilled copy of a register from this class. |
getSpillWeightScaleFactor [virtual] | Get the scale factor of spill weight for this register class. |
getSubClassWithSubReg [virtual] | Return the largest legal subclass of RC that supports subreg Idx. |
getSubReg | Returns the physical register number of sub-register "Index" for physical register RegNo. Return zero if the sub-register does not exist. |
getSubRegIdxOffset | Get the offset of the bit range covered by a sub-register index. |
getSubRegIdxSize | Get the size of the bit range covered by a sub-register index. |
getSubRegIndex | For a given register pair, return the sub-register index if the second register is a sub-register of the first. Return zero otherwise. |
getSubRegIndexLaneMask | Return a bitmask representing the parts of a register that are covered by SubIdx |
getSubRegIndexName | Return the human-readable symbolic target-specific name for the specified SubRegIndex. |
getSubRegisterClass [virtual] | Returns the register class of all sub-registers of SuperRC obtained by applying the sub-register index SubRegIdx. |
getVRegFlagValue [virtual] | Return the numeric value of the named virtual-register flag, if known. |
getVRegFlagsOfReg [virtual] | Return the virtual-register flag names associated with Reg. |
hasRegUnit | Returns true if Reg contains RegUnit. |
hasRegUnitIntervals | Returns true if this target uses regunit intervals. |
hasReservedSpillSlot [virtual] | Return true if the target already reserved a spill slot for Reg. |
hasStackRealignment | True if stack realignment is required and still possible. |
isArgumentRegister [virtual] | Returns true if PhysReg can be used as an argument to a function. |
isArtificial | Return true if the given register is artificial. |
isArtificialRegUnit | Return true when the given register unit is considered artificial. |
isAsmClobberable [virtual] | Returns false if we can't guarantee that Physreg, specified as an IR asm clobber constraint, will be preserved across the statement. |
isCalleeSavedPhysReg [virtual] | This is a wrapper around getCallPreservedMask(). Return true if the register is preserved after the call. |
isCallerPreservedPhysReg [virtual] | Return true if PhysReg is restored before any use after modification. |
isConstant | Returns true if the given register is constant. |
isConstantPhysReg [virtual] | Returns true if PhysReg is unallocatable and constant throughout the function. Used by MachineRegisterInfo::isConstantPhysReg(). |
isDivergentRegClass [virtual] | Returns true if the register class is considered divergent. |
isFixedRegister [virtual] | Returns true if PhysReg is a fixed register. |
isFrameOffsetLegal [virtual] | Determine whether a given base register plus offset immediate is encodable to resolve a frame index. |
isGeneralPurposeRegister [virtual] | Returns true if PhysReg is a general purpose register. |
isGeneralPurposeRegisterClass [virtual] | Returns true if RC is a class/subclass of general purpose register. |
isIgnoredCVReg [virtual] | Return whether LLVMReg should be ignored for CodeView debug info. |
isInAllocatableClass | Return true if the register is in the allocation of any register class. |
isInlineAsmReadOnlyReg [virtual] | Returns true if PhysReg cannot be written to in inline asm statements. |
isNonallocatableRegisterCalleeSave [virtual] | Return true if Reg should be treated like a callee-saved register. |
isSubRegValidForRegClass | Return true if every register in RC supports sub-register Idx. |
isSubRegister | Returns true if RegB is a sub-register of RegA. |
isSubRegisterEq | Returns true if RegB is a sub-register of RegA or if RegB == RegA. |
isSuperOrSubRegisterEq | Returns true if RegB is a super-register or sub-register of RegA or if RegB == RegA. |
isSuperRegister | Returns true if RegB is a super-register of RegA. |
isSuperRegisterEq | Returns true if RegB is a super-register of RegA or if RegB == RegA. |
isTypeLegalForClass | isTypeLegalForClass overloads |
isUniformReg [virtual] | Returns true if the register is considered uniform. |
isVirtualFrameRegister [virtual] | Return true if Reg is a placeholder for a late-assigned frame register. |
legalclasstypes_begin | Loop over all of the value types that can be represented by values in the given register class. |
legalclasstypes_end | Return an iterator past the last legal value type for RC. |
lookThruCopyLike [virtual] | Walk a copy-like chain back to the original source register. |
lookThruSingleUseCopyChain [virtual] | Walk a single-use copy-like chain back to the original source register. |
mapDwarfRegsToLLVMRegs | Used to initialize Dwarf register to LLVM register number mapping. Called by TableGen auto-generated routines. DO NOT USE. |
mapLLVMRegToCVReg | Map an LLVM register number to a CodeView register number. |
mapLLVMRegToSEHReg | Map an LLVM register number to an SEH register number. |
mapLLVMRegsToDwarfRegs | Used to initialize LLVM register to Dwarf register number mapping. Called by TableGen auto-generated routines. DO NOT USE. |
markSuperRegs | Mark a register and all its aliases as reserved in the given set. |
materializeFrameBaseRegister [virtual] | Insert defining instruction(s) for a pointer to FrameIdx before insertion point I. Return materialized frame pointer. |
needsFrameBaseReg [virtual] | Return true if a frame-index reference prefers a non-FP/SP base register. |
operator[] | Return the descriptor for physical register Reg. |
prependOffsetExpression | Prepends a DWARF expression for Offset to DIExpression Expr. |
regClassPriorityTrumpsGlobalness [virtual] | Prefer register-class allocation priority over live-range globalness. |
regclass_begin | Return an iterator to the first register class. |
regclass_end | Return an iterator past the last register class. |
regclasses | Return a range over all register classes. |
regmaskSubsetEqual | Return true if all bits that are set in mask mask0 are also set in mask1. |
regsOverlap | regsOverlap overloads |
regunits | regunits overloads |
regunits_interval | Returns an iterator range over all native regunits in the RegUnitInterval table for Reg. |
requiresFrameIndexReplacementScavenging [virtual] | Returns true if the target requires using the RegScavenger directly for frame elimination despite using requiresFrameIndexScavenging. |
requiresFrameIndexScavenging [virtual] | Returns true if the target requires post PEI scavenging of registers for materializing frame index constants. |
requiresRegisterScavenging [virtual] | Returns true if the target requires (and can make use of) the register scavenger. |
requiresVirtualBaseRegisters [virtual] | Returns true if the target wants the LocalStackAllocation pass to be run and virtual base registers used for more efficient stack access. |
resolveFrameIndex [virtual] | Resolve a frame index operand of an instruction to reference the indicated base register plus offset instead. |
reverseComposeSubRegIndexLaneMask | Reverse-compose a virtual-register lane mask through subreg index IdxA. |
reverseComposeSubRegIndices | Return a subregister index that will compose to give you the subregister index. |
reverseLocalAssignment [virtual] | Return true if local live ranges should be allocated in reverse order. |
saveScavengerRegister [virtual] | Spill Reg so the register scavenger can reuse it. |
shouldAnalyzePhysregInMachineLoopInfo [virtual] | Returns true if MachineLoopInfo should analyze the given physreg for loop invariance. |
shouldCoalesce [virtual] | Return true if SrcRC and DstRC may morph into NewRC during coalescing. |
shouldRealignStack [virtual] | True if storage within the function requires the stack pointer to be aligned more than the normal calling convention calls for. |
shouldRegionSplitForVirtReg [virtual] | Decide whether region splitting should run for VirtReg. |
shouldRewriteCopySrc [virtual] | Return true if this copy-like source is preferable to an earlier use. |
shouldUseLastChanceRecoloringForVirtReg [virtual] | Decide whether last-chance recoloring should run for VirtReg. |
sub_and_superregs_inclusive | Return an iterator range over all sub- and super-registers of Reg, including Reg. |
subregs | Return an iterator range over all sub-registers of Reg, excluding Reg. |
subregs_inclusive | Return an iterator range over all sub-registers of Reg, including Reg. |
superregs | Return an iterator range over all super-registers of Reg, excluding Reg. |
superregs_inclusive | Return an iterator range over all super-registers of Reg, including Reg. |
trackLivenessAfterRegAlloc [virtual] | Returns true if the live-ins should be tracked after register allocation. |
updateRegAllocHint [virtual] | Update register allocation hints after Reg changes to NewReg. |
useFPForScavengingIndex [virtual] | Returns true if the target wants to use frame pointer based accesses to spill to the scavenger emergency spill slot. |