1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
// RUN: mlir-opt -allow-unregistered-dialect %s -inline="default-pipeline=''" | FileCheck %s
// Basic test that functions within affine operations are inlined.
func.func @func_with_affine_ops(%N: index) {
%c = arith.constant 200 : index
affine.for %i = 1 to 10 {
affine.if affine_set<(i)[N] : (i - 2 >= 0, 4 - i >= 0)>(%i)[%c] {
%w = affine.apply affine_map<(d0,d1)[s0] -> (d0+d1+s0)> (%i, %i) [%N]
}
}
return
}
// CHECK-LABEL: func @inline_with_affine_ops
func.func @inline_with_affine_ops() {
%c = arith.constant 1 : index
// CHECK: affine.for
// CHECK-NEXT: affine.if
// CHECK-NEXT: affine.apply
// CHECK-NOT: call
call @func_with_affine_ops(%c) : (index) -> ()
return
}
// CHECK-LABEL: func @not_inline_in_affine_op
func.func @not_inline_in_affine_op() {
%c = arith.constant 1 : index
// CHECK-NOT: affine.if
// CHECK: call
affine.for %i = 1 to 10 {
func.call @func_with_affine_ops(%c) : (index) -> ()
}
return
}
// -----
// Test when an invalid operation is nested in an affine op.
func.func @func_with_invalid_nested_op() {
affine.for %i = 1 to 10 {
"foo.opaque"() : () -> ()
}
return
}
// CHECK-LABEL: func @not_inline_invalid_nest_op
func.func @not_inline_invalid_nest_op() {
// CHECK: call @func_with_invalid_nested_op
call @func_with_invalid_nested_op() : () -> ()
return
}
// -----
// Test that calls are inlined into affine structures.
func.func @func_noop() {
return
}
// CHECK-LABEL: func @inline_into_affine_ops
func.func @inline_into_affine_ops() {
// CHECK-NOT: call @func_noop
affine.for %i = 1 to 10 {
func.call @func_noop() : () -> ()
}
return
}
// -----
// Test that calls with dimension arguments are properly inlined.
func.func @func_dim(%arg0: index, %arg1: memref<?xf32>) {
affine.load %arg1[%arg0] : memref<?xf32>
return
}
// CHECK-LABEL: @inline_dimension
// CHECK: (%[[ARG0:.*]]: memref<?xf32>)
func.func @inline_dimension(%arg0: memref<?xf32>) {
// CHECK: affine.for %[[IV:.*]] =
affine.for %i = 1 to 42 {
// CHECK-NOT: call @func_dim
// CHECK: affine.load %[[ARG0]][%[[IV]]]
func.call @func_dim(%i, %arg0) : (index, memref<?xf32>) -> ()
}
return
}
// -----
// Test that calls with vector operations are also inlined.
func.func @func_vector_dim(%arg0: index, %arg1: memref<32xf32>) {
affine.vector_load %arg1[%arg0] : memref<32xf32>, vector<4xf32>
return
}
// CHECK-LABEL: @inline_dimension_vector
// CHECK: (%[[ARG0:.*]]: memref<32xf32>)
func.func @inline_dimension_vector(%arg0: memref<32xf32>) {
// CHECK: affine.for %[[IV:.*]] =
affine.for %i = 1 to 42 {
// CHECK-NOT: call @func_dim
// CHECK: affine.vector_load %[[ARG0]][%[[IV]]]
func.call @func_vector_dim(%i, %arg0) : (index, memref<32xf32>) -> ()
}
return
}
// -----
// Test that calls that would result in violation of affine value
// categorization (top-level value stop being top-level) are not inlined.
func.func private @get_index() -> index
func.func @func_top_level(%arg0: memref<?xf32>) {
%0 = call @get_index() : () -> index
affine.load %arg0[%0] : memref<?xf32>
return
}
// CHECK-LABEL: @no_inline_not_top_level
func.func @no_inline_not_top_level(%arg0: memref<?xf32>) {
affine.for %i = 1 to 42 {
// CHECK: call @func_top_level
func.call @func_top_level(%arg0) : (memref<?xf32>) -> ()
}
return
}
|
