23#include "llvm/Config/llvm-config.h"
29#define DEBUG_TYPE "registerbankinfo"
34 "Number of partial mappings dynamically created");
36 "Number of partial mappings dynamically accessed");
38 "Number of value mappings dynamically created");
40 "Number of value mappings dynamically accessed");
42 "Number of operands mappings dynamically created");
44 "Number of operands mappings dynamically accessed");
46 "Number of instruction mappings dynamically created");
48 "Number of instruction mappings dynamically accessed");
57 unsigned NumRegBanks,
const unsigned *Sizes,
59 : RegBanks(RegBanks), NumRegBanks(NumRegBanks), Sizes(Sizes),
74 "ID does not match the index in the array");
85 if (!Reg.isVirtual()) {
93 if (
auto *RB = dyn_cast_if_present<const RegisterBank *>(RegClassOrBank))
96 dyn_cast_if_present<const TargetRegisterClass *>(RegClassOrBank))
104 assert(Reg.isPhysical() &&
"Reg must be a physreg");
107 return RegRCIt->second;
129 "The mapping of the register bank does not make sense");
137 auto &RegClassOrBank =
MRI.getRegClassOrRegBank(Reg);
138 if (isa<const TargetRegisterClass *>(RegClassOrBank))
139 return MRI.constrainRegClass(Reg, &RC);
141 const RegisterBank *RB = cast<const RegisterBank *>(RegClassOrBank);
143 if (RB && !RB->
covers(RC))
147 MRI.setRegClass(Reg, &RC);
158 return MI.isCopy() ||
MI.isPHI() ||
159 MI.getOpcode() == TargetOpcode::REG_SEQUENCE;
170 unsigned NumOperandsForMapping = IsCopyLike ? 1 :
MI.getNumOperands();
181 bool CompleteMapping =
true;
184 for (
unsigned OpIdx = 0, EndIdx =
MI.getNumOperands(); OpIdx != EndIdx;
201 const RegisterBank *CurRegBank = IsCopyLike ? AltRegBank :
nullptr;
208 CompleteMapping =
false;
220 if (!OperandsMapping[0]) {
221 if (
MI.isRegSequence()) {
227 OperandsMapping[0] = ValMapping;
234 for (; OpIdx != EndIdx; ++OpIdx) {
248 CompleteMapping =
true;
252 OperandsMapping[OpIdx] = ValMapping;
255 if (IsCopyLike && !CompleteMapping) {
260 assert(CompleteMapping &&
"Setting an uncomplete mapping");
264 NumOperandsForMapping);
283 ++NumPartialMappingsAccessed;
290 ++NumPartialMappingsCreated;
293 PartMapping = std::make_unique<PartialMapping>(StartIdx,
Length, RegBank);
305 unsigned NumBreakDowns) {
309 for (
unsigned Idx = 0;
Idx != NumBreakDowns; ++
Idx)
316 unsigned NumBreakDowns)
const {
317 ++NumValueMappingsAccessed;
324 ++NumValueMappingsCreated;
327 ValMapping = std::make_unique<ValueMapping>(BreakDown, NumBreakDowns);
331template <
typename Iterator>
335 ++NumOperandsMappingsAccessed;
344 ++NumOperandsMappingsCreated;
351 Res = std::make_unique<ValueMapping[]>(std::distance(Begin,
End));
353 for (Iterator It = Begin; It !=
End; ++It, ++
Idx) {
369 std::initializer_list<const RegisterBankInfo::ValueMapping *> OpdsMapping)
377 unsigned NumOperands) {
382RegisterBankInfo::getInstructionMappingImpl(
383 bool IsInvalid,
unsigned ID,
unsigned Cost,
385 unsigned NumOperands)
const {
387 OperandsMapping ==
nullptr && NumOperands == 0) ||
389 "Mismatch argument for invalid input");
390 ++NumInstructionMappingsAccessed;
398 ++NumInstructionMappingsCreated;
401 InstrMapping = std::make_unique<InstructionMapping>(
402 ID,
Cost, OperandsMapping, NumOperands);
403 return *InstrMapping;
418 if (Mapping.isValid()) {
428 assert(Mapping->verify(
MI) &&
"Mapping is invalid");
430 return PossibleMappings;
443 for (
unsigned OpIdx = 0,
445 OpIdx != EndIdx; ++OpIdx) {
464 "This mapping is too complex for this function");
467 if (NewRegs.
empty()) {
468 LLVM_DEBUG(
dbgs() <<
" has not been repaired, nothing to be done\n");
479 LLT OrigTy =
MRI.getType(OrigReg);
480 LLT NewTy =
MRI.getType(NewReg);
481 if (OrigTy != NewTy) {
487 "Types with difference size cannot be handled by the default "
489 LLVM_DEBUG(
dbgs() <<
"\nChange type of new opd from " << NewTy <<
" to "
491 MRI.setType(NewReg, OrigTy);
500 if (Reg.isPhysical()) {
506 assert(RC &&
"Expecting Register class");
507 return TRI.getRegSizeInBits(*RC);
509 return TRI.getRegSizeInBits(Reg,
MRI);
515#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
524 assert(RegBank &&
"Register bank not set");
526 assert((StartIdx <= getHighBitIdx()) &&
"Overflow, switch to APInt?");
529 "Register bank too small for Mask");
534 OS <<
"[" << StartIdx <<
", " << getHighBitIdx() <<
"], RegBank = ";
542 if (NumBreakDowns < 2)
547 if (Part->Length !=
First->Length || Part->RegBank !=
First->RegBank)
555 unsigned MeaningfulBitWidth)
const {
556 assert(NumBreakDowns &&
"Value mapped nowhere?!");
557 unsigned OrigValueBitWidth = 0;
561 assert(PartMap.
verify(RBI) &&
"Partial mapping is invalid");
567 assert(OrigValueBitWidth >= MeaningfulBitWidth &&
568 "Meaningful bits not covered by the mapping");
569 APInt ValueMask(OrigValueBitWidth, 0);
576 ValueMask ^= PartMapMask;
577 assert((ValueMask & PartMapMask) == PartMapMask &&
578 "Some partial mappings overlap");
584#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
592 OS <<
"#BreakDown: " << NumBreakDowns <<
" ";
597 OS <<
'[' << PartMap <<
']';
608 "NumOperands must match, see constructor");
610 "MI must be connected to a MachineFunction");
616 for (
unsigned Idx = 0;
Idx < NumOperands; ++
Idx) {
620 "We should not care about non-reg mapping");
626 LLT Ty =
MRI.getType(Reg);
630 "We must have a mapping for reg operands");
638 "Value mapping is invalid");
643#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
651 OS <<
"ID: " << getID() <<
" Cost: " << getCost() <<
" Mapping: ";
653 for (
unsigned OpIdx = 0; OpIdx != NumOperands; ++OpIdx) {
654 const ValueMapping &ValMapping = getOperandMapping(OpIdx);
657 OS <<
"{ Idx: " << OpIdx <<
" Map: " << ValMapping <<
'}';
661const int RegisterBankInfo::OperandsMapper::DontKnowIdx = -1;
666 :
MRI(
MRI),
MI(
MI), InstrMapping(InstrMapping) {
668 OpToNewVRegIdx.
resize(NumOpds, OperandsMapper::DontKnowIdx);
673RegisterBankInfo::OperandsMapper::getVRegsMem(
unsigned OpIdx) {
675 unsigned NumPartialVal =
677 int StartIdx = OpToNewVRegIdx[OpIdx];
679 if (StartIdx == OperandsMapper::DontKnowIdx) {
683 StartIdx = NewVRegs.size();
684 OpToNewVRegIdx[OpIdx] = StartIdx;
685 for (
unsigned i = 0; i < NumPartialVal; ++i)
686 NewVRegs.push_back(0);
689 getNewVRegsEnd(StartIdx, NumPartialVal);
695RegisterBankInfo::OperandsMapper::getNewVRegsEnd(
unsigned StartIdx,
696 unsigned NumVal)
const {
697 return const_cast<OperandsMapper *
>(
this)->getNewVRegsEnd(StartIdx, NumVal);
700RegisterBankInfo::OperandsMapper::getNewVRegsEnd(
unsigned StartIdx,
702 assert((NewVRegs.size() == StartIdx + NumVal ||
703 NewVRegs.size() > StartIdx + NumVal) &&
704 "NewVRegs too small to contain all the partial mapping");
705 return NewVRegs.size() <= StartIdx + NumVal ? NewVRegs.end()
706 : &NewVRegs[StartIdx + NumVal];
715 for (
Register &NewVReg : NewVRegsForOpIdx) {
716 assert(PartMap != ValMapping.
end() &&
"Out-of-bound access");
717 assert(NewVReg == 0 &&
"Register has already been created");
730 unsigned PartialMapIdx,
735 "Out-of-bound access for partial mapping");
737 (void)getVRegsMem(OpIdx);
738 assert(NewVRegs[OpToNewVRegIdx[OpIdx] + PartialMapIdx] == 0 &&
739 "This value is already set");
740 NewVRegs[OpToNewVRegIdx[OpIdx] + PartialMapIdx] = NewVReg;
745 bool ForDebug)
const {
748 int StartIdx = OpToNewVRegIdx[OpIdx];
750 if (StartIdx == OperandsMapper::DontKnowIdx)
751 return make_range(NewVRegs.end(), NewVRegs.end());
753 unsigned PartMapSize =
756 getNewVRegsEnd(StartIdx, PartMapSize);
761 assert((VReg || ForDebug) &&
"Some registers are uninitialized");
766#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
774 bool ForDebug)
const {
779 OS <<
"Populated indices (CellNumber, IndexInNewVRegs): ";
781 for (
unsigned Idx = 0;
Idx != NumOpds; ++
Idx) {
782 if (OpToNewVRegIdx[
Idx] != DontKnowIdx) {
785 OS <<
'(' <<
Idx <<
", " << OpToNewVRegIdx[
Idx] <<
')';
793 OS <<
"Operand Mapping: ";
797 getMI().getParent() && getMI().getMF()
798 ? getMI().getMF()->getSubtarget().getRegisterInfo()
801 for (
unsigned Idx = 0;
Idx != NumOpds; ++
Idx) {
802 if (OpToNewVRegIdx[
Idx] == DontKnowIdx)
808 bool IsFirstNewVReg =
true;
812 IsFirstNewVReg =
false;
unsigned const MachineRegisterInfo * MRI
This file implements a class to represent arbitrary precision integral constant values and operations...
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
#define LLVM_LIKELY(EXPR)
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
unsigned const TargetRegisterInfo * TRI
static unsigned getReg(const MCDisassembler *D, unsigned RC, unsigned RegNo)
static hash_code hashPartialMapping(unsigned StartIdx, unsigned Length, const RegisterBank *RegBank)
Hashing function for PartialMapping.
static bool isCopyLike(const MachineInstr &MI)
Check whether or not MI should be treated like a copy for the mappings.
static hash_code hashValueMapping(const RegisterBankInfo::PartialMapping *BreakDown, unsigned NumBreakDowns)
static hash_code hashInstructionMapping(unsigned ID, unsigned Cost, const RegisterBankInfo::ValueMapping *OperandsMapping, unsigned NumOperands)
static bool isValid(const char C)
Returns true if C is a valid mangled character: <0-9a-zA-Z_>.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Class for arbitrary precision integers.
bool isAllOnes() const
Determine if all bits are set. This is true for zero-width values.
static APInt getBitsSet(unsigned numBits, unsigned loBit, unsigned hiBit)
Get a value with a block of bits set.
static constexpr LLT scalar(unsigned SizeInBits)
Get a low-level scalar or aggregate "bag of bits".
constexpr bool isValid() const
constexpr TypeSize getSizeInBits() const
Returns the total size of the type. Must only be called on sized types.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Representation of each machine instruction.
MachineOperand class - Representation of each machine instruction operand.
bool isReg() const
isReg - Tests if this is a MO_Register operand.
void setReg(Register Reg)
Change the register this operand corresponds to.
Register getReg() const
getReg - Returns the register number.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Helper class that represents how the value of an instruction may be mapped and what is the related co...
unsigned getNumOperands() const
Get the number of operands.
unsigned getID() const
Get the ID.
bool verify(const MachineInstr &MI) const
Verifiy that this mapping makes sense for MI.
void dump() const
Print this on dbgs() stream.
void print(raw_ostream &OS) const
Print this on OS;.
bool isValid() const
Check whether this object is valid.
Helper class used to get/create the virtual registers that will be used to replace the MachineOperand...
const InstructionMapping & getInstrMapping() const
The final mapping of the instruction.
void setVRegs(unsigned OpIdx, unsigned PartialMapIdx, Register NewVReg)
Set the virtual register of the PartialMapIdx-th partial mapping of the OpIdx-th operand to NewVReg.
void print(raw_ostream &OS, bool ForDebug=false) const
Print this operands mapper on OS stream.
MachineInstr & getMI() const
void createVRegs(unsigned OpIdx)
Create as many new virtual registers as needed for the mapping of the OpIdx-th operand.
MachineRegisterInfo & getMRI() const
The MachineRegisterInfo we used to realize the mapping.
OperandsMapper(MachineInstr &MI, const InstructionMapping &InstrMapping, MachineRegisterInfo &MRI)
Create an OperandsMapper that will hold the information to apply InstrMapping to MI.
void dump() const
Print this operands mapper on dbgs() stream.
iterator_range< SmallVectorImpl< Register >::const_iterator > getVRegs(unsigned OpIdx, bool ForDebug=false) const
Get all the virtual registers required to map the OpIdx-th operand of the instruction.
Holds all the information related to register banks.
unsigned getSizeInBits(Register Reg, const MachineRegisterInfo &MRI, const TargetRegisterInfo &TRI) const
Get the size in bits of Reg.
const PartialMapping & getPartialMapping(unsigned StartIdx, unsigned Length, const RegisterBank &RegBank) const
Get the uniquely generated PartialMapping for the given arguments.
virtual InstructionMappings getInstrAlternativeMappings(const MachineInstr &MI) const
Get the alternative mappings for MI.
static const TargetRegisterClass * constrainGenericRegister(Register Reg, const TargetRegisterClass &RC, MachineRegisterInfo &MRI)
Constrain the (possibly generic) virtual register Reg to RC.
const RegisterBank ** RegBanks
Hold the set of supported register banks.
RegisterBankInfo()
This constructor is meaningless.
virtual const InstructionMapping & getInstrMapping(const MachineInstr &MI) const
Get the mapping of the different operands of MI on the register bank.
const InstructionMapping & getInstructionMapping(unsigned ID, unsigned Cost, const ValueMapping *OperandsMapping, unsigned NumOperands) const
Method to get a uniquely generated InstructionMapping.
static void applyDefaultMapping(const OperandsMapper &OpdMapper)
Helper method to apply something that is like the default mapping.
const TargetRegisterClass * getMinimalPhysRegClass(Register Reg, const TargetRegisterInfo &TRI) const
Get the MinimalPhysRegClass for Reg.
const ValueMapping & getValueMapping(unsigned StartIdx, unsigned Length, const RegisterBank &RegBank) const
The most common ValueMapping consists of a single PartialMapping.
const InstructionMapping & getInvalidInstructionMapping() const
Method to get a uniquely generated invalid InstructionMapping.
const RegisterBank & getRegBank(unsigned ID)
Get the register bank identified by ID.
DenseMap< unsigned, std::unique_ptr< ValueMapping[]> > MapOfOperandsMappings
Keep dynamically allocated array of ValueMapping in a separate map.
DenseMap< unsigned, std::unique_ptr< const ValueMapping > > MapOfValueMappings
Keep dynamically allocated ValueMapping in a separate map.
unsigned getMaximumSize(unsigned RegBankID) const
Get the maximum size in bits that fits in the given register bank.
DenseMap< unsigned, std::unique_ptr< const InstructionMapping > > MapOfInstructionMappings
Keep dynamically allocated InstructionMapping in a separate map.
unsigned getNumRegBanks() const
Get the total number of register banks.
const RegisterBank * getRegBankFromConstraints(const MachineInstr &MI, unsigned OpIdx, const TargetInstrInfo &TII, const MachineRegisterInfo &MRI) const
Get the register bank for the OpIdx-th operand of MI form the encoding constraints,...
virtual const RegisterBank & getRegBankFromRegClass(const TargetRegisterClass &RC, LLT Ty) const
Get a register bank that covers RC.
InstructionMappings getInstrPossibleMappings(const MachineInstr &MI) const
Get the possible mapping for MI.
DenseMap< unsigned, std::unique_ptr< const PartialMapping > > MapOfPartialMappings
Keep dynamically allocated PartialMapping in a separate map.
DenseMap< unsigned, const TargetRegisterClass * > PhysRegMinimalRCs
Getting the minimal register class of a physreg is expensive.
static const unsigned InvalidMappingID
Identifier used when the related instruction mapping instance is generated by the default constructor...
const ValueMapping * getOperandsMapping(Iterator Begin, Iterator End) const
Get the uniquely generated array of ValueMapping for the elements of between Begin and End.
bool cannotCopy(const RegisterBank &Dst, const RegisterBank &Src, unsigned Size) const
static const unsigned DefaultMappingID
Identifier used when the related instruction mapping instance is generated by target independent code...
SmallVector< const InstructionMapping *, 4 > InstructionMappings
Convenient type to represent the alternatives for mapping an instruction.
bool verify(const TargetRegisterInfo &TRI) const
Check that information hold by this instance make sense for the given TRI.
const InstructionMapping & getInstrMappingImpl(const MachineInstr &MI) const
Try to get the mapping of MI.
This class implements the register bank concept.
bool verify(const RegisterBankInfo &RBI, const TargetRegisterInfo &TRI) const
Check if this register bank is valid.
bool covers(const TargetRegisterClass &RC) const
Check whether this register bank covers RC.
unsigned getID() const
Get the identifier of this register bank.
Wrapper class representing virtual and physical registers.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
typename SuperClass::const_iterator const_iterator
typename SuperClass::iterator iterator
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
TargetInstrInfo - Interface to description of machine instruction set.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
TargetSubtargetInfo - Generic base class for all target subtargets.
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
virtual const RegisterBankInfo * getRegBankInfo() const
If the information for the register banks is available, return it.
virtual const TargetInstrInfo * getInstrInfo() const
An opaque object representing a hash code.
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
hash_code hash_value(const FixedPointSemantics &Val)
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Printable print(const GCNRegPressure &RP, const GCNSubtarget *ST=nullptr)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Printable printReg(Register Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)
Prints virtual and physical registers with or without a TRI instance.
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Helper struct that represents how a value is partially mapped into a register.
void print(raw_ostream &OS) const
Print this partial mapping on OS;.
unsigned StartIdx
Number of bits at which this partial mapping starts in the original value.
unsigned getHighBitIdx() const
bool verify(const RegisterBankInfo &RBI) const
Check that the Mask is compatible with the RegBank.
void dump() const
Print this partial mapping on dbgs() stream.
const RegisterBank * RegBank
Register bank where the partial value lives.
unsigned Length
Length of this mapping in bits.
Helper struct that represents how a value is mapped through different register banks.
const PartialMapping * begin() const
Iterators through the PartialMappings.
const PartialMapping * end() const
void print(raw_ostream &OS) const
Print this on OS;.
bool partsAllUniform() const
unsigned NumBreakDowns
Number of partial mapping to break down this value.
void dump() const
Print this on dbgs() stream.
bool verify(const RegisterBankInfo &RBI, unsigned MeaningfulBitWidth) const
Verify that this mapping makes sense for a value of MeaningfulBitWidth.