This is a little embarrassing.
When I reverted r261504 (getIterator() => getInstrIterator()) in
r261567, I did a `git grep` to see if there were new calls to
`getInstrIterator()` that I needed to migrate. There were 10-20 hits,
and I blindly did a `sed ...` before calling `ninja check`.
However, these were `MachineInstrBundleIterator::getInstrIterator()`,
which predated r261567. Perhaps coincidentally, these had an identical
name and return type.
This commit undoes my careless sed and restores
`MachineBasicBlock::iterator::getInstrIterator()`.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@261577
91177308-0d34-0410-b5e6-
96231b3b80d8
void insert(iterator I, IT S, IT E) {
assert((I == end() || I->getParent() == this) &&
"iterator points outside of basic block");
- Insts.insert(I.getIterator(), S, E);
+ Insts.insert(I.getInstrIterator(), S, E);
}
/// Insert MI into the instruction list before I.
"iterator points outside of basic block");
assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
"Cannot insert instruction with bundle flags");
- return Insts.insert(I.getIterator(), MI);
+ return Insts.insert(I.getInstrIterator(), MI);
}
/// Insert MI into the instruction list after I.
"iterator points outside of basic block");
assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
"Cannot insert instruction with bundle flags");
- return Insts.insertAfter(I.getIterator(), MI);
+ return Insts.insertAfter(I.getInstrIterator(), MI);
}
/// Remove an instruction from the instruction list and delete it.
/// Remove a range of instructions from the instruction list and delete them.
iterator erase(iterator I, iterator E) {
- return Insts.erase(I.getIterator(), E.getIterator());
+ return Insts.erase(I.getInstrIterator(), E.getInstrIterator());
}
/// Remove an instruction or bundle from the instruction list and delete it.
/// instructions to move.
void splice(iterator Where, MachineBasicBlock *Other,
iterator From, iterator To) {
- Insts.splice(Where.getIterator(), Other->Insts, From.getIterator(),
- To.getIterator());
+ Insts.splice(Where.getInstrIterator(), Other->Insts,
+ From.getInstrIterator(), To.getInstrIterator());
}
/// This method unlinks 'this' from the containing function, and returns it,
/// instructions. Return UnknownLoc if there is none.
DebugLoc findDebugLoc(instr_iterator MBBI);
DebugLoc findDebugLoc(iterator MBBI) {
- return findDebugLoc(MBBI.getIterator());
+ return findDebugLoc(MBBI.getInstrIterator());
}
/// Possible outcome of a register liveness query to computeRegisterLiveness()
/// Create an MIBundleBuilder that inserts instructions into a new bundle in
/// BB above the bundle or instruction at Pos.
MIBundleBuilder(MachineBasicBlock &BB, MachineBasicBlock::iterator Pos)
- : MBB(BB), Begin(Pos.getIterator()), End(Begin) {}
+ : MBB(BB), Begin(Pos.getInstrIterator()), End(Begin) {}
/// Create a bundle from the sequence of instructions between B and E.
MIBundleBuilder(MachineBasicBlock &BB, MachineBasicBlock::iterator B,
MachineBasicBlock::iterator E)
- : MBB(BB), Begin(B.getIterator()), End(E.getIterator()) {
+ : MBB(BB), Begin(B.getInstrIterator()), End(E.getInstrIterator()) {
assert(B != E && "No instructions to bundle");
++B;
while (B != E) {
// Template allows conversion from const to nonconst.
template <class OtherTy>
MachineInstrBundleIterator(const MachineInstrBundleIterator<OtherTy> &I)
- : MII(I.getIterator()) {}
+ : MII(I.getInstrIterator()) {}
MachineInstrBundleIterator() : MII(nullptr) {}
Ty &operator*() const { return *MII; }
return Temp;
}
- instr_iterator getIterator() const { return MII; }
+ instr_iterator getInstrIterator() const { return MII; }
};
} // end namespace llvm
std::vector<int64_t> Literals;
if (I->isBundle()) {
MachineInstr *DeleteMI = I;
- MachineBasicBlock::instr_iterator BI = I.getIterator();
+ MachineBasicBlock::instr_iterator BI = I.getInstrIterator();
while (++BI != E && BI->isBundledWithPred()) {
BI->unbundleFromPred();
for (unsigned i = 0, e = BI->getNumOperands(); i != e; ++i) {
I--;
if (!TII->isALUInstr(I->getOpcode()) && !I->isBundle())
return Result;
- MachineBasicBlock::instr_iterator BI = I.getIterator();
+ MachineBasicBlock::instr_iterator BI = I.getInstrIterator();
if (I->isBundle())
BI++;
int LastDstChan = -1;
Dist = 0;
MachineBasicBlock::const_iterator I = MI; ++I;
- MachineBasicBlock::const_instr_iterator II = std::prev(I.getIterator());
+ MachineBasicBlock::const_instr_iterator II = std::prev(I.getInstrIterator());
assert(II->isInsideBundle() && "Empty bundle?");
int Idx = -1;
LastITMI->findRegisterUseOperand(ARM::ITSTATE)->setIsKill();
// Finalize the bundle.
- finalizeBundle(MBB, InsertPos.getIterator(), ++LastITMI->getIterator());
+ finalizeBundle(MBB, InsertPos.getInstrIterator(),
+ ++LastITMI->getIterator());
Modified = true;
++NumITs;
if (!It->isBundle())
return It->getOpcode() == Hexagon::S2_allocframe;
auto End = It->getParent()->instr_end();
- MachineBasicBlock::const_instr_iterator I = It.getIterator();
+ MachineBasicBlock::const_instr_iterator I = It.getInstrIterator();
while (++I != End && I->isBundled())
if (I->getOpcode() == Hexagon::S2_allocframe)
return true;
unsigned HexagonInstrInfo::nonDbgBundleSize(
MachineBasicBlock::const_iterator BundleHead) const {
assert(BundleHead->isBundle() && "Not a bundle header");
- auto MII = BundleHead.getIterator();
+ auto MII = BundleHead.getInstrIterator();
// Skip the bundle header.
return nonDbgMICount(++MII, getBundleEnd(BundleHead));
}
MachineBasicBlock::iterator BundleIt, bool Before) {
MachineBasicBlock::instr_iterator InsertPt;
if (Before)
- InsertPt = BundleIt.getIterator();
+ InsertPt = BundleIt.getInstrIterator();
else
- InsertPt = std::next(BundleIt).getIterator();
+ InsertPt = std::next(BundleIt).getInstrIterator();
MachineBasicBlock &B = *MI->getParent();
// The instruction should at least be bundled with the preceding instruction