[MLIR][Standard] Add log1p operation to std
[lldb.git] / mlir / test / IR / core-ops.mlir
1 // RUN: mlir-opt -allow-unregistered-dialect %s | FileCheck %s
2 // Verify the printed output can be parsed.
3 // RUN: mlir-opt -allow-unregistered-dialect %s | mlir-opt -allow-unregistered-dialect | FileCheck %s
4 // Verify the generic form can be parsed.
5 // RUN: mlir-opt -allow-unregistered-dialect -mlir-print-op-generic %s | mlir-opt -allow-unregistered-dialect | FileCheck %s
6
7 // CHECK: #map0 = affine_map<(d0) -> (d0 + 1)>
8
9 // CHECK: #map1 = affine_map<()[s0] -> (s0 + 1)>
10
11 // CHECK-DAG: #[[$BASE_MAP0:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>
12 // CHECK-DAG: #[[$BASE_MAP3:map[0-9]+]] = affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3)>
13
14 // CHECK-DAG: #[[$BASE_MAP1:map[0-9]+]] = affine_map<(d0)[s0] -> (d0 + s0)>
15 // CHECK-DAG: #[[$SUBVIEW_MAP1:map[0-9]+]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>
16
17 // CHECK-DAG: #[[$BASE_MAP2:map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 22 + d1)>
18 // CHECK-DAG: #[[$SUBVIEW_MAP2:map[0-9]+]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
19 // CHECK-DAG: #[[$SUBVIEW_MAP3:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2 + 8)>
20 // CHECK-DAG: #[[$SUBVIEW_MAP4:map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
21 // CHECK-DAG: #[[$SUBVIEW_MAP5:map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0 * 8 + s0 + d1 * 2)>
22 // CHECK-DAG: #[[$SUBVIEW_MAP6:map[0-9]+]] = affine_map<(d0, d1, d2, d3, d4) -> (d0 * 36 + d1 * 36 + d2 * 4 + d3 * 4 + d4)>
23 // CHECK-DAG: #[[$SUBVIEW_MAP7:map[0-9]+]] = affine_map<(d0, d1, d2, d3, d4, d5)[s0, s1, s2, s3, s4, s5, s6] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4 + d4 * s5 + d5 * s6)>
24 // CHECK-DAG: #[[$SUBVIEW_MAP8:map[0-9]+]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3, s4] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4)>
25
26 // CHECK-LABEL: func @func_with_ops
27 // CHECK-SAME: %[[ARG:.*]]: f32
28 func @func_with_ops(f32) {
29 ^bb0(%a : f32):
30   // CHECK: %[[T:.*]] = "getTensor"() : () -> tensor<4x4x?xf32>
31   %t = "getTensor"() : () -> tensor<4x4x?xf32>
32
33   // CHECK: %[[C2:.*]] = constant 2 : index
34   // CHECK-NEXT: %{{.*}} = dim %[[T]], %[[C2]] : tensor<4x4x?xf32>
35   %c2 = constant 2 : index
36   %t2 = "std.dim"(%t, %c2) : (tensor<4x4x?xf32>, index) -> index
37
38   // CHECK: %{{.*}} = addf %[[ARG]], %[[ARG]] : f32
39   %x = "std.addf"(%a, %a) : (f32,f32) -> (f32)
40
41   // CHECK: return
42   return
43 }
44
45 // CHECK-LABEL: func @standard_instrs(%arg0: tensor<4x4x?xf32>, %arg1: f32, %arg2: i32, %arg3: index, %arg4: i64, %arg5: f16) {
46 func @standard_instrs(tensor<4x4x?xf32>, f32, i32, index, i64, f16) {
47 ^bb42(%t: tensor<4x4x?xf32>, %f: f32, %i: i32, %idx : index, %j: i64, %half: f16):
48   // CHECK: %[[C2:.*]] = constant 2 : index
49   // CHECK: %[[A2:.*]] = dim %arg0, %[[C2]] : tensor<4x4x?xf32>
50   %c2 = constant 2 : index
51   %a2 = dim %t, %c2 : tensor<4x4x?xf32>
52
53   // CHECK: %[[F2:.*]] = addf %arg1, %arg1 : f32
54   %f2 = "std.addf"(%f, %f) : (f32,f32) -> f32
55
56   // CHECK: %[[F3:.*]] = addf %[[F2]], %[[F2]] : f32
57   %f3 = addf %f2, %f2 : f32
58
59   // CHECK: %[[I2:.*]] = addi %arg2, %arg2 : i32
60   %i2 = "std.addi"(%i, %i) : (i32,i32) -> i32
61
62   // CHECK: %[[I3:.*]] = addi %[[I2]], %[[I2]] : i32
63   %i3 = addi %i2, %i2 : i32
64
65   // CHECK: %[[IDX1:.*]] = addi %arg3, %arg3 : index
66   %idx1 = addi %idx, %idx : index
67
68   // CHECK: %[[IDX2:.*]] = addi %arg3, %[[IDX1]] : index
69   %idx2 = "std.addi"(%idx, %idx1) : (index, index) -> index
70
71   // CHECK: %[[F4:.*]] = subf %arg1, %arg1 : f32
72   %f4 = "std.subf"(%f, %f) : (f32,f32) -> f32
73
74   // CHECK: %[[F5:.*]] = subf %[[F4]], %[[F4]] : f32
75   %f5 = subf %f4, %f4 : f32
76
77   // CHECK: %[[I4:.*]] = subi %arg2, %arg2 : i32
78   %i4 = "std.subi"(%i, %i) : (i32,i32) -> i32
79
80   // CHECK: %[[I5:.*]] = subi %[[I4]], %[[I4]] : i32
81   %i5 = subi %i4, %i4 : i32
82
83   // CHECK: %[[F6:.*]] = mulf %[[F2]], %[[F2]] : f32
84   %f6 = mulf %f2, %f2 : f32
85
86   // CHECK: %[[I6:.*]] = muli %[[I2]], %[[I2]] : i32
87   %i6 = muli %i2, %i2 : i32
88
89   // CHECK: %[[F7:.*]] = powf %[[F2]], %[[F2]] : f32
90   %f7 = powf %f2, %f2 : f32
91
92   // CHECK: %[[C0:.*]] = create_complex %[[F2]], %[[F2]] : complex<f32>
93   %c0 = "std.create_complex"(%f2, %f2) : (f32, f32) -> complex<f32>
94
95   // CHECK: %[[C1:.*]] = create_complex %[[F2]], %[[F2]] : complex<f32>
96   %c1 = create_complex %f2, %f2 : complex<f32>
97
98   // CHECK: %[[REAL0:.*]] = re %[[CPLX0:.*]] : complex<f32>
99   %real0 = "std.re"(%c0) : (complex<f32>) -> f32
100
101   // CHECK: %[[REAL1:.*]] = re %[[CPLX0]] : complex<f32>
102   %real1 = re %c0 : complex<f32>
103
104   // CHECK: %[[IMAG0:.*]] = im %[[CPLX0]] : complex<f32>
105   %imag0 = "std.im"(%c0) : (complex<f32>) -> f32
106
107   // CHECK: %[[IMAG1:.*]] = im %[[CPLX0]] : complex<f32>
108   %imag1 = im %c0 : complex<f32>
109
110   // CHECK: %c42_i32 = constant 42 : i32
111   %x = "std.constant"(){value = 42 : i32} : () -> i32
112
113   // CHECK: %c42_i32_0 = constant 42 : i32
114   %7 = constant 42 : i32
115
116   // CHECK: %c43 = constant {crazy = "std.foo"} 43 : index
117   %8 = constant {crazy = "std.foo"} 43: index
118
119   // CHECK: %cst = constant 4.300000e+01 : bf16
120   %9 = constant 43.0 : bf16
121
122   // CHECK: %f = constant @func_with_ops : (f32) -> ()
123   %10 = constant @func_with_ops : (f32) -> ()
124
125   // CHECK: %f_1 = constant @affine_apply : () -> ()
126   %11 = constant @affine_apply : () -> ()
127
128   // CHECK: %f_2 = constant @affine_apply : () -> ()
129   %12 = constant @affine_apply : () -> ()
130
131   // CHECK: %cst_3 = constant dense<0> : vector<4xi32>
132   %13 = constant dense<0> : vector<4 x i32>
133
134   // CHECK: %cst_4 = constant dense<0> : tensor<42xi32>
135   %tci32 = constant dense<0> : tensor<42 x i32>
136
137   // CHECK: %cst_5 = constant dense<0> : vector<42xi32>
138   %vci32 = constant dense<0> : vector<42 x i32>
139
140   // CHECK: %{{[0-9]+}} = cmpi eq, %{{[0-9]+}}, %{{[0-9]+}} : i32
141   %14 = cmpi eq, %i3, %i4 : i32
142
143   // Predicate 1 means inequality comparison.
144   // CHECK: %{{[0-9]+}} = cmpi ne, %{{[0-9]+}}, %{{[0-9]+}} : i32
145   %15 = "std.cmpi"(%i3, %i4) {predicate = 1} : (i32, i32) -> i1
146
147   // CHECK: %{{[0-9]+}} = cmpi slt, %cst_3, %cst_3 : vector<4xi32>
148   %16 = cmpi slt, %13, %13 : vector<4 x i32>
149
150   // CHECK: %{{[0-9]+}} = cmpi ne, %cst_3, %cst_3 : vector<4xi32>
151   %17 = "std.cmpi"(%13, %13) {predicate = 1} : (vector<4 x i32>, vector<4 x i32>) -> vector<4 x i1>
152
153   // CHECK: %{{[0-9]+}} = cmpi slt, %arg3, %arg3 : index
154   %18 = cmpi slt, %idx, %idx : index
155
156   // CHECK: %{{[0-9]+}} = cmpi eq, %cst_4, %cst_4 : tensor<42xi32>
157   %19 = cmpi eq, %tci32, %tci32 : tensor<42 x i32>
158
159   // CHECK: %{{[0-9]+}} = cmpi eq, %cst_5, %cst_5 : vector<42xi32>
160   %20 = cmpi eq, %vci32, %vci32 : vector<42 x i32>
161
162   // CHECK: %{{[0-9]+}} = select %{{[0-9]+}}, %arg3, %arg3 : index
163   %21 = select %18, %idx, %idx : index
164
165   // CHECK: %{{[0-9]+}} = select %{{[0-9]+}}, %cst_4, %cst_4 : tensor<42xi1>, tensor<42xi32>
166   %22 = select %19, %tci32, %tci32 : tensor<42 x i1>, tensor<42 x i32>
167
168   // CHECK: %{{[0-9]+}} = select %{{[0-9]+}}, %cst_5, %cst_5 : vector<42xi1>, vector<42xi32>
169   %23 = select %20, %vci32, %vci32 : vector<42 x i1>, vector<42 x i32>
170
171   // CHECK: %{{[0-9]+}} = select %{{[0-9]+}}, %arg3, %arg3 : index
172   %24 = "std.select"(%18, %idx, %idx) : (i1, index, index) -> index
173
174   // CHECK: %{{[0-9]+}} = select %{{[0-9]+}}, %cst_4, %cst_4 : tensor<42xi32>
175   %25 = std.select %18, %tci32, %tci32 : tensor<42 x i32>
176
177   // CHECK: %{{[0-9]+}} = divi_signed %arg2, %arg2 : i32
178   %26 = divi_signed %i, %i : i32
179
180   // CHECK: %{{[0-9]+}} = divi_signed %arg3, %arg3 : index
181   %27 = divi_signed %idx, %idx : index
182
183   // CHECK: %{{[0-9]+}} = divi_signed %cst_5, %cst_5 : vector<42xi32>
184   %28 = divi_signed %vci32, %vci32 : vector<42 x i32>
185
186   // CHECK: %{{[0-9]+}} = divi_signed %cst_4, %cst_4 : tensor<42xi32>
187   %29 = divi_signed %tci32, %tci32 : tensor<42 x i32>
188
189   // CHECK: %{{[0-9]+}} = divi_signed %arg2, %arg2 : i32
190   %30 = "std.divi_signed"(%i, %i) : (i32, i32) -> i32
191
192   // CHECK: %{{[0-9]+}} = divi_unsigned %arg2, %arg2 : i32
193   %31 = divi_unsigned %i, %i : i32
194
195   // CHECK: %{{[0-9]+}} = divi_unsigned %arg3, %arg3 : index
196   %32 = divi_unsigned %idx, %idx : index
197
198   // CHECK: %{{[0-9]+}} = divi_unsigned %cst_5, %cst_5 : vector<42xi32>
199   %33 = divi_unsigned %vci32, %vci32 : vector<42 x i32>
200
201   // CHECK: %{{[0-9]+}} = divi_unsigned %cst_4, %cst_4 : tensor<42xi32>
202   %34 = divi_unsigned %tci32, %tci32 : tensor<42 x i32>
203
204   // CHECK: %{{[0-9]+}} = divi_unsigned %arg2, %arg2 : i32
205   %35 = "std.divi_unsigned"(%i, %i) : (i32, i32) -> i32
206
207   // CHECK: %{{[0-9]+}} = remi_signed %arg2, %arg2 : i32
208   %36 = remi_signed %i, %i : i32
209
210   // CHECK: %{{[0-9]+}} = remi_signed %arg3, %arg3 : index
211   %37 = remi_signed %idx, %idx : index
212
213   // CHECK: %{{[0-9]+}} = remi_signed %cst_5, %cst_5 : vector<42xi32>
214   %38 = remi_signed %vci32, %vci32 : vector<42 x i32>
215
216   // CHECK: %{{[0-9]+}} = remi_signed %cst_4, %cst_4 : tensor<42xi32>
217   %39 = remi_signed %tci32, %tci32 : tensor<42 x i32>
218
219   // CHECK: %{{[0-9]+}} = remi_signed %arg2, %arg2 : i32
220   %40 = "std.remi_signed"(%i, %i) : (i32, i32) -> i32
221
222   // CHECK: %{{[0-9]+}} = remi_unsigned %arg2, %arg2 : i32
223   %41 = remi_unsigned %i, %i : i32
224
225   // CHECK: %{{[0-9]+}} = remi_unsigned %arg3, %arg3 : index
226   %42 = remi_unsigned %idx, %idx : index
227
228   // CHECK: %{{[0-9]+}} = remi_unsigned %cst_5, %cst_5 : vector<42xi32>
229   %43 = remi_unsigned %vci32, %vci32 : vector<42 x i32>
230
231   // CHECK: %{{[0-9]+}} = remi_unsigned %cst_4, %cst_4 : tensor<42xi32>
232   %44 = remi_unsigned %tci32, %tci32 : tensor<42 x i32>
233
234   // CHECK: %{{[0-9]+}} = remi_unsigned %arg2, %arg2 : i32
235   %45 = "std.remi_unsigned"(%i, %i) : (i32, i32) -> i32
236
237   // CHECK: %{{[0-9]+}} = divf %arg1, %arg1 : f32
238   %46 = "std.divf"(%f, %f) : (f32,f32) -> f32
239
240   // CHECK: %{{[0-9]+}} = divf %arg1, %arg1 : f32
241   %47 = divf %f, %f : f32
242
243   // CHECK: %{{[0-9]+}} = divf %arg0, %arg0 : tensor<4x4x?xf32>
244   %48 = divf %t, %t : tensor<4x4x?xf32>
245
246   // CHECK: %{{[0-9]+}} = remf %arg1, %arg1 : f32
247   %49 = "std.remf"(%f, %f) : (f32,f32) -> f32
248
249   // CHECK: %{{[0-9]+}} = remf %arg1, %arg1 : f32
250   %50 = remf %f, %f : f32
251
252   // CHECK: %{{[0-9]+}} = remf %arg0, %arg0 : tensor<4x4x?xf32>
253   %51 = remf %t, %t : tensor<4x4x?xf32>
254
255   // CHECK: %{{[0-9]+}} = and %arg2, %arg2 : i32
256   %52 = "std.and"(%i, %i) : (i32,i32) -> i32
257
258   // CHECK: %{{[0-9]+}} = and %arg2, %arg2 : i32
259   %53 = and %i, %i : i32
260
261   // CHECK: %{{[0-9]+}} = and %cst_5, %cst_5 : vector<42xi32>
262   %54 = std.and %vci32, %vci32 : vector<42 x i32>
263
264   // CHECK: %{{[0-9]+}} = and %cst_4, %cst_4 : tensor<42xi32>
265   %55 = and %tci32, %tci32 : tensor<42 x i32>
266
267   // CHECK: %{{[0-9]+}} = or %arg2, %arg2 : i32
268   %56 = "std.or"(%i, %i) : (i32,i32) -> i32
269
270   // CHECK: %{{[0-9]+}} = or %arg2, %arg2 : i32
271   %57 = or %i, %i : i32
272
273   // CHECK: %{{[0-9]+}} = or %cst_5, %cst_5 : vector<42xi32>
274   %58 = std.or %vci32, %vci32 : vector<42 x i32>
275
276   // CHECK: %{{[0-9]+}} = or %cst_4, %cst_4 : tensor<42xi32>
277   %59 = or %tci32, %tci32 : tensor<42 x i32>
278
279   // CHECK: %{{[0-9]+}} = xor %arg2, %arg2 : i32
280   %60 = "std.xor"(%i, %i) : (i32,i32) -> i32
281
282   // CHECK: %{{[0-9]+}} = xor %arg2, %arg2 : i32
283   %61 = xor %i, %i : i32
284
285   // CHECK: %{{[0-9]+}} = xor %cst_5, %cst_5 : vector<42xi32>
286   %62 = std.xor %vci32, %vci32 : vector<42 x i32>
287
288   // CHECK: %{{[0-9]+}} = xor %cst_4, %cst_4 : tensor<42xi32>
289   %63 = xor %tci32, %tci32 : tensor<42 x i32>
290
291   %64 = constant dense<0.> : vector<4 x f32>
292   %tcf32 = constant dense<0.> : tensor<42 x f32>
293   %vcf32 = constant dense<0.> : vector<4 x f32>
294
295   // CHECK: %{{[0-9]+}} = cmpf ogt, %{{[0-9]+}}, %{{[0-9]+}} : f32
296   %65 = cmpf ogt, %f3, %f4 : f32
297
298   // Predicate 0 means ordered equality comparison.
299   // CHECK: %{{[0-9]+}} = cmpf oeq, %{{[0-9]+}}, %{{[0-9]+}} : f32
300   %66 = "std.cmpf"(%f3, %f4) {predicate = 1} : (f32, f32) -> i1
301
302   // CHECK: %{{[0-9]+}} = cmpf olt, %cst_8, %cst_8 : vector<4xf32>
303   %67 = cmpf olt, %vcf32, %vcf32 : vector<4 x f32>
304
305   // CHECK: %{{[0-9]+}} = cmpf oeq, %cst_8, %cst_8 : vector<4xf32>
306   %68 = "std.cmpf"(%vcf32, %vcf32) {predicate = 1} : (vector<4 x f32>, vector<4 x f32>) -> vector<4 x i1>
307
308   // CHECK: %{{[0-9]+}} = cmpf oeq, %cst_7, %cst_7 : tensor<42xf32>
309   %69 = cmpf oeq, %tcf32, %tcf32 : tensor<42 x f32>
310
311   // CHECK: %{{[0-9]+}} = cmpf oeq, %cst_8, %cst_8 : vector<4xf32>
312   %70 = cmpf oeq, %vcf32, %vcf32 : vector<4 x f32>
313
314   // CHECK: %{{[0-9]+}} = rank %arg0 : tensor<4x4x?xf32>
315   %71 = "std.rank"(%t) : (tensor<4x4x?xf32>) -> index
316
317   // CHECK: %{{[0-9]+}} = rank %arg0 : tensor<4x4x?xf32>
318   %72 = rank %t : tensor<4x4x?xf32>
319
320   // CHECK: = constant unit
321   %73 = constant unit
322
323   // CHECK: constant true
324   %74 = constant true
325
326   // CHECK: constant false
327   %75 = constant false
328
329   // CHECK: = index_cast {{.*}} : index to i64
330   %76 = index_cast %idx : index to i64
331
332   // CHECK: = index_cast {{.*}} : i32 to index
333   %77 = index_cast %i : i32 to index
334
335   // CHECK: = sitofp {{.*}} : i32 to f32
336   %78 = sitofp %i : i32 to f32
337
338   // CHECK: = sitofp {{.*}} : i32 to f64
339   %79 = sitofp %i : i32 to f64
340
341   // CHECK: = sitofp {{.*}} : i64 to f32
342   %80 = sitofp %j : i64 to f32
343
344   // CHECK: = sitofp {{.*}} : i64 to f64
345   %81 = sitofp %j : i64 to f64
346
347   // CHECK: = sexti %arg2 : i32 to i64
348   %82 = "std.sexti"(%i) : (i32) -> i64
349
350   // CHECK: = sexti %arg2 : i32 to i64
351   %83 = sexti %i : i32 to i64
352
353   // CHECK: %{{[0-9]+}} = sexti %cst_5 : vector<42xi32>
354   %84 = sexti %vci32 : vector<42 x i32> to vector<42 x i64>
355
356   // CHECK: %{{[0-9]+}} = sexti %cst_4 : tensor<42xi32>
357   %85 = sexti %tci32 : tensor<42 x i32> to tensor<42 x i64>
358
359   // CHECK: = zexti %arg2 : i32 to i64
360   %86 = "std.zexti"(%i) : (i32) -> i64
361
362   // CHECK: = zexti %arg2 : i32 to i64
363   %87 = zexti %i : i32 to i64
364
365   // CHECK: %{{[0-9]+}} = zexti %cst_5 : vector<42xi32>
366   %88 = zexti %vci32 : vector<42 x i32> to vector<42 x i64>
367
368   // CHECK: %{{[0-9]+}} = zexti %cst_4 : tensor<42xi32>
369   %89 = zexti %tci32 : tensor<42 x i32> to tensor<42 x i64>
370
371   // CHECK: = trunci %arg2 : i32 to i16
372   %90 = "std.trunci"(%i) : (i32) -> i16
373
374   // CHECK: = trunci %arg2 : i32 to i16
375   %91 = trunci %i : i32 to i16
376
377   // CHECK: %{{[0-9]+}} = trunci %cst_5 : vector<42xi32>
378   %92 = trunci %vci32 : vector<42 x i32> to vector<42 x i16>
379
380   // CHECK: %{{[0-9]+}} = trunci %cst_4 : tensor<42xi32>
381   %93 = trunci %tci32 : tensor<42 x i32> to tensor<42 x i16>
382
383   // CHECK: = fpext {{.*}} : f16 to f32
384   %94 = fpext %half : f16 to f32
385
386   // CHECK: = fptrunc {{.*}} : f32 to f16
387   %95 = fptrunc %f : f32 to f16
388
389   // CHECK: %{{[0-9]+}} = exp %arg1 : f32
390   %96 = "std.exp"(%f) : (f32) -> f32
391
392   // CHECK: %{{[0-9]+}} = exp %arg1 : f32
393   %97 = exp %f : f32
394
395   // CHECK: %{{[0-9]+}} = exp %cst_8 : vector<4xf32>
396   %98 = exp %vcf32 : vector<4xf32>
397
398   // CHECK: %{{[0-9]+}} = exp %arg0 : tensor<4x4x?xf32>
399   %99 = exp %t : tensor<4x4x?xf32>
400
401   // CHECK: %{{[0-9]+}} = absf %arg1 : f32
402   %100 = "std.absf"(%f) : (f32) -> f32
403
404   // CHECK: %{{[0-9]+}} = absf %arg1 : f32
405   %101 = absf %f : f32
406
407   // CHECK: %{{[0-9]+}} = absf %cst_8 : vector<4xf32>
408   %102 = absf %vcf32 : vector<4xf32>
409
410   // CHECK: %{{[0-9]+}} = absf %arg0 : tensor<4x4x?xf32>
411   %103 = absf %t : tensor<4x4x?xf32>
412
413   // CHECK: %{{[0-9]+}} = ceilf %arg1 : f32
414   %104 = "std.ceilf"(%f) : (f32) -> f32
415
416   // CHECK: %{{[0-9]+}} = ceilf %arg1 : f32
417   %105 = ceilf %f : f32
418
419   // CHECK: %{{[0-9]+}} = ceilf %cst_8 : vector<4xf32>
420   %106 = ceilf %vcf32 : vector<4xf32>
421
422   // CHECK: %{{[0-9]+}} = ceilf %arg0 : tensor<4x4x?xf32>
423   %107 = ceilf %t : tensor<4x4x?xf32>
424
425   // CHECK: %{{[0-9]+}} = cos %arg1 : f32
426   %108 = "std.cos"(%f) : (f32) -> f32
427
428   // CHECK: %{{[0-9]+}} = cos %arg1 : f32
429   %109 = cos %f : f32
430
431   // CHECK: %{{[0-9]+}} = cos %cst_8 : vector<4xf32>
432   %110 = cos %vcf32 : vector<4xf32>
433
434   // CHECK: %{{[0-9]+}} = cos %arg0 : tensor<4x4x?xf32>
435   %111 = cos %t : tensor<4x4x?xf32>
436
437   // CHECK: %{{[0-9]+}} = negf %arg1 : f32
438   %112 = "std.negf"(%f) : (f32) -> f32
439
440   // CHECK: %{{[0-9]+}} = negf %arg1 : f32
441   %113 = negf %f : f32
442
443   // CHECK: %{{[0-9]+}} = negf %cst_8 : vector<4xf32>
444   %114 = negf %vcf32 : vector<4xf32>
445
446   // CHECK: %{{[0-9]+}} = negf %arg0 : tensor<4x4x?xf32>
447   %115 = negf %t : tensor<4x4x?xf32>
448
449   // CHECK: %{{[0-9]+}} = copysign %arg1, %arg1 : f32
450   %116 = "std.copysign"(%f, %f) : (f32, f32) -> f32
451
452   // CHECK: %{{[0-9]+}} = copysign %arg1, %arg1 : f32
453   %117 = copysign %f, %f : f32
454
455   // CHECK: %{{[0-9]+}} = copysign %cst_8, %cst_8 : vector<4xf32>
456   %118 = copysign %vcf32, %vcf32 : vector<4xf32>
457
458   // CHECK: %{{[0-9]+}} = copysign %arg0, %arg0 : tensor<4x4x?xf32>
459   %119 = copysign %t, %t : tensor<4x4x?xf32>
460
461   // CHECK: %{{[0-9]+}} = tanh %arg1 : f32
462   %120 = "std.tanh"(%f) : (f32) -> f32
463
464   // CHECK: %{{[0-9]+}} = tanh %arg1 : f32
465   %121 = tanh %f : f32
466
467   // CHECK: %{{[0-9]+}} = tanh %cst_8 : vector<4xf32>
468   %122 = tanh %vcf32 : vector<4xf32>
469
470   // CHECK: %{{[0-9]+}} = tanh %arg0 : tensor<4x4x?xf32>
471   %123 = tanh %t : tensor<4x4x?xf32>
472
473   // CHECK: %{{[0-9]+}} = shift_left %arg2, %arg2 : i32
474   %124 = "std.shift_left"(%i, %i) : (i32, i32) -> i32
475
476   // CHECK:%{{[0-9]+}} = shift_left %[[I2]], %[[I2]] : i32
477   %125 = shift_left %i2, %i2 : i32
478
479   // CHECK: %{{[0-9]+}} = shift_left %arg3, %arg3 : index
480   %126 = shift_left %idx, %idx : index
481
482   // CHECK: %{{[0-9]+}} = shift_left %cst_5, %cst_5 : vector<42xi32>
483   %127 = shift_left %vci32, %vci32 : vector<42 x i32>
484
485   // CHECK: %{{[0-9]+}} = shift_left %cst_4, %cst_4 : tensor<42xi32>
486   %128 = shift_left %tci32, %tci32 : tensor<42 x i32>
487
488   // CHECK: %{{[0-9]+}} = shift_right_signed %arg2, %arg2 : i32
489   %129 = "std.shift_right_signed"(%i, %i) : (i32, i32) -> i32
490
491   // CHECK:%{{[0-9]+}} = shift_right_signed %[[I2]], %[[I2]] : i32
492   %130 = shift_right_signed %i2, %i2 : i32
493
494   // CHECK: %{{[0-9]+}} = shift_right_signed %arg3, %arg3 : index
495   %131 = shift_right_signed %idx, %idx : index
496
497   // CHECK: %{{[0-9]+}} = shift_right_signed %cst_5, %cst_5 : vector<42xi32>
498   %132 = shift_right_signed %vci32, %vci32 : vector<42 x i32>
499
500   // CHECK: %{{[0-9]+}} = shift_right_signed %cst_4, %cst_4 : tensor<42xi32>
501   %133 = shift_right_signed %tci32, %tci32 : tensor<42 x i32>
502
503   // CHECK: %{{[0-9]+}} = shift_right_unsigned %arg2, %arg2 : i32
504   %134 = "std.shift_right_unsigned"(%i, %i) : (i32, i32) -> i32
505
506   // CHECK:%{{[0-9]+}} = shift_right_unsigned %[[I2]], %[[I2]] : i32
507   %135 = shift_right_unsigned %i2, %i2 : i32
508
509   // CHECK: %{{[0-9]+}} = shift_right_unsigned %arg3, %arg3 : index
510   %136 = shift_right_unsigned %idx, %idx : index
511
512   // CHECK: %{{[0-9]+}} = shift_right_unsigned %cst_5, %cst_5 : vector<42xi32>
513   %137 = shift_right_unsigned %vci32, %vci32 : vector<42 x i32>
514
515   // CHECK: %{{[0-9]+}} = shift_right_unsigned %cst_4, %cst_4 : tensor<42xi32>
516   %138 = shift_right_unsigned %tci32, %tci32 : tensor<42 x i32>
517
518   // CHECK: %{{[0-9]+}} = sqrt %arg1 : f32
519   %139 = "std.sqrt"(%f) : (f32) -> f32
520
521   // CHECK: %{{[0-9]+}} = sqrt %arg1 : f32
522   %140 = sqrt %f : f32
523
524   // CHECK: %{{[0-9]+}} = sqrt %cst_8 : vector<4xf32>
525   %141 = sqrt %vcf32 : vector<4xf32>
526
527   // CHECK: %{{[0-9]+}} = sqrt %arg0 : tensor<4x4x?xf32>
528   %142 = sqrt %t : tensor<4x4x?xf32>
529
530   // CHECK: = fpext {{.*}} : vector<4xf32> to vector<4xf64>
531   %143 = fpext %vcf32 : vector<4xf32> to vector<4xf64>
532
533   // CHECK: = fptrunc {{.*}} : vector<4xf32> to vector<4xf16>
534   %144 = fptrunc %vcf32 : vector<4xf32> to vector<4xf16>
535
536   // CHECK: %{{[0-9]+}} = rsqrt %arg1 : f32
537   %145 = rsqrt %f : f32
538
539   // CHECK: %{{[0-9]+}} = sin %arg1 : f32
540   %146 = "std.sin"(%f) : (f32) -> f32
541
542   // CHECK: %{{[0-9]+}} = sin %arg1 : f32
543   %147 = sin %f : f32
544
545   // CHECK: %{{[0-9]+}} = sin %cst_8 : vector<4xf32>
546   %148 = sin %vcf32 : vector<4xf32>
547
548   // CHECK: %{{[0-9]+}} = sin %arg0 : tensor<4x4x?xf32>
549   %149 = sin %t : tensor<4x4x?xf32>
550
551   // CHECK: = fptosi {{.*}} : f32 to i32
552   %159 = fptosi %f : f32 to i32
553
554   // CHECK: = fptosi {{.*}} : f32 to i64
555   %160 = fptosi %f : f32 to i64
556
557   // CHECK: = fptosi {{.*}} : f16 to i32
558   %161 = fptosi %half : f16 to i32
559
560   // CHECK: = fptosi {{.*}} : f16 to i64
561   %162 = fptosi %half : f16 to i64
562
563   // CHECK: floorf %arg1 : f32
564   %163 = "std.floorf"(%f) : (f32) -> f32
565
566   // CHECK: %{{[0-9]+}} = floorf %arg1 : f32
567   %164 = floorf %f : f32
568
569   // CHECK: %{{[0-9]+}} = floorf %cst_8 : vector<4xf32>
570   %165 = floorf %vcf32 : vector<4xf32>
571
572   // CHECK: %{{[0-9]+}} = floorf %arg0 : tensor<4x4x?xf32>
573   %166 = floorf %t : tensor<4x4x?xf32>
574
575   // CHECK: %{{[0-9]+}} = floordivi_signed %arg2, %arg2 : i32
576   %167 = floordivi_signed %i, %i : i32
577
578   // CHECK: %{{[0-9]+}} = floordivi_signed %arg3, %arg3 : index
579   %168 = floordivi_signed %idx, %idx : index
580
581   // CHECK: %{{[0-9]+}} = floordivi_signed %cst_5, %cst_5 : vector<42xi32>
582   %169 = floordivi_signed %vci32, %vci32 : vector<42 x i32>
583
584   // CHECK: %{{[0-9]+}} = floordivi_signed %cst_4, %cst_4 : tensor<42xi32>
585   %170 = floordivi_signed %tci32, %tci32 : tensor<42 x i32>
586
587   // CHECK: %{{[0-9]+}} = ceildivi_signed %arg2, %arg2 : i32
588   %171 = ceildivi_signed %i, %i : i32
589
590   // CHECK: %{{[0-9]+}} = ceildivi_signed %arg3, %arg3 : index
591   %172 = ceildivi_signed %idx, %idx : index
592
593   // CHECK: %{{[0-9]+}} = ceildivi_signed %cst_5, %cst_5 : vector<42xi32>
594   %173 = ceildivi_signed %vci32, %vci32 : vector<42 x i32>
595
596   // CHECK: %{{[0-9]+}} = ceildivi_signed %cst_4, %cst_4 : tensor<42xi32>
597   %174 = ceildivi_signed %tci32, %tci32 : tensor<42 x i32>
598
599   // CHECK: %{{[0-9]+}} = log1p %arg1 : f32
600   %175 = log1p %f : f32
601
602   return
603 }
604
605 // CHECK-LABEL: func @affine_apply() {
606 func @affine_apply() {
607   %i = "std.constant"() {value = 0: index} : () -> index
608   %j = "std.constant"() {value = 1: index} : () -> index
609
610   // CHECK: affine.apply #map0(%c0)
611   %a = "affine.apply" (%i) { map = affine_map<(d0) -> (d0 + 1)> } :
612     (index) -> (index)
613
614   // CHECK: affine.apply #map1()[%c0]
615   %b = affine.apply affine_map<()[x] -> (x+1)>()[%i]
616
617   return
618 }
619
620 // CHECK-LABEL: func @load_store_prefetch
621 func @load_store_prefetch(memref<4x4xi32>, index) {
622 ^bb0(%0: memref<4x4xi32>, %1: index):
623   // CHECK: %0 = load %arg0[%arg1, %arg1] : memref<4x4xi32>
624   %2 = "std.load"(%0, %1, %1) : (memref<4x4xi32>, index, index)->i32
625
626   // CHECK: %{{.*}} = load %arg0[%arg1, %arg1] : memref<4x4xi32>
627   %3 = load %0[%1, %1] : memref<4x4xi32>
628
629   // CHECK: prefetch %arg0[%arg1, %arg1], write, locality<1>, data : memref<4x4xi32>
630   prefetch %0[%1, %1], write, locality<1>, data : memref<4x4xi32>
631
632   // CHECK: prefetch %arg0[%arg1, %arg1], read, locality<3>, instr : memref<4x4xi32>
633   prefetch %0[%1, %1], read, locality<3>, instr : memref<4x4xi32>
634
635   return
636 }
637
638 // Test with zero-dimensional operands using no index in load/store.
639 // CHECK-LABEL: func @zero_dim_no_idx
640 func @zero_dim_no_idx(%arg0 : memref<i32>, %arg1 : memref<i32>, %arg2 : memref<i32>) {
641   %0 = std.load %arg0[] : memref<i32>
642   std.store %0, %arg1[] : memref<i32>
643   return
644   // CHECK: %0 = load %{{.*}}[] : memref<i32>
645   // CHECK: store %{{.*}}, %{{.*}}[] : memref<i32>
646 }
647
648 // CHECK-LABEL: func @return_op(%arg0: i32) -> i32 {
649 func @return_op(%a : i32) -> i32 {
650   // CHECK: return %arg0 : i32
651   "std.return" (%a) : (i32)->()
652 }
653
654 // CHECK-LABEL: func @calls(%arg0: i32) {
655 func @calls(%arg0: i32) {
656   // CHECK: %0 = call @return_op(%arg0) : (i32) -> i32
657   %x = call @return_op(%arg0) : (i32) -> i32
658   // CHECK: %1 = call @return_op(%0) : (i32) -> i32
659   %y = call @return_op(%x) : (i32) -> i32
660   // CHECK: %2 = call @return_op(%0) : (i32) -> i32
661   %z = "std.call"(%x) {callee = @return_op} : (i32) -> i32
662
663   // CHECK: %f = constant @affine_apply : () -> ()
664   %f = constant @affine_apply : () -> ()
665
666   // CHECK: call_indirect %f() : () -> ()
667   call_indirect %f() : () -> ()
668
669   // CHECK: %f_0 = constant @return_op : (i32) -> i32
670   %f_0 = constant @return_op : (i32) -> i32
671
672   // CHECK: %3 = call_indirect %f_0(%arg0) : (i32) -> i32
673   %2 = call_indirect %f_0(%arg0) : (i32) -> i32
674
675   // CHECK: %4 = call_indirect %f_0(%arg0) : (i32) -> i32
676   %3 = "std.call_indirect"(%f_0, %arg0) : ((i32) -> i32, i32) -> i32
677
678   return
679 }
680
681 // CHECK-LABEL: func @memref_cast(%arg0
682 func @memref_cast(%arg0: memref<4xf32>, %arg1 : memref<?xf32>, %arg2 : memref<64x16x4xf32, offset: 0, strides: [64, 4, 1]>) {
683   // CHECK: %0 = memref_cast %arg0 : memref<4xf32> to memref<?xf32>
684   %0 = memref_cast %arg0 : memref<4xf32> to memref<?xf32>
685
686   // CHECK: %1 = memref_cast %arg1 : memref<?xf32> to memref<4xf32>
687   %1 = memref_cast %arg1 : memref<?xf32> to memref<4xf32>
688
689   // CHECK: {{%.*}} = memref_cast %arg2 : memref<64x16x4xf32, #[[$BASE_MAP0]]> to memref<64x16x4xf32, #[[$BASE_MAP3]]>
690   %2 = memref_cast %arg2 : memref<64x16x4xf32, offset: 0, strides: [64, 4, 1]> to memref<64x16x4xf32, offset: ?, strides: [?, ?, ?]>
691
692   // CHECK: {{%.*}} = memref_cast {{%.*}} : memref<64x16x4xf32, #[[$BASE_MAP3]]> to memref<64x16x4xf32, #[[$BASE_MAP0]]>
693   %3 = memref_cast %2 : memref<64x16x4xf32, offset: ?, strides: [?, ?, ?]> to memref<64x16x4xf32, offset: 0, strides: [64, 4, 1]>
694
695   // CHECK: memref_cast %{{.*}} : memref<4xf32> to memref<*xf32>
696   %4 = memref_cast %1 : memref<4xf32> to memref<*xf32>
697
698   // CHECK: memref_cast %{{.*}} : memref<*xf32> to memref<4xf32>
699   %5 = memref_cast %4 : memref<*xf32> to memref<4xf32>
700   return
701 }
702
703 // Check that unranked memrefs with non-default memory space roundtrip
704 // properly.
705 // CHECK-LABEL: @unranked_memref_roundtrip(memref<*xf32, 4>)
706 func private @unranked_memref_roundtrip(memref<*xf32, 4>)
707
708 // CHECK-LABEL: func @memref_view(%arg0
709 func @memref_view(%arg0 : index, %arg1 : index, %arg2 : index) {
710   %0 = alloc() : memref<2048xi8>
711   // Test two dynamic sizes and dynamic offset.
712   // CHECK: %{{.*}} = std.view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32>
713   %1 = view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32>
714
715   // Test one dynamic size and dynamic offset.
716   // CHECK: %{{.*}} = std.view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32>
717   %3 = view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32>
718
719   // Test static sizes and static offset.
720   // CHECK: %{{.*}} = std.view %0[{{.*}}][] : memref<2048xi8> to memref<64x4xf32>
721   %c0 = constant 0: index
722   %5 = view %0[%c0][] : memref<2048xi8> to memref<64x4xf32>
723   return
724 }
725
726 // CHECK-LABEL: func @memref_subview(%arg0
727 func @memref_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
728   %c0 = constant 0 : index
729   %c1 = constant 1 : index
730
731   %0 = alloc() : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>>
732   // CHECK: subview %0[%c0, %c0, %c0] [%arg0, %arg1, %arg2] [%c1, %c1, %c1] :
733   // CHECK-SAME: memref<8x16x4xf32, #[[$BASE_MAP0]]>
734   // CHECK-SAME: to memref<?x?x?xf32, #[[$BASE_MAP3]]>
735   %1 = subview %0[%c0, %c0, %c0][%arg0, %arg1, %arg2][%c1, %c1, %c1]
736     : memref<8x16x4xf32, offset:0, strides: [64, 4, 1]> to
737       memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
738
739   %2 = alloc()[%arg2] : memref<64xf32, affine_map<(d0)[s0] -> (d0 + s0)>>
740   // CHECK: subview %2[%c1] [%arg0] [%c1] :
741   // CHECK-SAME: memref<64xf32, #[[$BASE_MAP1]]>
742   // CHECK-SAME: to memref<?xf32, #[[$SUBVIEW_MAP1]]>
743   %3 = subview %2[%c1][%arg0][%c1]
744     : memref<64xf32, affine_map<(d0)[s0] -> (d0 + s0)>> to
745       memref<?xf32, affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>>
746
747   %4 = alloc() : memref<64x22xf32, affine_map<(d0, d1) -> (d0 * 22 + d1)>>
748   // CHECK: subview %4[%c0, %c1] [%arg0, %arg1] [%c1, %c0] :
749   // CHECK-SAME: memref<64x22xf32, #[[$BASE_MAP2]]>
750   // CHECK-SAME: to memref<?x?xf32, #[[$SUBVIEW_MAP2]]>
751   %5 = subview %4[%c0, %c1][%arg0, %arg1][%c1, %c0]
752     : memref<64x22xf32, offset:0, strides: [22, 1]> to
753       memref<?x?xf32, offset:?, strides: [?, ?]>
754
755   // CHECK: subview %0[0, 2, 0] [4, 4, 4] [1, 1, 1] :
756   // CHECK-SAME: memref<8x16x4xf32, #[[$BASE_MAP0]]>
757   // CHECK-SAME: to memref<4x4x4xf32, #[[$SUBVIEW_MAP3]]>
758   %6 = subview %0[0, 2, 0][4, 4, 4][1, 1, 1]
759     : memref<8x16x4xf32, offset:0, strides: [64, 4, 1]> to
760       memref<4x4x4xf32, offset:8, strides: [64, 4, 1]>
761
762   %7 = alloc(%arg1, %arg2) : memref<?x?xf32>
763   // CHECK: subview {{%.*}}[0, 0] [4, 4] [1, 1] :
764   // CHECK-SAME: memref<?x?xf32>
765   // CHECK-SAME: to memref<4x4xf32, #[[$SUBVIEW_MAP4]]>
766   %8 = subview %7[0, 0][4, 4][1, 1]
767     : memref<?x?xf32> to memref<4x4xf32, offset: ?, strides:[?, 1]>
768
769   %9 = alloc() : memref<16x4xf32>
770   // CHECK: subview {{%.*}}[{{%.*}}, {{%.*}}] [4, 4] [{{%.*}}, {{%.*}}] :
771   // CHECK-SAME: memref<16x4xf32>
772   // CHECK-SAME: to memref<4x4xf32, #[[$SUBVIEW_MAP2]]
773   %10 = subview %9[%arg1, %arg1][4, 4][%arg2, %arg2]
774     : memref<16x4xf32> to memref<4x4xf32, offset: ?, strides:[?, ?]>
775
776   // CHECK: subview {{%.*}}[{{%.*}}, {{%.*}}] [4, 4] [2, 2] :
777   // CHECK-SAME: memref<16x4xf32>
778   // CHECK-SAME: to memref<4x4xf32, #[[$SUBVIEW_MAP5]]
779   %11 = subview %9[%arg1, %arg2][4, 4][2, 2]
780     : memref<16x4xf32> to memref<4x4xf32, offset: ?, strides:[8, 2]>
781
782   %12 = alloc() : memref<1x9x1x4x1xf32, affine_map<(d0, d1, d2, d3, d4) -> (36 * d0 + 36 * d1 + 4 * d2 + 4 * d3 + d4)>>
783   // CHECK: subview %12[%arg1, %arg1, %arg1, %arg1, %arg1]
784   // CHECK-SAME: [1, 9, 1, 4, 1] [%arg2, %arg2, %arg2, %arg2, %arg2] :
785   // CHECK-SAME: memref<1x9x1x4x1xf32, #[[$SUBVIEW_MAP6]]> to memref<9x4xf32, #[[$SUBVIEW_MAP2]]>
786   %13 = subview %12[%arg1, %arg1, %arg1, %arg1, %arg1][1, 9, 1, 4, 1][%arg2, %arg2, %arg2, %arg2, %arg2] : memref<1x9x1x4x1xf32, offset: 0, strides: [36, 36, 4, 4, 1]> to memref<9x4xf32, offset: ?, strides: [?, ?]>
787   // CHECK: subview %12[%arg1, %arg1, %arg1, %arg1, %arg1]
788   // CHECK-SAME: [1, 9, 1, 4, 1] [%arg2, %arg2, %arg2, %arg2, %arg2] :
789   // CHECK-SAME: memref<1x9x1x4x1xf32, #[[$SUBVIEW_MAP6]]> to memref<1x9x4xf32, #[[$BASE_MAP3]]>
790   %14 = subview %12[%arg1, %arg1, %arg1, %arg1, %arg1][1, 9, 1, 4, 1][%arg2, %arg2, %arg2, %arg2, %arg2] : memref<1x9x1x4x1xf32, offset: 0, strides: [36, 36, 4, 4, 1]> to memref<1x9x4xf32, offset: ?, strides: [?, ?, ?]>
791
792   %15 = alloc(%arg1, %arg2)[%c0, %c1, %arg1, %arg0, %arg0, %arg2, %arg2] : memref<1x?x5x1x?x1xf32, affine_map<(d0, d1, d2, d3, d4, d5)[s0, s1, s2, s3, s4, s5, s6] -> (s0 + s1 * d0 + s2 * d1 + s3 * d2 + s4 * d3 + s5 * d4 + s6 * d5)>>
793   // CHECK: subview %15[0, 0, 0, 0, 0, 0] [1, %arg1, 5, 1, %arg2, 1] [1, 1, 1, 1, 1, 1]  :
794   // CHECK-SAME: memref<1x?x5x1x?x1xf32,  #[[$SUBVIEW_MAP7]]> to memref<?x5x?xf32, #[[$BASE_MAP3]]>
795   %16 = subview %15[0, 0, 0, 0, 0, 0][1, %arg1, 5, 1, %arg2, 1][1, 1, 1, 1, 1, 1] : memref<1x?x5x1x?x1xf32, offset: ?, strides: [?, ?, ?, ?, ?, ?]> to memref<?x5x?xf32, offset: ?, strides: [?, ?, ?]>
796   // CHECK: subview %15[%arg1, %arg1, %arg1, %arg1, %arg1, %arg1] [1, %arg1, 5, 1, %arg2, 1] [1, 1, 1, 1, 1, 1]  :
797   // CHECK-SAME: memref<1x?x5x1x?x1xf32, #[[$SUBVIEW_MAP7]]> to memref<?x5x?x1xf32, #[[$SUBVIEW_MAP8]]>
798   %17 = subview %15[%arg1, %arg1, %arg1, %arg1, %arg1, %arg1][1, %arg1, 5, 1, %arg2, 1][1, 1, 1, 1, 1, 1] :  memref<1x?x5x1x?x1xf32, offset: ?, strides: [?, ?, ?, ?, ?, ?]> to memref<?x5x?x1xf32, offset: ?, strides: [?, ?, ?, ?]>
799
800   %18 = alloc() : memref<1x8xf32>
801   // CHECK: subview %18[0, 0] [1, 8] [1, 1]  : memref<1x8xf32> to memref<8xf32>
802   %19 = subview %18[0, 0][1, 8][1, 1] : memref<1x8xf32> to memref<8xf32>
803
804   %20 = alloc() : memref<8x16x4xf32>
805   // CHECK: subview %20[0, 0, 0] [1, 16, 4] [1, 1, 1]  : memref<8x16x4xf32> to memref<16x4xf32>
806   %21 = subview %20[0, 0, 0][1, 16, 4][1, 1, 1] : memref<8x16x4xf32> to memref<16x4xf32>
807
808   %22 = subview %20[3, 4, 2][1, 6, 3][1, 1, 1] : memref<8x16x4xf32> to memref<6x3xf32, offset: 210, strides: [4, 1]>
809
810   %23 = alloc() : memref<f32>
811   %78 = subview %23[] [] []  : memref<f32> to memref<f32>
812   return
813 }
814
815 // CHECK-LABEL: func @test_dimop
816 // CHECK-SAME: %[[ARG:.*]]: tensor<4x4x?xf32>
817 func @test_dimop(%arg0: tensor<4x4x?xf32>) {
818   // CHECK: %[[C2:.*]] = constant 2 : index
819   // CHECK: %{{.*}} = dim %[[ARG]], %[[C2]] : tensor<4x4x?xf32>
820   %c2 = constant 2 : index
821   %0 = dim %arg0, %c2 : tensor<4x4x?xf32>
822   // use dim as an index to ensure type correctness
823   %1 = affine.apply affine_map<(d0) -> (d0)>(%0)
824   return
825 }
826
827 // CHECK-LABEL: func @test_splat_op
828 // CHECK-SAME: [[S:%arg[0-9]+]]: f32
829 func @test_splat_op(%s : f32) {
830   %v = splat %s : vector<8xf32>
831   // CHECK: splat [[S]] : vector<8xf32>
832   %t = splat %s : tensor<8xf32>
833   // CHECK: splat [[S]] : tensor<8xf32>
834   %u = "std.splat"(%s) : (f32) -> vector<4xf32>
835   // CHECK: splat [[S]] : vector<4xf32>
836   return
837 }
838
839 // CHECK-LABEL: func @tensor_load_store
840 func @tensor_load_store(%0 : memref<4x4xi32>) {
841   // CHECK: %[[TENSOR:.*]] = tensor_load %[[MEMREF:.*]] : memref<4x4xi32>
842   %1 = tensor_load %0 : memref<4x4xi32>
843   // CHECK: tensor_store %[[TENSOR]], %[[MEMREF]] : memref<4x4xi32>
844   tensor_store %1, %0 : memref<4x4xi32>
845   return
846 }
847
848 // CHECK-LABEL: func @unranked_tensor_load_store
849 func @unranked_tensor_load_store(%0 : memref<*xi32>) {
850   // CHECK: %[[TENSOR:.*]] = tensor_load %[[MEMREF:.*]] : memref<*xi32>
851   %1 = tensor_load %0 : memref<*xi32>
852   // CHECK: tensor_store %[[TENSOR]], %[[MEMREF]] : memref<*xi32>
853   tensor_store %1, %0 : memref<*xi32>
854   return
855 }
856
857 // CHECK-LABEL: func @atomic_rmw
858 // CHECK-SAME: ([[BUF:%.*]]: memref<10xf32>, [[VAL:%.*]]: f32, [[I:%.*]]: index)
859 func @atomic_rmw(%I: memref<10xf32>, %val: f32, %i : index) {
860   %x = atomic_rmw addf %val, %I[%i] : (f32, memref<10xf32>) -> f32
861   // CHECK: atomic_rmw addf [[VAL]], [[BUF]]{{\[}}[[I]]]
862   return
863 }
864
865 // CHECK-LABEL: func @generic_atomic_rmw
866 // CHECK-SAME: ([[BUF:%.*]]: memref<1x2xf32>, [[I:%.*]]: index, [[J:%.*]]: index)
867 func @generic_atomic_rmw(%I: memref<1x2xf32>, %i : index, %j : index) {
868   %x = generic_atomic_rmw %I[%i, %j] : memref<1x2xf32> {
869   // CHECK-NEXT: generic_atomic_rmw [[BUF]]{{\[}}[[I]], [[J]]] : memref
870     ^bb0(%old_value : f32):
871       %c1 = constant 1.0 : f32
872       %out = addf %c1, %old_value : f32
873       atomic_yield %out : f32
874   // CHECK: index_attr = 8 : index
875   } { index_attr = 8 : index }
876   return
877 }
878
879 // CHECK-LABEL: func @assume_alignment
880 // CHECK-SAME: %[[MEMREF:.*]]: memref<4x4xf16>
881 func @assume_alignment(%0: memref<4x4xf16>) {
882   // CHECK: assume_alignment %[[MEMREF]], 16 : memref<4x4xf16>
883   assume_alignment %0, 16 : memref<4x4xf16>
884   return
885 }
886
887 // CHECK-LABEL: func @subtensor({{.*}}) {
888 func @subtensor(%t: tensor<8x16x4xf32>, %idx : index) {
889   %c0 = constant 0 : index
890   %c1 = constant 1 : index
891
892   // CHECK: subtensor
893   // CHECK-SAME: tensor<8x16x4xf32> to tensor<?x?x?xf32>
894   %1 = subtensor %t[%c0, %c0, %c0][%idx, %idx, %idx][%c1, %c1, %c1]
895     : tensor<8x16x4xf32> to tensor<?x?x?xf32>
896
897   // CHECK: subtensor
898   // CHECK-SAME: tensor<8x16x4xf32> to tensor<4x4x4xf32>
899   %2 = subtensor %t[0, 2, 0][4, 4, 4][1, 1, 1]
900     : tensor<8x16x4xf32> to tensor<4x4x4xf32>
901
902   // CHECK: subtensor
903   // CHECK-SAME: tensor<8x16x4xf32> to tensor<4x4xf32>
904   %3 = subtensor %t[0, 2, 0][4, 1, 4][1, 1, 1]
905     : tensor<8x16x4xf32> to tensor<4x4xf32>
906
907   return
908 }
909
910 // CHECK-LABEL: func @subtensor_insert({{.*}}) {
911 func @subtensor_insert(%t: tensor<8x16x4xf32>, %t2: tensor<16x32x8xf32>, %idx : index) {
912   %c0 = constant 0 : index
913   %c1 = constant 1 : index
914
915   // CHECK: subtensor_insert
916   // CHECK-SAME: tensor<8x16x4xf32> into tensor<16x32x8xf32>
917   %1 = subtensor_insert %t into %t2[%c0, %c0, %c0][%idx, %idx, %idx][%c1, %c1, %c1]
918     : tensor<8x16x4xf32> into tensor<16x32x8xf32>
919
920   // CHECK: subtensor_insert
921   // CHECK-SAME: tensor<8x16x4xf32> into tensor<16x32x8xf32>
922   %2 = subtensor_insert %t into %t2[%c0, %idx, %c0][%idx, 4, %idx][%c1, 1, %c1]
923     : tensor<8x16x4xf32> into tensor<16x32x8xf32>
924
925   return
926 }