← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/IntrinsicsARM.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/include/llvm/IntrinsicsARM.td
 
1
//===- IntrinsicsARM.td - Defines ARM intrinsics -----------*- 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
// This file defines all of the ARM-specific intrinsics.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
 
 
15
//===----------------------------------------------------------------------===//
 
16
// TLS
 
17
 
 
18
let TargetPrefix = "arm" in {  // All intrinsics start with "llvm.arm.".
 
19
  def int_arm_thread_pointer : GCCBuiltin<"__builtin_thread_pointer">,
 
20
              Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>;
 
21
}
 
22
 
 
23
//===----------------------------------------------------------------------===//
 
24
// Advanced SIMD (NEON)
 
25
 
 
26
let TargetPrefix = "arm" in {  // All intrinsics start with "llvm.arm.".
 
27
 
 
28
  // The following classes do not correspond directly to GCC builtins.
 
29
  class Neon_1Arg_Intrinsic
 
30
    : Intrinsic<[llvm_anyvector_ty], [LLVMMatchType<0>], [IntrNoMem]>;
 
31
  class Neon_1Arg_Narrow_Intrinsic
 
32
    : Intrinsic<[llvm_anyvector_ty],
 
33
                [LLVMExtendedElementVectorType<0>], [IntrNoMem]>;
 
34
  class Neon_1Arg_Long_Intrinsic
 
35
    : Intrinsic<[llvm_anyvector_ty],
 
36
                [LLVMTruncatedElementVectorType<0>], [IntrNoMem]>;
 
37
  class Neon_2Arg_Intrinsic
 
38
    : Intrinsic<[llvm_anyvector_ty], [LLVMMatchType<0>, LLVMMatchType<0>],
 
39
                [IntrNoMem]>;
 
40
  class Neon_2Arg_Narrow_Intrinsic
 
41
    : Intrinsic<[llvm_anyvector_ty],
 
42
                [LLVMExtendedElementVectorType<0>,
 
43
                 LLVMExtendedElementVectorType<0>],
 
44
                [IntrNoMem]>;
 
45
  class Neon_2Arg_Long_Intrinsic
 
46
    : Intrinsic<[llvm_anyvector_ty],
 
47
                [LLVMTruncatedElementVectorType<0>,
 
48
                 LLVMTruncatedElementVectorType<0>],
 
49
                [IntrNoMem]>;
 
50
  class Neon_2Arg_Wide_Intrinsic
 
51
    : Intrinsic<[llvm_anyvector_ty],
 
52
                [LLVMMatchType<0>, LLVMTruncatedElementVectorType<0>],
 
53
                [IntrNoMem]>;
 
54
  class Neon_3Arg_Intrinsic
 
55
    : Intrinsic<[llvm_anyvector_ty],
 
56
                [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>],
 
57
                [IntrNoMem]>;
 
58
  class Neon_3Arg_Long_Intrinsic
 
59
    : Intrinsic<[llvm_anyvector_ty],
 
60
                [LLVMMatchType<0>,
 
61
                 LLVMTruncatedElementVectorType<0>,
 
62
                 LLVMTruncatedElementVectorType<0>],
 
63
                [IntrNoMem]>;
 
64
  class Neon_CvtFxToFP_Intrinsic
 
65
    : Intrinsic<[llvm_anyfloat_ty], [llvm_anyint_ty, llvm_i32_ty], [IntrNoMem]>;
 
66
  class Neon_CvtFPToFx_Intrinsic
 
67
    : Intrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty, llvm_i32_ty], [IntrNoMem]>;
 
68
 
 
69
  // The table operands for VTBL and VTBX consist of 1 to 4 v8i8 vectors.
 
70
  // Besides the table, VTBL has one other v8i8 argument and VTBX has two.
 
71
  // Overall, the classes range from 2 to 6 v8i8 arguments.
 
72
  class Neon_Tbl2Arg_Intrinsic
 
73
    : Intrinsic<[llvm_v8i8_ty],
 
74
                [llvm_v8i8_ty, llvm_v8i8_ty], [IntrNoMem]>;
 
75
  class Neon_Tbl3Arg_Intrinsic
 
76
    : Intrinsic<[llvm_v8i8_ty],
 
77
                [llvm_v8i8_ty, llvm_v8i8_ty, llvm_v8i8_ty], [IntrNoMem]>;
 
