← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/CodeGen/RegisterScavenging.h

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm/CodeGen/RegisterScavenging.h
1
 
//===-- RegisterScavenging.h - Machine register scavenging ------*- 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 declares the machine register scavenger class. It can provide
11
 
// information such as unused register at any point in a machine basic block.
12
 
// It also provides a mechanism to make registers availbale by evicting them
13
 
// to spill slots.
14
 
//
15
 
//===----------------------------------------------------------------------===//
16
 
 
17
 
#ifndef LLVM_CODEGEN_REGISTER_SCAVENGING_H
18
 
#define LLVM_CODEGEN_REGISTER_SCAVENGING_H
19
 
 
20
 
#include "llvm/CodeGen/MachineBasicBlock.h"
21
 
#include "llvm/ADT/BitVector.h"
22
 
 
23
 
namespace llvm {
24
 
 
25
 
class MachineRegisterInfo;
26
 
class TargetRegisterInfo;
27
 
class TargetInstrInfo;
28
 
class TargetRegisterClass;
29
 
 
30
 
class RegScavenger {
31
 
  const TargetRegisterInfo *TRI;
32
 
  const TargetInstrInfo *TII;
33
 
  MachineRegisterInfo* MRI;
34
 
  MachineBasicBlock *MBB;
35
 
  MachineBasicBlock::iterator MBBI;
36
 
  unsigned NumPhysRegs;
37
 
 
38
 
  /// Tracking - True if RegScavenger is currently tracking the liveness of 
39
 
  /// registers.
40
 
  bool Tracking;
41
 
 
42
 
  /// ScavengingFrameIndex - Special spill slot used for scavenging a register
43
 
  /// post register allocation.
44
 
  int ScavengingFrameIndex;
45
 
 
46
 
  /// ScavengedReg - If none zero, the specific register is currently being
47
 
  /// scavenged. That is, it is spilled to the special scavenging stack slot.
48
 
  unsigned ScavengedReg;
49
 
 
50
 
  /// ScavengedRC - Register class of the scavenged register.
51
 
  ///
52
 
  const TargetRegisterClass *ScavengedRC;
53
 
 
54
 
  /// ScavengeRestore - Instruction that restores the scavenged register from
55
 
  /// stack.
56
 
  const MachineInstr *ScavengeRestore;
57
 
 
58
 
  /// CalleeSavedrRegs - A bitvector of callee saved registers for the target.
59
 
  ///
60
 
  BitVector CalleeSavedRegs;
61
 
 
62
 
  /// ReservedRegs - A bitvector of reserved registers.
63
 
  ///
64
 
  BitVector ReservedRegs;
65
 
 
66
 
  /// RegsAvailable - The current state of all the physical registers immediately
67
 
  /// before MBBI. One bit per physical register. If bit is set that means it's
68
 
  /// available, unset means the register is currently being used.
69
 
  BitVector RegsAvailable;
70
 
 
71
 
public:
72
 
  RegScavenger()
73
 
    : MBB(NULL), NumPhysRegs(0), Tracking(false),
74
 
      ScavengingFrameIndex(-1), ScavengedReg(0), ScavengedRC(NULL) {}
75
 
 
76
 
  /// enterBasicBlock - Start tracking liveness from the begin of the specific
77
 
  /// basic block.
78
 
  void enterBasicBlock(MachineBasicBlock *mbb);
79
 
 
80
 
  /// initRegState - allow resetting register state info for multiple
81
 
  /// passes over/within the same function.
82
 
  void initRegState();
83
 
 
84
 
  /// forward - Move the internal MBB iterator and update register states.
85
 
  void forward();
86
 
 
87
 
  /// forward - Move the internal MBB iterator and update register states until
88
 
  /// it has processed the specific iterator.
89
 
  void forward(MachineBasicBlock::iterator I) {
90
 
    if (!Tracking && MBB->begin() != I) forward();
91
 
    while (MBBI != I) forward();
92
 
  }
93
 
 
94
 
