← 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/X86/X86Subtarget.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/X86/X86Subtarget.h
 
1
//=====---- X86Subtarget.h - Define Subtarget for the X86 -----*- 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 X86 specific subclass of TargetSubtarget.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#ifndef X86SUBTARGET_H
 
15
#define X86SUBTARGET_H
 
16
 
 
17
#include "llvm/Target/TargetSubtarget.h"
 
18
#include <string>
 
19
 
 
20
namespace llvm {
 
21
class GlobalValue;
 
22
class TargetMachine;
 
23
 
 
24
/// PICStyles - The X86 backend supports a number of different styles of PIC.
 
25
///
 
26
namespace PICStyles {
 
27
enum Style {
 
28
  StubPIC,          // Used on i386-darwin in -fPIC mode.
 
29
  StubDynamicNoPIC, // Used on i386-darwin in -mdynamic-no-pic mode.
 
30
  GOT,              // Used on many 32-bit unices in -fPIC mode.
 
31
  RIPRel,           // Used on X86-64 when not in -static mode.
 
32
  None              // Set when in -static mode (not PIC or DynamicNoPIC mode).
 
33
};
 
34
}
 
35
 
 
36
class X86Subtarget : public TargetSubtarget {
 
37
protected:
 
38
  enum X86SSEEnum {
 
39
    NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
 
40
  };
 
41
 
 
42
  enum X863DNowEnum {
 
43
    NoThreeDNow, ThreeDNow, ThreeDNowA
 
44
  };
 
45
 
 
46
  /// PICStyle - Which PIC style to use
 
47
  ///
 
48
  PICStyles::Style PICStyle;
 
49
 
 
50
  /// X86SSELevel - MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, or
 
51
  /// none supported.
 
52
  X86SSEEnum X86SSELevel;
 
53
 
 
54
  /// X863DNowLevel - 3DNow or 3DNow Athlon, or none supported.
 
55
  ///
 
56
  X863DNowEnum X863DNowLevel;
 
57
 
 
58
  /// HasCMov - True if this processor has conditional move instructions
 
59
  /// (generally pentium pro+).
 
60
  bool HasCMov;
 
61
 
 
62
  /// HasX86_64 - True if the processor supports X86-64 instructions.
 
63
  ///
 
64
  bool HasX86_64;
 
65
 
 
66
  /// HasSSE4A - True if the processor supports SSE4A instructions.
 
67
  bool HasSSE4A;
 
68
 
 
69
  /// HasAVX - Target has AVX instructions
 
70
  bool HasAVX;
 
71
 
 
72
  /// HasFMA3 - Target has 3-operand fused multiply-add
 
73
  bool HasFMA3;
 
74
 
 
75
  /// HasFMA4 - Target has 4-operand fused multiply-add
 
76
  bool HasFMA4;
 
77
 
 
78
  /// IsBTMemSlow - True if BT (bit test) of memory instructions are slow.
 
79
  bool IsBTMemSlow;
 
80
 
 
81
  /// HasVectorUAMem - True if SIMD operations can have unaligned memory
 
82
  ///                  operands. This may require setting a feature bit in the
 
83
  ///                  processor.
 
84
  bool HasVectorUAMem;
 
85
 
 
86
  /// DarwinVers - Nonzero if this is a darwin platform: the numeric
 
87
  /// version of the platform, e.g. 8 = 10.4 (Tiger), 9 = 10.5 (Leopard), etc.
 
88
  unsigned char DarwinVers; // Is any darwin-x86 platform.
 
89
 
 
90
  /// stackAlignment - The minimum alignment known to hold of the stack frame on
 
91
  /// entry to the function and which must be maintained by every function.
 
92
  unsigned stackAlignment;
 
93
 
 
94
  /// Max. memset / memcpy size that is turned into rep/movs, rep/stos ops.
 
95
  ///
 
96
  unsigned MaxInlineSizeThreshold;
 
97
 
 
98
private:
 
99
  /// Is64Bit - True if the processor supports 64-bit instructions and
 
100
  /// pointer size is 64 bit.
 
101
  bool Is64Bit;
 
102
 
 
103
public:
 
104
  enum {
 
105
    isELF, isCygwin, isDarwin, isWindows, isMingw
 
106
  } TargetType;
 
107
 
 
108
  /// This constructor initializes the data members to match that
 
109
  /// of the specified triple.
 
110
  ///
 
111
  X86Subtarget(const std::string &TT, const std::string &FS, bool is64Bit);
 
112
 
 
113
  /// getStackAlignment - Returns the minimum alignment known to hold of the
 
114
  /// stack frame on entry to the function and which must be maintained by every
 
115
  /// function for this subtarget.
 
116
  unsigned getStackAlignment() const { return stackAlignment; }
 
117
 
 
118
  /// getMaxInlineSizeThreshold - Returns the maximum memset / memcpy size
 
119
  /// that still makes it profitable to inline the call.
 
120
  unsigned getMaxInlineSizeThreshold() const { return MaxInlineSizeThreshold; }
 
121
 
 
122
  /// ParseSubtargetFeatures - Parses features string setting specified
 
123
  /// subtarget options.  Definition of function is auto generated by tblgen.
 
124
  std::string ParseSubtargetFeatures(const std::string &FS,
 
125
                                     const std::string &CPU);
 
126
 
 
127
  /// AutoDetectSubtargetFeatures - Auto-detect CPU features using CPUID
 
128
  /// instruction.
 
129
  void AutoDetectSubtargetFeatures();
 
130
 
 
131
  bool is64Bit() const { return Is64Bit; }
 
132
 
 
133
  PICStyles::Style getPICStyle() const { return PICStyle; }
 
134
  void setPICStyle(PICStyles::Style Style)  { PICStyle = Style; }
 
135
 
 
136
  bool hasMMX() const { return X86SSELevel >= MMX; }
 
137
  bool hasSSE1() const { return X86SSELevel >= SSE1; }
 
138
  bool hasSSE2() const { return X86SSELevel >= SSE2; }
 
139
  bool hasSSE3() const { return X86SSELevel >= SSE3; }
 
140
  bool hasSSSE3() const { return X86SSELevel >= SSSE3; }
 
141
  bool hasSSE41() const { return X86SSELevel >= SSE41; }
 
142
  bool hasSSE42() const { return X86SSELevel >= SSE42; }
 
143
  bool hasSSE4A() const { return HasSSE4A; }
 
144
  bool has3DNow() const { return X863DNowLevel >= ThreeDNow; }
 
145
  bool has3DNowA() const { return X863DNowLevel >= ThreeDNowA; }
 
146
  bool hasAVX() const { return HasAVX; }
 
147
  bool hasFMA3() const { return HasFMA3; }
 
148
  bool hasFMA4() const { return HasFMA4; }
 
149
  bool isBTMemSlow() const { return IsBTMemSlow; }
 
150
  bool hasVectorUAMem() const { return HasVectorUAMem; }
 
151
 
 
152
  bool isTargetDarwin() const { return TargetType == isDarwin; }
 
153
  bool isTargetELF() const { return TargetType == isELF; }
 
154
 
 
155
  bool isTargetWindows() const { return TargetType == isWindows; }
 
156
  bool isTargetMingw() const { return TargetType == isMingw; }
 
157
  bool isTargetCygwin() const { return TargetType == isCygwin; }
 
158
  bool isTargetCygMing() const {
 
159
    return TargetType == isMingw || TargetType == isCygwin;
 
160
  }
 
161
 
 
162
  /// isTargetCOFF - Return true if this is any COFF/Windows target variant.
 
163
  bool isTargetCOFF() const {
 
164
    return TargetType == isMingw || TargetType == isCygwin ||
 
165
           TargetType == isWindows;
 
166
  }
 
167
 
 
168
  bool isTargetWin64() const {
 
169
    return Is64Bit && (TargetType == isMingw || TargetType == isWindows);
 
170
  }
 
171
 
 
172
  std::string getDataLayout() const {
 
173
    const char *p;
 
174
    if (is64Bit())
 
175
      p = "e-p:64:64-s:64-f64:64:64-i64:64:64-f80:128:128-n8:16:32:64";
 
176
    else if (isTargetDarwin())
 
177
      p = "e-p:32:32-f64:32:64-i64:32:64-f80:128:128-n8:16:32";
 
178
    else if (isTargetMingw() || isTargetWindows())
 
179
      p = "e-p:32:32-f64:64:64-i64:64:64-f80:32:32-n8:16:32";
 
180
    else
 
181
      p = "e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32";
 
182
 
 
183
    return std::string(p);
 
184
  }
 
185
 
 
186
  bool isPICStyleSet() const { return PICStyle != PICStyles::None; }
 
187
  bool isPICStyleGOT() const { return PICStyle == PICStyles::GOT; }
 
188
  bool isPICStyleRIPRel() const { return PICStyle == PICStyles::RIPRel; }
 
189
 
 
190
  bool isPICStyleStubPIC() const {
 
191
    return PICStyle == PICStyles::StubPIC;
 
192
  }
 
193
 
 
194
  bool isPICStyleStubNoDynamic() const {
 
195
    return PICStyle == PICStyles::StubDynamicNoPIC;
 
196
  }
 
197
  bool isPICStyleStubAny() const {
 
198
    return PICStyle == PICStyles::StubDynamicNoPIC ||
 
199
           PICStyle == PICStyles::StubPIC; }
 
200
 
 
201
  /// getDarwinVers - Return the darwin version number, 8 = Tiger, 9 = Leopard,
 
202
  /// 10 = Snow Leopard, etc.
 
203
  unsigned getDarwinVers() const { return DarwinVers; }
 
204
 
 
205
  /// ClassifyGlobalReference - Classify a global variable reference for the
 
206
  /// current subtarget according to how we should reference it in a non-pcrel
 
207
  /// context.
 
208
  unsigned char ClassifyGlobalReference(const GlobalValue *GV,
 
209
                                        const TargetMachine &TM)const;
 
210
 
 
211
  /// ClassifyBlockAddressReference - Classify a blockaddress reference for the
 
212
  /// current subtarget according to how we should reference it in a non-pcrel
 
213
  /// context.
 
214
  unsigned char ClassifyBlockAddressReference() const;
 
215
 
 
216
  /// IsLegalToCallImmediateAddr - Return true if the subtarget allows calls
 
217
  /// to immediate address.
 
218
  bool IsLegalToCallImmediateAddr(const TargetMachine &TM) const;
 
219
 
 
220
  /// This function returns the name of a function which has an interface
 
221
  /// like the non-standard bzero function, if such a function exists on
 
222
  /// the current subtarget and it is considered prefereable over
 
223
  /// memset with zero passed as the second argument. Otherwise it
 
224
  /// returns null.
 
225
  const char *getBZeroEntry() const;
 
226
 
 
227
  /// getSpecialAddressLatency - For targets where it is beneficial to
 
228
  /// backschedule instructions that compute addresses, return a value
 
229
  /// indicating the number of scheduling cycles of backscheduling that
 
230
  /// should be attempted.
 
231
  unsigned getSpecialAddressLatency() const;
 
232
 
 
233
  /// enablePostRAScheduler - X86 target is enabling post-alloc scheduling
 
234
  /// at 'More' optimization level.
 
235
  bool enablePostRAScheduler(CodeGenOpt::Level OptLevel,
 
236
                             TargetSubtarget::AntiDepBreakMode& Mode,
 
237
                             RegClassVector& CriticalPathRCs) const;
 
238
};
 
239
 
 
240
} // End llvm namespace
 
241
 
 
242
#endif