78
  class Neon_Tbl4Arg_Intrinsic
 
79
    : Intrinsic<[llvm_v8i8_ty],
 
80
                [llvm_v8i8_ty, llvm_v8i8_ty, llvm_v8i8_ty, llvm_v8i8_ty],
 
81
                [IntrNoMem]>;
 
82
  class Neon_Tbl5Arg_Intrinsic
 
83
    : Intrinsic<[llvm_v8i8_ty],
 
84
                [llvm_v8i8_ty, llvm_v8i8_ty, llvm_v8i8_ty, llvm_v8i8_ty,
 
85
                 llvm_v8i8_ty], [IntrNoMem]>;
 
86
  class Neon_Tbl6Arg_Intrinsic
 
87
    : Intrinsic<[llvm_v8i8_ty],
 
88
                [llvm_v8i8_ty, llvm_v8i8_ty, llvm_v8i8_ty, llvm_v8i8_ty,
 
89
                 llvm_v8i8_ty, llvm_v8i8_ty], [IntrNoMem]>;
 
90
}
 
91
 
 
92
// Arithmetic ops
 
93
 
 
94
let Properties = [IntrNoMem, Commutative] in {
 
95
 
 
96
  // Vector Add.
 
97
  def int_arm_neon_vhadds : Neon_2Arg_Intrinsic;
 
98
  def int_arm_neon_vhaddu : Neon_2Arg_Intrinsic;
 
99
  def int_arm_neon_vrhadds : Neon_2Arg_Intrinsic;
 
100
  def int_arm_neon_vrhaddu : Neon_2Arg_Intrinsic;
 
101
  def int_arm_neon_vqadds : Neon_2Arg_Intrinsic;
 
102
  def int_arm_neon_vqaddu : Neon_2Arg_Intrinsic;
 
103
  def int_arm_neon_vaddhn : Neon_2Arg_Narrow_Intrinsic;
 
104
  def int_arm_neon_vraddhn : Neon_2Arg_Narrow_Intrinsic;
 
105
  def int_arm_neon_vaddls : Neon_2Arg_Long_Intrinsic;
 
106
  def int_arm_neon_vaddlu : Neon_2Arg_Long_Intrinsic;
 
107
  def int_arm_neon_vaddws : Neon_2Arg_Wide_Intrinsic;
 
108
  def int_arm_neon_vaddwu : Neon_2Arg_Wide_Intrinsic;
 
109
 
 
110
  // Vector Multiply.
 
111
  def int_arm_neon_vmulp : Neon_2Arg_Intrinsic;
 
112
  def int_arm_neon_vqdmulh : Neon_2Arg_Intrinsic;
 
113
  def int_arm_neon_vqrdmulh : Neon_2Arg_Intrinsic;
 
114
  def int_arm_neon_vmulls : Neon_2Arg_Long_Intrinsic;
 
115
  def int_arm_neon_vmullu : Neon_2Arg_Long_Intrinsic;
 
116
  def int_arm_neon_vmullp : Neon_2Arg_Long_Intrinsic;
 
117
  def int_arm_neon_vqdmull : Neon_2Arg_Long_Intrinsic;
 
118
 
 
119
  // Vector Multiply and Accumulate/Subtract.
 
120
  def int_arm_neon_vmlals : Neon_3Arg_Long_Intrinsic;
 
121
  def int_arm_neon_vmlalu : Neon_3Arg_Long_Intrinsic;
 
122
  def int_arm_neon_vmlsls : Neon_3Arg_Long_Intrinsic;
 
123
  def int_arm_neon_vmlslu : Neon_3Arg_Long_Intrinsic;
 
124
  def int_arm_neon_vqdmlal : Neon_3Arg_Long_Intrinsic;
 
125
  def int_arm_neon_vqdmlsl : Neon_3Arg_Long_Intrinsic;
 
126
 
 
127
  // Vector Maximum.
 
128
  def int_arm_neon_vmaxs : Neon_2Arg_Intrinsic;
 
129
  def int_arm_neon_vmaxu : Neon_2Arg_Intrinsic;
 
130
 
 
131
  // Vector Minimum.
 
132
  def int_arm_neon_vmins : Neon_2Arg_Intrinsic;
 
133
  def int_arm_neon_vminu : Neon_2Arg_Intrinsic;
 
134
 
 
135
  // Vector Reciprocal Step.
 
136
  def int_arm_neon_vrecps : Neon_2Arg_Intrinsic;
 
137
 
 
138
  // Vector Reciprocal Square Root Step.
 
139
  def int_arm_neon_vrsqrts : Neon_2Arg_Intrinsic;
 
140
}
 