  /// skipTo - Move the internal MBB iterator but do not update register states.
95
 
  ///
96
 
  void skipTo(MachineBasicBlock::iterator I) { MBBI = I; }
97
 
 
98
 
  /// getRegsUsed - return all registers currently in use in used.
99
 
  void getRegsUsed(BitVector &used, bool includeReserved);
100
 
 
101
 
  /// getRegsAvailable - Return all available registers in the register class
102
 
  /// in Mask.
103
 
  void getRegsAvailable(const TargetRegisterClass *RC, BitVector &Mask);
104
 
 
105
 
  /// FindUnusedReg - Find a unused register of the specified register class.
106
 
  /// Return 0 if none is found.
107
 
  unsigned FindUnusedReg(const TargetRegisterClass *RegClass) const;
108
 
 
109
 
  /// setScavengingFrameIndex / getScavengingFrameIndex - accessor and setter of
110
 
  /// ScavengingFrameIndex.
111
 
  void setScavengingFrameIndex(int FI) { ScavengingFrameIndex = FI; }
112
 
  int getScavengingFrameIndex() const { return ScavengingFrameIndex; }
113
 
 
114
 
  /// scavengeRegister - Make a register of the specific register class
115
 
  /// available and do the appropriate bookkeeping. SPAdj is the stack
116
 
  /// adjustment due to call frame, it's passed along to eliminateFrameIndex().
117
 
  /// Returns the scavenged register.
118
 
  unsigned scavengeRegister(const TargetRegisterClass *RegClass,
119
 
                            MachineBasicBlock::iterator I, int SPAdj);
120
 
  unsigned scavengeRegister(const TargetRegisterClass *RegClass, int SPAdj) {
121
 
    return scavengeRegister(RegClass, MBBI, SPAdj);
122
 
  }
123
 
 
124
 
  /// setUsed - Tell the scavenger a register is used.
125
 
  ///
126
 
  void setUsed(unsigned Reg);
127
 
private:
128
 
  /// isReserved - Returns true if a register is reserved. It is never "unused".
129
 
  bool isReserved(unsigned Reg) const { return ReservedRegs.test(Reg); }
130
 
 
131
 
  /// isUsed / isUnused - Test if a register is currently being used.
132
 
  ///
133
 
  bool isUsed(unsigned Reg) const   { return !RegsAvailable.test(Reg); }
134
 
  bool isUnused(unsigned Reg) const { return RegsAvailable.test(Reg); }
135
 
 
136
 
  /// isAliasUsed - Is Reg or an alias currently in use?
137
 
  bool isAliasUsed(unsigned Reg) const;
138
 
 
139
 
  /// setUsed / setUnused - Mark the state of one or a number of registers.
140
 
  ///
141
 
  void setUsed(BitVector &Regs) {
142
 
    RegsAvailable &= ~Regs;
143
 
  }
144
 
  void setUnused(BitVector &Regs) {
145
 
    RegsAvailable |= Regs;
146
 
  }
147
 
 
148
 
  /// Add Reg and all its sub-registers to BV.
149
 
  void addRegWithSubRegs(BitVector &BV, unsigned Reg);
150
 
 
151
 
  /// Add Reg and its aliases to BV.
152
 
  void addRegWithAliases(BitVector &BV, unsigned Reg);
153
 
 
154
 
  /// findSurvivorReg - Return the candidate register that is unused for the
155
 
  /// longest after StartMI. UseMI is set to the instruction where the search
156
 
  /// stopped.
157
 
  ///
158
 
  /// No more than InstrLimit instructions are inspected.
159
 
  unsigned findSurvivorReg(MachineBasicBlock::iterator StartMI,
160
 
                           BitVector &Candidates,
161
 
                           unsigned InstrLimit,
162
 
                           MachineBasicBlock::iterator &UseMI);
163
 
 
164
 
};
165
 
 
166
 
} // End llvm namespace
167
 
 
168
 
#endif