2016-03-28 21:09:54 +08:00
|
|
|
//===-- LanaiDelaySlotFiller.cpp - Lanai delay slot filler ----------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// Simple pass to fills delay slots with useful instructions.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "Lanai.h"
|
|
|
|
#include "LanaiTargetMachine.h"
|
|
|
|
#include "llvm/ADT/SmallSet.h"
|
|
|
|
#include "llvm/ADT/Statistic.h"
|
|
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
|
|
|
#include "llvm/CodeGen/MachineInstrBuilder.h"
|
|
|
|
#include "llvm/Support/CommandLine.h"
|
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
#define DEBUG_TYPE "delay-slot-filler"
|
|
|
|
|
|
|
|
STATISTIC(FilledSlots, "Number of delay slots filled");
|
|
|
|
|
|
|
|
static cl::opt<bool>
|
|
|
|
NopDelaySlotFiller("lanai-nop-delay-filler", cl::init(false),
|
|
|
|
cl::desc("Fill Lanai delay slots with NOPs."),
|
|
|
|
cl::Hidden);
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
struct Filler : public MachineFunctionPass {
|
|
|
|
// Target machine description which we query for reg. names, data
|
|
|
|
// layout, etc.
|
|
|
|
const TargetInstrInfo *TII;
|
|
|
|
const TargetRegisterInfo *TRI;
|
|
|
|
MachineBasicBlock::instr_iterator LastFiller;
|
|
|
|
|
|
|
|
static char ID;
|
|
|
|
explicit Filler() : MachineFunctionPass(ID) {}
|
|
|
|
|
2016-10-01 10:56:57 +08:00
|
|
|
StringRef getPassName() const override { return "Lanai Delay Slot Filler"; }
|
2016-03-28 21:09:54 +08:00
|
|
|
|
|
|
|
bool runOnMachineBasicBlock(MachineBasicBlock &MBB);
|
|
|
|
|
|
|
|
bool runOnMachineFunction(MachineFunction &MF) override {
|
|
|
|
const LanaiSubtarget &Subtarget = MF.getSubtarget<LanaiSubtarget>();
|
|
|
|
TII = Subtarget.getInstrInfo();
|
|
|
|
TRI = Subtarget.getRegisterInfo();
|
|
|
|
|
|
|
|
bool Changed = false;
|
|
|
|
for (MachineFunction::iterator FI = MF.begin(), FE = MF.end(); FI != FE;
|
|
|
|
++FI)
|
|
|
|
Changed |= runOnMachineBasicBlock(*FI);
|
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
2016-04-05 01:09:25 +08:00
|
|
|
MachineFunctionProperties getRequiredProperties() const override {
|
|
|
|
return MachineFunctionProperties().set(
|
2016-08-25 09:27:13 +08:00
|
|
|
MachineFunctionProperties::Property::NoVRegs);
|
2016-04-05 01:09:25 +08:00
|
|
|
}
|
|
|
|
|
2016-03-28 21:09:54 +08:00
|
|
|
void insertDefsUses(MachineBasicBlock::instr_iterator MI,
|
|
|
|
SmallSet<unsigned, 32> &RegDefs,
|
|
|
|
SmallSet<unsigned, 32> &RegUses);
|
|
|
|
|
|
|
|
bool isRegInSet(SmallSet<unsigned, 32> &RegSet, unsigned Reg);
|
|
|
|
|
|
|
|
bool delayHasHazard(MachineBasicBlock::instr_iterator MI, bool &SawLoad,
|
|
|
|
bool &SawStore, SmallSet<unsigned, 32> &RegDefs,
|
|
|
|
SmallSet<unsigned, 32> &RegUses);
|
|
|
|
|
|
|
|
bool findDelayInstr(MachineBasicBlock &MBB,
|
|
|
|
MachineBasicBlock::instr_iterator Slot,
|
|
|
|
MachineBasicBlock::instr_iterator &Filler);
|
|
|
|
};
|
|
|
|
char Filler::ID = 0;
|
|
|
|
} // end of anonymous namespace
|
|
|
|
|
|
|
|
// createLanaiDelaySlotFillerPass - Returns a pass that fills in delay
|
|
|
|
// slots in Lanai MachineFunctions
|
|
|
|
FunctionPass *
|
2016-07-16 06:38:32 +08:00
|
|
|
llvm::createLanaiDelaySlotFillerPass(const LanaiTargetMachine & /*tm*/) {
|
2016-03-28 21:09:54 +08:00
|
|
|
return new Filler();
|
|
|
|
}
|
|
|
|
|
|
|
|
// runOnMachineBasicBlock - Fill in delay slots for the given basic block.
|
|
|
|
// There is one or two delay slot per delayed instruction.
|
|
|
|
bool Filler::runOnMachineBasicBlock(MachineBasicBlock &MBB) {
|
|
|
|
bool Changed = false;
|
|
|
|
LastFiller = MBB.instr_end();
|
|
|
|
|
|
|
|
for (MachineBasicBlock::instr_iterator I = MBB.instr_begin();
|
|
|
|
I != MBB.instr_end(); ++I) {
|
|
|
|
if (I->getDesc().hasDelaySlot()) {
|
|
|
|
MachineBasicBlock::instr_iterator InstrWithSlot = I;
|
|
|
|
MachineBasicBlock::instr_iterator J = I;
|
|
|
|
|
|
|
|
// Treat RET specially as it is only instruction with 2 delay slots
|
|
|
|
// generated while all others generated have 1 delay slot.
|
|
|
|
if (I->getOpcode() == Lanai::RET) {
|
|
|
|
// RET is generated as part of epilogue generation and hence we know
|
|
|
|
// what the two instructions preceding it are and that it is safe to
|
|
|
|
// insert RET above them.
|
ADT: Give ilist<T>::reverse_iterator a handle to the current node
Reverse iterators to doubly-linked lists can be simpler (and cheaper)
than std::reverse_iterator. Make it so.
In particular, change ilist<T>::reverse_iterator so that it is *never*
invalidated unless the node it references is deleted. This matches the
guarantees of ilist<T>::iterator.
(Note: MachineBasicBlock::iterator is *not* an ilist iterator, but a
MachineInstrBundleIterator<MachineInstr>. This commit does not change
MachineBasicBlock::reverse_iterator, but it does update
MachineBasicBlock::reverse_instr_iterator. See note at end of commit
message for details on bundle iterators.)
Given the list (with the Sentinel showing twice for simplicity):
[Sentinel] <-> A <-> B <-> [Sentinel]
the following is now true:
1. begin() represents A.
2. begin() holds the pointer for A.
3. end() represents [Sentinel].
4. end() holds the poitner for [Sentinel].
5. rbegin() represents B.
6. rbegin() holds the pointer for B.
7. rend() represents [Sentinel].
8. rend() holds the pointer for [Sentinel].
The changes are #6 and #8. Here are some properties from the old
scheme (which used std::reverse_iterator):
- rbegin() held the pointer for [Sentinel] and rend() held the pointer
for A;
- operator*() cost two dereferences instead of one;
- converting from a valid iterator to its valid reverse_iterator
involved a confusing increment; and
- "RI++->erase()" left RI invalid. The unintuitive replacement was
"RI->erase(), RE = end()".
With vector-like data structures these properties are hard to avoid
(since past-the-beginning is not a valid pointer), and don't impose a
real cost (since there's still only one dereference, and all iterators
are invalidated on erase). But with lists, this was a poor design.
Specifically, the following code (which obviously works with normal
iterators) now works with ilist::reverse_iterator as well:
for (auto RI = L.rbegin(), RE = L.rend(); RI != RE;)
fooThatMightRemoveArgFromList(*RI++);
Converting between iterator and reverse_iterator for the same node uses
the getReverse() function.
reverse_iterator iterator::getReverse();
iterator reverse_iterator::getReverse();
Why doesn't iterator <=> reverse_iterator conversion use constructors?
In order to catch and update old code, reverse_iterator does not even
have an explicit conversion from iterator. It wouldn't be safe because
there would be no reasonable way to catch all the bugs from the changed
semantic (see the changes at call sites that are part of this patch).
Old code used this API:
std::reverse_iterator::reverse_iterator(iterator);
iterator std::reverse_iterator::base();
Here's how to update from old code to new (that incorporates the
semantic change), assuming I is an ilist<>::iterator and RI is an
ilist<>::reverse_iterator:
[Old] ==> [New]
reverse_iterator(I) (--I).getReverse()
reverse_iterator(I) ++I.getReverse()
--reverse_iterator(I) I.getReverse()
reverse_iterator(++I) I.getReverse()
RI.base() (--RI).getReverse()
RI.base() ++RI.getReverse()
--RI.base() RI.getReverse()
(++RI).base() RI.getReverse()
delete &*RI, RE = end() delete &*RI++
RI->erase(), RE = end() RI++->erase()
=======================================
Note: bundle iterators are out of scope
=======================================
MachineBasicBlock::iterator, also known as
MachineInstrBundleIterator<MachineInstr>, is a wrapper to represent
MachineInstr bundles. The idea is that each operator++ takes you to the
beginning of the next bundle. Implementing a sane reverse iterator for
this is harder than ilist. Here are the options:
- Use std::reverse_iterator<MBB::i>. Store a handle to the beginning of
the next bundle. A call to operator*() runs a loop (usually
operator--() will be called 1 time, for unbundled instructions).
Increment/decrement just works. This is the status quo.
- Store a handle to the final node in the bundle. A call to operator*()
still runs a loop, but it iterates one time fewer (usually
operator--() will be called 0 times, for unbundled instructions).
Increment/decrement just works.
- Make the ilist_sentinel<MachineInstr> *always* store that it's the
sentinel (instead of just in asserts mode). Then the bundle iterator
can sniff the sentinel bit in operator++().
I initially tried implementing the end() option as part of this commit,
but updating iterator/reverse_iterator conversion call sites was
error-prone. I have a WIP series of patches that implements the final
option.
llvm-svn: 280032
2016-08-30 08:13:12 +08:00
|
|
|
MachineBasicBlock::reverse_instr_iterator RI = ++I.getReverse();
|
2016-03-28 21:09:54 +08:00
|
|
|
assert(RI->getOpcode() == Lanai::LDW_RI && RI->getOperand(0).isReg() &&
|
|
|
|
RI->getOperand(0).getReg() == Lanai::FP &&
|
|
|
|
RI->getOperand(1).isReg() &&
|
|
|
|
RI->getOperand(1).getReg() == Lanai::FP &&
|
|
|
|
RI->getOperand(2).isImm() && RI->getOperand(2).getImm() == -8);
|
|
|
|
++RI;
|
|
|
|
assert(RI->getOpcode() == Lanai::ADD_I_LO &&
|
|
|
|
RI->getOperand(0).isReg() &&
|
|
|
|
RI->getOperand(0).getReg() == Lanai::SP &&
|
|
|
|
RI->getOperand(1).isReg() &&
|
|
|
|
RI->getOperand(1).getReg() == Lanai::FP);
|
ADT: Give ilist<T>::reverse_iterator a handle to the current node
Reverse iterators to doubly-linked lists can be simpler (and cheaper)
than std::reverse_iterator. Make it so.
In particular, change ilist<T>::reverse_iterator so that it is *never*
invalidated unless the node it references is deleted. This matches the
guarantees of ilist<T>::iterator.
(Note: MachineBasicBlock::iterator is *not* an ilist iterator, but a
MachineInstrBundleIterator<MachineInstr>. This commit does not change
MachineBasicBlock::reverse_iterator, but it does update
MachineBasicBlock::reverse_instr_iterator. See note at end of commit
message for details on bundle iterators.)
Given the list (with the Sentinel showing twice for simplicity):
[Sentinel] <-> A <-> B <-> [Sentinel]
the following is now true:
1. begin() represents A.
2. begin() holds the pointer for A.
3. end() represents [Sentinel].
4. end() holds the poitner for [Sentinel].
5. rbegin() represents B.
6. rbegin() holds the pointer for B.
7. rend() represents [Sentinel].
8. rend() holds the pointer for [Sentinel].
The changes are #6 and #8. Here are some properties from the old
scheme (which used std::reverse_iterator):
- rbegin() held the pointer for [Sentinel] and rend() held the pointer
for A;
- operator*() cost two dereferences instead of one;
- converting from a valid iterator to its valid reverse_iterator
involved a confusing increment; and
- "RI++->erase()" left RI invalid. The unintuitive replacement was
"RI->erase(), RE = end()".
With vector-like data structures these properties are hard to avoid
(since past-the-beginning is not a valid pointer), and don't impose a
real cost (since there's still only one dereference, and all iterators
are invalidated on erase). But with lists, this was a poor design.
Specifically, the following code (which obviously works with normal
iterators) now works with ilist::reverse_iterator as well:
for (auto RI = L.rbegin(), RE = L.rend(); RI != RE;)
fooThatMightRemoveArgFromList(*RI++);
Converting between iterator and reverse_iterator for the same node uses
the getReverse() function.
reverse_iterator iterator::getReverse();
iterator reverse_iterator::getReverse();
Why doesn't iterator <=> reverse_iterator conversion use constructors?
In order to catch and update old code, reverse_iterator does not even
have an explicit conversion from iterator. It wouldn't be safe because
there would be no reasonable way to catch all the bugs from the changed
semantic (see the changes at call sites that are part of this patch).
Old code used this API:
std::reverse_iterator::reverse_iterator(iterator);
iterator std::reverse_iterator::base();
Here's how to update from old code to new (that incorporates the
semantic change), assuming I is an ilist<>::iterator and RI is an
ilist<>::reverse_iterator:
[Old] ==> [New]
reverse_iterator(I) (--I).getReverse()
reverse_iterator(I) ++I.getReverse()
--reverse_iterator(I) I.getReverse()
reverse_iterator(++I) I.getReverse()
RI.base() (--RI).getReverse()
RI.base() ++RI.getReverse()
--RI.base() RI.getReverse()
(++RI).base() RI.getReverse()
delete &*RI, RE = end() delete &*RI++
RI->erase(), RE = end() RI++->erase()
=======================================
Note: bundle iterators are out of scope
=======================================
MachineBasicBlock::iterator, also known as
MachineInstrBundleIterator<MachineInstr>, is a wrapper to represent
MachineInstr bundles. The idea is that each operator++ takes you to the
beginning of the next bundle. Implementing a sane reverse iterator for
this is harder than ilist. Here are the options:
- Use std::reverse_iterator<MBB::i>. Store a handle to the beginning of
the next bundle. A call to operator*() runs a loop (usually
operator--() will be called 1 time, for unbundled instructions).
Increment/decrement just works. This is the status quo.
- Store a handle to the final node in the bundle. A call to operator*()
still runs a loop, but it iterates one time fewer (usually
operator--() will be called 0 times, for unbundled instructions).
Increment/decrement just works.
- Make the ilist_sentinel<MachineInstr> *always* store that it's the
sentinel (instead of just in asserts mode). Then the bundle iterator
can sniff the sentinel bit in operator++().
I initially tried implementing the end() option as part of this commit,
but updating iterator/reverse_iterator conversion call sites was
error-prone. I have a WIP series of patches that implements the final
option.
llvm-svn: 280032
2016-08-30 08:13:12 +08:00
|
|
|
MachineBasicBlock::instr_iterator FI = RI.getReverse();
|
2016-03-28 21:09:54 +08:00
|
|
|
MBB.splice(std::next(I), &MBB, FI, I);
|
|
|
|
FilledSlots += 2;
|
|
|
|
} else {
|
|
|
|
if (!NopDelaySlotFiller && findDelayInstr(MBB, I, J)) {
|
|
|
|
MBB.splice(std::next(I), &MBB, J);
|
|
|
|
} else {
|
|
|
|
BuildMI(MBB, std::next(I), DebugLoc(), TII->get(Lanai::NOP));
|
|
|
|
}
|
|
|
|
++FilledSlots;
|
|
|
|
}
|
|
|
|
|
|
|
|
Changed = true;
|
|
|
|
// Record the filler instruction that filled the delay slot.
|
|
|
|
// The instruction after it will be visited in the next iteration.
|
|
|
|
LastFiller = ++I;
|
|
|
|
|
|
|
|
// Bundle the delay slot filler to InstrWithSlot so that the machine
|
|
|
|
// verifier doesn't expect this instruction to be a terminator.
|
|
|
|
MIBundleBuilder(MBB, InstrWithSlot, std::next(LastFiller));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Filler::findDelayInstr(MachineBasicBlock &MBB,
|
|
|
|
MachineBasicBlock::instr_iterator Slot,
|
|
|
|
MachineBasicBlock::instr_iterator &Filler) {
|
|
|
|
SmallSet<unsigned, 32> RegDefs;
|
|
|
|
SmallSet<unsigned, 32> RegUses;
|
|
|
|
|
|
|
|
insertDefsUses(Slot, RegDefs, RegUses);
|
|
|
|
|
|
|
|
bool SawLoad = false;
|
|
|
|
bool SawStore = false;
|
|
|
|
|
ADT: Give ilist<T>::reverse_iterator a handle to the current node
Reverse iterators to doubly-linked lists can be simpler (and cheaper)
than std::reverse_iterator. Make it so.
In particular, change ilist<T>::reverse_iterator so that it is *never*
invalidated unless the node it references is deleted. This matches the
guarantees of ilist<T>::iterator.
(Note: MachineBasicBlock::iterator is *not* an ilist iterator, but a
MachineInstrBundleIterator<MachineInstr>. This commit does not change
MachineBasicBlock::reverse_iterator, but it does update
MachineBasicBlock::reverse_instr_iterator. See note at end of commit
message for details on bundle iterators.)
Given the list (with the Sentinel showing twice for simplicity):
[Sentinel] <-> A <-> B <-> [Sentinel]
the following is now true:
1. begin() represents A.
2. begin() holds the pointer for A.
3. end() represents [Sentinel].
4. end() holds the poitner for [Sentinel].
5. rbegin() represents B.
6. rbegin() holds the pointer for B.
7. rend() represents [Sentinel].
8. rend() holds the pointer for [Sentinel].
The changes are #6 and #8. Here are some properties from the old
scheme (which used std::reverse_iterator):
- rbegin() held the pointer for [Sentinel] and rend() held the pointer
for A;
- operator*() cost two dereferences instead of one;
- converting from a valid iterator to its valid reverse_iterator
involved a confusing increment; and
- "RI++->erase()" left RI invalid. The unintuitive replacement was
"RI->erase(), RE = end()".
With vector-like data structures these properties are hard to avoid
(since past-the-beginning is not a valid pointer), and don't impose a
real cost (since there's still only one dereference, and all iterators
are invalidated on erase). But with lists, this was a poor design.
Specifically, the following code (which obviously works with normal
iterators) now works with ilist::reverse_iterator as well:
for (auto RI = L.rbegin(), RE = L.rend(); RI != RE;)
fooThatMightRemoveArgFromList(*RI++);
Converting between iterator and reverse_iterator for the same node uses
the getReverse() function.
reverse_iterator iterator::getReverse();
iterator reverse_iterator::getReverse();
Why doesn't iterator <=> reverse_iterator conversion use constructors?
In order to catch and update old code, reverse_iterator does not even
have an explicit conversion from iterator. It wouldn't be safe because
there would be no reasonable way to catch all the bugs from the changed
semantic (see the changes at call sites that are part of this patch).
Old code used this API:
std::reverse_iterator::reverse_iterator(iterator);
iterator std::reverse_iterator::base();
Here's how to update from old code to new (that incorporates the
semantic change), assuming I is an ilist<>::iterator and RI is an
ilist<>::reverse_iterator:
[Old] ==> [New]
reverse_iterator(I) (--I).getReverse()
reverse_iterator(I) ++I.getReverse()
--reverse_iterator(I) I.getReverse()
reverse_iterator(++I) I.getReverse()
RI.base() (--RI).getReverse()
RI.base() ++RI.getReverse()
--RI.base() RI.getReverse()
(++RI).base() RI.getReverse()
delete &*RI, RE = end() delete &*RI++
RI->erase(), RE = end() RI++->erase()
=======================================
Note: bundle iterators are out of scope
=======================================
MachineBasicBlock::iterator, also known as
MachineInstrBundleIterator<MachineInstr>, is a wrapper to represent
MachineInstr bundles. The idea is that each operator++ takes you to the
beginning of the next bundle. Implementing a sane reverse iterator for
this is harder than ilist. Here are the options:
- Use std::reverse_iterator<MBB::i>. Store a handle to the beginning of
the next bundle. A call to operator*() runs a loop (usually
operator--() will be called 1 time, for unbundled instructions).
Increment/decrement just works. This is the status quo.
- Store a handle to the final node in the bundle. A call to operator*()
still runs a loop, but it iterates one time fewer (usually
operator--() will be called 0 times, for unbundled instructions).
Increment/decrement just works.
- Make the ilist_sentinel<MachineInstr> *always* store that it's the
sentinel (instead of just in asserts mode). Then the bundle iterator
can sniff the sentinel bit in operator++().
I initially tried implementing the end() option as part of this commit,
but updating iterator/reverse_iterator conversion call sites was
error-prone. I have a WIP series of patches that implements the final
option.
llvm-svn: 280032
2016-08-30 08:13:12 +08:00
|
|
|
for (MachineBasicBlock::reverse_instr_iterator I = ++Slot.getReverse();
|
|
|
|
I != MBB.instr_rend(); ++I) {
|
2016-03-28 21:09:54 +08:00
|
|
|
// skip debug value
|
|
|
|
if (I->isDebugValue())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Convert to forward iterator.
|
ADT: Give ilist<T>::reverse_iterator a handle to the current node
Reverse iterators to doubly-linked lists can be simpler (and cheaper)
than std::reverse_iterator. Make it so.
In particular, change ilist<T>::reverse_iterator so that it is *never*
invalidated unless the node it references is deleted. This matches the
guarantees of ilist<T>::iterator.
(Note: MachineBasicBlock::iterator is *not* an ilist iterator, but a
MachineInstrBundleIterator<MachineInstr>. This commit does not change
MachineBasicBlock::reverse_iterator, but it does update
MachineBasicBlock::reverse_instr_iterator. See note at end of commit
message for details on bundle iterators.)
Given the list (with the Sentinel showing twice for simplicity):
[Sentinel] <-> A <-> B <-> [Sentinel]
the following is now true:
1. begin() represents A.
2. begin() holds the pointer for A.
3. end() represents [Sentinel].
4. end() holds the poitner for [Sentinel].
5. rbegin() represents B.
6. rbegin() holds the pointer for B.
7. rend() represents [Sentinel].
8. rend() holds the pointer for [Sentinel].
The changes are #6 and #8. Here are some properties from the old
scheme (which used std::reverse_iterator):
- rbegin() held the pointer for [Sentinel] and rend() held the pointer
for A;
- operator*() cost two dereferences instead of one;
- converting from a valid iterator to its valid reverse_iterator
involved a confusing increment; and
- "RI++->erase()" left RI invalid. The unintuitive replacement was
"RI->erase(), RE = end()".
With vector-like data structures these properties are hard to avoid
(since past-the-beginning is not a valid pointer), and don't impose a
real cost (since there's still only one dereference, and all iterators
are invalidated on erase). But with lists, this was a poor design.
Specifically, the following code (which obviously works with normal
iterators) now works with ilist::reverse_iterator as well:
for (auto RI = L.rbegin(), RE = L.rend(); RI != RE;)
fooThatMightRemoveArgFromList(*RI++);
Converting between iterator and reverse_iterator for the same node uses
the getReverse() function.
reverse_iterator iterator::getReverse();
iterator reverse_iterator::getReverse();
Why doesn't iterator <=> reverse_iterator conversion use constructors?
In order to catch and update old code, reverse_iterator does not even
have an explicit conversion from iterator. It wouldn't be safe because
there would be no reasonable way to catch all the bugs from the changed
semantic (see the changes at call sites that are part of this patch).
Old code used this API:
std::reverse_iterator::reverse_iterator(iterator);
iterator std::reverse_iterator::base();
Here's how to update from old code to new (that incorporates the
semantic change), assuming I is an ilist<>::iterator and RI is an
ilist<>::reverse_iterator:
[Old] ==> [New]
reverse_iterator(I) (--I).getReverse()
reverse_iterator(I) ++I.getReverse()
--reverse_iterator(I) I.getReverse()
reverse_iterator(++I) I.getReverse()
RI.base() (--RI).getReverse()
RI.base() ++RI.getReverse()
--RI.base() RI.getReverse()
(++RI).base() RI.getReverse()
delete &*RI, RE = end() delete &*RI++
RI->erase(), RE = end() RI++->erase()
=======================================
Note: bundle iterators are out of scope
=======================================
MachineBasicBlock::iterator, also known as
MachineInstrBundleIterator<MachineInstr>, is a wrapper to represent
MachineInstr bundles. The idea is that each operator++ takes you to the
beginning of the next bundle. Implementing a sane reverse iterator for
this is harder than ilist. Here are the options:
- Use std::reverse_iterator<MBB::i>. Store a handle to the beginning of
the next bundle. A call to operator*() runs a loop (usually
operator--() will be called 1 time, for unbundled instructions).
Increment/decrement just works. This is the status quo.
- Store a handle to the final node in the bundle. A call to operator*()
still runs a loop, but it iterates one time fewer (usually
operator--() will be called 0 times, for unbundled instructions).
Increment/decrement just works.
- Make the ilist_sentinel<MachineInstr> *always* store that it's the
sentinel (instead of just in asserts mode). Then the bundle iterator
can sniff the sentinel bit in operator++().
I initially tried implementing the end() option as part of this commit,
but updating iterator/reverse_iterator conversion call sites was
error-prone. I have a WIP series of patches that implements the final
option.
llvm-svn: 280032
2016-08-30 08:13:12 +08:00
|
|
|
MachineBasicBlock::instr_iterator FI = I.getReverse();
|
2016-03-28 21:09:54 +08:00
|
|
|
|
|
|
|
if (I->hasUnmodeledSideEffects() || I->isInlineAsm() || I->isLabel() ||
|
|
|
|
FI == LastFiller || I->isPseudo())
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (delayHasHazard(FI, SawLoad, SawStore, RegDefs, RegUses)) {
|
|
|
|
insertDefsUses(FI, RegDefs, RegUses);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
Filler = FI;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Filler::delayHasHazard(MachineBasicBlock::instr_iterator MI, bool &SawLoad,
|
|
|
|
bool &SawStore, SmallSet<unsigned, 32> &RegDefs,
|
|
|
|
SmallSet<unsigned, 32> &RegUses) {
|
|
|
|
if (MI->isImplicitDef() || MI->isKill())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Loads or stores cannot be moved past a store to the delay slot
|
|
|
|
// and stores cannot be moved past a load.
|
|
|
|
if (MI->mayLoad()) {
|
|
|
|
if (SawStore)
|
|
|
|
return true;
|
|
|
|
SawLoad = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (MI->mayStore()) {
|
|
|
|
if (SawStore)
|
|
|
|
return true;
|
|
|
|
SawStore = true;
|
|
|
|
if (SawLoad)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert((!MI->isCall() && !MI->isReturn()) &&
|
|
|
|
"Cannot put calls or returns in delay slot.");
|
|
|
|
|
|
|
|
for (unsigned I = 0, E = MI->getNumOperands(); I != E; ++I) {
|
|
|
|
const MachineOperand &MO = MI->getOperand(I);
|
|
|
|
unsigned Reg;
|
|
|
|
|
|
|
|
if (!MO.isReg() || !(Reg = MO.getReg()))
|
|
|
|
continue; // skip
|
|
|
|
|
|
|
|
if (MO.isDef()) {
|
|
|
|
// check whether Reg is defined or used before delay slot.
|
|
|
|
if (isRegInSet(RegDefs, Reg) || isRegInSet(RegUses, Reg))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (MO.isUse()) {
|
|
|
|
// check whether Reg is defined before delay slot.
|
|
|
|
if (isRegInSet(RegDefs, Reg))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Insert Defs and Uses of MI into the sets RegDefs and RegUses.
|
|
|
|
void Filler::insertDefsUses(MachineBasicBlock::instr_iterator MI,
|
|
|
|
SmallSet<unsigned, 32> &RegDefs,
|
|
|
|
SmallSet<unsigned, 32> &RegUses) {
|
|
|
|
// If MI is a call or return, just examine the explicit non-variadic operands.
|
|
|
|
MCInstrDesc MCID = MI->getDesc();
|
|
|
|
unsigned E = MI->isCall() || MI->isReturn() ? MCID.getNumOperands()
|
|
|
|
: MI->getNumOperands();
|
|
|
|
for (unsigned I = 0; I != E; ++I) {
|
|
|
|
const MachineOperand &MO = MI->getOperand(I);
|
|
|
|
unsigned Reg;
|
|
|
|
|
|
|
|
if (!MO.isReg() || !(Reg = MO.getReg()))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (MO.isDef())
|
|
|
|
RegDefs.insert(Reg);
|
|
|
|
else if (MO.isUse())
|
|
|
|
RegUses.insert(Reg);
|
|
|
|
}
|
2016-04-03 08:49:27 +08:00
|
|
|
|
|
|
|
// Call & return instructions defines SP implicitly. Implicit defines are not
|
|
|
|
// included in the RegDefs set of calls but instructions modifying SP cannot
|
|
|
|
// be inserted in the delay slot of a call/return as these instructions are
|
|
|
|
// expanded to multiple instructions with SP modified before the branch that
|
|
|
|
// has the delay slot.
|
2016-05-21 05:41:53 +08:00
|
|
|
if (MI->isCall() || MI->isReturn())
|
|
|
|
RegDefs.insert(Lanai::SP);
|
2016-03-28 21:09:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true if the Reg or its alias is in the RegSet.
|
|
|
|
bool Filler::isRegInSet(SmallSet<unsigned, 32> &RegSet, unsigned Reg) {
|
|
|
|
// Check Reg and all aliased Registers.
|
|
|
|
for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI)
|
|
|
|
if (RegSet.count(*AI))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|