19 #ifndef LLVM_CODEGEN_SLOTINDEXES_H
20 #define LLVM_CODEGEN_SLOTINDEXES_H
56 #ifdef EXPENSIVE_CHECKS
62 assert(((tmp & 0x1) == 0x0) &&
"Pointer already poisoned?");
67 bool isPoisoned()
const {
return (reinterpret_cast<intptr_t>(mi) & 0x1) == 0x1; }
68 #endif // EXPENSIVE_CHECKS
122 : lie(entry, slot) {}
124 IndexListEntry* listEntry()
const {
125 assert(
isValid() &&
"Attempt to compare reserved index.");
126 #ifdef EXPENSIVE_CHECKS
127 assert(!lie.getPointer()->isPoisoned() &&
128 "Attempt to access deleted list-entry.");
129 #endif // EXPENSIVE_CHECKS
130 return lie.getPointer();
133 unsigned getIndex()
const {
134 return listEntry()->
getIndex() | getSlot();
138 Slot getSlot()
const {
139 return static_cast<Slot
>(lie.getInt());
154 assert(lie.getPointer() !=
nullptr &&
155 "Attempt to construct index with 0 pointer.");
161 return lie.getPointer();
175 return lie == other.lie;
179 return lie != other.lie;
185 return getIndex() < other.getIndex();
190 return getIndex() <= other.getIndex();
196 return getIndex() > other.getIndex();
202 return getIndex() >= other.getIndex();
207 return A.lie.getPointer() == B.lie.getPointer();
218 return other.getIndex() - getIndex();
229 bool isBlock()
const {
return getSlot() == Slot_Block; }
236 bool isRegister()
const {
return getSlot() == Slot_Register; }
239 bool isDead()
const {
return getSlot() == Slot_Dead; }
245 return SlotIndex(listEntry(), Slot_Block);
252 return SlotIndex(listEntry(), Slot_Dead);
258 return SlotIndex(listEntry(), EC ? Slot_EarlyClobber : Slot_Register);
263 return SlotIndex(listEntry(), Slot_Dead);
274 if (s == Slot_Dead) {
275 return SlotIndex(listEntry()->getNextNode(), Slot_Block);
283 return SlotIndex(listEntry()->getNextNode(), getSlot());
294 if (s == Slot_Block) {
295 return SlotIndex(listEntry()->getPrevNode(), Slot_Dead);
303 return SlotIndex(listEntry()->getPrevNode(), getSlot());
327 return LHS.first < RHS.first;
340 #ifdef EXPENSIVE_CHECKS
342 #endif // EXPENSIVE_CHECKS
363 alignOf<IndexListEntry>()));
398 assert(indexList.
front().
getIndex() == 0 &&
"First index is not 0?");
410 return mi2iMap.
count(instr);
417 assert(itr != mi2iMap.
end() &&
"Instruction not found in maps.");
444 assert(MBB &&
"MI must be inserted inna basic block");
451 if (MapItr != mi2iMap.
end())
452 return MapItr->second;
461 assert(MBB &&
"MI must be inserted inna basic block");
468 if (MapItr != mi2iMap.
end())
469 return MapItr->second;
474 const std::pair<SlotIndex, SlotIndex> &
476 return MBBRanges[Num];
480 const std::pair<SlotIndex, SlotIndex> &
508 return MI->getParent();
510 std::lower_bound(idx2MBBMap.
begin(), idx2MBBMap.
end(), index);
513 ((I != idx2MBBMap.
end() && I->first > index) ||
514 (I == idx2MBBMap.
end() && idx2MBBMap.
size()>0)) ? (I-1): I;
516 assert(J != idx2MBBMap.
end() && J->first <= index &&
518 "index does not correspond to an MBB");
525 std::lower_bound(idx2MBBMap.
begin(), idx2MBBMap.
end(), start);
528 while (itr != idx2MBBMap.
end()) {
529 if (itr->first >= end)
542 assert(start < end &&
"Backwards ranges not allowed.");
545 std::lower_bound(idx2MBBMap.
begin(), idx2MBBMap.
end(), start);
547 if (itr == idx2MBBMap.
end()) {
548 itr = std::prev(itr);
553 if (itr->first < end)
556 itr = std::prev(itr);
558 if (itr->first <= start)
571 "Instructions inside bundles should use bundle start's slot.");
572 assert(mi2iMap.
find(mi) == mi2iMap.
end() &&
"Instr already indexed.");
575 assert(!mi->
isDebugValue() &&
"Cannot number DBG_VALUE instructions.");
577 assert(mi->
getParent() !=
nullptr &&
"Instr must be added to function.");
584 prevItr = std::prev(nextItr);
588 nextItr = std::next(prevItr);
593 unsigned dist = ((nextItr->getIndex() - prevItr->getIndex())/2) & ~3u;
594 unsigned newNumber = prevItr->getIndex() + dist;
598 indexList.
insert(nextItr, createEntry(mi, newNumber));
604 SlotIndex newIndex(&*newItr, SlotIndex::Slot_Block);
605 mi2iMap.
insert(std::make_pair(mi, newIndex));
614 if (mi2iItr != mi2iMap.
end()) {
616 assert(miEntry->getInstr() == mi &&
"Instruction indexes broken.");
619 mi2iMap.
erase(mi2iItr);
627 if (mi2iItr == mi2iMap.
end())
629 SlotIndex replaceBaseIndex = mi2iItr->second;
631 assert(miEntry->getInstr() == mi &&
632 "Mismatched instruction in index tables.");
634 mi2iMap.
erase(mi2iItr);
635 mi2iMap.
insert(std::make_pair(newMI, replaceBaseIndex));
647 startEntry = &indexList.
back();
648 endEntry = createEntry(
nullptr, 0);
649 newItr = indexList.
insertAfter(startEntry, endEntry);
651 startEntry = createEntry(
nullptr, 0);
653 newItr = indexList.
insert(endEntry, startEntry);
656 SlotIndex startIdx(startEntry, SlotIndex::Slot_Block);
657 SlotIndex endIdx(endEntry, SlotIndex::Slot_Block);
661 "Can't insert a new block at the beginning of a function.");
663 MBBRanges[prevMBB->getNumber()].second = startIdx;
665 assert(
unsigned(mbb->
getNumber()) == MBBRanges.size() &&
666 "Blocks must be added in order");
667 MBBRanges.push_back(std::make_pair(startIdx, endIdx));
691 #ifdef EXPENSIVE_CHECKS
693 graveyardList.push_back(entry);
696 indexList.
erase(entry);
710 #endif // LLVM_CODEGEN_SLOTINDEXES_H
bool isInsideBundle() const
Return true if MI is in a bundle (but not the first MI in a bundle).
void push_back(const T &Elt)
const MachineFunction * getParent() const
getParent - Return the MachineFunction containing this basic block.
const_iterator end(StringRef path)
Get end iterator over path.
void renumberIndexes()
Renumber the index list, providing space for new instructions.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
std::pair< SlotIndex, MachineBasicBlock * > IdxMBBPair
iplist< IndexListEntry >::iterator iterator
static NodeTy * createNode(const NodeTy &V)
SlotIndex getBoundaryIndex() const
Returns the boundary index for associated with this index.
int getInstrDistance(SlotIndex other) const
Return the scaled distance from this index to the given one, where all slots on the same instruction ...
void destroySentinel(IndexListEntry *) const
int getNumber() const
getNumber - MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a M...
SlotIndex getBaseIndex() const
Returns the base index for associated with this index.
int distance(SlotIndex other) const
Return the distance from this index to the given one.
MachineInstr * getInstr() const
bool operator==(SlotIndex other) const
Compare two SlotIndex objects for equality.
void deleteNode(IndexListEntry *N)
bool isRegister() const
isRegister - Returns true if this is a normal register use/def slot.
SlotIndex getIndexAfter(const MachineInstr *MI) const
getIndexAfter - Returns the index of the first indexed instruction after MI, or the end index of its ...
bool isEarlyClobber() const
isEarlyClobber - Returns true if this is an early-clobber slot.
This file defines the MallocAllocator and BumpPtrAllocator interfaces.
static bool isEarlierInstr(SlotIndex A, SlotIndex B)
isEarlierInstr - Return true if A refers to an instruction earlier than B.
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
SlotIndex getLastIndex()
Returns the base index of the last slot in this analysis.
bool operator>=(SlotIndex other) const
Compare two SlotIndex objects.
bool operator>(SlotIndex other) const
Compare two SlotIndex objects.
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
ilist_default_traits - Default template traits for intrusive list.
static void noteHead(IndexListEntry *, IndexListEntry *)
bool isBlock() const
isBlock - Returns true if this is a block boundary slot.
SlotIndex getDeadSlot() const
Returns the dead def kill slot for the current instruction.
SlotIndex getNextNonNullIndex(SlotIndex Index)
Returns the next non-null index, if one exists.
bool isDead() const
isDead - Returns true if this is a dead def kill slot.
void eraseIndex(SlotIndex index)
Free the resources that were required to maintain a SlotIndex.
bool operator!=(SlotIndex other) const
Compare two SlotIndex objects for inequality.
IndexListEntry * provideInitialHead() const
The default distance between instructions as returned by distance().
SlotIndex getPrevIndex() const
Returns the previous index.
void setIndex(unsigned index)
SlotIndex getPrevSlot() const
Returns the previous slot in the index list.
const MachineBasicBlock * getParent() const
bool isDebugValue() const
unsigned getIndex() const
bool erase(const KeyT &Val)
bool operator<=(SlotIndex other) const
Compare two SlotIndex objects.
void initializeSlotIndexesPass(PassRegistry &)
bool isValid() const
Returns true if this is a valid index.
SlotIndex(const SlotIndex &li, Slot s)
bool operator<(SlotIndex other) const
Compare two SlotIndex objects.
void insertMBBInMaps(MachineBasicBlock *mbb)
Add the given MachineBasicBlock into the maps.
PointerIntPair - This class implements a pair of a pointer and small integer.
Allocate memory in an ever growing pool, as if by bump-pointer.
bool findLiveInMBBs(SlotIndex start, SlotIndex end, SmallVectorImpl< MachineBasicBlock * > &mbbs) const
bundle_iterator - MachineBasicBlock iterator that automatically skips over MIs that are inside bundle...
LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void * Allocate(size_t Size, size_t Alignment)
Allocate space at the specified alignment.
iterator insertAfter(iterator where, NodeTy *New)
bool operator()(const IdxMBBPair &LHS, const IdxMBBPair &RHS) const
iterator insert(iterator where, const NodeTy &val)
Represent the analysis usage information of a pass.
void dump() const
Dump the indexes.
SlotIndex getZeroIndex()
Returns the zero index for this analysis.
void setInstr(MachineInstr *mi)
SlotIndex getInstructionIndex(const MachineInstr *MI) const
Returns the base index for the given instruction.
iterator erase(iterator where)
MachineInstr * getInstructionFromIndex(SlotIndex index) const
Returns the instruction for the given index, or null if the given index has no instruction associated...
SlotIndex getIndexBefore(const MachineInstr *MI) const
getIndexBefore - Returns the index of the last indexed instruction before MI, or the start index of i...
isPodLike - This is a type trait that is used to determine whether a given type can be copied around ...
static bool isSameInstr(SlotIndex A, SlotIndex B)
isSameInstr - Return true if A and B refer to the same instruction.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
bool hasIndex(const MachineInstr *instr) const
Returns true if the given machine instr is mapped to an index, otherwise returns false.
MachineBasicBlock * getMBBFromIndex(SlotIndex index) const
Returns the basic block which the given index falls in.
SlotIndex getMBBEndIdx(const MachineBasicBlock *mbb) const
Returns the last index in the given basic block.
MachineBasicBlock * getMBBCoveringRange(SlotIndex start, SlotIndex end) const
Returns the MBB covering the given range, or null if the range covers more than one basic block...
size_type count(const KeyT &Val) const
Return 1 if the specified key is in the map, 0 otherwise.
SlotIndex getMBBEndIdx(unsigned Num) const
Returns the last index in the given basic block number.
IndexListEntry(MachineInstr *mi, unsigned index)
void repairIndexesInRange(MachineBasicBlock *MBB, MachineBasicBlock::iterator Begin, MachineBasicBlock::iterator End)
Repair indexes after adding and removing instructions.
MachineInstr * getBundleStart(MachineInstr *MI)
getBundleStart - Returns the first instruction in the bundle containing MI.
void getAnalysisUsage(AnalysisUsage &au) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
SlotIndex getNextIndex() const
Returns the next index.
void print(raw_ostream &os) const
Print this index to the given raw_ostream.
Representation of each machine instruction.
bundle_iterator< const MachineInstr, const_instr_iterator > const_iterator
void replaceMachineInstrInMaps(MachineInstr *mi, MachineInstr *newMI)
ReplaceMachineInstrInMaps - Replacing a machine instr with a new one in maps used by register allocat...
This class represents an entry in the slot index list held in the SlotIndexes pass.
bool runOnMachineFunction(MachineFunction &fn) override
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
ilist_node - Base class that provides next/prev services for nodes that use ilist_nextprev_traits or ...
void releaseMemory() override
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
IndexListEntry * ensureHead(IndexListEntry *) const
void dump() const
Dump this index to stderr.
SlotIndex()
Construct an invalid index.
iterator find(const KeyT &Val)
void removeMachineInstrFromMaps(MachineInstr *mi)
Remove the given machine instruction from the mapping.
SlotIndex getMBBStartIdx(unsigned Num) const
Returns the first index in the given basic block number.
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
SlotIndex getRegSlot(bool EC=false) const
Returns the register use/def slot in the current instruction for a normal or early-clobber def...
static NodeTy * createSentinel()
createSentinel - create the dynamic sentinel
IndexListEntry * createSentinel() const
bool operator<(int64_t V1, const APSInt &V2)
const std::pair< SlotIndex, SlotIndex > & getMBBRange(const MachineBasicBlock *MBB) const
Return the (start,end) range of the given basic block.
BasicBlockListType::iterator iterator
This class implements an extremely fast bulk output stream that can only output to a stream...
SlotIndex getMBBStartIdx(const MachineBasicBlock *mbb) const
Returns the first index in the given basic block.
SlotIndex getNextSlot() const
Returns the next slot in the index list.
SlotIndex - An opaque wrapper around machine indexes.
SlotIndex insertMachineInstrInMaps(MachineInstr *mi, bool Late=false)
Insert the given machine instruction into the mapping.
NodeTy * remove(iterator &IT)
const std::pair< SlotIndex, SlotIndex > & getMBBRange(unsigned Num) const
Return the (start,end) range of the given basic block number.