← Back to branch summary

~ubuntu-branches/ubuntu/maverick/clamav/maverick-backports

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/Target/ARM/ARMMachineFunctionInfo.h

  • Committer: Bazaar Package Importer
  • Author(s): Stephen Gran, Stephen Gran, Michael Tautschnig
  • Date: 2010-04-26 21:41:18 UTC
  • mfrom: (2.1.6 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100426214118-i6lo606wnh7ywfj6
Tags: 0.96+dfsg-4
http://bugs.debian.org/579271
http://bugs.debian.org/579068
[ Stephen Gran ]
* Fixed typo in clamav-milter's postinst

[ Michael Tautschnig ]
* Fixed typo in clamav-freshclam's postinst (closes: #579271)
* Debconf translation updates
  - Portuguese (closes: #579068)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/Target/ARM/ARMMachineFunctionInfo.h
 
1
//====- ARMMachineFuctionInfo.h - ARM machine function info -----*- 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 ARM-specific per-machine-function information.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#ifndef ARMMACHINEFUNCTIONINFO_H
 
15
#define ARMMACHINEFUNCTIONINFO_H
 
16
 
 
17
#include "ARMSubtarget.h"
 
18
#include "llvm/CodeGen/MachineFunction.h"
 
19
#include "llvm/Target/TargetRegisterInfo.h"
 
20
#include "llvm/Target/TargetMachine.h"
 
21
#include "llvm/ADT/BitVector.h"
 
22
 
 
23
namespace llvm {
 
24
 
 
25
/// ARMFunctionInfo - This class is derived from MachineFunction private
 
26
/// ARM target-specific information for each MachineFunction.
 
27
class ARMFunctionInfo : public MachineFunctionInfo {
 
28
 
 
29
  /// isThumb - True if this function is compiled under Thumb mode.
 
30
  /// Used to initialized Align, so must precede it.
 
31
  bool isThumb;
 
32
 
 
33
  /// hasThumb2 - True if the target architecture supports Thumb2. Do not use
 
34
  /// to determine if function is compiled under Thumb mode, for that use
 
35
  /// 'isThumb'.
 
36
  bool hasThumb2;
 
37
 
 
38
  /// VarArgsRegSaveSize - Size of the register save area for vararg functions.
 
39
  ///
 
40
  unsigned VarArgsRegSaveSize;
 
41
 
 
42
  /// HasStackFrame - True if this function has a stack frame. Set by
 
43
  /// processFunctionBeforeCalleeSavedScan().
 
44
  bool HasStackFrame;
 
45
 
 
46
  /// LRSpilledForFarJump - True if the LR register has been for spilled to
 
47
  /// enable far jump.
 
48
  bool LRSpilledForFarJump;
 
49
 
 
50
  /// FramePtrSpillOffset - If HasStackFrame, this records the frame pointer
 
51
  /// spill stack offset.
 
52
  unsigned FramePtrSpillOffset;
 
53
 
 
54
  /// GPRCS1Offset, GPRCS2Offset, DPRCSOffset - Starting offset of callee saved
 
55
  /// register spills areas. For Mac OS X:
 
56
  ///
 
57
  /// GPR callee-saved (1) : r4, r5, r6, r7, lr
 
58
  /// --------------------------------------------
 
59
  /// GPR callee-saved (2) : r8, r10, r11
 
60
  /// --------------------------------------------
 
61
  /// DPR callee-saved : d8 - d15
 
62
  unsigned GPRCS1Offset;
 
63
  unsigned GPRCS2Offset;
 
64
  unsigned DPRCSOffset;
 
65
 
 
66
  /// GPRCS1Size, GPRCS2Size, DPRCSSize - Sizes of callee saved register spills
 
67
  /// areas.
 
68
  unsigned GPRCS1Size;
 
69
  unsigned GPRCS2Size;
 
70
  unsigned DPRCSSize;
 
71
 
 
72
  /// GPRCS1Frames, GPRCS2Frames, DPRCSFrames - Keeps track of frame indices
 
73
  /// which belong to these spill areas.
 
74
  BitVector GPRCS1Frames;
 
75
  BitVector GPRCS2Frames;
 
76
  BitVector DPRCSFrames;
 
77
 
 
78
  /// SpilledCSRegs - A BitVector mask of all spilled callee-saved registers.
 
79
  ///
 
80
  BitVector SpilledCSRegs;
 
81
 
 
82
  /// JumpTableUId - Unique id for jumptables.
 
83
  ///
 
84
  unsigned JumpTableUId;
 
85
 
 
86
  unsigned ConstPoolEntryUId;
 
87
 
 
88
public:
 
89
  ARMFunctionInfo() :
 
90
    isThumb(false),
 
91
    hasThumb2(false),
 
92
    VarArgsRegSaveSize(0), HasStackFrame(false),
 
93
    LRSpilledForFarJump(false),
 
94
    FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0),
 
95
    GPRCS1Size(0), GPRCS2Size(0), DPRCSSize(0),
 
96
    GPRCS1Frames(0), GPRCS2Frames(0), DPRCSFrames(0),
 
97
    JumpTableUId(0), ConstPoolEntryUId(0) {}
 
98
 
 
99
  explicit ARMFunctionInfo(MachineFunction &MF) :
 
100
    isThumb(MF.getTarget().getSubtarget<ARMSubtarget>().isThumb()),
 
101
    hasThumb2(MF.getTarget().getSubtarget<ARMSubtarget>().hasThumb2()),
 
102
    VarArgsRegSaveSize(0), HasStackFrame(false),
 
103
    LRSpilledForFarJump(false),
 
104
    FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0),
 
105
    GPRCS1Size(0), GPRCS2Size(0), DPRCSSize(0),
 
106
    GPRCS1Frames(32), GPRCS2Frames(32), DPRCSFrames(32),
 
107
    SpilledCSRegs(MF.getTarget().getRegisterInfo()->getNumRegs()),
 
108
    JumpTableUId(0), ConstPoolEntryUId(0) {}
 
109
 
 
110
  bool isThumbFunction() const { return isThumb; }
 
111
  bool isThumb1OnlyFunction() const { return isThumb && !hasThumb2; }
 
112
  bool isThumb2Function() const { return isThumb && hasThumb2; }
 
113
 
 
114
  unsigned getVarArgsRegSaveSize() const { return VarArgsRegSaveSize; }
 
115
  void setVarArgsRegSaveSize(unsigned s) { VarArgsRegSaveSize = s; }
 
116
 
 
117
  bool hasStackFrame() const { return HasStackFrame; }
 
118
  void setHasStackFrame(bool s) { HasStackFrame = s; }
 
119
 
 
120
  bool isLRSpilledForFarJump() const { return LRSpilledForFarJump; }
 
121
  void setLRIsSpilledForFarJump(bool s) { LRSpilledForFarJump = s; }
 
122
 
 
123
  unsigned getFramePtrSpillOffset() const { return FramePtrSpillOffset; }
 
124
  void setFramePtrSpillOffset(unsigned o) { FramePtrSpillOffset = o; }
 
125
 
 
126
  unsigned getGPRCalleeSavedArea1Offset() const { return GPRCS1Offset; }
 
127
  unsigned getGPRCalleeSavedArea2Offset() const { return GPRCS2Offset; }
 
128
  unsigned getDPRCalleeSavedAreaOffset()  const { return DPRCSOffset; }
 
129
 
 
130
  void setGPRCalleeSavedArea1Offset(unsigned o) { GPRCS1Offset = o; }
 
131
  void setGPRCalleeSavedArea2Offset(unsigned o) { GPRCS2Offset = o; }
 
132
  void setDPRCalleeSavedAreaOffset(unsigned o)  { DPRCSOffset = o; }
 
133
 
 
134
  unsigned getGPRCalleeSavedArea1Size() const { return GPRCS1Size; }
 
135
  unsigned getGPRCalleeSavedArea2Size() const { return GPRCS2Size; }
 
136
  unsigned getDPRCalleeSavedAreaSize()  const { return DPRCSSize; }
 
137
 
 
138
  void setGPRCalleeSavedArea1Size(unsigned s) { GPRCS1Size = s; }
 
139
  void setGPRCalleeSavedArea2Size(unsigned s) { GPRCS2Size = s; }
 
140
  void setDPRCalleeSavedAreaSize(unsigned s)  { DPRCSSize = s; }
 
141
 
 
142
  bool isGPRCalleeSavedArea1Frame(int fi) const {
 
143
    if (fi < 0 || fi >= (int)GPRCS1Frames.size())
 
144
      return false;
 
145
    return GPRCS1Frames[fi];
 
146
  }
 
147
  bool isGPRCalleeSavedArea2Frame(int fi) const {
 
148
    if (fi < 0 || fi >= (int)GPRCS2Frames.size())
 
149
      return false;
 
150
    return GPRCS2Frames[fi];
 
151
  }
 
152
  bool isDPRCalleeSavedAreaFrame(int fi) const {
 
153
    if (fi < 0 || fi >= (int)DPRCSFrames.size())
 
154
      return false;
 
155
    return DPRCSFrames[fi];
 
156
  }
 
157
 
 
158
  void addGPRCalleeSavedArea1Frame(int fi) {
 
159
    if (fi >= 0) {
 
160
      int Size = GPRCS1Frames.size();
 
161
      if (fi >= Size) {
 
162
        Size *= 2;
 
163
        if (fi >= Size)
 
164
          Size = fi+1;
 
165
        GPRCS1Frames.resize(Size);
 
166
      }
 
167
      GPRCS1Frames[fi] = true;
 
168
    }
 
169
  }
 
170
  void addGPRCalleeSavedArea2Frame(int fi) {
 
171
    if (fi >= 0) {
 
172
      int Size = GPRCS2Frames.size();
 
173
      if (fi >= Size) {
 
174
        Size *= 2;
 
175
        if (fi >= Size)
 
176
          Size = fi+1;
 
177
        GPRCS2Frames.resize(Size);
 
178
      }
 
179
      GPRCS2Frames[fi] = true;
 
180
    }
 
181
  }
 
182
  void addDPRCalleeSavedAreaFrame(int fi) {
 
183
    if (fi >= 0) {
 
184
      int Size = DPRCSFrames.size();
 
185
      if (fi >= Size) {
 
186
        Size *= 2;
 
187
        if (fi >= Size)
 
188
          Size = fi+1;
 
189
        DPRCSFrames.resize(Size);
 
190
      }
 
191
      DPRCSFrames[fi] = true;
 
192
    }
 
193
  }
 
194
 
 
195
  void setCSRegisterIsSpilled(unsigned Reg) {
 
196
    SpilledCSRegs.set(Reg);
 
197
  }
 
198
 
 
199
  bool isCSRegisterSpilled(unsigned Reg) const {
 
200
    return SpilledCSRegs[Reg];
 
201
  }
 
202
 
 
203
  const BitVector &getSpilledCSRegisters() const {
 
204
    return SpilledCSRegs;
 
205
  }
 
206
 
 
207
  unsigned createJumpTableUId() {
 
208
    return JumpTableUId++;
 
209
  }
 
210
 
 
211
  unsigned getNumJumpTables() const {
 
212
    return JumpTableUId;
 
213
  }
 
214
 
 
215
  void initConstPoolEntryUId(unsigned UId) {
 
216
    ConstPoolEntryUId = UId;
 
217
  }
 
218
 
 
219
  unsigned getNumConstPoolEntries() const {
 
220
    return ConstPoolEntryUId;
 
221
  }
 
222
 
 
223
  unsigned createConstPoolEntryUId() {
 
224
    return ConstPoolEntryUId++;
 
225
  }
 
226
};
 
227
} // End llvm namespace
 
228
 
 
229
#endif // ARMMACHINEFUNCTIONINFO_H