← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/Target/X86/X86InstrFormats.td

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/Target/X86/X86InstrFormats.td
 
1
//===- X86InstrFormats.td - X86 Instruction Formats --------*- tablegen -*-===//
 
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
//===----------------------------------------------------------------------===//
 
11
// X86 Instruction Format Definitions.
 
12
//
 
13
 
 
14
// Format specifies the encoding used by the instruction.  This is part of the
 
15
// ad-hoc solution used to emit machine instruction encodings by our machine
 
16
// code emitter.
 
17
class Format<bits<6> val> {
 
18
  bits<6> Value = val;
 
19
}
 
20
 
 
21
def Pseudo     : Format<0>; def RawFrm     : Format<1>;
 
22
def AddRegFrm  : Format<2>; def MRMDestReg : Format<3>;
 
23
def MRMDestMem : Format<4>; def MRMSrcReg  : Format<5>;
 
24
def MRMSrcMem  : Format<6>;
 
25
def MRM0r  : Format<16>; def MRM1r  : Format<17>; def MRM2r  : Format<18>;
 
26
def MRM3r  : Format<19>; def MRM4r  : Format<20>; def MRM5r  : Format<21>;
 
27
def MRM6r  : Format<22>; def MRM7r  : Format<23>;
 
28
def MRM0m  : Format<24>; def MRM1m  : Format<25>; def MRM2m  : Format<26>;
 
29
def MRM3m  : Format<27>; def MRM4m  : Format<28>; def MRM5m  : Format<29>;
 
30
def MRM6m  : Format<30>; def MRM7m  : Format<31>;
 
31
def MRMInitReg : Format<32>;
 
32
def MRM_C1 : Format<33>;
 
33
def MRM_C2 : Format<34>;
 
34
def MRM_C3 : Format<35>;
 
35
def MRM_C4 : Format<36>;
 
36
def MRM_C8 : Format<37>;
 
37
def MRM_C9 : Format<38>;
 
38
def MRM_E8 : Format<39>;
 
39
def MRM_F0 : Format<40>;
 
40
def MRM_F8 : Format<41>;
 
41
def MRM_F9 : Format<42>;
 
42
 
 
43
// ImmType - This specifies the immediate type used by an instruction. This is
 
44
// part of the ad-hoc solution used to emit machine instruction encodings by our
 
45
// machine code emitter.
 
46
class ImmType<bits<3> val> {
 
47
  bits<3> Value = val;
 
48
}
 
49
def NoImm      : ImmType<0>;
 
50
def Imm8       : ImmType<1>;
 
51
def Imm8PCRel  : ImmType<2>;
 
52
def Imm16      : ImmType<3>;
 
53
def Imm32      : ImmType<4>;
 
54
def Imm32PCRel : ImmType<5>;
 
55
def Imm64      : ImmType<6>;
 
56
 
 
57
// FPFormat - This specifies what form this FP instruction has.  This is used by
 
58
// the Floating-Point stackifier pass.
 
59
class FPFormat<bits<3> val> {
 
60
  bits<3> Value = val;
 
61
}
 
62
def NotFP      : FPFormat<0>;
 
63
def ZeroArgFP  : FPFormat<1>;
 
64
def OneArgFP   : FPFormat<2>;
 
65
def OneArgFPRW : FPFormat<3>;
 
66
def TwoArgFP   : FPFormat<4>;
 
67
def CompareFP  : FPFormat<5>;
 
68
def CondMovFP  : FPFormat<6>;
 
69
def SpecialFP  : FPFormat<7>;
 
70
 
 
71
// Prefix byte classes which are used to indicate to the ad-hoc machine code
 
72
// emitter that various prefix bytes are required.
 
73
class OpSize { bit hasOpSizePrefix = 1; }
 
74
class AdSize { bit hasAdSizePrefix = 1; }
 
75
class REX_W  { bit hasREX_WPrefix = 1; }
 
76
class LOCK   { bit hasLockPrefix = 1; }
 
77
class SegFS  { bits<2> SegOvrBits = 1; }
 
78
class SegGS  { bits<2> SegOvrBits = 2; }
 
79
class TB     { bits<4> Prefix = 1; }
 
