Skip to content

Commit

Permalink
Browse files Browse the repository at this point in the history
[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
  • Loading branch information
georgemitenkov committed Aug 20, 2020
1 parent 2b0f40b commit dc693a0
Show file tree
Hide file tree
Showing 13 changed files with 383 additions and 388 deletions.
5 changes: 0 additions & 5 deletions mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVMPass.cpp
Expand Up @@ -41,11 +41,6 @@ void ConvertSPIRVToLLVMPass::runOnOperation() {
populateSPIRVToLLVMConversionPatterns(context, converter, patterns);
populateSPIRVToLLVMFunctionConversionPatterns(context, converter, patterns);

// Currently pulls in Std to LLVM conversion patterns
// that help with testing. This allows to convert
// function arguments to LLVM.
populateStdToLLVMConversionPatterns(converter, patterns);

ConversionTarget target(getContext());
target.addIllegalDialect<spirv::SPIRVDialect>();
target.addLegalDialect<LLVM::LLVMDialect>();
Expand Down
104 changes: 52 additions & 52 deletions mlir/test/Conversion/SPIRVToLLVM/arithmetic-ops-to-llvm.mlir
Expand Up @@ -5,231 +5,231 @@
//===----------------------------------------------------------------------===//

// CHECK-LABEL: @iadd_scalar
func @iadd_scalar(%arg0: i32, %arg1: i32) {
spv.func @iadd_scalar(%arg0: i32, %arg1: i32) "None" {
// CHECK: llvm.add %{{.*}}, %{{.*}} : !llvm.i32
%0 = spv.IAdd %arg0, %arg1 : i32
return
spv.Return
}

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

//===----------------------------------------------------------------------===//
// spv.ISub
//===----------------------------------------------------------------------===//

// CHECK-LABEL: @isub_scalar
func @isub_scalar(%arg0: i8, %arg1: i8) {
spv.func @isub_scalar(%arg0: i8, %arg1: i8) "None" {
// CHECK: llvm.sub %{{.*}}, %{{.*}} : !llvm.i8
%0 = spv.ISub %arg0, %arg1 : i8
return
spv.Return
}

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

//===----------------------------------------------------------------------===//
// spv.IMul
//===----------------------------------------------------------------------===//

// CHECK-LABEL: @imul_scalar
func @imul_scalar(%arg0: i32, %arg1: i32) {
spv.func @imul_scalar(%arg0: i32, %arg1: i32) "None" {
// CHECK: llvm.mul %{{.*}}, %{{.*}} : !llvm.i32
%0 = spv.IMul %arg0, %arg1 : i32
return
spv.Return
}

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

//===----------------------------------------------------------------------===//
// spv.FAdd
//===----------------------------------------------------------------------===//

// CHECK-LABEL: @fadd_scalar
func @fadd_scalar(%arg0: f16, %arg1: f16) {
spv.func @fadd_scalar(%arg0: f16, %arg1: f16) "None" {
// CHECK: llvm.fadd %{{.*}}, %{{.*}} : !llvm.half
%0 = spv.FAdd %arg0, %arg1 : f16
return
spv.Return
}

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

//===----------------------------------------------------------------------===//
// spv.FSub
//===----------------------------------------------------------------------===//

// CHECK-LABEL: @fsub_scalar
func @fsub_scalar(%arg0: f32, %arg1: f32) {
spv.func @fsub_scalar(%arg0: f32, %arg1: f32) "None" {
// CHECK: llvm.fsub %{{.*}}, %{{.*}} : !llvm.float
%0 = spv.FSub %arg0, %arg1 : f32
return
spv.Return
}

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

//===----------------------------------------------------------------------===//
// spv.FDiv
//===----------------------------------------------------------------------===//

// CHECK-LABEL: @fdiv_scalar
func @fdiv_scalar(%arg0: f32, %arg1: f32) {
spv.func @fdiv_scalar(%arg0: f32, %arg1: f32) "None" {
// CHECK: llvm.fdiv %{{.*}}, %{{.*}} : !llvm.float
%0 = spv.FDiv %arg0, %arg1 : f32
return
spv.Return
}

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

//===----------------------------------------------------------------------===//
// spv.FMul
//===----------------------------------------------------------------------===//

// CHECK-LABEL: @fmul_scalar
func @fmul_scalar(%arg0: f32, %arg1: f32) {
spv.func @fmul_scalar(%arg0: f32, %arg1: f32) "None" {
// CHECK: llvm.fmul %{{.*}}, %{{.*}} : !llvm.float
%0 = spv.FMul %arg0, %arg1 : f32
return
spv.Return
}

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

//===----------------------------------------------------------------------===//
// spv.FRem
//===----------------------------------------------------------------------===//

// CHECK-LABEL: @frem_scalar
func @frem_scalar(%arg0: f32, %arg1: f32) {
spv.func @frem_scalar(%arg0: f32, %arg1: f32) "None" {
// CHECK: llvm.frem %{{.*}}, %{{.*}} : !llvm.float
%0 = spv.FRem %arg0, %arg1 : f32
return
spv.Return
}

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

//===----------------------------------------------------------------------===//
// spv.FNegate
//===----------------------------------------------------------------------===//

// CHECK-LABEL: @fneg_scalar
func @fneg_scalar(%arg: f64) {
spv.func @fneg_scalar(%arg: f64) "None" {
// CHECK: llvm.fneg %{{.*}} : !llvm.double
%0 = spv.FNegate %arg : f64
return
spv.Return
}

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

//===----------------------------------------------------------------------===//
// spv.UDiv
//===----------------------------------------------------------------------===//

// CHECK-LABEL: @udiv_scalar
func @udiv_scalar(%arg0: i32, %arg1: i32) {
spv.func @udiv_scalar(%arg0: i32, %arg1: i32) "None" {
// CHECK: llvm.udiv %{{.*}}, %{{.*}} : !llvm.i32
%0 = spv.UDiv %arg0, %arg1 : i32
return
spv.Return
}

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

//===----------------------------------------------------------------------===//
// spv.UMod
//===----------------------------------------------------------------------===//

// CHECK-LABEL: @umod_scalar
func @umod_scalar(%arg0: i32, %arg1: i32) {
spv.func @umod_scalar(%arg0: i32, %arg1: i32) "None" {
// CHECK: llvm.urem %{{.*}}, %{{.*}} : !llvm.i32
%0 = spv.UMod %arg0, %arg1 : i32
return
spv.Return
}

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

//===----------------------------------------------------------------------===//
// spv.SDiv
//===----------------------------------------------------------------------===//

// CHECK-LABEL: @sdiv_scalar
func @sdiv_scalar(%arg0: i16, %arg1: i16) {
spv.func @sdiv_scalar(%arg0: i16, %arg1: i16) "None" {
// CHECK: llvm.sdiv %{{.*}}, %{{.*}} : !llvm.i16
%0 = spv.SDiv %arg0, %arg1 : i16
return
spv.Return
}

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

//===----------------------------------------------------------------------===//
// spv.SRem
//===----------------------------------------------------------------------===//

// CHECK-LABEL: @srem_scalar
func @srem_scalar(%arg0: i32, %arg1: i32) {
spv.func @srem_scalar(%arg0: i32, %arg1: i32) "None" {
// CHECK: llvm.srem %{{.*}}, %{{.*}} : !llvm.i32
%0 = spv.SRem %arg0, %arg1 : i32
return
spv.Return
}

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

0 comments on commit dc693a0

Please sign in to comment.