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" 3937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines#include "llvm/Target/TargetSubtargetInfo.h" 4027f291600b04c382c390b16fdacd52b910b9164dChris Lattner#include <algorithm> 4134d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenosusing namespace llvm; 4234d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos 43dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "regalloc" 44dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 4501afdb3a45f63af540b43b414c6094220a8f91e7Jakob Stoklund OlesenSTATISTIC(NumSpillSlots, "Number of spill slots allocated"); 4601afdb3a45f63af540b43b414c6094220a8f91e7Jakob Stoklund OlesenSTATISTIC(NumIdCopies, "Number of identity moves eliminated after rewriting"); 47844731a7f1909f55935e3514c9e713a62d67662eDan Gohman 488c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner//===----------------------------------------------------------------------===// 498c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner// VirtRegMap implementation 508c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner//===----------------------------------------------------------------------===// 518c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner 5249c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Andersonchar VirtRegMap::ID = 0; 5349c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson 54ce665bd2e2b581ab0858d1afe359192bac96b868Owen AndersonINITIALIZE_PASS(VirtRegMap, "virtregmap", "Virtual Register Map", false, false) 5549c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson 5649c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Andersonbool VirtRegMap::runOnMachineFunction(MachineFunction &mf) { 5790f95f88c6ce09c6744777dc9d140c3c77203b92Evan Cheng MRI = &mf.getRegInfo(); 5837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines TII = mf.getSubtarget().getInstrInfo(); 5937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines TRI = mf.getSubtarget().getRegisterInfo(); 6049c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson MF = &mf; 61233a60ec40b41027ff429e2f2c27fa2be762f2e9Lang Hames 6249c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson Virt2PhysMap.clear(); 6349c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson Virt2StackSlotMap.clear(); 6449c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson Virt2SplitMap.clear(); 65fe095f39e7009c51d1c86769792ccbcad8cdd2ecMike Stump 662926869b4a083fc951484de03a9867eabf81e880Chris Lattner grow(); 6749c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson return false; 682926869b4a083fc951484de03a9867eabf81e880Chris Lattner} 692926869b4a083fc951484de03a9867eabf81e880Chris Lattner 708c4d88d3697835371ecf6823f4142af13603ad2dChris Lattnervoid VirtRegMap::grow() { 7142e9c963921776cb498c33b6c6c03f29971316f3Jakob Stoklund Olesen unsigned NumRegs = MF->getRegInfo().getNumVirtRegs(); 7242e9c963921776cb498c33b6c6c03f29971316f3Jakob Stoklund Olesen Virt2PhysMap.resize(NumRegs); 7342e9c963921776cb498c33b6c6c03f29971316f3Jakob Stoklund Olesen Virt2StackSlotMap.resize(NumRegs); 7442e9c963921776cb498c33b6c6c03f29971316f3Jakob Stoklund Olesen Virt2SplitMap.resize(NumRegs); 7534d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos} 7634d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos 77b55e91e08738b804f17109a49881e51b69e91299Jakob Stoklund Olesenunsigned VirtRegMap::createSpillSlot(const TargetRegisterClass *RC) { 78b55e91e08738b804f17109a49881e51b69e91299Jakob Stoklund Olesen int SS = MF->getFrameInfo()->CreateSpillStackObject(RC->getSize(), 79b55e91e08738b804f17109a49881e51b69e91299Jakob Stoklund Olesen RC->getAlignment()); 8001afdb3a45f63af540b43b414c6094220a8f91e7Jakob Stoklund Olesen ++NumSpillSlots; 81b55e91e08738b804f17109a49881e51b69e91299Jakob Stoklund Olesen return SS; 82b55e91e08738b804f17109a49881e51b69e91299Jakob Stoklund Olesen} 83b55e91e08738b804f17109a49881e51b69e91299Jakob Stoklund Olesen 84980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesenbool VirtRegMap::hasPreferredPhys(unsigned VirtReg) { 85980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen unsigned Hint = MRI->getSimpleHint(VirtReg); 86980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen if (!Hint) 87980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen return 0; 88980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(Hint)) 89980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen Hint = getPhys(Hint); 90980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen return getPhys(VirtReg) == Hint; 91980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen} 92980bddfb1c26e2e9374d1645f9ae26c44742606fJakob Stoklund Olesen 93fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesenbool VirtRegMap::hasKnownPreference(unsigned VirtReg) { 94fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen std::pair<unsigned, unsigned> Hint = MRI->getRegAllocationHint(VirtReg); 95fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Hint.second)) 96fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen return true; 97fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(Hint.second)) 98fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen return hasPhys(Hint.second); 99fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen return false; 100fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen} 101fc6374439edf2f74da4026f4cea8e341d092be5cJakob Stoklund Olesen 1028c4d88d3697835371ecf6823f4142af13603ad2dChris Lattnerint VirtRegMap::assignVirt2StackSlot(unsigned virtReg) { 1036f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman assert(TargetRegisterInfo::isVirtualRegister(virtReg)); 1047f690e625807b9320bf4ae437b8f35258acc99deChris Lattner assert(Virt2StackSlotMap[virtReg] == NO_STACK_SLOT && 1058c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner "attempt to assign stack slot to already spilled register"); 10649c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson const TargetRegisterClass* RC = MF->getRegInfo().getRegClass(virtReg); 107b55e91e08738b804f17109a49881e51b69e91299Jakob Stoklund Olesen return Virt2StackSlotMap[virtReg] = createSpillSlot(RC); 10834d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos} 10934d9bc9f168d17c52eb57e024580bd9499695f91Alkis Evlogimenos 110d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Chengvoid VirtRegMap::assignVirt2StackSlot(unsigned virtReg, int SS) { 1116f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman assert(TargetRegisterInfo::isVirtualRegister(virtReg)); 1127f690e625807b9320bf4ae437b8f35258acc99deChris Lattner assert(Virt2StackSlotMap[virtReg] == NO_STACK_SLOT && 1138c4d88d3697835371ecf6823f4142af13603ad2dChris Lattner "attempt to assign stack slot to already spilled register"); 114d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng assert((SS >= 0 || 11549c8aa0d8b2824c70d178c5d55cda64d6613c0d8Owen Anderson (SS >= MF->getFrameInfo()->getObjectIndexBegin())) && 1169193514e2e3e599e241220b72bc9add25a80a8fdEvan Cheng "illegal fixed frame index"); 117d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng Virt2StackSlotMap[virtReg] = SS; 11838af59a43c4176d8f34bd26faeb18b23080a1d9bAlkis Evlogimenos} 11938af59a43c4176d8f34bd26faeb18b23080a1d9bAlkis Evlogimenos 12005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenvoid VirtRegMap::print(raw_ostream &OS, const Module*) const { 12105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen OS << "********** REGISTER MAP **********\n"; 12205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen for (unsigned i = 0, e = MRI->getNumVirtRegs(); i != e; ++i) { 12305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen unsigned Reg = TargetRegisterInfo::index2VirtReg(i); 12405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen if (Virt2PhysMap[Reg] != (unsigned)VirtRegMap::NO_PHYS_REG) { 12505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen OS << '[' << PrintReg(Reg, TRI) << " -> " 12605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen << PrintReg(Virt2PhysMap[Reg], TRI) << "] " 12737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines << TRI->getRegClassName(MRI->getRegClass(Reg)) << "\n"; 12805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen } 12905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen } 13005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 13105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen for (unsigned i = 0, e = MRI->getNumVirtRegs(); i != e; ++i) { 13205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen unsigned Reg = TargetRegisterInfo::index2VirtReg(i); 13305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen if (Virt2StackSlotMap[Reg] != VirtRegMap::NO_STACK_SLOT) { 13405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen OS << '[' << PrintReg(Reg, TRI) << " -> fi#" << Virt2StackSlotMap[Reg] 13537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines << "] " << TRI->getRegClassName(MRI->getRegClass(Reg)) << "\n"; 13605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen } 13705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen } 13805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen OS << '\n'; 13905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen} 14005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 141b720be6a50f4e1b3280d2b029ee38dda14577525Manman Ren#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 14205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenvoid VirtRegMap::dump() const { 14305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen print(dbgs()); 14405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen} 14577e300e8f0b8db8eec448cae9c87d7c5bfad9757Manman Ren#endif 14605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 14705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen//===----------------------------------------------------------------------===// 14805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen// VirtRegRewriter 14905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen//===----------------------------------------------------------------------===// 15005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen// 15105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen// The VirtRegRewriter is the last of the register allocator passes. 15205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen// It rewrites virtual registers to physical registers as specified in the 15305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen// VirtRegMap analysis. It also updates live-in information on basic blocks 15405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen// according to LiveIntervals. 15505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen// 15605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesennamespace { 15705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenclass VirtRegRewriter : public MachineFunctionPass { 15805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen MachineFunction *MF; 15905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen const TargetMachine *TM; 16005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen const TargetRegisterInfo *TRI; 16105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen const TargetInstrInfo *TII; 16205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen MachineRegisterInfo *MRI; 16305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen SlotIndexes *Indexes; 16405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen LiveIntervals *LIS; 16505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen VirtRegMap *VRM; 16636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SparseSet<unsigned> PhysRegs; 16705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 16805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen void rewrite(); 16905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen void addMBBLiveIns(); 17005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenpublic: 17105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen static char ID; 17205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen VirtRegRewriter() : MachineFunctionPass(ID) {} 17305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 17436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void getAnalysisUsage(AnalysisUsage &AU) const override; 17505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 17636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool runOnMachineFunction(MachineFunction&) override; 17705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen}; 17805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen} // end anonymous namespace 17905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 18005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenchar &llvm::VirtRegRewriterID = VirtRegRewriter::ID; 18105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 18205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund OlesenINITIALIZE_PASS_BEGIN(VirtRegRewriter, "virtregrewriter", 18305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen "Virtual Register Rewriter", false, false) 18405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund OlesenINITIALIZE_PASS_DEPENDENCY(SlotIndexes) 18505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund OlesenINITIALIZE_PASS_DEPENDENCY(LiveIntervals) 18605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund OlesenINITIALIZE_PASS_DEPENDENCY(LiveDebugVariables) 187bb36a438722d4d56febc07c6472c8446bb6faafeEvan ChengINITIALIZE_PASS_DEPENDENCY(LiveStacks) 18805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund OlesenINITIALIZE_PASS_DEPENDENCY(VirtRegMap) 18905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund OlesenINITIALIZE_PASS_END(VirtRegRewriter, "virtregrewriter", 19005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen "Virtual Register Rewriter", false, false) 19105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 19205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenchar VirtRegRewriter::ID = 0; 19305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 19405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenvoid VirtRegRewriter::getAnalysisUsage(AnalysisUsage &AU) const { 19505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen AU.setPreservesCFG(); 19605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen AU.addRequired<LiveIntervals>(); 19705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen AU.addRequired<SlotIndexes>(); 19805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen AU.addPreserved<SlotIndexes>(); 19905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen AU.addRequired<LiveDebugVariables>(); 200bb36a438722d4d56febc07c6472c8446bb6faafeEvan Cheng AU.addRequired<LiveStacks>(); 201bb36a438722d4d56febc07c6472c8446bb6faafeEvan Cheng AU.addPreserved<LiveStacks>(); 20205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen AU.addRequired<VirtRegMap>(); 20305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen MachineFunctionPass::getAnalysisUsage(AU); 20405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen} 20505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 20605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenbool VirtRegRewriter::runOnMachineFunction(MachineFunction &fn) { 20705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen MF = &fn; 20805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen TM = &MF->getTarget(); 20937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines TRI = MF->getSubtarget().getRegisterInfo(); 21037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines TII = MF->getSubtarget().getInstrInfo(); 21105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen MRI = &MF->getRegInfo(); 21205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen Indexes = &getAnalysis<SlotIndexes>(); 21305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen LIS = &getAnalysis<LiveIntervals>(); 21405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen VRM = &getAnalysis<VirtRegMap>(); 215ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen DEBUG(dbgs() << "********** REWRITE VIRTUAL REGISTERS **********\n" 216ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen << "********** Function: " 21796601ca332ab388754ca4673be8973396fea2dddCraig Topper << MF->getName() << '\n'); 21805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen DEBUG(VRM->dump()); 21905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 22005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen // Add kill flags while we still have virtual registers. 221e617ccb80da76821379bbff4a2fdcd09e8401e8bJakob Stoklund Olesen LIS->addKillFlags(VRM); 22205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 223fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen // Live-in lists on basic blocks are required for physregs. 224fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen addMBBLiveIns(); 225fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen 22605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen // Rewrite virtual registers. 22705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen rewrite(); 22805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 22905ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen // Write out new DBG_VALUE instructions. 23005ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen getAnalysis<LiveDebugVariables>().emitDebugValues(VRM); 23105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 23205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen // All machine operands and other references to virtual registers have been 23305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen // replaced. Remove the virtual registers and release all the transient data. 23405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen VRM->clearAllVirt(); 23505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen MRI->clearVirtRegs(); 23605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen return true; 23705ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen} 23805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 239fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen// Compute MBB live-in lists from virtual register live ranges and their 240fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen// assignments. 241fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesenvoid VirtRegRewriter::addMBBLiveIns() { 242fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen SmallVector<MachineBasicBlock*, 16> LiveIn; 243fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen for (unsigned Idx = 0, IdxE = MRI->getNumVirtRegs(); Idx != IdxE; ++Idx) { 244fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen unsigned VirtReg = TargetRegisterInfo::index2VirtReg(Idx); 245fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen if (MRI->reg_nodbg_empty(VirtReg)) 246fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen continue; 247fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen LiveInterval &LI = LIS->getInterval(VirtReg); 248fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen if (LI.empty() || LIS->intervalIsInOneMBB(LI)) 249fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen continue; 250fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen // This is a virtual register that is live across basic blocks. Its 251fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen // assigned PhysReg must be marked as live-in to those blocks. 252fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen unsigned PhysReg = VRM->getPhys(VirtReg); 253fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen assert(PhysReg != VirtRegMap::NO_PHYS_REG && "Unmapped virtual register."); 254fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen 255ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (LI.hasSubRanges()) { 256ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines for (LiveInterval::SubRange &S : LI.subranges()) { 257ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines for (const auto &Seg : S.segments) { 258ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!Indexes->findLiveInMBBs(Seg.start, Seg.end, LiveIn)) 259ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines continue; 260ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines for (MCSubRegIndexIterator SR(PhysReg, TRI); SR.isValid(); ++SR) { 261ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines unsigned SubReg = SR.getSubReg(); 262ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines unsigned SubRegIndex = SR.getSubRegIndex(); 263ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines unsigned SubRegLaneMask = TRI->getSubRegIndexLaneMask(SubRegIndex); 264ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if ((SubRegLaneMask & S.LaneMask) == 0) 265ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines continue; 266ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines for (unsigned i = 0, e = LiveIn.size(); i != e; ++i) { 267ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!LiveIn[i]->isLiveIn(SubReg)) 268ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines LiveIn[i]->addLiveIn(SubReg); 269ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 270ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 271ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines LiveIn.clear(); 272ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 273ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 274ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } else { 275ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Scan the segments of LI. 276ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines for (const auto &Seg : LI.segments) { 277ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!Indexes->findLiveInMBBs(Seg.start, Seg.end, LiveIn)) 278ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines continue; 279ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines for (unsigned i = 0, e = LiveIn.size(); i != e; ++i) 280ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!LiveIn[i]->isLiveIn(PhysReg)) 281ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines LiveIn[i]->addLiveIn(PhysReg); 282ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines LiveIn.clear(); 283ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 284fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen } 285fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen } 286fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen} 287fe17bdbb50efe2f7f68d0b99e55ae52bd9477978Jakob Stoklund Olesen 28805ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesenvoid VirtRegRewriter::rewrite() { 2894c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar bool NoSubRegLiveness = !MRI->subRegLivenessEnabled(); 29093e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen SmallVector<unsigned, 8> SuperDeads; 29193e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen SmallVector<unsigned, 8> SuperDefs; 292ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen SmallVector<unsigned, 8> SuperKills; 293ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet SmallPtrSet<const MachineInstr *, 4> NoReturnInsts; 294ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 29536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Here we have a SparseSet to hold which PhysRegs are actually encountered 29636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // in the MF we are about to iterate over so that later when we call 29736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // setPhysRegUsed, we are only doing it for physRegs that were actually found 29836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // in the program and not for all of the possible physRegs for the given 29936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // target architecture. If the target has a lot of physRegs, then for a small 30036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // program there will be a significant compile time reduction here. 30136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines PhysRegs.clear(); 30236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines PhysRegs.setUniverse(TRI->getNumRegs()); 30336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 30436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // The function with uwtable should guarantee that the stack unwinder 30536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // can unwind the stack to the previous frame. Thus, we can't apply the 30636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // noreturn optimization if the caller function has uwtable attribute. 30736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool HasUWTable = MF->getFunction()->hasFnAttribute(Attribute::UWTable); 30836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 309ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen for (MachineFunction::iterator MBBI = MF->begin(), MBBE = MF->end(); 310ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen MBBI != MBBE; ++MBBI) { 311ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen DEBUG(MBBI->print(dbgs(), Indexes)); 312ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet bool IsExitBB = MBBI->succ_empty(); 3133f9c251e40dac7503f7ae455fab89bdc359c7b85Evan Cheng for (MachineBasicBlock::instr_iterator 3143f9c251e40dac7503f7ae455fab89bdc359c7b85Evan Cheng MII = MBBI->instr_begin(), MIE = MBBI->instr_end(); MII != MIE;) { 315ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen MachineInstr *MI = MII; 316ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen ++MII; 317ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 31836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Check if this instruction is a call to a noreturn function. If this 31936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // is a call to noreturn function and we don't need the stack unwinding 32036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // functionality (i.e. this function does not have uwtable attribute and 32136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // the callee function has the nounwind attribute), then we can ignore 32236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // the definitions set by this instruction. 32336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!HasUWTable && IsExitBB && MI->isCall()) { 324ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet for (MachineInstr::mop_iterator MOI = MI->operands_begin(), 325ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet MOE = MI->operands_end(); MOI != MOE; ++MOI) { 326ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet MachineOperand &MO = *MOI; 327ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet if (!MO.isGlobal()) 328ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet continue; 329ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet const Function *Func = dyn_cast<Function>(MO.getGlobal()); 330f0c6ab6f00861fd97ad593cfc6d841082e4b4bd1Quentin Colombet if (!Func || !Func->hasFnAttribute(Attribute::NoReturn) || 331f0c6ab6f00861fd97ad593cfc6d841082e4b4bd1Quentin Colombet // We need to keep correct unwind information 332f0c6ab6f00861fd97ad593cfc6d841082e4b4bd1Quentin Colombet // even if the function will not return, since the 333f0c6ab6f00861fd97ad593cfc6d841082e4b4bd1Quentin Colombet // runtime may need it. 334f0c6ab6f00861fd97ad593cfc6d841082e4b4bd1Quentin Colombet !Func->hasFnAttribute(Attribute::NoUnwind)) 335ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet continue; 336ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet NoReturnInsts.insert(MI); 337ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet break; 338ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet } 33936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 340ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet 341ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen for (MachineInstr::mop_iterator MOI = MI->operands_begin(), 342ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen MOE = MI->operands_end(); MOI != MOE; ++MOI) { 343ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen MachineOperand &MO = *MOI; 344d9f0ff56a1878347fe5a0f162ef8c2ef2b63aeb5Jakob Stoklund Olesen 345d9f0ff56a1878347fe5a0f162ef8c2ef2b63aeb5Jakob Stoklund Olesen // Make sure MRI knows about registers clobbered by regmasks. 346d9f0ff56a1878347fe5a0f162ef8c2ef2b63aeb5Jakob Stoklund Olesen if (MO.isRegMask()) 347d9f0ff56a1878347fe5a0f162ef8c2ef2b63aeb5Jakob Stoklund Olesen MRI->addPhysRegsUsedFromRegMask(MO.getRegMask()); 348d9f0ff56a1878347fe5a0f162ef8c2ef2b63aeb5Jakob Stoklund Olesen 34936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // If we encounter a VirtReg or PhysReg then get at the PhysReg and add 35036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // it to the physreg bitset. Later we use only the PhysRegs that were 35136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // actually encountered in the MF to populate the MRI's used physregs. 35236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (MO.isReg() && MO.getReg()) 35336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines PhysRegs.insert( 35436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines TargetRegisterInfo::isVirtualRegister(MO.getReg()) ? 35536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines VRM->getPhys(MO.getReg()) : 35636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MO.getReg()); 35736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 358ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen if (!MO.isReg() || !TargetRegisterInfo::isVirtualRegister(MO.getReg())) 359ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen continue; 360ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen unsigned VirtReg = MO.getReg(); 36105ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen unsigned PhysReg = VRM->getPhys(VirtReg); 36205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen assert(PhysReg != VirtRegMap::NO_PHYS_REG && 36305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen "Instruction uses unmapped VirtReg"); 364fb9ebbf236974beac31705eaeb9f50ab585af6abJakob Stoklund Olesen assert(!MRI->isReserved(PhysReg) && "Reserved register assignment"); 365ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 366ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // Preserve semantics of sub-register operands. 367ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen if (MO.getSubReg()) { 368ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // A virtual register kill refers to the whole register, so we may 369200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen // have to add <imp-use,kill> operands for the super-register. A 370200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen // partial redef always kills and redefines the super-register. 371ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (NoSubRegLiveness && MO.readsReg() 372ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines && (MO.isDef() || MO.isKill())) 373200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen SuperKills.push_back(PhysReg); 374200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen 375200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen if (MO.isDef()) { 376200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen // The <def,undef> flag only makes sense for sub-register defs, and 377200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen // we are substituting a full physreg. An <imp-use,kill> operand 378200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen // from the SuperKills list will represent the partial read of the 379200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen // super-register. 380200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen MO.setIsUndef(false); 381200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen 382200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen // Also add implicit defs for the super-register. 383ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (NoSubRegLiveness) { 384ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (MO.isDead()) 385ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SuperDeads.push_back(PhysReg); 386ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines else 387ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SuperDefs.push_back(PhysReg); 388ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 389200a8cef256f6aade13692752a8fa8f6120cf04fJakob Stoklund Olesen } 390ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 391ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // PhysReg operands cannot have subregister indexes. 392ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen PhysReg = TRI->getSubReg(PhysReg, MO.getSubReg()); 393ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen assert(PhysReg && "Invalid SubReg for physical register"); 394ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen MO.setSubReg(0); 395ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen } 396ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // Rewrite. Note we could have used MachineOperand::substPhysReg(), but 397ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // we need the inlining here. 398ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen MO.setReg(PhysReg); 399ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen } 400ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 401ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // Add any missing super-register kills after rewriting the whole 402ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // instruction. 403ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen while (!SuperKills.empty()) 404ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen MI->addRegisterKilled(SuperKills.pop_back_val(), TRI, true); 405ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 40693e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen while (!SuperDeads.empty()) 40793e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen MI->addRegisterDead(SuperDeads.pop_back_val(), TRI, true); 40893e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen 40993e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen while (!SuperDefs.empty()) 41093e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen MI->addRegisterDefined(SuperDefs.pop_back_val(), TRI); 41193e110ba344ddc901dfb2af61d9c21002d8d3080Jakob Stoklund Olesen 412ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen DEBUG(dbgs() << "> " << *MI); 413ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 414ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // Finally, remove any identity copies. 415ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen if (MI->isIdentityCopy()) { 416cf5e5f3cc08a3c7ede5b423ee4b18586cb1079e9Jakob Stoklund Olesen ++NumIdCopies; 417280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen if (MI->getNumOperands() == 2) { 418280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen DEBUG(dbgs() << "Deleting identity copy.\n"); 419280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen if (Indexes) 420280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen Indexes->removeMachineInstrFromMaps(MI); 421280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen // It's safe to erase MI because MII has already been incremented. 422280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen MI->eraseFromParent(); 423280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen } else { 424280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen // Transform identity copy to a KILL to deal with subregisters. 425280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen MI->setDesc(TII->get(TargetOpcode::KILL)); 426280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen DEBUG(dbgs() << "Identity copy: " << *MI); 427280ea1a7466751c6d27ff343072c65e59a950053Jakob Stoklund Olesen } 428ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen } 429ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen } 430ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen } 431ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen 432ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen // Tell MRI about physical registers in use. 433ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet if (NoReturnInsts.empty()) { 43436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (SparseSet<unsigned>::iterator 43536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines RegI = PhysRegs.begin(), E = PhysRegs.end(); RegI != E; ++RegI) 43636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!MRI->reg_nodbg_empty(*RegI)) 43736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MRI->setPhysRegUsed(*RegI); 438ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet } else { 43936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (SparseSet<unsigned>::iterator 44036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines I = PhysRegs.begin(), E = PhysRegs.end(); I != E; ++I) { 44136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned Reg = *I; 442ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet if (MRI->reg_nodbg_empty(Reg)) 443ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet continue; 444ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet // Check if this register has a use that will impact the rest of the 445ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet // code. Uses in debug and noreturn instructions do not impact the 446ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet // generated code. 44736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (MachineInstr &It : MRI->reg_nodbg_instructions(Reg)) { 44836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!NoReturnInsts.count(&It)) { 449ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet MRI->setPhysRegUsed(Reg); 450ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet break; 451ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet } 452ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet } 453ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet } 454ce734f1f43b3c5f614b95b53e3ed86f65daca8ddQuentin Colombet } 455ba05c01dabc40373760a20c874103fc58d4377f0Jakob Stoklund Olesen} 45636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 457