CbC/CbC_llvm: lib/CodeGen/BranchRelaxation.cpp comparison

comparison lib/CodeGen/BranchRelaxation.cpp @ 121:803732b1fca8

LLVM 5.0

author	kono
date	Fri, 27 Oct 2017 17:07:41 +0900
parents	1172e4bd9c6f
children	3a76565eade5

comparison

equal deleted inserted replaced

-:1172e4bd9c6f
+:803732b1fca8
-//===-- BranchRelaxation.cpp ----------------------------------------------===//
+//===- BranchRelaxation.cpp -----------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include "llvm/CodeGen/Passes.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/CodeGen/LivePhysRegs.h"
+#include "llvm/CodeGen/MachineBasicBlock.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/RegisterScavenging.h"
-#include "llvm/Target/TargetInstrInfo.h"
+#include "llvm/IR/DebugLoc.h"
-#include "llvm/Target/TargetSubtargetInfo.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Target/TargetInstrInfo.h"
+#include "llvm/Target/TargetRegisterInfo.h"
+#include "llvm/Target/TargetSubtargetInfo.h"
+#include <cassert>
+#include <cstdint>
+#include <iterator>
+#include <memory>
 using namespace llvm;
 #define DEBUG_TYPE "branch-relaxation"
 STATISTIC(NumUnconditionalRelaxed, "Number of unconditional branches relaxed");
 #define BRANCH_RELAX_NAME "Branch relaxation pass"
 namespace {
 class BranchRelaxation : public MachineFunctionPass {
 /// BasicBlockInfo - Information about the offset and size of a single
 /// basic block.
 struct BasicBlockInfo {
 /// Offset - Distance from the beginning of the function to the beginning
 /// of this basic block.
 ///
 /// The offset is always aligned as required by the basic block.
-unsigned Offset;
+unsigned Offset = 0;
 /// Size - Size of the basic block in bytes.  If the block contains
 /// inline assembly, this is a worst case estimate.
 ///
 /// The size does not include any alignment padding whether from the
 /// beginning of the block, or from an aligned jump table at the end.
-unsigned Size;
+unsigned Size = 0;
-BasicBlockInfo() : Offset(0), Size(0) {}
+BasicBlockInfo() = default;
 /// Compute the offset immediately following this block. \p MBB is the next
 /// block.
 unsigned postOffset(const MachineBasicBlock &MBB) const {
 unsigned PO = Offset + Size;
 }
 };
 SmallVector<BasicBlockInfo, 16> BlockInfo;
 std::unique_ptr<RegScavenger> RS;
+LivePhysRegs LiveRegs;
 MachineFunction *MF;
+const TargetRegisterInfo *TRI;
 const TargetInstrInfo *TII;
 bool relaxBranchInstructions();
 void scanFunction();
 void dumpBBs();
 void verify();
 public:
 static char ID;
-BranchRelaxation() : MachineFunctionPass(ID) { }
+BranchRelaxation() : MachineFunctionPass(ID) {}
 bool runOnMachineFunction(MachineFunction &MF) override;
-StringRef getPassName() const override {
+StringRef getPassName() const override { return BRANCH_RELAX_NAME; }
-return BRANCH_RELAX_NAME;
-}
 };
-}
+} // end anonymous namespace
 char BranchRelaxation::ID = 0;
 char &llvm::BranchRelaxationPassID = BranchRelaxation::ID;
 INITIALIZE_PASS(BranchRelaxation, DEBUG_TYPE, BRANCH_RELAX_NAME, false, false)
 /// verify - check BBOffsets, BBSizes, alignment of islands
 PrevNum = Num;
 }
 #endif
 }
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 /// print block size and offset information - debugging
-void BranchRelaxation::dumpBBs() {
+LLVM_DUMP_METHOD void BranchRelaxation::dumpBBs() {
 for (auto &MBB : *MF) {
 const BasicBlockInfo &BBI = BlockInfo[MBB.getNumber()];
 dbgs() << format("BB#%u\toffset=%08x\t", MBB.getNumber(), BBI.Offset)
 << format("size=%#x\n", BBI.Size);
 }
 }
+#endif
 /// scanFunction - Do the initial scan of the function, building up
 /// information about each block.
 void BranchRelaxation::scanFunction() {
 BlockInfo.clear();
 PrevNum = Num;
 }
 }
 /// Insert a new empty basic block and insert it after \BB
 MachineBasicBlock *BranchRelaxation::createNewBlockAfter(MachineBasicBlock &BB) {
 // Create a new MBB for the code after the OrigBB.
 MachineBasicBlock *NewBB =
 MF->CreateMachineBasicBlock(BB.getBasicBlock());
 MF->insert(++BB.getIterator(), NewBB);
 TII->insertUnconditionalBranch(*OrigBB, NewBB, DebugLoc());
 // Insert an entry into BlockInfo to align it properly with the block numbers.
 BlockInfo.insert(BlockInfo.begin() + NewBB->getNumber(), BasicBlockInfo());
 NewBB->transferSuccessors(OrigBB);
 OrigBB->addSuccessor(NewBB);
 OrigBB->addSuccessor(DestBB);
 // Cleanup potential unconditional branch to successor block.
 // block, it may contain a tablejump.
 BlockInfo[NewBB->getNumber()].Size = computeBlockSize(*NewBB);
 // All BBOffsets following these blocks must be modified.
 adjustBlockOffsets(*OrigBB);
+// Need to fix live-in lists if we track liveness.
+if (TRI->trackLivenessAfterRegAlloc(*MF))
+computeAndAddLiveIns(LiveRegs, *NewBB);
 ++NumSplit;
 return NewBB;
 }
 // Update the successor lists according to the transformation to follow.
 // Do it here since if there's no split, no update is needed.
 MBB->replaceSuccessor(FBB, &NewBB);
 NewBB.addSuccessor(FBB);
+// Need to fix live-in lists if we track liveness.
+if (TRI->trackLivenessAfterRegAlloc(*MF))
+computeAndAddLiveIns(LiveRegs, NewBB);
 }
 // We now have an appropriate fall-through block in place (either naturally or
 // just created), so we can invert the condition.
 MachineBasicBlock &NextBB = *std::next(MachineFunction::iterator(MBB));
 // Relaxing branches involves creating new basic blocks, so re-eval
 // end() for termination.
 for (MachineFunction::iterator I = MF->begin(); I != MF->end(); ++I) {
 MachineBasicBlock &MBB = *I;
-auto Last = MBB.rbegin();
+// Empty block?
-if (Last == MBB.rend()) // Empty block.
+MachineBasicBlock::iterator Last = MBB.getLastNonDebugInstr();
+if (Last == MBB.end())
 continue;
 // Expand the unconditional branch first if necessary. If there is a
 // conditional branch, this will end up changing the branch destination of
 // it to be over the newly inserted indirect branch block, which may avoid
 DEBUG(dbgs() << "***** BranchRelaxation *****\n");
 const TargetSubtargetInfo &ST = MF->getSubtarget();
 TII = ST.getInstrInfo();
-const TargetRegisterInfo *TRI = ST.getRegisterInfo();
+TRI = ST.getRegisterInfo();
 if (TRI->trackLivenessAfterRegAlloc(*MF))
 RS.reset(new RegScavenger());
 // Renumber all of the machine basic blocks in the function, guaranteeing that
 // the numbers agree with the position of the block in the function.

Mercurial > hg > CbC > CbC_llvm

comparison lib/CodeGen/BranchRelaxation.cpp @ 121:803732b1fca8