2004-07-23 19:56:30 +02:00
|
|
|
//===-- LiveIntervalAnalysis.h - Live Interval Analysis ---------*- C++ -*-===//
|
2003-11-20 04:32:25 +01:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:59:42 +01:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2003-11-20 04:32:25 +01:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2004-07-19 04:13:59 +02:00
|
|
|
// This file implements the LiveInterval analysis pass. Given some numbering of
|
|
|
|
// each the machine instructions (in this implemention depth-first order) an
|
|
|
|
// interval [i, j) is said to be a live interval for register v if there is no
|
2008-03-14 00:04:27 +01:00
|
|
|
// instruction with number j' > j such that v is live at j' and there is no
|
2004-07-19 04:13:59 +02:00
|
|
|
// instruction with number i' < i such that v is live at i'. In this
|
|
|
|
// implementation intervals can have holes, i.e. an interval might look like
|
|
|
|
// [1,20), [50,65), [1000,1001).
|
2003-11-20 04:32:25 +01:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2004-07-23 19:56:30 +02:00
|
|
|
#ifndef LLVM_CODEGEN_LIVEINTERVAL_ANALYSIS_H
|
|
|
|
#define LLVM_CODEGEN_LIVEINTERVAL_ANALYSIS_H
|
2003-11-20 04:32:25 +01:00
|
|
|
|
2009-08-19 22:52:54 +02:00
|
|
|
#include "llvm/CodeGen/MachineBasicBlock.h"
|
2003-11-20 04:32:25 +01:00
|
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
2005-09-21 06:19:09 +02:00
|
|
|
#include "llvm/CodeGen/LiveInterval.h"
|
2009-11-04 00:52:08 +01:00
|
|
|
#include "llvm/CodeGen/SlotIndexes.h"
|
2007-02-15 06:59:24 +01:00
|
|
|
#include "llvm/ADT/BitVector.h"
|
2007-04-17 22:32:26 +02:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2009-01-07 03:08:57 +01:00
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
2007-08-14 01:45:17 +02:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2007-09-05 23:46:51 +02:00
|
|
|
#include "llvm/Support/Allocator.h"
|
2007-11-14 00:04:28 +01:00
|
|
|
#include <cmath>
|
2009-11-04 00:52:08 +01:00
|
|
|
#include <iterator>
|
2003-11-20 04:32:25 +01:00
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
|
2008-07-25 02:02:30 +02:00
|
|
|
class AliasAnalysis;
|
2004-08-04 11:46:26 +02:00
|
|
|
class LiveVariables;
|
2007-12-11 03:09:15 +01:00
|
|
|
class MachineLoopInfo;
|
2008-02-10 19:45:23 +01:00
|
|
|
class TargetRegisterInfo;
|
2007-12-31 05:13:23 +01:00
|
|
|
class MachineRegisterInfo;
|
Allow the live interval analysis pass to be a bit more aggressive about
numbering values in live ranges for physical registers.
The alpha backend currently generates code that looks like this:
vreg = preg
...
preg = vreg
use preg
...
preg = vreg
use preg
etc. Because vreg contains the value of preg coming in, each of the
copies back into preg contain that initial value as well.
In the case of the Alpha, this allows this testcase:
void "foo"(int %blah) {
store int 5, int *%MyVar
store int 12, int* %MyVar2
ret void
}
to compile to:
foo:
ldgp $29, 0($27)
ldiq $0,5
stl $0,MyVar
ldiq $0,12
stl $0,MyVar2
ret $31,($26),1
instead of:
foo:
ldgp $29, 0($27)
bis $29,$29,$0
ldiq $1,5
bis $0,$0,$29
stl $1,MyVar
ldiq $1,12
bis $0,$0,$29
stl $1,MyVar2
ret $31,($26),1
This does not seem to have any noticable effect on X86 code.
This fixes PR535.
llvm-svn: 20536
2005-03-10 00:05:19 +01:00
|
|
|
class TargetInstrInfo;
|
2007-04-17 22:32:26 +02:00
|
|
|
class TargetRegisterClass;
|
2004-08-04 11:46:26 +02:00
|
|
|
class VirtRegMap;
|
2010-08-12 22:01:23 +02:00
|
|
|
|
2004-08-04 11:46:26 +02:00
|
|
|
class LiveIntervals : public MachineFunctionPass {
|
|
|
|
MachineFunction* mf_;
|
2008-02-22 10:24:50 +01:00
|
|
|
MachineRegisterInfo* mri_;
|
2004-08-04 11:46:26 +02:00
|
|
|
const TargetMachine* tm_;
|
2008-02-10 19:45:23 +01:00
|
|
|
const TargetRegisterInfo* tri_;
|
Allow the live interval analysis pass to be a bit more aggressive about
numbering values in live ranges for physical registers.
The alpha backend currently generates code that looks like this:
vreg = preg
...
preg = vreg
use preg
...
preg = vreg
use preg
etc. Because vreg contains the value of preg coming in, each of the
copies back into preg contain that initial value as well.
In the case of the Alpha, this allows this testcase:
void "foo"(int %blah) {
store int 5, int *%MyVar
store int 12, int* %MyVar2
ret void
}
to compile to:
foo:
ldgp $29, 0($27)
ldiq $0,5
stl $0,MyVar
ldiq $0,12
stl $0,MyVar2
ret $31,($26),1
instead of:
foo:
ldgp $29, 0($27)
bis $29,$29,$0
ldiq $1,5
bis $0,$0,$29
stl $1,MyVar
ldiq $1,12
bis $0,$0,$29
stl $1,MyVar2
ret $31,($26),1
This does not seem to have any noticable effect on X86 code.
This fixes PR535.
llvm-svn: 20536
2005-03-10 00:05:19 +01:00
|
|
|
const TargetInstrInfo* tii_;
|
2008-07-25 02:02:30 +02:00
|
|
|
AliasAnalysis *aa_;
|
2004-08-04 11:46:26 +02:00
|
|
|
LiveVariables* lv_;
|
2009-11-04 00:52:08 +01:00
|
|
|
SlotIndexes* indexes_;
|
2004-08-04 11:46:26 +02:00
|
|
|
|
2007-09-05 23:46:51 +02:00
|
|
|
/// Special pool allocator for VNInfo's (LiveInterval val#).
|
|
|
|
///
|
2010-03-30 22:16:45 +02:00
|
|
|
VNInfo::Allocator VNInfoAllocator;
|
2007-09-05 23:46:51 +02:00
|
|
|
|
2008-08-14 00:08:30 +02:00
|
|
|
typedef DenseMap<unsigned, LiveInterval*> Reg2IntervalMap;
|
2004-08-04 11:46:26 +02:00
|
|
|
Reg2IntervalMap r2iMap_;
|
|
|
|
|
2009-09-14 23:33:42 +02:00
|
|
|
/// allocatableRegs_ - A bit vector of allocatable registers.
|
2007-02-15 06:59:24 +01:00
|
|
|
BitVector allocatableRegs_;
|
2007-03-01 03:03:03 +01:00
|
|
|
|
2004-08-04 11:46:26 +02:00
|
|
|
public:
|
2007-05-06 15:37:16 +02:00
|
|
|
static char ID; // Pass identification, replacement for typeid
|
2010-10-19 19:21:58 +02:00
|
|
|
LiveIntervals() : MachineFunctionPass(ID) {
|
|
|
|
initializeLiveIntervalsPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2007-05-01 23:15:47 +02:00
|
|
|
|
2010-03-01 21:59:38 +01:00
|
|
|
// Calculate the spill weight to assign to a single instruction.
|
|
|
|
static float getSpillWeight(bool isDef, bool isUse, unsigned loopDepth);
|
2007-11-12 07:35:08 +01:00
|
|
|
|
2004-08-04 11:46:26 +02:00
|
|
|
typedef Reg2IntervalMap::iterator iterator;
|
2004-09-30 17:59:17 +02:00
|
|
|
typedef Reg2IntervalMap::const_iterator const_iterator;
|
|
|
|
const_iterator begin() const { return r2iMap_.begin(); }
|
|
|
|
const_iterator end() const { return r2iMap_.end(); }
|
2004-08-04 11:46:26 +02:00
|
|
|
iterator begin() { return r2iMap_.begin(); }
|
|
|
|
iterator end() { return r2iMap_.end(); }
|
2008-05-05 20:30:58 +02:00
|
|
|
unsigned getNumIntervals() const { return (unsigned)r2iMap_.size(); }
|
2004-08-04 11:46:26 +02:00
|
|
|
|
|
|
|
LiveInterval &getInterval(unsigned reg) {
|
|
|
|
Reg2IntervalMap::iterator I = r2iMap_.find(reg);
|
|
|
|
assert(I != r2iMap_.end() && "Interval does not exist for register");
|
2008-08-13 23:49:13 +02:00
|
|
|
return *I->second;
|
2004-08-04 11:46:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
const LiveInterval &getInterval(unsigned reg) const {
|
|
|
|
Reg2IntervalMap::const_iterator I = r2iMap_.find(reg);
|
|
|
|
assert(I != r2iMap_.end() && "Interval does not exist for register");
|
2008-08-13 23:49:13 +02:00
|
|
|
return *I->second;
|
2004-08-04 11:46:26 +02:00
|
|
|
}
|
|
|
|
|
2007-02-19 22:49:54 +01:00
|
|
|
bool hasInterval(unsigned reg) const {
|
2007-03-01 03:03:03 +01:00
|
|
|
return r2iMap_.count(reg);
|
2007-02-19 22:49:54 +01:00
|
|
|
}
|
|
|
|
|
2010-08-10 02:02:26 +02:00
|
|
|
/// isAllocatable - is the physical register reg allocatable in the current
|
|
|
|
/// function?
|
|
|
|
bool isAllocatable(unsigned reg) const {
|
|
|
|
return allocatableRegs_.test(reg);
|
|
|
|
}
|
|
|
|
|
2008-07-23 00:46:49 +02:00
|
|
|
/// getScaledIntervalSize - get the size of an interval in "units,"
|
2008-06-24 01:25:37 +02:00
|
|
|
/// where every function is composed of one thousand units. This
|
|
|
|
/// measure scales properly with empty index slots in the function.
|
2008-07-23 00:46:49 +02:00
|
|
|
double getScaledIntervalSize(LiveInterval& I) {
|
2009-11-04 00:52:08 +01:00
|
|
|
return (1000.0 * I.getSize()) / indexes_->getIndexesLength();
|
2008-07-23 00:46:49 +02:00
|
|
|
}
|
2010-04-21 02:44:22 +02:00
|
|
|
|
|
|
|
/// getFuncInstructionCount - Return the number of instructions in the
|
|
|
|
/// current function.
|
|
|
|
unsigned getFuncInstructionCount() {
|
|
|
|
return indexes_->getFunctionSize();
|
|
|
|
}
|
2010-08-12 22:01:23 +02:00
|
|
|
|
2008-07-23 00:46:49 +02:00
|
|
|
/// getApproximateInstructionCount - computes an estimate of the number
|
|
|
|
/// of instructions in a given LiveInterval.
|
|
|
|
unsigned getApproximateInstructionCount(LiveInterval& I) {
|
|
|
|
double IntervalPercentage = getScaledIntervalSize(I) / 1000.0;
|
2009-11-04 00:52:08 +01:00
|
|
|
return (unsigned)(IntervalPercentage * indexes_->getFunctionSize());
|
2008-10-23 22:43:13 +02:00
|
|
|
}
|
|
|
|
|
2007-06-08 19:18:56 +02:00
|
|
|
// Interval creation
|
|
|
|
LiveInterval &getOrCreateInterval(unsigned reg) {
|
|
|
|
Reg2IntervalMap::iterator I = r2iMap_.find(reg);
|
|
|
|
if (I == r2iMap_.end())
|
2008-08-14 00:08:30 +02:00
|
|
|
I = r2iMap_.insert(std::make_pair(reg, createInterval(reg))).first;
|
2008-08-13 23:49:13 +02:00
|
|
|
return *I->second;
|
2007-06-08 19:18:56 +02:00
|
|
|
}
|
2009-02-08 12:04:35 +01:00
|
|
|
|
|
|
|
/// dupInterval - Duplicate a live interval. The caller is responsible for
|
|
|
|
/// managing the allocated memory.
|
|
|
|
LiveInterval *dupInterval(LiveInterval *li);
|
2010-08-12 22:01:23 +02:00
|
|
|
|
2008-06-05 19:15:43 +02:00
|
|
|
/// addLiveRangeToEndOfBlock - Given a register and an instruction,
|
|
|
|
/// adds a live range from that instruction to the end of its MBB.
|
|
|
|
LiveRange addLiveRangeToEndOfBlock(unsigned reg,
|
2009-09-04 22:41:11 +02:00
|
|
|
MachineInstr* startInst);
|
2004-08-04 11:46:26 +02:00
|
|
|
|
2011-02-08 01:03:05 +01:00
|
|
|
/// shrinkToUses - After removing some uses of a register, shrink its live
|
|
|
|
/// range to just the remaining uses. This method does not compute reaching
|
|
|
|
/// defs for new uses, and it doesn't remove dead defs.
|
|
|
|
/// Dead PHIDef values are marked as unused.
|
2011-03-08 00:29:10 +01:00
|
|
|
/// New dead machine instructions are added to the dead vector.
|
2011-03-17 21:37:07 +01:00
|
|
|
/// Return true if the interval may have been separated into multiple
|
|
|
|
/// connected components.
|
|
|
|
bool shrinkToUses(LiveInterval *li,
|
2011-03-08 00:29:10 +01:00
|
|
|
SmallVectorImpl<MachineInstr*> *dead = 0);
|
2011-02-08 01:03:05 +01:00
|
|
|
|
2007-06-08 19:18:56 +02:00
|
|
|
// Interval removal
|
2004-08-04 11:46:26 +02:00
|
|
|
|
2007-06-08 19:18:56 +02:00
|
|
|
void removeInterval(unsigned Reg) {
|
2008-08-14 00:08:30 +02:00
|
|
|
DenseMap<unsigned, LiveInterval*>::iterator I = r2iMap_.find(Reg);
|
2008-08-13 23:49:13 +02:00
|
|
|
delete I->second;
|
|
|
|
r2iMap_.erase(I);
|
2006-12-17 06:15:13 +01:00
|
|
|
}
|
2004-09-30 17:59:17 +02:00
|
|
|
|
2011-01-12 23:28:48 +01:00
|
|
|
SlotIndexes *getSlotIndexes() const {
|
|
|
|
return indexes_;
|
|
|
|
}
|
|
|
|
|
2009-04-22 00:46:52 +02:00
|
|
|
/// isNotInMIMap - returns true if the specified machine instr has been
|
|
|
|
/// removed or was never entered in the map.
|
2009-11-04 00:52:08 +01:00
|
|
|
bool isNotInMIMap(const MachineInstr* Instr) const {
|
|
|
|
return !indexes_->hasIndex(Instr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the base index of the given instruction.
|
|
|
|
SlotIndex getInstructionIndex(const MachineInstr *instr) const {
|
|
|
|
return indexes_->getInstructionIndex(instr);
|
|
|
|
}
|
2010-08-12 22:01:23 +02:00
|
|
|
|
2009-11-04 00:52:08 +01:00
|
|
|
/// Returns the instruction associated with the given index.
|
|
|
|
MachineInstr* getInstructionFromIndex(SlotIndex index) const {
|
|
|
|
return indexes_->getInstructionFromIndex(index);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return the first index in the given basic block.
|
|
|
|
SlotIndex getMBBStartIdx(const MachineBasicBlock *mbb) const {
|
|
|
|
return indexes_->getMBBStartIdx(mbb);
|
2010-08-12 22:01:23 +02:00
|
|
|
}
|
2009-11-04 00:52:08 +01:00
|
|
|
|
|
|
|
/// Return the last index in the given basic block.
|
|
|
|
SlotIndex getMBBEndIdx(const MachineBasicBlock *mbb) const {
|
|
|
|
return indexes_->getMBBEndIdx(mbb);
|
2010-08-12 22:01:23 +02:00
|
|
|
}
|
2009-11-04 00:52:08 +01:00
|
|
|
|
2010-07-17 09:34:01 +02:00
|
|
|
bool isLiveInToMBB(const LiveInterval &li,
|
|
|
|
const MachineBasicBlock *mbb) const {
|
|
|
|
return li.liveAt(getMBBStartIdx(mbb));
|
|
|
|
}
|
|
|
|
|
|
|
|
LiveRange* findEnteringRange(LiveInterval &li,
|
|
|
|
const MachineBasicBlock *mbb) {
|
|
|
|
return li.getLiveRangeContaining(getMBBStartIdx(mbb));
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isLiveOutOfMBB(const LiveInterval &li,
|
|
|
|
const MachineBasicBlock *mbb) const {
|
|
|
|
return li.liveAt(getMBBEndIdx(mbb).getPrevSlot());
|
|
|
|
}
|
|
|
|
|
|
|
|
LiveRange* findExitingRange(LiveInterval &li,
|
|
|
|
const MachineBasicBlock *mbb) {
|
|
|
|
return li.getLiveRangeContaining(getMBBEndIdx(mbb).getPrevSlot());
|
|
|
|
}
|
|
|
|
|
2009-11-04 00:52:08 +01:00
|
|
|
MachineBasicBlock* getMBBFromIndex(SlotIndex index) const {
|
|
|
|
return indexes_->getMBBFromIndex(index);
|
|
|
|
}
|
|
|
|
|
2009-11-14 01:02:51 +01:00
|
|
|
SlotIndex InsertMachineInstrInMaps(MachineInstr *MI) {
|
|
|
|
return indexes_->insertMachineInstrInMaps(MI);
|
2007-02-23 00:03:39 +01:00
|
|
|
}
|
|
|
|
|
2006-08-25 00:43:55 +02:00
|
|
|
void RemoveMachineInstrFromMaps(MachineInstr *MI) {
|
2009-11-04 00:52:08 +01:00
|
|
|
indexes_->removeMachineInstrFromMaps(MI);
|
2006-08-25 00:43:55 +02:00
|
|
|
}
|
2007-06-08 19:18:56 +02:00
|
|
|
|
2008-02-13 04:01:43 +01:00
|
|
|
void ReplaceMachineInstrInMaps(MachineInstr *MI, MachineInstr *NewMI) {
|
2009-11-04 00:52:08 +01:00
|
|
|
indexes_->replaceMachineInstrInMaps(MI, NewMI);
|
|
|
|
}
|
|
|
|
|
2010-07-17 09:34:01 +02:00
|
|
|
void InsertMBBInMaps(MachineBasicBlock *MBB) {
|
|
|
|
indexes_->insertMBBInMaps(MBB);
|
|
|
|
}
|
|
|
|
|
2009-11-04 00:52:08 +01:00
|
|
|
bool findLiveInMBBs(SlotIndex Start, SlotIndex End,
|
|
|
|
SmallVectorImpl<MachineBasicBlock*> &MBBs) const {
|
|
|
|
return indexes_->findLiveInMBBs(Start, End, MBBs);
|
|
|
|
}
|
|
|
|
|
|
|
|
void renumber() {
|
2009-11-14 01:02:51 +01:00
|
|
|
indexes_->renumberIndexes();
|
2008-02-13 04:01:43 +01:00
|
|
|
}
|
|
|
|
|
2010-03-30 22:16:45 +02:00
|
|
|
VNInfo::Allocator& getVNInfoAllocator() { return VNInfoAllocator; }
|
2007-09-05 23:46:51 +02:00
|
|
|
|
2007-06-08 19:18:56 +02:00
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const;
|
|
|
|
virtual void releaseMemory();
|
|
|
|
|
|
|
|
/// runOnMachineFunction - pass entry point
|
|
|
|
virtual bool runOnMachineFunction(MachineFunction&);
|
|
|
|
|
|
|
|
/// print - Implement the dump method.
|
2009-08-23 08:03:38 +02:00
|
|
|
virtual void print(raw_ostream &O, const Module* = 0) const;
|
2007-06-08 19:18:56 +02:00
|
|
|
|
2007-12-06 01:01:56 +01:00
|
|
|
/// isReMaterializable - Returns true if every definition of MI of every
|
|
|
|
/// val# of the specified interval is re-materializable. Also returns true
|
|
|
|
/// by reference if all of the defs are load instructions.
|
2008-09-30 17:44:16 +02:00
|
|
|
bool isReMaterializable(const LiveInterval &li,
|
2011-03-10 02:21:58 +01:00
|
|
|
const SmallVectorImpl<LiveInterval*> *SpillIs,
|
2008-09-30 17:44:16 +02:00
|
|
|
bool &isLoad);
|
2007-12-06 01:01:56 +01:00
|
|
|
|
2009-01-13 07:05:10 +01:00
|
|
|
/// intervalIsInOneMBB - Returns true if the specified interval is entirely
|
|
|
|
/// within a single basic block.
|
|
|
|
bool intervalIsInOneMBB(const LiveInterval &li) const;
|
|
|
|
|
2011-02-08 22:13:03 +01:00
|
|
|
/// addKillFlags - Add kill flags to any instruction that kills a virtual
|
|
|
|
/// register.
|
|
|
|
void addKillFlags();
|
|
|
|
|
2012-01-27 23:36:19 +01:00
|
|
|
/// moveInstr - Move MachineInstr mi to insertPt, updating the live
|
|
|
|
/// intervals of mi's operands to reflect the new position. The insertion
|
|
|
|
/// point can be above or below mi, but must be in the same basic block.
|
|
|
|
void moveInstr(MachineBasicBlock::iterator insertPt, MachineInstr* mi);
|
|
|
|
|
2010-08-12 22:01:23 +02:00
|
|
|
private:
|
2006-09-15 05:57:23 +02:00
|
|
|
/// computeIntervals - Compute live intervals.
|
2006-09-14 08:42:17 +02:00
|
|
|
void computeIntervals();
|
2009-09-14 23:33:42 +02:00
|
|
|
|
2004-08-04 11:46:26 +02:00
|
|
|
/// handleRegisterDef - update intervals for a register def
|
|
|
|
/// (calls handlePhysicalRegisterDef and
|
|
|
|
/// handleVirtualRegisterDef)
|
2006-09-03 10:07:11 +02:00
|
|
|
void handleRegisterDef(MachineBasicBlock *MBB,
|
2009-09-04 22:41:11 +02:00
|
|
|
MachineBasicBlock::iterator MI,
|
2009-11-04 00:52:08 +01:00
|
|
|
SlotIndex MIIdx,
|
2008-07-10 09:35:43 +02:00
|
|
|
MachineOperand& MO, unsigned MOIdx);
|
2004-08-04 11:46:26 +02:00
|
|
|
|
2010-05-05 20:27:40 +02:00
|
|
|
/// isPartialRedef - Return true if the specified def at the specific index
|
|
|
|
/// is partially re-defining the specified live interval. A common case of
|
2010-08-12 22:01:23 +02:00
|
|
|
/// this is a definition of the sub-register.
|
2010-05-05 20:27:40 +02:00
|
|
|
bool isPartialRedef(SlotIndex MIIdx, MachineOperand &MO,
|
|
|
|
LiveInterval &interval);
|
|
|
|
|
2004-08-04 11:46:26 +02:00
|
|
|
/// handleVirtualRegisterDef - update intervals for a virtual
|
|
|
|
/// register def
|
2006-09-03 10:07:11 +02:00
|
|
|
void handleVirtualRegisterDef(MachineBasicBlock *MBB,
|
|
|
|
MachineBasicBlock::iterator MI,
|
2009-11-04 00:52:08 +01:00
|
|
|
SlotIndex MIIdx, MachineOperand& MO,
|
2009-09-04 22:41:11 +02:00
|
|
|
unsigned MOIdx,
|
|
|
|
LiveInterval& interval);
|
2004-08-04 11:46:26 +02:00
|
|
|
|
Allow the live interval analysis pass to be a bit more aggressive about
numbering values in live ranges for physical registers.
The alpha backend currently generates code that looks like this:
vreg = preg
...
preg = vreg
use preg
...
preg = vreg
use preg
etc. Because vreg contains the value of preg coming in, each of the
copies back into preg contain that initial value as well.
In the case of the Alpha, this allows this testcase:
void "foo"(int %blah) {
store int 5, int *%MyVar
store int 12, int* %MyVar2
ret void
}
to compile to:
foo:
ldgp $29, 0($27)
ldiq $0,5
stl $0,MyVar
ldiq $0,12
stl $0,MyVar2
ret $31,($26),1
instead of:
foo:
ldgp $29, 0($27)
bis $29,$29,$0
ldiq $1,5
bis $0,$0,$29
stl $1,MyVar
ldiq $1,12
bis $0,$0,$29
stl $1,MyVar2
ret $31,($26),1
This does not seem to have any noticable effect on X86 code.
This fixes PR535.
llvm-svn: 20536
2005-03-10 00:05:19 +01:00
|
|
|
/// handlePhysicalRegisterDef - update intervals for a physical register
|
2006-08-25 00:43:55 +02:00
|
|
|
/// def.
|
2004-08-04 11:46:26 +02:00
|
|
|
void handlePhysicalRegisterDef(MachineBasicBlock* mbb,
|
|
|
|
MachineBasicBlock::iterator mi,
|
2009-11-04 00:52:08 +01:00
|
|
|
SlotIndex MIIdx, MachineOperand& MO,
|
2006-08-31 07:54:43 +02:00
|
|
|
LiveInterval &interval,
|
2008-02-15 19:24:29 +01:00
|
|
|
MachineInstr *CopyMI);
|
2004-08-04 11:46:26 +02:00
|
|
|
|
2007-02-19 22:49:54 +01:00
|
|
|
/// handleLiveInRegister - Create interval for a livein register.
|
2007-02-21 23:41:17 +01:00
|
|
|
void handleLiveInRegister(MachineBasicBlock* mbb,
|
2009-11-04 00:52:08 +01:00
|
|
|
SlotIndex MIIdx,
|
2007-04-25 09:30:23 +02:00
|
|
|
LiveInterval &interval, bool isAlias = false);
|
2007-02-19 22:49:54 +01:00
|
|
|
|
2008-02-22 10:24:50 +01:00
|
|
|
/// getReMatImplicitUse - If the remat definition MI has one (for now, we
|
|
|
|
/// only allow one) virtual register operand, then its uses are implicitly
|
|
|
|
/// using the register. Returns the virtual register.
|
|
|
|
unsigned getReMatImplicitUse(const LiveInterval &li,
|
|
|
|
MachineInstr *MI) const;
|
|
|
|
|
|
|
|
/// isValNoAvailableAt - Return true if the val# of the specified interval
|
|
|
|
/// which reaches the given instruction also reaches the specified use
|
|
|
|
/// index.
|
|
|
|
bool isValNoAvailableAt(const LiveInterval &li, MachineInstr *MI,
|
2009-11-04 00:52:08 +01:00
|
|
|
SlotIndex UseIdx) const;
|
2008-02-22 10:24:50 +01:00
|
|
|
|
2007-08-14 01:45:17 +02:00
|
|
|
/// isReMaterializable - Returns true if the definition MI of the specified
|
2007-12-06 01:01:56 +01:00
|
|
|
/// val# of the specified interval is re-materializable. Also returns true
|
|
|
|
/// by reference if the def is a load.
|
2007-08-29 22:45:00 +02:00
|
|
|
bool isReMaterializable(const LiveInterval &li, const VNInfo *ValNo,
|
2008-09-30 17:44:16 +02:00
|
|
|
MachineInstr *MI,
|
2011-03-10 02:21:58 +01:00
|
|
|
const SmallVectorImpl<LiveInterval*> *SpillIs,
|
2008-09-30 17:44:16 +02:00
|
|
|
bool &isLoad);
|
2007-08-14 01:45:17 +02:00
|
|
|
|
2008-08-13 23:49:13 +02:00
|
|
|
static LiveInterval* createInterval(unsigned Reg);
|
2004-08-04 11:46:26 +02:00
|
|
|
|
2009-09-14 23:33:42 +02:00
|
|
|
void printInstrs(raw_ostream &O) const;
|
|
|
|
void dumpInstrs() const;
|
2004-08-04 11:46:26 +02:00
|
|
|
};
|
2003-11-20 04:32:25 +01:00
|
|
|
} // End llvm namespace
|
|
|
|
|
|
|
|
#endif
|