141
 
 
142
// Vector Subtract.
 
143
def int_arm_neon_vhsubs : Neon_2Arg_Intrinsic;
 
144
def int_arm_neon_vhsubu : Neon_2Arg_Intrinsic;
 
145
def int_arm_neon_vqsubs : Neon_2Arg_Intrinsic;
 
146
def int_arm_neon_vqsubu : Neon_2Arg_Intrinsic;
 
147
def int_arm_neon_vsubhn : Neon_2Arg_Narrow_Intrinsic;
 
148
def int_arm_neon_vrsubhn : Neon_2Arg_Narrow_Intrinsic;
 
149
def int_arm_neon_vsubls : Neon_2Arg_Long_Intrinsic;
 
150
def int_arm_neon_vsublu : Neon_2Arg_Long_Intrinsic;
 
151
def int_arm_neon_vsubws : Neon_2Arg_Wide_Intrinsic;
 
152
def int_arm_neon_vsubwu : Neon_2Arg_Wide_Intrinsic;
 
153
 
 
154
// Vector Absolute Compare.
 
155
let TargetPrefix = "arm" in {
 
156
  def int_arm_neon_vacged : Intrinsic<[llvm_v2i32_ty],
 
157
                                      [llvm_v2f32_ty, llvm_v2f32_ty],
 
158
                                      [IntrNoMem]>;
 
159
  def int_arm_neon_vacgeq : Intrinsic<[llvm_v4i32_ty],
 
160
                                      [llvm_v4f32_ty, llvm_v4f32_ty],
 
161
                                      [IntrNoMem]>;
 
162
  def int_arm_neon_vacgtd : Intrinsic<[llvm_v2i32_ty],
 
163
                                      [llvm_v2f32_ty, llvm_v2f32_ty],
 
164
                                      [IntrNoMem]>;
 
165
  def int_arm_neon_vacgtq : Intrinsic<[llvm_v4i32_ty],
 
166
                                      [llvm_v4f32_ty, llvm_v4f32_ty],
 
167
                                      [IntrNoMem]>;
 
168
}
 
169
 
 
170
// Vector Absolute Differences.
 
171
def int_arm_neon_vabds : Neon_2Arg_Intrinsic;
 
172
def int_arm_neon_vabdu : Neon_2Arg_Intrinsic;
 
173
def int_arm_neon_vabdls : Neon_2Arg_Long_Intrinsic;
 
174
def int_arm_neon_vabdlu : Neon_2Arg_Long_Intrinsic;
 
175
 
 
176
// Vector Absolute Difference and Accumulate.
 
177
def int_arm_neon_vabas : Neon_3Arg_Intrinsic;
 
178
def int_arm_neon_vabau : Neon_3Arg_Intrinsic;
 
179
def int_arm_neon_vabals : Neon_3Arg_Long_Intrinsic;
 
180
def int_arm_neon_vabalu : Neon_3Arg_Long_Intrinsic;
 
181
 
 
182
// Vector Pairwise Add.
 
183
def int_arm_neon_vpadd : Neon_2Arg_Intrinsic;
 
184
 
 
185
// Vector Pairwise Add Long.
 
186
// Note: This is different than the other "long" NEON intrinsics because
 
187
// the result vector has half as many elements as the source vector.
 
188
// The source and destination vector types must be specified separately.
 
189
let TargetPrefix = "arm" in {
 
190
  def int_arm_neon_vpaddls : Intrinsic<[llvm_anyvector_ty], [llvm_anyvector_ty],
 
191
                                       [IntrNoMem]>;
 
192
  def int_arm_neon_vpaddlu : Intrinsic<[llvm_anyvector_ty], [llvm_anyvector_ty],
 
193
                                       [IntrNoMem]>;
 
194
}
 
195
 
 
196
// Vector Pairwise Add and Accumulate Long.
 
197
// Note: This is similar to vpaddl but the destination vector also appears
 
