SplitKit.h revision 521a453721aeefbb6783b6acc8ea36b3c18b4931
1//===-------- SplitKit.cpp - Toolkit for splitting live ranges --*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file contains the SplitAnalysis class as well as mutator functions for 11// live range splitting. 12// 13//===----------------------------------------------------------------------===// 14 15#include "llvm/ADT/SmallPtrSet.h" 16#include "llvm/ADT/DenseMap.h" 17#include "llvm/CodeGen/SlotIndexes.h" 18 19namespace llvm { 20 21class LiveInterval; 22class LiveIntervals; 23class LiveRangeEdit; 24class MachineInstr; 25class MachineLoop; 26class MachineLoopInfo; 27class MachineRegisterInfo; 28class TargetInstrInfo; 29class TargetRegisterInfo; 30class VirtRegMap; 31class VNInfo; 32class raw_ostream; 33 34/// At some point we should just include MachineDominators.h: 35class MachineDominatorTree; 36template <class NodeT> class DomTreeNodeBase; 37typedef DomTreeNodeBase<MachineBasicBlock> MachineDomTreeNode; 38 39/// SplitAnalysis - Analyze a LiveInterval, looking for live range splitting 40/// opportunities. 41class SplitAnalysis { 42public: 43 const MachineFunction &mf_; 44 const LiveIntervals &lis_; 45 const MachineLoopInfo &loops_; 46 const TargetInstrInfo &tii_; 47 48 // Instructions using the the current register. 49 typedef SmallPtrSet<const MachineInstr*, 16> InstrPtrSet; 50 InstrPtrSet usingInstrs_; 51 52 // The number of instructions using curli in each basic block. 53 typedef DenseMap<const MachineBasicBlock*, unsigned> BlockCountMap; 54 BlockCountMap usingBlocks_; 55 56 // The number of basic block using curli in each loop. 57 typedef DenseMap<const MachineLoop*, unsigned> LoopCountMap; 58 LoopCountMap usingLoops_; 59 60private: 61 // Current live interval. 62 const LiveInterval *curli_; 63 64 // Sumarize statistics by counting instructions using curli_. 65 void analyzeUses(); 66 67 /// canAnalyzeBranch - Return true if MBB ends in a branch that can be 68 /// analyzed. 69 bool canAnalyzeBranch(const MachineBasicBlock *MBB); 70 71public: 72 SplitAnalysis(const MachineFunction &mf, const LiveIntervals &lis, 73 const MachineLoopInfo &mli); 74 75 /// analyze - set curli to the specified interval, and analyze how it may be 76 /// split. 77 void analyze(const LiveInterval *li); 78 79 /// clear - clear all data structures so SplitAnalysis is ready to analyze a 80 /// new interval. 81 void clear(); 82 83 typedef SmallPtrSet<const MachineBasicBlock*, 16> BlockPtrSet; 84 typedef SmallPtrSet<const MachineLoop*, 16> LoopPtrSet; 85 86 // Print a set of blocks with use counts. 87 void print(const BlockPtrSet&, raw_ostream&) const; 88 89 // Sets of basic blocks surrounding a machine loop. 90 struct LoopBlocks { 91 BlockPtrSet Loop; // Blocks in the loop. 92 BlockPtrSet Preds; // Loop predecessor blocks. 93 BlockPtrSet Exits; // Loop exit blocks. 94 95 void clear() { 96 Loop.clear(); 97 Preds.clear(); 98 Exits.clear(); 99 } 100 }; 101 102 // Print loop blocks with use counts. 103 void print(const LoopBlocks&, raw_ostream&) const; 104 105 // Calculate the block sets surrounding the loop. 106 void getLoopBlocks(const MachineLoop *Loop, LoopBlocks &Blocks); 107 108 /// LoopPeripheralUse - how is a variable used in and around a loop? 109 /// Peripheral blocks are the loop predecessors and exit blocks. 110 enum LoopPeripheralUse { 111 ContainedInLoop, // All uses are inside the loop. 112 SinglePeripheral, // At most one instruction per peripheral block. 113 MultiPeripheral, // Multiple instructions in some peripheral blocks. 114 OutsideLoop // Uses outside loop periphery. 115 }; 116 117 /// analyzeLoopPeripheralUse - Return an enum describing how curli_ is used in 118 /// and around the Loop. 119 LoopPeripheralUse analyzeLoopPeripheralUse(const LoopBlocks&); 120 121 /// getCriticalExits - It may be necessary to partially break critical edges 122 /// leaving the loop if an exit block has phi uses of curli. Collect the exit 123 /// blocks that need special treatment into CriticalExits. 124 void getCriticalExits(const LoopBlocks &Blocks, BlockPtrSet &CriticalExits); 125 126 /// canSplitCriticalExits - Return true if it is possible to insert new exit 127 /// blocks before the blocks in CriticalExits. 128 bool canSplitCriticalExits(const LoopBlocks &Blocks, 129 BlockPtrSet &CriticalExits); 130 131 /// getCriticalPreds - Get the set of loop predecessors with critical edges to 132 /// blocks outside the loop that have curli live in. We don't have to break 133 /// these edges, but they do require special treatment. 134 void getCriticalPreds(const LoopBlocks &Blocks, BlockPtrSet &CriticalPreds); 135 136 /// getSplitLoops - Get the set of loops that have curli uses and would be 137 /// profitable to split. 138 void getSplitLoops(LoopPtrSet&); 139 140 /// getBestSplitLoop - Return the loop where curli may best be split to a 141 /// separate register, or NULL. 142 const MachineLoop *getBestSplitLoop(); 143 144 /// getMultiUseBlocks - Add basic blocks to Blocks that may benefit from 145 /// having curli split to a new live interval. Return true if Blocks can be 146 /// passed to SplitEditor::splitSingleBlocks. 147 bool getMultiUseBlocks(BlockPtrSet &Blocks); 148 149 /// getBlockForInsideSplit - If curli is contained inside a single basic block, 150 /// and it wou pay to subdivide the interval inside that block, return it. 151 /// Otherwise return NULL. The returned block can be passed to 152 /// SplitEditor::splitInsideBlock. 153 const MachineBasicBlock *getBlockForInsideSplit(); 154}; 155 156 157/// LiveIntervalMap - Map values from a large LiveInterval into a small 158/// interval that is a subset. Insert phi-def values as needed. This class is 159/// used by SplitEditor to create new smaller LiveIntervals. 160/// 161/// parentli_ is the larger interval, li_ is the subset interval. Every value 162/// in li_ corresponds to exactly one value in parentli_, and the live range 163/// of the value is contained within the live range of the parentli_ value. 164/// Values in parentli_ may map to any number of openli_ values, including 0. 165class LiveIntervalMap { 166 LiveIntervals &lis_; 167 MachineDominatorTree &mdt_; 168 169 // The parent interval is never changed. 170 const LiveInterval &parentli_; 171 172 // The child interval's values are fully contained inside parentli_ values. 173 LiveInterval *li_; 174 175 typedef DenseMap<const VNInfo*, VNInfo*> ValueMap; 176 177 // Map parentli_ values to simple values in li_ that are defined at the same 178 // SlotIndex, or NULL for parentli_ values that have complex li_ defs. 179 // Note there is a difference between values mapping to NULL (complex), and 180 // values not present (unknown/unmapped). 181 ValueMap valueMap_; 182 183 typedef std::pair<VNInfo*, MachineDomTreeNode*> LiveOutPair; 184 typedef DenseMap<MachineBasicBlock*,LiveOutPair> LiveOutMap; 185 186 // liveOutCache_ - Map each basic block where li_ is live out to the live-out 187 // value and its defining block. One of these conditions shall be true: 188 // 189 // 1. !liveOutCache_.count(MBB) 190 // 2. liveOutCache_[MBB].second.getNode() == MBB 191 // 3. forall P in preds(MBB): liveOutCache_[P] == liveOutCache_[MBB] 192 // 193 // This is only a cache, the values can be computed as: 194 // 195 // VNI = li_->getVNInfoAt(lis_.getMBBEndIdx(MBB)) 196 // Node = mbt_[lis_.getMBBFromIndex(VNI->def)] 197 // 198 // The cache is also used as a visiteed set by mapValue(). 199 LiveOutMap liveOutCache_; 200 201public: 202 LiveIntervalMap(LiveIntervals &lis, 203 MachineDominatorTree &mdt, 204 const LiveInterval &parentli) 205 : lis_(lis), mdt_(mdt), parentli_(parentli), li_(0) {} 206 207 /// reset - clear all data structures and start a new live interval. 208 void reset(LiveInterval *); 209 210 /// getLI - return the current live interval. 211 LiveInterval *getLI() const { return li_; } 212 213 /// defValue - define a value in li_ from the parentli_ value VNI and Idx. 214 /// Idx does not have to be ParentVNI->def, but it must be contained within 215 /// ParentVNI's live range in parentli_. 216 /// Return the new li_ value. 217 VNInfo *defValue(const VNInfo *ParentVNI, SlotIndex Idx); 218 219 /// mapValue - map ParentVNI to the corresponding li_ value at Idx. It is 220 /// assumed that ParentVNI is live at Idx. 221 /// If ParentVNI has not been defined by defValue, it is assumed that 222 /// ParentVNI->def dominates Idx. 223 /// If ParentVNI has been defined by defValue one or more times, a value that 224 /// dominates Idx will be returned. This may require creating extra phi-def 225 /// values and adding live ranges to li_. 226 /// If simple is not NULL, *simple will indicate if ParentVNI is a simply 227 /// mapped value. 228 VNInfo *mapValue(const VNInfo *ParentVNI, SlotIndex Idx, bool *simple = 0); 229 230 // extendTo - Find the last li_ value defined in MBB at or before Idx. The 231 // parentli is assumed to be live at Idx. Extend the live range to include 232 // Idx. Return the found VNInfo, or NULL. 233 VNInfo *extendTo(const MachineBasicBlock *MBB, SlotIndex Idx); 234 235 /// isMapped - Return true is ParentVNI is a known mapped value. It may be a 236 /// simple 1-1 mapping or a complex mapping to later defs. 237 bool isMapped(const VNInfo *ParentVNI) const { 238 return valueMap_.count(ParentVNI); 239 } 240 241 /// isComplexMapped - Return true if ParentVNI has received new definitions 242 /// with defValue. 243 bool isComplexMapped(const VNInfo *ParentVNI) const; 244 245 // addSimpleRange - Add a simple range from parentli_ to li_. 246 // ParentVNI must be live in the [Start;End) interval. 247 void addSimpleRange(SlotIndex Start, SlotIndex End, const VNInfo *ParentVNI); 248 249 /// addRange - Add live ranges to li_ where [Start;End) intersects parentli_. 250 /// All needed values whose def is not inside [Start;End) must be defined 251 /// beforehand so mapValue will work. 252 void addRange(SlotIndex Start, SlotIndex End); 253}; 254 255 256/// SplitEditor - Edit machine code and LiveIntervals for live range 257/// splitting. 258/// 259/// - Create a SplitEditor from a SplitAnalysis. 260/// - Start a new live interval with openIntv. 261/// - Mark the places where the new interval is entered using enterIntv* 262/// - Mark the ranges where the new interval is used with useIntv* 263/// - Mark the places where the interval is exited with exitIntv*. 264/// - Finish the current interval with closeIntv and repeat from 2. 265/// - Rewrite instructions with finish(). 266/// 267class SplitEditor { 268 SplitAnalysis &sa_; 269 LiveIntervals &lis_; 270 VirtRegMap &vrm_; 271 MachineRegisterInfo &mri_; 272 const TargetInstrInfo &tii_; 273 const TargetRegisterInfo &tri_; 274 275 /// edit_ - The current parent register and new intervals created. 276 LiveRangeEdit &edit_; 277 278 /// dupli_ - Created as a copy of curli_, ranges are carved out as new 279 /// intervals get added through openIntv / closeIntv. This is used to avoid 280 /// editing curli_. 281 LiveIntervalMap dupli_; 282 283 /// Currently open LiveInterval. 284 LiveIntervalMap openli_; 285 286 /// defFromParent - Define Reg from ParentVNI at UseIdx using either 287 /// rematerialization or a COPY from parent. Return the new value. 288 VNInfo *defFromParent(LiveIntervalMap &Reg, 289 VNInfo *ParentVNI, 290 SlotIndex UseIdx, 291 MachineBasicBlock &MBB, 292 MachineBasicBlock::iterator I); 293 294 /// intervalsLiveAt - Return true if any member of intervals_ is live at Idx. 295 bool intervalsLiveAt(SlotIndex Idx) const; 296 297 /// Values in curli whose live range has been truncated when entering an open 298 /// li. 299 SmallPtrSet<const VNInfo*, 8> truncatedValues; 300 301 /// addTruncSimpleRange - Add the given simple range to dupli_ after 302 /// truncating any overlap with intervals_. 303 void addTruncSimpleRange(SlotIndex Start, SlotIndex End, VNInfo *VNI); 304 305 /// criticalPreds_ - Set of basic blocks where both dupli and openli should be 306 /// live out because of a critical edge. 307 SplitAnalysis::BlockPtrSet criticalPreds_; 308 309 /// computeRemainder - Compute the dupli liveness as the complement of all the 310 /// new intervals. 311 void computeRemainder(); 312 313 /// rewrite - Rewrite all uses of reg to use the new registers. 314 void rewrite(unsigned reg); 315 316public: 317 /// Create a new SplitEditor for editing the LiveInterval analyzed by SA. 318 /// Newly created intervals will be appended to newIntervals. 319 SplitEditor(SplitAnalysis &SA, LiveIntervals&, VirtRegMap&, 320 MachineDominatorTree&, LiveRangeEdit&); 321 322 /// getAnalysis - Get the corresponding analysis. 323 SplitAnalysis &getAnalysis() { return sa_; } 324 325 /// Create a new virtual register and live interval. 326 void openIntv(); 327 328 /// enterIntvBefore - Enter openli before the instruction at Idx. If curli is 329 /// not live before Idx, a COPY is not inserted. 330 void enterIntvBefore(SlotIndex Idx); 331 332 /// enterIntvAtEnd - Enter openli at the end of MBB. 333 void enterIntvAtEnd(MachineBasicBlock &MBB); 334 335 /// useIntv - indicate that all instructions in MBB should use openli. 336 void useIntv(const MachineBasicBlock &MBB); 337 338 /// useIntv - indicate that all instructions in range should use openli. 339 void useIntv(SlotIndex Start, SlotIndex End); 340 341 /// leaveIntvAfter - Leave openli after the instruction at Idx. 342 void leaveIntvAfter(SlotIndex Idx); 343 344 /// leaveIntvAtTop - Leave the interval at the top of MBB. 345 /// Currently, only one value can leave the interval. 346 void leaveIntvAtTop(MachineBasicBlock &MBB); 347 348 /// closeIntv - Indicate that we are done editing the currently open 349 /// LiveInterval, and ranges can be trimmed. 350 void closeIntv(); 351 352 /// finish - after all the new live ranges have been created, compute the 353 /// remaining live range, and rewrite instructions to use the new registers. 354 void finish(); 355 356 // ===--- High level methods ---=== 357 358 /// splitAroundLoop - Split curli into a separate live interval inside 359 /// the loop. 360 void splitAroundLoop(const MachineLoop*); 361 362 /// splitSingleBlocks - Split curli into a separate live interval inside each 363 /// basic block in Blocks. 364 void splitSingleBlocks(const SplitAnalysis::BlockPtrSet &Blocks); 365 366 /// splitInsideBlock - Split curli into multiple intervals inside MBB. 367 void splitInsideBlock(const MachineBasicBlock *); 368}; 369 370} 371