Skip to content

Commit dc693a0

Browse files
georgemitenkovgeorgemitenkov
committed
[MLIR][SPIRVToLLVM] Removed std to llvm patterns from the conversion
Removed the Standard to LLVM conversion patterns that were previously pulled in for testing purposes. This helps to separate the conversion to LLVM dialect of the MLIR module with both SPIR-V and Standard dialects in it (particularly helpful for SPIR-V cpu runner). Also, tests were changed accordingly. Reviewed By: mravishankar Differential Revision: https://reviews.llvm.org/D86285
1 parent 2b0f40b commit dc693a0

13 files changed

+383
-388
lines changed

‎mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVMPass.cpp

Lines changed: 0 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -41,11 +41,6 @@ void ConvertSPIRVToLLVMPass::runOnOperation() {
4141
populateSPIRVToLLVMConversionPatterns(context, converter, patterns);
4242
populateSPIRVToLLVMFunctionConversionPatterns(context, converter, patterns);
4343

44-
// Currently pulls in Std to LLVM conversion patterns
45-
// that help with testing. This allows to convert
46-
// function arguments to LLVM.
47-
populateStdToLLVMConversionPatterns(converter, patterns);
48-
4944
ConversionTarget target(getContext());
5045
target.addIllegalDialect<spirv::SPIRVDialect>();
5146
target.addLegalDialect<LLVM::LLVMDialect>();

‎mlir/test/Conversion/SPIRVToLLVM/arithmetic-ops-to-llvm.mlir

Lines changed: 52 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -5,231 +5,231 @@
55
//===----------------------------------------------------------------------===//
66

77
// CHECK-LABEL: @iadd_scalar
8-
func @iadd_scalar(%arg0: i32, %arg1: i32) {
8+
spv.func @iadd_scalar(%arg0: i32, %arg1: i32) "None" {
99
// CHECK: llvm.add %{{.*}}, %{{.*}} : !llvm.i32
1010
%0 = spv.IAdd %arg0, %arg1 : i32
11-
return
11+
spv.Return
1212
}
1313

1414
// CHECK-LABEL: @iadd_vector
15-
func @iadd_vector(%arg0: vector<4xi64>, %arg1: vector<4xi64>) {
15+
spv.func @iadd_vector(%arg0: vector<4xi64>, %arg1: vector<4xi64>) "None" {
1616
// CHECK: llvm.add %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
1717
%0 = spv.IAdd %arg0, %arg1 : vector<4xi64>
18-
return
18+
spv.Return
1919
}
2020

2121
//===----------------------------------------------------------------------===//
2222
// spv.ISub
2323
//===----------------------------------------------------------------------===//
2424

2525
// CHECK-LABEL: @isub_scalar
26-
func @isub_scalar(%arg0: i8, %arg1: i8) {
26+
spv.func @isub_scalar(%arg0: i8, %arg1: i8) "None" {
2727
// CHECK: llvm.sub %{{.*}}, %{{.*}} : !llvm.i8
2828
%0 = spv.ISub %arg0, %arg1 : i8
29-
return
29+
spv.Return
3030
}
3131

3232
// CHECK-LABEL: @isub_vector
33-
func @isub_vector(%arg0: vector<2xi16>, %arg1: vector<2xi16>) {
33+
spv.func @isub_vector(%arg0: vector<2xi16>, %arg1: vector<2xi16>) "None" {
3434
// CHECK: llvm.sub %{{.*}}, %{{.*}} : !llvm.vec<2 x i16>
3535
%0 = spv.ISub %arg0, %arg1 : vector<2xi16>
36-
return
36+
spv.Return
3737
}
3838

3939
//===----------------------------------------------------------------------===//
4040
// spv.IMul
4141
//===----------------------------------------------------------------------===//
4242

4343
// CHECK-LABEL: @imul_scalar
44-
func @imul_scalar(%arg0: i32, %arg1: i32) {
44+
spv.func @imul_scalar(%arg0: i32, %arg1: i32) "None" {
4545
// CHECK: llvm.mul %{{.*}}, %{{.*}} : !llvm.i32
4646
%0 = spv.IMul %arg0, %arg1 : i32
47-
return
47+
spv.Return
4848
}
4949

5050
// CHECK-LABEL: @imul_vector
51-
func @imul_vector(%arg0: vector<3xi32>, %arg1: vector<3xi32>) {
51+
spv.func @imul_vector(%arg0: vector<3xi32>, %arg1: vector<3xi32>) "None" {
5252
// CHECK: llvm.mul %{{.*}}, %{{.*}} : !llvm.vec<3 x i32>
5353
%0 = spv.IMul %arg0, %arg1 : vector<3xi32>
54-
return
54+
spv.Return
5555
}
5656

5757
//===----------------------------------------------------------------------===//
5858
// spv.FAdd
5959
//===----------------------------------------------------------------------===//
6060

6161
// CHECK-LABEL: @fadd_scalar
62-
func @fadd_scalar(%arg0: f16, %arg1: f16) {
62+
spv.func @fadd_scalar(%arg0: f16, %arg1: f16) "None" {
6363
// CHECK: llvm.fadd %{{.*}}, %{{.*}} : !llvm.half
6464
%0 = spv.FAdd %arg0, %arg1 : f16
65-
return
65+
spv.Return
6666
}
6767

6868
// CHECK-LABEL: @fadd_vector
69-
func @fadd_vector(%arg0: vector<4xf32>, %arg1: vector<4xf32>) {
69+
spv.func @fadd_vector(%arg0: vector<4xf32>, %arg1: vector<4xf32>) "None" {
7070
// CHECK: llvm.fadd %{{.*}}, %{{.*}} : !llvm.vec<4 x float>
7171
%0 = spv.FAdd %arg0, %arg1 : vector<4xf32>
72-
return
72+
spv.Return
7373
}
7474

7575
//===----------------------------------------------------------------------===//
7676
// spv.FSub
7777
//===----------------------------------------------------------------------===//
7878

7979
// CHECK-LABEL: @fsub_scalar
80-
func @fsub_scalar(%arg0: f32, %arg1: f32) {
80+
spv.func @fsub_scalar(%arg0: f32, %arg1: f32) "None" {
8181
// CHECK: llvm.fsub %{{.*}}, %{{.*}} : !llvm.float
8282
%0 = spv.FSub %arg0, %arg1 : f32
83-
return
83+
spv.Return
8484
}
8585

8686
// CHECK-LABEL: @fsub_vector
87-
func @fsub_vector(%arg0: vector<2xf32>, %arg1: vector<2xf32>) {
87+
spv.func @fsub_vector(%arg0: vector<2xf32>, %arg1: vector<2xf32>) "None" {
8888
// CHECK: llvm.fsub %{{.*}}, %{{.*}} : !llvm.vec<2 x float>
8989
%0 = spv.FSub %arg0, %arg1 : vector<2xf32>
90-
return
90+
spv.Return
9191
}
9292

9393
//===----------------------------------------------------------------------===//
9494
// spv.FDiv
9595
//===----------------------------------------------------------------------===//
9696

9797
// CHECK-LABEL: @fdiv_scalar
98-
func @fdiv_scalar(%arg0: f32, %arg1: f32) {
98+
spv.func @fdiv_scalar(%arg0: f32, %arg1: f32) "None" {
9999
// CHECK: llvm.fdiv %{{.*}}, %{{.*}} : !llvm.float
100100
%0 = spv.FDiv %arg0, %arg1 : f32
101-
return
101+
spv.Return
102102
}
103103

104104
// CHECK-LABEL: @fdiv_vector
105-
func @fdiv_vector(%arg0: vector<3xf64>, %arg1: vector<3xf64>) {
105+
spv.func @fdiv_vector(%arg0: vector<3xf64>, %arg1: vector<3xf64>) "None" {
106106
// CHECK: llvm.fdiv %{{.*}}, %{{.*}} : !llvm.vec<3 x double>
107107
%0 = spv.FDiv %arg0, %arg1 : vector<3xf64>
108-
return
108+
spv.Return
109109
}
110110

111111
//===----------------------------------------------------------------------===//
112112
// spv.FMul
113113
//===----------------------------------------------------------------------===//
114114

115115
// CHECK-LABEL: @fmul_scalar
116-
func @fmul_scalar(%arg0: f32, %arg1: f32) {
116+
spv.func @fmul_scalar(%arg0: f32, %arg1: f32) "None" {
117117
// CHECK: llvm.fmul %{{.*}}, %{{.*}} : !llvm.float
118118
%0 = spv.FMul %arg0, %arg1 : f32
119-
return
119+
spv.Return
120120
}
121121

122122
// CHECK-LABEL: @fmul_vector
123-
func @fmul_vector(%arg0: vector<2xf32>, %arg1: vector<2xf32>) {
123+
spv.func @fmul_vector(%arg0: vector<2xf32>, %arg1: vector<2xf32>) "None" {
124124
// CHECK: llvm.fmul %{{.*}}, %{{.*}} : !llvm.vec<2 x float>
125125
%0 = spv.FMul %arg0, %arg1 : vector<2xf32>
126-
return
126+
spv.Return
127127
}
128128

129129
//===----------------------------------------------------------------------===//
130130
// spv.FRem
131131
//===----------------------------------------------------------------------===//
132132

133133
// CHECK-LABEL: @frem_scalar
134-
func @frem_scalar(%arg0: f32, %arg1: f32) {
134+
spv.func @frem_scalar(%arg0: f32, %arg1: f32) "None" {
135135
// CHECK: llvm.frem %{{.*}}, %{{.*}} : !llvm.float
136136
%0 = spv.FRem %arg0, %arg1 : f32
137-
return
137+
spv.Return
138138
}
139139

140140
// CHECK-LABEL: @frem_vector
141-
func @frem_vector(%arg0: vector<3xf64>, %arg1: vector<3xf64>) {
141+
spv.func @frem_vector(%arg0: vector<3xf64>, %arg1: vector<3xf64>) "None" {
142142
// CHECK: llvm.frem %{{.*}}, %{{.*}} : !llvm.vec<3 x double>
143143
%0 = spv.FRem %arg0, %arg1 : vector<3xf64>
144-
return
144+
spv.Return
145145
}
146146

147147
//===----------------------------------------------------------------------===//
148148
// spv.FNegate
149149
//===----------------------------------------------------------------------===//
150150

151151
// CHECK-LABEL: @fneg_scalar
152-
func @fneg_scalar(%arg: f64) {
152+
spv.func @fneg_scalar(%arg: f64) "None" {
153153
// CHECK: llvm.fneg %{{.*}} : !llvm.double
154154
%0 = spv.FNegate %arg : f64
155-
return
155+
spv.Return
156156
}
157157

158158
// CHECK-LABEL: @fneg_vector
159-
func @fneg_vector(%arg: vector<2xf32>) {
159+
spv.func @fneg_vector(%arg: vector<2xf32>) "None" {
160160
// CHECK: llvm.fneg %{{.*}} : !llvm.vec<2 x float>
161161
%0 = spv.FNegate %arg : vector<2xf32>
162-
return
162+
spv.Return
163163
}
164164

165165
//===----------------------------------------------------------------------===//
166166
// spv.UDiv
167167
//===----------------------------------------------------------------------===//
168168

169169
// CHECK-LABEL: @udiv_scalar
170-
func @udiv_scalar(%arg0: i32, %arg1: i32) {
170+
spv.func @udiv_scalar(%arg0: i32, %arg1: i32) "None" {
171171
// CHECK: llvm.udiv %{{.*}}, %{{.*}} : !llvm.i32
172172
%0 = spv.UDiv %arg0, %arg1 : i32
173-
return
173+
spv.Return
174174
}
175175

176176
// CHECK-LABEL: @udiv_vector
177-
func @udiv_vector(%arg0: vector<3xi64>, %arg1: vector<3xi64>) {
177+
spv.func @udiv_vector(%arg0: vector<3xi64>, %arg1: vector<3xi64>) "None" {
178178
// CHECK: llvm.udiv %{{.*}}, %{{.*}} : !llvm.vec<3 x i64>
179179
%0 = spv.UDiv %arg0, %arg1 : vector<3xi64>
180-
return
180+
spv.Return
181181
}
182182

183183
//===----------------------------------------------------------------------===//
184184
// spv.UMod
185185
//===----------------------------------------------------------------------===//
186186

187187
// CHECK-LABEL: @umod_scalar
188-
func @umod_scalar(%arg0: i32, %arg1: i32) {
188+
spv.func @umod_scalar(%arg0: i32, %arg1: i32) "None" {
189189
// CHECK: llvm.urem %{{.*}}, %{{.*}} : !llvm.i32
190190
%0 = spv.UMod %arg0, %arg1 : i32
191-
return
191+
spv.Return
192192
}
193193

194194
// CHECK-LABEL: @umod_vector
195-
func @umod_vector(%arg0: vector<3xi64>, %arg1: vector<3xi64>) {
195+
spv.func @umod_vector(%arg0: vector<3xi64>, %arg1: vector<3xi64>) "None" {
196196
// CHECK: llvm.urem %{{.*}}, %{{.*}} : !llvm.vec<3 x i64>
197197
%0 = spv.UMod %arg0, %arg1 : vector<3xi64>
198-
return
198+
spv.Return
199199
}
200200

201201
//===----------------------------------------------------------------------===//
202202
// spv.SDiv
203203
//===----------------------------------------------------------------------===//
204204

205205
// CHECK-LABEL: @sdiv_scalar
206-
func @sdiv_scalar(%arg0: i16, %arg1: i16) {
206+
spv.func @sdiv_scalar(%arg0: i16, %arg1: i16) "None" {
207207
// CHECK: llvm.sdiv %{{.*}}, %{{.*}} : !llvm.i16
208208
%0 = spv.SDiv %arg0, %arg1 : i16
209-
return
209+
spv.Return
210210
}
211211

212212
// CHECK-LABEL: @sdiv_vector
213-
func @sdiv_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) {
213+
spv.func @sdiv_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
214214
// CHECK: llvm.sdiv %{{.*}}, %{{.*}} : !llvm.vec<2 x i64>
215215
%0 = spv.SDiv %arg0, %arg1 : vector<2xi64>
216-
return
216+
spv.Return
217217
}
218218

219219
//===----------------------------------------------------------------------===//
220220
// spv.SRem
221221
//===----------------------------------------------------------------------===//
222222

223223
// CHECK-LABEL: @srem_scalar
224-
func @srem_scalar(%arg0: i32, %arg1: i32) {
224+
spv.func @srem_scalar(%arg0: i32, %arg1: i32) "None" {
225225
// CHECK: llvm.srem %{{.*}}, %{{.*}} : !llvm.i32
226226
%0 = spv.SRem %arg0, %arg1 : i32
227-
return
227+
spv.Return
228228
}
229229

230230
// CHECK-LABEL: @srem_vector
231-
func @srem_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) {
231+
spv.func @srem_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" {
232232
// CHECK: llvm.srem %{{.*}}, %{{.*}} : !llvm.vec<4 x i32>
233233
%0 = spv.SRem %arg0, %arg1 : vector<4xi32>
234-
return
234+
spv.Return
235235
}

0 commit comments

Comments
 (0)