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"
|
2003-12-18 13:06:04 +00:00
|
|
|
#include "llvm/CodeGen/LiveVariables.h"
|
|
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
|
|
|
#include "llvm/CodeGen/MachineInstr.h"
|
2007-12-31 04:13:23 +00:00
|
|
|
#include "llvm/CodeGen/MachineRegisterInfo.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"
|
2006-08-27 12:54:02 +00:00
|
|
|
#include "llvm/Support/Compiler.h"
|
2008-03-13 06:37:55 +00:00
|
|
|
#include "llvm/Support/Debug.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");
|
|
|
|
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");
|
2008-06-18 07:49:14 +00:00
|
|
|
STATISTIC(NumReMats, "Number of instructions re-materialized");
|
2008-03-13 06:37:55 +00:00
|
|
|
|
2006-12-19 22:41:21 +00:00
|
|
|
namespace {
|
2008-05-10 00:12:52 +00:00
|
|
|
class VISIBILITY_HIDDEN TwoAddressInstructionPass
|
|
|
|
: public MachineFunctionPass {
|
2008-03-13 06:37:55 +00:00
|
|
|
const TargetInstrInfo *TII;
|
|
|
|
const TargetRegisterInfo *TRI;
|
|
|
|
MachineRegisterInfo *MRI;
|
|
|
|
LiveVariables *LV;
|
|
|
|
|
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
|
|
|
|
|
|
|
bool isProfitableToReMat(unsigned Reg, const TargetRegisterClass *RC,
|
2008-06-25 01:16:38 +00:00
|
|
|
MachineInstr *MI, MachineInstr *DefMI,
|
|
|
|
MachineBasicBlock *MBB, unsigned Loc,
|
2008-06-18 07:49:14 +00:00
|
|
|
DenseMap<MachineInstr*, unsigned> &DistanceMap);
|
2009-01-23 23:27:33 +00:00
|
|
|
|
|
|
|
bool CommuteInstruction(MachineBasicBlock::iterator &mi,
|
|
|
|
MachineFunction::iterator &mbbi,
|
|
|
|
unsigned RegC, unsigned Dist,
|
|
|
|
DenseMap<MachineInstr*, unsigned> &DistanceMap);
|
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
|
2008-09-04 17:05:41 +00:00
|
|
|
TwoAddressInstructionPass() : MachineFunctionPass(&ID) {}
|
2007-05-01 21:15:47 +00:00
|
|
|
|
2008-05-10 00:12:52 +00:00
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
AU.addPreserved<LiveVariables>();
|
|
|
|
AU.addPreservedID(MachineLoopInfoID);
|
|
|
|
AU.addPreservedID(MachineDominatorsID);
|
2008-10-07 20:22:28 +00:00
|
|
|
if (StrongPHIElim)
|
|
|
|
AU.addPreservedID(StrongPHIEliminationID);
|
|
|
|
else
|
|
|
|
AU.addPreservedID(PHIEliminationID);
|
2008-05-10 00:12:52 +00:00
|
|
|
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;
|
|
|
|
static RegisterPass<TwoAddressInstructionPass>
|
|
|
|
X("twoaddressinstruction", "Two-Address instruction pass");
|
|
|
|
|
2008-05-13 02:05:11 +00:00
|
|
|
const PassInfo *const llvm::TwoAddressInstructionPassID = &X;
|
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) {
|
|
|
|
// Check if it's safe to move this instruction.
|
|
|
|
bool SeenStore = true; // Be conservative.
|
|
|
|
if (!MI->isSafeToMove(TII, SeenStore))
|
|
|
|
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;
|
|
|
|
for (MachineRegisterInfo::use_iterator UI = MRI->use_begin(SavedReg),
|
|
|
|
UE = MRI->use_end(); UI != UE; ++UI) {
|
|
|
|
MachineOperand &UseMO = UI.getOperand();
|
|
|
|
if (!UseMO.isKill())
|
|
|
|
continue;
|
|
|
|
KillMI = UseMO.getParent();
|
|
|
|
break;
|
|
|
|
}
|
2008-05-10 00:12:52 +00:00
|
|
|
|
2008-03-13 06:37:55 +00:00
|
|
|
if (!KillMI || KillMI->getParent() != MBB)
|
|
|
|
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.
|
|
|
|
//
|
|
|
|
// 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;
|
2008-03-13 06:37:55 +00:00
|
|
|
for (MachineBasicBlock::iterator I = next(OldPos); I != KillPos; ++I) {
|
|
|
|
MachineInstr *OtherMI = I;
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Update kill and LV information.
|
|
|
|
KillMO->setIsKill(false);
|
|
|
|
KillMO = MI->findRegisterUseOperand(SavedReg, false, TRI);
|
|
|
|
KillMO->setIsKill(true);
|
2008-07-02 21:28:58 +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);
|
|
|
|
|
|
|
|
++Num3AddrSunk;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-06-18 07:49:14 +00:00
|
|
|
/// isTwoAddrUse - Return true if the specified MI is using the specified
|
|
|
|
/// register as a two-address operand.
|
|
|
|
static bool isTwoAddrUse(MachineInstr *UseMI, unsigned Reg) {
|
|
|
|
const TargetInstrDesc &TID = UseMI->getDesc();
|
|
|
|
for (unsigned i = 0, e = TID.getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = UseMI->getOperand(i);
|
2008-10-03 15:45:36 +00:00
|
|
|
if (MO.isReg() && MO.getReg() == Reg &&
|
2008-06-18 07:49:14 +00:00
|
|
|
(MO.isDef() || TID.getOperandConstraint(i, TOI::TIED_TO) != -1))
|
|
|
|
// Earlier use is a two-address one.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isProfitableToReMat - Return true if the heuristics determines it is likely
|
|
|
|
/// to be profitable to re-materialize the definition of Reg rather than copy
|
|
|
|
/// the register.
|
|
|
|
bool
|
|
|
|
TwoAddressInstructionPass::isProfitableToReMat(unsigned Reg,
|
|
|
|
const TargetRegisterClass *RC,
|
2008-06-25 01:16:38 +00:00
|
|
|
MachineInstr *MI, MachineInstr *DefMI,
|
|
|
|
MachineBasicBlock *MBB, unsigned Loc,
|
|
|
|
DenseMap<MachineInstr*, unsigned> &DistanceMap){
|
2008-06-18 07:49:14 +00:00
|
|
|
bool OtherUse = false;
|
|
|
|
for (MachineRegisterInfo::use_iterator UI = MRI->use_begin(Reg),
|
|
|
|
UE = MRI->use_end(); UI != UE; ++UI) {
|
|
|
|
MachineOperand &UseMO = UI.getOperand();
|
|
|
|
if (!UseMO.isUse())
|
|
|
|
continue;
|
|
|
|
MachineInstr *UseMI = UseMO.getParent();
|
2008-06-25 01:16:38 +00:00
|
|
|
MachineBasicBlock *UseMBB = UseMI->getParent();
|
|
|
|
if (UseMBB == MBB) {
|
|
|
|
DenseMap<MachineInstr*, unsigned>::iterator DI = DistanceMap.find(UseMI);
|
|
|
|
if (DI != DistanceMap.end() && DI->second == Loc)
|
|
|
|
continue; // Current use.
|
|
|
|
OtherUse = true;
|
|
|
|
// There is at least one other use in the MBB that will clobber the
|
|
|
|
// register.
|
|
|
|
if (isTwoAddrUse(UseMI, Reg))
|
|
|
|
return true;
|
|
|
|
}
|
2008-06-18 07:49:14 +00:00
|
|
|
}
|
2008-06-25 01:16:38 +00:00
|
|
|
|
|
|
|
// If other uses in MBB are not two-address uses, then don't remat.
|
|
|
|
if (OtherUse)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// No other uses in the same block, remat if it's defined in the same
|
|
|
|
// block so it does not unnecessarily extend the live range.
|
|
|
|
return MBB == DefMI->getParent();
|
2008-06-18 07:49:14 +00:00
|
|
|
}
|
|
|
|
|
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,
|
|
|
|
MachineFunction::iterator &mbbi,
|
|
|
|
unsigned RegC, unsigned Dist,
|
|
|
|
DenseMap<MachineInstr*, unsigned> &DistanceMap) {
|
|
|
|
MachineInstr *MI = mi;
|
|
|
|
DOUT << "2addr: COMMUTING : " << *MI;
|
|
|
|
MachineInstr *NewMI = TII->commuteInstruction(MI);
|
|
|
|
|
|
|
|
if (NewMI == 0) {
|
|
|
|
DOUT << "2addr: COMMUTING FAILED!\n";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
DOUT << "2addr: COMMUTED TO: " << *NewMI;
|
|
|
|
// If the instruction changed to commute it, update livevar.
|
|
|
|
if (NewMI != MI) {
|
|
|
|
if (LV)
|
|
|
|
// Update live variables
|
|
|
|
LV->replaceKillInstruction(RegC, MI, NewMI);
|
|
|
|
|
|
|
|
mbbi->insert(mi, NewMI); // Insert the new inst
|
|
|
|
mbbi->erase(mi); // Nuke the old inst.
|
|
|
|
mi = NewMI;
|
|
|
|
DistanceMap.insert(std::make_pair(NewMI, Dist));
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-05-10 00:12:52 +00:00
|
|
|
/// runOnMachineFunction - Reduce two-address instructions to two operands.
|
2003-12-18 13:06:04 +00:00
|
|
|
///
|
2004-01-31 21:14:04 +00:00
|
|
|
bool TwoAddressInstructionPass::runOnMachineFunction(MachineFunction &MF) {
|
2006-11-28 22:48:48 +00:00
|
|
|
DOUT << "Machine Function\n";
|
2004-07-22 15:26:23 +00:00
|
|
|
const TargetMachine &TM = MF.getTarget();
|
2008-03-13 06:37:55 +00:00
|
|
|
MRI = &MF.getRegInfo();
|
|
|
|
TII = TM.getInstrInfo();
|
|
|
|
TRI = TM.getRegisterInfo();
|
2008-07-02 21:28:58 +00:00
|
|
|
LV = getAnalysisToUpdate<LiveVariables>();
|
2004-07-22 15:26:23 +00:00
|
|
|
|
|
|
|
bool MadeChange = false;
|
|
|
|
|
2006-11-28 22:48:48 +00:00
|
|
|
DOUT << "********** REWRITING TWO-ADDR INSTRS **********\n";
|
|
|
|
DOUT << "********** Function: " << MF.getFunction()->getName() << '\n';
|
2004-07-22 15:26:23 +00:00
|
|
|
|
2008-06-18 07:49:14 +00:00
|
|
|
// ReMatRegs - Keep track of the registers whose def's are remat'ed.
|
|
|
|
BitVector ReMatRegs;
|
|
|
|
ReMatRegs.resize(MRI->getLastVirtReg()+1);
|
|
|
|
|
|
|
|
// DistanceMap - Keep track the distance of a MI from the start of the
|
|
|
|
// current basic block.
|
|
|
|
DenseMap<MachineInstr*, unsigned> DistanceMap;
|
A problem that's exposed when machine LICM is enabled. Consider this code:
LBB1_3: # bb
...
xorl %ebp, %ebp
subl (%ebx), %ebp
...
incl %ecx
cmpl %edi, %ecx
jl LBB1_3 # bb
Whe using machine LICM, LLVM converts it into:
xorl %esi, %esi
LBB1_3: # bb
...
movl %esi, %ebp
subl (%ebx), %ebp
...
incl %ecx
cmpl %edi, %ecx
jl LBB1_3 # bb
Two address conversion inserts the copy instruction. However, it's cheaper to
rematerialize it, and remat helps reduce register pressure.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51562 91177308-0d34-0410-b5e6-96231b3b80d8
2008-05-26 05:18:34 +00:00
|
|
|
|
2004-07-22 15:26:23 +00:00
|
|
|
for (MachineFunction::iterator mbbi = MF.begin(), mbbe = MF.end();
|
|
|
|
mbbi != mbbe; ++mbbi) {
|
2008-06-18 07:49:14 +00:00
|
|
|
unsigned Dist = 0;
|
|
|
|
DistanceMap.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; ) {
|
|
|
|
MachineBasicBlock::iterator nmi = next(mi);
|
2008-01-07 07:27:27 +00:00
|
|
|
const TargetInstrDesc &TID = mi->getDesc();
|
2006-11-01 23:06:55 +00:00
|
|
|
bool FirstTied = true;
|
2008-05-10 00:12:52 +00:00
|
|
|
|
2008-06-18 07:49:14 +00:00
|
|
|
DistanceMap.insert(std::make_pair(mi, ++Dist));
|
2008-01-07 07:27:27 +00:00
|
|
|
for (unsigned si = 1, e = TID.getNumOperands(); si < e; ++si) {
|
|
|
|
int ti = TID.getOperandConstraint(si, TOI::TIED_TO);
|
2006-11-01 23:06:55 +00:00
|
|
|
if (ti == -1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (FirstTied) {
|
|
|
|
++NumTwoAddressInstrs;
|
2006-12-07 20:28:15 +00:00
|
|
|
DOUT << '\t'; DEBUG(mi->print(*cerr.stream(), &TM));
|
2006-11-01 23:06:55 +00:00
|
|
|
}
|
2008-05-10 00:12:52 +00:00
|
|
|
|
2006-11-01 23:06:55 +00:00
|
|
|
FirstTied = false;
|
|
|
|
|
2008-10-03 15:45:36 +00:00
|
|
|
assert(mi->getOperand(si).isReg() && mi->getOperand(si).getReg() &&
|
2006-11-01 23:06:55 +00:00
|
|
|
mi->getOperand(si).isUse() && "two address instruction invalid");
|
|
|
|
|
2008-05-10 00:12:52 +00:00
|
|
|
// If the two operands are the same we just remove the use
|
2006-11-01 23:06:55 +00:00
|
|
|
// and mark the def as def&use, otherwise we have to insert a copy.
|
|
|
|
if (mi->getOperand(ti).getReg() != mi->getOperand(si).getReg()) {
|
2008-05-10 00:12:52 +00:00
|
|
|
// Rewrite:
|
2006-11-01 23:06:55 +00:00
|
|
|
// a = b op c
|
|
|
|
// to:
|
|
|
|
// a = b
|
|
|
|
// a = a op c
|
|
|
|
unsigned regA = mi->getOperand(ti).getReg();
|
|
|
|
unsigned regB = mi->getOperand(si).getReg();
|
|
|
|
|
2008-02-10 18:45:23 +00:00
|
|
|
assert(TargetRegisterInfo::isVirtualRegister(regA) &&
|
|
|
|
TargetRegisterInfo::isVirtualRegister(regB) &&
|
2006-11-01 23:06:55 +00:00
|
|
|
"cannot update physical register live information");
|
2004-07-22 15:26:23 +00:00
|
|
|
|
2004-07-21 23:17:57 +00:00
|
|
|
#ifndef NDEBUG
|
2006-11-01 23:06:55 +00:00
|
|
|
// 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((int)i == ti ||
|
2008-10-03 15:45:36 +00:00
|
|
|
!mi->getOperand(i).isReg() ||
|
2006-11-01 23:06:55 +00:00
|
|
|
mi->getOperand(i).getReg() != regA);
|
2004-07-21 23:17:57 +00:00
|
|
|
#endif
|
2004-02-04 22:17:40 +00:00
|
|
|
|
2006-11-01 23:06:55 +00:00
|
|
|
// If this instruction is not the killing user of B, see if we can
|
|
|
|
// rearrange the code to make it so. Making it the killing user will
|
|
|
|
// allow us to coalesce A and B together, eliminating the copy we are
|
|
|
|
// about to insert.
|
2008-03-05 00:59:57 +00:00
|
|
|
if (!mi->killsRegister(regB)) {
|
2006-11-01 23:06:55 +00:00
|
|
|
// If this instruction is commutative, check to see if C dies. If
|
|
|
|
// so, swap the B and C operands. This makes the live ranges of A
|
|
|
|
// and C joinable.
|
|
|
|
// FIXME: This code also works for A := B op C instructions.
|
2008-01-07 07:27:27 +00:00
|
|
|
if (TID.isCommutable() && mi->getNumOperands() >= 3) {
|
2008-10-03 15:45:36 +00:00
|
|
|
assert(mi->getOperand(3-si).isReg() &&
|
2006-11-01 23:06:55 +00:00
|
|
|
"Not a proper commutative instruction!");
|
|
|
|
unsigned regC = mi->getOperand(3-si).getReg();
|
2008-03-05 00:59:57 +00:00
|
|
|
if (mi->killsRegister(regC)) {
|
2009-01-23 23:27:33 +00:00
|
|
|
if (CommuteInstruction(mi, mbbi, regC, Dist, DistanceMap)) {
|
2006-11-01 23:06:55 +00:00
|
|
|
++NumCommuted;
|
|
|
|
regB = regC;
|
|
|
|
goto InstructionRearranged;
|
2005-04-21 22:36:52 +00:00
|
|
|
}
|
2005-01-19 07:08:42 +00:00
|
|
|
}
|
Make the 2-address instruction lowering pass smarter in two ways:
1. If we are two-addressing a commutable instruction and the LHS is not the
last use of the variable, see if the instruction is the last use of the
RHS. If so, commute the instruction, allowing us to avoid a
register-register copy in many cases for common instructions like ADD, OR,
AND, etc on X86.
2. If #1 doesn't hold, and if this is an instruction that also existing in
3-address form, promote the instruction to a 3-address instruction to
avoid the register-register copy. We can do this for several common
instructions in X86, including ADDrr, INC, DEC, etc.
This patch implements test/Regression/CodeGen/X86/commute-two-addr.ll,
overlap-add.ll, and overlap-shift.ll when I check in the X86 support for it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19245 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-02 02:34:12 +00:00
|
|
|
}
|
2006-11-01 23:06:55 +00:00
|
|
|
|
|
|
|
// If this instruction is potentially convertible to a true
|
|
|
|
// three-address instruction,
|
2008-01-07 07:27:27 +00:00
|
|
|
if (TID.isConvertibleTo3Addr()) {
|
2006-11-01 23:06:55 +00:00
|
|
|
// FIXME: This assumes there are no more operands which are tied
|
|
|
|
// to another register.
|
|
|
|
#ifndef NDEBUG
|
2008-05-10 00:12:52 +00:00
|
|
|
for (unsigned i = si + 1, e = TID.getNumOperands(); i < e; ++i)
|
2008-01-07 07:27:27 +00:00
|
|
|
assert(TID.getOperandConstraint(i, TOI::TIED_TO) == -1);
|
2006-11-01 23:06:55 +00:00
|
|
|
#endif
|
|
|
|
|
2008-07-02 23:41:07 +00:00
|
|
|
MachineInstr *NewMI = TII->convertToThreeAddress(mbbi, mi, LV);
|
2008-06-18 07:49:14 +00:00
|
|
|
if (NewMI) {
|
2006-11-28 22:48:48 +00:00
|
|
|
DOUT << "2addr: CONVERTING 2-ADDR: " << *mi;
|
2008-06-18 07:49:14 +00:00
|
|
|
DOUT << "2addr: TO 3-ADDR: " << *NewMI;
|
2008-03-13 07:56:58 +00:00
|
|
|
bool Sunk = false;
|
2008-05-10 00:12:52 +00:00
|
|
|
|
2008-06-18 07:49:14 +00:00
|
|
|
if (NewMI->findRegisterUseOperand(regB, false, TRI))
|
2008-03-13 07:56:58 +00:00
|
|
|
// FIXME: Temporary workaround. If the new instruction doesn't
|
|
|
|
// uses regB, convertToThreeAddress must have created more
|
|
|
|
// then one instruction.
|
2008-06-18 07:49:14 +00:00
|
|
|
Sunk = Sink3AddrInstruction(mbbi, NewMI, regB, mi);
|
2008-05-10 00:12:52 +00:00
|
|
|
|
|
|
|
mbbi->erase(mi); // Nuke the old inst.
|
|
|
|
|
2008-03-27 01:27:25 +00:00
|
|
|
if (!Sunk) {
|
2008-06-18 07:49:14 +00:00
|
|
|
DistanceMap.insert(std::make_pair(NewMI, Dist));
|
|
|
|
mi = NewMI;
|
2008-03-27 01:27:25 +00:00
|
|
|
nmi = next(mi);
|
|
|
|
}
|
2008-05-10 00:12:52 +00:00
|
|
|
|
2006-11-01 23:06:55 +00:00
|
|
|
++NumConvertedTo3Addr;
|
2008-05-10 00:12:52 +00:00
|
|
|
break; // Done with this instruction.
|
2006-11-01 23:06:55 +00:00
|
|
|
}
|
2007-10-20 04:01:47 +00:00
|
|
|
}
|
Make the 2-address instruction lowering pass smarter in two ways:
1. If we are two-addressing a commutable instruction and the LHS is not the
last use of the variable, see if the instruction is the last use of the
RHS. If so, commute the instruction, allowing us to avoid a
register-register copy in many cases for common instructions like ADD, OR,
AND, etc on X86.
2. If #1 doesn't hold, and if this is an instruction that also existing in
3-address form, promote the instruction to a 3-address instruction to
avoid the register-register copy. We can do this for several common
instructions in X86, including ADDrr, INC, DEC, etc.
This patch implements test/Regression/CodeGen/X86/commute-two-addr.ll,
overlap-add.ll, and overlap-shift.ll when I check in the X86 support for it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19245 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-02 02:34:12 +00:00
|
|
|
}
|
2004-07-22 15:26:23 +00:00
|
|
|
|
2006-11-01 23:06:55 +00:00
|
|
|
InstructionRearranged:
|
2008-06-18 07:49:14 +00:00
|
|
|
const TargetRegisterClass* rc = MRI->getRegClass(regA);
|
|
|
|
MachineInstr *DefMI = MRI->getVRegDef(regB);
|
|
|
|
// If it's safe and profitable, remat the definition instead of
|
|
|
|
// copying it.
|
2008-06-25 01:16:38 +00:00
|
|
|
if (DefMI &&
|
2008-08-27 20:58:54 +00:00
|
|
|
DefMI->getDesc().isAsCheapAsAMove() &&
|
2008-08-27 20:33:50 +00:00
|
|
|
DefMI->isSafeToReMat(TII, regB) &&
|
2008-06-25 01:16:38 +00:00
|
|
|
isProfitableToReMat(regB, rc, mi, DefMI, mbbi, Dist,DistanceMap)){
|
2008-06-18 07:49:14 +00:00
|
|
|
DEBUG(cerr << "2addr: REMATTING : " << *DefMI << "\n");
|
|
|
|
TII->reMaterialize(*mbbi, mi, regA, DefMI);
|
|
|
|
ReMatRegs.set(regB);
|
|
|
|
++NumReMats;
|
A problem that's exposed when machine LICM is enabled. Consider this code:
LBB1_3: # bb
...
xorl %ebp, %ebp
subl (%ebx), %ebp
...
incl %ecx
cmpl %edi, %ecx
jl LBB1_3 # bb
Whe using machine LICM, LLVM converts it into:
xorl %esi, %esi
LBB1_3: # bb
...
movl %esi, %ebp
subl (%ebx), %ebp
...
incl %ecx
cmpl %edi, %ecx
jl LBB1_3 # bb
Two address conversion inserts the copy instruction. However, it's cheaper to
rematerialize it, and remat helps reduce register pressure.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51562 91177308-0d34-0410-b5e6-96231b3b80d8
2008-05-26 05:18:34 +00:00
|
|
|
} else {
|
|
|
|
TII->copyRegToReg(*mbbi, mi, regA, regB, rc, rc);
|
|
|
|
}
|
2006-11-01 23:06:55 +00:00
|
|
|
|
|
|
|
MachineBasicBlock::iterator prevMi = prior(mi);
|
2004-07-22 15:26:23 +00:00
|
|
|
|
2008-05-10 00:12:52 +00:00
|
|
|
// Update live variables for regB.
|
2008-07-02 21:28:58 +00:00
|
|
|
if (LV) {
|
|
|
|
LiveVariables::VarInfo& varInfoB = LV->getVarInfo(regB);
|
2008-05-10 00:12:52 +00:00
|
|
|
|
2008-07-02 21:28:58 +00:00
|
|
|
// regB is used in this BB.
|
|
|
|
varInfoB.UsedBlocks[mbbi->getNumber()] = true;
|
2004-07-22 15:26:23 +00:00
|
|
|
|
2008-07-03 09:09:37 +00:00
|
|
|
if (LV->removeVirtualRegisterKilled(regB, mi))
|
2008-07-02 21:28:58 +00:00
|
|
|
LV->addVirtualRegisterKilled(regB, prevMi);
|
2004-07-22 15:26:23 +00:00
|
|
|
|
2008-07-03 09:09:37 +00:00
|
|
|
if (LV->removeVirtualRegisterDead(regB, mi))
|
2008-07-02 21:28:58 +00:00
|
|
|
LV->addVirtualRegisterDead(regB, prevMi);
|
|
|
|
}
|
2008-11-12 17:15:19 +00:00
|
|
|
|
|
|
|
DOUT << "\t\tprepend:\t"; DEBUG(prevMi->print(*cerr.stream(), &TM));
|
2008-07-02 21:28:58 +00:00
|
|
|
|
2008-05-10 00:12:52 +00:00
|
|
|
// Replace all occurences of regB with regA.
|
2006-11-01 23:06:55 +00:00
|
|
|
for (unsigned i = 0, e = mi->getNumOperands(); i != e; ++i) {
|
2008-10-03 15:45:36 +00:00
|
|
|
if (mi->getOperand(i).isReg() &&
|
2006-11-01 23:06:55 +00:00
|
|
|
mi->getOperand(i).getReg() == regB)
|
|
|
|
mi->getOperand(i).setReg(regA);
|
|
|
|
}
|
2004-07-22 15:26:23 +00:00
|
|
|
}
|
|
|
|
|
2006-11-01 23:06:55 +00:00
|
|
|
assert(mi->getOperand(ti).isDef() && mi->getOperand(si).isUse());
|
|
|
|
mi->getOperand(ti).setReg(mi->getOperand(si).getReg());
|
|
|
|
MadeChange = true;
|
2004-07-22 15:26:23 +00:00
|
|
|
|
2006-12-07 20:28:15 +00:00
|
|
|
DOUT << "\t\trewrite to:\t"; DEBUG(mi->print(*cerr.stream(), &TM));
|
2006-11-01 23:06:55 +00:00
|
|
|
}
|
2008-05-10 00:12:52 +00:00
|
|
|
|
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
|
|
|
|
2008-06-25 01:16:38 +00:00
|
|
|
// Some remat'ed instructions are dead.
|
|
|
|
int VReg = ReMatRegs.find_first();
|
|
|
|
while (VReg != -1) {
|
|
|
|
if (MRI->use_empty(VReg)) {
|
|
|
|
MachineInstr *DefMI = MRI->getVRegDef(VReg);
|
|
|
|
DefMI->eraseFromParent();
|
2008-05-26 05:49:49 +00:00
|
|
|
}
|
2008-06-25 01:16:38 +00:00
|
|
|
VReg = ReMatRegs.find_next(VReg);
|
A problem that's exposed when machine LICM is enabled. Consider this code:
LBB1_3: # bb
...
xorl %ebp, %ebp
subl (%ebx), %ebp
...
incl %ecx
cmpl %edi, %ecx
jl LBB1_3 # bb
Whe using machine LICM, LLVM converts it into:
xorl %esi, %esi
LBB1_3: # bb
...
movl %esi, %ebp
subl (%ebx), %ebp
...
incl %ecx
cmpl %edi, %ecx
jl LBB1_3 # bb
Two address conversion inserts the copy instruction. However, it's cheaper to
rematerialize it, and remat helps reduce register pressure.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51562 91177308-0d34-0410-b5e6-96231b3b80d8
2008-05-26 05:18:34 +00:00
|
|
|
}
|
|
|
|
|
2004-07-22 15:26:23 +00:00
|
|
|
return MadeChange;
|
2003-12-18 13:06:04 +00:00
|
|
|
}
|