80
class REP    { bits<4> Prefix = 2; }
 
81
class D8     { bits<4> Prefix = 3; }
 
82
class D9     { bits<4> Prefix = 4; }
 
83
class DA     { bits<4> Prefix = 5; }
 
84
class DB     { bits<4> Prefix = 6; }
 
85
class DC     { bits<4> Prefix = 7; }
 
86
class DD     { bits<4> Prefix = 8; }
 
87
class DE     { bits<4> Prefix = 9; }
 
88
class DF     { bits<4> Prefix = 10; }
 
89
class XD     { bits<4> Prefix = 11; }
 
90
class XS     { bits<4> Prefix = 12; }
 
91
class T8     { bits<4> Prefix = 13; }
 
92
class TA     { bits<4> Prefix = 14; }
 
93
class TF     { bits<4> Prefix = 15; }
 
94
 
 
95
class X86Inst<bits<8> opcod, Format f, ImmType i, dag outs, dag ins,
 
96
              string AsmStr>
 
97
  : Instruction {
 
98
  let Namespace = "X86";
 
99
 
 
100
  bits<8> Opcode = opcod;
 
101
  Format Form = f;
 
102
  bits<6> FormBits = Form.Value;
 
103
  ImmType ImmT = i;
 
104
  bits<3> ImmTypeBits = ImmT.Value;
 
105
 
 
106
  dag OutOperandList = outs;
 
107
  dag InOperandList = ins;
 
108
  string AsmString = AsmStr;
 
109
 
 
110
  //
 
111
  // Attributes specific to X86 instructions...
 
112
  //
 
113
  bit hasOpSizePrefix = 0;  // Does this inst have a 0x66 prefix?
 
114
  bit hasAdSizePrefix = 0;  // Does this inst have a 0x67 prefix?
 
115
 
 
116
  bits<4> Prefix = 0;       // Which prefix byte does this inst have?
 
117
  bit hasREX_WPrefix  = 0;  // Does this inst requires the REX.W prefix?
 
118
  FPFormat FPForm;          // What flavor of FP instruction is this?
 
119
  bits<3> FPFormBits = 0;
 
120
  bit hasLockPrefix = 0;    // Does this inst have a 0xF0 prefix?
 
121
  bits<2> SegOvrBits = 0;   // Segment override prefix.
 
122
}
 
123
 
 
124
class I<bits<8> o, Format f, dag outs, dag ins, string asm, list<dag> pattern>
 
125
  : X86Inst<o, f, NoImm, outs, ins, asm> {
 
126
  let Pattern = pattern;
 
127
  let CodeSize = 3;
 
128
}
 
129
class Ii8 <bits<8> o, Format f, dag outs, dag ins, string asm, 
 
130
           list<dag> pattern>
 
131
  : X86Inst<o, f, Imm8 , outs, ins, asm> {
 
132
  let Pattern = pattern;
 
133
  let CodeSize = 3;
 
134
}
 
135
class Ii8PCRel<bits<8> o, Format f, dag outs, dag ins, string asm, 
 
136
               list<dag> pattern>
 
137
  : X86Inst<o, f, Imm8PCRel, outs, ins, asm> {
 
138
  let Pattern = pattern;
 
139
  let CodeSize = 3;
 
140
}
 
141
class Ii16<bits<8> o, Format f, dag outs, dag ins, string asm, 
 
142
           list<dag> pattern>
 
143
  : X86Inst<o, f, Imm16, outs, ins, asm> {
 
144
  let Pattern = pattern;
 
145
  let CodeSize = 3;
 
146
}
 
147
class Ii32<bits<8> o, Format f, dag outs, dag ins, string asm, 
 
148
           list<dag> pattern>
 
149
  : X86Inst<o, f, Imm32, outs, ins, asm> {
 
150
  let Pattern = pattern;
 
151
  let CodeSize = 3;
 
152
}
 
153
 
 
154
class Ii32PCRel<bits<8> o, Format f, dag outs, dag ins, string asm, 
 
155
           list<dag> pattern>
 
156
  : X86Inst<o, f, Imm32PCRel, outs, ins, asm> {
 
157
  let Pattern = pattern;
 
158
  let CodeSize = 3;
 
159
}
 