198
// as the first argument.
 
199
let TargetPrefix = "arm" in {
 
200
  def int_arm_neon_vpadals : Intrinsic<[llvm_anyvector_ty],
 
201
                                       [LLVMMatchType<0>, llvm_anyvector_ty],
 
202
                                       [IntrNoMem]>;
 
203
  def int_arm_neon_vpadalu : Intrinsic<[llvm_anyvector_ty],
 
204
                                       [LLVMMatchType<0>, llvm_anyvector_ty],
 
205
                                       [IntrNoMem]>;
 
206
}
 
207
 
 
208
// Vector Pairwise Maximum and Minimum.
 
209
def int_arm_neon_vpmaxs : Neon_2Arg_Intrinsic;
 
210
def int_arm_neon_vpmaxu : Neon_2Arg_Intrinsic;
 
211
def int_arm_neon_vpmins : Neon_2Arg_Intrinsic;
 
212
def int_arm_neon_vpminu : Neon_2Arg_Intrinsic;
 
213
 
 
214
// Vector Shifts:
 
215
//
 
216
// The various saturating and rounding vector shift operations need to be
 
217
// represented by intrinsics in LLVM, and even the basic VSHL variable shift
 
218
// operation cannot be safely translated to LLVM's shift operators.  VSHL can
 
219
// be used for both left and right shifts, or even combinations of the two,
 
220
// depending on the signs of the shift amounts.  It also has well-defined
 
221
// behavior for shift amounts that LLVM leaves undefined.  Only basic shifts
 
222
// by constants can be represented with LLVM's shift operators.
 
223
//
 
224
// The shift counts for these intrinsics are always vectors, even for constant
 
225
// shifts, where the constant is replicated.  For consistency with VSHL (and
 
226
// other variable shift instructions), left shifts have positive shift counts
 
227
// and right shifts have negative shift counts.  This convention is also used
 
228
// for constant right shift intrinsics, and to help preserve sanity, the
 
229
// intrinsic names use "shift" instead of either "shl" or "shr".  Where
 
230
// applicable, signed and unsigned versions of the intrinsics are
 
231
// distinguished with "s" and "u" suffixes.  A few NEON shift instructions,
 
232
// such as VQSHLU, take signed operands but produce unsigned results; these
 
233
// use a "su" suffix.
 
234
 
 
235
// Vector Shift.
 
236
def int_arm_neon_vshifts : Neon_2Arg_Intrinsic;
 
237
def int_arm_neon_vshiftu : Neon_2Arg_Intrinsic;
 
238
def int_arm_neon_vshiftls : Neon_2Arg_Long_Intrinsic;
 
239
def int_arm_neon_vshiftlu : Neon_2Arg_Long_Intrinsic;
 
240
def int_arm_neon_vshiftn : Neon_2Arg_Narrow_Intrinsic;
 
241
 
 
242
// Vector Rounding Shift.
 
243
def int_arm_neon_vrshifts : Neon_2Arg_Intrinsic;
 
244
def int_arm_neon_vrshiftu : Neon_2Arg_Intrinsic;
 
245
def int_arm_neon_vrshiftn : Neon_2Arg_Narrow_Intrinsic;
 
246
 
 
247
// Vector Saturating Shift.
 
248
def int_arm_neon_vqshifts : Neon_2Arg_Intrinsic;
 
249
def int_arm_neon_vqshiftu : Neon_2Arg_Intrinsic;
 
250
def int_arm_neon_vqshiftsu : Neon_2Arg_Intrinsic;
 
251
def int_arm_neon_vqshiftns : Neon_2Arg_Narrow_Intrinsic;
 
252
def int_arm_neon_vqshiftnu : Neon_2Arg_Narrow_Intrinsic;
 
253
def int_arm_neon_vqshiftnsu : Neon_2Arg_Narrow_Intrinsic;
 
254
 
 
255
// Vector Saturating Rounding Shift.
 
256
def int_arm_neon_vqrshifts : Neon_2Arg_Intrinsic;
 
257
def int_arm_neon_vqrshiftu : Neon_2Arg_Intrinsic;
 
258
def int_arm_neon_vqrshiftns : Neon_2Arg_Narrow_Intrinsic;
 
259
def int_arm_neon_vqrshiftnu : Neon_2Arg_Narrow_Intrinsic;
 
