134d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos//===-- llvm/CodeGen/VirtRegMap.cpp - Virtual Register Map ----------------===// 234d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos// 334d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos// The LLVM Compiler Infrastructure 434d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 734d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos// 834d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos//===----------------------------------------------------------------------===// 934d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos// 108c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner// This file implements the VirtRegMap class. 118c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner// 12f451cb870efcf9e0302d25ed05f4cac6bb494e42Dan Gohman// It also contains implementations of the Spiller interface, which, given a 138c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner// virtual register map and a machine function, eliminates all virtual 148c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner// references by replacing them with physical register references - adding spill 150d6c5b6489b9abb634a1506d183ba47f1bf4d1f0Alkis Evlogimenos// code as necessary. 1634d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos// 1734d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos//===----------------------------------------------------------------------===// 1834d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos 191ead68d769f27f6d68d4aaeffe4199fa2cacbc95Jakob Stoklund Olesen#include "llvm/CodeGen/VirtRegMap.h" 2005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen#include "LiveDebugVariables.h" 21d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/STLExtras.h" 2236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/ADT/SparseSet.h" 23d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/Statistic.h" 2405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen#include "llvm/CodeGen/LiveIntervalAnalysis.h" 25bb36a438722d4d56febc07c6472c8446bb6faafeEvan Cheng#include "llvm/CodeGen/LiveStackAnalysis.h" 2634d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos#include "llvm/CodeGen/MachineFrameInfo.h" 278c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner#include "llvm/CodeGen/MachineFunction.h" 284cce6b4c7882ef0cc993d931b90bf33985c96110Evan Cheng#include "llvm/CodeGen/MachineInstrBuilder.h" 2984bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineRegisterInfo.h" 3005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen#include "llvm/CodeGen/Passes.h" 31ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet#include "llvm/IR/Function.h" 32551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/Support/CommandLine.h" 33a4f0b3a084d120cfc5b5bb06f64b222f5cb72740Chris Lattner#include "llvm/Support/Compiler.h" 34752272a5e553313f7b0397a06a23b4fe8ac013c4Evan Cheng#include "llvm/Support/Debug.h" 351cd1d98232c3c3a0bd3810c3bf6c2572ea02f208Daniel Dunbar#include "llvm/Support/raw_ostream.h" 36d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetInstrInfo.h" 37d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetMachine.h" 38d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetRegisterInfo.h" 3927f291600b04c382c390b16fdacd52b910b9164dChris Lattner#include <algorithm> 4034d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenosusing namespace llvm; 4134d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos 42dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "regalloc" 43dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 4401afdb3a45f63af540b43b414c6094220a8f91e7Jakob Stoklund OlesenSTATISTIC(NumSpillSlots, "Number of spill slots allocated"); 4501afdb3a45f63af540b43b414c6094220a8f91e7Jakob Stoklund OlesenSTATISTIC(NumIdCopies, "Number of identity moves eliminated after rewriting"); 46844731a7f1909f55935e3514c9e713a62d67662eDan Gohman 478c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner//===----------------------------------------------------------------------===// 488c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner// VirtRegMap implementation 498c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner//===----------------------------------------------------------------------===// 508c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner 5149c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Andersonchar VirtRegMap::ID = 0; 5249c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson 53ce665bd2e2b581ab0858d1afe359192bac96b868Owen AndersonINITIALIZE_PASS(VirtRegMap, "virtregmap", "Virtual Register Map", false, false) 5449c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson 5549c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Andersonbool VirtRegMap::runOnMachineFunction(MachineFunction &mf) { 5690f95f88c6ce09c6744777dc9d140c3c77203b92Evan Cheng MRI = &mf.getRegInfo(); 5749c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson TII = mf.getTarget().getInstrInfo(); 58fe095f39e7009c51d1c86769792ccbcad8cdd2ecMike Stump TRI = mf.getTarget().getRegisterInfo(); 5949c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson MF = &mf; 60233a60ec40b41027ff429e2f2c27fa2be762f2e9Lang Hames 6149c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson Virt2PhysMap.clear(); 6249c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson Virt2StackSlotMap.clear(); 6349c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson Virt2SplitMap.clear(); 64fe095f39e7009c51d1c86769792ccbcad8cdd2ecMike Stump 652926869b4a083fc951484de03a9867eabf81e880Chris Lattner grow(); 6649c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson return false; 672926869b4a083fc951484de03a9867eabf81e880Chris Lattner} 682926869b4a083fc951484de03a9867eabf81e880Chris Lattner 698c4d88d3697835371ecf6823f4142af13603ad2dChris Lattnervoid VirtRegMap::grow() { 7042e9c963921776cb498c33b6c6c03f29971316f3Jakob Stoklund Olesen unsigned NumRegs = MF->getRegInfo().getNumVirtRegs(); 7142e9c963921776cb498c33b6c6c03f29971316f3Jakob Stoklund Olesen Virt2PhysMap.resize(NumRegs); 7242e9c963921776cb498c33b6c6c03f29971316f3Jakob Stoklund Olesen Virt2StackSlotMap.resize(NumRegs); 7342e9c963921776cb498c33b6c6c03f29971316f3Jakob Stoklund Olesen Virt2SplitMap.resize(NumRegs); 7434d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos} 7534d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos 76b55e91e08738b804f17109a49881e51b69e91299Jakob Stoklund Olesenunsigned VirtRegMap::createSpillSlot(const TargetRegisterClass *RC) { 77b55e91e08738b804f17109a49881e51b69e91299Jakob Stoklund Olesen int SS = MF->getFrameInfo()->CreateSpillStackObject(RC->getSize(), 78b55e91e08738b804f17109a49881e51b69e91299Jakob Stoklund Olesen RC->getAlignment()); 7901afdb3a45f63af540b43b414c6094220a8f91e7Jakob Stoklund Olesen ++NumSpillSlots; 80b55e91e08738b804f17109a49881e51b69e91299Jakob Stoklund Olesen return SS; 81b55e91e08738b804f17109a49881e51b69e91299Jakob Stoklund Olesen} 82b55e91e08738b804f17109a49881e51b69e91299Jakob Stoklund Olesen 83980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesenbool VirtRegMap::hasPreferredPhys(unsigned VirtReg) { 84980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen unsigned Hint = MRI->getSimpleHint(VirtReg); 85980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen if (!Hint) 86980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen return 0; 87980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(Hint)) 88980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen Hint = getPhys(Hint); 89980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen return getPhys(VirtReg) == Hint; 90980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen} 91980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen 92fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesenbool VirtRegMap::hasKnownPreference(unsigned VirtReg) { 93fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen std::pair<unsigned, unsigned> Hint = MRI->getRegAllocationHint(VirtReg); 94fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Hint.second)) 95fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen return true; 96fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(Hint.second)) 97fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen return hasPhys(Hint.second); 98fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen return false; 99fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen} 100fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen 1018c4d88d3697835371ecf6823f4142af13603ad2dChris Lattnerint VirtRegMap::assignVirt2StackSlot(unsigned virtReg) { 1026f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman assert(TargetRegisterInfo::isVirtualRegister(virtReg)); 1037f690e625807b9320bf4ae437b8f35258acc99deChris Lattner assert(Virt2StackSlotMap[virtReg] == NO_STACK_SLOT && 1048c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner "attempt to assign stack slot to already spilled register"); 10549c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson const TargetRegisterClass* RC = MF->getRegInfo().getRegClass(virtReg); 106b55e91e08738b804f17109a49881e51b69e91299Jakob Stoklund Olesen return Virt2StackSlotMap[virtReg] = createSpillSlot(RC); 10734d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos} 10834d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos 109d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Chengvoid VirtRegMap::assignVirt2StackSlot(unsigned virtReg, int SS) { 1106f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman assert(TargetRegisterInfo::isVirtualRegister(virtReg)); 1117f690e625807b9320bf4ae437b8f35258acc99deChris Lattner assert(Virt2StackSlotMap[virtReg] == NO_STACK_SLOT && 1128c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner "attempt to assign stack slot to already spilled register"); 113d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng assert((SS >= 0 || 11449c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson (SS >= MF->getFrameInfo()->getObjectIndexBegin())) && 1159193514e2e3e599e241220b72bc9add25a80a8fdEvan Cheng "illegal fixed frame index"); 116d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng Virt2StackSlotMap[virtReg] = SS; 11738af59a43c4176d8f34bd26faeb18b23080a1d9bAlkis Evlogimenos} 11838af59a43c4176d8f34bd26faeb18b23080a1d9bAlkis Evlogimenos 11905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenvoid VirtRegMap::print(raw_ostream &OS, const Module*) const { 12005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen OS << "********** REGISTER MAP **********\n"; 12105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen for (unsigned i = 0, e = MRI->getNumVirtRegs(); i != e; ++i) { 12205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen unsigned Reg = TargetRegisterInfo::index2VirtReg(i); 12305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen if (Virt2PhysMap[Reg] != (unsigned)VirtRegMap::NO_PHYS_REG) { 12405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen OS << '[' << PrintReg(Reg, TRI) << " -> " 12505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen << PrintReg(Virt2PhysMap[Reg], TRI) << "] " 12605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen << MRI->getRegClass(Reg)->getName() << "\n"; 12705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen } 12805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen } 12905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 13005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen for (unsigned i = 0, e = MRI->getNumVirtRegs(); i != e; ++i) { 13105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen unsigned Reg = TargetRegisterInfo::index2VirtReg(i); 13205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen if (Virt2StackSlotMap[Reg] != VirtRegMap::NO_STACK_SLOT) { 13305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen OS << '[' << PrintReg(Reg, TRI) << " -> fi#" << Virt2StackSlotMap[Reg] 13405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen << "] " << MRI->getRegClass(Reg)->getName() << "\n"; 13505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen } 13605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen } 13705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen OS << '\n'; 13805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen} 13905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 140b720be6a50f4e1b3280d2b029ee38dda14577525Manman Ren#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 14105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenvoid VirtRegMap::dump() const { 14205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen print(dbgs()); 14305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen} 14477e300e8f0b8db8eec448cae9c87d7c5bfad9757Manman Ren#endif 14505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 14605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen//===----------------------------------------------------------------------===// 14705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen// VirtRegRewriter 14805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen//===----------------------------------------------------------------------===// 14905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen// 15005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen// The VirtRegRewriter is the last of the register allocator passes. 15105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen// It rewrites virtual registers to physical registers as specified in the 15205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen// VirtRegMap analysis. It also updates live-in information on basic blocks 15305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen// according to LiveIntervals. 15405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen// 15505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesennamespace { 15605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenclass VirtRegRewriter : public MachineFunctionPass { 15705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen MachineFunction *MF; 15805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen const TargetMachine *TM; 15905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen const TargetRegisterInfo *TRI; 16005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen const TargetInstrInfo *TII; 16105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen MachineRegisterInfo *MRI; 16205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen SlotIndexes *Indexes; 16305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen LiveIntervals *LIS; 16405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen VirtRegMap *VRM; 16536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SparseSet<unsigned> PhysRegs; 16605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 16705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen void rewrite(); 16805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen void addMBBLiveIns(); 16905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenpublic: 17005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen static char ID; 17105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen VirtRegRewriter() : MachineFunctionPass(ID) {} 17205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 17336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void getAnalysisUsage(AnalysisUsage &AU) const override; 17405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 17536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool runOnMachineFunction(MachineFunction&) override; 17605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen}; 17705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen} // end anonymous namespace 17805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 17905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenchar &llvm::VirtRegRewriterID = VirtRegRewriter::ID; 18005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 18105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund OlesenINITIALIZE_PASS_BEGIN(VirtRegRewriter, "virtregrewriter", 18205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen "Virtual Register Rewriter", false, false) 18305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund OlesenINITIALIZE_PASS_DEPENDENCY(SlotIndexes) 18405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund OlesenINITIALIZE_PASS_DEPENDENCY(LiveIntervals) 18505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund OlesenINITIALIZE_PASS_DEPENDENCY(LiveDebugVariables) 186bb36a438722d4d56febc07c6472c8446bb6faafeEvan ChengINITIALIZE_PASS_DEPENDENCY(LiveStacks) 18705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund OlesenINITIALIZE_PASS_DEPENDENCY(VirtRegMap) 18805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund OlesenINITIALIZE_PASS_END(VirtRegRewriter, "virtregrewriter", 18905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen "Virtual Register Rewriter", false, false) 19005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 19105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenchar VirtRegRewriter::ID = 0; 19205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 19305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenvoid VirtRegRewriter::getAnalysisUsage(AnalysisUsage &AU) const { 19405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen AU.setPreservesCFG(); 19505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen AU.addRequired<LiveIntervals>(); 19605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen AU.addRequired<SlotIndexes>(); 19705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen AU.addPreserved<SlotIndexes>(); 19805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen AU.addRequired<LiveDebugVariables>(); 199bb36a438722d4d56febc07c6472c8446bb6faafeEvan Cheng AU.addRequired<LiveStacks>(); 200bb36a438722d4d56febc07c6472c8446bb6faafeEvan Cheng AU.addPreserved<LiveStacks>(); 20105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen AU.addRequired<VirtRegMap>(); 20205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen MachineFunctionPass::getAnalysisUsage(AU); 20305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen} 20405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 20505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenbool VirtRegRewriter::runOnMachineFunction(MachineFunction &fn) { 20605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen MF = &fn; 20705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen TM = &MF->getTarget(); 20805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen TRI = TM->getRegisterInfo(); 20905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen TII = TM->getInstrInfo(); 21005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen MRI = &MF->getRegInfo(); 21105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen Indexes = &getAnalysis<SlotIndexes>(); 21205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen LIS = &getAnalysis<LiveIntervals>(); 21305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen VRM = &getAnalysis<VirtRegMap>(); 214ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen DEBUG(dbgs() << "********** REWRITE VIRTUAL REGISTERS **********\n" 215ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen << "********** Function: " 21696601ca332ab388754ca4673be8973396fea2dddCraig Topper << MF->getName() << '\n'); 21705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen DEBUG(VRM->dump()); 21805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 21905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen // Add kill flags while we still have virtual registers. 220e617ccb80da76821379bbff4a2fdcd09e8401e8bJakob Stoklund Olesen LIS->addKillFlags(VRM); 22105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 222fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen // Live-in lists on basic blocks are required for physregs. 223fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen addMBBLiveIns(); 224fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen 22505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen // Rewrite virtual registers. 22605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen rewrite(); 22705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 22805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen // Write out new DBG_VALUE instructions. 22905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen getAnalysis<LiveDebugVariables>().emitDebugValues(VRM); 23005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 23105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen // All machine operands and other references to virtual registers have been 23205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen // replaced. Remove the virtual registers and release all the transient data. 23305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen VRM->clearAllVirt(); 23405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen MRI->clearVirtRegs(); 23505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen return true; 23605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen} 23705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 238fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen// Compute MBB live-in lists from virtual register live ranges and their 239fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen// assignments. 240fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesenvoid VirtRegRewriter::addMBBLiveIns() { 241fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen SmallVector<MachineBasicBlock*, 16> LiveIn; 242fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen for (unsigned Idx = 0, IdxE = MRI->getNumVirtRegs(); Idx != IdxE; ++Idx) { 243fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen unsigned VirtReg = TargetRegisterInfo::index2VirtReg(Idx); 244fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen if (MRI->reg_nodbg_empty(VirtReg)) 245fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen continue; 246fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen LiveInterval &LI = LIS->getInterval(VirtReg); 247fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen if (LI.empty() || LIS->intervalIsInOneMBB(LI)) 248fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen continue; 249fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen // This is a virtual register that is live across basic blocks. Its 250fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen // assigned PhysReg must be marked as live-in to those blocks. 251fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen unsigned PhysReg = VRM->getPhys(VirtReg); 252fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen assert(PhysReg != VirtRegMap::NO_PHYS_REG && "Unmapped virtual register."); 253fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen 254fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen // Scan the segments of LI. 255fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen for (LiveInterval::const_iterator I = LI.begin(), E = LI.end(); I != E; 256fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen ++I) { 257fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen if (!Indexes->findLiveInMBBs(I->start, I->end, LiveIn)) 258fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen continue; 259fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen for (unsigned i = 0, e = LiveIn.size(); i != e; ++i) 260fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen if (!LiveIn[i]->isLiveIn(PhysReg)) 261fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen LiveIn[i]->addLiveIn(PhysReg); 262fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen LiveIn.clear(); 263fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen } 264fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen } 265fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen} 266fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen 26705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenvoid VirtRegRewriter::rewrite() { 26893e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen SmallVector<unsigned, 8> SuperDeads; 26993e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen SmallVector<unsigned, 8> SuperDefs; 270ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen SmallVector<unsigned, 8> SuperKills; 271ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet SmallPtrSet<const MachineInstr *, 4> NoReturnInsts; 272ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 27336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Here we have a SparseSet to hold which PhysRegs are actually encountered 27436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // in the MF we are about to iterate over so that later when we call 27536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // setPhysRegUsed, we are only doing it for physRegs that were actually found 27636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // in the program and not for all of the possible physRegs for the given 27736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // target architecture. If the target has a lot of physRegs, then for a small 27836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // program there will be a significant compile time reduction here. 27936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines PhysRegs.clear(); 28036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines PhysRegs.setUniverse(TRI->getNumRegs()); 28136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 28236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // The function with uwtable should guarantee that the stack unwinder 28336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // can unwind the stack to the previous frame. Thus, we can't apply the 28436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // noreturn optimization if the caller function has uwtable attribute. 28536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool HasUWTable = MF->getFunction()->hasFnAttribute(Attribute::UWTable); 28636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 287ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen for (MachineFunction::iterator MBBI = MF->begin(), MBBE = MF->end(); 288ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen MBBI != MBBE; ++MBBI) { 289ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen DEBUG(MBBI->print(dbgs(), Indexes)); 290ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet bool IsExitBB = MBBI->succ_empty(); 2913f9c251e40dac7503f7ae455fab89bdc359c7b85Evan Cheng for (MachineBasicBlock::instr_iterator 2923f9c251e40dac7503f7ae455fab89bdc359c7b85Evan Cheng MII = MBBI->instr_begin(), MIE = MBBI->instr_end(); MII != MIE;) { 293ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen MachineInstr *MI = MII; 294ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen ++MII; 295ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 29636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Check if this instruction is a call to a noreturn function. If this 29736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // is a call to noreturn function and we don't need the stack unwinding 29836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // functionality (i.e. this function does not have uwtable attribute and 29936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // the callee function has the nounwind attribute), then we can ignore 30036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // the definitions set by this instruction. 30136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!HasUWTable && IsExitBB && MI->isCall()) { 302ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet for (MachineInstr::mop_iterator MOI = MI->operands_begin(), 303ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet MOE = MI->operands_end(); MOI != MOE; ++MOI) { 304ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet MachineOperand &MO = *MOI; 305ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet if (!MO.isGlobal()) 306ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet continue; 307ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet const Function *Func = dyn_cast<Function>(MO.getGlobal()); 308f0c6ab6f00861fd97ad593cfc6d841082e4b4bd1Quentin Colombet if (!Func || !Func->hasFnAttribute(Attribute::NoReturn) || 309f0c6ab6f00861fd97ad593cfc6d841082e4b4bd1Quentin Colombet // We need to keep correct unwind information 310f0c6ab6f00861fd97ad593cfc6d841082e4b4bd1Quentin Colombet // even if the function will not return, since the 311f0c6ab6f00861fd97ad593cfc6d841082e4b4bd1Quentin Colombet // runtime may need it. 312f0c6ab6f00861fd97ad593cfc6d841082e4b4bd1Quentin Colombet !Func->hasFnAttribute(Attribute::NoUnwind)) 313ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet continue; 314ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet NoReturnInsts.insert(MI); 315ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet break; 316ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet } 31736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 318ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet 319ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen for (MachineInstr::mop_iterator MOI = MI->operands_begin(), 320ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen MOE = MI->operands_end(); MOI != MOE; ++MOI) { 321ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen MachineOperand &MO = *MOI; 322d9f0ff56a1878347fe5a0f162ef8c2ef2b63aeb5Jakob Stoklund Olesen 323d9f0ff56a1878347fe5a0f162ef8c2ef2b63aeb5Jakob Stoklund Olesen // Make sure MRI knows about registers clobbered by regmasks. 324d9f0ff56a1878347fe5a0f162ef8c2ef2b63aeb5Jakob Stoklund Olesen if (MO.isRegMask()) 325d9f0ff56a1878347fe5a0f162ef8c2ef2b63aeb5Jakob Stoklund Olesen MRI->addPhysRegsUsedFromRegMask(MO.getRegMask()); 326d9f0ff56a1878347fe5a0f162ef8c2ef2b63aeb5Jakob Stoklund Olesen 32736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // If we encounter a VirtReg or PhysReg then get at the PhysReg and add 32836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // it to the physreg bitset. Later we use only the PhysRegs that were 32936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // actually encountered in the MF to populate the MRI's used physregs. 33036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (MO.isReg() && MO.getReg()) 33136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines PhysRegs.insert( 33236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines TargetRegisterInfo::isVirtualRegister(MO.getReg()) ? 33336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines VRM->getPhys(MO.getReg()) : 33436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MO.getReg()); 33536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 336ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen if (!MO.isReg() || !TargetRegisterInfo::isVirtualRegister(MO.getReg())) 337ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen continue; 338ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen unsigned VirtReg = MO.getReg(); 33905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen unsigned PhysReg = VRM->getPhys(VirtReg); 34005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen assert(PhysReg != VirtRegMap::NO_PHYS_REG && 34105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen "Instruction uses unmapped VirtReg"); 342fb9ebbf236974beac31705eaeb9f50ab585af6abJakob Stoklund Olesen assert(!MRI->isReserved(PhysReg) && "Reserved register assignment"); 343ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 344ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // Preserve semantics of sub-register operands. 345ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen if (MO.getSubReg()) { 346ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // A virtual register kill refers to the whole register, so we may 347200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen // have to add <imp-use,kill> operands for the super-register. A 348200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen // partial redef always kills and redefines the super-register. 349200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen if (MO.readsReg() && (MO.isDef() || MO.isKill())) 350200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen SuperKills.push_back(PhysReg); 351200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen 352200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen if (MO.isDef()) { 353200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen // The <def,undef> flag only makes sense for sub-register defs, and 354200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen // we are substituting a full physreg. An <imp-use,kill> operand 355200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen // from the SuperKills list will represent the partial read of the 356200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen // super-register. 357200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen MO.setIsUndef(false); 358200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen 359200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen // Also add implicit defs for the super-register. 360200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen if (MO.isDead()) 361200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen SuperDeads.push_back(PhysReg); 362200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen else 363200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen SuperDefs.push_back(PhysReg); 364200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen } 365ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 366ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // PhysReg operands cannot have subregister indexes. 367ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen PhysReg = TRI->getSubReg(PhysReg, MO.getSubReg()); 368ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen assert(PhysReg && "Invalid SubReg for physical register"); 369ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen MO.setSubReg(0); 370ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen } 371ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // Rewrite. Note we could have used MachineOperand::substPhysReg(), but 372ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // we need the inlining here. 373ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen MO.setReg(PhysReg); 374ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen } 375ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 376ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // Add any missing super-register kills after rewriting the whole 377ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // instruction. 378ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen while (!SuperKills.empty()) 379ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen MI->addRegisterKilled(SuperKills.pop_back_val(), TRI, true); 380ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 38193e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen while (!SuperDeads.empty()) 38293e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen MI->addRegisterDead(SuperDeads.pop_back_val(), TRI, true); 38393e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen 38493e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen while (!SuperDefs.empty()) 38593e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen MI->addRegisterDefined(SuperDefs.pop_back_val(), TRI); 38693e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen 387ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen DEBUG(dbgs() << "> " << *MI); 388ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 389ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // Finally, remove any identity copies. 390ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen if (MI->isIdentityCopy()) { 391cf5e5f3cc08a3c7ede5b423ee4b18586cb1079e9Jakob Stoklund Olesen ++NumIdCopies; 392280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen if (MI->getNumOperands() == 2) { 393280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen DEBUG(dbgs() << "Deleting identity copy.\n"); 394280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen if (Indexes) 395280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen Indexes->removeMachineInstrFromMaps(MI); 396280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen // It's safe to erase MI because MII has already been incremented. 397280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen MI->eraseFromParent(); 398280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen } else { 399280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen // Transform identity copy to a KILL to deal with subregisters. 400280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen MI->setDesc(TII->get(TargetOpcode::KILL)); 401280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen DEBUG(dbgs() << "Identity copy: " << *MI); 402280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen } 403ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen } 404ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen } 405ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen } 406ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 407ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // Tell MRI about physical registers in use. 408ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet if (NoReturnInsts.empty()) { 40936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (SparseSet<unsigned>::iterator 41036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines RegI = PhysRegs.begin(), E = PhysRegs.end(); RegI != E; ++RegI) 41136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!MRI->reg_nodbg_empty(*RegI)) 41236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MRI->setPhysRegUsed(*RegI); 413ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet } else { 41436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (SparseSet<unsigned>::iterator 41536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines I = PhysRegs.begin(), E = PhysRegs.end(); I != E; ++I) { 41636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned Reg = *I; 417ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet if (MRI->reg_nodbg_empty(Reg)) 418ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet continue; 419ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet // Check if this register has a use that will impact the rest of the 420ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet // code. Uses in debug and noreturn instructions do not impact the 421ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet // generated code. 42236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (MachineInstr &It : MRI->reg_nodbg_instructions(Reg)) { 42336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!NoReturnInsts.count(&It)) { 424ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet MRI->setPhysRegUsed(Reg); 425ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet break; 426ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet } 427ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet } 428ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet } 429ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet } 430ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen} 43136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 432