2004-02-24 00:08:11 +01:00
|
|
|
//===-- llvm/CodeGen/VirtRegMap.cpp - Virtual Register Map ----------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2004-09-30 03:54:45 +02:00
|
|
|
// This file implements the VirtRegMap class.
|
|
|
|
//
|
|
|
|
// It also contains implementations of the the Spiller interface, which, given a
|
|
|
|
// virtual register map and a machine function, eliminates all virtual
|
|
|
|
// references by replacing them with physical register references - adding spill
|
2004-02-24 09:58:30 +01:00
|
|
|
// code as necessary.
|
2004-02-24 00:08:11 +01:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2004-09-30 03:54:45 +02:00
|
|
|
#define DEBUG_TYPE "spiller"
|
2004-02-24 00:08:11 +01:00
|
|
|
#include "VirtRegMap.h"
|
2004-02-24 09:58:30 +01:00
|
|
|
#include "llvm/Function.h"
|
2004-02-24 00:08:11 +01:00
|
|
|
#include "llvm/CodeGen/MachineFrameInfo.h"
|
2004-09-30 03:54:45 +02:00
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
|
|
#include "llvm/CodeGen/SSARegMap.h"
|
2004-02-24 00:08:11 +01:00
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2004-02-24 09:58:30 +01:00
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
2004-09-02 00:55:40 +02:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
|
|
|
#include "llvm/Support/Debug.h"
|
|
|
|
#include "llvm/ADT/Statistic.h"
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2004-10-26 17:35:58 +02:00
|
|
|
#include <algorithm>
|
2006-01-23 00:41:00 +01:00
|
|
|
#include <iostream>
|
2004-02-24 00:08:11 +01:00
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
namespace {
|
2004-09-30 03:54:45 +02:00
|
|
|
Statistic<> NumSpills("spiller", "Number of register spills");
|
|
|
|
Statistic<> NumStores("spiller", "Number of stores added");
|
|
|
|
Statistic<> NumLoads ("spiller", "Number of loads added");
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
Statistic<> NumReused("spiller", "Number of values reused");
|
2004-10-01 21:47:12 +02:00
|
|
|
Statistic<> NumDSE ("spiller", "Number of dead stores elided");
|
2006-02-03 03:02:59 +01:00
|
|
|
Statistic<> NumDCE ("spiller", "Number of copies elided");
|
2004-09-30 03:54:45 +02:00
|
|
|
|
|
|
|
enum SpillerName { simple, local };
|
|
|
|
|
|
|
|
cl::opt<SpillerName>
|
|
|
|
SpillerOpt("spiller",
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
cl::desc("Spiller to use: (default: local)"),
|
2004-09-30 03:54:45 +02:00
|
|
|
cl::Prefix,
|
|
|
|
cl::values(clEnumVal(simple, " simple spiller"),
|
|
|
|
clEnumVal(local, " local spiller"),
|
|
|
|
clEnumValEnd),
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
cl::init(local));
|
2004-09-30 03:54:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// VirtRegMap implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
void VirtRegMap::grow() {
|
2004-09-30 04:15:18 +02:00
|
|
|
Virt2PhysMap.grow(MF.getSSARegMap()->getLastVirtReg());
|
|
|
|
Virt2StackSlotMap.grow(MF.getSSARegMap()->getLastVirtReg());
|
2004-02-24 00:08:11 +01:00
|
|
|
}
|
|
|
|
|
2004-09-30 03:54:45 +02:00
|
|
|
int VirtRegMap::assignVirt2StackSlot(unsigned virtReg) {
|
|
|
|
assert(MRegisterInfo::isVirtualRegister(virtReg));
|
2004-09-30 04:15:18 +02:00
|
|
|
assert(Virt2StackSlotMap[virtReg] == NO_STACK_SLOT &&
|
2004-09-30 03:54:45 +02:00
|
|
|
"attempt to assign stack slot to already spilled register");
|
2004-09-30 04:15:18 +02:00
|
|
|
const TargetRegisterClass* RC = MF.getSSARegMap()->getRegClass(virtReg);
|
|
|
|
int frameIndex = MF.getFrameInfo()->CreateStackObject(RC->getSize(),
|
|
|
|
RC->getAlignment());
|
|
|
|
Virt2StackSlotMap[virtReg] = frameIndex;
|
2004-09-30 03:54:45 +02:00
|
|
|
++NumSpills;
|
|
|
|
return frameIndex;
|
2004-02-24 00:08:11 +01:00
|
|
|
}
|
|
|
|
|
2004-09-30 03:54:45 +02:00
|
|
|
void VirtRegMap::assignVirt2StackSlot(unsigned virtReg, int frameIndex) {
|
|
|
|
assert(MRegisterInfo::isVirtualRegister(virtReg));
|
2004-09-30 04:15:18 +02:00
|
|
|
assert(Virt2StackSlotMap[virtReg] == NO_STACK_SLOT &&
|
2004-09-30 03:54:45 +02:00
|
|
|
"attempt to assign stack slot to already spilled register");
|
2004-09-30 04:15:18 +02:00
|
|
|
Virt2StackSlotMap[virtReg] = frameIndex;
|
2004-05-29 22:38:05 +02:00
|
|
|
}
|
|
|
|
|
2004-10-02 01:15:36 +02:00
|
|
|
void VirtRegMap::virtFolded(unsigned VirtReg, MachineInstr *OldMI,
|
|
|
|
unsigned OpNo, MachineInstr *NewMI) {
|
|
|
|
// Move previous memory references folded to new instruction.
|
|
|
|
MI2VirtMapTy::iterator IP = MI2VirtMap.lower_bound(NewMI);
|
2005-04-22 00:36:52 +02:00
|
|
|
for (MI2VirtMapTy::iterator I = MI2VirtMap.lower_bound(OldMI),
|
2004-10-02 01:15:36 +02:00
|
|
|
E = MI2VirtMap.end(); I != E && I->first == OldMI; ) {
|
|
|
|
MI2VirtMap.insert(IP, std::make_pair(NewMI, I->second));
|
2004-09-30 18:35:08 +02:00
|
|
|
MI2VirtMap.erase(I++);
|
2004-09-30 03:54:45 +02:00
|
|
|
}
|
2004-09-30 18:35:08 +02:00
|
|
|
|
2004-10-02 01:15:36 +02:00
|
|
|
ModRef MRInfo;
|
|
|
|
if (!OldMI->getOperand(OpNo).isDef()) {
|
|
|
|
assert(OldMI->getOperand(OpNo).isUse() && "Operand is not use or def?");
|
|
|
|
MRInfo = isRef;
|
|
|
|
} else {
|
|
|
|
MRInfo = OldMI->getOperand(OpNo).isUse() ? isModRef : isMod;
|
|
|
|
}
|
2004-09-30 03:54:45 +02:00
|
|
|
|
|
|
|
// add new memory reference
|
2004-10-02 01:15:36 +02:00
|
|
|
MI2VirtMap.insert(IP, std::make_pair(NewMI, std::make_pair(VirtReg, MRInfo)));
|
2004-09-30 03:54:45 +02:00
|
|
|
}
|
2004-03-01 21:05:10 +01:00
|
|
|
|
2004-09-30 04:15:18 +02:00
|
|
|
void VirtRegMap::print(std::ostream &OS) const {
|
|
|
|
const MRegisterInfo* MRI = MF.getTarget().getRegisterInfo();
|
2004-09-30 03:54:45 +02:00
|
|
|
|
2004-09-30 04:15:18 +02:00
|
|
|
OS << "********** REGISTER MAP **********\n";
|
2004-09-30 03:54:45 +02:00
|
|
|
for (unsigned i = MRegisterInfo::FirstVirtualRegister,
|
2004-09-30 04:15:18 +02:00
|
|
|
e = MF.getSSARegMap()->getLastVirtReg(); i <= e; ++i) {
|
|
|
|
if (Virt2PhysMap[i] != (unsigned)VirtRegMap::NO_PHYS_REG)
|
|
|
|
OS << "[reg" << i << " -> " << MRI->getName(Virt2PhysMap[i]) << "]\n";
|
2005-04-22 00:36:52 +02:00
|
|
|
|
2004-09-30 03:54:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
for (unsigned i = MRegisterInfo::FirstVirtualRegister,
|
2004-09-30 04:15:18 +02:00
|
|
|
e = MF.getSSARegMap()->getLastVirtReg(); i <= e; ++i)
|
|
|
|
if (Virt2StackSlotMap[i] != VirtRegMap::NO_STACK_SLOT)
|
|
|
|
OS << "[reg" << i << " -> fi#" << Virt2StackSlotMap[i] << "]\n";
|
|
|
|
OS << '\n';
|
2004-03-01 21:05:10 +01:00
|
|
|
}
|
|
|
|
|
2004-09-30 03:54:45 +02:00
|
|
|
void VirtRegMap::dump() const { print(std::cerr); }
|
2004-02-24 00:08:11 +01:00
|
|
|
|
2004-02-24 09:58:30 +01:00
|
|
|
|
2004-09-30 03:54:45 +02:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Simple Spiller Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
2004-03-02 00:18:15 +01:00
|
|
|
|
2004-09-30 03:54:45 +02:00
|
|
|
Spiller::~Spiller() {}
|
2004-03-02 00:18:15 +01:00
|
|
|
|
2004-02-24 09:58:30 +01:00
|
|
|
namespace {
|
2004-09-30 03:54:45 +02:00
|
|
|
struct SimpleSpiller : public Spiller {
|
|
|
|
bool runOnMachineFunction(MachineFunction& mf, const VirtRegMap &VRM);
|
|
|
|
};
|
|
|
|
}
|
2004-02-24 09:58:30 +01:00
|
|
|
|
2005-01-23 23:45:13 +01:00
|
|
|
bool SimpleSpiller::runOnMachineFunction(MachineFunction &MF,
|
|
|
|
const VirtRegMap &VRM) {
|
2004-09-30 03:54:45 +02:00
|
|
|
DEBUG(std::cerr << "********** REWRITE MACHINE CODE **********\n");
|
|
|
|
DEBUG(std::cerr << "********** Function: "
|
|
|
|
<< MF.getFunction()->getName() << '\n');
|
2005-01-23 23:45:13 +01:00
|
|
|
const TargetMachine &TM = MF.getTarget();
|
|
|
|
const MRegisterInfo &MRI = *TM.getRegisterInfo();
|
|
|
|
bool *PhysRegsUsed = MF.getUsedPhysregs();
|
2004-09-30 03:54:45 +02:00
|
|
|
|
2004-09-30 04:33:48 +02:00
|
|
|
// LoadedRegs - Keep track of which vregs are loaded, so that we only load
|
|
|
|
// each vreg once (in the case where a spilled vreg is used by multiple
|
|
|
|
// operands). This is always smaller than the number of operands to the
|
|
|
|
// current machine instr, so it should be small.
|
|
|
|
std::vector<unsigned> LoadedRegs;
|
2004-09-30 03:54:45 +02:00
|
|
|
|
2004-09-30 04:59:33 +02:00
|
|
|
for (MachineFunction::iterator MBBI = MF.begin(), E = MF.end();
|
|
|
|
MBBI != E; ++MBBI) {
|
|
|
|
DEBUG(std::cerr << MBBI->getBasicBlock()->getName() << ":\n");
|
|
|
|
MachineBasicBlock &MBB = *MBBI;
|
|
|
|
for (MachineBasicBlock::iterator MII = MBB.begin(),
|
|
|
|
E = MBB.end(); MII != E; ++MII) {
|
|
|
|
MachineInstr &MI = *MII;
|
|
|
|
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
MachineOperand &MO = MI.getOperand(i);
|
2005-04-04 23:35:34 +02:00
|
|
|
if (MO.isRegister() && MO.getReg())
|
|
|
|
if (MRegisterInfo::isVirtualRegister(MO.getReg())) {
|
|
|
|
unsigned VirtReg = MO.getReg();
|
|
|
|
unsigned PhysReg = VRM.getPhys(VirtReg);
|
|
|
|
if (VRM.hasStackSlot(VirtReg)) {
|
|
|
|
int StackSlot = VRM.getStackSlot(VirtReg);
|
2005-09-30 03:29:00 +02:00
|
|
|
const TargetRegisterClass* RC =
|
|
|
|
MF.getSSARegMap()->getRegClass(VirtReg);
|
2005-04-22 00:36:52 +02:00
|
|
|
|
2005-04-04 23:35:34 +02:00
|
|
|
if (MO.isUse() &&
|
|
|
|
std::find(LoadedRegs.begin(), LoadedRegs.end(), VirtReg)
|
|
|
|
== LoadedRegs.end()) {
|
2005-09-30 03:29:00 +02:00
|
|
|
MRI.loadRegFromStackSlot(MBB, &MI, PhysReg, StackSlot, RC);
|
2005-04-04 23:35:34 +02:00
|
|
|
LoadedRegs.push_back(VirtReg);
|
|
|
|
++NumLoads;
|
|
|
|
DEBUG(std::cerr << '\t' << *prior(MII));
|
|
|
|
}
|
2005-04-22 00:36:52 +02:00
|
|
|
|
2005-04-04 23:35:34 +02:00
|
|
|
if (MO.isDef()) {
|
2005-09-30 03:29:00 +02:00
|
|
|
MRI.storeRegToStackSlot(MBB, next(MII), PhysReg, StackSlot, RC);
|
2005-04-04 23:35:34 +02:00
|
|
|
++NumStores;
|
|
|
|
}
|
2004-09-30 04:59:33 +02:00
|
|
|
}
|
2005-04-04 23:35:34 +02:00
|
|
|
PhysRegsUsed[PhysReg] = true;
|
|
|
|
MI.SetMachineOperandReg(i, PhysReg);
|
|
|
|
} else {
|
|
|
|
PhysRegsUsed[MO.getReg()] = true;
|
2004-09-30 03:54:45 +02:00
|
|
|
}
|
|
|
|
}
|
2005-04-04 23:35:34 +02:00
|
|
|
|
2004-09-30 18:10:45 +02:00
|
|
|
DEBUG(std::cerr << '\t' << MI);
|
2004-09-30 04:33:48 +02:00
|
|
|
LoadedRegs.clear();
|
2004-09-30 03:54:45 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2004-02-24 09:58:30 +01:00
|
|
|
|
2004-09-30 03:54:45 +02:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Local Spiller Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
2004-02-24 09:58:30 +01:00
|
|
|
|
2004-09-30 03:54:45 +02:00
|
|
|
namespace {
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
/// LocalSpiller - This spiller does a simple pass over the machine basic
|
|
|
|
/// block to attempt to keep spills in registers as much as possible for
|
|
|
|
/// blocks that have low register pressure (the vreg may be spilled due to
|
|
|
|
/// register pressure in other blocks).
|
2004-09-30 03:54:45 +02:00
|
|
|
class LocalSpiller : public Spiller {
|
|
|
|
const MRegisterInfo *MRI;
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
const TargetInstrInfo *TII;
|
2004-09-30 03:54:45 +02:00
|
|
|
public:
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
bool runOnMachineFunction(MachineFunction &MF, const VirtRegMap &VRM) {
|
|
|
|
MRI = MF.getTarget().getRegisterInfo();
|
|
|
|
TII = MF.getTarget().getInstrInfo();
|
|
|
|
DEBUG(std::cerr << "\n**** Local spiller rewriting function '"
|
|
|
|
<< MF.getFunction()->getName() << "':\n");
|
|
|
|
|
|
|
|
for (MachineFunction::iterator MBB = MF.begin(), E = MF.end();
|
|
|
|
MBB != E; ++MBB)
|
|
|
|
RewriteMBB(*MBB, VRM);
|
|
|
|
return true;
|
2004-09-30 03:54:45 +02:00
|
|
|
}
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
private:
|
|
|
|
void RewriteMBB(MachineBasicBlock &MBB, const VirtRegMap &VRM);
|
|
|
|
void ClobberPhysReg(unsigned PR, std::map<int, unsigned> &SpillSlots,
|
Physregs may hold multiple stack slot values at the same time. Keep track
of this, and use it to our advantage (bwahahah). This allows us to eliminate another
60 instructions from smg2000 on PPC (probably significantly more on X86). A common
old-new diff looks like this:
stw r2, 3304(r1)
- lwz r2, 3192(r1)
stw r2, 3300(r1)
- lwz r2, 3192(r1)
stw r2, 3296(r1)
- lwz r2, 3192(r1)
stw r2, 3200(r1)
- lwz r2, 3192(r1)
stw r2, 3196(r1)
- lwz r2, 3192(r1)
+ or r2, r2, r2
stw r2, 3188(r1)
and
- lwz r31, 604(r1)
- lwz r13, 604(r1)
- lwz r14, 604(r1)
- lwz r15, 604(r1)
- lwz r16, 604(r1)
- lwz r30, 604(r1)
+ or r31, r30, r30
+ or r13, r30, r30
+ or r14, r30, r30
+ or r15, r30, r30
+ or r16, r30, r30
+ or r30, r30, r30
Removal of the R = R copies is coming next...
llvm-svn: 25919
2006-02-03 01:36:31 +01:00
|
|
|
std::multimap<unsigned, int> &PhysRegs);
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
void ClobberPhysRegOnly(unsigned PR, std::map<int, unsigned> &SpillSlots,
|
Physregs may hold multiple stack slot values at the same time. Keep track
of this, and use it to our advantage (bwahahah). This allows us to eliminate another
60 instructions from smg2000 on PPC (probably significantly more on X86). A common
old-new diff looks like this:
stw r2, 3304(r1)
- lwz r2, 3192(r1)
stw r2, 3300(r1)
- lwz r2, 3192(r1)
stw r2, 3296(r1)
- lwz r2, 3192(r1)
stw r2, 3200(r1)
- lwz r2, 3192(r1)
stw r2, 3196(r1)
- lwz r2, 3192(r1)
+ or r2, r2, r2
stw r2, 3188(r1)
and
- lwz r31, 604(r1)
- lwz r13, 604(r1)
- lwz r14, 604(r1)
- lwz r15, 604(r1)
- lwz r16, 604(r1)
- lwz r30, 604(r1)
+ or r31, r30, r30
+ or r13, r30, r30
+ or r14, r30, r30
+ or r15, r30, r30
+ or r16, r30, r30
+ or r30, r30, r30
Removal of the R = R copies is coming next...
llvm-svn: 25919
2006-02-03 01:36:31 +01:00
|
|
|
std::multimap<unsigned, int> &PhysRegs);
|
|
|
|
void ModifyStackSlot(int Slot, std::map<int, unsigned> &SpillSlots,
|
|
|
|
std::multimap<unsigned, int> &PhysRegs);
|
2004-09-30 03:54:45 +02:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2006-02-04 00:13:58 +01:00
|
|
|
/// AvailableSpills - As the local spiller is scanning and rewriting an MBB from
|
|
|
|
/// top down, keep track of which spills slots are available in each register.
|
2006-02-04 00:28:46 +01:00
|
|
|
///
|
|
|
|
/// Note that not all physregs are created equal here. In particular, some
|
|
|
|
/// physregs are reloads that we are allowed to clobber or ignore at any time.
|
|
|
|
/// Other physregs are values that the register allocated program is using that
|
|
|
|
/// we cannot CHANGE, but we can read if we like. We keep track of this on a
|
|
|
|
/// per-stack-slot basis as the low bit in the value of the SpillSlotsAvailable
|
|
|
|
/// entries. The predicate 'canClobberPhysReg()' checks this bit and
|
|
|
|
/// addAvailable sets it if.
|
2006-02-04 00:13:58 +01:00
|
|
|
class AvailableSpills {
|
|
|
|
const MRegisterInfo *MRI;
|
|
|
|
const TargetInstrInfo *TII;
|
|
|
|
|
|
|
|
// SpillSlotsAvailable - This map keeps track of all of the spilled virtual
|
|
|
|
// register values that are still available, due to being loaded or stored to,
|
|
|
|
// but not invalidated yet.
|
|
|
|
std::map<int, unsigned> SpillSlotsAvailable;
|
|
|
|
|
|
|
|
// PhysRegsAvailable - This is the inverse of SpillSlotsAvailable, indicating
|
|
|
|
// which stack slot values are currently held by a physreg. This is used to
|
|
|
|
// invalidate entries in SpillSlotsAvailable when a physreg is modified.
|
|
|
|
std::multimap<unsigned, int> PhysRegsAvailable;
|
|
|
|
|
|
|
|
void ClobberPhysRegOnly(unsigned PhysReg);
|
|
|
|
public:
|
|
|
|
AvailableSpills(const MRegisterInfo *mri, const TargetInstrInfo *tii)
|
|
|
|
: MRI(mri), TII(tii) {
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getSpillSlotPhysReg - If the specified stack slot is available in a
|
|
|
|
/// physical register, return that PhysReg, otherwise return 0.
|
|
|
|
unsigned getSpillSlotPhysReg(int Slot) const {
|
|
|
|
std::map<int, unsigned>::const_iterator I = SpillSlotsAvailable.find(Slot);
|
|
|
|
if (I != SpillSlotsAvailable.end())
|
2006-02-04 00:28:46 +01:00
|
|
|
return I->second >> 1; // Remove the CanClobber bit.
|
2006-02-04 00:13:58 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// addAvailable - Mark that the specified stack slot is available in the
|
2006-02-04 00:28:46 +01:00
|
|
|
/// specified physreg. If CanClobber is true, the physreg can be modified at
|
|
|
|
/// any time without changing the semantics of the program.
|
|
|
|
void addAvailable(int Slot, unsigned Reg, bool CanClobber = true) {
|
2006-02-04 00:50:46 +01:00
|
|
|
// If this stack slot is thought to be available in some other physreg,
|
|
|
|
// remove its record.
|
|
|
|
ModifyStackSlot(Slot);
|
|
|
|
|
2006-02-04 00:13:58 +01:00
|
|
|
PhysRegsAvailable.insert(std::make_pair(Reg, Slot));
|
2006-02-04 04:27:39 +01:00
|
|
|
SpillSlotsAvailable[Slot] = (Reg << 1) | (unsigned)CanClobber;
|
2006-02-04 00:13:58 +01:00
|
|
|
|
|
|
|
DEBUG(std::cerr << "Remembering SS#" << Slot << " in physreg "
|
|
|
|
<< MRI->getName(Reg) << "\n");
|
|
|
|
}
|
|
|
|
|
2006-02-04 00:28:46 +01:00
|
|
|
/// canClobberPhysReg - Return true if the spiller is allowed to change the
|
|
|
|
/// value of the specified stackslot register if it desires. The specified
|
|
|
|
/// stack slot must be available in a physreg for this query to make sense.
|
|
|
|
bool canClobberPhysReg(int Slot) const {
|
|
|
|
assert(SpillSlotsAvailable.count(Slot) && "Slot not available!");
|
|
|
|
return SpillSlotsAvailable.find(Slot)->second & 1;
|
|
|
|
}
|
2006-02-04 00:13:58 +01:00
|
|
|
|
|
|
|
/// ClobberPhysReg - This is called when the specified physreg changes
|
|
|
|
/// value. We use this to invalidate any info about stuff we thing lives in
|
|
|
|
/// it and any of its aliases.
|
|
|
|
void ClobberPhysReg(unsigned PhysReg);
|
|
|
|
|
|
|
|
/// ModifyStackSlot - This method is called when the value in a stack slot
|
|
|
|
/// changes. This removes information about which register the previous value
|
|
|
|
/// for this slot lives in (as the previous value is dead now).
|
|
|
|
void ModifyStackSlot(int Slot);
|
|
|
|
};
|
|
|
|
|
|
|
|
/// ClobberPhysRegOnly - This is called when the specified physreg changes
|
|
|
|
/// value. We use this to invalidate any info about stuff we thing lives in it.
|
|
|
|
void AvailableSpills::ClobberPhysRegOnly(unsigned PhysReg) {
|
|
|
|
std::multimap<unsigned, int>::iterator I =
|
|
|
|
PhysRegsAvailable.lower_bound(PhysReg);
|
Physregs may hold multiple stack slot values at the same time. Keep track
of this, and use it to our advantage (bwahahah). This allows us to eliminate another
60 instructions from smg2000 on PPC (probably significantly more on X86). A common
old-new diff looks like this:
stw r2, 3304(r1)
- lwz r2, 3192(r1)
stw r2, 3300(r1)
- lwz r2, 3192(r1)
stw r2, 3296(r1)
- lwz r2, 3192(r1)
stw r2, 3200(r1)
- lwz r2, 3192(r1)
stw r2, 3196(r1)
- lwz r2, 3192(r1)
+ or r2, r2, r2
stw r2, 3188(r1)
and
- lwz r31, 604(r1)
- lwz r13, 604(r1)
- lwz r14, 604(r1)
- lwz r15, 604(r1)
- lwz r16, 604(r1)
- lwz r30, 604(r1)
+ or r31, r30, r30
+ or r13, r30, r30
+ or r14, r30, r30
+ or r15, r30, r30
+ or r16, r30, r30
+ or r30, r30, r30
Removal of the R = R copies is coming next...
llvm-svn: 25919
2006-02-03 01:36:31 +01:00
|
|
|
while (I != PhysRegsAvailable.end() && I->first == PhysReg) {
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
int Slot = I->second;
|
Physregs may hold multiple stack slot values at the same time. Keep track
of this, and use it to our advantage (bwahahah). This allows us to eliminate another
60 instructions from smg2000 on PPC (probably significantly more on X86). A common
old-new diff looks like this:
stw r2, 3304(r1)
- lwz r2, 3192(r1)
stw r2, 3300(r1)
- lwz r2, 3192(r1)
stw r2, 3296(r1)
- lwz r2, 3192(r1)
stw r2, 3200(r1)
- lwz r2, 3192(r1)
stw r2, 3196(r1)
- lwz r2, 3192(r1)
+ or r2, r2, r2
stw r2, 3188(r1)
and
- lwz r31, 604(r1)
- lwz r13, 604(r1)
- lwz r14, 604(r1)
- lwz r15, 604(r1)
- lwz r16, 604(r1)
- lwz r30, 604(r1)
+ or r31, r30, r30
+ or r13, r30, r30
+ or r14, r30, r30
+ or r15, r30, r30
+ or r16, r30, r30
+ or r30, r30, r30
Removal of the R = R copies is coming next...
llvm-svn: 25919
2006-02-03 01:36:31 +01:00
|
|
|
PhysRegsAvailable.erase(I++);
|
2006-02-04 00:28:46 +01:00
|
|
|
assert((SpillSlotsAvailable[Slot] >> 1) == PhysReg &&
|
2006-02-04 00:13:58 +01:00
|
|
|
"Bidirectional map mismatch!");
|
|
|
|
SpillSlotsAvailable.erase(Slot);
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
DEBUG(std::cerr << "PhysReg " << MRI->getName(PhysReg)
|
Physregs may hold multiple stack slot values at the same time. Keep track
of this, and use it to our advantage (bwahahah). This allows us to eliminate another
60 instructions from smg2000 on PPC (probably significantly more on X86). A common
old-new diff looks like this:
stw r2, 3304(r1)
- lwz r2, 3192(r1)
stw r2, 3300(r1)
- lwz r2, 3192(r1)
stw r2, 3296(r1)
- lwz r2, 3192(r1)
stw r2, 3200(r1)
- lwz r2, 3192(r1)
stw r2, 3196(r1)
- lwz r2, 3192(r1)
+ or r2, r2, r2
stw r2, 3188(r1)
and
- lwz r31, 604(r1)
- lwz r13, 604(r1)
- lwz r14, 604(r1)
- lwz r15, 604(r1)
- lwz r16, 604(r1)
- lwz r30, 604(r1)
+ or r31, r30, r30
+ or r13, r30, r30
+ or r14, r30, r30
+ or r15, r30, r30
+ or r16, r30, r30
+ or r30, r30, r30
Removal of the R = R copies is coming next...
llvm-svn: 25919
2006-02-03 01:36:31 +01:00
|
|
|
<< " clobbered, invalidating SS#" << Slot << "\n");
|
2004-09-30 03:54:45 +02:00
|
|
|
}
|
|
|
|
}
|
2004-02-24 09:58:30 +01:00
|
|
|
|
2006-02-04 00:13:58 +01:00
|
|
|
/// ClobberPhysReg - This is called when the specified physreg changes
|
|
|
|
/// value. We use this to invalidate any info about stuff we thing lives in
|
|
|
|
/// it and any of its aliases.
|
|
|
|
void AvailableSpills::ClobberPhysReg(unsigned PhysReg) {
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
for (const unsigned *AS = MRI->getAliasSet(PhysReg); *AS; ++AS)
|
2006-02-04 00:13:58 +01:00
|
|
|
ClobberPhysRegOnly(*AS);
|
|
|
|
ClobberPhysRegOnly(PhysReg);
|
Physregs may hold multiple stack slot values at the same time. Keep track
of this, and use it to our advantage (bwahahah). This allows us to eliminate another
60 instructions from smg2000 on PPC (probably significantly more on X86). A common
old-new diff looks like this:
stw r2, 3304(r1)
- lwz r2, 3192(r1)
stw r2, 3300(r1)
- lwz r2, 3192(r1)
stw r2, 3296(r1)
- lwz r2, 3192(r1)
stw r2, 3200(r1)
- lwz r2, 3192(r1)
stw r2, 3196(r1)
- lwz r2, 3192(r1)
+ or r2, r2, r2
stw r2, 3188(r1)
and
- lwz r31, 604(r1)
- lwz r13, 604(r1)
- lwz r14, 604(r1)
- lwz r15, 604(r1)
- lwz r16, 604(r1)
- lwz r30, 604(r1)
+ or r31, r30, r30
+ or r13, r30, r30
+ or r14, r30, r30
+ or r15, r30, r30
+ or r16, r30, r30
+ or r30, r30, r30
Removal of the R = R copies is coming next...
llvm-svn: 25919
2006-02-03 01:36:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// ModifyStackSlot - This method is called when the value in a stack slot
|
|
|
|
/// changes. This removes information about which register the previous value
|
|
|
|
/// for this slot lives in (as the previous value is dead now).
|
2006-02-04 00:13:58 +01:00
|
|
|
void AvailableSpills::ModifyStackSlot(int Slot) {
|
|
|
|
std::map<int, unsigned>::iterator It = SpillSlotsAvailable.find(Slot);
|
|
|
|
if (It == SpillSlotsAvailable.end()) return;
|
2006-02-04 00:28:46 +01:00
|
|
|
unsigned Reg = It->second >> 1;
|
2006-02-04 00:13:58 +01:00
|
|
|
SpillSlotsAvailable.erase(It);
|
Physregs may hold multiple stack slot values at the same time. Keep track
of this, and use it to our advantage (bwahahah). This allows us to eliminate another
60 instructions from smg2000 on PPC (probably significantly more on X86). A common
old-new diff looks like this:
stw r2, 3304(r1)
- lwz r2, 3192(r1)
stw r2, 3300(r1)
- lwz r2, 3192(r1)
stw r2, 3296(r1)
- lwz r2, 3192(r1)
stw r2, 3200(r1)
- lwz r2, 3192(r1)
stw r2, 3196(r1)
- lwz r2, 3192(r1)
+ or r2, r2, r2
stw r2, 3188(r1)
and
- lwz r31, 604(r1)
- lwz r13, 604(r1)
- lwz r14, 604(r1)
- lwz r15, 604(r1)
- lwz r16, 604(r1)
- lwz r30, 604(r1)
+ or r31, r30, r30
+ or r13, r30, r30
+ or r14, r30, r30
+ or r15, r30, r30
+ or r16, r30, r30
+ or r30, r30, r30
Removal of the R = R copies is coming next...
llvm-svn: 25919
2006-02-03 01:36:31 +01:00
|
|
|
|
|
|
|
// This register may hold the value of multiple stack slots, only remove this
|
|
|
|
// stack slot from the set of values the register contains.
|
|
|
|
std::multimap<unsigned, int>::iterator I = PhysRegsAvailable.lower_bound(Reg);
|
|
|
|
for (; ; ++I) {
|
|
|
|
assert(I != PhysRegsAvailable.end() && I->first == Reg &&
|
|
|
|
"Map inverse broken!");
|
|
|
|
if (I->second == Slot) break;
|
|
|
|
}
|
|
|
|
PhysRegsAvailable.erase(I);
|
2004-09-30 03:54:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
Physregs may hold multiple stack slot values at the same time. Keep track
of this, and use it to our advantage (bwahahah). This allows us to eliminate another
60 instructions from smg2000 on PPC (probably significantly more on X86). A common
old-new diff looks like this:
stw r2, 3304(r1)
- lwz r2, 3192(r1)
stw r2, 3300(r1)
- lwz r2, 3192(r1)
stw r2, 3296(r1)
- lwz r2, 3192(r1)
stw r2, 3200(r1)
- lwz r2, 3192(r1)
stw r2, 3196(r1)
- lwz r2, 3192(r1)
+ or r2, r2, r2
stw r2, 3188(r1)
and
- lwz r31, 604(r1)
- lwz r13, 604(r1)
- lwz r14, 604(r1)
- lwz r15, 604(r1)
- lwz r16, 604(r1)
- lwz r30, 604(r1)
+ or r31, r30, r30
+ or r13, r30, r30
+ or r14, r30, r30
+ or r15, r30, r30
+ or r16, r30, r30
+ or r30, r30, r30
Removal of the R = R copies is coming next...
llvm-svn: 25919
2006-02-03 01:36:31 +01:00
|
|
|
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
// ReusedOp - For each reused operand, we keep track of a bit of information, in
|
|
|
|
// case we need to rollback upon processing a new operand. See comments below.
|
|
|
|
namespace {
|
|
|
|
struct ReusedOp {
|
|
|
|
// The MachineInstr operand that reused an available value.
|
|
|
|
unsigned Operand;
|
2005-04-22 00:36:52 +02:00
|
|
|
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
// StackSlot - The spill slot of the value being reused.
|
|
|
|
unsigned StackSlot;
|
2005-04-22 00:36:52 +02:00
|
|
|
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
// PhysRegReused - The physical register the value was available in.
|
|
|
|
unsigned PhysRegReused;
|
2005-04-22 00:36:52 +02:00
|
|
|
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
// AssignedPhysReg - The physreg that was assigned for use by the reload.
|
|
|
|
unsigned AssignedPhysReg;
|
2005-10-06 19:19:06 +02:00
|
|
|
|
|
|
|
// VirtReg - The virtual register itself.
|
|
|
|
unsigned VirtReg;
|
|
|
|
|
|
|
|
ReusedOp(unsigned o, unsigned ss, unsigned prr, unsigned apr,
|
|
|
|
unsigned vreg)
|
|
|
|
: Operand(o), StackSlot(ss), PhysRegReused(prr), AssignedPhysReg(apr),
|
|
|
|
VirtReg(vreg) {}
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// rewriteMBB - Keep track of which spills are available even after the
|
|
|
|
/// register allocator is done with them. If possible, avoid reloading vregs.
|
|
|
|
void LocalSpiller::RewriteMBB(MachineBasicBlock &MBB, const VirtRegMap &VRM) {
|
|
|
|
|
|
|
|
DEBUG(std::cerr << MBB.getBasicBlock()->getName() << ":\n");
|
|
|
|
|
2006-02-04 00:13:58 +01:00
|
|
|
// Spills - Keep track of which spilled values are available in physregs so
|
|
|
|
// that we can choose to reuse the physregs instead of emitting reloads.
|
|
|
|
AvailableSpills Spills(MRI, TII);
|
|
|
|
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
std::vector<ReusedOp> ReusedOperands;
|
|
|
|
|
|
|
|
// DefAndUseVReg - When we see a def&use operand that is spilled, keep track
|
|
|
|
// of it. ".first" is the machine operand index (should always be 0 for now),
|
|
|
|
// and ".second" is the virtual register that is spilled.
|
|
|
|
std::vector<std::pair<unsigned, unsigned> > DefAndUseVReg;
|
|
|
|
|
2004-10-01 21:47:12 +02:00
|
|
|
// MaybeDeadStores - When we need to write a value back into a stack slot,
|
|
|
|
// keep track of the inserted store. If the stack slot value is never read
|
|
|
|
// (because the value was used from some available register, for example), and
|
|
|
|
// subsequently stored to, the original store is dead. This map keeps track
|
|
|
|
// of inserted stores that are not used. If we see a subsequent store to the
|
|
|
|
// same stack slot, the original store is deleted.
|
|
|
|
std::map<int, MachineInstr*> MaybeDeadStores;
|
|
|
|
|
2005-01-23 23:45:13 +01:00
|
|
|
bool *PhysRegsUsed = MBB.getParent()->getUsedPhysregs();
|
|
|
|
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
for (MachineBasicBlock::iterator MII = MBB.begin(), E = MBB.end();
|
|
|
|
MII != E; ) {
|
|
|
|
MachineInstr &MI = *MII;
|
|
|
|
MachineBasicBlock::iterator NextMII = MII; ++NextMII;
|
|
|
|
|
|
|
|
ReusedOperands.clear();
|
|
|
|
DefAndUseVReg.clear();
|
|
|
|
|
|
|
|
// Process all of the spilled uses and all non spilled reg references.
|
|
|
|
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = MI.getOperand(i);
|
2005-09-09 22:29:51 +02:00
|
|
|
if (!MO.isRegister() || MO.getReg() == 0)
|
|
|
|
continue; // Ignore non-register operands.
|
|
|
|
|
|
|
|
if (MRegisterInfo::isPhysicalRegister(MO.getReg())) {
|
|
|
|
// Ignore physregs for spilling, but remember that it is used by this
|
|
|
|
// function.
|
2005-04-04 23:35:34 +02:00
|
|
|
PhysRegsUsed[MO.getReg()] = true;
|
2005-09-09 22:29:51 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(MRegisterInfo::isVirtualRegister(MO.getReg()) &&
|
|
|
|
"Not a virtual or a physical register?");
|
|
|
|
|
|
|
|
unsigned VirtReg = MO.getReg();
|
|
|
|
if (!VRM.hasStackSlot(VirtReg)) {
|
|
|
|
// This virtual register was assigned a physreg!
|
|
|
|
unsigned Phys = VRM.getPhys(VirtReg);
|
|
|
|
PhysRegsUsed[Phys] = true;
|
|
|
|
MI.SetMachineOperandReg(i, Phys);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// This virtual register is now known to be a spilled value.
|
|
|
|
if (!MO.isUse())
|
|
|
|
continue; // Handle defs in the loop below (handle use&def here though)
|
|
|
|
|
|
|
|
// If this is both a def and a use, we need to emit a store to the
|
|
|
|
// stack slot after the instruction. Keep track of D&U operands
|
|
|
|
// because we are about to change it to a physreg here.
|
|
|
|
if (MO.isDef()) {
|
|
|
|
// Remember that this was a def-and-use operand, and that the
|
|
|
|
// stack slot is live after this instruction executes.
|
|
|
|
DefAndUseVReg.push_back(std::make_pair(i, VirtReg));
|
|
|
|
}
|
|
|
|
|
|
|
|
int StackSlot = VRM.getStackSlot(VirtReg);
|
|
|
|
unsigned PhysReg;
|
|
|
|
|
|
|
|
// Check to see if this stack slot is available.
|
2006-02-04 00:28:46 +01:00
|
|
|
if ((PhysReg = Spills.getSpillSlotPhysReg(StackSlot)) &&
|
|
|
|
// Don't reuse it for a def&use operand if we aren't allowed to change
|
|
|
|
// the physreg!
|
|
|
|
(!MO.isDef() || Spills.canClobberPhysReg(StackSlot))) {
|
2006-02-04 00:13:58 +01:00
|
|
|
// If this stack slot value is already available, reuse it!
|
2005-09-09 22:29:51 +02:00
|
|
|
DEBUG(std::cerr << "Reusing SS#" << StackSlot << " from physreg "
|
2006-02-04 00:13:58 +01:00
|
|
|
<< MRI->getName(PhysReg) << " for vreg"
|
2005-09-09 22:29:51 +02:00
|
|
|
<< VirtReg <<" instead of reloading into physreg "
|
|
|
|
<< MRI->getName(VRM.getPhys(VirtReg)) << "\n");
|
|
|
|
MI.SetMachineOperandReg(i, PhysReg);
|
|
|
|
|
|
|
|
// The only technical detail we have is that we don't know that
|
|
|
|
// PhysReg won't be clobbered by a reloaded stack slot that occurs
|
|
|
|
// later in the instruction. In particular, consider 'op V1, V2'.
|
|
|
|
// If V1 is available in physreg R0, we would choose to reuse it
|
|
|
|
// here, instead of reloading it into the register the allocator
|
|
|
|
// indicated (say R1). However, V2 might have to be reloaded
|
|
|
|
// later, and it might indicate that it needs to live in R0. When
|
|
|
|
// this occurs, we need to have information available that
|
|
|
|
// indicates it is safe to use R1 for the reload instead of R0.
|
|
|
|
//
|
|
|
|
// To further complicate matters, we might conflict with an alias,
|
|
|
|
// or R0 and R1 might not be compatible with each other. In this
|
|
|
|
// case, we actually insert a reload for V1 in R1, ensuring that
|
|
|
|
// we can get at R0 or its alias.
|
|
|
|
ReusedOperands.push_back(ReusedOp(i, StackSlot, PhysReg,
|
2005-10-06 19:19:06 +02:00
|
|
|
VRM.getPhys(VirtReg), VirtReg));
|
2005-09-09 22:29:51 +02:00
|
|
|
++NumReused;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, reload it and remember that we have it.
|
|
|
|
PhysReg = VRM.getPhys(VirtReg);
|
2006-01-04 07:47:48 +01:00
|
|
|
assert(PhysReg && "Must map virtreg to physreg!");
|
2005-09-30 03:29:00 +02:00
|
|
|
const TargetRegisterClass* RC =
|
|
|
|
MBB.getParent()->getSSARegMap()->getRegClass(VirtReg);
|
2005-09-09 22:29:51 +02:00
|
|
|
|
|
|
|
RecheckRegister:
|
|
|
|
// Note that, if we reused a register for a previous operand, the
|
|
|
|
// register we want to reload into might not actually be
|
|
|
|
// available. If this occurs, use the register indicated by the
|
|
|
|
// reuser.
|
|
|
|
if (!ReusedOperands.empty()) // This is most often empty.
|
|
|
|
for (unsigned ro = 0, e = ReusedOperands.size(); ro != e; ++ro)
|
|
|
|
if (ReusedOperands[ro].PhysRegReused == PhysReg) {
|
|
|
|
// Yup, use the reload register that we didn't use before.
|
|
|
|
PhysReg = ReusedOperands[ro].AssignedPhysReg;
|
|
|
|
goto RecheckRegister;
|
|
|
|
} else {
|
|
|
|
ReusedOp &Op = ReusedOperands[ro];
|
|
|
|
unsigned PRRU = Op.PhysRegReused;
|
|
|
|
if (MRI->areAliases(PRRU, PhysReg)) {
|
|
|
|
// Okay, we found out that an alias of a reused register
|
|
|
|
// was used. This isn't good because it means we have
|
|
|
|
// to undo a previous reuse.
|
2005-10-06 19:19:06 +02:00
|
|
|
const TargetRegisterClass *AliasRC =
|
|
|
|
MBB.getParent()->getSSARegMap()->getRegClass(Op.VirtReg);
|
2005-09-09 22:29:51 +02:00
|
|
|
MRI->loadRegFromStackSlot(MBB, &MI, Op.AssignedPhysReg,
|
2005-10-06 19:19:06 +02:00
|
|
|
Op.StackSlot, AliasRC);
|
2006-02-04 00:13:58 +01:00
|
|
|
Spills.ClobberPhysReg(Op.AssignedPhysReg);
|
|
|
|
Spills.ClobberPhysReg(Op.PhysRegReused);
|
|
|
|
|
2004-10-01 21:47:12 +02:00
|
|
|
// Any stores to this stack slot are not dead anymore.
|
2005-09-09 22:29:51 +02:00
|
|
|
MaybeDeadStores.erase(Op.StackSlot);
|
|
|
|
|
|
|
|
MI.SetMachineOperandReg(Op.Operand, Op.AssignedPhysReg);
|
2006-02-04 00:13:58 +01:00
|
|
|
|
|
|
|
Spills.addAvailable(Op.StackSlot, Op.AssignedPhysReg);
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
++NumLoads;
|
|
|
|
DEBUG(std::cerr << '\t' << *prior(MII));
|
|
|
|
|
2005-09-09 22:29:51 +02:00
|
|
|
DEBUG(std::cerr << "Reuse undone!\n");
|
|
|
|
ReusedOperands.erase(ReusedOperands.begin()+ro);
|
|
|
|
--NumReused;
|
|
|
|
goto ContinueReload;
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
}
|
|
|
|
}
|
2005-09-09 22:29:51 +02:00
|
|
|
ContinueReload:
|
|
|
|
PhysRegsUsed[PhysReg] = true;
|
2005-09-30 03:29:00 +02:00
|
|
|
MRI->loadRegFromStackSlot(MBB, &MI, PhysReg, StackSlot, RC);
|
2005-09-09 22:29:51 +02:00
|
|
|
// This invalidates PhysReg.
|
2006-02-04 00:13:58 +01:00
|
|
|
Spills.ClobberPhysReg(PhysReg);
|
2005-09-09 22:29:51 +02:00
|
|
|
|
|
|
|
// Any stores to this stack slot are not dead anymore.
|
|
|
|
MaybeDeadStores.erase(StackSlot);
|
2006-02-04 00:13:58 +01:00
|
|
|
Spills.addAvailable(StackSlot, PhysReg);
|
2005-09-09 22:29:51 +02:00
|
|
|
++NumLoads;
|
2006-02-04 00:13:58 +01:00
|
|
|
MI.SetMachineOperandReg(i, PhysReg);
|
2005-09-09 22:29:51 +02:00
|
|
|
DEBUG(std::cerr << '\t' << *prior(MII));
|
2004-09-30 03:54:45 +02:00
|
|
|
}
|
2004-02-24 09:58:30 +01:00
|
|
|
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
// Loop over all of the implicit defs, clearing them from our available
|
|
|
|
// sets.
|
2005-01-23 23:45:13 +01:00
|
|
|
for (const unsigned *ImpDef = TII->getImplicitDefs(MI.getOpcode());
|
|
|
|
*ImpDef; ++ImpDef) {
|
|
|
|
PhysRegsUsed[*ImpDef] = true;
|
2006-02-04 00:13:58 +01:00
|
|
|
Spills.ClobberPhysReg(*ImpDef);
|
2005-01-23 23:45:13 +01:00
|
|
|
}
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
|
|
|
|
DEBUG(std::cerr << '\t' << MI);
|
|
|
|
|
|
|
|
// If we have folded references to memory operands, make sure we clear all
|
|
|
|
// physical registers that may contain the value of the spilled virtual
|
|
|
|
// register
|
2005-01-14 16:54:24 +01:00
|
|
|
VirtRegMap::MI2VirtMapTy::const_iterator I, End;
|
|
|
|
for (tie(I, End) = VRM.getFoldedVirts(&MI); I != End; ++I) {
|
2004-10-02 01:15:36 +02:00
|
|
|
DEBUG(std::cerr << "Folded vreg: " << I->second.first << " MR: "
|
|
|
|
<< I->second.second);
|
|
|
|
unsigned VirtReg = I->second.first;
|
|
|
|
VirtRegMap::ModRef MR = I->second.second;
|
Teach the local spiller to turn stack slot loads into register-register copies
when possible, avoiding the load (and avoiding the copy if the value is already
in the right register).
This patch came about when I noticed code like the following being generated:
store R17 -> [SS1]
...blah...
R4 = load [SS1]
This was causing an LSU reject on the G5. This problem was due to the register
allocator folding spill code into a reg-reg copy (producing the load), which
prevented the spiller from being able to rewrite the load into a copy, despite
the fact that the value was already available in a register. In the case
above, we now rip out the R4 load and replace it with a R4 = R17 copy.
This speeds up several programs on X86 (which spills a lot :) ), e.g.
smg2k from 22.39->20.60s, povray from 12.93->12.66s, 168.wupwise from
68.54->53.83s (!), 197.parser from 7.33->6.62s (!), etc. This may have a larger
impact in some cases on the G5 (by avoiding LSU rejects), though it probably
won't trigger as often (less spilling in general).
Targets that implement folding of loads/stores into copies should implement
the isLoadFromStackSlot hook to get this.
llvm-svn: 23388
2005-09-19 08:56:21 +02:00
|
|
|
if (!VRM.hasStackSlot(VirtReg)) {
|
|
|
|
DEBUG(std::cerr << ": No stack slot!\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
int SS = VRM.getStackSlot(VirtReg);
|
|
|
|
DEBUG(std::cerr << " - StackSlot: " << SS << "\n");
|
|
|
|
|
|
|
|
// If this folded instruction is just a use, check to see if it's a
|
|
|
|
// straight load from the virt reg slot.
|
|
|
|
if ((MR & VirtRegMap::isRef) && !(MR & VirtRegMap::isMod)) {
|
|
|
|
int FrameIdx;
|
2006-02-02 21:12:32 +01:00
|
|
|
if (unsigned DestReg = TII->isLoadFromStackSlot(&MI, FrameIdx)) {
|
|
|
|
// If this spill slot is available, turn it into a copy (or nothing)
|
|
|
|
// instead of leaving it as a load!
|
2006-02-04 00:13:58 +01:00
|
|
|
unsigned InReg;
|
|
|
|
if (FrameIdx == SS && (InReg = Spills.getSpillSlotPhysReg(SS))) {
|
Teach the local spiller to turn stack slot loads into register-register copies
when possible, avoiding the load (and avoiding the copy if the value is already
in the right register).
This patch came about when I noticed code like the following being generated:
store R17 -> [SS1]
...blah...
R4 = load [SS1]
This was causing an LSU reject on the G5. This problem was due to the register
allocator folding spill code into a reg-reg copy (producing the load), which
prevented the spiller from being able to rewrite the load into a copy, despite
the fact that the value was already available in a register. In the case
above, we now rip out the R4 load and replace it with a R4 = R17 copy.
This speeds up several programs on X86 (which spills a lot :) ), e.g.
smg2k from 22.39->20.60s, povray from 12.93->12.66s, 168.wupwise from
68.54->53.83s (!), 197.parser from 7.33->6.62s (!), etc. This may have a larger
impact in some cases on the G5 (by avoiding LSU rejects), though it probably
won't trigger as often (less spilling in general).
Targets that implement folding of loads/stores into copies should implement
the isLoadFromStackSlot hook to get this.
llvm-svn: 23388
2005-09-19 08:56:21 +02:00
|
|
|
DEBUG(std::cerr << "Promoted Load To Copy: " << MI);
|
|
|
|
MachineFunction &MF = *MBB.getParent();
|
2006-02-04 00:13:58 +01:00
|
|
|
if (DestReg != InReg) {
|
|
|
|
MRI->copyRegToReg(MBB, &MI, DestReg, InReg,
|
Teach the local spiller to turn stack slot loads into register-register copies
when possible, avoiding the load (and avoiding the copy if the value is already
in the right register).
This patch came about when I noticed code like the following being generated:
store R17 -> [SS1]
...blah...
R4 = load [SS1]
This was causing an LSU reject on the G5. This problem was due to the register
allocator folding spill code into a reg-reg copy (producing the load), which
prevented the spiller from being able to rewrite the load into a copy, despite
the fact that the value was already available in a register. In the case
above, we now rip out the R4 load and replace it with a R4 = R17 copy.
This speeds up several programs on X86 (which spills a lot :) ), e.g.
smg2k from 22.39->20.60s, povray from 12.93->12.66s, 168.wupwise from
68.54->53.83s (!), 197.parser from 7.33->6.62s (!), etc. This may have a larger
impact in some cases on the G5 (by avoiding LSU rejects), though it probably
won't trigger as often (less spilling in general).
Targets that implement folding of loads/stores into copies should implement
the isLoadFromStackSlot hook to get this.
llvm-svn: 23388
2005-09-19 08:56:21 +02:00
|
|
|
MF.getSSARegMap()->getRegClass(VirtReg));
|
2005-10-05 20:30:19 +02:00
|
|
|
// Revisit the copy so we make sure to notice the effects of the
|
|
|
|
// operation on the destreg (either needing to RA it if it's
|
|
|
|
// virtual or needing to clobber any values if it's physical).
|
|
|
|
NextMII = &MI;
|
|
|
|
--NextMII; // backtrack to the copy.
|
Teach the local spiller to turn stack slot loads into register-register copies
when possible, avoiding the load (and avoiding the copy if the value is already
in the right register).
This patch came about when I noticed code like the following being generated:
store R17 -> [SS1]
...blah...
R4 = load [SS1]
This was causing an LSU reject on the G5. This problem was due to the register
allocator folding spill code into a reg-reg copy (producing the load), which
prevented the spiller from being able to rewrite the load into a copy, despite
the fact that the value was already available in a register. In the case
above, we now rip out the R4 load and replace it with a R4 = R17 copy.
This speeds up several programs on X86 (which spills a lot :) ), e.g.
smg2k from 22.39->20.60s, povray from 12.93->12.66s, 168.wupwise from
68.54->53.83s (!), 197.parser from 7.33->6.62s (!), etc. This may have a larger
impact in some cases on the G5 (by avoiding LSU rejects), though it probably
won't trigger as often (less spilling in general).
Targets that implement folding of loads/stores into copies should implement
the isLoadFromStackSlot hook to get this.
llvm-svn: 23388
2005-09-19 08:56:21 +02:00
|
|
|
}
|
|
|
|
MBB.erase(&MI);
|
|
|
|
goto ProcessNextInst;
|
2004-10-02 01:15:36 +02:00
|
|
|
}
|
|
|
|
}
|
Teach the local spiller to turn stack slot loads into register-register copies
when possible, avoiding the load (and avoiding the copy if the value is already
in the right register).
This patch came about when I noticed code like the following being generated:
store R17 -> [SS1]
...blah...
R4 = load [SS1]
This was causing an LSU reject on the G5. This problem was due to the register
allocator folding spill code into a reg-reg copy (producing the load), which
prevented the spiller from being able to rewrite the load into a copy, despite
the fact that the value was already available in a register. In the case
above, we now rip out the R4 load and replace it with a R4 = R17 copy.
This speeds up several programs on X86 (which spills a lot :) ), e.g.
smg2k from 22.39->20.60s, povray from 12.93->12.66s, 168.wupwise from
68.54->53.83s (!), 197.parser from 7.33->6.62s (!), etc. This may have a larger
impact in some cases on the G5 (by avoiding LSU rejects), though it probably
won't trigger as often (less spilling in general).
Targets that implement folding of loads/stores into copies should implement
the isLoadFromStackSlot hook to get this.
llvm-svn: 23388
2005-09-19 08:56:21 +02:00
|
|
|
}
|
2004-10-01 21:47:12 +02:00
|
|
|
|
Teach the local spiller to turn stack slot loads into register-register copies
when possible, avoiding the load (and avoiding the copy if the value is already
in the right register).
This patch came about when I noticed code like the following being generated:
store R17 -> [SS1]
...blah...
R4 = load [SS1]
This was causing an LSU reject on the G5. This problem was due to the register
allocator folding spill code into a reg-reg copy (producing the load), which
prevented the spiller from being able to rewrite the load into a copy, despite
the fact that the value was already available in a register. In the case
above, we now rip out the R4 load and replace it with a R4 = R17 copy.
This speeds up several programs on X86 (which spills a lot :) ), e.g.
smg2k from 22.39->20.60s, povray from 12.93->12.66s, 168.wupwise from
68.54->53.83s (!), 197.parser from 7.33->6.62s (!), etc. This may have a larger
impact in some cases on the G5 (by avoiding LSU rejects), though it probably
won't trigger as often (less spilling in general).
Targets that implement folding of loads/stores into copies should implement
the isLoadFromStackSlot hook to get this.
llvm-svn: 23388
2005-09-19 08:56:21 +02:00
|
|
|
// If this reference is not a use, any previous store is now dead.
|
|
|
|
// Otherwise, the store to this stack slot is not dead anymore.
|
|
|
|
std::map<int, MachineInstr*>::iterator MDSI = MaybeDeadStores.find(SS);
|
|
|
|
if (MDSI != MaybeDeadStores.end()) {
|
|
|
|
if (MR & VirtRegMap::isRef) // Previous store is not dead.
|
|
|
|
MaybeDeadStores.erase(MDSI);
|
|
|
|
else {
|
|
|
|
// If we get here, the store is dead, nuke it now.
|
|
|
|
assert(MR == VirtRegMap::isMod && "Can't be modref!");
|
|
|
|
MBB.erase(MDSI->second);
|
|
|
|
MaybeDeadStores.erase(MDSI);
|
|
|
|
++NumDSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the spill slot value is available, and this is a new definition of
|
|
|
|
// the value, the value is not available anymore.
|
|
|
|
if (MR & VirtRegMap::isMod) {
|
Physregs may hold multiple stack slot values at the same time. Keep track
of this, and use it to our advantage (bwahahah). This allows us to eliminate another
60 instructions from smg2000 on PPC (probably significantly more on X86). A common
old-new diff looks like this:
stw r2, 3304(r1)
- lwz r2, 3192(r1)
stw r2, 3300(r1)
- lwz r2, 3192(r1)
stw r2, 3296(r1)
- lwz r2, 3192(r1)
stw r2, 3200(r1)
- lwz r2, 3192(r1)
stw r2, 3196(r1)
- lwz r2, 3192(r1)
+ or r2, r2, r2
stw r2, 3188(r1)
and
- lwz r31, 604(r1)
- lwz r13, 604(r1)
- lwz r14, 604(r1)
- lwz r15, 604(r1)
- lwz r16, 604(r1)
- lwz r30, 604(r1)
+ or r31, r30, r30
+ or r13, r30, r30
+ or r14, r30, r30
+ or r15, r30, r30
+ or r16, r30, r30
+ or r30, r30, r30
Removal of the R = R copies is coming next...
llvm-svn: 25919
2006-02-03 01:36:31 +01:00
|
|
|
// Notice that the value in this stack slot has been modified.
|
2006-02-04 00:13:58 +01:00
|
|
|
Spills.ModifyStackSlot(SS);
|
Fix a deficiency in the spiller that Evan noticed. In particular, consider
this code:
store [stack slot #0], R10
= add R14, [stack slot #0]
The spiller didn't know that the store made the value of [stackslot#0] available
in R10 *IF* the store came from a copy instruction with the store folded into it.
This patch teaches VirtRegMap to look at these stores and recognize the values
they make available. In one case Evan provided, this code:
divsd %XMM0, %XMM1
movsd %XMM1, QWORD PTR [%ESP + 40]
1) movsd QWORD PTR [%ESP + 48], %XMM1
2) movsd %XMM1, QWORD PTR [%ESP + 48]
addsd %XMM1, %XMM0
3) movsd QWORD PTR [%ESP + 48], %XMM1
movsd QWORD PTR [%ESP + 4], %XMM0
turns into:
divsd %XMM0, %XMM1
movsd %XMM1, QWORD PTR [%ESP + 40]
addsd %XMM1, %XMM0
3) movsd QWORD PTR [%ESP + 48], %XMM1
movsd QWORD PTR [%ESP + 4], %XMM0
In this case, instruction #2 was removed because of the value made
available by #1, and inst #1 was later deleted because it is now
never used before the stack slot is redefined by #3.
This occurs here and there in a lot of code with high spilling, on PPC
most of the removed loads/stores are LSU-reject-causing loads, which is
nice.
On X86, things are much better (because it spills more), where we nuke
about 1% of the instructions from SMG2000 and several hundred from eon.
More improvements to come...
llvm-svn: 25917
2006-02-03 00:29:36 +01:00
|
|
|
|
|
|
|
// If this is *just* a mod of the value, check to see if this is just a
|
|
|
|
// store to the spill slot (i.e. the spill got merged into the copy). If
|
|
|
|
// so, realize that the vreg is available now, and add the store to the
|
|
|
|
// MaybeDeadStore info.
|
|
|
|
int StackSlot;
|
|
|
|
if (!(MR & VirtRegMap::isRef)) {
|
|
|
|
if (unsigned SrcReg = TII->isStoreToStackSlot(&MI, StackSlot)) {
|
|
|
|
assert(MRegisterInfo::isPhysicalRegister(SrcReg) &&
|
|
|
|
"Src hasn't been allocated yet?");
|
Physregs may hold multiple stack slot values at the same time. Keep track
of this, and use it to our advantage (bwahahah). This allows us to eliminate another
60 instructions from smg2000 on PPC (probably significantly more on X86). A common
old-new diff looks like this:
stw r2, 3304(r1)
- lwz r2, 3192(r1)
stw r2, 3300(r1)
- lwz r2, 3192(r1)
stw r2, 3296(r1)
- lwz r2, 3192(r1)
stw r2, 3200(r1)
- lwz r2, 3192(r1)
stw r2, 3196(r1)
- lwz r2, 3192(r1)
+ or r2, r2, r2
stw r2, 3188(r1)
and
- lwz r31, 604(r1)
- lwz r13, 604(r1)
- lwz r14, 604(r1)
- lwz r15, 604(r1)
- lwz r16, 604(r1)
- lwz r30, 604(r1)
+ or r31, r30, r30
+ or r13, r30, r30
+ or r14, r30, r30
+ or r15, r30, r30
+ or r16, r30, r30
+ or r30, r30, r30
Removal of the R = R copies is coming next...
llvm-svn: 25919
2006-02-03 01:36:31 +01:00
|
|
|
// Okay, this is certainly a store of SrcReg to [StackSlot]. Mark
|
Fix a deficiency in the spiller that Evan noticed. In particular, consider
this code:
store [stack slot #0], R10
= add R14, [stack slot #0]
The spiller didn't know that the store made the value of [stackslot#0] available
in R10 *IF* the store came from a copy instruction with the store folded into it.
This patch teaches VirtRegMap to look at these stores and recognize the values
they make available. In one case Evan provided, this code:
divsd %XMM0, %XMM1
movsd %XMM1, QWORD PTR [%ESP + 40]
1) movsd QWORD PTR [%ESP + 48], %XMM1
2) movsd %XMM1, QWORD PTR [%ESP + 48]
addsd %XMM1, %XMM0
3) movsd QWORD PTR [%ESP + 48], %XMM1
movsd QWORD PTR [%ESP + 4], %XMM0
turns into:
divsd %XMM0, %XMM1
movsd %XMM1, QWORD PTR [%ESP + 40]
addsd %XMM1, %XMM0
3) movsd QWORD PTR [%ESP + 48], %XMM1
movsd QWORD PTR [%ESP + 4], %XMM0
In this case, instruction #2 was removed because of the value made
available by #1, and inst #1 was later deleted because it is now
never used before the stack slot is redefined by #3.
This occurs here and there in a lot of code with high spilling, on PPC
most of the removed loads/stores are LSU-reject-causing loads, which is
nice.
On X86, things are much better (because it spills more), where we nuke
about 1% of the instructions from SMG2000 and several hundred from eon.
More improvements to come...
llvm-svn: 25917
2006-02-03 00:29:36 +01:00
|
|
|
// this as a potentially dead store in case there is a subsequent
|
|
|
|
// store into the stack slot without a read from it.
|
|
|
|
MaybeDeadStores[StackSlot] = &MI;
|
|
|
|
|
|
|
|
// If the stack slot value was previously available in some other
|
|
|
|
// register, change it now. Otherwise, make the register available,
|
|
|
|
// in PhysReg.
|
2006-02-04 00:28:46 +01:00
|
|
|
Spills.addAvailable(StackSlot, SrcReg, false /*don't clobber*/);
|
Fix a deficiency in the spiller that Evan noticed. In particular, consider
this code:
store [stack slot #0], R10
= add R14, [stack slot #0]
The spiller didn't know that the store made the value of [stackslot#0] available
in R10 *IF* the store came from a copy instruction with the store folded into it.
This patch teaches VirtRegMap to look at these stores and recognize the values
they make available. In one case Evan provided, this code:
divsd %XMM0, %XMM1
movsd %XMM1, QWORD PTR [%ESP + 40]
1) movsd QWORD PTR [%ESP + 48], %XMM1
2) movsd %XMM1, QWORD PTR [%ESP + 48]
addsd %XMM1, %XMM0
3) movsd QWORD PTR [%ESP + 48], %XMM1
movsd QWORD PTR [%ESP + 4], %XMM0
turns into:
divsd %XMM0, %XMM1
movsd %XMM1, QWORD PTR [%ESP + 40]
addsd %XMM1, %XMM0
3) movsd QWORD PTR [%ESP + 48], %XMM1
movsd QWORD PTR [%ESP + 4], %XMM0
In this case, instruction #2 was removed because of the value made
available by #1, and inst #1 was later deleted because it is now
never used before the stack slot is redefined by #3.
This occurs here and there in a lot of code with high spilling, on PPC
most of the removed loads/stores are LSU-reject-causing loads, which is
nice.
On X86, things are much better (because it spills more), where we nuke
about 1% of the instructions from SMG2000 and several hundred from eon.
More improvements to come...
llvm-svn: 25917
2006-02-03 00:29:36 +01:00
|
|
|
}
|
|
|
|
}
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
}
|
2004-09-30 03:54:45 +02:00
|
|
|
}
|
2004-02-24 09:58:30 +01:00
|
|
|
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
// Process all of the spilled defs.
|
|
|
|
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = MI.getOperand(i);
|
|
|
|
if (MO.isRegister() && MO.getReg() && MO.isDef()) {
|
|
|
|
unsigned VirtReg = MO.getReg();
|
|
|
|
|
|
|
|
if (!MRegisterInfo::isVirtualRegister(VirtReg)) {
|
|
|
|
// Check to see if this is a def-and-use vreg operand that we do need
|
|
|
|
// to insert a store for.
|
|
|
|
bool OpTakenCareOf = false;
|
|
|
|
if (MO.isUse() && !DefAndUseVReg.empty()) {
|
|
|
|
for (unsigned dau = 0, e = DefAndUseVReg.size(); dau != e; ++dau)
|
|
|
|
if (DefAndUseVReg[dau].first == i) {
|
|
|
|
VirtReg = DefAndUseVReg[dau].second;
|
|
|
|
OpTakenCareOf = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2005-04-22 00:36:52 +02:00
|
|
|
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
if (!OpTakenCareOf) {
|
2006-02-03 04:16:14 +01:00
|
|
|
// Check to see if this is a noop copy. If so, eliminate the
|
|
|
|
// instruction before considering the dest reg to be changed.
|
|
|
|
unsigned Src, Dst;
|
|
|
|
if (TII->isMoveInstr(MI, Src, Dst) && Src == Dst) {
|
|
|
|
++NumDCE;
|
|
|
|
DEBUG(std::cerr << "Removing now-noop copy: " << MI);
|
|
|
|
MBB.erase(&MI);
|
|
|
|
goto ProcessNextInst;
|
|
|
|
}
|
2006-02-04 00:13:58 +01:00
|
|
|
Spills.ClobberPhysReg(VirtReg);
|
2006-02-03 04:06:49 +01:00
|
|
|
continue;
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
}
|
2005-04-22 00:36:52 +02:00
|
|
|
}
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
|
2006-02-03 04:06:49 +01:00
|
|
|
// The only vregs left are stack slot definitions.
|
|
|
|
int StackSlot = VRM.getStackSlot(VirtReg);
|
|
|
|
const TargetRegisterClass *RC =
|
|
|
|
MBB.getParent()->getSSARegMap()->getRegClass(VirtReg);
|
|
|
|
unsigned PhysReg;
|
|
|
|
|
|
|
|
// If this is a def&use operand, and we used a different physreg for
|
|
|
|
// it than the one assigned, make sure to execute the store from the
|
|
|
|
// correct physical register.
|
|
|
|
if (MO.getReg() == VirtReg)
|
|
|
|
PhysReg = VRM.getPhys(VirtReg);
|
|
|
|
else
|
|
|
|
PhysReg = MO.getReg();
|
|
|
|
|
|
|
|
PhysRegsUsed[PhysReg] = true;
|
|
|
|
MRI->storeRegToStackSlot(MBB, next(MII), PhysReg, StackSlot, RC);
|
|
|
|
DEBUG(std::cerr << "Store:\t" << *next(MII));
|
|
|
|
MI.SetMachineOperandReg(i, PhysReg);
|
|
|
|
|
2006-02-03 04:16:14 +01:00
|
|
|
// Check to see if this is a noop copy. If so, eliminate the
|
|
|
|
// instruction before considering the dest reg to be changed.
|
|
|
|
{
|
|
|
|
unsigned Src, Dst;
|
|
|
|
if (TII->isMoveInstr(MI, Src, Dst) && Src == Dst) {
|
|
|
|
++NumDCE;
|
|
|
|
DEBUG(std::cerr << "Removing now-noop copy: " << MI);
|
|
|
|
MBB.erase(&MI);
|
|
|
|
goto ProcessNextInst;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-03 04:06:49 +01:00
|
|
|
// If there is a dead store to this stack slot, nuke it now.
|
|
|
|
MachineInstr *&LastStore = MaybeDeadStores[StackSlot];
|
|
|
|
if (LastStore) {
|
|
|
|
DEBUG(std::cerr << " Killed store:\t" << *LastStore);
|
|
|
|
++NumDSE;
|
|
|
|
MBB.erase(LastStore);
|
2004-02-24 09:58:30 +01:00
|
|
|
}
|
2006-02-03 04:06:49 +01:00
|
|
|
LastStore = next(MII);
|
|
|
|
|
|
|
|
// If the stack slot value was previously available in some other
|
|
|
|
// register, change it now. Otherwise, make the register available,
|
|
|
|
// in PhysReg.
|
2006-02-04 00:13:58 +01:00
|
|
|
Spills.ModifyStackSlot(StackSlot);
|
|
|
|
Spills.ClobberPhysReg(PhysReg);
|
|
|
|
Spills.addAvailable(StackSlot, PhysReg);
|
2006-02-03 04:06:49 +01:00
|
|
|
++NumStores;
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
}
|
2004-09-30 03:54:45 +02:00
|
|
|
}
|
Teach the local spiller to turn stack slot loads into register-register copies
when possible, avoiding the load (and avoiding the copy if the value is already
in the right register).
This patch came about when I noticed code like the following being generated:
store R17 -> [SS1]
...blah...
R4 = load [SS1]
This was causing an LSU reject on the G5. This problem was due to the register
allocator folding spill code into a reg-reg copy (producing the load), which
prevented the spiller from being able to rewrite the load into a copy, despite
the fact that the value was already available in a register. In the case
above, we now rip out the R4 load and replace it with a R4 = R17 copy.
This speeds up several programs on X86 (which spills a lot :) ), e.g.
smg2k from 22.39->20.60s, povray from 12.93->12.66s, 168.wupwise from
68.54->53.83s (!), 197.parser from 7.33->6.62s (!), etc. This may have a larger
impact in some cases on the G5 (by avoiding LSU rejects), though it probably
won't trigger as often (less spilling in general).
Targets that implement folding of loads/stores into copies should implement
the isLoadFromStackSlot hook to get this.
llvm-svn: 23388
2005-09-19 08:56:21 +02:00
|
|
|
ProcessNextInst:
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
MII = NextMII;
|
2004-09-30 03:54:45 +02:00
|
|
|
}
|
2004-02-24 09:58:30 +01:00
|
|
|
}
|
|
|
|
|
2004-09-30 03:54:45 +02:00
|
|
|
|
Substantially revamp the local spiller, causing it to actually improve the
generated code over the simple spiller. The new local spiller generates
substantially better code than the simple one in some cases, by reusing
values that are loaded out of stack slots and kept available in registers.
This primarily helps programs that are spilling a lot, and there is still
stuff that can be done to improve it. This patch makes the local spiller
the default, as it's only a tiny bit slower than the simple spiller (it
increases the runtime of llc by < 1%).
Here are some numbers with speedups.
Program #reuse old(s) new(s) Speedup
Povray: 3452, 16.87 -> 15.93 (5.5%)
177.mesa: 2176, 2.77 -> 2.76 (0%)
179.art: 35, 28.43 -> 28.01 (1.5%)
183.equake: 55, 61.44 -> 61.41 (0%)
188.ammp: 869, 174 -> 149 (15%)
164.gzip: 43, 40.73 -> 40.71 (0%)
175.vpr: 351, 18.54 -> 17.34 (6.5%)
176.gcc: 2471, 5.01 -> 4.92 (1.8%)
181.mcf 42, 79.30 -> 75.20 (5.2%)
186.crafty: 484, 29.73 -> 30.04 (-1%)
197.parser: 251, 10.47 -> 10.67 (-1%)
252.eon: 1501, 1.98 -> 1.75 (12%)
253.perlbm: 1183, 14.83 -> 14.42 (2.8%)
254.gap: 825, 7.46 -> 7.29 (2.3%)
255.vortex: 285, 10.51 -> 10.27 (2.3%)
256.bzip2: 63, 55.70 -> 55.20 (0.9%)
300.twolf: 830, 21.63 -> 22.00 (-1%)
PtrDist/ks 14, 32.75 -> 17.53 (46.5%)
Olden/tsp 46, 8.71 -> 8.24 (5.4%)
Free/distray 70, 1.09 -> 0.99 (9.2%)
llvm-svn: 16629
2004-10-01 21:04:51 +02:00
|
|
|
|
2004-09-30 03:54:45 +02:00
|
|
|
llvm::Spiller* llvm::createSpiller() {
|
|
|
|
switch (SpillerOpt) {
|
|
|
|
default: assert(0 && "Unreachable!");
|
|
|
|
case local:
|
|
|
|
return new LocalSpiller();
|
|
|
|
case simple:
|
|
|
|
return new SimpleSpiller();
|
|
|
|
}
|
2004-02-24 09:58:30 +01:00
|
|
|
}
|