← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/test/TableGen/TargetInstrInfo.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/test/TableGen/TargetInstrInfo.td
 
1
// This test describes how we eventually want to describe instructions in
 
2
// the target independent code generators.
 
3
// RUN: tblgen %s
 
4
 
 
5
// Target indep stuff.
 
6
class Instruction {   // Would have other stuff eventually
 
7
  bit isTwoAddress = 0;
 
8
  string AssemblyString;
 
9
}
 
10
class RegisterClass;
 
11
 
 
12
class RTLNode;
 
13
 
 
14
def ops;                 // Marker for operand list.
 
15
 
 
16
// Various expressions used in RTL descriptions.
 
17
def imm8    : RTLNode;
 
18
def imm32   : RTLNode;
 
19
def addr    : RTLNode;
 
20
 
 
21
def set     : RTLNode;
 
22
def signext : RTLNode;
 
23
def zeroext : RTLNode;
 
24
def plus    : RTLNode;
 
25
def and     : RTLNode;
 
26
def xor     : RTLNode;
 
27
def shl     : RTLNode;
 
28
def load    : RTLNode;
 
29
def store   : RTLNode;
 
30
def unspec  : RTLNode;
 
31
 
 
32
// Start of X86 specific stuff.
 
33
 
 
34
def R8  : RegisterClass;
 
35
def R16 : RegisterClass;
 
36
def R32 : RegisterClass;
 
37
 
 
38
def CL;  // As are currently defined
 
39
def AL;
 
40
def AX;
 
41
def EDX;
 
42
 
 
43
class Format<bits<5> val> {
 
44
  bits<5> Value = val;
 
45
}
 
46
 
 
47
def Pseudo     : Format<0>; def RawFrm     : Format<1>;
 
48
def AddRegFrm  : Format<2>; def MRMDestReg : Format<3>;
 
49
def MRMDestMem : Format<4>; def MRMSrcReg  : Format<5>;
 
50
def MRMSrcMem  : Format<6>;
 
51
def MRM0r  : Format<16>; def MRM1r  : Format<17>; def MRM2r  : Format<18>;
 
52
def MRM3r  : Format<19>; def MRM4r  : Format<20>; def MRM5r  : Format<21>;
 
53
def MRM6r  : Format<22>; def MRM7r  : Format<23>;
 
54
def MRM0m  : Format<24>; def MRM1m  : Format<25>; def MRM2m  : Format<26>;
 
55
def MRM3m  : Format<27>; def MRM4m  : Format<28>; def MRM5m  : Format<29>;
 
56
def MRM6m  : Format<30>; def MRM7m  : Format<31>;
 
57
 
 
58
 
 
59
class Inst<dag opnds, string asmstr, bits<8> opcode,
 
60
           Format f, list<dag> rtl> : Instruction {
 
61
  dag Operands = opnds;
 
62
  string AssemblyString = asmstr;
 
63
  bits<8> Opcode = opcode;
 
64
  Format Format = f;
 
65
  list<dag> RTL = rtl;
 
66
}
 
67
 
 
68
 
 
69
// Start of instruction definitions, the real point of this file.
 
70
//
 
71
// Note that these patterns show a couple of important things:
 
72
//  1. The order and contents of the operands of the MachineInstr are
 
73
//     described here.  Eventually we can do away with this when everything
 
74
//     is generated from the description.
 
75
//  2. The asm string is captured here, which makes it possible to get rid of
 
76
//     a ton of hacks in the various printers and a bunch of flags.
 
77
//  3. Target specific properties (e.g. Format) can still be captured as
 
78
//     needed.
 
79
//  4. We capture the behavior of the instruction with a simplified RTL-like
 
80
//     expression.
 
81
//  5. The use/def properties for each operand are automatically inferred from
 
82
//     the pattern.
 
83
//  6. Address expressions should become first-class entities.
 
84
 
 
85
// Simple copy instruction.  isMoveInstr could easily be inferred from this,
 
86
// as could TargetRegisterInfo::copyRegToReg.
 
87
def MOV8rr : Inst<(ops R8:$dst, R8:$src),
 
88
                  "mov $dst, $src", 0x88, MRMDestReg,
 
89
                  [(set R8:$dst, R8:$src)]>;
 
90
 
 
91
// Simple immediate initialization.
 
92
def MOV8ri : Inst<(ops R8:$dst, imm8:$src),
 
93
                  "mov $dst, $src", 0xB0, AddRegFrm,
 
94
                  [(set R8:$dst, imm8:$src)]>;
 
95
 
 
96
// Two address instructions are described as three-addr instructions, with
 
97
// the special target-independent isTwoAddress flag set.  The asm pattern
 
98
// should not refer to the $src1, this would be enforced by the
 
99
// TargetInstrInfo tablegen backend.
 
100
let isTwoAddress = 1 in
 
101
def AND8rr : Inst<(ops R8:$dst, R8:$src1, R8:$src2),
 
102
                  "and $dst, $src2", 0x20, MRMDestReg,
 
103
                  [(set R8:$dst, (and R8:$src1, R8:$src2))]>;
 
104
 
 
105
// Instructions that have explicit uses/defs make them explicit in the RTL.
 
106
// Instructions that need extra stuff emitted in the assembly can, trivially.
 
107
let isTwoAddress = 1 in
 
108
def SHL32rCL : Inst<(ops R32:$dst, R32:$src),
 
109
                  "shl $dst, CL", 0xD2, MRM4r,
 
110
                  [(set R32:$dst, (shl R32:$src, CL))]>;
 
111
 
 
112
// The RTL list is a list, allowing complex instructions to be defined easily.
 
113
// Temporary 'internal' registers can be used to break instructions appart.
 
114
let isTwoAddress = 1 in
 
115
def XOR32mi : Inst<(ops addr:$addr, imm32:$imm),
 
116
                   "xor $dst, $src2", 0x81, MRM6m,
 
117
                   [(set R32:$tmp1, (load addr:$addr)),
 
118
                    (set R32:$tmp2, (xor R32:$tmp1, imm32:$imm)),
 
119
                    (store addr:$addr, R32:$tmp2)]>;
 
120
 
 
121
// Alternatively, if each tmporary register is only used once, the instruction
 
122
// can just be described in nested form.  This would be the canonical 
 
123
// representation the target generator would convert the above into.  Pick your
 
124
// favorite indentation scheme.
 
125
let isTwoAddress = 1 in
 
126
def AND32mr : Inst<(ops addr:$addr, R32:$src),
 
127
                   "xor $dst, $src2", 0x81, MRM6m,
 
128
                   [(store addr:$addr,
 
129
                       (and
 
130
                            (load addr:$addr),
 
131
                            R32:$src)
 
132
                       )
 
133
                   ]>;
 
134
 
 
135
// Describing complex instructions is not too hard!  Note how implicit uses/defs
 
136
// become explicit here.
 
137
def CBW : Inst<(ops),
 
138
               "cbw", 0x98, RawFrm,
 
139
               [(set AX, (signext AL))]>;
 
140
 
 
141
// Noop, does nothing.
 
142
def NOOP : Inst<(ops), "nop", 0x90, RawFrm, []>;
 
143
 
 
144
 
 
145
// Instructions that don't expect optimization can use unspec.
 
146
def IN8rr : Inst<(ops), "in AL, EDX", 0xEC, RawFrm,
 
147
                 [(set AL, (unspec EDX))]>;
 
148