1 //===---- LiveRangeEdit.h - Basic tools for split and spill -----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // The LiveRangeEdit class represents changes done to a virtual register when it
11 // is spilled or split.
13 // The parent register is never changed. Instead, a number of new virtual
14 // registers are created and added to the newRegs vector.
16 //===----------------------------------------------------------------------===//
18 #ifndef LLVM_CODEGEN_LIVERANGEEDIT_H
19 #define LLVM_CODEGEN_LIVERANGEEDIT_H
21 #include "llvm/CodeGen/LiveInterval.h"
22 #include "llvm/ADT/SmallPtrSet.h"
28 class MachineRegisterInfo;
32 LiveInterval &parent_;
33 SmallVectorImpl<LiveInterval*> &newRegs_;
34 const SmallVectorImpl<LiveInterval*> &uselessRegs_;
36 /// firstNew_ - Index of the first register added to newRegs_.
37 const unsigned firstNew_;
39 /// scannedRemattable_ - true when remattable values have been identified.
40 bool scannedRemattable_;
42 /// remattable_ - Values defined by remattable instructions as identified by
43 /// tii.isTriviallyReMaterializable().
44 SmallPtrSet<VNInfo*,4> remattable_;
46 /// rematted_ - Values that were actually rematted, and so need to have their
47 /// live range trimmed or entirely removed.
48 SmallPtrSet<VNInfo*,4> rematted_;
50 /// scanRemattable - Identify the parent_ values that may rematerialize.
51 void scanRemattable(LiveIntervals &lis,
52 const TargetInstrInfo &tii,
55 /// allUsesAvailableAt - Return true if all registers used by OrigMI at
56 /// OrigIdx are also available with the same value at UseIdx.
57 bool allUsesAvailableAt(const MachineInstr *OrigMI, SlotIndex OrigIdx,
58 SlotIndex UseIdx, LiveIntervals &lis);
61 /// Create a LiveRangeEdit for breaking down parent into smaller pieces.
62 /// @param parent The register being spilled or split.
63 /// @param newRegs List to receive any new registers created. This needn't be
64 /// empty initially, any existing registers are ignored.
65 /// @param uselessRegs List of registers that can't be used when
66 /// rematerializing values because they are about to be removed.
67 LiveRangeEdit(LiveInterval &parent,
68 SmallVectorImpl<LiveInterval*> &newRegs,
69 const SmallVectorImpl<LiveInterval*> &uselessRegs)
70 : parent_(parent), newRegs_(newRegs), uselessRegs_(uselessRegs),
71 firstNew_(newRegs.size()), scannedRemattable_(false) {}
73 LiveInterval &getParent() const { return parent_; }
74 unsigned getReg() const { return parent_.reg; }
76 /// Iterator for accessing the new registers added by this edit.
77 typedef SmallVectorImpl<LiveInterval*>::const_iterator iterator;
78 iterator begin() const { return newRegs_.begin()+firstNew_; }
79 iterator end() const { return newRegs_.end(); }
81 /// assignStackSlot - Ensure a stack slot is assigned to parent.
82 /// @return the assigned stack slot number.
83 int assignStackSlot(VirtRegMap&);
85 /// create - Create a new register with the same class and stack slot as
87 LiveInterval &create(MachineRegisterInfo&, LiveIntervals&, VirtRegMap&);
89 /// anyRematerializable - Return true if any parent values may be
91 /// This function must be called before ny rematerialization is attempted.
92 bool anyRematerializable(LiveIntervals&, const TargetInstrInfo&,
95 /// Remat - Information needed to rematerialize at a specific location.
97 VNInfo *ParentVNI; // parent_'s value at the remat location.
98 MachineInstr *OrigMI; // Instruction defining ParentVNI.
99 operator bool() const { return OrigMI; }
102 /// canRematerializeAt - Determine if ParentVNI can be rematerialized at
103 /// UseIdx. It is assumed that parent_.getVNINfoAt(UseIdx) == ParentVNI.
104 /// When cheapAsAMove is set, only cheap remats are allowed.
105 Remat canRematerializeAt(VNInfo *ParentVNI,
110 /// rematerializeAt - Rematerialize RM.ParentVNI into DestReg by inserting an
111 /// instruction into MBB before MI. The new instruction is mapped, but
112 /// liveness is not updated.
113 /// Return the SlotIndex of the new instruction.
114 SlotIndex rematerializeAt(MachineBasicBlock &MBB,
115 MachineBasicBlock::iterator MI,
119 const TargetInstrInfo&,
120 const TargetRegisterInfo&);
122 /// didRematerialize - Return true if ParentVNI was rematerialized anywhere.
123 bool didRematerialize(VNInfo *ParentVNI) const {
124 return rematted_.count(ParentVNI);