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