CbC/CbC_llvm: lib/Target/Mips/MipsConstantIslandPass.cpp comparison

comparison lib/Target/Mips/MipsConstantIslandPass.cpp @ 100:7d135dc70f03 LLVM 3.9

LLVM 3.9

author	Miyagi Mitsuki <e135756@ie.u-ryukyu.ac.jp>
date	Tue, 26 Jan 2016 22:53:40 +0900
parents	afa8332a0e37
children	1172e4bd9c6f

comparison

equal deleted inserted replaced

-:6418606d0ead
+:7d135dc70f03
 /// BBHasFallthrough - Return true if the specified basic block can fallthrough
 /// into the block immediately after it.
 static bool BBHasFallthrough(MachineBasicBlock *MBB) {
 // Get the next machine basic block in the function.
-MachineFunction::iterator MBBI = MBB;
+MachineFunction::iterator MBBI = MBB->getIterator();
 // Can't fall off end of function.
 if (std::next(MBBI) == MBB->getParent()->end())
 return false;
-MachineBasicBlock *NextBB = std::next(MBBI);
+MachineBasicBlock *NextBB = &*std::next(MBBI);
 for (MachineBasicBlock::succ_iterator I = MBB->succ_begin(),
 E = MBB->succ_end(); I != E; ++I)
 if (*I == NextBB)
 return true;
 // First thing, compute the size of all basic blocks, and see if the function
 // has any inline assembly in it. If so, we have to be conservative about
 // alignment assumptions, as we don't know for sure the size of any
 // instructions in the inline assembly.
 for (MachineFunction::iterator I = MF->begin(), E = MF->end(); I != E; ++I)
-computeBlockSize(I);
+computeBlockSize(&*I);
 // Compute block offsets.
-adjustBBOffsetsAfter(MF->begin());
+adjustBBOffsetsAfter(&MF->front());
 // Now go back through the instructions and build up our data structures.
 for (MachineFunction::iterator MBBI = MF->begin(), E = MF->end();
 MBBI != E; ++MBBI) {
 MachineBasicBlock &MBB = *MBBI;
 MachineBasicBlock *OrigBB = MI->getParent();
 // Create a new MBB for the code after the OrigBB.
 MachineBasicBlock *NewBB =
 MF->CreateMachineBasicBlock(OrigBB->getBasicBlock());
-MachineFunction::iterator MBBI = OrigBB; ++MBBI;
+MachineFunction::iterator MBBI = ++OrigBB->getIterator();
 MF->insert(MBBI, NewBB);
 // Splice the instructions starting with MI over to NewBB.
 NewBB->splice(NewBB->end(), OrigBB, MI, OrigBB->end());
 MachineBasicBlock* Water, CPUser &U,
 unsigned &Growth) {
 unsigned CPELogAlign = getCPELogAlign(U.CPEMI);
 unsigned CPEOffset = BBInfo[Water->getNumber()].postOffset(CPELogAlign);
 unsigned NextBlockOffset, NextBlockAlignment;
-MachineFunction::const_iterator NextBlock = Water;
+MachineFunction::const_iterator NextBlock = ++Water->getIterator();
-if (++NextBlock == MF->end()) {
+if (NextBlock == MF->end()) {
 NextBlockOffset = BBInfo[Water->getNumber()].postOffset();
 NextBlockAlignment = 0;
 } else {
 NextBlockOffset = BBInfo[NextBlock->getNumber()].Offset;
 NextBlockAlignment = NextBlock->getAlignment();
 unsigned CPEOffset = UserBBI.postOffset(CPELogAlign) + Delta;
 if (isOffsetInRange(UserOffset, CPEOffset, U)) {
 DEBUG(dbgs() << "Split at end of BB#" << UserMBB->getNumber()
 << format(", expected CPE offset %#x\n", CPEOffset));
-NewMBB = std::next(MachineFunction::iterator(UserMBB));
+NewMBB = &*++UserMBB->getIterator();
 // Add an unconditional branch from UserMBB to fallthrough block.  Record
 // it for branch lengthening; this new branch will not get out of range,
 // but if the preceding conditional branch is out of range, the targets
 // will be exchanged, and the altered branch may be out of range, so the
 // machinery has to know about it.
 // updated to match the WaterList, which will be updated below.
 if (NewWaterList.erase(WaterBB))
 NewWaterList.insert(NewIsland);
 // The new CPE goes before the following block (NewMBB).
-NewMBB = std::next(MachineFunction::iterator(WaterBB));
+NewMBB = &*++WaterBB->getIterator();
 } else {
 // No water found.
 // we first see if a longer form of the instrucion could have reached
 // the constant. in that case we won't bother to split
 if (!NoLoadRelaxation) {
 // splitBlockBeforeInstr adds to WaterList, which is important when it is
 // called while handling branches so that the water will be seen on the
 // next iteration for constant pools, but in this context, we don't want
 // it.  Check for this so it will be removed from the WaterList.
 // Also remove any entry from NewWaterList.
-MachineBasicBlock *WaterBB = std::prev(MachineFunction::iterator(NewMBB));
+MachineBasicBlock *WaterBB = &*--NewMBB->getIterator();
 IP = std::find(WaterList.begin(), WaterList.end(), WaterBB);
 if (IP != WaterList.end())
 NewWaterList.erase(WaterBB);
 // We are adding new water.  Update NewWaterList.
 // more than once and is also important to ensure the algorithm terminates.
 if (IP != WaterList.end())
 WaterList.erase(IP);
 // Okay, we know we can put an island before NewMBB now, do it!
-MF->insert(NewMBB, NewIsland);
+MF->insert(NewMBB->getIterator(), NewIsland);
 // Update internal data structures to account for the newly inserted MBB.
 updateForInsertedWaterBlock(NewIsland);
 // Decrement the old entry, and remove it if refcount becomes 0.
 // Mark the basic block as aligned as required by the const-pool entry.
 NewIsland->setAlignment(getCPELogAlign(U.CPEMI));
 // Increase the size of the island block to account for the new entry.
 BBInfo[NewIsland->getNumber()].Size += Size;
-adjustBBOffsetsAfter(std::prev(MachineFunction::iterator(NewIsland)));
+adjustBBOffsetsAfter(&*--NewIsland->getIterator());
 // Finally, change the CPI in the instruction operand to be ID.
 for (unsigned i = 0, e = UserMI->getNumOperands(); i != e; ++i)
 if (UserMI->getOperand(i).isCPI()) {
 UserMI->getOperand(i).setIndex(ID);
 int delta = TII->GetInstSizeInBytes(&MBB->back());
 BBInfo[MBB->getNumber()].Size -= delta;
 MBB->back().eraseFromParent();
 // BBInfo[SplitBB].Offset is wrong temporarily, fixed below
 }
-MachineBasicBlock *NextBB = std::next(MachineFunction::iterator(MBB));
+MachineBasicBlock *NextBB = &*++MBB->getIterator();
 DEBUG(dbgs() << "  Insert B to BB#" << DestBB->getNumber()
 << " also invert condition and change dest. to BB#"
 << NextBB->getNumber() << "\n");

Mercurial > hg > CbC > CbC_llvm

comparison lib/Target/Mips/MipsConstantIslandPass.cpp @ 100:7d135dc70f03 LLVM 3.9