← Back to branch summary

~ubuntu-branches/ubuntu/quantal/llvm-3.1/quantal

« back to all changes in this revision

Viewing changes to lib/CodeGen/LiveRangeEdit.cpp

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2012-04-10 23:38:33 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20120410233833-5ibwguerdnr58six
Tags: 3.1~svn154439-1
* New snapshot release
* Change the soname to match what Debian is expecting
* Clean up the dh_shlibdeps call

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/CodeGen/LiveRangeEdit.cpp
12
12
//===----------------------------------------------------------------------===//
13
13
 
14
14
#define DEBUG_TYPE "regalloc"
15
 
#include "LiveRangeEdit.h"
16
15
#include "VirtRegMap.h"
17
16
#include "llvm/ADT/SetVector.h"
18
17
#include "llvm/ADT/Statistic.h"
19
18
#include "llvm/CodeGen/CalcSpillWeights.h"
20
19
#include "llvm/CodeGen/LiveIntervalAnalysis.h"
 
20
#include "llvm/CodeGen/LiveRangeEdit.h"
21
21
#include "llvm/CodeGen/MachineRegisterInfo.h"
22
22
#include "llvm/Target/TargetInstrInfo.h"
23
23
#include "llvm/Support/Debug.h"
31
31
 
32
32
void LiveRangeEdit::Delegate::anchor() { }
33
33
 
34
 