260
def int_arm_neon_vqrshiftnsu : Neon_2Arg_Narrow_Intrinsic;
 
261
 
 
262
// Vector Shift and Insert.
 
263
def int_arm_neon_vshiftins : Neon_3Arg_Intrinsic;
 
264
 
 
265
// Vector Absolute Value and Saturating Absolute Value.
 
266
def int_arm_neon_vabs : Neon_1Arg_Intrinsic;
 
267
def int_arm_neon_vqabs : Neon_1Arg_Intrinsic;
 
268
 
 
269
// Vector Saturating Negate.
 
270
def int_arm_neon_vqneg : Neon_1Arg_Intrinsic;
 
271
 
 
272
// Vector Count Leading Sign/Zero Bits.
 
273
def int_arm_neon_vcls : Neon_1Arg_Intrinsic;
 
274
def int_arm_neon_vclz : Neon_1Arg_Intrinsic;
 
275
 
 
276
// Vector Count One Bits.
 
277
def int_arm_neon_vcnt : Neon_1Arg_Intrinsic;
 
278
 
 
279
// Vector Reciprocal Estimate.
 
280
def int_arm_neon_vrecpe : Neon_1Arg_Intrinsic;
 
281
 
 
282
// Vector Reciprocal Square Root Estimate.
 
283
def int_arm_neon_vrsqrte : Neon_1Arg_Intrinsic;
 
284
 
 
285
// Vector Conversions Between Floating-point and Fixed-point.
 
286
def int_arm_neon_vcvtfp2fxs : Neon_CvtFPToFx_Intrinsic;
 
287
def int_arm_neon_vcvtfp2fxu : Neon_CvtFPToFx_Intrinsic;
 
288
def int_arm_neon_vcvtfxs2fp : Neon_CvtFxToFP_Intrinsic;
 
289
def int_arm_neon_vcvtfxu2fp : Neon_CvtFxToFP_Intrinsic;
 
290
 
 
291
// Narrowing and Lengthening Vector Moves.
 
292
def int_arm_neon_vmovn : Neon_1Arg_Narrow_Intrinsic;
 
293
def int_arm_neon_vqmovns : Neon_1Arg_Narrow_Intrinsic;
 
294
def int_arm_neon_vqmovnu : Neon_1Arg_Narrow_Intrinsic;
 
295
def int_arm_neon_vqmovnsu : Neon_1Arg_Narrow_Intrinsic;
 
296
def int_arm_neon_vmovls : Neon_1Arg_Long_Intrinsic;
 
297
def int_arm_neon_vmovlu : Neon_1Arg_Long_Intrinsic;
 
298
 
 
299
// Vector Table Lookup.
 
300
// The first 1-4 arguments are the table.
 
301
def int_arm_neon_vtbl1 : Neon_Tbl2Arg_Intrinsic;
 
302
def int_arm_neon_vtbl2 : Neon_Tbl3Arg_Intrinsic;
 
303
def int_arm_neon_vtbl3 : Neon_Tbl4Arg_Intrinsic;
 
304
def int_arm_neon_vtbl4 : Neon_Tbl5Arg_Intrinsic;
 
305
 
 
306
// Vector Table Extension.
 
307
// Some elements of the destination vector may not be updated, so the original
 
308
// value of that vector is passed as the first argument.  The next 1-4
 
309
// arguments after that are the table.
 
310
def int_arm_neon_vtbx1 : Neon_Tbl3Arg_Intrinsic;
 
311
def int_arm_neon_vtbx2 : Neon_Tbl4Arg_Intrinsic;
 
312
def int_arm_neon_vtbx3 : Neon_Tbl5Arg_Intrinsic;
 
313
def int_arm_neon_vtbx4 : Neon_Tbl6Arg_Intrinsic;
 