160
 
 
161
// FPStack Instruction Templates:
 
162
// FPI - Floating Point Instruction template.
 
163
class FPI<bits<8> o, Format F, dag outs, dag ins, string asm>
 
164
  : I<o, F, outs, ins, asm, []> {}
 
165
 
 
166
// FpI_ - Floating Point Psuedo Instruction template. Not Predicated.
 
167
class FpI_<dag outs, dag ins, FPFormat fp, list<dag> pattern>
 
168
  : X86Inst<0, Pseudo, NoImm, outs, ins, ""> {
 
169
  let FPForm = fp; let FPFormBits = FPForm.Value;
 
170
  let Pattern = pattern;
 
171
}
 
172
 
 
173
// Templates for instructions that use a 16- or 32-bit segmented address as
 
174
//  their only operand: lcall (FAR CALL) and ljmp (FAR JMP)
 
175
//
 
176
//   Iseg16 - 16-bit segment selector, 16-bit offset
 
177
//   Iseg32 - 16-bit segment selector, 32-bit offset
 
178
 
 
179
class Iseg16 <bits<8> o, Format f, dag outs, dag ins, string asm, 
 
180
              list<dag> pattern> : X86Inst<o, f, NoImm, outs, ins, asm> {
 
181
  let Pattern = pattern;
 
182
  let CodeSize = 3;
 
183
}
 
184
 
 
185
class Iseg32 <bits<8> o, Format f, dag outs, dag ins, string asm, 
 
186
              list<dag> pattern> : X86Inst<o, f, NoImm, outs, ins, asm> {
 
187
  let Pattern = pattern;
 
188
  let CodeSize = 3;
 
189
}
 
190
 
 
191
// SSE1 Instruction Templates:
 
192
// 
 
193
//   SSI   - SSE1 instructions with XS prefix.
 
194
//   PSI   - SSE1 instructions with TB prefix.
 
195
//   PSIi8 - SSE1 instructions with ImmT == Imm8 and TB prefix.
 
196
 
 
197
class SSI<bits<8> o, Format F, dag outs, dag ins, string asm, list<dag> pattern>
 
198
      : I<o, F, outs, ins, asm, pattern>, XS, Requires<[HasSSE1]>;
 
199
class SSIi8<bits<8> o, Format F, dag outs, dag ins, string asm, 
 
200
            list<dag> pattern>
 
201
      : Ii8<o, F, outs, ins, asm, pattern>, XS, Requires<[HasSSE1]>;
 
202
class PSI<bits<8> o, Format F, dag outs, dag ins, string asm, list<dag> pattern>
 
203
      : I<o, F, outs, ins, asm, pattern>, TB, Requires<[HasSSE1]>;
 
204
class PSIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 
205
            list<dag> pattern>
 
206
      : Ii8<o, F, outs, ins, asm, pattern>, TB, Requires<[HasSSE1]>;
 
207
 
 
208
// SSE2 Instruction Templates:
 
209
// 
 
210
//   SDI    - SSE2 instructions with XD prefix.
 
211
//   SDIi8  - SSE2 instructions with ImmT == Imm8 and XD prefix.
 
212
//   SSDIi8 - SSE2 instructions with ImmT == Imm8 and XS prefix.
 
213
//   PDI    - SSE2 instructions with TB and OpSize prefixes.
 
214
//   PDIi8  - SSE2 instructions with ImmT == Imm8 and TB and OpSize prefixes.
 
215
 
 
216
class SDI<bits<8> o, Format F, dag outs, dag ins, string asm, list<dag> pattern>
 
217
      : I<o, F, outs, ins, asm, pattern>, XD, Requires<[HasSSE2]>;
 
218
class SDIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 
219
            list<dag> pattern>
 
220
      : Ii8<o, F, outs, ins, asm, pattern>, XD, Requires<[HasSSE2]>;
 
221
class SSDIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 
222
             list<dag> pattern>
 
223
      : Ii8<o, F, outs, ins, asm, pattern>, XS, Requires<[HasSSE2]>;
 
224
class PDI<bits<8> o, Format F, dag outs, dag ins, string asm, list<dag> pattern>
 
