2011-01-04 21:10:05 +00:00
|
|
|
//===-------- SplitKit.h - Toolkit for splitting live ranges ----*- C++ -*-===//
|
2010-07-20 15:41:07 +00:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file contains the SplitAnalysis class as well as mutator functions for
|
|
|
|
// live range splitting.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2011-04-24 15:46:51 +00:00
|
|
|
#ifndef LLVM_CODEGEN_SPLITKIT_H
|
|
|
|
#define LLVM_CODEGEN_SPLITKIT_H
|
|
|
|
|
2011-09-13 01:34:21 +00:00
|
|
|
#include "LiveRangeCalc.h"
|
2011-04-06 03:57:00 +00:00
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
2010-07-20 15:41:07 +00:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2011-02-03 06:18:29 +00:00
|
|
|
#include "llvm/ADT/IntervalMap.h"
|
2010-12-21 01:50:21 +00:00
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
2010-07-20 15:41:07 +00:00
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
|
2011-02-03 06:18:29 +00:00
|
|
|
class ConnectedVNInfoEqClasses;
|
2010-07-20 15:41:07 +00:00
|
|
|
class LiveInterval;
|
|
|
|
class LiveIntervals;
|
2010-10-14 23:49:52 +00:00
|
|
|
class LiveRangeEdit;
|
2010-07-20 15:41:07 +00:00
|
|
|
class MachineInstr;
|
|
|
|
class MachineLoopInfo;
|
2010-07-26 23:44:11 +00:00
|
|
|
class MachineRegisterInfo;
|
2010-07-20 21:46:58 +00:00
|
|
|
class TargetInstrInfo;
|
2010-11-10 19:31:50 +00:00
|
|
|
class TargetRegisterInfo;
|
2010-07-26 23:44:11 +00:00
|
|
|
class VirtRegMap;
|
|
|
|
class VNInfo;
|
2010-10-22 20:28:21 +00:00
|
|
|
class raw_ostream;
|
2010-07-20 15:41:07 +00:00
|
|
|
|
2010-07-26 23:44:11 +00:00
|
|
|
/// SplitAnalysis - Analyze a LiveInterval, looking for live range splitting
|
|
|
|
/// opportunities.
|
2010-07-20 15:41:07 +00:00
|
|
|
class SplitAnalysis {
|
2010-08-10 17:07:22 +00:00
|
|
|
public:
|
2011-01-26 00:50:53 +00:00
|
|
|
const MachineFunction &MF;
|
2011-02-19 00:53:42 +00:00
|
|
|
const VirtRegMap &VRM;
|
2011-01-26 00:50:53 +00:00
|
|
|
const LiveIntervals &LIS;
|
|
|
|
const MachineLoopInfo &Loops;
|
|
|
|
const TargetInstrInfo &TII;
|
2010-07-20 15:41:07 +00:00
|
|
|
|
2011-01-18 21:13:27 +00:00
|
|
|
// Sorted slot indexes of using instructions.
|
|
|
|
SmallVector<SlotIndex, 8> UseSlots;
|
|
|
|
|
2011-02-09 22:50:26 +00:00
|
|
|
/// Additional information about basic blocks where the current variable is
|
|
|
|
/// live. Such a block will look like one of these templates:
|
|
|
|
///
|
|
|
|
/// 1. | o---x | Internal to block. Variable is only live in this block.
|
|
|
|
/// 2. |---x | Live-in, kill.
|
|
|
|
/// 3. | o---| Def, live-out.
|
2011-05-30 01:33:26 +00:00
|
|
|
/// 4. |---x o---| Live-in, kill, def, live-out. Counted by NumGapBlocks.
|
2011-02-09 22:50:26 +00:00
|
|
|
/// 5. |---o---o---| Live-through with uses or defs.
|
2011-05-30 01:33:26 +00:00
|
|
|
/// 6. |-----------| Live-through without uses. Counted by NumThroughBlocks.
|
|
|
|
///
|
|
|
|
/// Two BlockInfo entries are created for template 4. One for the live-in
|
|
|
|
/// segment, and one for the live-out segment. These entries look as if the
|
|
|
|
/// block were split in the middle where the live range isn't live.
|
|
|
|
///
|
|
|
|
/// Live-through blocks without any uses don't get BlockInfo entries. They
|
|
|
|
/// are simply listed in ThroughBlocks instead.
|
2011-02-09 22:50:26 +00:00
|
|
|
///
|
|
|
|
struct BlockInfo {
|
|
|
|
MachineBasicBlock *MBB;
|
2011-08-02 22:54:14 +00:00
|
|
|
SlotIndex FirstInstr; ///< First instr accessing current reg.
|
|
|
|
SlotIndex LastInstr; ///< Last instr accessing current reg.
|
2011-08-02 22:37:22 +00:00
|
|
|
SlotIndex FirstDef; ///< First non-phi valno->def, or SlotIndex().
|
2011-02-09 22:50:26 +00:00
|
|
|
bool LiveIn; ///< Current reg is live in.
|
|
|
|
bool LiveOut; ///< Current reg is live out.
|
Reapply r134047 now that the world is ready for it.
This patch will sometimes choose live range split points next to
interference instead of always splitting next to a register point. That
means spill code can now appear almost anywhere, and it was necessary
to fix code that didn't expect that.
The difficult places were:
- Between a CALL returning a value on the x87 stack and the
corresponding FpPOP_RETVAL (was FpGET_ST0). Probably also near x87
inline assembly, but that didn't actually show up in testing.
- Between a CALL popping arguments off the stack and the corresponding
ADJCALLSTACKUP.
Both are fixed now. The only place spill code can't appear is after
terminators, see SplitAnalysis::getLastSplitPoint.
Original commit message:
Rewrite RAGreedy::splitAroundRegion, now with cool ASCII art.
This function has to deal with a lot of special cases, and the old
version got it wrong sometimes. In particular, it would sometimes leave
multiple uses in the stack interval in a single block. That causes bad
code with multiple reloads in the same basic block.
The new version handles block entry and exit in a single pass. It first
eliminates all the easy cases, and then goes on to create a local
interval for the blocks with difficult interference. Previously, we
would only create the local interval for completely isolated blocks.
It can happen that the stack interval becomes completely empty because
we could allocate a register in all edge bundles, and the new local
intervals deal with the interference. The empty stack interval is
harmless, but we need to remove a SplitKit assertion that checks for
empty intervals.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134125 91177308-0d34-0410-b5e6-96231b3b80d8
2011-06-30 01:30:39 +00:00
|
|
|
|
|
|
|
/// isOneInstr - Returns true when this BlockInfo describes a single
|
|
|
|
/// instruction.
|
|
|
|
bool isOneInstr() const {
|
2011-08-02 22:54:14 +00:00
|
|
|
return SlotIndex::isSameInstr(FirstInstr, LastInstr);
|
Reapply r134047 now that the world is ready for it.
This patch will sometimes choose live range split points next to
interference instead of always splitting next to a register point. That
means spill code can now appear almost anywhere, and it was necessary
to fix code that didn't expect that.
The difficult places were:
- Between a CALL returning a value on the x87 stack and the
corresponding FpPOP_RETVAL (was FpGET_ST0). Probably also near x87
inline assembly, but that didn't actually show up in testing.
- Between a CALL popping arguments off the stack and the corresponding
ADJCALLSTACKUP.
Both are fixed now. The only place spill code can't appear is after
terminators, see SplitAnalysis::getLastSplitPoint.
Original commit message:
Rewrite RAGreedy::splitAroundRegion, now with cool ASCII art.
This function has to deal with a lot of special cases, and the old
version got it wrong sometimes. In particular, it would sometimes leave
multiple uses in the stack interval in a single block. That causes bad
code with multiple reloads in the same basic block.
The new version handles block entry and exit in a single pass. It first
eliminates all the easy cases, and then goes on to create a local
interval for the blocks with difficult interference. Previously, we
would only create the local interval for completely isolated blocks.
It can happen that the stack interval becomes completely empty because
we could allocate a register in all edge bundles, and the new local
intervals deal with the interference. The empty stack interval is
harmless, but we need to remove a SplitKit assertion that checks for
empty intervals.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134125 91177308-0d34-0410-b5e6-96231b3b80d8
2011-06-30 01:30:39 +00:00
|
|
|
}
|
2011-02-09 22:50:26 +00:00
|
|
|
};
|
|
|
|
|
2010-08-12 17:07:14 +00:00
|
|
|
private:
|
|
|
|
// Current live interval.
|
2011-01-26 00:50:53 +00:00
|
|
|
const LiveInterval *CurLI;
|
2010-08-12 17:07:14 +00:00
|
|
|
|
2011-04-05 04:20:27 +00:00
|
|
|
/// LastSplitPoint - Last legal split point in each basic block in the current
|
|
|
|
/// function. The first entry is the first terminator, the second entry is the
|
|
|
|
/// last valid split point for a variable that is live in to a landing pad
|
|
|
|
/// successor.
|
|
|
|
SmallVector<std::pair<SlotIndex, SlotIndex>, 8> LastSplitPoint;
|
|
|
|
|
2011-04-06 03:57:00 +00:00
|
|
|
/// UseBlocks - Blocks where CurLI has uses.
|
|
|
|
SmallVector<BlockInfo, 8> UseBlocks;
|
|
|
|
|
2011-05-30 01:33:26 +00:00
|
|
|
/// NumGapBlocks - Number of duplicate entries in UseBlocks for blocks where
|
|
|
|
/// the live range has a gap.
|
|
|
|
unsigned NumGapBlocks;
|
|
|
|
|
2011-04-06 03:57:00 +00:00
|
|
|
/// ThroughBlocks - Block numbers where CurLI is live through without uses.
|
2011-04-09 02:59:09 +00:00
|
|
|
BitVector ThroughBlocks;
|
|
|
|
|
|
|
|
/// NumThroughBlocks - Number of live-through blocks.
|
|
|
|
unsigned NumThroughBlocks;
|
2011-04-06 03:57:00 +00:00
|
|
|
|
2011-05-03 20:42:13 +00:00
|
|
|
/// DidRepairRange - analyze was forced to shrinkToUses().
|
|
|
|
bool DidRepairRange;
|
|
|
|
|
2011-04-05 04:20:27 +00:00
|
|
|
SlotIndex computeLastSplitPoint(unsigned Num);
|
|
|
|
|
2011-01-26 00:50:53 +00:00
|
|
|
// Sumarize statistics by counting instructions using CurLI.
|
2010-07-20 16:12:37 +00:00
|
|
|
void analyzeUses();
|
2010-07-20 15:41:07 +00:00
|
|
|
|
2011-02-09 22:50:26 +00:00
|
|
|
/// calcLiveBlockInfo - Compute per-block information about CurLI.
|
2011-03-05 18:33:49 +00:00
|
|
|
bool calcLiveBlockInfo();
|
2011-02-09 22:50:26 +00:00
|
|
|
|
2010-07-20 15:41:07 +00:00
|
|
|
public:
|
2011-02-19 00:53:42 +00:00
|
|
|
SplitAnalysis(const VirtRegMap &vrm, const LiveIntervals &lis,
|
2010-07-20 23:50:15 +00:00
|
|
|
const MachineLoopInfo &mli);
|
2010-07-20 15:41:07 +00:00
|
|
|
|
2011-01-26 00:50:53 +00:00
|
|
|
/// analyze - set CurLI to the specified interval, and analyze how it may be
|
2010-07-20 15:41:07 +00:00
|
|
|
/// split.
|
|
|
|
void analyze(const LiveInterval *li);
|
|
|
|
|
2011-05-03 20:42:13 +00:00
|
|
|
/// didRepairRange() - Returns true if CurLI was invalid and has been repaired
|
|
|
|
/// by analyze(). This really shouldn't happen, but sometimes the coalescer
|
|
|
|
/// can create live ranges that end in mid-air.
|
|
|
|
bool didRepairRange() const { return DidRepairRange; }
|
|
|
|
|
2010-07-20 15:41:07 +00:00
|
|
|
/// clear - clear all data structures so SplitAnalysis is ready to analyze a
|
|
|
|
/// new interval.
|
|
|
|
void clear();
|
|
|
|
|
2011-02-17 19:13:53 +00:00
|
|
|
/// getParent - Return the last analyzed interval.
|
|
|
|
const LiveInterval &getParent() const { return *CurLI; }
|
|
|
|
|
2011-04-05 04:20:27 +00:00
|
|
|
/// getLastSplitPoint - Return that base index of the last valid split point
|
|
|
|
/// in the basic block numbered Num.
|
|
|
|
SlotIndex getLastSplitPoint(unsigned Num) {
|
|
|
|
// Inline the common simple case.
|
|
|
|
if (LastSplitPoint[Num].first.isValid() &&
|
|
|
|
!LastSplitPoint[Num].second.isValid())
|
|
|
|
return LastSplitPoint[Num].first;
|
|
|
|
return computeLastSplitPoint(Num);
|
|
|
|
}
|
|
|
|
|
2011-02-21 23:09:46 +00:00
|
|
|
/// isOriginalEndpoint - Return true if the original live range was killed or
|
|
|
|
/// (re-)defined at Idx. Idx should be the 'def' slot for a normal kill/def,
|
|
|
|
/// and 'use' for an early-clobber def.
|
|
|
|
/// This can be used to recognize code inserted by earlier live range
|
|
|
|
/// splitting.
|
|
|
|
bool isOriginalEndpoint(SlotIndex Idx) const;
|
|
|
|
|
2011-04-06 03:57:00 +00:00
|
|
|
/// getUseBlocks - Return an array of BlockInfo objects for the basic blocks
|
|
|
|
/// where CurLI has uses.
|
2011-05-28 02:32:57 +00:00
|
|
|
ArrayRef<BlockInfo> getUseBlocks() const { return UseBlocks; }
|
2011-04-06 03:57:00 +00:00
|
|
|
|
2011-04-09 02:59:09 +00:00
|
|
|
/// getNumThroughBlocks - Return the number of through blocks.
|
|
|
|
unsigned getNumThroughBlocks() const { return NumThroughBlocks; }
|
|
|
|
|
|
|
|
/// isThroughBlock - Return true if CurLI is live through MBB without uses.
|
|
|
|
bool isThroughBlock(unsigned MBB) const { return ThroughBlocks.test(MBB); }
|
2011-04-06 03:57:00 +00:00
|
|
|
|
2011-04-12 21:30:53 +00:00
|
|
|
/// getThroughBlocks - Return the set of through blocks.
|
|
|
|
const BitVector &getThroughBlocks() const { return ThroughBlocks; }
|
|
|
|
|
2011-05-28 02:32:57 +00:00
|
|
|
/// getNumLiveBlocks - Return the number of blocks where CurLI is live.
|
|
|
|
unsigned getNumLiveBlocks() const {
|
2011-05-30 01:33:26 +00:00
|
|
|
return getUseBlocks().size() - NumGapBlocks + getNumThroughBlocks();
|
2011-05-28 02:32:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// countLiveBlocks - Return the number of blocks where li is live. This is
|
|
|
|
/// guaranteed to return the same number as getNumLiveBlocks() after calling
|
|
|
|
/// analyze(li).
|
2011-04-26 22:33:12 +00:00
|
|
|
unsigned countLiveBlocks(const LiveInterval *li) const;
|
|
|
|
|
2010-07-20 21:46:58 +00:00
|
|
|
typedef SmallPtrSet<const MachineBasicBlock*, 16> BlockPtrSet;
|
|
|
|
|
2011-08-05 22:20:45 +00:00
|
|
|
/// shouldSplitSingleBlock - Returns true if it would help to create a local
|
|
|
|
/// live range for the instructions in BI. There is normally no benefit to
|
|
|
|
/// creating a live range for a single instruction, but it does enable
|
|
|
|
/// register class inflation if the instruction has a restricted register
|
|
|
|
/// class.
|
|
|
|
///
|
|
|
|
/// @param BI The block to be isolated.
|
|
|
|
/// @param SingleInstrs True when single instructions should be isolated.
|
|
|
|
bool shouldSplitSingleBlock(const BlockInfo &BI, bool SingleInstrs) const;
|
2010-07-20 15:41:07 +00:00
|
|
|
};
|
|
|
|
|
2010-08-18 19:00:08 +00:00
|
|
|
|
2010-07-26 23:44:11 +00:00
|
|
|
/// SplitEditor - Edit machine code and LiveIntervals for live range
|
|
|
|
/// splitting.
|
|
|
|
///
|
2010-08-06 22:17:33 +00:00
|
|
|
/// - Create a SplitEditor from a SplitAnalysis.
|
2010-08-04 22:08:39 +00:00
|
|
|
/// - Start a new live interval with openIntv.
|
|
|
|
/// - Mark the places where the new interval is entered using enterIntv*
|
|
|
|
/// - Mark the ranges where the new interval is used with useIntv*
|
|
|
|
/// - Mark the places where the interval is exited with exitIntv*.
|
|
|
|
/// - Finish the current interval with closeIntv and repeat from 2.
|
2010-10-08 23:42:21 +00:00
|
|
|
/// - Rewrite instructions with finish().
|
2010-07-26 23:44:11 +00:00
|
|
|
///
|
|
|
|
class SplitEditor {
|
2011-02-19 00:42:33 +00:00
|
|
|
SplitAnalysis &SA;
|
2011-01-26 00:50:53 +00:00
|
|
|
LiveIntervals &LIS;
|
|
|
|
VirtRegMap &VRM;
|
|
|
|
MachineRegisterInfo &MRI;
|
2011-02-03 06:18:29 +00:00
|
|
|
MachineDominatorTree &MDT;
|
2011-01-26 00:50:53 +00:00
|
|
|
const TargetInstrInfo &TII;
|
|
|
|
const TargetRegisterInfo &TRI;
|
2010-07-26 23:44:11 +00:00
|
|
|
|
Add an interface for SplitKit complement spill modes.
SplitKit always computes a complement live range to cover the places
where the original live range was live, but no explicit region has been
allocated.
Currently, the complement live range is created to be as small as
possible - it never overlaps any of the regions. This minimizes
register pressure, but if the complement is going to be spilled anyway,
that is not very important. The spiller will eliminate redundant
spills, and hoist others by making the spill slot live range overlap
some of the regions created by splitting. Stack slots are cheap.
This patch adds the interface to enable spill modes in SplitKit. In
spill mode, SplitKit will assume that the complement is going to spill,
so it will allow it to overlap regions in order to avoid back-copies.
By doing some of the spiller's work early, the complement live range
becomes simpler. In some cases, it can become much simpler because no
extra PHI-defs are required. This will speed up both splitting and
spilling.
This is only the interface to enable spill modes, no implementation yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@139500 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-12 16:49:21 +00:00
|
|
|
public:
|
|
|
|
|
|
|
|
/// ComplementSpillMode - Select how the complement live range should be
|
|
|
|
/// created. SplitEditor automatically creates interval 0 to contain
|
|
|
|
/// anything that isn't added to another interval. This complement interval
|
|
|
|
/// can get quite complicated, and it can sometimes be an advantage to allow
|
|
|
|
/// it to overlap the other intervals. If it is going to spill anyway, no
|
|
|
|
/// registers are wasted by keeping a value in two places at the same time.
|
|
|
|
enum ComplementSpillMode {
|
|
|
|
/// SM_Partition(Default) - Try to create the complement interval so it
|
|
|
|
/// doesn't overlap any other intervals, and the original interval is
|
|
|
|
/// partitioned. This may require a large number of back copies and extra
|
|
|
|
/// PHI-defs. Only segments marked with overlapIntv will be overlapping.
|
|
|
|
SM_Partition,
|
|
|
|
|
|
|
|
/// SM_Size - Overlap intervals to minimize the number of inserted COPY
|
|
|
|
/// instructions. Copies to the complement interval are hoisted to their
|
|
|
|
/// common dominator, so only one COPY is required per value in the
|
|
|
|
/// complement interval. This also means that no extra PHI-defs need to be
|
|
|
|
/// inserted in the complement interval.
|
|
|
|
SM_Size,
|
|
|
|
|
|
|
|
/// SM_Speed - Overlap intervals to minimize the expected execution
|
|
|
|
/// frequency of the inserted copies. This is very similar to SM_Size, but
|
|
|
|
/// the complement interval may get some extra PHI-defs.
|
|
|
|
SM_Speed
|
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
2011-01-26 00:50:53 +00:00
|
|
|
/// Edit - The current parent register and new intervals created.
|
2011-03-02 23:31:50 +00:00
|
|
|
LiveRangeEdit *Edit;
|
2010-10-14 23:49:52 +00:00
|
|
|
|
2011-02-03 06:18:29 +00:00
|
|
|
/// Index into Edit of the currently open interval.
|
|
|
|
/// The index 0 is used for the complement, so the first interval started by
|
|
|
|
/// openIntv will be 1.
|
|
|
|
unsigned OpenIdx;
|
|
|
|
|
Add an interface for SplitKit complement spill modes.
SplitKit always computes a complement live range to cover the places
where the original live range was live, but no explicit region has been
allocated.
Currently, the complement live range is created to be as small as
possible - it never overlaps any of the regions. This minimizes
register pressure, but if the complement is going to be spilled anyway,
that is not very important. The spiller will eliminate redundant
spills, and hoist others by making the spill slot live range overlap
some of the regions created by splitting. Stack slots are cheap.
This patch adds the interface to enable spill modes in SplitKit. In
spill mode, SplitKit will assume that the complement is going to spill,
so it will allow it to overlap regions in order to avoid back-copies.
By doing some of the spiller's work early, the complement live range
becomes simpler. In some cases, it can become much simpler because no
extra PHI-defs are required. This will speed up both splitting and
spilling.
This is only the interface to enable spill modes, no implementation yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@139500 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-12 16:49:21 +00:00
|
|
|
/// The current spill mode, selected by reset().
|
|
|
|
ComplementSpillMode SpillMode;
|
|
|
|
|
2011-02-03 06:18:29 +00:00
|
|
|
typedef IntervalMap<SlotIndex, unsigned> RegAssignMap;
|
|
|
|
|
|
|
|
/// Allocator for the interval map. This will eventually be shared with
|
|
|
|
/// SlotIndexes and LiveIntervals.
|
|
|
|
RegAssignMap::Allocator Allocator;
|
|
|
|
|
|
|
|
/// RegAssign - Map of the assigned register indexes.
|
|
|
|
/// Edit.get(RegAssign.lookup(Idx)) is the register that should be live at
|
|
|
|
/// Idx.
|
|
|
|
RegAssignMap RegAssign;
|
2010-07-26 23:44:11 +00:00
|
|
|
|
2011-03-01 23:14:53 +00:00
|
|
|
typedef DenseMap<std::pair<unsigned, unsigned>, VNInfo*> ValueMap;
|
|
|
|
|
|
|
|
/// Values - keep track of the mapping from parent values to values in the new
|
|
|
|
/// intervals. Given a pair (RegIdx, ParentVNI->id), Values contains:
|
|
|
|
///
|
|
|
|
/// 1. No entry - the value is not mapped to Edit.get(RegIdx).
|
|
|
|
/// 2. Null - the value is mapped to multiple values in Edit.get(RegIdx).
|
|
|
|
/// Each value is represented by a minimal live range at its def.
|
|
|
|
/// 3. A non-null VNInfo - the value is mapped to a single new value.
|
|
|
|
/// The new value has no live ranges anywhere.
|
|
|
|
ValueMap Values;
|
|
|
|
|
2011-09-13 01:34:21 +00:00
|
|
|
/// LRCalc - Cache for computing live ranges and SSA update.
|
|
|
|
LiveRangeCalc LRCalc;
|
2011-04-15 17:24:49 +00:00
|
|
|
|
2011-03-01 23:14:53 +00:00
|
|
|
/// defValue - define a value in RegIdx from ParentVNI at Idx.
|
|
|
|
/// Idx does not have to be ParentVNI->def, but it must be contained within
|
|
|
|
/// ParentVNI's live range in ParentLI. The new value is added to the value
|
|
|
|
/// map.
|
|
|
|
/// Return the new LI value.
|
|
|
|
VNInfo *defValue(unsigned RegIdx, const VNInfo *ParentVNI, SlotIndex Idx);
|
|
|
|
|
|
|
|
/// markComplexMapped - Mark ParentVNI as complex mapped in RegIdx regardless
|
|
|
|
/// of the number of defs.
|
|
|
|
void markComplexMapped(unsigned RegIdx, const VNInfo *ParentVNI);
|
|
|
|
|
2010-11-10 19:31:50 +00:00
|
|
|
/// defFromParent - Define Reg from ParentVNI at UseIdx using either
|
|
|
|
/// rematerialization or a COPY from parent. Return the new value.
|
2011-02-03 06:18:29 +00:00
|
|
|
VNInfo *defFromParent(unsigned RegIdx,
|
2010-11-10 19:31:50 +00:00
|
|
|
VNInfo *ParentVNI,
|
|
|
|
SlotIndex UseIdx,
|
|
|
|
MachineBasicBlock &MBB,
|
|
|
|
MachineBasicBlock::iterator I);
|
|
|
|
|
2011-03-02 01:59:34 +00:00
|
|
|
/// extendRange - Extend the live range of Edit.get(RegIdx) so it reaches Idx.
|
|
|
|
/// Insert PHIDefs as needed to preserve SSA form.
|
|
|
|
void extendRange(unsigned RegIdx, SlotIndex Idx);
|
|
|
|
|
2011-04-15 17:24:49 +00:00
|
|
|
/// transferValues - Transfer values to the new ranges.
|
|
|
|
/// Return true if any ranges were skipped.
|
|
|
|
bool transferValues();
|
2011-03-02 23:05:19 +00:00
|
|
|
|
2011-03-02 23:05:16 +00:00
|
|
|
/// extendPHIKillRanges - Extend the ranges of all values killed by original
|
|
|
|
/// parent PHIDefs.
|
|
|
|
void extendPHIKillRanges();
|
|
|
|
|
2011-02-03 06:18:29 +00:00
|
|
|
/// rewriteAssigned - Rewrite all uses of Edit.getReg() to assigned registers.
|
2011-03-02 23:05:19 +00:00
|
|
|
void rewriteAssigned(bool ExtendRanges);
|
2010-09-21 22:32:21 +00:00
|
|
|
|
2011-03-08 22:46:11 +00:00
|
|
|
/// deleteRematVictims - Delete defs that are dead after rematerializing.
|
|
|
|
void deleteRematVictims();
|
|
|
|
|
2010-07-26 23:44:11 +00:00
|
|
|
public:
|
|
|
|
/// Create a new SplitEditor for editing the LiveInterval analyzed by SA.
|
2010-08-04 22:08:39 +00:00
|
|
|
/// Newly created intervals will be appended to newIntervals.
|
2010-10-28 20:34:50 +00:00
|
|
|
SplitEditor(SplitAnalysis &SA, LiveIntervals&, VirtRegMap&,
|
2011-03-03 01:29:13 +00:00
|
|
|
MachineDominatorTree&);
|
2010-07-26 23:44:11 +00:00
|
|
|
|
2011-03-03 01:29:13 +00:00
|
|
|
/// reset - Prepare for a new split.
|
Add an interface for SplitKit complement spill modes.
SplitKit always computes a complement live range to cover the places
where the original live range was live, but no explicit region has been
allocated.
Currently, the complement live range is created to be as small as
possible - it never overlaps any of the regions. This minimizes
register pressure, but if the complement is going to be spilled anyway,
that is not very important. The spiller will eliminate redundant
spills, and hoist others by making the spill slot live range overlap
some of the regions created by splitting. Stack slots are cheap.
This patch adds the interface to enable spill modes in SplitKit. In
spill mode, SplitKit will assume that the complement is going to spill,
so it will allow it to overlap regions in order to avoid back-copies.
By doing some of the spiller's work early, the complement live range
becomes simpler. In some cases, it can become much simpler because no
extra PHI-defs are required. This will speed up both splitting and
spilling.
This is only the interface to enable spill modes, no implementation yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@139500 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-12 16:49:21 +00:00
|
|
|
void reset(LiveRangeEdit&, ComplementSpillMode = SM_Partition);
|
2010-07-26 23:44:11 +00:00
|
|
|
|
2010-08-04 22:08:39 +00:00
|
|
|
/// Create a new virtual register and live interval.
|
2011-04-12 18:11:31 +00:00
|
|
|
/// Return the interval index, starting from 1. Interval index 0 is the
|
|
|
|
/// implicit complement interval.
|
|
|
|
unsigned openIntv();
|
|
|
|
|
|
|
|
/// currentIntv - Return the current interval index.
|
|
|
|
unsigned currentIntv() const { return OpenIdx; }
|
|
|
|
|
|
|
|
/// selectIntv - Select a previously opened interval index.
|
|
|
|
void selectIntv(unsigned Idx);
|
2010-07-26 23:44:11 +00:00
|
|
|
|
2011-02-03 17:04:16 +00:00
|
|
|
/// enterIntvBefore - Enter the open interval before the instruction at Idx.
|
|
|
|
/// If the parent interval is not live before Idx, a COPY is not inserted.
|
|
|
|
/// Return the beginning of the new live range.
|
|
|
|
SlotIndex enterIntvBefore(SlotIndex Idx);
|
2010-08-12 17:07:14 +00:00
|
|
|
|
Reapply r134047 now that the world is ready for it.
This patch will sometimes choose live range split points next to
interference instead of always splitting next to a register point. That
means spill code can now appear almost anywhere, and it was necessary
to fix code that didn't expect that.
The difficult places were:
- Between a CALL returning a value on the x87 stack and the
corresponding FpPOP_RETVAL (was FpGET_ST0). Probably also near x87
inline assembly, but that didn't actually show up in testing.
- Between a CALL popping arguments off the stack and the corresponding
ADJCALLSTACKUP.
Both are fixed now. The only place spill code can't appear is after
terminators, see SplitAnalysis::getLastSplitPoint.
Original commit message:
Rewrite RAGreedy::splitAroundRegion, now with cool ASCII art.
This function has to deal with a lot of special cases, and the old
version got it wrong sometimes. In particular, it would sometimes leave
multiple uses in the stack interval in a single block. That causes bad
code with multiple reloads in the same basic block.
The new version handles block entry and exit in a single pass. It first
eliminates all the easy cases, and then goes on to create a local
interval for the blocks with difficult interference. Previously, we
would only create the local interval for completely isolated blocks.
It can happen that the stack interval becomes completely empty because
we could allocate a register in all edge bundles, and the new local
intervals deal with the interference. The empty stack interval is
harmless, but we need to remove a SplitKit assertion that checks for
empty intervals.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134125 91177308-0d34-0410-b5e6-96231b3b80d8
2011-06-30 01:30:39 +00:00
|
|
|
/// enterIntvAfter - Enter the open interval after the instruction at Idx.
|
|
|
|
/// Return the beginning of the new live range.
|
|
|
|
SlotIndex enterIntvAfter(SlotIndex Idx);
|
|
|
|
|
2011-02-03 17:04:16 +00:00
|
|
|
/// enterIntvAtEnd - Enter the open interval at the end of MBB.
|
|
|
|
/// Use the open interval from he inserted copy to the MBB end.
|
|
|
|
/// Return the beginning of the new live range.
|
|
|
|
SlotIndex enterIntvAtEnd(MachineBasicBlock &MBB);
|
2010-07-26 23:44:11 +00:00
|
|
|
|
2011-01-26 00:50:53 +00:00
|
|
|
/// useIntv - indicate that all instructions in MBB should use OpenLI.
|
2010-08-04 22:08:39 +00:00
|
|
|
void useIntv(const MachineBasicBlock &MBB);
|
2010-07-26 23:44:11 +00:00
|
|
|
|
2011-01-26 00:50:53 +00:00
|
|
|
/// useIntv - indicate that all instructions in range should use OpenLI.
|
2010-08-04 22:08:39 +00:00
|
|
|
void useIntv(SlotIndex Start, SlotIndex End);
|
2010-07-26 23:44:11 +00:00
|
|
|
|
2011-02-03 17:04:16 +00:00
|
|
|
/// leaveIntvAfter - Leave the open interval after the instruction at Idx.
|
|
|
|
/// Return the end of the live range.
|
|
|
|
SlotIndex leaveIntvAfter(SlotIndex Idx);
|
2010-08-12 17:07:14 +00:00
|
|
|
|
2011-02-09 23:30:25 +00:00
|
|
|
/// leaveIntvBefore - Leave the open interval before the instruction at Idx.
|
|
|
|
/// Return the end of the live range.
|
|
|
|
SlotIndex leaveIntvBefore(SlotIndex Idx);
|
|
|
|
|
2010-08-04 22:08:39 +00:00
|
|
|
/// leaveIntvAtTop - Leave the interval at the top of MBB.
|
2011-02-03 17:04:16 +00:00
|
|
|
/// Add liveness from the MBB top to the copy.
|
|
|
|
/// Return the end of the live range.
|
|
|
|
SlotIndex leaveIntvAtTop(MachineBasicBlock &MBB);
|
2010-07-26 23:44:11 +00:00
|
|
|
|
2011-02-08 18:50:21 +00:00
|
|
|
/// overlapIntv - Indicate that all instructions in range should use the open
|
|
|
|
/// interval, but also let the complement interval be live.
|
|
|
|
///
|
|
|
|
/// This doubles the register pressure, but is sometimes required to deal with
|
|
|
|
/// register uses after the last valid split point.
|
|
|
|
///
|
|
|
|
/// The Start index should be a return value from a leaveIntv* call, and End
|
|
|
|
/// should be in the same basic block. The parent interval must have the same
|
|
|
|
/// value across the range.
|
|
|
|
///
|
|
|
|
void overlapIntv(SlotIndex Start, SlotIndex End);
|
|
|
|
|
2010-10-08 23:42:21 +00:00
|
|
|
/// finish - after all the new live ranges have been created, compute the
|
|
|
|
/// remaining live range, and rewrite instructions to use the new registers.
|
2011-04-21 18:38:15 +00:00
|
|
|
/// @param LRMap When not null, this vector will map each live range in Edit
|
|
|
|
/// back to the indices returned by openIntv.
|
|
|
|
/// There may be extra indices created by dead code elimination.
|
|
|
|
void finish(SmallVectorImpl<unsigned> *LRMap = 0);
|
2010-07-26 23:44:11 +00:00
|
|
|
|
2011-02-03 06:18:29 +00:00
|
|
|
/// dump - print the current interval maping to dbgs().
|
|
|
|
void dump() const;
|
|
|
|
|
2010-07-26 23:44:11 +00:00
|
|
|
// ===--- High level methods ---===
|
|
|
|
|
2011-04-12 19:32:53 +00:00
|
|
|
/// splitSingleBlock - Split CurLI into a separate live interval around the
|
|
|
|
/// uses in a single block. This is intended to be used as part of a larger
|
|
|
|
/// split, and doesn't call finish().
|
|
|
|
void splitSingleBlock(const SplitAnalysis::BlockInfo &BI);
|
|
|
|
|
2011-07-15 21:47:57 +00:00
|
|
|
/// splitLiveThroughBlock - Split CurLI in the given block such that it
|
|
|
|
/// enters the block in IntvIn and leaves it in IntvOut. There may be uses in
|
|
|
|
/// the block, but they will be ignored when placing split points.
|
|
|
|
///
|
|
|
|
/// @param MBBNum Block number.
|
|
|
|
/// @param IntvIn Interval index entering the block.
|
|
|
|
/// @param LeaveBefore When set, leave IntvIn before this point.
|
|
|
|
/// @param IntvOut Interval index leaving the block.
|
|
|
|
/// @param EnterAfter When set, enter IntvOut after this point.
|
|
|
|
void splitLiveThroughBlock(unsigned MBBNum,
|
|
|
|
unsigned IntvIn, SlotIndex LeaveBefore,
|
|
|
|
unsigned IntvOut, SlotIndex EnterAfter);
|
|
|
|
|
|
|
|
/// splitRegInBlock - Split CurLI in the given block such that it enters the
|
|
|
|
/// block in IntvIn and leaves it on the stack (or not at all). Split points
|
|
|
|
/// are placed in a way that avoids putting uses in the stack interval. This
|
|
|
|
/// may require creating a local interval when there is interference.
|
|
|
|
///
|
|
|
|
/// @param BI Block descriptor.
|
|
|
|
/// @param IntvIn Interval index entering the block. Not 0.
|
|
|
|
/// @param LeaveBefore When set, leave IntvIn before this point.
|
|
|
|
void splitRegInBlock(const SplitAnalysis::BlockInfo &BI,
|
|
|
|
unsigned IntvIn, SlotIndex LeaveBefore);
|
|
|
|
|
|
|
|
/// splitRegOutBlock - Split CurLI in the given block such that it enters the
|
|
|
|
/// block on the stack (or isn't live-in at all) and leaves it in IntvOut.
|
|
|
|
/// Split points are placed to avoid interference and such that the uses are
|
|
|
|
/// not in the stack interval. This may require creating a local interval
|
|
|
|
/// when there is interference.
|
|
|
|
///
|
|
|
|
/// @param BI Block descriptor.
|
|
|
|
/// @param IntvOut Interval index leaving the block.
|
|
|
|
/// @param EnterAfter When set, enter IntvOut after this point.
|
|
|
|
void splitRegOutBlock(const SplitAnalysis::BlockInfo &BI,
|
|
|
|
unsigned IntvOut, SlotIndex EnterAfter);
|
2010-08-13 21:18:48 +00:00
|
|
|
};
|
2010-07-20 15:41:07 +00:00
|
|
|
|
|
|
|
}
|
2011-04-24 15:46:51 +00:00
|
|
|
|
|
|
|
#endif
|