2003-12-18 13:06:04 +00:00
|
|
|
//===-- TwoAddressInstructionPass.cpp - Two-Address instruction pass ------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2003-12-18 13:06:04 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2004-01-04 23:09:24 +00:00
|
|
|
// This file implements the TwoAddress instruction pass which is used
|
|
|
|
// by most register allocators. Two-Address instructions are rewritten
|
|
|
|
// from:
|
|
|
|
//
|
|
|
|
// A = B op C
|
|
|
|
//
|
|
|
|
// to:
|
|
|
|
//
|
|
|
|
// A = B
|
2004-02-04 22:17:40 +00:00
|
|
|
// A op= C
|
2003-12-18 13:06:04 +00:00
|
|
|
//
|
2004-02-04 22:17:40 +00:00
|
|
|
// Note that if a register allocator chooses to use this pass, that it
|
|
|
|
// has to be capable of handling the non-SSA nature of these rewritten
|
|
|
|
// virtual registers.
|
|
|
|
//
|
|
|
|
// It is also worth noting that the duplicate operand of the two
|
|
|
|
// address instruction is removed.
|
2004-01-31 21:07:15 +00:00
|
|
|
//
|
2003-12-18 13:06:04 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#define DEBUG_TYPE "twoaddrinstr"
|
2004-01-31 21:07:15 +00:00
|
|
|
#include "llvm/CodeGen/Passes.h"
|
2004-07-21 23:17:57 +00:00
|
|
|
#include "llvm/Function.h"
|
2012-08-03 22:58:34 +00:00
|
|
|
#include "llvm/CodeGen/LiveIntervalAnalysis.h"
|
2003-12-18 13:06:04 +00:00
|
|
|
#include "llvm/CodeGen/LiveVariables.h"
|
|
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
|
|
|
#include "llvm/CodeGen/MachineInstr.h"
|
2010-06-15 05:56:31 +00:00
|
|
|
#include "llvm/CodeGen/MachineInstrBuilder.h"
|
2007-12-31 04:13:23 +00:00
|
|
|
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
2009-10-09 23:27:56 +00:00
|
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
2011-11-14 19:48:55 +00:00
|
|
|
#include "llvm/MC/MCInstrItineraries.h"
|
2008-02-10 18:45:23 +00:00
|
|
|
#include "llvm/Target/TargetRegisterInfo.h"
|
2003-12-18 13:06:04 +00:00
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2008-10-07 20:22:28 +00:00
|
|
|
#include "llvm/Target/TargetOptions.h"
|
2008-03-13 06:37:55 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2010-05-05 18:45:40 +00:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2008-06-18 07:49:14 +00:00
|
|
|
#include "llvm/ADT/BitVector.h"
|
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2009-01-05 17:59:02 +00:00
|
|
|
#include "llvm/ADT/SmallSet.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2003-12-18 13:06:04 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2006-12-19 22:41:21 +00:00
|
|
|
STATISTIC(NumTwoAddressInstrs, "Number of two-address instructions");
|
|
|
|
STATISTIC(NumCommuted , "Number of instructions commuted to coalesce");
|
Teach 2addr pass to be do more commuting. If both uses of a two-address instruction are killed, but the first operand has a use before and after the def, commute if the second operand does not suffer from the same issue.
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1028
%reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
In this case, it might not be possible to coalesce the second MOV8rr
instruction if the first one is coalesced. So it would be profitable to
commute it:
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1029
%reg1030<def> = ADD8rr %reg1029<kill>, %reg1028<kill>, %EFLAGS<imp-def,dead>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62954 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-25 03:53:59 +00:00
|
|
|
STATISTIC(NumAggrCommuted , "Number of instructions aggressively commuted");
|
2006-12-19 22:41:21 +00:00
|
|
|
STATISTIC(NumConvertedTo3Addr, "Number of instructions promoted to 3-address");
|
2008-03-13 06:37:55 +00:00
|
|
|
STATISTIC(Num3AddrSunk, "Number of 3-address instructions sunk");
|
2011-11-14 19:48:55 +00:00
|
|
|
STATISTIC(NumReSchedUps, "Number of instructions re-scheduled up");
|
|
|
|
STATISTIC(NumReSchedDowns, "Number of instructions re-scheduled down");
|
2008-03-13 06:37:55 +00:00
|
|
|
|
2006-12-19 22:41:21 +00:00
|
|
|
namespace {
|
2009-10-25 06:33:48 +00:00
|
|
|
class TwoAddressInstructionPass : public MachineFunctionPass {
|
2012-08-03 23:25:45 +00:00
|
|
|
MachineFunction *MF;
|
2008-03-13 06:37:55 +00:00
|
|
|
const TargetInstrInfo *TII;
|
|
|
|
const TargetRegisterInfo *TRI;
|
2011-11-14 19:48:55 +00:00
|
|
|
const InstrItineraryData *InstrItins;
|
2008-03-13 06:37:55 +00:00
|
|
|
MachineRegisterInfo *MRI;
|
|
|
|
LiveVariables *LV;
|
2012-08-03 22:58:34 +00:00
|
|
|
SlotIndexes *Indexes;
|
|
|
|
LiveIntervals *LIS;
|
2009-10-09 23:27:56 +00:00
|
|
|
AliasAnalysis *AA;
|
2011-11-16 18:44:48 +00:00
|
|
|
CodeGenOpt::Level OptLevel;
|
2008-03-13 06:37:55 +00:00
|
|
|
|
2009-03-01 02:03:43 +00:00
|
|
|
// DistanceMap - Keep track the distance of a MI from the start of the
|
|
|
|
// current basic block.
|
|
|
|
DenseMap<MachineInstr*, unsigned> DistanceMap;
|
|
|
|
|
|
|
|
// SrcRegMap - A map from virtual registers to physical registers which
|
|
|
|
// are likely targets to be coalesced to due to copies from physical
|
|
|
|
// registers to virtual registers. e.g. v1024 = move r0.
|
|
|
|
DenseMap<unsigned, unsigned> SrcRegMap;
|
|
|
|
|
|
|
|
// DstRegMap - A map from virtual registers to physical registers which
|
|
|
|
// are likely targets to be coalesced to due to copies to physical
|
|
|
|
// registers from virtual registers. e.g. r1 = move v1024.
|
|
|
|
DenseMap<unsigned, unsigned> DstRegMap;
|
|
|
|
|
2010-05-05 18:45:40 +00:00
|
|
|
/// RegSequences - Keep track the list of REG_SEQUENCE instructions seen
|
|
|
|
/// during the initial walk of the machine function.
|
|
|
|
SmallVector<MachineInstr*, 16> RegSequences;
|
|
|
|
|
2008-05-10 00:12:52 +00:00
|
|
|
bool Sink3AddrInstruction(MachineBasicBlock *MBB, MachineInstr *MI,
|
|
|
|
unsigned Reg,
|
|
|
|
MachineBasicBlock::iterator OldPos);
|
2008-06-18 07:49:14 +00:00
|
|
|
|
Teach 2addr pass to be do more commuting. If both uses of a two-address instruction are killed, but the first operand has a use before and after the def, commute if the second operand does not suffer from the same issue.
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1028
%reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
In this case, it might not be possible to coalesce the second MOV8rr
instruction if the first one is coalesced. So it would be profitable to
commute it:
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1029
%reg1030<def> = ADD8rr %reg1029<kill>, %reg1028<kill>, %EFLAGS<imp-def,dead>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62954 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-25 03:53:59 +00:00
|
|
|
bool NoUseAfterLastDef(unsigned Reg, MachineBasicBlock *MBB, unsigned Dist,
|
|
|
|
unsigned &LastDef);
|
|
|
|
|
2012-05-03 01:45:13 +00:00
|
|
|
bool isProfitableToCommute(unsigned regA, unsigned regB, unsigned regC,
|
Teach 2addr pass to be do more commuting. If both uses of a two-address instruction are killed, but the first operand has a use before and after the def, commute if the second operand does not suffer from the same issue.
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1028
%reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
In this case, it might not be possible to coalesce the second MOV8rr
instruction if the first one is coalesced. So it would be profitable to
commute it:
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1029
%reg1030<def> = ADD8rr %reg1029<kill>, %reg1028<kill>, %EFLAGS<imp-def,dead>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62954 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-25 03:53:59 +00:00
|
|
|
MachineInstr *MI, MachineBasicBlock *MBB,
|
2009-03-01 02:03:43 +00:00
|
|
|
unsigned Dist);
|
Teach 2addr pass to be do more commuting. If both uses of a two-address instruction are killed, but the first operand has a use before and after the def, commute if the second operand does not suffer from the same issue.
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1028
%reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
In this case, it might not be possible to coalesce the second MOV8rr
instruction if the first one is coalesced. So it would be profitable to
commute it:
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1029
%reg1030<def> = ADD8rr %reg1029<kill>, %reg1028<kill>, %EFLAGS<imp-def,dead>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62954 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-25 03:53:59 +00:00
|
|
|
|
2009-01-23 23:27:33 +00:00
|
|
|
bool CommuteInstruction(MachineBasicBlock::iterator &mi,
|
|
|
|
MachineFunction::iterator &mbbi,
|
2009-03-01 02:03:43 +00:00
|
|
|
unsigned RegB, unsigned RegC, unsigned Dist);
|
|
|
|
|
2011-03-02 01:08:17 +00:00
|
|
|
bool isProfitableToConv3Addr(unsigned RegA, unsigned RegB);
|
2009-03-30 21:34:07 +00:00
|
|
|
|
|
|
|
bool ConvertInstTo3Addr(MachineBasicBlock::iterator &mi,
|
|
|
|
MachineBasicBlock::iterator &nmi,
|
|
|
|
MachineFunction::iterator &mbbi,
|
2011-02-10 02:20:55 +00:00
|
|
|
unsigned RegA, unsigned RegB, unsigned Dist);
|
2009-03-30 21:34:07 +00:00
|
|
|
|
2011-11-14 19:48:55 +00:00
|
|
|
bool isDefTooClose(unsigned Reg, unsigned Dist,
|
|
|
|
MachineInstr *MI, MachineBasicBlock *MBB);
|
|
|
|
|
|
|
|
bool RescheduleMIBelowKill(MachineBasicBlock *MBB,
|
|
|
|
MachineBasicBlock::iterator &mi,
|
|
|
|
MachineBasicBlock::iterator &nmi,
|
|
|
|
unsigned Reg);
|
|
|
|
bool RescheduleKillAboveMI(MachineBasicBlock *MBB,
|
|
|
|
MachineBasicBlock::iterator &mi,
|
|
|
|
MachineBasicBlock::iterator &nmi,
|
|
|
|
unsigned Reg);
|
|
|
|
|
2009-09-03 20:58:42 +00:00
|
|
|
bool TryInstructionTransform(MachineBasicBlock::iterator &mi,
|
|
|
|
MachineBasicBlock::iterator &nmi,
|
|
|
|
MachineFunction::iterator &mbbi,
|
|
|
|
unsigned SrcIdx, unsigned DstIdx,
|
2011-03-02 01:08:17 +00:00
|
|
|
unsigned Dist,
|
|
|
|
SmallPtrSet<MachineInstr*, 8> &Processed);
|
|
|
|
|
|
|
|
void ScanUses(unsigned DstReg, MachineBasicBlock *MBB,
|
|
|
|
SmallPtrSet<MachineInstr*, 8> &Processed);
|
2009-09-03 20:58:42 +00:00
|
|
|
|
2009-03-01 02:03:43 +00:00
|
|
|
void ProcessCopy(MachineInstr *MI, MachineBasicBlock *MBB,
|
|
|
|
SmallPtrSet<MachineInstr*, 8> &Processed);
|
2009-08-07 00:28:58 +00:00
|
|
|
|
2012-08-03 23:57:58 +00:00
|
|
|
typedef SmallVector<std::pair<unsigned, unsigned>, 4> TiedPairList;
|
|
|
|
typedef SmallDenseMap<unsigned, TiedPairList> TiedOperandMap;
|
2012-08-03 23:25:45 +00:00
|
|
|
bool collectTiedOperands(MachineInstr *MI, TiedOperandMap&);
|
2012-08-03 23:57:58 +00:00
|
|
|
void processTiedPairs(MachineInstr *MI, TiedPairList&, unsigned &Dist);
|
2012-08-03 23:25:45 +00:00
|
|
|
|
2010-05-17 20:57:12 +00:00
|
|
|
void CoalesceExtSubRegs(SmallVector<unsigned,4> &Srcs, unsigned DstReg);
|
|
|
|
|
2010-05-05 18:45:40 +00:00
|
|
|
/// EliminateRegSequences - Eliminate REG_SEQUENCE instructions as part
|
|
|
|
/// of the de-ssa process. This replaces sources of REG_SEQUENCE as
|
|
|
|
/// sub-register references of the register defined by REG_SEQUENCE.
|
|
|
|
bool EliminateRegSequences();
|
2010-05-17 23:24:12 +00:00
|
|
|
|
2008-03-13 06:37:55 +00:00
|
|
|
public:
|
2007-05-06 13:37:16 +00:00
|
|
|
static char ID; // Pass identification, replacement for typeid
|
2010-10-19 17:21:58 +00:00
|
|
|
TwoAddressInstructionPass() : MachineFunctionPass(ID) {
|
|
|
|
initializeTwoAddressInstructionPassPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2007-05-01 21:15:47 +00:00
|
|
|
|
2008-05-10 00:12:52 +00:00
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
2009-07-31 23:37:33 +00:00
|
|
|
AU.setPreservesCFG();
|
2009-10-09 23:27:56 +00:00
|
|
|
AU.addRequired<AliasAnalysis>();
|
2008-05-10 00:12:52 +00:00
|
|
|
AU.addPreserved<LiveVariables>();
|
2012-08-03 22:58:34 +00:00
|
|
|
AU.addPreserved<SlotIndexes>();
|
|
|
|
AU.addPreserved<LiveIntervals>();
|
2008-05-10 00:12:52 +00:00
|
|
|
AU.addPreservedID(MachineLoopInfoID);
|
|
|
|
AU.addPreservedID(MachineDominatorsID);
|
|
|
|
MachineFunctionPass::getAnalysisUsage(AU);
|
|
|
|
}
|
2003-12-18 22:40:24 +00:00
|
|
|
|
2008-05-10 00:12:52 +00:00
|
|
|
/// runOnMachineFunction - Pass entry point.
|
2004-07-22 15:26:23 +00:00
|
|
|
bool runOnMachineFunction(MachineFunction&);
|
|
|
|
};
|
2006-05-24 17:04:05 +00:00
|
|
|
}
|
2003-12-18 13:06:04 +00:00
|
|
|
|
2008-05-13 00:00:25 +00:00
|
|
|
char TwoAddressInstructionPass::ID = 0;
|
2010-10-12 19:48:12 +00:00
|
|
|
INITIALIZE_PASS_BEGIN(TwoAddressInstructionPass, "twoaddressinstruction",
|
|
|
|
"Two-Address instruction pass", false, false)
|
|
|
|
INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
|
|
|
|
INITIALIZE_PASS_END(TwoAddressInstructionPass, "twoaddressinstruction",
|
2010-10-07 22:25:06 +00:00
|
|
|
"Two-Address instruction pass", false, false)
|
2008-05-13 00:00:25 +00:00
|
|
|
|
2010-08-06 18:33:48 +00:00
|
|
|
char &llvm::TwoAddressInstructionPassID = TwoAddressInstructionPass::ID;
|
2003-12-18 22:40:24 +00:00
|
|
|
|
2008-03-13 06:37:55 +00:00
|
|
|
/// Sink3AddrInstruction - A two-address instruction has been converted to a
|
|
|
|
/// three-address instruction to avoid clobbering a register. Try to sink it
|
2008-05-10 00:12:52 +00:00
|
|
|
/// past the instruction that would kill the above mentioned register to reduce
|
|
|
|
/// register pressure.
|
2008-03-13 06:37:55 +00:00
|
|
|
bool TwoAddressInstructionPass::Sink3AddrInstruction(MachineBasicBlock *MBB,
|
|
|
|
MachineInstr *MI, unsigned SavedReg,
|
|
|
|
MachineBasicBlock::iterator OldPos) {
|
2011-09-23 22:41:57 +00:00
|
|
|
// FIXME: Shouldn't we be trying to do this before we three-addressify the
|
|
|
|
// instruction? After this transformation is done, we no longer need
|
|
|
|
// the instruction to be in three-address form.
|
|
|
|
|
2008-03-13 06:37:55 +00:00
|
|
|
// Check if it's safe to move this instruction.
|
|
|
|
bool SeenStore = true; // Be conservative.
|
2010-03-02 19:03:01 +00:00
|
|
|
if (!MI->isSafeToMove(TII, AA, SeenStore))
|
2008-03-13 06:37:55 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
unsigned DefReg = 0;
|
|
|
|
SmallSet<unsigned, 4> UseRegs;
|
2008-05-10 00:12:52 +00:00
|
|
|
|
2008-03-13 06:37:55 +00:00
|
|
|
for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
|
|
|
|
const MachineOperand &MO = MI->getOperand(i);
|
2008-10-03 15:45:36 +00:00
|
|
|
if (!MO.isReg())
|
2008-03-13 06:37:55 +00:00
|
|
|
continue;
|
|
|
|
unsigned MOReg = MO.getReg();
|
|
|
|
if (!MOReg)
|
|
|
|
continue;
|
|
|
|
if (MO.isUse() && MOReg != SavedReg)
|
|
|
|
UseRegs.insert(MO.getReg());
|
|
|
|
if (!MO.isDef())
|
|
|
|
continue;
|
|
|
|
if (MO.isImplicit())
|
|
|
|
// Don't try to move it if it implicitly defines a register.
|
|
|
|
return false;
|
|
|
|
if (DefReg)
|
|
|
|
// For now, don't move any instructions that define multiple registers.
|
|
|
|
return false;
|
|
|
|
DefReg = MO.getReg();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find the instruction that kills SavedReg.
|
|
|
|
MachineInstr *KillMI = NULL;
|
2010-03-23 20:36:12 +00:00
|
|
|
for (MachineRegisterInfo::use_nodbg_iterator
|
|
|
|
UI = MRI->use_nodbg_begin(SavedReg),
|
|
|
|
UE = MRI->use_nodbg_end(); UI != UE; ++UI) {
|
2008-03-13 06:37:55 +00:00
|
|
|
MachineOperand &UseMO = UI.getOperand();
|
|
|
|
if (!UseMO.isKill())
|
|
|
|
continue;
|
|
|
|
KillMI = UseMO.getParent();
|
|
|
|
break;
|
|
|
|
}
|
2008-05-10 00:12:52 +00:00
|
|
|
|
2011-09-23 22:41:57 +00:00
|
|
|
// If we find the instruction that kills SavedReg, and it is in an
|
|
|
|
// appropriate location, we can try to sink the current instruction
|
|
|
|
// past it.
|
|
|
|
if (!KillMI || KillMI->getParent() != MBB || KillMI == MI ||
|
2012-08-09 22:08:26 +00:00
|
|
|
KillMI == OldPos || KillMI->isTerminator())
|
2008-03-13 06:37:55 +00:00
|
|
|
return false;
|
|
|
|
|
2008-05-10 00:12:52 +00:00
|
|
|
// If any of the definitions are used by another instruction between the
|
|
|
|
// position and the kill use, then it's not safe to sink it.
|
2012-02-03 05:12:30 +00:00
|
|
|
//
|
2008-05-10 00:12:52 +00:00
|
|
|
// FIXME: This can be sped up if there is an easy way to query whether an
|
2008-06-18 07:49:14 +00:00
|
|
|
// instruction is before or after another instruction. Then we can use
|
2008-05-10 00:12:52 +00:00
|
|
|
// MachineRegisterInfo def / use instead.
|
2008-03-13 06:37:55 +00:00
|
|
|
MachineOperand *KillMO = NULL;
|
|
|
|
MachineBasicBlock::iterator KillPos = KillMI;
|
|
|
|
++KillPos;
|
2008-05-10 00:12:52 +00:00
|
|
|
|
2008-06-18 07:49:14 +00:00
|
|
|
unsigned NumVisited = 0;
|
2009-12-03 00:50:42 +00:00
|
|
|
for (MachineBasicBlock::iterator I = llvm::next(OldPos); I != KillPos; ++I) {
|
2008-03-13 06:37:55 +00:00
|
|
|
MachineInstr *OtherMI = I;
|
2010-02-11 18:22:31 +00:00
|
|
|
// DBG_VALUE cannot be counted against the limit.
|
|
|
|
if (OtherMI->isDebugValue())
|
|
|
|
continue;
|
2008-06-18 07:49:14 +00:00
|
|
|
if (NumVisited > 30) // FIXME: Arbitrary limit to reduce compile time cost.
|
|
|
|
return false;
|
|
|
|
++NumVisited;
|
2008-03-13 06:37:55 +00:00
|
|
|
for (unsigned i = 0, e = OtherMI->getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = OtherMI->getOperand(i);
|
2008-10-03 15:45:36 +00:00
|
|
|
if (!MO.isReg())
|
2008-03-13 06:37:55 +00:00
|
|
|
continue;
|
|
|
|
unsigned MOReg = MO.getReg();
|
|
|
|
if (!MOReg)
|
|
|
|
continue;
|
|
|
|
if (DefReg == MOReg)
|
|
|
|
return false;
|
2008-05-10 00:12:52 +00:00
|
|
|
|
2008-03-13 06:37:55 +00:00
|
|
|
if (MO.isKill()) {
|
|
|
|
if (OtherMI == KillMI && MOReg == SavedReg)
|
2008-06-18 07:49:14 +00:00
|
|
|
// Save the operand that kills the register. We want to unset the kill
|
|
|
|
// marker if we can sink MI past it.
|
2008-03-13 06:37:55 +00:00
|
|
|
KillMO = &MO;
|
|
|
|
else if (UseRegs.count(MOReg))
|
|
|
|
// One of the uses is killed before the destination.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-08-09 22:08:26 +00:00
|
|
|
assert(KillMO && "Didn't find kill");
|
2008-03-13 06:37:55 +00:00
|
|
|
|
|
|
|
// Update kill and LV information.
|
|
|
|
KillMO->setIsKill(false);
|
|
|
|
KillMO = MI->findRegisterUseOperand(SavedReg, false, TRI);
|
|
|
|
KillMO->setIsKill(true);
|
2012-02-03 05:12:30 +00:00
|
|
|
|
2008-07-03 09:09:37 +00:00
|
|
|
if (LV)
|
|
|
|
LV->replaceKillInstruction(SavedReg, KillMI, MI);
|
2008-03-13 06:37:55 +00:00
|
|
|
|
|
|
|
// Move instruction to its destination.
|
|
|
|
MBB->remove(MI);
|
|
|
|
MBB->insert(KillPos, MI);
|
|
|
|
|
2012-08-03 22:58:34 +00:00
|
|
|
if (LIS)
|
|
|
|
LIS->handleMove(MI);
|
|
|
|
|
2008-03-13 06:37:55 +00:00
|
|
|
++Num3AddrSunk;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
Teach 2addr pass to be do more commuting. If both uses of a two-address instruction are killed, but the first operand has a use before and after the def, commute if the second operand does not suffer from the same issue.
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1028
%reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
In this case, it might not be possible to coalesce the second MOV8rr
instruction if the first one is coalesced. So it would be profitable to
commute it:
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1029
%reg1030<def> = ADD8rr %reg1029<kill>, %reg1028<kill>, %EFLAGS<imp-def,dead>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62954 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-25 03:53:59 +00:00
|
|
|
/// NoUseAfterLastDef - Return true if there are no intervening uses between the
|
|
|
|
/// last instruction in the MBB that defines the specified register and the
|
|
|
|
/// two-address instruction which is being processed. It also returns the last
|
|
|
|
/// def location by reference
|
|
|
|
bool TwoAddressInstructionPass::NoUseAfterLastDef(unsigned Reg,
|
2009-03-01 02:03:43 +00:00
|
|
|
MachineBasicBlock *MBB, unsigned Dist,
|
|
|
|
unsigned &LastDef) {
|
Teach 2addr pass to be do more commuting. If both uses of a two-address instruction are killed, but the first operand has a use before and after the def, commute if the second operand does not suffer from the same issue.
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1028
%reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
In this case, it might not be possible to coalesce the second MOV8rr
instruction if the first one is coalesced. So it would be profitable to
commute it:
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1029
%reg1030<def> = ADD8rr %reg1029<kill>, %reg1028<kill>, %EFLAGS<imp-def,dead>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62954 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-25 03:53:59 +00:00
|
|
|
LastDef = 0;
|
|
|
|
unsigned LastUse = Dist;
|
|
|
|
for (MachineRegisterInfo::reg_iterator I = MRI->reg_begin(Reg),
|
|
|
|
E = MRI->reg_end(); I != E; ++I) {
|
|
|
|
MachineOperand &MO = I.getOperand();
|
|
|
|
MachineInstr *MI = MO.getParent();
|
2010-02-09 19:54:29 +00:00
|
|
|
if (MI->getParent() != MBB || MI->isDebugValue())
|
2010-02-09 02:01:46 +00:00
|
|
|
continue;
|
Teach 2addr pass to be do more commuting. If both uses of a two-address instruction are killed, but the first operand has a use before and after the def, commute if the second operand does not suffer from the same issue.
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1028
%reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
In this case, it might not be possible to coalesce the second MOV8rr
instruction if the first one is coalesced. So it would be profitable to
commute it:
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1029
%reg1030<def> = ADD8rr %reg1029<kill>, %reg1028<kill>, %EFLAGS<imp-def,dead>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62954 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-25 03:53:59 +00:00
|
|
|
DenseMap<MachineInstr*, unsigned>::iterator DI = DistanceMap.find(MI);
|
|
|
|
if (DI == DistanceMap.end())
|
|
|
|
continue;
|
|
|
|
if (MO.isUse() && DI->second < LastUse)
|
|
|
|
LastUse = DI->second;
|
|
|
|
if (MO.isDef() && DI->second > LastDef)
|
|
|
|
LastDef = DI->second;
|
|
|
|
}
|
|
|
|
|
|
|
|
return !(LastUse > LastDef && LastUse < Dist);
|
|
|
|
}
|
|
|
|
|
2009-03-01 02:03:43 +00:00
|
|
|
/// isCopyToReg - Return true if the specified MI is a copy instruction or
|
|
|
|
/// a extract_subreg instruction. It also returns the source and destination
|
|
|
|
/// registers and whether they are physical registers by reference.
|
|
|
|
static bool isCopyToReg(MachineInstr &MI, const TargetInstrInfo *TII,
|
|
|
|
unsigned &SrcReg, unsigned &DstReg,
|
|
|
|
bool &IsSrcPhys, bool &IsDstPhys) {
|
|
|
|
SrcReg = 0;
|
|
|
|
DstReg = 0;
|
2010-07-16 04:45:42 +00:00
|
|
|
if (MI.isCopy()) {
|
|
|
|
DstReg = MI.getOperand(0).getReg();
|
|
|
|
SrcReg = MI.getOperand(1).getReg();
|
|
|
|
} else if (MI.isInsertSubreg() || MI.isSubregToReg()) {
|
|
|
|
DstReg = MI.getOperand(0).getReg();
|
|
|
|
SrcReg = MI.getOperand(2).getReg();
|
|
|
|
} else
|
|
|
|
return false;
|
2009-03-01 02:03:43 +00:00
|
|
|
|
2010-07-16 04:45:42 +00:00
|
|
|
IsSrcPhys = TargetRegisterInfo::isPhysicalRegister(SrcReg);
|
|
|
|
IsDstPhys = TargetRegisterInfo::isPhysicalRegister(DstReg);
|
|
|
|
return true;
|
2009-03-01 02:03:43 +00:00
|
|
|
}
|
|
|
|
|
Implement support for using modeling implicit-zero-extension on x86-64
with SUBREG_TO_REG, teach SimpleRegisterCoalescing to coalesce
SUBREG_TO_REG instructions (which are similar to INSERT_SUBREG
instructions), and teach the DAGCombiner to take advantage of this on
targets which support it. This eliminates many redundant
zero-extension operations on x86-64.
This adds a new TargetLowering hook, isZExtFree. It's similar to
isTruncateFree, except it only applies to actual definitions, and not
no-op truncates which may not zero the high bits.
Also, this adds a new optimization to SimplifyDemandedBits: transform
operations like x+y into (zext (add (trunc x), (trunc y))) on targets
where all the casts are no-ops. In contexts where the high part of the
add is explicitly masked off, this allows the mask operation to be
eliminated. Fix the DAGCombiner to avoid undoing these transformations
to eliminate casts on targets where the casts are no-ops.
Also, this adds a new two-address lowering heuristic. Since
two-address lowering runs before coalescing, it helps to be able to
look through copies when deciding whether commuting and/or
three-address conversion are profitable.
Also, fix a bug in LiveInterval::MergeInClobberRanges. It didn't handle
the case that a clobber range extended both before and beyond an
existing live range. In that case, multiple live ranges need to be
added. This was exposed by the new subreg coalescing code.
Remove 2008-05-06-SpillerBug.ll. It was bugpoint-reduced, and the
spiller behavior it was looking for no longer occurrs with the new
instruction selection.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@68576 91177308-0d34-0410-b5e6-96231b3b80d8
2009-04-08 00:15:30 +00:00
|
|
|
/// isKilled - Test if the given register value, which is used by the given
|
|
|
|
/// instruction, is killed by the given instruction. This looks through
|
|
|
|
/// coalescable copies to see if the original value is potentially not killed.
|
|
|
|
///
|
|
|
|
/// For example, in this code:
|
|
|
|
///
|
|
|
|
/// %reg1034 = copy %reg1024
|
|
|
|
/// %reg1035 = copy %reg1025<kill>
|
|
|
|
/// %reg1036 = add %reg1034<kill>, %reg1035<kill>
|
|
|
|
///
|
|
|
|
/// %reg1034 is not considered to be killed, since it is copied from a
|
|
|
|
/// register which is not killed. Treating it as not killed lets the
|
|
|
|
/// normal heuristics commute the (two-address) add, which lets
|
|
|
|
/// coalescing eliminate the extra copy.
|
|
|
|
///
|
|
|
|
static bool isKilled(MachineInstr &MI, unsigned Reg,
|
|
|
|
const MachineRegisterInfo *MRI,
|
|
|
|
const TargetInstrInfo *TII) {
|
|
|
|
MachineInstr *DefMI = &MI;
|
|
|
|
for (;;) {
|
|
|
|
if (!DefMI->killsRegister(Reg))
|
|
|
|
return false;
|
|
|
|
if (TargetRegisterInfo::isPhysicalRegister(Reg))
|
|
|
|
return true;
|
|
|
|
MachineRegisterInfo::def_iterator Begin = MRI->def_begin(Reg);
|
|
|
|
// If there are multiple defs, we can't do a simple analysis, so just
|
|
|
|
// go with what the kill flag says.
|
2009-12-03 00:50:42 +00:00
|
|
|
if (llvm::next(Begin) != MRI->def_end())
|
Implement support for using modeling implicit-zero-extension on x86-64
with SUBREG_TO_REG, teach SimpleRegisterCoalescing to coalesce
SUBREG_TO_REG instructions (which are similar to INSERT_SUBREG
instructions), and teach the DAGCombiner to take advantage of this on
targets which support it. This eliminates many redundant
zero-extension operations on x86-64.
This adds a new TargetLowering hook, isZExtFree. It's similar to
isTruncateFree, except it only applies to actual definitions, and not
no-op truncates which may not zero the high bits.
Also, this adds a new optimization to SimplifyDemandedBits: transform
operations like x+y into (zext (add (trunc x), (trunc y))) on targets
where all the casts are no-ops. In contexts where the high part of the
add is explicitly masked off, this allows the mask operation to be
eliminated. Fix the DAGCombiner to avoid undoing these transformations
to eliminate casts on targets where the casts are no-ops.
Also, this adds a new two-address lowering heuristic. Since
two-address lowering runs before coalescing, it helps to be able to
look through copies when deciding whether commuting and/or
three-address conversion are profitable.
Also, fix a bug in LiveInterval::MergeInClobberRanges. It didn't handle
the case that a clobber range extended both before and beyond an
existing live range. In that case, multiple live ranges need to be
added. This was exposed by the new subreg coalescing code.
Remove 2008-05-06-SpillerBug.ll. It was bugpoint-reduced, and the
spiller behavior it was looking for no longer occurrs with the new
instruction selection.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@68576 91177308-0d34-0410-b5e6-96231b3b80d8
2009-04-08 00:15:30 +00:00
|
|
|
return true;
|
|
|
|
DefMI = &*Begin;
|
|
|
|
bool IsSrcPhys, IsDstPhys;
|
|
|
|
unsigned SrcReg, DstReg;
|
|
|
|
// If the def is something other than a copy, then it isn't going to
|
|
|
|
// be coalesced, so follow the kill flag.
|
|
|
|
if (!isCopyToReg(*DefMI, TII, SrcReg, DstReg, IsSrcPhys, IsDstPhys))
|
|
|
|
return true;
|
|
|
|
Reg = SrcReg;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-01 02:03:43 +00:00
|
|
|
/// isTwoAddrUse - Return true if the specified MI uses the specified register
|
|
|
|
/// as a two-address use. If so, return the destination register by reference.
|
|
|
|
static bool isTwoAddrUse(MachineInstr &MI, unsigned Reg, unsigned &DstReg) {
|
2011-06-28 19:10:37 +00:00
|
|
|
const MCInstrDesc &MCID = MI.getDesc();
|
|
|
|
unsigned NumOps = MI.isInlineAsm()
|
|
|
|
? MI.getNumOperands() : MCID.getNumOperands();
|
2009-03-30 21:34:07 +00:00
|
|
|
for (unsigned i = 0; i != NumOps; ++i) {
|
2009-03-01 02:03:43 +00:00
|
|
|
const MachineOperand &MO = MI.getOperand(i);
|
|
|
|
if (!MO.isReg() || !MO.isUse() || MO.getReg() != Reg)
|
|
|
|
continue;
|
2009-03-19 20:30:06 +00:00
|
|
|
unsigned ti;
|
|
|
|
if (MI.isRegTiedToDefOperand(i, &ti)) {
|
2009-03-01 02:03:43 +00:00
|
|
|
DstReg = MI.getOperand(ti).getReg();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// findOnlyInterestingUse - Given a register, if has a single in-basic block
|
|
|
|
/// use, return the use instruction if it's a copy or a two-address use.
|
|
|
|
static
|
|
|
|
MachineInstr *findOnlyInterestingUse(unsigned Reg, MachineBasicBlock *MBB,
|
|
|
|
MachineRegisterInfo *MRI,
|
|
|
|
const TargetInstrInfo *TII,
|
2009-04-14 00:32:25 +00:00
|
|
|
bool &IsCopy,
|
2009-03-01 02:03:43 +00:00
|
|
|
unsigned &DstReg, bool &IsDstPhys) {
|
2010-03-03 21:18:38 +00:00
|
|
|
if (!MRI->hasOneNonDBGUse(Reg))
|
|
|
|
// None or more than one use.
|
2009-03-01 02:03:43 +00:00
|
|
|
return 0;
|
2010-03-03 21:18:38 +00:00
|
|
|
MachineInstr &UseMI = *MRI->use_nodbg_begin(Reg);
|
2009-03-01 02:03:43 +00:00
|
|
|
if (UseMI.getParent() != MBB)
|
|
|
|
return 0;
|
|
|
|
unsigned SrcReg;
|
|
|
|
bool IsSrcPhys;
|
2009-04-14 00:32:25 +00:00
|
|
|
if (isCopyToReg(UseMI, TII, SrcReg, DstReg, IsSrcPhys, IsDstPhys)) {
|
|
|
|
IsCopy = true;
|
2009-03-01 02:03:43 +00:00
|
|
|
return &UseMI;
|
2009-04-14 00:32:25 +00:00
|
|
|
}
|
2009-03-01 02:03:43 +00:00
|
|
|
IsDstPhys = false;
|
2009-04-14 00:32:25 +00:00
|
|
|
if (isTwoAddrUse(UseMI, Reg, DstReg)) {
|
|
|
|
IsDstPhys = TargetRegisterInfo::isPhysicalRegister(DstReg);
|
2009-03-01 02:03:43 +00:00
|
|
|
return &UseMI;
|
2009-04-14 00:32:25 +00:00
|
|
|
}
|
2009-03-01 02:03:43 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getMappedReg - Return the physical register the specified virtual register
|
|
|
|
/// might be mapped to.
|
|
|
|
static unsigned
|
|
|
|
getMappedReg(unsigned Reg, DenseMap<unsigned, unsigned> &RegMap) {
|
|
|
|
while (TargetRegisterInfo::isVirtualRegister(Reg)) {
|
|
|
|
DenseMap<unsigned, unsigned>::iterator SI = RegMap.find(Reg);
|
|
|
|
if (SI == RegMap.end())
|
|
|
|
return 0;
|
|
|
|
Reg = SI->second;
|
|
|
|
}
|
|
|
|
if (TargetRegisterInfo::isPhysicalRegister(Reg))
|
|
|
|
return Reg;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// regsAreCompatible - Return true if the two registers are equal or aliased.
|
|
|
|
///
|
|
|
|
static bool
|
|
|
|
regsAreCompatible(unsigned RegA, unsigned RegB, const TargetRegisterInfo *TRI) {
|
|
|
|
if (RegA == RegB)
|
|
|
|
return true;
|
|
|
|
if (!RegA || !RegB)
|
|
|
|
return false;
|
|
|
|
return TRI->regsOverlap(RegA, RegB);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-07-25 18:28:13 +00:00
|
|
|
/// isProfitableToCommute - Return true if it's potentially profitable to commute
|
Teach 2addr pass to be do more commuting. If both uses of a two-address instruction are killed, but the first operand has a use before and after the def, commute if the second operand does not suffer from the same issue.
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1028
%reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
In this case, it might not be possible to coalesce the second MOV8rr
instruction if the first one is coalesced. So it would be profitable to
commute it:
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1029
%reg1030<def> = ADD8rr %reg1029<kill>, %reg1028<kill>, %EFLAGS<imp-def,dead>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62954 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-25 03:53:59 +00:00
|
|
|
/// the two-address instruction that's being processed.
|
|
|
|
bool
|
2012-05-03 01:45:13 +00:00
|
|
|
TwoAddressInstructionPass::isProfitableToCommute(unsigned regA, unsigned regB,
|
|
|
|
unsigned regC,
|
2009-03-01 02:03:43 +00:00
|
|
|
MachineInstr *MI, MachineBasicBlock *MBB,
|
|
|
|
unsigned Dist) {
|
2011-11-16 18:44:48 +00:00
|
|
|
if (OptLevel == CodeGenOpt::None)
|
|
|
|
return false;
|
|
|
|
|
Teach 2addr pass to be do more commuting. If both uses of a two-address instruction are killed, but the first operand has a use before and after the def, commute if the second operand does not suffer from the same issue.
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1028
%reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
In this case, it might not be possible to coalesce the second MOV8rr
instruction if the first one is coalesced. So it would be profitable to
commute it:
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1029
%reg1030<def> = ADD8rr %reg1029<kill>, %reg1028<kill>, %EFLAGS<imp-def,dead>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62954 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-25 03:53:59 +00:00
|
|
|
// Determine if it's profitable to commute this two address instruction. In
|
|
|
|
// general, we want no uses between this instruction and the definition of
|
|
|
|
// the two-address register.
|
|
|
|
// e.g.
|
|
|
|
// %reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
|
|
|
|
// %reg1029<def> = MOV8rr %reg1028
|
|
|
|
// %reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
|
|
|
|
// insert => %reg1030<def> = MOV8rr %reg1028
|
|
|
|
// %reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
|
|
|
|
// In this case, it might not be possible to coalesce the second MOV8rr
|
|
|
|
// instruction if the first one is coalesced. So it would be profitable to
|
|
|
|
// commute it:
|
|
|
|
// %reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
|
|
|
|
// %reg1029<def> = MOV8rr %reg1028
|
|
|
|
// %reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
|
|
|
|
// insert => %reg1030<def> = MOV8rr %reg1029
|
2012-02-03 05:12:30 +00:00
|
|
|
// %reg1030<def> = ADD8rr %reg1029<kill>, %reg1028<kill>, %EFLAGS<imp-def,dead>
|
Teach 2addr pass to be do more commuting. If both uses of a two-address instruction are killed, but the first operand has a use before and after the def, commute if the second operand does not suffer from the same issue.
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1028
%reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
In this case, it might not be possible to coalesce the second MOV8rr
instruction if the first one is coalesced. So it would be profitable to
commute it:
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1029
%reg1030<def> = ADD8rr %reg1029<kill>, %reg1028<kill>, %EFLAGS<imp-def,dead>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62954 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-25 03:53:59 +00:00
|
|
|
|
|
|
|
if (!MI->killsRegister(regC))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Ok, we have something like:
|
|
|
|
// %reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
|
|
|
|
// let's see if it's worth commuting it.
|
|
|
|
|
2009-03-01 02:03:43 +00:00
|
|
|
// Look for situations like this:
|
|
|
|
// %reg1024<def> = MOV r1
|
|
|
|
// %reg1025<def> = MOV r0
|
|
|
|
// %reg1026<def> = ADD %reg1024, %reg1025
|
|
|
|
// r0 = MOV %reg1026
|
|
|
|
// Commute the ADD to hopefully eliminate an otherwise unavoidable copy.
|
2012-05-03 01:45:13 +00:00
|
|
|
unsigned ToRegA = getMappedReg(regA, DstRegMap);
|
|
|
|
if (ToRegA) {
|
|
|
|
unsigned FromRegB = getMappedReg(regB, SrcRegMap);
|
|
|
|
unsigned FromRegC = getMappedReg(regC, SrcRegMap);
|
|
|
|
bool BComp = !FromRegB || regsAreCompatible(FromRegB, ToRegA, TRI);
|
|
|
|
bool CComp = !FromRegC || regsAreCompatible(FromRegC, ToRegA, TRI);
|
|
|
|
if (BComp != CComp)
|
|
|
|
return !BComp && CComp;
|
|
|
|
}
|
2009-03-01 02:03:43 +00:00
|
|
|
|
Teach 2addr pass to be do more commuting. If both uses of a two-address instruction are killed, but the first operand has a use before and after the def, commute if the second operand does not suffer from the same issue.
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1028
%reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
In this case, it might not be possible to coalesce the second MOV8rr
instruction if the first one is coalesced. So it would be profitable to
commute it:
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1029
%reg1030<def> = ADD8rr %reg1029<kill>, %reg1028<kill>, %EFLAGS<imp-def,dead>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62954 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-25 03:53:59 +00:00
|
|
|
// If there is a use of regC between its last def (could be livein) and this
|
|
|
|
// instruction, then bail.
|
|
|
|
unsigned LastDefC = 0;
|
2009-03-01 02:03:43 +00:00
|
|
|
if (!NoUseAfterLastDef(regC, MBB, Dist, LastDefC))
|
Teach 2addr pass to be do more commuting. If both uses of a two-address instruction are killed, but the first operand has a use before and after the def, commute if the second operand does not suffer from the same issue.
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1028
%reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
In this case, it might not be possible to coalesce the second MOV8rr
instruction if the first one is coalesced. So it would be profitable to
commute it:
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1029
%reg1030<def> = ADD8rr %reg1029<kill>, %reg1028<kill>, %EFLAGS<imp-def,dead>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62954 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-25 03:53:59 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// If there is a use of regB between its last def (could be livein) and this
|
|
|
|
// instruction, then go ahead and make this transformation.
|
|
|
|
unsigned LastDefB = 0;
|
2009-03-01 02:03:43 +00:00
|
|
|
if (!NoUseAfterLastDef(regB, MBB, Dist, LastDefB))
|
Teach 2addr pass to be do more commuting. If both uses of a two-address instruction are killed, but the first operand has a use before and after the def, commute if the second operand does not suffer from the same issue.
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1028
%reg1030<def> = ADD8rr %reg1028<kill>, %reg1029<kill>, %EFLAGS<imp-def,dead>
In this case, it might not be possible to coalesce the second MOV8rr
instruction if the first one is coalesced. So it would be profitable to
commute it:
%reg1028<def> = EXTRACT_SUBREG %reg1027<kill>, 1
%reg1029<def> = MOV8rr %reg1028
%reg1029<def> = SHR8ri %reg1029, 7, %EFLAGS<imp-def,dead>
insert => %reg1030<def> = MOV8rr %reg1029
%reg1030<def> = ADD8rr %reg1029<kill>, %reg1028<kill>, %EFLAGS<imp-def,dead>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62954 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-25 03:53:59 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// Since there are no intervening uses for both registers, then commute
|
|
|
|
// if the def of regC is closer. Its live interval is shorter.
|
|
|
|
return LastDefB && LastDefC && LastDefC > LastDefB;
|
|
|
|
}
|
|
|
|
|
2009-01-23 23:27:33 +00:00
|
|
|
/// CommuteInstruction - Commute a two-address instruction and update the basic
|
|
|
|
/// block, distance map, and live variables if needed. Return true if it is
|
|
|
|
/// successful.
|
|
|
|
bool
|
|
|
|
TwoAddressInstructionPass::CommuteInstruction(MachineBasicBlock::iterator &mi,
|
2009-03-01 02:03:43 +00:00
|
|
|
MachineFunction::iterator &mbbi,
|
|
|
|
unsigned RegB, unsigned RegC, unsigned Dist) {
|
2009-01-23 23:27:33 +00:00
|
|
|
MachineInstr *MI = mi;
|
2010-01-05 01:24:21 +00:00
|
|
|
DEBUG(dbgs() << "2addr: COMMUTING : " << *MI);
|
2009-01-23 23:27:33 +00:00
|
|
|
MachineInstr *NewMI = TII->commuteInstruction(MI);
|
|
|
|
|
|
|
|
if (NewMI == 0) {
|
2010-01-05 01:24:21 +00:00
|
|
|
DEBUG(dbgs() << "2addr: COMMUTING FAILED!\n");
|
2009-01-23 23:27:33 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-01-05 01:24:21 +00:00
|
|
|
DEBUG(dbgs() << "2addr: COMMUTED TO: " << *NewMI);
|
2009-01-23 23:27:33 +00:00
|
|
|
// If the instruction changed to commute it, update livevar.
|
|
|
|
if (NewMI != MI) {
|
|
|
|
if (LV)
|
|
|
|
// Update live variables
|
|
|
|
LV->replaceKillInstruction(RegC, MI, NewMI);
|
2012-08-03 22:58:34 +00:00
|
|
|
if (Indexes)
|
|
|
|
Indexes->replaceMachineInstrInMaps(MI, NewMI);
|
2009-01-23 23:27:33 +00:00
|
|
|
|
|
|
|
mbbi->insert(mi, NewMI); // Insert the new inst
|
|
|
|
mbbi->erase(mi); // Nuke the old inst.
|
|
|
|
mi = NewMI;
|
|
|
|
DistanceMap.insert(std::make_pair(NewMI, Dist));
|
|
|
|
}
|
2009-03-01 02:03:43 +00:00
|
|
|
|
|
|
|
// Update source register map.
|
|
|
|
unsigned FromRegC = getMappedReg(RegC, SrcRegMap);
|
|
|
|
if (FromRegC) {
|
|
|
|
unsigned RegA = MI->getOperand(0).getReg();
|
|
|
|
SrcRegMap[RegA] = FromRegC;
|
|
|
|
}
|
|
|
|
|
2009-01-23 23:27:33 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-03-30 21:34:07 +00:00
|
|
|
/// isProfitableToConv3Addr - Return true if it is profitable to convert the
|
|
|
|
/// given 2-address instruction to a 3-address one.
|
|
|
|
bool
|
2011-03-02 01:08:17 +00:00
|
|
|
TwoAddressInstructionPass::isProfitableToConv3Addr(unsigned RegA,unsigned RegB){
|
2009-03-30 21:34:07 +00:00
|
|
|
// Look for situations like this:
|
|
|
|
// %reg1024<def> = MOV r1
|
|
|
|
// %reg1025<def> = MOV r0
|
|
|
|
// %reg1026<def> = ADD %reg1024, %reg1025
|
|
|
|
// r2 = MOV %reg1026
|
|
|
|
// Turn ADD into a 3-address instruction to avoid a copy.
|
2011-03-02 01:08:17 +00:00
|
|
|
unsigned FromRegB = getMappedReg(RegB, SrcRegMap);
|
|
|
|
if (!FromRegB)
|
|
|
|
return false;
|
2009-03-30 21:34:07 +00:00
|
|
|
unsigned ToRegA = getMappedReg(RegA, DstRegMap);
|
2011-03-02 01:08:17 +00:00
|
|
|
return (ToRegA && !regsAreCompatible(FromRegB, ToRegA, TRI));
|
2009-03-30 21:34:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// ConvertInstTo3Addr - Convert the specified two-address instruction into a
|
|
|
|
/// three address one. Return true if this transformation was successful.
|
|
|
|
bool
|
|
|
|
TwoAddressInstructionPass::ConvertInstTo3Addr(MachineBasicBlock::iterator &mi,
|
|
|
|
MachineBasicBlock::iterator &nmi,
|
|
|
|
MachineFunction::iterator &mbbi,
|
2011-02-10 02:20:55 +00:00
|
|
|
unsigned RegA, unsigned RegB,
|
|
|
|
unsigned Dist) {
|
2009-03-30 21:34:07 +00:00
|
|
|
MachineInstr *NewMI = TII->convertToThreeAddress(mbbi, mi, LV);
|
|
|
|
if (NewMI) {
|
2010-01-05 01:24:21 +00:00
|
|
|
DEBUG(dbgs() << "2addr: CONVERTING 2-ADDR: " << *mi);
|
|
|
|
DEBUG(dbgs() << "2addr: TO 3-ADDR: " << *NewMI);
|
2009-03-30 21:34:07 +00:00
|
|
|
bool Sunk = false;
|
|
|
|
|
2012-08-03 22:58:34 +00:00
|
|
|
if (Indexes)
|
|
|
|
Indexes->replaceMachineInstrInMaps(mi, NewMI);
|
|
|
|
|
2009-03-30 21:34:07 +00:00
|
|
|
if (NewMI->findRegisterUseOperand(RegB, false, TRI))
|
|
|
|
// FIXME: Temporary workaround. If the new instruction doesn't
|
|
|
|
// uses RegB, convertToThreeAddress must have created more
|
|
|
|
// then one instruction.
|
|
|
|
Sunk = Sink3AddrInstruction(mbbi, NewMI, RegB, mi);
|
|
|
|
|
|
|
|
mbbi->erase(mi); // Nuke the old inst.
|
|
|
|
|
|
|
|
if (!Sunk) {
|
|
|
|
DistanceMap.insert(std::make_pair(NewMI, Dist));
|
|
|
|
mi = NewMI;
|
2009-12-03 00:50:42 +00:00
|
|
|
nmi = llvm::next(mi);
|
2009-03-30 21:34:07 +00:00
|
|
|
}
|
2011-02-10 02:20:55 +00:00
|
|
|
|
|
|
|
// Update source and destination register maps.
|
|
|
|
SrcRegMap.erase(RegA);
|
|
|
|
DstRegMap.erase(RegB);
|
2009-03-30 21:34:07 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-03-02 01:08:17 +00:00
|
|
|
/// ScanUses - Scan forward recursively for only uses, update maps if the use
|
|
|
|
/// is a copy or a two-address instruction.
|
|
|
|
void
|
|
|
|
TwoAddressInstructionPass::ScanUses(unsigned DstReg, MachineBasicBlock *MBB,
|
|
|
|
SmallPtrSet<MachineInstr*, 8> &Processed) {
|
|
|
|
SmallVector<unsigned, 4> VirtRegPairs;
|
|
|
|
bool IsDstPhys;
|
|
|
|
bool IsCopy = false;
|
|
|
|
unsigned NewReg = 0;
|
|
|
|
unsigned Reg = DstReg;
|
|
|
|
while (MachineInstr *UseMI = findOnlyInterestingUse(Reg, MBB, MRI, TII,IsCopy,
|
|
|
|
NewReg, IsDstPhys)) {
|
|
|
|
if (IsCopy && !Processed.insert(UseMI))
|
|
|
|
break;
|
|
|
|
|
|
|
|
DenseMap<MachineInstr*, unsigned>::iterator DI = DistanceMap.find(UseMI);
|
|
|
|
if (DI != DistanceMap.end())
|
|
|
|
// Earlier in the same MBB.Reached via a back edge.
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (IsDstPhys) {
|
|
|
|
VirtRegPairs.push_back(NewReg);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
bool isNew = SrcRegMap.insert(std::make_pair(NewReg, Reg)).second;
|
|
|
|
if (!isNew)
|
|
|
|
assert(SrcRegMap[NewReg] == Reg && "Can't map to two src registers!");
|
|
|
|
VirtRegPairs.push_back(NewReg);
|
|
|
|
Reg = NewReg;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!VirtRegPairs.empty()) {
|
|
|
|
unsigned ToReg = VirtRegPairs.back();
|
|
|
|
VirtRegPairs.pop_back();
|
|
|
|
while (!VirtRegPairs.empty()) {
|
|
|
|
unsigned FromReg = VirtRegPairs.back();
|
|
|
|
VirtRegPairs.pop_back();
|
|
|
|
bool isNew = DstRegMap.insert(std::make_pair(FromReg, ToReg)).second;
|
|
|
|
if (!isNew)
|
|
|
|
assert(DstRegMap[FromReg] == ToReg &&"Can't map to two dst registers!");
|
|
|
|
ToReg = FromReg;
|
|
|
|
}
|
|
|
|
bool isNew = DstRegMap.insert(std::make_pair(DstReg, ToReg)).second;
|
|
|
|
if (!isNew)
|
|
|
|
assert(DstRegMap[DstReg] == ToReg && "Can't map to two dst registers!");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-01 02:03:43 +00:00
|
|
|
/// ProcessCopy - If the specified instruction is not yet processed, process it
|
|
|
|
/// if it's a copy. For a copy instruction, we find the physical registers the
|
|
|
|
/// source and destination registers might be mapped to. These are kept in
|
|
|
|
/// point-to maps used to determine future optimizations. e.g.
|
|
|
|
/// v1024 = mov r0
|
|
|
|
/// v1025 = mov r1
|
|
|
|
/// v1026 = add v1024, v1025
|
|
|
|
/// r1 = mov r1026
|
|
|
|
/// If 'add' is a two-address instruction, v1024, v1026 are both potentially
|
|
|
|
/// coalesced to r0 (from the input side). v1025 is mapped to r1. v1026 is
|
|
|
|
/// potentially joined with r1 on the output side. It's worthwhile to commute
|
|
|
|
/// 'add' to eliminate a copy.
|
|
|
|
void TwoAddressInstructionPass::ProcessCopy(MachineInstr *MI,
|
|
|
|
MachineBasicBlock *MBB,
|
|
|
|
SmallPtrSet<MachineInstr*, 8> &Processed) {
|
|
|
|
if (Processed.count(MI))
|
|
|
|
return;
|
|
|
|
|
|
|
|
bool IsSrcPhys, IsDstPhys;
|
|
|
|
unsigned SrcReg, DstReg;
|
|
|
|
if (!isCopyToReg(*MI, TII, SrcReg, DstReg, IsSrcPhys, IsDstPhys))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (IsDstPhys && !IsSrcPhys)
|
|
|
|
DstRegMap.insert(std::make_pair(SrcReg, DstReg));
|
|
|
|
else if (!IsDstPhys && IsSrcPhys) {
|
2009-04-13 20:04:24 +00:00
|
|
|
bool isNew = SrcRegMap.insert(std::make_pair(DstReg, SrcReg)).second;
|
|
|
|
if (!isNew)
|
|
|
|
assert(SrcRegMap[DstReg] == SrcReg &&
|
|
|
|
"Can't map to two src physical registers!");
|
2009-03-01 02:03:43 +00:00
|
|
|
|
2011-03-02 01:08:17 +00:00
|
|
|
ScanUses(DstReg, MBB, Processed);
|
2009-03-01 02:03:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Processed.insert(MI);
|
2011-03-02 01:08:17 +00:00
|
|
|
return;
|
2009-03-01 02:03:43 +00:00
|
|
|
}
|
|
|
|
|
2011-11-14 19:48:55 +00:00
|
|
|
/// RescheduleMIBelowKill - If there is one more local instruction that reads
|
|
|
|
/// 'Reg' and it kills 'Reg, consider moving the instruction below the kill
|
|
|
|
/// instruction in order to eliminate the need for the copy.
|
|
|
|
bool
|
|
|
|
TwoAddressInstructionPass::RescheduleMIBelowKill(MachineBasicBlock *MBB,
|
|
|
|
MachineBasicBlock::iterator &mi,
|
|
|
|
MachineBasicBlock::iterator &nmi,
|
|
|
|
unsigned Reg) {
|
2012-07-15 03:29:46 +00:00
|
|
|
// Bail immediately if we don't have LV available. We use it to find kills
|
|
|
|
// efficiently.
|
|
|
|
if (!LV)
|
|
|
|
return false;
|
|
|
|
|
2011-11-14 19:48:55 +00:00
|
|
|
MachineInstr *MI = &*mi;
|
2012-02-03 05:12:30 +00:00
|
|
|
DenseMap<MachineInstr*, unsigned>::iterator DI = DistanceMap.find(MI);
|
2011-11-14 19:48:55 +00:00
|
|
|
if (DI == DistanceMap.end())
|
|
|
|
// Must be created from unfolded load. Don't waste time trying this.
|
|
|
|
return false;
|
|
|
|
|
2012-07-15 03:29:46 +00:00
|
|
|
MachineInstr *KillMI = LV->getVarInfo(Reg).findKill(MBB);
|
|
|
|
if (!KillMI || MI == KillMI || KillMI->isCopy() || KillMI->isCopyLike())
|
2011-11-14 19:48:55 +00:00
|
|
|
// Don't mess with copies, they may be coalesced later.
|
|
|
|
return false;
|
|
|
|
|
2011-12-07 07:15:52 +00:00
|
|
|
if (KillMI->hasUnmodeledSideEffects() || KillMI->isCall() ||
|
|
|
|
KillMI->isBranch() || KillMI->isTerminator())
|
2011-11-14 19:48:55 +00:00
|
|
|
// Don't move pass calls, etc.
|
|
|
|
return false;
|
|
|
|
|
|
|
|
unsigned DstReg;
|
|
|
|
if (isTwoAddrUse(*KillMI, Reg, DstReg))
|
|
|
|
return false;
|
|
|
|
|
2011-11-15 06:26:51 +00:00
|
|
|
bool SeenStore = true;
|
2011-11-14 19:48:55 +00:00
|
|
|
if (!MI->isSafeToMove(TII, AA, SeenStore))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (TII->getInstrLatency(InstrItins, MI) > 1)
|
|
|
|
// FIXME: Needs more sophisticated heuristics.
|
|
|
|
return false;
|
|
|
|
|
|
|
|
SmallSet<unsigned, 2> Uses;
|
2011-11-16 03:47:42 +00:00
|
|
|
SmallSet<unsigned, 2> Kills;
|
2011-11-14 19:48:55 +00:00
|
|
|
SmallSet<unsigned, 2> Defs;
|
|
|
|
for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
|
|
|
|
const MachineOperand &MO = MI->getOperand(i);
|
|
|
|
if (!MO.isReg())
|
|
|
|
continue;
|
|
|
|
unsigned MOReg = MO.getReg();
|
|
|
|
if (!MOReg)
|
|
|
|
continue;
|
|
|
|
if (MO.isDef())
|
|
|
|
Defs.insert(MOReg);
|
2011-11-16 03:47:42 +00:00
|
|
|
else {
|
2011-11-14 19:48:55 +00:00
|
|
|
Uses.insert(MOReg);
|
2011-11-16 03:47:42 +00:00
|
|
|
if (MO.isKill() && MOReg != Reg)
|
|
|
|
Kills.insert(MOReg);
|
|
|
|
}
|
2011-11-14 19:48:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Move the copies connected to MI down as well.
|
|
|
|
MachineBasicBlock::iterator From = MI;
|
|
|
|
MachineBasicBlock::iterator To = llvm::next(From);
|
|
|
|
while (To->isCopy() && Defs.count(To->getOperand(1).getReg())) {
|
|
|
|
Defs.insert(To->getOperand(0).getReg());
|
|
|
|
++To;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if the reschedule will not break depedencies.
|
|
|
|
unsigned NumVisited = 0;
|
|
|
|
MachineBasicBlock::iterator KillPos = KillMI;
|
|
|
|
++KillPos;
|
|
|
|
for (MachineBasicBlock::iterator I = To; I != KillPos; ++I) {
|
|
|
|
MachineInstr *OtherMI = I;
|
|
|
|
// DBG_VALUE cannot be counted against the limit.
|
|
|
|
if (OtherMI->isDebugValue())
|
|
|
|
continue;
|
|
|
|
if (NumVisited > 10) // FIXME: Arbitrary limit to reduce compile time cost.
|
|
|
|
return false;
|
|
|
|
++NumVisited;
|
2011-12-07 07:15:52 +00:00
|
|
|
if (OtherMI->hasUnmodeledSideEffects() || OtherMI->isCall() ||
|
|
|
|
OtherMI->isBranch() || OtherMI->isTerminator())
|
2011-11-14 19:48:55 +00:00
|
|
|
// Don't move pass calls, etc.
|
|
|
|
return false;
|
|
|
|
for (unsigned i = 0, e = OtherMI->getNumOperands(); i != e; ++i) {
|
|
|
|
const MachineOperand &MO = OtherMI->getOperand(i);
|
|
|
|
if (!MO.isReg())
|
|
|
|
continue;
|
|
|
|
unsigned MOReg = MO.getReg();
|
|
|
|
if (!MOReg)
|
|
|
|
continue;
|
|
|
|
if (MO.isDef()) {
|
|
|
|
if (Uses.count(MOReg))
|
|
|
|
// Physical register use would be clobbered.
|
|
|
|
return false;
|
|
|
|
if (!MO.isDead() && Defs.count(MOReg))
|
|
|
|
// May clobber a physical register def.
|
|
|
|
// FIXME: This may be too conservative. It's ok if the instruction
|
|
|
|
// is sunken completely below the use.
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
if (Defs.count(MOReg))
|
|
|
|
return false;
|
2011-11-16 03:47:42 +00:00
|
|
|
if (MOReg != Reg &&
|
|
|
|
((MO.isKill() && Uses.count(MOReg)) || Kills.count(MOReg)))
|
2011-11-14 19:48:55 +00:00
|
|
|
// Don't want to extend other live ranges and update kills.
|
|
|
|
return false;
|
2012-07-15 03:29:46 +00:00
|
|
|
if (MOReg == Reg && !MO.isKill())
|
|
|
|
// We can't schedule across a use of the register in question.
|
|
|
|
return false;
|
|
|
|
// Ensure that if this is register in question, its the kill we expect.
|
|
|
|
assert((MOReg != Reg || OtherMI == KillMI) &&
|
|
|
|
"Found multiple kills of a register in a basic block");
|
2011-11-14 19:48:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Move debug info as well.
|
2011-11-14 21:11:15 +00:00
|
|
|
while (From != MBB->begin() && llvm::prior(From)->isDebugValue())
|
|
|
|
--From;
|
2011-11-14 19:48:55 +00:00
|
|
|
|
|
|
|
// Copies following MI may have been moved as well.
|
|
|
|
nmi = To;
|
|
|
|
MBB->splice(KillPos, MBB, From, To);
|
|
|
|
DistanceMap.erase(DI);
|
|
|
|
|
2012-07-15 03:29:46 +00:00
|
|
|
// Update live variables
|
|
|
|
LV->removeVirtualRegisterKilled(Reg, KillMI);
|
|
|
|
LV->addVirtualRegisterKilled(Reg, MI);
|
2012-08-03 22:58:34 +00:00
|
|
|
if (LIS)
|
|
|
|
LIS->handleMove(MI);
|
2011-11-14 19:48:55 +00:00
|
|
|
|
2012-07-17 17:57:23 +00:00
|
|
|
DEBUG(dbgs() << "\trescheduled below kill: " << *KillMI);
|
2011-11-14 19:48:55 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isDefTooClose - Return true if the re-scheduling will put the given
|
|
|
|
/// instruction too close to the defs of its register dependencies.
|
|
|
|
bool TwoAddressInstructionPass::isDefTooClose(unsigned Reg, unsigned Dist,
|
|
|
|
MachineInstr *MI,
|
|
|
|
MachineBasicBlock *MBB) {
|
|
|
|
for (MachineRegisterInfo::def_iterator DI = MRI->def_begin(Reg),
|
|
|
|
DE = MRI->def_end(); DI != DE; ++DI) {
|
|
|
|
MachineInstr *DefMI = &*DI;
|
|
|
|
if (DefMI->getParent() != MBB || DefMI->isCopy() || DefMI->isCopyLike())
|
|
|
|
continue;
|
|
|
|
if (DefMI == MI)
|
|
|
|
return true; // MI is defining something KillMI uses
|
|
|
|
DenseMap<MachineInstr*, unsigned>::iterator DDI = DistanceMap.find(DefMI);
|
|
|
|
if (DDI == DistanceMap.end())
|
|
|
|
return true; // Below MI
|
|
|
|
unsigned DefDist = DDI->second;
|
|
|
|
assert(Dist > DefDist && "Visited def already?");
|
2012-06-05 21:11:27 +00:00
|
|
|
if (TII->getInstrLatency(InstrItins, DefMI) > (Dist - DefDist))
|
2011-11-14 19:48:55 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// RescheduleKillAboveMI - If there is one more local instruction that reads
|
|
|
|
/// 'Reg' and it kills 'Reg, consider moving the kill instruction above the
|
|
|
|
/// current two-address instruction in order to eliminate the need for the
|
|
|
|
/// copy.
|
|
|
|
bool
|
|
|
|
TwoAddressInstructionPass::RescheduleKillAboveMI(MachineBasicBlock *MBB,
|
|
|
|
MachineBasicBlock::iterator &mi,
|
|
|
|
MachineBasicBlock::iterator &nmi,
|
|
|
|
unsigned Reg) {
|
2012-07-15 03:29:46 +00:00
|
|
|
// Bail immediately if we don't have LV available. We use it to find kills
|
|
|
|
// efficiently.
|
|
|
|
if (!LV)
|
|
|
|
return false;
|
|
|
|
|
2011-11-14 19:48:55 +00:00
|
|
|
MachineInstr *MI = &*mi;
|
|
|
|
DenseMap<MachineInstr*, unsigned>::iterator DI = DistanceMap.find(MI);
|
|
|
|
if (DI == DistanceMap.end())
|
|
|
|
// Must be created from unfolded load. Don't waste time trying this.
|
|
|
|
return false;
|
|
|
|
|
2012-07-15 03:29:46 +00:00
|
|
|
MachineInstr *KillMI = LV->getVarInfo(Reg).findKill(MBB);
|
|
|
|
if (!KillMI || MI == KillMI || KillMI->isCopy() || KillMI->isCopyLike())
|
2011-11-14 19:48:55 +00:00
|
|
|
// Don't mess with copies, they may be coalesced later.
|
|
|
|
return false;
|
|
|
|
|
|
|
|
unsigned DstReg;
|
|
|
|
if (isTwoAddrUse(*KillMI, Reg, DstReg))
|
|
|
|
return false;
|
|
|
|
|
2011-11-15 06:26:51 +00:00
|
|
|
bool SeenStore = true;
|
2011-11-14 19:48:55 +00:00
|
|
|
if (!KillMI->isSafeToMove(TII, AA, SeenStore))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
SmallSet<unsigned, 2> Uses;
|
|
|
|
SmallSet<unsigned, 2> Kills;
|
|
|
|
SmallSet<unsigned, 2> Defs;
|
|
|
|
SmallSet<unsigned, 2> LiveDefs;
|
|
|
|
for (unsigned i = 0, e = KillMI->getNumOperands(); i != e; ++i) {
|
|
|
|
const MachineOperand &MO = KillMI->getOperand(i);
|
|
|
|
if (!MO.isReg())
|
|
|
|
continue;
|
|
|
|
unsigned MOReg = MO.getReg();
|
|
|
|
if (MO.isUse()) {
|
|
|
|
if (!MOReg)
|
|
|
|
continue;
|
|
|
|
if (isDefTooClose(MOReg, DI->second, MI, MBB))
|
|
|
|
return false;
|
2012-07-15 03:29:46 +00:00
|
|
|
if (MOReg == Reg && !MO.isKill())
|
|
|
|
return false;
|
2011-11-14 19:48:55 +00:00
|
|
|
Uses.insert(MOReg);
|
|
|
|
if (MO.isKill() && MOReg != Reg)
|
|
|
|
Kills.insert(MOReg);
|
|
|
|
} else if (TargetRegisterInfo::isPhysicalRegister(MOReg)) {
|
|
|
|
Defs.insert(MOReg);
|
|
|
|
if (!MO.isDead())
|
|
|
|
LiveDefs.insert(MOReg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if the reschedule will not break depedencies.
|
|
|
|
unsigned NumVisited = 0;
|
|
|
|
MachineBasicBlock::iterator KillPos = KillMI;
|
|
|
|
for (MachineBasicBlock::iterator I = mi; I != KillPos; ++I) {
|
|
|
|
MachineInstr *OtherMI = I;
|
|
|
|
// DBG_VALUE cannot be counted against the limit.
|
|
|
|
if (OtherMI->isDebugValue())
|
|
|
|
continue;
|
|
|
|
if (NumVisited > 10) // FIXME: Arbitrary limit to reduce compile time cost.
|
|
|
|
return false;
|
|
|
|
++NumVisited;
|
2011-12-07 07:15:52 +00:00
|
|
|
if (OtherMI->hasUnmodeledSideEffects() || OtherMI->isCall() ||
|
|
|
|
OtherMI->isBranch() || OtherMI->isTerminator())
|
2011-11-14 19:48:55 +00:00
|
|
|
// Don't move pass calls, etc.
|
|
|
|
return false;
|
2011-11-16 03:05:12 +00:00
|
|
|
SmallVector<unsigned, 2> OtherDefs;
|
2011-11-14 19:48:55 +00:00
|
|
|
for (unsigned i = 0, e = OtherMI->getNumOperands(); i != e; ++i) {
|
|
|
|
const MachineOperand &MO = OtherMI->getOperand(i);
|
|
|
|
if (!MO.isReg())
|
|
|
|
continue;
|
|
|
|
unsigned MOReg = MO.getReg();
|
|
|
|
if (!MOReg)
|
|
|
|
continue;
|
|
|
|
if (MO.isUse()) {
|
|
|
|
if (Defs.count(MOReg))
|
|
|
|
// Moving KillMI can clobber the physical register if the def has
|
|
|
|
// not been seen.
|
|
|
|
return false;
|
|
|
|
if (Kills.count(MOReg))
|
|
|
|
// Don't want to extend other live ranges and update kills.
|
|
|
|
return false;
|
2012-07-15 03:29:46 +00:00
|
|
|
if (OtherMI != MI && MOReg == Reg && !MO.isKill())
|
|
|
|
// We can't schedule across a use of the register in question.
|
|
|
|
return false;
|
2011-11-14 19:48:55 +00:00
|
|
|
} else {
|
2011-11-16 03:05:12 +00:00
|
|
|
OtherDefs.push_back(MOReg);
|
2011-11-14 19:48:55 +00:00
|
|
|
}
|
|
|
|
}
|
2011-11-16 03:05:12 +00:00
|
|
|
|
|
|
|
for (unsigned i = 0, e = OtherDefs.size(); i != e; ++i) {
|
|
|
|
unsigned MOReg = OtherDefs[i];
|
|
|
|
if (Uses.count(MOReg))
|
|
|
|
return false;
|
|
|
|
if (TargetRegisterInfo::isPhysicalRegister(MOReg) &&
|
|
|
|
LiveDefs.count(MOReg))
|
|
|
|
return false;
|
|
|
|
// Physical register def is seen.
|
|
|
|
Defs.erase(MOReg);
|
|
|
|
}
|
2011-11-14 19:48:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Move the old kill above MI, don't forget to move debug info as well.
|
|
|
|
MachineBasicBlock::iterator InsertPos = mi;
|
2011-11-14 21:11:15 +00:00
|
|
|
while (InsertPos != MBB->begin() && llvm::prior(InsertPos)->isDebugValue())
|
|
|
|
--InsertPos;
|
2011-11-14 19:48:55 +00:00
|
|
|
MachineBasicBlock::iterator From = KillMI;
|
|
|
|
MachineBasicBlock::iterator To = llvm::next(From);
|
|
|
|
while (llvm::prior(From)->isDebugValue())
|
|
|
|
--From;
|
|
|
|
MBB->splice(InsertPos, MBB, From, To);
|
|
|
|
|
2011-11-16 03:33:08 +00:00
|
|
|
nmi = llvm::prior(InsertPos); // Backtrack so we process the moved instr.
|
2011-11-14 19:48:55 +00:00
|
|
|
DistanceMap.erase(DI);
|
|
|
|
|
2012-07-15 03:29:46 +00:00
|
|
|
// Update live variables
|
|
|
|
LV->removeVirtualRegisterKilled(Reg, KillMI);
|
|
|
|
LV->addVirtualRegisterKilled(Reg, MI);
|
2012-08-03 22:58:34 +00:00
|
|
|
if (LIS)
|
|
|
|
LIS->handleMove(KillMI);
|
2012-07-15 03:29:46 +00:00
|
|
|
|
2012-07-17 17:57:23 +00:00
|
|
|
DEBUG(dbgs() << "\trescheduled kill: " << *KillMI);
|
2011-11-14 19:48:55 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-09-03 20:58:42 +00:00
|
|
|
/// TryInstructionTransform - For the case where an instruction has a single
|
|
|
|
/// pair of tied register operands, attempt some transformations that may
|
|
|
|
/// either eliminate the tied operands or improve the opportunities for
|
2012-04-09 20:17:30 +00:00
|
|
|
/// coalescing away the register copy. Returns true if no copy needs to be
|
|
|
|
/// inserted to untie mi's operands (either because they were untied, or
|
|
|
|
/// because mi was rescheduled, and will be visited again later).
|
2009-09-03 20:58:42 +00:00
|
|
|
bool TwoAddressInstructionPass::
|
|
|
|
TryInstructionTransform(MachineBasicBlock::iterator &mi,
|
|
|
|
MachineBasicBlock::iterator &nmi,
|
|
|
|
MachineFunction::iterator &mbbi,
|
2011-03-02 01:08:17 +00:00
|
|
|
unsigned SrcIdx, unsigned DstIdx, unsigned Dist,
|
|
|
|
SmallPtrSet<MachineInstr*, 8> &Processed) {
|
2011-11-16 18:44:48 +00:00
|
|
|
if (OptLevel == CodeGenOpt::None)
|
|
|
|
return false;
|
|
|
|
|
2011-11-14 19:48:55 +00:00
|
|
|
MachineInstr &MI = *mi;
|
|
|
|
unsigned regA = MI.getOperand(DstIdx).getReg();
|
|
|
|
unsigned regB = MI.getOperand(SrcIdx).getReg();
|
2009-09-03 20:58:42 +00:00
|
|
|
|
|
|
|
assert(TargetRegisterInfo::isVirtualRegister(regB) &&
|
|
|
|
"cannot make instruction into two-address form");
|
2011-11-14 19:48:55 +00:00
|
|
|
bool regBKilled = isKilled(MI, regB, MRI, TII);
|
2009-09-03 20:58:42 +00:00
|
|
|
|
2012-05-03 01:45:13 +00:00
|
|
|
if (TargetRegisterInfo::isVirtualRegister(regA))
|
|
|
|
ScanUses(regA, &*mbbi, Processed);
|
|
|
|
|
2009-09-03 20:58:42 +00:00
|
|
|
// Check if it is profitable to commute the operands.
|
|
|
|
unsigned SrcOp1, SrcOp2;
|
|
|
|
unsigned regC = 0;
|
|
|
|
unsigned regCIdx = ~0U;
|
|
|
|
bool TryCommute = false;
|
|
|
|
bool AggressiveCommute = false;
|
2011-12-07 07:15:52 +00:00
|
|
|
if (MI.isCommutable() && MI.getNumOperands() >= 3 &&
|
2011-11-14 19:48:55 +00:00
|
|
|
TII->findCommutedOpIndices(&MI, SrcOp1, SrcOp2)) {
|
2009-09-03 20:58:42 +00:00
|
|
|
if (SrcIdx == SrcOp1)
|
|
|
|
regCIdx = SrcOp2;
|
|
|
|
else if (SrcIdx == SrcOp2)
|
|
|
|
regCIdx = SrcOp1;
|
|
|
|
|
|
|
|
if (regCIdx != ~0U) {
|
2011-11-14 19:48:55 +00:00
|
|
|
regC = MI.getOperand(regCIdx).getReg();
|
|
|
|
if (!regBKilled && isKilled(MI, regC, MRI, TII))
|
2009-09-03 20:58:42 +00:00
|
|
|
// If C dies but B does not, swap the B and C operands.
|
|
|
|
// This makes the live ranges of A and C joinable.
|
|
|
|
TryCommute = true;
|
2012-05-03 01:45:13 +00:00
|
|
|
else if (isProfitableToCommute(regA, regB, regC, &MI, mbbi, Dist)) {
|
2009-09-03 20:58:42 +00:00
|
|
|
TryCommute = true;
|
|
|
|
AggressiveCommute = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If it's profitable to commute, try to do so.
|
|
|
|
if (TryCommute && CommuteInstruction(mi, mbbi, regB, regC, Dist)) {
|
|
|
|
++NumCommuted;
|
|
|
|
if (AggressiveCommute)
|
|
|
|
++NumAggrCommuted;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-11-14 19:48:55 +00:00
|
|
|
// If there is one more use of regB later in the same MBB, consider
|
|
|
|
// re-schedule this MI below it.
|
|
|
|
if (RescheduleMIBelowKill(mbbi, mi, nmi, regB)) {
|
|
|
|
++NumReSchedDowns;
|
2012-04-09 20:17:30 +00:00
|
|
|
return true;
|
2011-11-14 19:48:55 +00:00
|
|
|
}
|
|
|
|
|
2011-12-07 07:15:52 +00:00
|
|
|
if (MI.isConvertibleTo3Addr()) {
|
2009-09-03 20:58:42 +00:00
|
|
|
// This instruction is potentially convertible to a true
|
|
|
|
// three-address instruction. Check if it is profitable.
|
2011-03-02 01:08:17 +00:00
|
|
|
if (!regBKilled || isProfitableToConv3Addr(regA, regB)) {
|
2009-09-03 20:58:42 +00:00
|
|
|
// Try to convert it.
|
2011-02-10 02:20:55 +00:00
|
|
|
if (ConvertInstTo3Addr(mi, nmi, mbbi, regA, regB, Dist)) {
|
2009-09-03 20:58:42 +00:00
|
|
|
++NumConvertedTo3Addr;
|
|
|
|
return true; // Done with this instruction.
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-06-21 22:17:20 +00:00
|
|
|
|
2011-11-14 19:48:55 +00:00
|
|
|
// If there is one more use of regB later in the same MBB, consider
|
|
|
|
// re-schedule it before this MI if it's legal.
|
|
|
|
if (RescheduleKillAboveMI(mbbi, mi, nmi, regB)) {
|
|
|
|
++NumReSchedUps;
|
2012-04-09 20:17:30 +00:00
|
|
|
return true;
|
2011-11-14 19:48:55 +00:00
|
|
|
}
|
|
|
|
|
2010-06-21 22:17:20 +00:00
|
|
|
// If this is an instruction with a load folded into it, try unfolding
|
|
|
|
// the load, e.g. avoid this:
|
|
|
|
// movq %rdx, %rcx
|
|
|
|
// addq (%rax), %rcx
|
|
|
|
// in favor of this:
|
|
|
|
// movq (%rax), %rcx
|
|
|
|
// addq %rdx, %rcx
|
|
|
|
// because it's preferable to schedule a load than a register copy.
|
2011-12-07 07:15:52 +00:00
|
|
|
if (MI.mayLoad() && !regBKilled) {
|
2010-06-21 22:17:20 +00:00
|
|
|
// Determine if a load can be unfolded.
|
|
|
|
unsigned LoadRegIndex;
|
|
|
|
unsigned NewOpc =
|
2011-11-14 19:48:55 +00:00
|
|
|
TII->getOpcodeAfterMemoryUnfold(MI.getOpcode(),
|
2010-06-21 22:17:20 +00:00
|
|
|
/*UnfoldLoad=*/true,
|
|
|
|
/*UnfoldStore=*/false,
|
|
|
|
&LoadRegIndex);
|
|
|
|
if (NewOpc != 0) {
|
2011-06-28 19:10:37 +00:00
|
|
|
const MCInstrDesc &UnfoldMCID = TII->get(NewOpc);
|
|
|
|
if (UnfoldMCID.getNumDefs() == 1) {
|
2010-06-21 22:17:20 +00:00
|
|
|
// Unfold the load.
|
2011-11-14 19:48:55 +00:00
|
|
|
DEBUG(dbgs() << "2addr: UNFOLDING: " << MI);
|
2010-06-21 22:17:20 +00:00
|
|
|
const TargetRegisterClass *RC =
|
2012-05-03 01:14:37 +00:00
|
|
|
TRI->getAllocatableClass(
|
2012-08-03 23:25:45 +00:00
|
|
|
TII->getRegClass(UnfoldMCID, LoadRegIndex, TRI, *MF));
|
2010-06-21 22:17:20 +00:00
|
|
|
unsigned Reg = MRI->createVirtualRegister(RC);
|
|
|
|
SmallVector<MachineInstr *, 2> NewMIs;
|
2012-08-03 23:25:45 +00:00
|
|
|
if (!TII->unfoldMemoryOperand(*MF, &MI, Reg,
|
2010-07-02 20:36:18 +00:00
|
|
|
/*UnfoldLoad=*/true,/*UnfoldStore=*/false,
|
|
|
|
NewMIs)) {
|
|
|
|
DEBUG(dbgs() << "2addr: ABANDONING UNFOLD\n");
|
|
|
|
return false;
|
|
|
|
}
|
2010-06-21 22:17:20 +00:00
|
|
|
assert(NewMIs.size() == 2 &&
|
|
|
|
"Unfolded a load into multiple instructions!");
|
|
|
|
// The load was previously folded, so this is the only use.
|
|
|
|
NewMIs[1]->addRegisterKilled(Reg, TRI);
|
|
|
|
|
|
|
|
// Tentatively insert the instructions into the block so that they
|
|
|
|
// look "normal" to the transformation logic.
|
|
|
|
mbbi->insert(mi, NewMIs[0]);
|
|
|
|
mbbi->insert(mi, NewMIs[1]);
|
|
|
|
|
|
|
|
DEBUG(dbgs() << "2addr: NEW LOAD: " << *NewMIs[0]
|
|
|
|
<< "2addr: NEW INST: " << *NewMIs[1]);
|
|
|
|
|
|
|
|
// Transform the instruction, now that it no longer has a load.
|
|
|
|
unsigned NewDstIdx = NewMIs[1]->findRegisterDefOperandIdx(regA);
|
|
|
|
unsigned NewSrcIdx = NewMIs[1]->findRegisterUseOperandIdx(regB);
|
|
|
|
MachineBasicBlock::iterator NewMI = NewMIs[1];
|
|
|
|
bool TransformSuccess =
|
|
|
|
TryInstructionTransform(NewMI, mi, mbbi,
|
2011-03-02 01:08:17 +00:00
|
|
|
NewSrcIdx, NewDstIdx, Dist, Processed);
|
2010-06-21 22:17:20 +00:00
|
|
|
if (TransformSuccess ||
|
|
|
|
NewMIs[1]->getOperand(NewSrcIdx).isKill()) {
|
|
|
|
// Success, or at least we made an improvement. Keep the unfolded
|
|
|
|
// instructions and discard the original.
|
|
|
|
if (LV) {
|
2011-11-14 19:48:55 +00:00
|
|
|
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = MI.getOperand(i);
|
2012-02-03 05:12:30 +00:00
|
|
|
if (MO.isReg() &&
|
2010-06-22 00:32:04 +00:00
|
|
|
TargetRegisterInfo::isVirtualRegister(MO.getReg())) {
|
|
|
|
if (MO.isUse()) {
|
2010-06-22 02:07:21 +00:00
|
|
|
if (MO.isKill()) {
|
|
|
|
if (NewMIs[0]->killsRegister(MO.getReg()))
|
2011-11-14 19:48:55 +00:00
|
|
|
LV->replaceKillInstruction(MO.getReg(), &MI, NewMIs[0]);
|
2010-06-22 02:07:21 +00:00
|
|
|
else {
|
|
|
|
assert(NewMIs[1]->killsRegister(MO.getReg()) &&
|
|
|
|
"Kill missing after load unfold!");
|
2011-11-14 19:48:55 +00:00
|
|
|
LV->replaceKillInstruction(MO.getReg(), &MI, NewMIs[1]);
|
2010-06-22 02:07:21 +00:00
|
|
|
}
|
|
|
|
}
|
2011-11-14 19:48:55 +00:00
|
|
|
} else if (LV->removeVirtualRegisterDead(MO.getReg(), &MI)) {
|
2010-06-22 02:07:21 +00:00
|
|
|
if (NewMIs[1]->registerDefIsDead(MO.getReg()))
|
|
|
|
LV->addVirtualRegisterDead(MO.getReg(), NewMIs[1]);
|
|
|
|
else {
|
|
|
|
assert(NewMIs[0]->registerDefIsDead(MO.getReg()) &&
|
|
|
|
"Dead flag missing after load unfold!");
|
|
|
|
LV->addVirtualRegisterDead(MO.getReg(), NewMIs[0]);
|
|
|
|
}
|
|
|
|
}
|
2010-06-22 00:32:04 +00:00
|
|
|
}
|
2010-06-21 22:17:20 +00:00
|
|
|
}
|
|
|
|
LV->addVirtualRegisterKilled(Reg, NewMIs[1]);
|
|
|
|
}
|
2011-11-14 19:48:55 +00:00
|
|
|
MI.eraseFromParent();
|
2010-06-21 22:17:20 +00:00
|
|
|
mi = NewMIs[1];
|
|
|
|
if (TransformSuccess)
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
// Transforming didn't eliminate the tie and didn't lead to an
|
|
|
|
// improvement. Clean up the unfolded instructions and keep the
|
|
|
|
// original.
|
|
|
|
DEBUG(dbgs() << "2addr: ABANDONING UNFOLD\n");
|
|
|
|
NewMIs[0]->eraseFromParent();
|
|
|
|
NewMIs[1]->eraseFromParent();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-03 20:58:42 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-08-03 23:25:45 +00:00
|
|
|
// Collect tied operands of MI that need to be handled.
|
|
|
|
// Rewrite trivial cases immediately.
|
|
|
|
// Return true if any tied operands where found, including the trivial ones.
|
|
|
|
bool TwoAddressInstructionPass::
|
|
|
|
collectTiedOperands(MachineInstr *MI, TiedOperandMap &TiedOperands) {
|
|
|
|
const MCInstrDesc &MCID = MI->getDesc();
|
|
|
|
bool AnyOps = false;
|
2012-09-04 22:59:30 +00:00
|
|
|
unsigned NumOps = MI->getNumOperands();
|
2012-08-03 23:25:45 +00:00
|
|
|
|
|
|
|
for (unsigned SrcIdx = 0; SrcIdx < NumOps; ++SrcIdx) {
|
|
|
|
unsigned DstIdx = 0;
|
|
|
|
if (!MI->isRegTiedToDefOperand(SrcIdx, &DstIdx))
|
|
|
|
continue;
|
|
|
|
AnyOps = true;
|
2012-08-07 22:47:06 +00:00
|
|
|
MachineOperand &SrcMO = MI->getOperand(SrcIdx);
|
|
|
|
MachineOperand &DstMO = MI->getOperand(DstIdx);
|
|
|
|
unsigned SrcReg = SrcMO.getReg();
|
|
|
|
unsigned DstReg = DstMO.getReg();
|
|
|
|
// Tied constraint already satisfied?
|
|
|
|
if (SrcReg == DstReg)
|
|
|
|
continue;
|
2012-08-03 23:25:45 +00:00
|
|
|
|
2012-08-07 22:47:06 +00:00
|
|
|
assert(SrcReg && SrcMO.isUse() && "two address instruction invalid");
|
2012-08-03 23:25:45 +00:00
|
|
|
|
|
|
|
// Deal with <undef> uses immediately - simply rewrite the src operand.
|
2012-08-07 22:47:06 +00:00
|
|
|
if (SrcMO.isUndef()) {
|
2012-08-03 23:25:45 +00:00
|
|
|
// Constrain the DstReg register class if required.
|
|
|
|
if (TargetRegisterInfo::isVirtualRegister(DstReg))
|
|
|
|
if (const TargetRegisterClass *RC = TII->getRegClass(MCID, SrcIdx,
|
|
|
|
TRI, *MF))
|
|
|
|
MRI->constrainRegClass(DstReg, RC);
|
2012-08-07 22:47:06 +00:00
|
|
|
SrcMO.setReg(DstReg);
|
2012-08-03 23:25:45 +00:00
|
|
|
DEBUG(dbgs() << "\t\trewrite undef:\t" << *MI);
|
|
|
|
continue;
|
|
|
|
}
|
2012-08-07 22:47:06 +00:00
|
|
|
TiedOperands[SrcReg].push_back(std::make_pair(SrcIdx, DstIdx));
|
2012-08-03 23:25:45 +00:00
|
|
|
}
|
|
|
|
return AnyOps;
|
|
|
|
}
|
|
|
|
|
2012-08-03 23:57:58 +00:00
|
|
|
// Process a list of tied MI operands that all use the same source register.
|
|
|
|
// The tied pairs are of the form (SrcIdx, DstIdx).
|
|
|
|
void
|
|
|
|
TwoAddressInstructionPass::processTiedPairs(MachineInstr *MI,
|
|
|
|
TiedPairList &TiedPairs,
|
|
|
|
unsigned &Dist) {
|
|
|
|
bool IsEarlyClobber = false;
|
|
|
|
bool RemovedKillFlag = false;
|
|
|
|
bool AllUsesCopied = true;
|
|
|
|
unsigned LastCopiedReg = 0;
|
|
|
|
unsigned RegB = 0;
|
|
|
|
for (unsigned tpi = 0, tpe = TiedPairs.size(); tpi != tpe; ++tpi) {
|
|
|
|
unsigned SrcIdx = TiedPairs[tpi].first;
|
|
|
|
unsigned DstIdx = TiedPairs[tpi].second;
|
|
|
|
|
|
|
|
const MachineOperand &DstMO = MI->getOperand(DstIdx);
|
|
|
|
unsigned RegA = DstMO.getReg();
|
|
|
|
IsEarlyClobber |= DstMO.isEarlyClobber();
|
|
|
|
|
|
|
|
// Grab RegB from the instruction because it may have changed if the
|
|
|
|
// instruction was commuted.
|
|
|
|
RegB = MI->getOperand(SrcIdx).getReg();
|
|
|
|
|
|
|
|
if (RegA == RegB) {
|
|
|
|
// The register is tied to multiple destinations (or else we would
|
|
|
|
// not have continued this far), but this use of the register
|
|
|
|
// already matches the tied destination. Leave it.
|
|
|
|
AllUsesCopied = false;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
LastCopiedReg = RegA;
|
|
|
|
|
|
|
|
assert(TargetRegisterInfo::isVirtualRegister(RegB) &&
|
|
|
|
"cannot make instruction into two-address form");
|
|
|
|
|
|
|
|
#ifndef NDEBUG
|
|
|
|
// First, verify that we don't have a use of "a" in the instruction
|
|
|
|
// (a = b + a for example) because our transformation will not
|
|
|
|
// work. This should never occur because we are in SSA form.
|
|
|
|
for (unsigned i = 0; i != MI->getNumOperands(); ++i)
|
|
|
|
assert(i == DstIdx ||
|
|
|
|
!MI->getOperand(i).isReg() ||
|
|
|
|
MI->getOperand(i).getReg() != RegA);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Emit a copy.
|
|
|
|
BuildMI(*MI->getParent(), MI, MI->getDebugLoc(),
|
|
|
|
TII->get(TargetOpcode::COPY), RegA).addReg(RegB);
|
|
|
|
|
|
|
|
// Update DistanceMap.
|
|
|
|
MachineBasicBlock::iterator PrevMI = MI;
|
|
|
|
--PrevMI;
|
|
|
|
DistanceMap.insert(std::make_pair(PrevMI, Dist));
|
|
|
|
DistanceMap[MI] = ++Dist;
|
|
|
|
|
|
|
|
SlotIndex CopyIdx;
|
|
|
|
if (Indexes)
|
|
|
|
CopyIdx = Indexes->insertMachineInstrInMaps(PrevMI).getRegSlot();
|
|
|
|
|
|
|
|
DEBUG(dbgs() << "\t\tprepend:\t" << *PrevMI);
|
|
|
|
|
|
|
|
MachineOperand &MO = MI->getOperand(SrcIdx);
|
|
|
|
assert(MO.isReg() && MO.getReg() == RegB && MO.isUse() &&
|
|
|
|
"inconsistent operand info for 2-reg pass");
|
|
|
|
if (MO.isKill()) {
|
|
|
|
MO.setIsKill(false);
|
|
|
|
RemovedKillFlag = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure regA is a legal regclass for the SrcIdx operand.
|
|
|
|
if (TargetRegisterInfo::isVirtualRegister(RegA) &&
|
|
|
|
TargetRegisterInfo::isVirtualRegister(RegB))
|
|
|
|
MRI->constrainRegClass(RegA, MRI->getRegClass(RegB));
|
|
|
|
|
|
|
|
MO.setReg(RegA);
|
|
|
|
|
|
|
|
// Propagate SrcRegMap.
|
|
|
|
SrcRegMap[RegA] = RegB;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (AllUsesCopied) {
|
|
|
|
if (!IsEarlyClobber) {
|
|
|
|
// Replace other (un-tied) uses of regB with LastCopiedReg.
|
|
|
|
for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = MI->getOperand(i);
|
|
|
|
if (MO.isReg() && MO.getReg() == RegB && MO.isUse()) {
|
|
|
|
if (MO.isKill()) {
|
|
|
|
MO.setIsKill(false);
|
|
|
|
RemovedKillFlag = true;
|
|
|
|
}
|
|
|
|
MO.setReg(LastCopiedReg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Update live variables for regB.
|
|
|
|
if (RemovedKillFlag && LV && LV->getVarInfo(RegB).removeKill(MI)) {
|
|
|
|
MachineBasicBlock::iterator PrevMI = MI;
|
|
|
|
--PrevMI;
|
|
|
|
LV->addVirtualRegisterKilled(RegB, PrevMI);
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (RemovedKillFlag) {
|
|
|
|
// Some tied uses of regB matched their destination registers, so
|
|
|
|
// regB is still used in this instruction, but a kill flag was
|
|
|
|
// removed from a different tied use of regB, so now we need to add
|
|
|
|
// a kill flag to one of the remaining uses of regB.
|
|
|
|
for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = MI->getOperand(i);
|
|
|
|
if (MO.isReg() && MO.getReg() == RegB && MO.isUse()) {
|
|
|
|
MO.setIsKill(true);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-05-10 00:12:52 +00:00
|
|
|
/// runOnMachineFunction - Reduce two-address instructions to two operands.
|
2003-12-18 13:06:04 +00:00
|
|
|
///
|
2012-08-03 23:25:45 +00:00
|
|
|
bool TwoAddressInstructionPass::runOnMachineFunction(MachineFunction &Func) {
|
|
|
|
MF = &Func;
|
|
|
|
const TargetMachine &TM = MF->getTarget();
|
|
|
|
MRI = &MF->getRegInfo();
|
2008-03-13 06:37:55 +00:00
|
|
|
TII = TM.getInstrInfo();
|
|
|
|
TRI = TM.getRegisterInfo();
|
2011-11-14 19:48:55 +00:00
|
|
|
InstrItins = TM.getInstrItineraryData();
|
2012-08-03 22:58:34 +00:00
|
|
|
Indexes = getAnalysisIfAvailable<SlotIndexes>();
|
2009-01-28 13:14:17 +00:00
|
|
|
LV = getAnalysisIfAvailable<LiveVariables>();
|
2012-08-03 22:58:34 +00:00
|
|
|
LIS = getAnalysisIfAvailable<LiveIntervals>();
|
2009-10-09 23:27:56 +00:00
|
|
|
AA = &getAnalysis<AliasAnalysis>();
|
2011-11-16 18:44:48 +00:00
|
|
|
OptLevel = TM.getOptLevel();
|
2004-07-22 15:26:23 +00:00
|
|
|
|
|
|
|
bool MadeChange = false;
|
|
|
|
|
2010-01-05 01:24:21 +00:00
|
|
|
DEBUG(dbgs() << "********** REWRITING TWO-ADDR INSTRS **********\n");
|
2012-02-03 05:12:30 +00:00
|
|
|
DEBUG(dbgs() << "********** Function: "
|
2012-08-22 06:07:19 +00:00
|
|
|
<< MF->getName() << '\n');
|
2004-07-22 15:26:23 +00:00
|
|
|
|
2011-07-29 22:51:22 +00:00
|
|
|
// This pass takes the function out of SSA form.
|
|
|
|
MRI->leaveSSA();
|
|
|
|
|
2012-08-03 23:25:45 +00:00
|
|
|
TiedOperandMap TiedOperands;
|
2009-09-03 20:58:42 +00:00
|
|
|
|
2009-03-01 02:03:43 +00:00
|
|
|
SmallPtrSet<MachineInstr*, 8> Processed;
|
2012-08-03 23:25:45 +00:00
|
|
|
for (MachineFunction::iterator mbbi = MF->begin(), mbbe = MF->end();
|
2004-07-22 15:26:23 +00:00
|
|
|
mbbi != mbbe; ++mbbi) {
|
2008-06-18 07:49:14 +00:00
|
|
|
unsigned Dist = 0;
|
|
|
|
DistanceMap.clear();
|
2009-03-01 02:03:43 +00:00
|
|
|
SrcRegMap.clear();
|
|
|
|
DstRegMap.clear();
|
|
|
|
Processed.clear();
|
2004-07-22 15:26:23 +00:00
|
|
|
for (MachineBasicBlock::iterator mi = mbbi->begin(), me = mbbi->end();
|
2008-03-27 01:27:25 +00:00
|
|
|
mi != me; ) {
|
2009-12-03 00:50:42 +00:00
|
|
|
MachineBasicBlock::iterator nmi = llvm::next(mi);
|
2010-02-10 21:47:48 +00:00
|
|
|
if (mi->isDebugValue()) {
|
|
|
|
mi = nmi;
|
|
|
|
continue;
|
|
|
|
}
|
2010-03-23 20:36:12 +00:00
|
|
|
|
2010-05-05 18:45:40 +00:00
|
|
|
// Remember REG_SEQUENCE instructions, we'll deal with them later.
|
|
|
|
if (mi->isRegSequence())
|
|
|
|
RegSequences.push_back(&*mi);
|
|
|
|
|
2008-06-18 07:49:14 +00:00
|
|
|
DistanceMap.insert(std::make_pair(mi, ++Dist));
|
2009-03-01 02:03:43 +00:00
|
|
|
|
|
|
|
ProcessCopy(&*mi, &*mbbi, Processed);
|
|
|
|
|
2009-09-03 20:58:42 +00:00
|
|
|
// First scan through all the tied register uses in this instruction
|
|
|
|
// and record a list of pairs of tied operands for each register.
|
2012-08-03 23:25:45 +00:00
|
|
|
if (!collectTiedOperands(mi, TiedOperands)) {
|
|
|
|
mi = nmi;
|
|
|
|
continue;
|
2009-09-03 20:58:42 +00:00
|
|
|
}
|
2004-02-04 22:17:40 +00:00
|
|
|
|
2012-08-03 23:25:45 +00:00
|
|
|
++NumTwoAddressInstrs;
|
2012-08-03 23:57:58 +00:00
|
|
|
MadeChange = true;
|
2012-08-03 23:25:45 +00:00
|
|
|
DEBUG(dbgs() << '\t' << *mi);
|
|
|
|
|
2012-07-18 18:58:22 +00:00
|
|
|
// If the instruction has a single pair of tied operands, try some
|
|
|
|
// transformations that may either eliminate the tied operands or
|
|
|
|
// improve the opportunities for coalescing away the register copy.
|
|
|
|
if (TiedOperands.size() == 1) {
|
|
|
|
SmallVector<std::pair<unsigned, unsigned>, 4> &TiedPairs
|
|
|
|
= TiedOperands.begin()->second;
|
|
|
|
if (TiedPairs.size() == 1) {
|
|
|
|
unsigned SrcIdx = TiedPairs[0].first;
|
|
|
|
unsigned DstIdx = TiedPairs[0].second;
|
|
|
|
unsigned SrcReg = mi->getOperand(SrcIdx).getReg();
|
|
|
|
unsigned DstReg = mi->getOperand(DstIdx).getReg();
|
|
|
|
if (SrcReg != DstReg &&
|
|
|
|
TryInstructionTransform(mi, nmi, mbbi, SrcIdx, DstIdx, Dist,
|
|
|
|
Processed)) {
|
|
|
|
// The tied operands have been eliminated or shifted further down the
|
|
|
|
// block to ease elimination. Continue processing with 'nmi'.
|
|
|
|
TiedOperands.clear();
|
|
|
|
mi = nmi;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-03 20:58:42 +00:00
|
|
|
// Now iterate over the information collected above.
|
|
|
|
for (TiedOperandMap::iterator OI = TiedOperands.begin(),
|
|
|
|
OE = TiedOperands.end(); OI != OE; ++OI) {
|
2012-08-03 23:57:58 +00:00
|
|
|
processTiedPairs(mi, OI->second, Dist);
|
2010-01-05 01:24:21 +00:00
|
|
|
DEBUG(dbgs() << "\t\trewrite to:\t" << *mi);
|
2012-06-25 03:27:12 +00:00
|
|
|
}
|
2008-05-10 00:12:52 +00:00
|
|
|
|
2012-06-25 03:27:12 +00:00
|
|
|
// Rewrite INSERT_SUBREG as COPY now that we no longer need SSA form.
|
|
|
|
if (mi->isInsertSubreg()) {
|
|
|
|
// From %reg = INSERT_SUBREG %reg, %subreg, subidx
|
|
|
|
// To %reg:subidx = COPY %subreg
|
|
|
|
unsigned SubIdx = mi->getOperand(3).getImm();
|
|
|
|
mi->RemoveOperand(3);
|
|
|
|
assert(mi->getOperand(0).getSubReg() == 0 && "Unexpected subreg idx");
|
|
|
|
mi->getOperand(0).setSubReg(SubIdx);
|
|
|
|
mi->getOperand(0).setIsUndef(mi->getOperand(1).isUndef());
|
|
|
|
mi->RemoveOperand(1);
|
|
|
|
mi->setDesc(TII->get(TargetOpcode::COPY));
|
|
|
|
DEBUG(dbgs() << "\t\tconvert to:\t" << *mi);
|
2010-07-06 23:26:25 +00:00
|
|
|
}
|
|
|
|
|
2009-09-03 20:58:42 +00:00
|
|
|
// Clear TiedOperands here instead of at the top of the loop
|
|
|
|
// since most instructions do not have tied operands.
|
|
|
|
TiedOperands.clear();
|
2008-03-27 01:27:25 +00:00
|
|
|
mi = nmi;
|
2003-12-18 13:06:04 +00:00
|
|
|
}
|
2004-07-22 15:26:23 +00:00
|
|
|
}
|
2003-12-18 13:06:04 +00:00
|
|
|
|
2010-05-05 18:45:40 +00:00
|
|
|
// Eliminate REG_SEQUENCE instructions. Their whole purpose was to preseve
|
|
|
|
// SSA form. It's now safe to de-SSA.
|
|
|
|
MadeChange |= EliminateRegSequences();
|
|
|
|
|
2004-07-22 15:26:23 +00:00
|
|
|
return MadeChange;
|
2003-12-18 13:06:04 +00:00
|
|
|
}
|
2010-05-05 18:45:40 +00:00
|
|
|
|
|
|
|
static void UpdateRegSequenceSrcs(unsigned SrcReg,
|
2010-05-17 20:57:12 +00:00
|
|
|
unsigned DstReg, unsigned SubIdx,
|
2010-05-29 00:14:14 +00:00
|
|
|
MachineRegisterInfo *MRI,
|
|
|
|
const TargetRegisterInfo &TRI) {
|
2010-05-05 18:45:40 +00:00
|
|
|
for (MachineRegisterInfo::reg_iterator RI = MRI->reg_begin(SrcReg),
|
2010-05-12 01:27:49 +00:00
|
|
|
RE = MRI->reg_end(); RI != RE; ) {
|
2010-05-05 18:45:40 +00:00
|
|
|
MachineOperand &MO = RI.getOperand();
|
|
|
|
++RI;
|
2010-05-29 00:14:14 +00:00
|
|
|
MO.substVirtReg(DstReg, SubIdx, TRI);
|
2010-05-17 20:57:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-24 23:28:42 +00:00
|
|
|
// Find the first def of Reg, assuming they are all in the same basic block.
|
|
|
|
static MachineInstr *findFirstDef(unsigned Reg, MachineRegisterInfo *MRI) {
|
|
|
|
SmallPtrSet<MachineInstr*, 8> Defs;
|
|
|
|
MachineInstr *First = 0;
|
|
|
|
for (MachineRegisterInfo::def_iterator RI = MRI->def_begin(Reg);
|
|
|
|
MachineInstr *MI = RI.skipInstruction(); Defs.insert(MI))
|
|
|
|
First = MI;
|
|
|
|
if (!First)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
MachineBasicBlock *MBB = First->getParent();
|
|
|
|
MachineBasicBlock::iterator A = First, B = First;
|
|
|
|
bool Moving;
|
|
|
|
do {
|
|
|
|
Moving = false;
|
|
|
|
if (A != MBB->begin()) {
|
|
|
|
Moving = true;
|
|
|
|
--A;
|
|
|
|
if (Defs.erase(A)) First = A;
|
|
|
|
}
|
|
|
|
if (B != MBB->end()) {
|
|
|
|
Defs.erase(B);
|
|
|
|
++B;
|
|
|
|
Moving = true;
|
|
|
|
}
|
|
|
|
} while (Moving && !Defs.empty());
|
|
|
|
assert(Defs.empty() && "Instructions outside basic block!");
|
|
|
|
return First;
|
|
|
|
}
|
|
|
|
|
2010-05-17 20:57:12 +00:00
|
|
|
/// CoalesceExtSubRegs - If a number of sources of the REG_SEQUENCE are
|
|
|
|
/// EXTRACT_SUBREG from the same register and to the same virtual register
|
|
|
|
/// with different sub-register indices, attempt to combine the
|
|
|
|
/// EXTRACT_SUBREGs and pre-coalesce them. e.g.
|
|
|
|
/// %reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
|
|
|
|
/// %reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
|
|
|
|
/// %reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
|
|
|
|
/// Since D subregs 5, 6 can combine to a Q register, we can coalesce
|
|
|
|
/// reg1026 to reg1029.
|
|
|
|
void
|
|
|
|
TwoAddressInstructionPass::CoalesceExtSubRegs(SmallVector<unsigned,4> &Srcs,
|
|
|
|
unsigned DstReg) {
|
|
|
|
SmallSet<unsigned, 4> Seen;
|
|
|
|
for (unsigned i = 0, e = Srcs.size(); i != e; ++i) {
|
|
|
|
unsigned SrcReg = Srcs[i];
|
|
|
|
if (!Seen.insert(SrcReg))
|
|
|
|
continue;
|
|
|
|
|
2010-06-03 23:53:58 +00:00
|
|
|
// Check that the instructions are all in the same basic block.
|
2012-07-02 18:55:36 +00:00
|
|
|
MachineInstr *SrcDefMI = MRI->getUniqueVRegDef(SrcReg);
|
|
|
|
MachineInstr *DstDefMI = MRI->getUniqueVRegDef(DstReg);
|
|
|
|
if (!SrcDefMI || !DstDefMI ||
|
|
|
|
SrcDefMI->getParent() != DstDefMI->getParent())
|
2010-06-03 23:53:58 +00:00
|
|
|
continue;
|
|
|
|
|
2010-07-08 16:40:22 +00:00
|
|
|
// If there are no other uses than copies which feed into
|
2010-05-17 20:57:12 +00:00
|
|
|
// the reg_sequence, then we might be able to coalesce them.
|
|
|
|
bool CanCoalesce = true;
|
2010-06-15 17:27:54 +00:00
|
|
|
SmallVector<unsigned, 4> SrcSubIndices, DstSubIndices;
|
2010-05-17 20:57:12 +00:00
|
|
|
for (MachineRegisterInfo::use_nodbg_iterator
|
|
|
|
UI = MRI->use_nodbg_begin(SrcReg),
|
|
|
|
UE = MRI->use_nodbg_end(); UI != UE; ++UI) {
|
|
|
|
MachineInstr *UseMI = &*UI;
|
2010-07-08 16:40:22 +00:00
|
|
|
if (!UseMI->isCopy() || UseMI->getOperand(0).getReg() != DstReg) {
|
2010-05-17 20:57:12 +00:00
|
|
|
CanCoalesce = false;
|
|
|
|
break;
|
|
|
|
}
|
2010-07-08 16:40:22 +00:00
|
|
|
SrcSubIndices.push_back(UseMI->getOperand(1).getSubReg());
|
2010-06-15 17:27:54 +00:00
|
|
|
DstSubIndices.push_back(UseMI->getOperand(0).getSubReg());
|
2010-05-17 20:57:12 +00:00
|
|
|
}
|
|
|
|
|
2010-06-15 17:27:54 +00:00
|
|
|
if (!CanCoalesce || SrcSubIndices.size() < 2)
|
2010-05-17 20:57:12 +00:00
|
|
|
continue;
|
|
|
|
|
2010-06-15 17:27:54 +00:00
|
|
|
// Check that the source subregisters can be combined.
|
|
|
|
std::sort(SrcSubIndices.begin(), SrcSubIndices.end());
|
2010-06-15 05:56:31 +00:00
|
|
|
unsigned NewSrcSubIdx = 0;
|
2010-06-15 17:27:54 +00:00
|
|
|
if (!TRI->canCombineSubRegIndices(MRI->getRegClass(SrcReg), SrcSubIndices,
|
2010-06-15 05:56:31 +00:00
|
|
|
NewSrcSubIdx))
|
2010-06-03 23:53:58 +00:00
|
|
|
continue;
|
|
|
|
|
2010-06-15 17:27:54 +00:00
|
|
|
// Check that the destination subregisters can also be combined.
|
|
|
|
std::sort(DstSubIndices.begin(), DstSubIndices.end());
|
|
|
|
unsigned NewDstSubIdx = 0;
|
|
|
|
if (!TRI->canCombineSubRegIndices(MRI->getRegClass(DstReg), DstSubIndices,
|
|
|
|
NewDstSubIdx))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// If neither source nor destination can be combined to the full register,
|
|
|
|
// just give up. This could be improved if it ever matters.
|
|
|
|
if (NewSrcSubIdx != 0 && NewDstSubIdx != 0)
|
|
|
|
continue;
|
|
|
|
|
2010-06-15 05:56:31 +00:00
|
|
|
// Now that we know that all the uses are extract_subregs and that those
|
|
|
|
// subregs can somehow be combined, scan all the extract_subregs again to
|
|
|
|
// make sure the subregs are in the right order and can be composed.
|
|
|
|
MachineInstr *SomeMI = 0;
|
|
|
|
CanCoalesce = true;
|
|
|
|
for (MachineRegisterInfo::use_nodbg_iterator
|
|
|
|
UI = MRI->use_nodbg_begin(SrcReg),
|
|
|
|
UE = MRI->use_nodbg_end(); UI != UE; ++UI) {
|
|
|
|
MachineInstr *UseMI = &*UI;
|
2010-07-08 16:40:22 +00:00
|
|
|
assert(UseMI->isCopy());
|
2010-06-15 05:56:31 +00:00
|
|
|
unsigned DstSubIdx = UseMI->getOperand(0).getSubReg();
|
2010-07-08 16:40:22 +00:00
|
|
|
unsigned SrcSubIdx = UseMI->getOperand(1).getSubReg();
|
2010-06-15 05:56:31 +00:00
|
|
|
assert(DstSubIdx != 0 && "missing subreg from RegSequence elimination");
|
2010-06-15 17:27:54 +00:00
|
|
|
if ((NewDstSubIdx == 0 &&
|
|
|
|
TRI->composeSubRegIndices(NewSrcSubIdx, DstSubIdx) != SrcSubIdx) ||
|
|
|
|
(NewSrcSubIdx == 0 &&
|
|
|
|
TRI->composeSubRegIndices(NewDstSubIdx, SrcSubIdx) != DstSubIdx)) {
|
2010-06-15 05:56:31 +00:00
|
|
|
CanCoalesce = false;
|
|
|
|
break;
|
|
|
|
}
|
2012-01-24 04:44:01 +00:00
|
|
|
// Keep track of one of the uses. Preferably the first one which has a
|
|
|
|
// <def,undef> flag.
|
|
|
|
if (!SomeMI || UseMI->getOperand(0).isUndef())
|
|
|
|
SomeMI = UseMI;
|
2010-06-15 05:56:31 +00:00
|
|
|
}
|
|
|
|
if (!CanCoalesce)
|
|
|
|
continue;
|
|
|
|
|
2010-07-08 16:40:22 +00:00
|
|
|
// Insert a copy to replace the original.
|
2010-07-08 16:40:15 +00:00
|
|
|
MachineInstr *CopyMI = BuildMI(*SomeMI->getParent(), SomeMI,
|
|
|
|
SomeMI->getDebugLoc(),
|
|
|
|
TII->get(TargetOpcode::COPY))
|
2012-01-24 04:44:01 +00:00
|
|
|
.addReg(DstReg, RegState::Define |
|
|
|
|
getUndefRegState(SomeMI->getOperand(0).isUndef()),
|
|
|
|
NewDstSubIdx)
|
2010-07-08 16:40:15 +00:00
|
|
|
.addReg(SrcReg, 0, NewSrcSubIdx);
|
2010-06-15 05:56:31 +00:00
|
|
|
|
|
|
|
// Remove all the old extract instructions.
|
|
|
|
for (MachineRegisterInfo::use_nodbg_iterator
|
|
|
|
UI = MRI->use_nodbg_begin(SrcReg),
|
|
|
|
UE = MRI->use_nodbg_end(); UI != UE; ) {
|
|
|
|
MachineInstr *UseMI = &*UI;
|
|
|
|
++UI;
|
|
|
|
if (UseMI == CopyMI)
|
|
|
|
continue;
|
2010-07-08 16:40:22 +00:00
|
|
|
assert(UseMI->isCopy());
|
2010-06-15 05:56:31 +00:00
|
|
|
// Move any kills to the new copy or extract instruction.
|
|
|
|
if (UseMI->getOperand(1).isKill()) {
|
2010-07-08 16:40:22 +00:00
|
|
|
CopyMI->getOperand(1).setIsKill();
|
2010-06-15 05:56:31 +00:00
|
|
|
if (LV)
|
|
|
|
// Update live variables
|
|
|
|
LV->replaceKillInstruction(SrcReg, UseMI, &*CopyMI);
|
2010-05-17 20:57:12 +00:00
|
|
|
}
|
2010-06-15 05:56:31 +00:00
|
|
|
UseMI->eraseFromParent();
|
|
|
|
}
|
2010-05-05 18:45:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-17 23:24:12 +00:00
|
|
|
static bool HasOtherRegSequenceUses(unsigned Reg, MachineInstr *RegSeq,
|
|
|
|
MachineRegisterInfo *MRI) {
|
|
|
|
for (MachineRegisterInfo::use_iterator UI = MRI->use_begin(Reg),
|
|
|
|
UE = MRI->use_end(); UI != UE; ++UI) {
|
|
|
|
MachineInstr *UseMI = &*UI;
|
|
|
|
if (UseMI != RegSeq && UseMI->isRegSequence())
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-05-05 18:45:40 +00:00
|
|
|
/// EliminateRegSequences - Eliminate REG_SEQUENCE instructions as part
|
|
|
|
/// of the de-ssa process. This replaces sources of REG_SEQUENCE as
|
|
|
|
/// sub-register references of the register defined by REG_SEQUENCE. e.g.
|
|
|
|
///
|
|
|
|
/// %reg1029<def>, %reg1030<def> = VLD1q16 %reg1024<kill>, ...
|
|
|
|
/// %reg1031<def> = REG_SEQUENCE %reg1029<kill>, 5, %reg1030<kill>, 6
|
|
|
|
/// =>
|
|
|
|
/// %reg1031:5<def>, %reg1031:6<def> = VLD1q16 %reg1024<kill>, ...
|
|
|
|
bool TwoAddressInstructionPass::EliminateRegSequences() {
|
|
|
|
if (RegSequences.empty())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = RegSequences.size(); i != e; ++i) {
|
|
|
|
MachineInstr *MI = RegSequences[i];
|
|
|
|
unsigned DstReg = MI->getOperand(0).getReg();
|
|
|
|
if (MI->getOperand(0).getSubReg() ||
|
|
|
|
TargetRegisterInfo::isPhysicalRegister(DstReg) ||
|
|
|
|
!(MI->getNumOperands() & 1)) {
|
|
|
|
DEBUG(dbgs() << "Illegal REG_SEQUENCE instruction:" << *MI);
|
|
|
|
llvm_unreachable(0);
|
|
|
|
}
|
2010-05-11 00:04:31 +00:00
|
|
|
|
2010-05-17 22:09:49 +00:00
|
|
|
bool IsImpDef = true;
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
SmallVector<unsigned, 4> RealSrcs;
|
2010-05-11 00:04:31 +00:00
|
|
|
SmallSet<unsigned, 4> Seen;
|
2010-05-05 18:45:40 +00:00
|
|
|
for (unsigned i = 1, e = MI->getNumOperands(); i < e; i += 2) {
|
2012-06-25 03:27:12 +00:00
|
|
|
// Nothing needs to be inserted for <undef> operands.
|
|
|
|
if (MI->getOperand(i).isUndef()) {
|
|
|
|
MI->getOperand(i).setReg(0);
|
|
|
|
continue;
|
|
|
|
}
|
2010-05-05 18:45:40 +00:00
|
|
|
unsigned SrcReg = MI->getOperand(i).getReg();
|
2012-04-04 21:03:25 +00:00
|
|
|
unsigned SrcSubIdx = MI->getOperand(i).getSubReg();
|
2010-12-17 01:21:12 +00:00
|
|
|
unsigned SubIdx = MI->getOperand(i+1).getImm();
|
2012-01-18 04:16:16 +00:00
|
|
|
// DefMI of NULL means the value does not have a vreg in this block
|
|
|
|
// i.e., its a physical register or a subreg.
|
|
|
|
// In either case we force a copy to be generated.
|
|
|
|
MachineInstr *DefMI = NULL;
|
|
|
|
if (!MI->getOperand(i).getSubReg() &&
|
|
|
|
!TargetRegisterInfo::isPhysicalRegister(SrcReg)) {
|
2012-07-02 18:55:36 +00:00
|
|
|
DefMI = MRI->getUniqueVRegDef(SrcReg);
|
2010-05-05 18:45:40 +00:00
|
|
|
}
|
2010-05-11 00:04:31 +00:00
|
|
|
|
2012-01-18 04:16:16 +00:00
|
|
|
if (DefMI && DefMI->isImplicitDef()) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
DefMI->eraseFromParent();
|
|
|
|
continue;
|
|
|
|
}
|
2010-05-17 22:09:49 +00:00
|
|
|
IsImpDef = false;
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
|
2010-07-08 16:40:22 +00:00
|
|
|
// Remember COPY sources. These might be candidate for coalescing.
|
2012-01-18 04:16:16 +00:00
|
|
|
if (DefMI && DefMI->isCopy() && DefMI->getOperand(1).getSubReg())
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
RealSrcs.push_back(DefMI->getOperand(1).getReg());
|
|
|
|
|
2010-07-10 22:42:59 +00:00
|
|
|
bool isKill = MI->getOperand(i).isKill();
|
2012-01-18 04:16:16 +00:00
|
|
|
if (!DefMI || !Seen.insert(SrcReg) ||
|
|
|
|
MI->getParent() != DefMI->getParent() ||
|
2010-12-17 01:21:12 +00:00
|
|
|
!isKill || HasOtherRegSequenceUses(SrcReg, MI, MRI) ||
|
|
|
|
!TRI->getMatchingSuperRegClass(MRI->getRegClass(DstReg),
|
|
|
|
MRI->getRegClass(SrcReg), SubIdx)) {
|
2010-05-13 00:00:35 +00:00
|
|
|
// REG_SEQUENCE cannot have duplicated operands, add a copy.
|
2010-05-19 20:08:00 +00:00
|
|
|
// Also add an copy if the source is live-in the block. We don't want
|
2010-05-13 00:00:35 +00:00
|
|
|
// to end up with a partial-redef of a livein, e.g.
|
|
|
|
// BB0:
|
|
|
|
// reg1051:10<def> =
|
|
|
|
// ...
|
|
|
|
// BB1:
|
|
|
|
// ... = reg1051:10
|
|
|
|
// BB2:
|
|
|
|
// reg1051:9<def> =
|
|
|
|
// LiveIntervalAnalysis won't like it.
|
2010-05-19 20:08:00 +00:00
|
|
|
//
|
|
|
|
// If the REG_SEQUENCE doesn't kill its source, keeping live variables
|
|
|
|
// correctly up to date becomes very difficult. Insert a copy.
|
2010-08-09 20:19:16 +00:00
|
|
|
|
|
|
|
// Defer any kill flag to the last operand using SrcReg. Otherwise, we
|
|
|
|
// might insert a COPY that uses SrcReg after is was killed.
|
|
|
|
if (isKill)
|
|
|
|
for (unsigned j = i + 2; j < e; j += 2)
|
|
|
|
if (MI->getOperand(j).getReg() == SrcReg) {
|
|
|
|
MI->getOperand(j).setIsKill();
|
|
|
|
isKill = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-05-13 00:00:35 +00:00
|
|
|
MachineBasicBlock::iterator InsertLoc = MI;
|
2010-07-10 22:42:59 +00:00
|
|
|
MachineInstr *CopyMI = BuildMI(*MI->getParent(), InsertLoc,
|
|
|
|
MI->getDebugLoc(), TII->get(TargetOpcode::COPY))
|
2010-12-17 01:21:12 +00:00
|
|
|
.addReg(DstReg, RegState::Define, SubIdx)
|
2012-04-04 21:03:25 +00:00
|
|
|
.addReg(SrcReg, getKillRegState(isKill), SrcSubIdx);
|
2010-07-10 22:42:59 +00:00
|
|
|
MI->getOperand(i).setReg(0);
|
2012-01-18 04:16:16 +00:00
|
|
|
if (LV && isKill && !TargetRegisterInfo::isPhysicalRegister(SrcReg))
|
2010-07-10 22:42:59 +00:00
|
|
|
LV->replaceKillInstruction(SrcReg, MI, CopyMI);
|
|
|
|
DEBUG(dbgs() << "Inserted: " << *CopyMI);
|
2010-05-11 00:04:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (unsigned i = 1, e = MI->getNumOperands(); i < e; i += 2) {
|
|
|
|
unsigned SrcReg = MI->getOperand(i).getReg();
|
2010-07-10 22:42:59 +00:00
|
|
|
if (!SrcReg) continue;
|
2010-05-17 20:57:12 +00:00
|
|
|
unsigned SubIdx = MI->getOperand(i+1).getImm();
|
2010-05-29 00:14:14 +00:00
|
|
|
UpdateRegSequenceSrcs(SrcReg, DstReg, SubIdx, MRI, *TRI);
|
2010-05-05 18:45:40 +00:00
|
|
|
}
|
|
|
|
|
2012-01-24 23:28:42 +00:00
|
|
|
// Set <def,undef> flags on the first DstReg def in the basic block.
|
|
|
|
// It marks the beginning of the live range. All the other defs are
|
|
|
|
// read-modify-write.
|
|
|
|
if (MachineInstr *Def = findFirstDef(DstReg, MRI)) {
|
|
|
|
for (unsigned i = 0, e = Def->getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = Def->getOperand(i);
|
|
|
|
if (MO.isReg() && MO.isDef() && MO.getReg() == DstReg)
|
|
|
|
MO.setIsUndef();
|
|
|
|
}
|
|
|
|
DEBUG(dbgs() << "First def: " << *Def);
|
|
|
|
}
|
|
|
|
|
2010-05-17 22:09:49 +00:00
|
|
|
if (IsImpDef) {
|
|
|
|
DEBUG(dbgs() << "Turned: " << *MI << " into an IMPLICIT_DEF");
|
|
|
|
MI->setDesc(TII->get(TargetOpcode::IMPLICIT_DEF));
|
|
|
|
for (int j = MI->getNumOperands() - 1, ee = 0; j > ee; --j)
|
2012-02-03 05:12:30 +00:00
|
|
|
MI->RemoveOperand(j);
|
2010-05-17 22:09:49 +00:00
|
|
|
} else {
|
|
|
|
DEBUG(dbgs() << "Eliminated: " << *MI);
|
|
|
|
MI->eraseFromParent();
|
|
|
|
}
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
|
2010-06-18 23:10:20 +00:00
|
|
|
// Try coalescing some EXTRACT_SUBREG instructions. This can create
|
|
|
|
// INSERT_SUBREG instructions that must have <undef> flags added by
|
|
|
|
// LiveIntervalAnalysis, so only run it when LiveVariables is available.
|
|
|
|
if (LV)
|
|
|
|
CoalesceExtSubRegs(RealSrcs, DstReg);
|
2010-05-05 18:45:40 +00:00
|
|
|
}
|
|
|
|
|
2010-05-10 21:24:55 +00:00
|
|
|
RegSequences.clear();
|
2010-05-05 18:45:40 +00:00
|
|
|
return true;
|
|
|
|
}
|