225
      : I<o, F, outs, ins, asm, pattern>, TB, OpSize, Requires<[HasSSE2]>;
 
226
class PDIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 
227
            list<dag> pattern>
 
228
      : Ii8<o, F, outs, ins, asm, pattern>, TB, OpSize, Requires<[HasSSE2]>;
 
229
 
 
230
// SSE3 Instruction Templates:
 
231
// 
 
232
//   S3I   - SSE3 instructions with TB and OpSize prefixes.
 
233
//   S3SI  - SSE3 instructions with XS prefix.
 
234
//   S3DI  - SSE3 instructions with XD prefix.
 
235
 
 
236
class S3SI<bits<8> o, Format F, dag outs, dag ins, string asm, 
 
237
           list<dag> pattern>
 
238
      : I<o, F, outs, ins, asm, pattern>, XS, Requires<[HasSSE3]>;
 
239
class S3DI<bits<8> o, Format F, dag outs, dag ins, string asm, 
 
240
           list<dag> pattern>
 
241
      : I<o, F, outs, ins, asm, pattern>, XD, Requires<[HasSSE3]>;
 
242
class S3I<bits<8> o, Format F, dag outs, dag ins, string asm, list<dag> pattern>
 
243
      : I<o, F, outs, ins, asm, pattern>, TB, OpSize, Requires<[HasSSE3]>;
 
244
 
 
245
 
 
246
// SSSE3 Instruction Templates:
 
247
// 
 
248
//   SS38I - SSSE3 instructions with T8 prefix.
 
249
//   SS3AI - SSSE3 instructions with TA prefix.
 
250
//
 
251
// Note: SSSE3 instructions have 64-bit and 128-bit versions. The 64-bit version
 
252
// uses the MMX registers. We put those instructions here because they better
 
253
// fit into the SSSE3 instruction category rather than the MMX category.
 
254
 
 
255
class SS38I<bits<8> o, Format F, dag outs, dag ins, string asm,
 
256
            list<dag> pattern>
 
257
      : Ii8<o, F, outs, ins, asm, pattern>, T8, Requires<[HasSSSE3]>;
 
258
class SS3AI<bits<8> o, Format F, dag outs, dag ins, string asm,
 
259
            list<dag> pattern>
 
260
      : Ii8<o, F, outs, ins, asm, pattern>, TA, Requires<[HasSSSE3]>;
 
261
 
 
262
// SSE4.1 Instruction Templates:
 
263
// 
 
264
//   SS48I - SSE 4.1 instructions with T8 prefix.
 
265
//   SS41AIi8 - SSE 4.1 instructions with TA prefix and ImmT == Imm8.
 
266
//
 
267
class SS48I<bits<8> o, Format F, dag outs, dag ins, string asm,
 
268
            list<dag> pattern>
 
269
      : I<o, F, outs, ins, asm, pattern>, T8, Requires<[HasSSE41]>;
 
270
class SS4AIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 
271
            list<dag> pattern>
 
272
      : Ii8<o, F, outs, ins, asm, pattern>, TA, Requires<[HasSSE41]>;
 
273
 
 
274
// SSE4.2 Instruction Templates:
 
275
// 
 
276
//   SS428I - SSE 4.2 instructions with T8 prefix.
 
277
class SS428I<bits<8> o, Format F, dag outs, dag ins, string asm,
 
278
             list<dag> pattern>
 
279
      : I<o, F, outs, ins, asm, pattern>, T8, Requires<[HasSSE42]>;
 
280
 
 
281
//   SS42FI - SSE 4.2 instructions with TF prefix.
 
282
class SS42FI<bits<8> o, Format F, dag outs, dag ins, string asm,
 
283
              list<dag> pattern>
 
284
      : I<o, F, outs, ins, asm, pattern>, TF, Requires<[HasSSE42]>;
 
285
      
 
286
//   SS42AI = SSE 4.2 instructions with TA prefix
 
287
class SS42AI<bits<8> o, Format F, dag outs, dag ins, string asm,
 
288
             list<dag> pattern>
 
289
      : I<o, F, outs, ins, asm, pattern>, TA, Requires<[HasSSE42]>;
 