LiveInterval &LiveRangeEdit::createFrom(unsigned OldReg,
35
 
                                        LiveIntervals &LIS,
36
 
                                        VirtRegMap &VRM) {
37
 
  MachineRegisterInfo &MRI = VRM.getRegInfo();
 
34
LiveInterval &LiveRangeEdit::createFrom(unsigned OldReg) {
38
35
  unsigned VReg = MRI.createVirtualRegister(MRI.getRegClass(OldReg));
39
 
  VRM.grow();
40
 
  VRM.setIsSplitFromReg(VReg, VRM.getOriginal(OldReg));
 
36
  if (VRM) {
 
37
    VRM->grow();
 
38
    VRM->setIsSplitFromReg(VReg, VRM->getOriginal(OldReg));
 
39
  }
41
40
  LiveInterval &LI = LIS.getOrCreateInterval(VReg);
42
41
  newRegs_.push_back(&LI);
43
42
  return LI;
45
44
 
46
45
bool LiveRangeEdit::checkRematerializable(VNInfo *VNI,
47
46
                                          const MachineInstr *DefMI,
48
 
                                          const TargetInstrInfo &tii,
49
47
                                          AliasAnalysis *aa) {
50
48
  assert(DefMI && "Missing instruction");
51
49
  scannedRemattable_ = true;
52
 
  if (!tii.isTriviallyReMaterializable(DefMI, aa))
 
50
  if (!TII.isTriviallyReMaterializable(DefMI, aa))
53
51
    return false;
54
52
  remattable_.insert(VNI);
55
53
  return true;
56
54
}
57
55
 
58
 
void LiveRangeEdit::scanRemattable(LiveIntervals &lis,
59
 
                                   const TargetInstrInfo &tii,
60
 
                                   AliasAnalysis *aa) {
 
56
void LiveRangeEdit::scanRemattable(AliasAnalysis *aa) {
61
57
  for (LiveInterval::vni_iterator I = parent_.vni_begin(),
62
58
       E = parent_.vni_end(); I != E; ++I) {
63
59
    VNInfo *VNI = *I;
64
60
    if (VNI->isUnused())
65
61
      continue;
66
 
    MachineInstr *DefMI = lis.getInstructionFromIndex(VNI->def);
 
62
    MachineInstr *DefMI = LIS.getInstructionFromIndex(VNI->def);
67
63
    if (!DefMI)
68
64
      continue;
69
 
    checkRematerializable(VNI, DefMI, tii, aa);
 
65
    checkRematerializable(VNI, DefMI, aa);
70
66
  }
71
67
  scannedRemattable_ = true;
72
68
}
73
69
 
74
 
bool LiveRangeEdit::anyRematerializable(LiveIntervals &lis,
75
 
                                        const TargetInstrInfo &tii,
76
 
                                        AliasAnalysis *aa) {
 
70
bool LiveRangeEdit::anyRematerializable(AliasAnalysis *aa) {
77
71
  if (!scannedRemattable_)
78
 
    scanRemattable(lis, tii, aa);
 
72
    scanRemattable(aa);
79
73
  return !remattable_.empty();
80
74
}
81
75
 
83
77
/// OrigIdx are also available with the same value at UseIdx.
84
78
bool LiveRangeEdit::allUsesAvailableAt(const MachineInstr *OrigMI,
85
79
                                       SlotIndex OrigIdx,
86
 
                                       SlotIndex UseIdx,
87
 
                                       LiveIntervals &lis) {
 
80
                                       SlotIndex UseIdx) {
88
81
  OrigIdx = OrigIdx.getRegSlot(true);
89
82
  UseIdx = UseIdx.getRegSlot(true);
90
83
  for (unsigned i = 0, e = OrigMI->getNumOperands(); i != e; ++i) {
92
85
    if (!MO.isReg() || !MO.getReg() || MO.isDef())
93
86
      continue;
94
87
    // Reserved registers are OK.
95
 
    if (MO.isUndef() || !lis.hasInterval(MO.getReg()))
 
88
    if (MO.isUndef() || !LIS.hasInterval(MO.getReg()))
96
89
      continue;
97
90
 
98
 
    LiveInterval &li = lis.getInterval(MO.getReg());
 
91
    LiveInterval &li = LIS.getInterval(MO.getReg());
99
92
    const VNInfo *OVNI = li.getVNInfoAt(OrigIdx);
100
93
    if (!OVNI)
101
94
      continue;
107
100
 
108
101
bool LiveRangeEdit::canRematerializeAt(Remat &RM,
109
102
                                       SlotIndex UseIdx,
110
 
                                       bool cheapAsAMove,
111
 
                                       LiveIntervals &lis) {
 
103
                                       bool cheapAsAMove) {
112
104
  assert(scannedRemattable_ && "Call anyRematerializable first");
113
105
 
114
106
  // Use scanRemattable info.
118
110
  // No defining instruction provided.
119
111
  SlotIndex DefIdx;
120
112
  if (RM.OrigMI)
121
 
    DefIdx = lis.getInstructionIndex(RM.OrigMI);
 
113
    DefIdx = LIS.getInstructionIndex(RM.OrigMI);
122
114
  else {
123
115
    DefIdx = RM.ParentVNI->def;
124
 
    RM.OrigMI = lis.getInstructionFromIndex(DefIdx);
 
116
    RM.OrigMI = LIS.getInstructionFromIndex(DefIdx);
125
117
    assert(RM.OrigMI && "No defining instruction for remattable value");
126
118
  }
127
119
 
130
122
    return false;
131
123
 
132
124
  // Verify that all used registers are available with the same values.
133
 
  if (!allUsesAvailableAt(RM.OrigMI, DefIdx, UseIdx, lis))
 
125
  if (!allUsesAvailableAt(RM.OrigMI, DefIdx, UseIdx))
134
126
    return false;
135
127
 
136
128
  return true;
140
132
                                         MachineBasicBlock::iterator MI,
141
133
                                         unsigned DestReg,
142
134
                                         const Remat &RM,
143
 
                                         LiveIntervals &lis,
144
 
                                         const TargetInstrInfo &tii,
145
135
                                         const TargetRegisterInfo &tri,
146
136
                                         bool Late) {
147
137
  assert(RM.OrigMI && "Invalid remat");
148
 
  tii.reMaterialize(MBB, MI, DestReg, 0, RM.OrigMI, tri);
 
138
  TII.reMaterialize(MBB, MI, DestReg, 0, RM.OrigMI, tri);
149
139
  rematted_.insert(RM.ParentVNI);
150
 
  return lis.getSlotIndexes()->insertMachineInstrInMaps(--MI, Late)
 
140
  return LIS.getSlotIndexes()->insertMachineInstrInMaps(--MI, Late)
151
141
           .getRegSlot();
152
142
}
153
143
 
154
 
void LiveRangeEdit::eraseVirtReg(unsigned Reg, LiveIntervals &LIS) {
 
144
void LiveRangeEdit::eraseVirtReg(unsigned Reg) {
155
145
  if (delegate_ && delegate_->LRE_CanEraseVirtReg(Reg))
156
146
    LIS.removeInterval(Reg);
157
147
}
158
148
 
159
149
bool LiveRangeEdit::foldAsLoad(LiveInterval *LI,
160
 
                               SmallVectorImpl<MachineInstr*> &Dead,
161
 
                               MachineRegisterInfo &MRI,
162
 
                               LiveIntervals &LIS,
163
 
                               const TargetInstrInfo &TII) {
 
150
                               SmallVectorImpl<MachineInstr*> &Dead) {
164
151
  MachineInstr *DefMI = 0, *UseMI = 0;
165
152
 
166
153
  // Check that there is a single def and a single use.
206
193
}
207
194
 
208
195
void LiveRangeEdit::eliminateDeadDefs(SmallVectorImpl<MachineInstr*> &Dead,
209
 
                                      LiveIntervals &LIS, VirtRegMap &VRM,
210
 
                                      const TargetInstrInfo &TII,
211
196
                                      ArrayRef<unsigned> RegsBeingSpilled) {
212
197
  SetVector<LiveInterval*,
213
198
            SmallVector<LiveInterval*, 8>,
214
199
            SmallPtrSet<LiveInterval*, 8> > ToShrink;
215
 
  MachineRegisterInfo &MRI = VRM.getRegInfo();
216
200
 
217
201
  for (;;) {
218
202
    // Erase all dead defs.
263
247
            LI.removeValNo(VNI);
264
248
            if (LI.empty()) {
265
249
              ToShrink.remove(&LI);
266
 
              eraseVirtReg(Reg, LIS);
 
250
              eraseVirtReg(Reg);
267
251
            }
268
252
          }
269
253
        }
282
266
    // Shrink just one live interval. Then delete new dead defs.
283
267
    LiveInterval *LI = ToShrink.back();
284
268
    ToShrink.pop_back();
285
 
    if (foldAsLoad(LI, Dead, MRI, LIS, TII))
 
269
    if (foldAsLoad(LI, Dead))
286
270
      continue;
287
271
    if (delegate_)
288
272
      delegate_->LRE_WillShrinkVirtReg(LI->reg);
302
286
    }
303
287
    
304
288
    if (BeingSpilled) continue;
305
 
    
306
289
 
307
290
    // LI may have been separated, create new intervals.
308
291
    LI->RenumberValues(LIS);
311
294
    if (NumComp <= 1)
312
295
      continue;
313
296
    ++NumFracRanges;
314
 
    bool IsOriginal = VRM.getOriginal(LI->reg) == LI->reg;
 
297
    bool IsOriginal = VRM && VRM->getOriginal(LI->reg) == LI->reg;
315
298
    DEBUG(dbgs() << NumComp << " components: " << *LI << '\n');
316
299
    SmallVector<LiveInterval*, 8> Dups(1, LI);
317
300
    for (unsigned i = 1; i != NumComp; ++i) {
318
 
      Dups.push_back(&createFrom(LI->reg, LIS, VRM));
 
301
      Dups.push_back(&createFrom(LI->reg));
319
302
      // If LI is an original interval that hasn't been split yet, make the new
320
303
      // intervals their own originals instead of referring to LI. The original
321
304
      // interval must contain all the split products, and LI doesn't.
322
305
      if (IsOriginal)
323
 
        VRM.setIsSplitFromReg(Dups.back()->reg, 0);
 
306
        VRM->setIsSplitFromReg(Dups.back()->reg, 0);
324
307
      if (delegate_)
325
308
        delegate_->LRE_DidCloneVirtReg(Dups.back()->reg, LI->reg);
326
309
    }
329
312
}
330
313
 
331
314
void LiveRangeEdit::calculateRegClassAndHint(MachineFunction &MF,
332
 
                                             LiveIntervals &LIS,
333
315
                                             const MachineLoopInfo &Loops) {
334
316
  VirtRegAuxInfo VRAI(MF, LIS, Loops);
335
 
  MachineRegisterInfo &MRI = MF.getRegInfo();
336
317
  for (iterator I = begin(), E = end(); I != E; ++I) {
337
318
    LiveInterval &LI = **I;
338
319
    if (MRI.recomputeRegClass(LI.reg, MF.getTarget()))