314
 
 
315
let TargetPrefix = "arm" in {
 
316
 
 
317
  // De-interleaving vector loads from N-element structures.
 
318
  def int_arm_neon_vld1 : Intrinsic<[llvm_anyvector_ty],
 
319
                                    [llvm_ptr_ty], [IntrReadArgMem]>;
 
320
  def int_arm_neon_vld2 : Intrinsic<[llvm_anyvector_ty, LLVMMatchType<0>],
 
321
                                    [llvm_ptr_ty], [IntrReadArgMem]>;
 
322
  def int_arm_neon_vld3 : Intrinsic<[llvm_anyvector_ty, LLVMMatchType<0>,
 
323
                                     LLVMMatchType<0>],
 
324
                                    [llvm_ptr_ty], [IntrReadArgMem]>;
 
325
  def int_arm_neon_vld4 : Intrinsic<[llvm_anyvector_ty, LLVMMatchType<0>,
 
326
                                     LLVMMatchType<0>, LLVMMatchType<0>],
 
327
                                    [llvm_ptr_ty], [IntrReadArgMem]>;
 
328
 
 
329
  // Vector load N-element structure to one lane.
 
330
  def int_arm_neon_vld2lane : Intrinsic<[llvm_anyvector_ty, LLVMMatchType<0>],
 
331
                                        [llvm_ptr_ty, LLVMMatchType<0>,
 
332
                                         LLVMMatchType<0>, llvm_i32_ty],
 
333
                                        [IntrReadArgMem]>;
 
334
  def int_arm_neon_vld3lane : Intrinsic<[llvm_anyvector_ty, LLVMMatchType<0>,
 
335
                                         LLVMMatchType<0>],
 
336
                                        [llvm_ptr_ty, LLVMMatchType<0>,
 
337
                                         LLVMMatchType<0>, LLVMMatchType<0>,
 
338
                                         llvm_i32_ty], [IntrReadArgMem]>;
 
339
  def int_arm_neon_vld4lane : Intrinsic<[llvm_anyvector_ty, LLVMMatchType<0>,
 
340
                                         LLVMMatchType<0>, LLVMMatchType<0>],
 
341
                                        [llvm_ptr_ty, LLVMMatchType<0>,
 
342
                                         LLVMMatchType<0>, LLVMMatchType<0>,
 
343
                                         LLVMMatchType<0>, llvm_i32_ty],
 
344
                                        [IntrReadArgMem]>;
 
345
 
 
346
  // Interleaving vector stores from N-element structures.
 
347
  def int_arm_neon_vst1 : Intrinsic<[llvm_void_ty],
 
348
                                    [llvm_ptr_ty, llvm_anyvector_ty],
 
349
                                    [IntrWriteArgMem]>;
 
350
  def int_arm_neon_vst2 : Intrinsic<[llvm_void_ty],
 
351
                                    [llvm_ptr_ty, llvm_anyvector_ty,
 
352
                                     LLVMMatchType<0>], [IntrWriteArgMem]>;
 
353
  def int_arm_neon_vst3 : Intrinsic<[llvm_void_ty],
 
354
                                    [llvm_ptr_ty, llvm_anyvector_ty,
 
355
                                     LLVMMatchType<0>, LLVMMatchType<0>],
 
356
                                     [IntrWriteArgMem]>;
 
357
  def int_arm_neon_vst4 : Intrinsic<[llvm_void_ty],
 
358
                                    [llvm_ptr_ty, llvm_anyvector_ty,
 
359
                                     LLVMMatchType<0>, LLVMMatchType<0>,
 
360
                                     LLVMMatchType<0>], [IntrWriteArgMem]>;
 
361
 
 
362
  // Vector store N-element structure from one lane.
 
363
  def int_arm_neon_vst2lane : Intrinsic<[llvm_void_ty],
 
364
                                        [llvm_ptr_ty, llvm_anyvector_ty,
 
365
                                         LLVMMatchType<0>, llvm_i32_ty],
 
366
                                        [IntrWriteArgMem]>;
 
367
  def int_arm_neon_vst3lane : Intrinsic<[llvm_void_ty],
 
368
                                        [llvm_ptr_ty, llvm_anyvector_ty,
 
369
                                         LLVMMatchType<0>, LLVMMatchType<0>,
 
370
                                         llvm_i32_ty], [IntrWriteArgMem]>;
 
371
  def int_arm_neon_vst4lane : Intrinsic<[llvm_void_ty],
 
372
                                        [llvm_ptr_ty, llvm_anyvector_ty,
 
373
                                         LLVMMatchType<0>, LLVMMatchType<0>,
 
374
                                         LLVMMatchType<0>, llvm_i32_ty],
 
375
                                        [IntrWriteArgMem]>;
 
376
}