Members/tobaru/cbc/CbC_llvm: lib/CodeGen/VirtRegMap.cpp comparison

comparison lib/CodeGen/VirtRegMap.cpp @ 77:54457678186b

LLVM 3.6

author	Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date	Mon, 08 Sep 2014 22:06:00 +0900
parents	95c75e76d11b
children	60c9769439b8

comparison

equal deleted inserted replaced

-:e874dbf0ad9d
+:54457678186b
 // references by replacing them with physical register references - adding spill
 // code as necessary.
 //
 //===----------------------------------------------------------------------===//
-#define DEBUG_TYPE "regalloc"
 #include "llvm/CodeGen/VirtRegMap.h"
 #include "LiveDebugVariables.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SparseSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/CodeGen/LiveIntervalAnalysis.h"
 #include "llvm/CodeGen/LiveStackAnalysis.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetRegisterInfo.h"
+#include "llvm/Target/TargetSubtargetInfo.h"
 #include <algorithm>
 using namespace llvm;
+#define DEBUG_TYPE "regalloc"
 STATISTIC(NumSpillSlots, "Number of spill slots allocated");
 STATISTIC(NumIdCopies,   "Number of identity moves eliminated after rewriting");
 //===----------------------------------------------------------------------===//
 //  VirtRegMap implementation
 INITIALIZE_PASS(VirtRegMap, "virtregmap", "Virtual Register Map", false, false)
 bool VirtRegMap::runOnMachineFunction(MachineFunction &mf) {
 MRI = &mf.getRegInfo();
-TII = mf.getTarget().getInstrInfo();
+TII = mf.getSubtarget().getInstrInfo();
-TRI = mf.getTarget().getRegisterInfo();
+TRI = mf.getSubtarget().getRegisterInfo();
 MF = &mf;
 Virt2PhysMap.clear();
 Virt2StackSlotMap.clear();
 Virt2SplitMap.clear();
 const TargetInstrInfo *TII;
 MachineRegisterInfo *MRI;
 SlotIndexes *Indexes;
 LiveIntervals *LIS;
 VirtRegMap *VRM;
+SparseSet<unsigned> PhysRegs;
 void rewrite();
 void addMBBLiveIns();
 public:
 static char ID;
 VirtRegRewriter() : MachineFunctionPass(ID) {}
-virtual void getAnalysisUsage(AnalysisUsage &AU) const;
+void getAnalysisUsage(AnalysisUsage &AU) const override;
-virtual bool runOnMachineFunction(MachineFunction&);
+bool runOnMachineFunction(MachineFunction&) override;
 };
 } // end anonymous namespace
 char &llvm::VirtRegRewriterID = VirtRegRewriter::ID;
 }
 bool VirtRegRewriter::runOnMachineFunction(MachineFunction &fn) {
 MF = &fn;
 TM = &MF->getTarget();
-TRI = TM->getRegisterInfo();
+TRI = TM->getSubtargetImpl()->getRegisterInfo();
-TII = TM->getInstrInfo();
+TII = TM->getSubtargetImpl()->getInstrInfo();
 MRI = &MF->getRegInfo();
 Indexes = &getAnalysis<SlotIndexes>();
 LIS = &getAnalysis<LiveIntervals>();
 VRM = &getAnalysis<VirtRegMap>();
 DEBUG(dbgs() << "********** REWRITE VIRTUAL REGISTERS **********\n"
 SmallVector<unsigned, 8> SuperDeads;
 SmallVector<unsigned, 8> SuperDefs;
 SmallVector<unsigned, 8> SuperKills;
 SmallPtrSet<const MachineInstr *, 4> NoReturnInsts;
+// Here we have a SparseSet to hold which PhysRegs are actually encountered
+// in the MF we are about to iterate over so that later when we call
+// setPhysRegUsed, we are only doing it for physRegs that were actually found
+// in the program and not for all of the possible physRegs for the given
+// target architecture. If the target has a lot of physRegs, then for a small
+// program there will be a significant compile time reduction here.
+PhysRegs.clear();
+PhysRegs.setUniverse(TRI->getNumRegs());
+// The function with uwtable should guarantee that the stack unwinder
+// can unwind the stack to the previous frame.  Thus, we can't apply the
+// noreturn optimization if the caller function has uwtable attribute.
+bool HasUWTable = MF->getFunction()->hasFnAttribute(Attribute::UWTable);
 for (MachineFunction::iterator MBBI = MF->begin(), MBBE = MF->end();
 MBBI != MBBE; ++MBBI) {
 DEBUG(MBBI->print(dbgs(), Indexes));
 bool IsExitBB = MBBI->succ_empty();
 for (MachineBasicBlock::instr_iterator
 MII = MBBI->instr_begin(), MIE = MBBI->instr_end(); MII != MIE;) {
 MachineInstr *MI = MII;
 ++MII;
-// Check if this instruction is a call to a noreturn function.
+// Check if this instruction is a call to a noreturn function.  If this
-// If so, all the definitions set by this instruction can be ignored.
+// is a call to noreturn function and we don't need the stack unwinding
-if (IsExitBB && MI->isCall())
+// functionality (i.e. this function does not have uwtable attribute and
+// the callee function has the nounwind attribute), then we can ignore
+// the definitions set by this instruction.
+if (!HasUWTable && IsExitBB && MI->isCall()) {
 for (MachineInstr::mop_iterator MOI = MI->operands_begin(),
 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
 MachineOperand &MO = *MOI;
 if (!MO.isGlobal())
 continue;
 !Func->hasFnAttribute(Attribute::NoUnwind))
 continue;
 NoReturnInsts.insert(MI);
 break;
 }
+}
 for (MachineInstr::mop_iterator MOI = MI->operands_begin(),
 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
 MachineOperand &MO = *MOI;
 // Make sure MRI knows about registers clobbered by regmasks.
 if (MO.isRegMask())
 MRI->addPhysRegsUsedFromRegMask(MO.getRegMask());
+// If we encounter a VirtReg or PhysReg then get at the PhysReg and add
+// it to the physreg bitset.  Later we use only the PhysRegs that were
+// actually encountered in the MF to populate the MRI's used physregs.
+if (MO.isReg() && MO.getReg())
+PhysRegs.insert(
+TargetRegisterInfo::isVirtualRegister(MO.getReg()) ?
+VRM->getPhys(MO.getReg()) :
+MO.getReg());
 if (!MO.isReg() || !TargetRegisterInfo::isVirtualRegister(MO.getReg()))
 continue;
 unsigned VirtReg = MO.getReg();
 unsigned PhysReg = VRM->getPhys(VirtReg);
 }
 }
 // Tell MRI about physical registers in use.
 if (NoReturnInsts.empty()) {
-for (unsigned Reg = 1, RegE = TRI->getNumRegs(); Reg != RegE; ++Reg)
+for (SparseSet<unsigned>::iterator
-if (!MRI->reg_nodbg_empty(Reg))
+RegI = PhysRegs.begin(), E = PhysRegs.end(); RegI != E; ++RegI)
-MRI->setPhysRegUsed(Reg);
+if (!MRI->reg_nodbg_empty(*RegI))
+MRI->setPhysRegUsed(*RegI);
 } else {
-for (unsigned Reg = 1, RegE = TRI->getNumRegs(); Reg != RegE; ++Reg) {
+for (SparseSet<unsigned>::iterator
+I = PhysRegs.begin(), E = PhysRegs.end(); I != E; ++I) {
+unsigned Reg = *I;
 if (MRI->reg_nodbg_empty(Reg))
 continue;
 // Check if this register has a use that will impact the rest of the
 // code. Uses in debug and noreturn instructions do not impact the
 // generated code.
-for (MachineRegisterInfo::reg_nodbg_iterator It =
+for (MachineInstr &It : MRI->reg_nodbg_instructions(Reg)) {
-MRI->reg_nodbg_begin(Reg),
+if (!NoReturnInsts.count(&It)) {
-EndIt = MRI->reg_nodbg_end(); It != EndIt; ++It) {
-if (!NoReturnInsts.count(&(*It))) {
 MRI->setPhysRegUsed(Reg);
 break;
 }
 }
 }
 }
 }

Mercurial > hg > Members > tobaru > cbc > CbC_llvm

comparison lib/CodeGen/VirtRegMap.cpp @ 77:54457678186b