290
 
 
291
// X86-64 Instruction templates...
 
292
//
 
293
 
 
294
class RI<bits<8> o, Format F, dag outs, dag ins, string asm, list<dag> pattern>
 
295
      : I<o, F, outs, ins, asm, pattern>, REX_W;
 
296
class RIi8 <bits<8> o, Format F, dag outs, dag ins, string asm,
 
297
            list<dag> pattern>
 
298
      : Ii8<o, F, outs, ins, asm, pattern>, REX_W;
 
299
class RIi32 <bits<8> o, Format F, dag outs, dag ins, string asm,
 
300
             list<dag> pattern>
 
301
      : Ii32<o, F, outs, ins, asm, pattern>, REX_W;
 
302
 
 
303
class RIi64<bits<8> o, Format f, dag outs, dag ins, string asm,
 
304
            list<dag> pattern>
 
305
  : X86Inst<o, f, Imm64, outs, ins, asm>, REX_W {
 
306
  let Pattern = pattern;
 
307
  let CodeSize = 3;
 
308
}
 
309
 
 
310
class RSSI<bits<8> o, Format F, dag outs, dag ins, string asm,
 
311
           list<dag> pattern>
 
312
      : SSI<o, F, outs, ins, asm, pattern>, REX_W;
 
313
class RSDI<bits<8> o, Format F, dag outs, dag ins, string asm,
 
314
           list<dag> pattern>
 
315
      : SDI<o, F, outs, ins, asm, pattern>, REX_W;
 
316
class RPDI<bits<8> o, Format F, dag outs, dag ins, string asm,
 
317
           list<dag> pattern>
 
318
      : PDI<o, F, outs, ins, asm, pattern>, REX_W;
 
319
 
 
320
// MMX Instruction templates
 
321
//
 
322
 
 
323
// MMXI   - MMX instructions with TB prefix.
 
324
// MMXI64 - MMX instructions with TB prefix valid only in 64 bit mode.
 
325
// MMX2I  - MMX / SSE2 instructions with TB and OpSize prefixes.
 
326
// MMXIi8 - MMX instructions with ImmT == Imm8 and TB prefix.
 
327
// MMXIi8 - MMX instructions with ImmT == Imm8 and TB prefix.
 
328
// MMXID  - MMX instructions with XD prefix.
 
329
// MMXIS  - MMX instructions with XS prefix.
 
330
class MMXI<bits<8> o, Format F, dag outs, dag ins, string asm, 
 
331
           list<dag> pattern>
 
332
      : I<o, F, outs, ins, asm, pattern>, TB, Requires<[HasMMX]>;
 
333
class MMXI64<bits<8> o, Format F, dag outs, dag ins, string asm, 
 
334
             list<dag> pattern>
 
335
      : I<o, F, outs, ins, asm, pattern>, TB, Requires<[HasMMX,In64BitMode]>;
 
336
class MMXRI<bits<8> o, Format F, dag outs, dag ins, string asm, 
 
337
            list<dag> pattern>
 
338
      : I<o, F, outs, ins, asm, pattern>, TB, REX_W, Requires<[HasMMX]>;
 
339
class MMX2I<bits<8> o, Format F, dag outs, dag ins, string asm, 
 
340
            list<dag> pattern>
 
341
      : I<o, F, outs, ins, asm, pattern>, TB, OpSize, Requires<[HasMMX]>;
 
342
class MMXIi8<bits<8> o, Format F, dag outs, dag ins, string asm, 
 
343
             list<dag> pattern>
 
344
      : Ii8<o, F, outs, ins, asm, pattern>, TB, Requires<[HasMMX]>;
 
345
class MMXID<bits<8> o, Format F, dag outs, dag ins, string asm, 
 
346
            list<dag> pattern>
 
347
      : Ii8<o, F, outs, ins, asm, pattern>, XD, Requires<[HasMMX]>;
 
348
class MMXIS<bits<8> o, Format F, dag outs, dag ins, string asm, 
 
349
            list<dag> pattern>
 
350
      : Ii8<o, F, outs, ins, asm, pattern>, XS, Requires<[HasMMX]>;